rwops: Renamed SDL_RWops to SDL_IOStream, and other related symbols.

build-scripts/SDL_migration.cocci

@@ -1804,15 +1804,15 @@ expression e2;
 @@
 @@
 - RW_SEEK_CUR
-+ SDL_RW_SEEK_CUR
++ SDL_IO_SEEK_CUR
 @@
 @@
 - RW_SEEK_END
-+ SDL_RW_SEEK_END
++ SDL_IO_SEEK_END
 @@
 @@
 - RW_SEEK_SET
-+ SDL_RW_SEEK_SET
++ SDL_IO_SEEK_SET
 @@
 @@
 - SDL_SensorClose
@@ -3051,30 +3051,65 @@ typedef SDL_version, SDL_Version;
 @@
 @@
 - SDL_RWclose
-+ SDL_CloseRW
++ SDL_CloseIO
   (...)
 @@
 @@
 - SDL_RWread
-+ SDL_ReadRW
++ SDL_ReadIO
   (...)
 @@
 @@
 - SDL_RWwrite
-+ SDL_WriteRW
++ SDL_WriteIO
   (...)
 @@
 @@
 - SDL_RWtell
-+ SDL_TellRW
++ SDL_TellIO
   (...)
 @@
 @@
 - SDL_RWsize
-+ SDL_SizeRW
++ SDL_SizeIO
   (...)
 @@
 @@
 - SDL_RWseek
-+ SDL_SeekRW
++ SDL_SeekIO
   (...)
+@@
+@@
+- SDL_LoadBMP_RW
++ SDL_LoadBMP_IO
+  (...)
+@@
+@@
+- SDL_LoadWAV_RW
++ SDL_LoadWAV_IO
+  (...)
+@@
+@@
+- SDL_SaveBMP_RW
++ SDL_SaveBMP_IO
+  (...)
+@@
+@@
+- SDL_RWFromFile
++ SDL_IOFromFile
+  (...)
+@@
+@@
+- SDL_RWFromMem
++ SDL_IOFromMem
+  (...)
+@@
+@@
+- SDL_RWFromConstMem
++ SDL_IOFromConstMem
+  (...)
+@@
+typedef SDL_RWops, SDL_IOStream;
+@@
+- SDL_RWops
++ SDL_IOStream

docs/README-emscripten.md

@@ -301,7 +301,7 @@ Your game probably has data files. Here's how to access them.
 Filesystem access works like a Unix filesystem; you have a single directory
 tree, possibly interpolated from several mounted locations, no drive letters,
 '/' for a path separator. You can access them with standard file APIs like
-open() or fopen() or SDL_RWops. You can read or write from the filesystem.
+open() or fopen() or SDL_IOStream. You can read or write from the filesystem.
 
 By default, you probably have a "MEMFS" filesystem (all files are stored in
 memory, but access to them is immediate and doesn't need to block). There are

docs/README-migration.md

@@ -191,7 +191,7 @@ SDL_FreeWAV has been removed and calls can be replaced with SDL_free.
 
 SDL_LoadWAV() is a proper function now and no longer a macro (but offers the same functionality otherwise).
 
-SDL_LoadWAV_RW() and SDL_LoadWAV() return an int now: zero on success, -1 on error, like most of SDL. They no longer return a pointer to an SDL_AudioSpec.
+SDL_LoadWAV_IO() and SDL_LoadWAV() return an int now: zero on success, -1 on error, like most of SDL. They no longer return a pointer to an SDL_AudioSpec.
 
 SDL_AudioCVT interface has been removed, the SDL_AudioStream interface (for audio supplied in pieces) or the new SDL_ConvertAudioSamples() function (for converting a complete audio buffer in one call) can be used instead.
 
@@ -253,6 +253,7 @@ The following functions have been renamed:
 * SDL_AudioStreamGet() => SDL_GetAudioStreamData()
 * SDL_AudioStreamPut() => SDL_PutAudioStreamData()
 * SDL_FreeAudioStream() => SDL_DestroyAudioStream()
+* SDL_LoadWAV_RW() => SDL_LoadWAV_IO()
 * SDL_NewAudioStream() => SDL_CreateAudioStream()
 
 
@@ -1152,80 +1153,79 @@ The following symbols have been renamed:
 ## SDL_rwops.h
 
 The following symbols have been renamed:
-* RW_SEEK_CUR => SDL_RW_SEEK_CUR
-* RW_SEEK_END => SDL_RW_SEEK_END
-* RW_SEEK_SET => SDL_RW_SEEK_SET
+* RW_SEEK_CUR => SDL_IO_SEEK_CUR
+* RW_SEEK_END => SDL_IO_SEEK_END
+* RW_SEEK_SET => SDL_IO_SEEK_SET
 
-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_OpenRW and provide the function pointers through there. To call into a RWops's functionality, use the standard APIs (SDL_ReadRW, etc) instead of calling into function pointers directly.
+SDL_RWops is now an opaque structure, and has been renamed to SDL_IOStream. The SDL3 APIs to create an SDL_IOStream (SDL_IOFromFile, etc) are renamed but otherwise still function as they did in SDL2. However, to make a custom SDL_IOStream with app-provided function pointers, call SDL_OpenIO and provide the function pointers through there. To call into an SDL_IOStream's functionality, use the standard APIs (SDL_ReadIO, etc), as the function pointers are concealed.
 
-The RWops function pointers are now in a separate structure called SDL_RWopsInteface, which is provided to SDL_OpenRW. 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.
+The RWops function pointers are now in a separate structure called SDL_IOStreamInterface, which is provided to SDL_OpenIO when creating a custom SDL_IOStream implementation. All the functions now take a `void *` userdata argument for their first parameter instead of an SDL_IOStream, since that's now an opaque structure.
 
-SDL_RWread and SDL_RWwrite (and the read and write function pointers) have a different function signature in SDL3 in addition to being renamed.
+SDL_RWread and SDL_RWwrite (and the read and write function pointers) have a different function signature in SDL3, in addition to being renamed.
 
 Previously they looked more like stdio:
 
 ```c
-size_t SDL_RWread(SDL_RWops *context, void *ptr, size_t size, size_t maxnum);
-size_t SDL_RWwrite(SDL_RWops *context, const void *ptr, size_t size, size_t maxnum);
+size_t SDL_RWread(SDL_IOStream *context, void *ptr, size_t size, size_t maxnum);
+size_t SDL_RWwrite(SDL_IOStream *context, const void *ptr, size_t size, size_t maxnum);
 ```
 
 But now they look more like POSIX:
 
 ```c
-size_t SDL_ReadRW(void *userdata, void *ptr, size_t size);
-size_t SDL_WriteRW(void *userdata, const void *ptr, size_t size);
+size_t SDL_ReadIO(void *userdata, void *ptr, size_t size);
+size_t SDL_WriteIO(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)
+size_t custom_read(void *ptr, size_t size, size_t nitems, SDL_IOStream *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)
+size_t custom_read(void *ptr, size_t size, size_t nitems, SDL_IOStream *stream, SDL_IOStatus *status)
 {
     if (size > 0 && nitems > 0) {
-        return SDL_ReadRW(stream, ptr, size * nitems) / size;
+        return SDL_ReadIO(stream, ptr, size * nitems) / size;
     }
     return 0;
 }
 ```
 
-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_IOStream::type was removed; it wasn't meaningful for app-provided implementations at all, and wasn't much use for SDL's internal implementations, either. If you _have_ to identify the type, you can examine the SDL_IOStream's properties to detect built-in implementations.
 
-SDL_RWopsInterface::close implementations should clean up their own userdata, but not call SDL_CloseRW on themselves; now the contract is always that SDL_CloseRW is called, which calls `->close` and then frees the opaque object.
+SDL_IOStreamInterface::close implementations should clean up their own userdata, but not call SDL_CloseIO on themselves; now the contract is always that SDL_CloseIO is called, which calls `->close` before freeing 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_CloseRW() 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_OpenRW() and SDL_CloseRW().
+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_OpenIO() and SDL_CloseIO().
 
+SDL_RWFromFP has been removed from the API, due to issues when the SDL library uses a different C runtime from the application.
 
 You can implement this in your own code easily:
 ```c
 #include <stdio.h>
 
-typedef struct RWopsStdioFPData
+typedef struct IOStreamStdioFPData
 {
     FILE *fp;
     SDL_bool autoclose;
-} RWopsStdioFPData;
+} IOStreamStdioFPData;
 
 static Sint64 SDLCALL stdio_seek(void *userdata, Sint64 offset, int whence)
 {
-    FILE *fp = ((RWopsStdioFPData *) userdata)->fp;
+    FILE *fp = ((IOStreamStdioFPData *) userdata)->fp;
     int stdiowhence;
 
     switch (whence) {
-    case SDL_RW_SEEK_SET:
+    case SDL_IO_SEEK_SET:
         stdiowhence = SEEK_SET;
         break;
-    case SDL_RW_SEEK_CUR:
+    case SDL_IO_SEEK_CUR:
         stdiowhence = SEEK_CUR;
         break;
-    case SDL_RW_SEEK_END:
+    case SDL_IO_SEEK_END:
         stdiowhence = SEEK_END;
         break;
     default:
@@ -1242,9 +1242,9 @@ static Sint64 SDLCALL stdio_seek(void *userdata, Sint64 offset, int whence)
     return SDL_Error(SDL_EFSEEK);
 }
 
-static size_t SDLCALL stdio_read(void *userdata, void *ptr, size_t size)
+static size_t SDLCALL stdio_read(void *userdata, void *ptr, size_t size, SDL_IOStatus *status)
 {
-    FILE *fp = ((RWopsStdioFPData *) userdata)->fp;
+    FILE *fp = ((IOStreamStdioFPData *) userdata)->fp;
     const size_t bytes = fread(ptr, 1, size, fp);
     if (bytes == 0 && ferror(fp)) {
         SDL_Error(SDL_EFREAD);
@@ -1252,9 +1252,9 @@ static size_t SDLCALL stdio_read(void *userdata, void *ptr, size_t size)
     return bytes;
 }
 
-static size_t SDLCALL stdio_write(void *userdata, const void *ptr, size_t size)
+static size_t SDLCALL stdio_write(void *userdata, const void *ptr, size_t size, SDL_IOStatus *status)
 {
-    FILE *fp = ((RWopsStdioFPData *) userdata)->fp;
+    FILE *fp = ((IOStreamStdioFPData *) userdata)->fp;
     const size_t bytes = fwrite(ptr, 1, size, fp);
     if (bytes == 0 && ferror(fp)) {
         SDL_Error(SDL_EFWRITE);
@@ -1264,7 +1264,7 @@ static size_t SDLCALL stdio_write(void *userdata, const void *ptr, size_t size)
 
 static int SDLCALL stdio_close(void *userdata)
 {
-    RWopsStdioData *rwopsdata = (RWopsStdioData *) userdata;
+    IOStreamStdioData *rwopsdata = (IOStreamStdioData *) userdata;
     int status = 0;
     if (rwopsdata->autoclose) {
         if (fclose(rwopsdata->fp) != 0) {
@@ -1274,19 +1274,19 @@ static int SDLCALL stdio_close(void *userdata)
     return status;
 }
 
-SDL_RWops *SDL_RWFromFP(FILE *fp, SDL_bool autoclose)
+SDL_IOStream *SDL_RWFromFP(FILE *fp, SDL_bool autoclose)
 {
-    SDL_RWopsInterface iface;
-    RWopsStdioFPData *rwopsdata;
-    SDL_RWops *rwops;
+    SDL_IOStreamInterface iface;
+    IOStreamStdioFPData *rwopsdata;
+    SDL_IOStream *rwops;
 
-    rwopsdata = (RWopsStdioFPData *) SDL_malloc(sizeof (*rwopsdata));
+    rwopsdata = (IOStreamStdioFPData *) SDL_malloc(sizeof (*rwopsdata));
     if (!rwopsdata) {
         return NULL;
     }
 
     SDL_zero(iface);
-    /* There's no stdio_size because SDL_SizeRW emulates it the same way we'd do it for stdio anyhow. */
+    /* There's no stdio_size because SDL_SizeIO emulates it the same way we'd do it for stdio anyhow. */
     iface.seek = stdio_seek;
     iface.read = stdio_read;
     iface.write = stdio_write;
@@ -1295,7 +1295,7 @@ SDL_RWops *SDL_RWFromFP(FILE *fp, SDL_bool autoclose)
     rwopsdata->fp = fp;
     rwopsdata->autoclose = autoclose;
 
-    rwops = SDL_OpenRW(&iface, rwopsdata);
+    rwops = SDL_OpenIO(&iface, rwopsdata);
     if (!rwops) {
         iface.close(rwopsdata);
     }
@@ -1303,15 +1303,22 @@ SDL_RWops *SDL_RWFromFP(FILE *fp, SDL_bool autoclose)
 }
 ```
 
+The internal `FILE *` is available through a standard SDL_IOStream property, for streams made through SDL_IOFromFile() that use stdio behind the scenes; apps use this pointer at their own risk and should make sure that SDL and the app are using the same C runtime.
+
+
 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_RWclose() => SDL_CloseRW()
-* SDL_RWread() => SDL_ReadRW()
-* SDL_RWseek() => SDL_SeekRW()
-* SDL_RWsize() => SDL_SizeRW()
-* SDL_RWtell() => SDL_TellRW()
-* SDL_RWwrite() => SDL_WriteRW()
+* SDL_CloseRW() => SDL_CloseIO()
+* SDL_RWFromConstMem() => SDL_IOFromConstMem()
+* SDL_RWFromFile() => SDL_IOFromFile()
+* SDL_RWFromMem() => SDL_IOFromMem()
+* SDL_RWclose() => SDL_CloseIO()
+* SDL_RWread() => SDL_ReadIO()
+* SDL_RWseek() => SDL_SeekIO()
+* SDL_RWsize() => SDL_SizeIO()
+* SDL_RWtell() => SDL_TellIO()
+* SDL_RWwrite() => SDL_WriteIO()
 * SDL_ReadBE16() => SDL_ReadU16BE()
 * SDL_ReadBE32() => SDL_ReadU32BE()
 * SDL_ReadBE64() => SDL_ReadU64BE()
@@ -1325,6 +1332,10 @@ The following functions have been renamed:
 * SDL_WriteLE32() => SDL_WriteU32LE()
 * SDL_WriteLE64() => SDL_WriteU64LE()
 
+
+The following structures have been renamed:
+* SDL_RWops => SDL_IOStream
+
 ## SDL_sensor.h
 
 SDL_SensorID has changed from Sint32 to Uint32, with an invalid ID being 0.
@@ -1448,8 +1459,10 @@ The following functions have been renamed:
 * SDL_GetColorKey() => SDL_GetSurfaceColorKey()
 * SDL_HasColorKey() => SDL_SurfaceHasColorKey()
 * SDL_HasSurfaceRLE() => SDL_SurfaceHasRLE()
+* SDL_LoadBMP_RW() => SDL_LoadBMP_IO()
 * SDL_LowerBlit() => SDL_BlitSurfaceUnchecked()
 * SDL_LowerBlitScaled() => SDL_BlitSurfaceUncheckedScaled()
+* SDL_SaveBMP_RW() => SDL_SaveBMP_IO()
 * SDL_SetClipRect() => SDL_SetSurfaceClipRect()
 * SDL_SetColorKey() => SDL_SetSurfaceColorKey()
 * SDL_UpperBlit() => SDL_BlitSurface()

docs/README-winrt.md

@@ -42,7 +42,7 @@ Here is a rough list of what works, and what doesn't:
   * threads
   * timers (via SDL_GetTicks(), SDL_AddTimer(), SDL_GetPerformanceCounter(),
     SDL_GetPerformanceFrequency(), etc.)
-  * file I/O via SDL_RWops
+  * file I/O via SDL_IOStream
   * mouse input  (unsupported on Windows Phone)
   * audio, via SDL's WASAPI backend (if you want to record, your app must
     have "Microphone" capabilities enabled in its manifest, and the user must

include/SDL3/SDL_audio.h

@@ -1306,7 +1306,7 @@ extern DECLSPEC int SDLCALL SDL_SetAudioPostmixCallback(SDL_AudioDeviceID devid,
  * Example:
  *
  * ```c
- * SDL_LoadWAV_RW(SDL_RWFromFile("sample.wav", "rb"), 1, &spec, &buf, &len);
+ * SDL_LoadWAV_IO(SDL_IOFromFile("sample.wav", "rb"), 1, &spec, &buf, &len);
  * ```
  *
  * Note that the SDL_LoadWAV function does this same thing for you, but in a
@@ -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_CloseRW() on `src` before returning,
+ * \param freesrc If SDL_TRUE, calls SDL_CloseIO() 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
@@ -1344,7 +1344,7 @@ extern DECLSPEC int SDLCALL SDL_SetAudioPostmixCallback(SDL_AudioDeviceID devid,
  * \sa SDL_free
  * \sa SDL_LoadWAV
  */
-extern DECLSPEC int SDLCALL SDL_LoadWAV_RW(SDL_RWops * src, SDL_bool freesrc,
+extern DECLSPEC int SDLCALL SDL_LoadWAV_IO(SDL_IOStream * src, SDL_bool freesrc,
                                            SDL_AudioSpec * spec, Uint8 ** audio_buf,
                                            Uint32 * audio_len);
 
@@ -1354,7 +1354,7 @@ extern DECLSPEC int SDLCALL SDL_LoadWAV_RW(SDL_RWops * src, SDL_bool freesrc,
  * This is a convenience function that is effectively the same as:
  *
  * ```c
- * SDL_LoadWAV_RW(SDL_RWFromFile(path, "rb"), 1, spec, audio_buf, audio_len);
+ * SDL_LoadWAV_IO(SDL_IOFromFile(path, "rb"), 1, spec, audio_buf, audio_len);
  * ```
  *
  * Note that in SDL2, this was a preprocessor macro and not a real function.
@@ -1383,7 +1383,7 @@ extern DECLSPEC int SDLCALL SDL_LoadWAV_RW(SDL_RWops * src, SDL_bool freesrc,
  * \since This function is available since SDL 3.0.0.
  *
  * \sa SDL_free
- * \sa SDL_LoadWAV_RW
+ * \sa SDL_LoadWAV_IO
  */
 extern DECLSPEC int SDLCALL SDL_LoadWAV(const char *path, SDL_AudioSpec * spec,
                                         Uint8 ** audio_buf, Uint32 * audio_len);

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_CloseRW() on `src` before returning,
+ * \param freesrc if SDL_TRUE, calls SDL_CloseIO() 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.
@@ -279,7 +279,7 @@ extern DECLSPEC int SDLCALL SDL_AddGamepadMapping(const char *mapping);
  * \sa SDL_AddGamepadMappingsFromFile
  * \sa SDL_GetGamepadMappingForGUID
  */
-extern DECLSPEC int SDLCALL SDL_AddGamepadMappingsFromRW(SDL_RWops *src, SDL_bool freesrc);
+extern DECLSPEC int SDLCALL SDL_AddGamepadMappingsFromRW(SDL_IOStream *src, SDL_bool freesrc);
 
 /**
  * Load a set of gamepad mappings from a file.

include/SDL3/SDL_hints.h

@@ -2261,7 +2261,7 @@ extern "C" {
  *   "ignorezero"  - Like "truncate", but ignore fact chunk if the number of samples is zero.
  *   "ignore"      - Ignore fact chunk entirely. (default)
  *
- * This hint should be set before calling SDL_LoadWAV() or SDL_LoadWAV_RW()
+ * This hint should be set before calling SDL_LoadWAV() or SDL_LoadWAV_IO()
  */
 #define SDL_HINT_WAVE_FACT_CHUNK   "SDL_WAVE_FACT_CHUNK"
 
@@ -2278,7 +2278,7 @@ extern "C" {
  *   "ignore"       - Ignore the RIFF chunk size and always search up to 4 GiB.
  *   "maximum"      - Search for chunks until the end of file. (not recommended)
  *
- * This hint should be set before calling SDL_LoadWAV() or SDL_LoadWAV_RW()
+ * This hint should be set before calling SDL_LoadWAV() or SDL_LoadWAV_IO()
  */
 #define SDL_HINT_WAVE_RIFF_CHUNK_SIZE   "SDL_WAVE_RIFF_CHUNK_SIZE"
 
@@ -2293,7 +2293,7 @@ extern "C" {
  *   "dropframe"  - Decode until the first incomplete sample frame.
  *   "dropblock"  - Decode until the first incomplete block. (default)
  *
- * This hint should be set before calling SDL_LoadWAV() or SDL_LoadWAV_RW()
+ * This hint should be set before calling SDL_LoadWAV() or SDL_LoadWAV_IO()
  */
 #define SDL_HINT_WAVE_TRUNCATION   "SDL_WAVE_TRUNCATION"
 

include/SDL3/SDL_init.h

@@ -70,7 +70,7 @@ typedef enum
  * two may be used interchangeably. Though for readability of your code
  * SDL_InitSubSystem() might be preferred.
  *
- * The file I/O (for example: SDL_RWFromFile) and threading (SDL_CreateThread)
+ * The file I/O (for example: SDL_IOFromFile) and threading (SDL_CreateThread)
  * subsystems are initialized by default. Message boxes
  * (SDL_ShowSimpleMessageBox) also attempt to work without initializing the
  * video subsystem, in hopes of being useful in showing an error dialog when

include/SDL3/SDL_oldnames.h

@@ -69,6 +69,7 @@
 #define SDL_AudioStreamPut SDL_PutAudioStreamData
 #define SDL_FreeAudioStream SDL_DestroyAudioStream
 #define SDL_FreeWAV SDL_free
+#define SDL_LoadWAV_RW SDL_LoadWAV_IO
 #define SDL_NewAudioStream SDL_CreateAudioStream
 
 /* ##SDL_events.h */
@@ -449,15 +450,19 @@
 #define SDL_ScaleModeNearest SDL_SCALEMODE_NEAREST
 
 /* ##SDL_rwops.h */
-#define RW_SEEK_CUR SDL_RW_SEEK_CUR
-#define RW_SEEK_END SDL_RW_SEEK_END
-#define RW_SEEK_SET SDL_RW_SEEK_SET
-#define SDL_RWclose SDL_CloseRW
-#define SDL_RWread SDL_ReadRW
-#define SDL_RWseek SDL_SeekRW
-#define SDL_RWsize SDL_SizeRW
-#define SDL_RWtell SDL_TellRW
-#define SDL_RWwrite SDL_WriteRW
+#define RW_SEEK_CUR SDL_IO_SEEK_CUR
+#define RW_SEEK_END SDL_IO_SEEK_END
+#define RW_SEEK_SET SDL_IO_SEEK_SET
+#define SDL_RWFromConstMem SDL_IOFromConstMem
+#define SDL_RWFromFile SDL_IOFromFile
+#define SDL_RWFromMem SDL_IOFromMem
+#define SDL_RWclose SDL_CloseIO
+#define SDL_RWops SDL_IOStream
+#define SDL_RWread SDL_ReadIO
+#define SDL_RWseek SDL_SeekIO
+#define SDL_RWsize SDL_SizeIO
+#define SDL_RWtell SDL_TellIO
+#define SDL_RWwrite SDL_WriteIO
 #define SDL_ReadBE16 SDL_ReadU16BE
 #define SDL_ReadBE32 SDL_ReadU32BE
 #define SDL_ReadBE64 SDL_ReadU64BE
@@ -493,8 +498,10 @@
 #define SDL_GetColorKey SDL_GetSurfaceColorKey
 #define SDL_HasColorKey SDL_SurfaceHasColorKey
 #define SDL_HasSurfaceRLE SDL_SurfaceHasRLE
+#define SDL_LoadBMP_RW SDL_LoadBMP_IO
 #define SDL_LowerBlit SDL_BlitSurfaceUnchecked
 #define SDL_LowerBlitScaled SDL_BlitSurfaceUncheckedScaled
+#define SDL_SaveBMP_RW SDL_SaveBMP_IO
 #define SDL_SetClipRect SDL_SetSurfaceClipRect
 #define SDL_SetColorKey SDL_SetSurfaceColorKey
 #define SDL_UpperBlit SDL_BlitSurface
@@ -558,6 +565,7 @@
 #define SDL_AudioStreamPut SDL_AudioStreamPut_renamed_SDL_PutAudioStreamData
 #define SDL_FreeAudioStream SDL_FreeAudioStream_renamed_SDL_DestroyAudioStream
 #define SDL_FreeWAV SDL_FreeWAV_renamed_SDL_free
+#define SDL_LoadWAV_RW SDL_LoadWAV_RW_renamed_SDL_LoadWAV_IO
 #define SDL_NewAudioStream SDL_NewAudioStream_renamed_SDL_CreateAudioStream
 
 /* ##SDL_events.h */
@@ -939,15 +947,19 @@
 #define SDL_ScaleModeNearest SDL_ScaleModeNearest_renamed_SDL_SCALEMODE_NEAREST
 
 /* ##SDL_rwops.h */
-#define RW_SEEK_CUR RW_SEEK_CUR_renamed_SDL_RW_SEEK_CUR
-#define RW_SEEK_END RW_SEEK_END_renamed_SDL_RW_SEEK_END
-#define RW_SEEK_SET RW_SEEK_SET_renamed_SDL_RW_SEEK_SET
-#define SDL_RWclose SDL_RWclose_renamed_SDL_CloseRW
-#define SDL_RWread SDL_RWread_renamed_SDL_ReadRW
-#define SDL_RWseek SDL_RWseek_renamed_SDL_SeekRW
-#define SDL_RWsize SDL_RWsize_renamed_SDL_SizeRW
-#define SDL_RWtell SDL_RWtell_renamed_SDL_TellRW
-#define SDL_RWwrite SDL_RWwrite_renamed_SDL_WriteRW
+#define RW_SEEK_CUR RW_SEEK_CUR_renamed_SDL_IO_SEEK_CUR
+#define RW_SEEK_END RW_SEEK_END_renamed_SDL_IO_SEEK_END
+#define RW_SEEK_SET RW_SEEK_SET_renamed_SDL_IO_SEEK_SET
+#define SDL_RWFromConstMem SDL_RWFromConstMem_renamed_SDL_IOFromConstMem
+#define SDL_RWFromFile SDL_RWFromFile_renamed_SDL_IOFromFile
+#define SDL_RWFromMem SDL_RWFromMem_renamed_SDL_IOFromMem
+#define SDL_RWclose SDL_RWclose_renamed_SDL_CloseIO
+#define SDL_RWops SDL_RWops_renamed_SDL_IOStream
+#define SDL_RWread SDL_RWread_renamed_SDL_ReadIO
+#define SDL_RWseek SDL_RWseek_renamed_SDL_SeekIO
+#define SDL_RWsize SDL_RWsize_renamed_SDL_SizeIO
+#define SDL_RWtell SDL_RWtell_renamed_SDL_TellIO
+#define SDL_RWwrite SDL_RWwrite_renamed_SDL_WriteIO
 #define SDL_ReadBE16 SDL_ReadBE16_renamed_SDL_ReadU16BE
 #define SDL_ReadBE32 SDL_ReadBE32_renamed_SDL_ReadU32BE
 #define SDL_ReadBE64 SDL_ReadBE64_renamed_SDL_ReadU64BE
@@ -983,8 +995,10 @@
 #define SDL_GetColorKey SDL_GetColorKey_renamed_SDL_GetSurfaceColorKey
 #define SDL_HasColorKey SDL_HasColorKey_renamed_SDL_SurfaceHasColorKey
 #define SDL_HasSurfaceRLE SDL_HasSurfaceRLE_renamed_SDL_SurfaceHasRLE
+#define SDL_LoadBMP_RW SDL_LoadBMP_RW_renamed_SDL_LoadBMP_IO
 #define SDL_LowerBlit SDL_LowerBlit_renamed_SDL_BlitSurfaceUnchecked
 #define SDL_LowerBlitScaled SDL_LowerBlitScaled_renamed_SDL_BlitSurfaceUncheckedScaled
+#define SDL_SaveBMP_RW SDL_SaveBMP_RW_renamed_SDL_SaveBMP_IO
 #define SDL_SetClipRect SDL_SetClipRect_renamed_SDL_SetSurfaceClipRect
 #define SDL_SetColorKey SDL_SetColorKey_renamed_SDL_SetSurfaceColorKey
 #define SDL_UpperBlit SDL_UpperBlit_renamed_SDL_BlitSurface

include/SDL3/SDL_rwops.h

@@ -39,21 +39,21 @@
 extern "C" {
 #endif
 
-/* RWops status, set by a read or write operation */
-typedef enum SDL_RWopsStatus
+/* SDL_IOStream status, set by a read or write operation */
+typedef enum SDL_IOStatus
 {
-    SDL_RWOPS_STATUS_READY,     /**< Everything is ready */
-    SDL_RWOPS_STATUS_ERROR,     /**< Read or write I/O error */
-    SDL_RWOPS_STATUS_EOF,       /**< End of file */
-    SDL_RWOPS_STATUS_NOT_READY, /**< Non blocking I/O, not ready */
-    SDL_RWOPS_STATUS_READONLY,  /**< Tried to write a read-only buffer */
-    SDL_RWOPS_STATUS_WRITEONLY  /**< Tried to read a write-only buffer */
-} SDL_RWopsStatus;
-
-typedef struct SDL_RWopsInterface
+    SDL_IO_STATUS_READY,     /**< Everything is ready */
+    SDL_IO_STATUS_ERROR,     /**< Read or write I/O error */
+    SDL_IO_STATUS_EOF,       /**< End of file */
+    SDL_IO_STATUS_NOT_READY, /**< Non blocking I/O, not ready */
+    SDL_IO_STATUS_READONLY,  /**< Tried to write a read-only buffer */
+    SDL_IO_STATUS_WRITEONLY  /**< Tried to read a write-only buffer */
+} SDL_IOStatus;
+
+typedef struct SDL_IOStreamInterface
 {
     /**
-     *  Return the number of bytes in this rwops
+     *  Return the number of bytes in this SDL_IOStream
      *
      *  \return the total size of the data stream, or -1 on error.
      */
@@ -61,7 +61,7 @@ typedef struct SDL_RWopsInterface
 
     /**
      *  Seek to \c offset relative to \c whence, one of stdio's whence values:
-     *  SDL_RW_SEEK_SET, SDL_RW_SEEK_CUR, SDL_RW_SEEK_END
+     *  SDL_IO_SEEK_SET, SDL_IO_SEEK_CUR, SDL_IO_SEEK_END
      *
      *  \return the final offset in the data stream, or -1 on error.
      */
@@ -72,52 +72,52 @@ typedef struct SDL_RWopsInterface
      *  at by \c ptr.
      *
      *  On an incomplete read, you should set `*status` to a value from the
-     *  SDL_RWopsStatus enum. You do not have to explicitly set this on
+     *  SDL_IOStatus enum. You do not have to explicitly set this on
      *  a complete, successful read.
      *
      *  \return the number of bytes read
      */
-    size_t (SDLCALL *read)(void *userdata, void *ptr, size_t size, SDL_RWopsStatus *status);
+    size_t (SDLCALL *read)(void *userdata, void *ptr, size_t size, SDL_IOStatus *status);
 
     /**
      *  Write exactly \c size bytes from the area pointed at by \c ptr
      *  to data stream.
      *
      *  On an incomplete write, you should set `*status` to a value from the
-     *  SDL_RWopsStatus enum. You do not have to explicitly set this on
+     *  SDL_IOStatus enum. You do not have to explicitly set this on
      *  a complete, successful write.
      *
      *  \return the number of bytes written
      */
-    size_t (SDLCALL *write)(void *userdata, const void *ptr, size_t size, SDL_RWopsStatus *status);
+    size_t (SDLCALL *write)(void *userdata, const void *ptr, size_t size, SDL_IOStatus *status);
 
     /**
      *  Close and free any allocated resources.
      *
-     *  The RWops is still destroyed even if this fails, so clean up anything
+     *  The SDL_IOStream 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)(void *userdata);
-} SDL_RWopsInterface;
+} SDL_IOStreamInterface;
 
 
 /**
  * This is the read/write operation structure -- opaque, as of SDL3!
  */
-typedef struct SDL_RWops SDL_RWops;
+typedef struct SDL_IOStream SDL_IOStream;
 
 
 /**
- *  \name RWFrom functions
+ *  \name IOFrom functions
  *
- *  Functions to create SDL_RWops structures from various data streams.
+ *  Functions to create SDL_IOStream structures from various data streams.
  */
 /* @{ */
 
 /**
- * Use this function to create a new SDL_RWops structure for reading from
+ * Use this function to create a new SDL_IOStream structure for reading from
  * and/or writing to a named file.
  *
  * The `mode` string is treated roughly the same as in a call to the C
@@ -155,168 +155,168 @@ typedef struct SDL_RWops SDL_RWops;
  * This function supports Unicode filenames, but they must be encoded in UTF-8
  * format, regardless of the underlying operating system.
  *
- * As a fallback, SDL_RWFromFile() will transparently open a matching filename
+ * As a fallback, SDL_IOFromFile() will transparently open a matching filename
  * in an Android app's `assets`.
  *
- * Destroying the SDL_RWops will close the file handle SDL is holding internally.
+ * Destroying the SDL_IOStream will close the file handle SDL is holding internally.
  *
  * The following properties may be set at creation time by SDL:
  *
- * - `SDL_PROP_RWOPS_WINDOWS_HANDLE_POINTER`: a pointer, that can be cast
- *   to a win32 `HANDLE`, that this RWops is using to access the filesystem.
+ * - `SDL_PROP_IOSTREAM_WINDOWS_HANDLE_POINTER`: a pointer, that can be cast
+ *   to a win32 `HANDLE`, that this SDL_IOStream is using to access the filesystem.
  *   If the program isn't running on Windows, or SDL used some other method
  *   to access the filesystem, this property will not be set.
- * - `SDL_PROP_RWOPS_STDIO_HANDLE_POINTER`: a pointer, that can be cast
- *   to a stdio `FILE *`, that this RWops is using to access the filesystem.
+ * - `SDL_PROP_IOSTREAM_STDIO_HANDLE_POINTER`: a pointer, that can be cast
+ *   to a stdio `FILE *`, that this SDL_IOStream is using to access the filesystem.
  *   If SDL used some other method to access the filesystem, this property
  *   will not be set. PLEASE NOTE that if SDL is using a different C runtime
  *   than your app, trying to use this pointer will almost certainly result
  *   in a crash! This is mostly a problem on Windows; make sure you build SDL
  *   and your app with the same compiler and settings to avoid it.
- * - `SDL_PROP_RWOPS_ANDROID_AASSET_POINTER`: a pointer, that can be cast
- *   to an Android NDK `AAsset *`, that this RWops is using to access the
+ * - `SDL_PROP_IOSTREAM_ANDROID_AASSET_POINTER`: a pointer, that can be cast
+ *   to an Android NDK `AAsset *`, that this SDL_IOStream is using to access the
  *   filesystem. If SDL used some other method to access the filesystem, this
  *   property will not be set.
  *
  * \param file a UTF-8 string representing the filename to open
  * \param mode an ASCII string representing the mode to be used for opening
  *             the file.
- * \returns a pointer to the SDL_RWops structure that is created, or NULL on
+ * \returns a pointer to the SDL_IOStream structure that is created, or NULL on
  *          failure; call SDL_GetError() for more information.
  *
  * \since This function is available since SDL 3.0.0.
  *
- * \sa SDL_RWFromConstMem
- * \sa SDL_RWFromMem
- * \sa SDL_ReadRW
- * \sa SDL_SeekRW
- * \sa SDL_TellRW
- * \sa SDL_WriteRW
+ * \sa SDL_IOFromConstMem
+ * \sa SDL_IOFromMem
+ * \sa SDL_ReadIO
+ * \sa SDL_SeekIO
+ * \sa SDL_TellIO
+ * \sa SDL_WriteIO
  */
-extern DECLSPEC SDL_RWops *SDLCALL SDL_RWFromFile(const char *file, const char *mode);
+extern DECLSPEC SDL_IOStream *SDLCALL SDL_IOFromFile(const char *file, const char *mode);
 
-#define SDL_PROP_RWOPS_WINDOWS_HANDLE_POINTER "SDL.rwops.windows.handle"
-#define SDL_PROP_RWOPS_STDIO_HANDLE_POINTER "SDL.rwops.stdio.handle"
-#define SDL_PROP_RWOPS_ANDROID_AASSET_POINTER "SDL.rwops.android.aasset"
+#define SDL_PROP_IOSTREAM_WINDOWS_HANDLE_POINTER "SDL.iostream.windows.handle"
+#define SDL_PROP_IOSTREAM_STDIO_HANDLE_POINTER "SDL.iostream.stdio.handle"
+#define SDL_PROP_IOSTREAM_ANDROID_AASSET_POINTER "SDL.opstream.android.aasset"
 
 /**
  * Use this function to prepare a read-write memory buffer for use with
- * SDL_RWops.
+ * SDL_IOStream.
  *
- * This function sets up an SDL_RWops struct based on a memory area of a
+ * This function sets up an SDL_IOStream struct based on a memory area of a
  * certain size, for both read and write access.
  *
- * This memory buffer is not copied by the RWops; the pointer you provide must
+ * This memory buffer is not copied by the SDL_IOStream; the pointer you provide must
  * remain valid until you close the stream. Closing the stream will not free
  * the original buffer.
  *
- * If you need to make sure the RWops never writes to the memory buffer, you
- * should use SDL_RWFromConstMem() with a read-only buffer of memory instead.
+ * If you need to make sure the SDL_IOStream never writes to the memory buffer, you
+ * should use SDL_IOFromConstMem() with a read-only buffer of memory instead.
  *
- * \param mem a pointer to a buffer to feed an SDL_RWops stream
+ * \param mem a pointer to a buffer to feed an SDL_IOStream stream
  * \param size the buffer size, in bytes
- * \returns a pointer to a new SDL_RWops structure, or NULL if it fails; call
+ * \returns a pointer to a new SDL_IOStream structure, or NULL if it fails; 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_ReadRW
- * \sa SDL_SeekRW
- * \sa SDL_TellRW
- * \sa SDL_WriteRW
+ * \sa SDL_IOFromConstMem
+ * \sa SDL_IOFromFile
+ * \sa SDL_IOFromMem
+ * \sa SDL_ReadIO
+ * \sa SDL_SeekIO
+ * \sa SDL_TellIO
+ * \sa SDL_WriteIO
  */
-extern DECLSPEC SDL_RWops *SDLCALL SDL_RWFromMem(void *mem, size_t size);
+extern DECLSPEC SDL_IOStream *SDLCALL SDL_IOFromMem(void *mem, size_t size);
 
 /**
- * Use this function to prepare a read-only memory buffer for use with RWops.
+ * Use this function to prepare a read-only memory buffer for use with SDL_IOStream.
  *
- * This function sets up an SDL_RWops struct based on a memory area of a
+ * This function sets up an SDL_IOStream struct based on a memory area of a
  * certain size. It assumes the memory area is not writable.
  *
- * Attempting to write to this RWops stream will report an error without
+ * Attempting to write to this SDL_IOStream stream will report an error without
  * writing to the memory buffer.
  *
- * This memory buffer is not copied by the RWops; the pointer you provide must
+ * This memory buffer is not copied by the SDL_IOStream; the pointer you provide must
  * remain valid until you close the stream. Closing the stream will not free
  * the original buffer.
  *
- * If you need to write to a memory buffer, you should use SDL_RWFromMem()
+ * If you need to write to a memory buffer, you should use SDL_IOFromMem()
  * with a writable buffer of memory instead.
  *
- * \param mem a pointer to a read-only buffer to feed an SDL_RWops stream
+ * \param mem a pointer to a read-only buffer to feed an SDL_IOStream stream
  * \param size the buffer size, in bytes
- * \returns a pointer to a new SDL_RWops structure, or NULL if it fails; call
+ * \returns a pointer to a new SDL_IOStream structure, or NULL if it fails; 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_ReadRW
- * \sa SDL_SeekRW
- * \sa SDL_TellRW
+ * \sa SDL_IOFromConstMem
+ * \sa SDL_IOFromFile
+ * \sa SDL_IOFromMem
+ * \sa SDL_ReadIO
+ * \sa SDL_SeekIO
+ * \sa SDL_TellIO
  */
-extern DECLSPEC SDL_RWops *SDLCALL SDL_RWFromConstMem(const void *mem, size_t size);
+extern DECLSPEC SDL_IOStream *SDLCALL SDL_IOFromConstMem(const void *mem, size_t size);
 
-/* @} *//* RWFrom functions */
+/* @} *//* IOFrom functions */
 
 
 /**
- * Create a custom SDL_RWops.
+ * Create a custom SDL_IOStream.
  *
  * 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
+ * their own SDL_IOStream implementation. If you just need an SDL_IOStream to
  * read/write a common data source, you should use the built-in
- * implementations in SDL, like SDL_RWFromFile() or SDL_RWFromMem(), etc.
+ * implementations in SDL, like SDL_IOFromFile() or SDL_IOFromMem(), etc.
  *
- * You must free the returned pointer with SDL_CloseRW().
+ * You must free the returned pointer with SDL_CloseIO().
  *
  *
- * \param iface The function pointers that implement this RWops.
+ * \param iface The function pointers that implement this SDL_IOStream.
  * \param userdata The app-controlled pointer that is passed to iface's functions when called.
  * \returns a pointer to the allocated memory on success, or NULL on failure;
  *          call SDL_GetError() for more information.
  *
  * \since This function is available since SDL 3.0.0.
  *
- * \sa SDL_CloseRW
+ * \sa SDL_CloseIO
  */
-extern DECLSPEC SDL_RWops *SDLCALL SDL_OpenRW(const SDL_RWopsInterface *iface, void *userdata);
+extern DECLSPEC SDL_IOStream *SDLCALL SDL_OpenIO(const SDL_IOStreamInterface *iface, void *userdata);
 
 /**
- * Close and free an allocated SDL_RWops structure.
+ * Close and free an allocated SDL_IOStream structure.
  *
- * SDL_CloseRW() closes and cleans up the SDL_RWops stream. It releases any
- * resources used by the stream and frees the SDL_RWops itself with
- * SDL_CloseRW(). This returns 0 on success, or -1 if the stream failed to
+ * SDL_CloseIO() closes and cleans up the SDL_IOStream stream. It releases any
+ * resources used by the stream and frees the SDL_IOStream itself with
+ * SDL_CloseIO(). 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.
+ * an error, but the SDL_IOStream is still invalid once this function returns.
  *
- * \param context SDL_RWops structure to close
+ * \param context SDL_IOStream 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_ReadRW
- * \sa SDL_SeekRW
- * \sa SDL_WriteRW
+ * \sa SDL_IOFromConstMem
+ * \sa SDL_IOFromFile
+ * \sa SDL_IOFromMem
+ * \sa SDL_ReadIO
+ * \sa SDL_SeekIO
+ * \sa SDL_WriteIO
  */
-extern DECLSPEC int SDLCALL SDL_CloseRW(SDL_RWops *context);
+extern DECLSPEC int SDLCALL SDL_CloseIO(SDL_IOStream *context);
 
 /**
- * Get the properties associated with an SDL_RWops.
+ * Get the properties associated with an SDL_IOStream.
  *
- * \param context a pointer to an SDL_RWops structure
+ * \param context a pointer to an SDL_IOStream structure
  * \returns a valid property ID on success or 0 on failure; call
  *          SDL_GetError() for more information.
  *
@@ -325,99 +325,99 @@ extern DECLSPEC int SDLCALL SDL_CloseRW(SDL_RWops *context);
  * \sa SDL_GetProperty
  * \sa SDL_SetProperty
  */
-extern DECLSPEC SDL_PropertiesID SDLCALL SDL_GetRWProperties(SDL_RWops *context);
+extern DECLSPEC SDL_PropertiesID SDLCALL SDL_GetRWProperties(SDL_IOStream *context);
 
-#define SDL_RW_SEEK_SET 0       /**< Seek from the beginning of data */
-#define SDL_RW_SEEK_CUR 1       /**< Seek relative to current read point */
-#define SDL_RW_SEEK_END 2       /**< Seek relative to the end of data */
+#define SDL_IO_SEEK_SET 0       /**< Seek from the beginning of data */
+#define SDL_IO_SEEK_CUR 1       /**< Seek relative to current read point */
+#define SDL_IO_SEEK_END 2       /**< Seek relative to the end of data */
 
 /**
- * Query the stream status of a RWops.
+ * Query the stream status of an SDL_IOStream.
  *
  * This information can be useful to decide if a short read or write was
  * due to an error, an EOF, or a non-blocking operation that isn't yet
  * ready to complete.
  *
- * A RWops's status is only expected to change after a SDL_ReadRW or
- * SDL_WriteRW call; don't expect it to change if you just call this
+ * An SDL_IOStream's status is only expected to change after a SDL_ReadIO or
+ * SDL_WriteIO call; don't expect it to change if you just call this
  * query function in a tight loop.
  *
- * \param context the SDL_RWops to query.
- * \returns an SDL_RWopsStatus enum with the current state.
+ * \param context the SDL_IOStream to query.
+ * \returns an SDL_IOStatus enum with the current state.
  *
  * \threadsafety This function should not be called at the same time that
- *               another thread is operating on the same SDL_RWops.
+ *               another thread is operating on the same SDL_IOStream.
  *
  * \since This function is available since SDL 3.0.0.
  */
-extern DECLSPEC SDL_RWopsStatus SDLCALL SDL_GetRWStatus(SDL_RWops *context);
+extern DECLSPEC SDL_IOStatus SDLCALL SDL_GetRWStatus(SDL_IOStream *context);
 
 /**
- * Use this function to get the size of the data stream in an SDL_RWops.
+ * Use this function to get the size of the data stream in an SDL_IOStream.
  *
- * \param context the SDL_RWops to get the size of the data stream from
- * \returns the size of the data stream in the SDL_RWops on success or a
+ * \param context the SDL_IOStream to get the size of the data stream from
+ * \returns the size of the data stream in the SDL_IOStream 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.
  */
-extern DECLSPEC Sint64 SDLCALL SDL_SizeRW(SDL_RWops *context);
+extern DECLSPEC Sint64 SDLCALL SDL_SizeIO(SDL_IOStream *context);
 
 /**
- * Seek within an SDL_RWops data stream.
+ * Seek within an SDL_IOStream data stream.
  *
  * This function seeks to byte `offset`, relative to `whence`.
  *
  * `whence` may be any of the following values:
  *
- * - `SDL_RW_SEEK_SET`: seek from the beginning of data
- * - `SDL_RW_SEEK_CUR`: seek relative to current read point
- * - `SDL_RW_SEEK_END`: seek relative to the end of data
+ * - `SDL_IO_SEEK_SET`: seek from the beginning of data
+ * - `SDL_IO_SEEK_CUR`: seek relative to current read point
+ * - `SDL_IO_SEEK_END`: seek relative to the end of data
  *
  * If this stream can not seek, it will return -1.
  *
- * \param context a pointer to an SDL_RWops structure
+ * \param context a pointer to an SDL_IOStream structure
  * \param offset an offset in bytes, relative to **whence** location; can be
  *               negative
- * \param whence any of `SDL_RW_SEEK_SET`, `SDL_RW_SEEK_CUR`,
- *               `SDL_RW_SEEK_END`
+ * \param whence any of `SDL_IO_SEEK_SET`, `SDL_IO_SEEK_CUR`,
+ *               `SDL_IO_SEEK_END`
  * \returns the final offset in the data stream after the seek 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_ReadRW
- * \sa SDL_TellRW
- * \sa SDL_WriteRW
+ * \sa SDL_IOFromConstMem
+ * \sa SDL_IOFromFile
+ * \sa SDL_IOFromMem
+ * \sa SDL_ReadIO
+ * \sa SDL_TellIO
+ * \sa SDL_WriteIO
  */
-extern DECLSPEC Sint64 SDLCALL SDL_SeekRW(SDL_RWops *context, Sint64 offset, int whence);
+extern DECLSPEC Sint64 SDLCALL SDL_SeekIO(SDL_IOStream *context, Sint64 offset, int whence);
 
 /**
- * Determine the current read/write offset in an SDL_RWops data stream.
+ * Determine the current read/write offset in an SDL_IOStream data stream.
  *
- * SDL_TellRW is actually a wrapper function that calls the SDL_RWops's `seek`
- * method, with an offset of 0 bytes from `SDL_RW_SEEK_CUR`, to simplify
+ * SDL_TellIO is actually a wrapper function that calls the SDL_IOStream's `seek`
+ * method, with an offset of 0 bytes from `SDL_IO_SEEK_CUR`, to simplify
  * application development.
  *
- * \param context an SDL_RWops data stream object from which to get the
+ * \param context an SDL_IOStream data stream object from which to get the
  *                current offset
  * \returns the current offset in the stream, or -1 if the information can not
  *          be determined.
  *
  * \since This function is available since SDL 3.0.0.
  *
- * \sa SDL_RWFromConstMem
- * \sa SDL_RWFromFile
- * \sa SDL_RWFromMem
- * \sa SDL_ReadRW
- * \sa SDL_SeekRW
- * \sa SDL_WriteRW
+ * \sa SDL_IOFromConstMem
+ * \sa SDL_IOFromFile
+ * \sa SDL_IOFromMem
+ * \sa SDL_ReadIO
+ * \sa SDL_SeekIO
+ * \sa SDL_WriteIO
  */
-extern DECLSPEC Sint64 SDLCALL SDL_TellRW(SDL_RWops *context);
+extern DECLSPEC Sint64 SDLCALL SDL_TellIO(SDL_IOStream *context);
 
 /**
  * Read from a data source.
@@ -430,26 +430,26 @@ extern DECLSPEC Sint64 SDLCALL SDL_TellRW(SDL_RWops *context);
  * that this is not an error or end-of-file, and the caller can try again
  * later.
  *
- * SDL_ReadRW() is actually a function wrapper that calls the SDL_RWops's
+ * SDL_ReadIO() is actually a function wrapper that calls the SDL_IOStream's
  * `read` method appropriately, to simplify application development.
  *
- * \param context a pointer to an SDL_RWops structure
+ * \param context a pointer to an SDL_IOStream structure
  * \param ptr a pointer to a buffer to read data into
  * \param size the number of bytes to read from the data source.
  * \returns the number of bytes read, or 0 on end of file or other error.
  *
  * \since This function is available since SDL 3.0.0.
  *
- * \sa SDL_RWFromConstMem
- * \sa SDL_RWFromFile
- * \sa SDL_RWFromMem
- * \sa SDL_SeekRW
- * \sa SDL_WriteRW
+ * \sa SDL_IOFromConstMem
+ * \sa SDL_IOFromFile
+ * \sa SDL_IOFromMem
+ * \sa SDL_SeekIO
+ * \sa SDL_WriteIO
  */
-extern DECLSPEC size_t SDLCALL SDL_ReadRW(SDL_RWops *context, void *ptr, size_t size);
+extern DECLSPEC size_t SDLCALL SDL_ReadIO(SDL_IOStream *context, void *ptr, size_t size);
 
 /**
- * Write to an SDL_RWops data stream.
+ * Write to an SDL_IOStream data stream.
  *
  * This function writes exactly `size` bytes from the area pointed at by `ptr`
  * to the stream. If this fails for any reason, it'll return less than `size`
@@ -462,14 +462,14 @@ extern DECLSPEC size_t SDLCALL SDL_ReadRW(SDL_RWops *context, void *ptr, size_t
  * written because it would require blocking, this function returns -2 to
  * distinguish that this is not an error and the caller can try again later.
  *
- * SDL_WriteRW is actually a function wrapper that calls the SDL_RWops's
+ * SDL_WriteIO is actually a function wrapper that calls the SDL_IOStream's
  * `write` method appropriately, to simplify application development.
  *
  * It is an error to specify a negative `size`, but this parameter is signed
  * so you definitely cannot overflow the return value on a successful run with
  * enormous amounts of data.
  *
- * \param context a pointer to an SDL_RWops structure
+ * \param context a pointer to an SDL_IOStream structure
  * \param ptr a pointer to a buffer containing data to write
  * \param size the number of bytes to write
  * \returns the number of bytes written, which will be less than `num` on
@@ -477,21 +477,21 @@ extern DECLSPEC size_t SDLCALL SDL_ReadRW(SDL_RWops *context, void *ptr, size_t
  *
  * \since This function is available since SDL 3.0.0.
  *
- * \sa SDL_RWFromConstMem
- * \sa SDL_RWFromFile
- * \sa SDL_RWFromMem
- * \sa SDL_RWprint
- * \sa SDL_ReadRW
- * \sa SDL_SeekRW
+ * \sa SDL_IOFromConstMem
+ * \sa SDL_IOFromFile
+ * \sa SDL_IOFromMem
+ * \sa SDL_IOprintf
+ * \sa SDL_ReadIO
+ * \sa SDL_SeekIO
  */
-extern DECLSPEC size_t SDLCALL SDL_WriteRW(SDL_RWops *context, const void *ptr, size_t size);
+extern DECLSPEC size_t SDLCALL SDL_WriteIO(SDL_IOStream *context, const void *ptr, size_t size);
 
 /**
- * Print to an SDL_RWops data stream.
+ * Print to an SDL_IOStream data stream.
  *
  * This function does formatted printing to the stream.
  *
- * \param context a pointer to an SDL_RWops structure
+ * \param context a pointer to an SDL_IOStream structure
  * \param fmt a printf() style format string
  * \param ... additional parameters matching % tokens in the `fmt` string, if
  *            any
@@ -500,21 +500,21 @@ extern DECLSPEC size_t SDLCALL SDL_WriteRW(SDL_RWops *context, const void *ptr,
  *
  * \since This function is available since SDL 3.0.0.
  *
- * \sa SDL_RWFromConstMem
- * \sa SDL_RWFromFile
- * \sa SDL_RWFromMem
- * \sa SDL_ReadRW
- * \sa SDL_SeekRW
- * \sa SDL_WriteRW
+ * \sa SDL_IOFromConstMem
+ * \sa SDL_IOFromFile
+ * \sa SDL_IOFromMem
+ * \sa SDL_ReadIO
+ * \sa SDL_SeekIO
+ * \sa SDL_WriteIO
  */
-extern DECLSPEC size_t SDLCALL SDL_RWprintf(SDL_RWops *context, SDL_PRINTF_FORMAT_STRING const char *fmt, ...)  SDL_PRINTF_VARARG_FUNC(2);
+extern DECLSPEC size_t SDLCALL SDL_IOprintf(SDL_IOStream *context, SDL_PRINTF_FORMAT_STRING const char *fmt, ...)  SDL_PRINTF_VARARG_FUNC(2);
 
 /**
- * Print to an SDL_RWops data stream.
+ * Print to an SDL_IOStream data stream.
  *
  * This function does formatted printing to the stream.
  *
- * \param context a pointer to an SDL_RWops structure
+ * \param context a pointer to an SDL_IOStream structure
  * \param fmt a printf() style format string
  * \param ap a variable argument list
  * \returns the number of bytes written, or 0 on error; call SDL_GetError()
@@ -522,14 +522,14 @@ 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_RWFromConstMem
- * \sa SDL_RWFromFile
- * \sa SDL_RWFromMem
- * \sa SDL_ReadRW
- * \sa SDL_SeekRW
- * \sa SDL_WriteRW
+ * \sa SDL_IOFromConstMem
+ * \sa SDL_IOFromFile
+ * \sa SDL_IOFromMem
+ * \sa SDL_ReadIO
+ * \sa SDL_SeekIO
+ * \sa SDL_WriteIO
  */
-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);
+extern DECLSPEC size_t SDLCALL SDL_IOvprintf(SDL_IOStream *context, SDL_PRINTF_FORMAT_STRING const char *fmt, va_list ap) SDL_PRINTF_VARARG_FUNCV(2);
 
 /**
  * Load all the data from an SDL data stream.
@@ -540,15 +540,15 @@ extern DECLSPEC size_t SDLCALL SDL_RWvprintf(SDL_RWops *context, SDL_PRINTF_FORM
  *
  * The data should be freed with SDL_free().
  *
- * \param src the SDL_RWops to read all available data from
+ * \param src the SDL_IOStream 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_CloseRW() on `src` before returning,
+ * \param freesrc if SDL_TRUE, calls SDL_CloseIO() on `src` before returning,
  *                even in the case of an error
  * \returns the data, or NULL if there was an error.
  *
  * \since This function is available since SDL 3.0.0.
  */
-extern DECLSPEC void *SDLCALL SDL_LoadFile_RW(SDL_RWops *src, size_t *datasize, SDL_bool freesrc);
+extern DECLSPEC void *SDLCALL SDL_LoadFile_RW(SDL_IOStream *src, size_t *datasize, SDL_bool freesrc);
 
 /**
  * Load all the data from a file path.
@@ -575,19 +575,19 @@ extern DECLSPEC void *SDLCALL SDL_LoadFile(const char *file, size_t *datasize);
 /* @{ */
 
 /**
- * Use this function to read a byte from an SDL_RWops.
+ * Use this function to read a byte from an SDL_IOStream.
  *
- * \param src the SDL_RWops to read from
+ * \param src the SDL_IOStream to read from
  * \param value a pointer filled in with the data read
  * \returns SDL_TRUE on success or SDL_FALSE on failure; call SDL_GetError()
  *          for more information.
  *
  * \since This function is available since SDL 3.0.0.
  */
-extern DECLSPEC SDL_bool SDLCALL SDL_ReadU8(SDL_RWops *src, Uint8 *value);
+extern DECLSPEC SDL_bool SDLCALL SDL_ReadU8(SDL_IOStream *src, Uint8 *value);
 
 /**
- * Use this function to read 16 bits of little-endian data from an SDL_RWops
+ * Use this function to read 16 bits of little-endian data from an SDL_IOStream
  * and return in native format.
  *
  * SDL byteswaps the data only if necessary, so the data returned will be in
@@ -600,10 +600,10 @@ extern DECLSPEC SDL_bool SDLCALL SDL_ReadU8(SDL_RWops *src, Uint8 *value);
  *
  * \since This function is available since SDL 3.0.0.
  */
-extern DECLSPEC SDL_bool SDLCALL SDL_ReadU16LE(SDL_RWops *src, Uint16 *value);
+extern DECLSPEC SDL_bool SDLCALL SDL_ReadU16LE(SDL_IOStream *src, Uint16 *value);
 
 /**
- * Use this function to read 16 bits of little-endian data from an SDL_RWops
+ * Use this function to read 16 bits of little-endian data from an SDL_IOStream
  * and return in native format.
  *
  * SDL byteswaps the data only if necessary, so the data returned will be in
@@ -616,10 +616,10 @@ extern DECLSPEC SDL_bool SDLCALL SDL_ReadU16LE(SDL_RWops *src, Uint16 *value);
  *
  * \since This function is available since SDL 3.0.0.
  */
-extern DECLSPEC SDL_bool SDLCALL SDL_ReadS16LE(SDL_RWops *src, Sint16 *value);
+extern DECLSPEC SDL_bool SDLCALL SDL_ReadS16LE(SDL_IOStream *src, Sint16 *value);
 
 /**
- * Use this function to read 16 bits of big-endian data from an SDL_RWops and
+ * Use this function to read 16 bits of big-endian data from an SDL_IOStream and
  * return in native format.
  *
  * SDL byteswaps the data only if necessary, so the data returned will be in
@@ -632,10 +632,10 @@ extern DECLSPEC SDL_bool SDLCALL SDL_ReadS16LE(SDL_RWops *src, Sint16 *value);
  *
  * \since This function is available since SDL 3.0.0.
  */
-extern DECLSPEC SDL_bool SDLCALL SDL_ReadU16BE(SDL_RWops *src, Uint16 *value);
+extern DECLSPEC SDL_bool SDLCALL SDL_ReadU16BE(SDL_IOStream *src, Uint16 *value);
 
 /**
- * Use this function to read 16 bits of big-endian data from an SDL_RWops and
+ * Use this function to read 16 bits of big-endian data from an SDL_IOStream and
  * return in native format.
  *
  * SDL byteswaps the data only if necessary, so the data returned will be in
@@ -648,10 +648,10 @@ extern DECLSPEC SDL_bool SDLCALL SDL_ReadU16BE(SDL_RWops *src, Uint16 *value);
  *
  * \since This function is available since SDL 3.0.0.
  */
-extern DECLSPEC SDL_bool SDLCALL SDL_ReadS16BE(SDL_RWops *src, Sint16 *value);
+extern DECLSPEC SDL_bool SDLCALL SDL_ReadS16BE(SDL_IOStream *src, Sint16 *value);
 
 /**
- * Use this function to read 32 bits of little-endian data from an SDL_RWops
+ * Use this function to read 32 bits of little-endian data from an SDL_IOStream
  * and return in native format.
  *
  * SDL byteswaps the data only if necessary, so the data returned will be in
@@ -664,10 +664,10 @@ extern DECLSPEC SDL_bool SDLCALL SDL_ReadS16BE(SDL_RWops *src, Sint16 *value);
  *
  * \since This function is available since SDL 3.0.0.
  */
-extern DECLSPEC SDL_bool SDLCALL SDL_ReadU32LE(SDL_RWops *src, Uint32 *value);
+extern DECLSPEC SDL_bool SDLCALL SDL_ReadU32LE(SDL_IOStream *src, Uint32 *value);
 
 /**
- * Use this function to read 32 bits of little-endian data from an SDL_RWops
+ * Use this function to read 32 bits of little-endian data from an SDL_IOStream
  * and return in native format.
  *
  * SDL byteswaps the data only if necessary, so the data returned will be in
@@ -680,10 +680,10 @@ extern DECLSPEC SDL_bool SDLCALL SDL_ReadU32LE(SDL_RWops *src, Uint32 *value);
  *
  * \since This function is available since SDL 3.0.0.
  */
-extern DECLSPEC SDL_bool SDLCALL SDL_ReadS32LE(SDL_RWops *src, Sint32 *value);
+extern DECLSPEC SDL_bool SDLCALL SDL_ReadS32LE(SDL_IOStream *src, Sint32 *value);
 
 /**
- * Use this function to read 32 bits of big-endian data from an SDL_RWops and
+ * Use this function to read 32 bits of big-endian data from an SDL_IOStream and
  * return in native format.
  *
  * SDL byteswaps the data only if necessary, so the data returned will be in
@@ -696,10 +696,10 @@ extern DECLSPEC SDL_bool SDLCALL SDL_ReadS32LE(SDL_RWops *src, Sint32 *value);
  *
  * \since This function is available since SDL 3.0.0.
  */
-extern DECLSPEC SDL_bool SDLCALL SDL_ReadU32BE(SDL_RWops *src, Uint32 *value);
+extern DECLSPEC SDL_bool SDLCALL SDL_ReadU32BE(SDL_IOStream *src, Uint32 *value);
 
 /**
- * Use this function to read 32 bits of big-endian data from an SDL_RWops and
+ * Use this function to read 32 bits of big-endian data from an SDL_IOStream and
  * return in native format.
  *
  * SDL byteswaps the data only if necessary, so the data returned will be in
@@ -712,10 +712,10 @@ extern DECLSPEC SDL_bool SDLCALL SDL_ReadU32BE(SDL_RWops *src, Uint32 *value);
  *
  * \since This function is available since SDL 3.0.0.
  */
-extern DECLSPEC SDL_bool SDLCALL SDL_ReadS32BE(SDL_RWops *src, Sint32 *value);
+extern DECLSPEC SDL_bool SDLCALL SDL_ReadS32BE(SDL_IOStream *src, Sint32 *value);
 
 /**
- * Use this function to read 64 bits of little-endian data from an SDL_RWops
+ * Use this function to read 64 bits of little-endian data from an SDL_IOStream
  * and return in native format.
  *
  * SDL byteswaps the data only if necessary, so the data returned will be in
@@ -728,10 +728,10 @@ extern DECLSPEC SDL_bool SDLCALL SDL_ReadS32BE(SDL_RWops *src, Sint32 *value);
  *
  * \since This function is available since SDL 3.0.0.
  */
-extern DECLSPEC SDL_bool SDLCALL SDL_ReadU64LE(SDL_RWops *src, Uint64 *value);
+extern DECLSPEC SDL_bool SDLCALL SDL_ReadU64LE(SDL_IOStream *src, Uint64 *value);
 
 /**
- * Use this function to read 64 bits of little-endian data from an SDL_RWops
+ * Use this function to read 64 bits of little-endian data from an SDL_IOStream
  * and return in native format.
  *
  * SDL byteswaps the data only if necessary, so the data returned will be in
@@ -744,10 +744,10 @@ extern DECLSPEC SDL_bool SDLCALL SDL_ReadU64LE(SDL_RWops *src, Uint64 *value);
  *
  * \since This function is available since SDL 3.0.0.
  */
-extern DECLSPEC SDL_bool SDLCALL SDL_ReadS64LE(SDL_RWops *src, Sint64 *value);
+extern DECLSPEC SDL_bool SDLCALL SDL_ReadS64LE(SDL_IOStream *src, Sint64 *value);
 
 /**
- * Use this function to read 64 bits of big-endian data from an SDL_RWops and
+ * Use this function to read 64 bits of big-endian data from an SDL_IOStream and
  * return in native format.
  *
  * SDL byteswaps the data only if necessary, so the data returned will be in
@@ -760,10 +760,10 @@ extern DECLSPEC SDL_bool SDLCALL SDL_ReadS64LE(SDL_RWops *src, Sint64 *value);
  *
  * \since This function is available since SDL 3.0.0.
  */
-extern DECLSPEC SDL_bool SDLCALL SDL_ReadU64BE(SDL_RWops *src, Uint64 *value);
+extern DECLSPEC SDL_bool SDLCALL SDL_ReadU64BE(SDL_IOStream *src, Uint64 *value);
 
 /**
- * Use this function to read 64 bits of big-endian data from an SDL_RWops and
+ * Use this function to read 64 bits of big-endian data from an SDL_IOStream and
  * return in native format.
  *
  * SDL byteswaps the data only if necessary, so the data returned will be in
@@ -776,7 +776,7 @@ extern DECLSPEC SDL_bool SDLCALL SDL_ReadU64BE(SDL_RWops *src, Uint64 *value);
  *
  * \since This function is available since SDL 3.0.0.
  */
-extern DECLSPEC SDL_bool SDLCALL SDL_ReadS64BE(SDL_RWops *src, Sint64 *value);
+extern DECLSPEC SDL_bool SDLCALL SDL_ReadS64BE(SDL_IOStream *src, Sint64 *value);
 /* @} *//* Read endian functions */
 
 /**
@@ -787,19 +787,19 @@ extern DECLSPEC SDL_bool SDLCALL SDL_ReadS64BE(SDL_RWops *src, Sint64 *value);
 /* @{ */
 
 /**
- * Use this function to write a byte to an SDL_RWops.
+ * Use this function to write a byte to an SDL_IOStream.
  *
- * \param dst the SDL_RWops to write to
+ * \param dst the SDL_IOStream to write to
  * \param value the byte value to write
  * \returns SDL_TRUE on successful write, SDL_FALSE on failure; call
  *          SDL_GetError() for more information.
  *
  * \since This function is available since SDL 3.0.0.
  */
-extern DECLSPEC SDL_bool SDLCALL SDL_WriteU8(SDL_RWops *dst, Uint8 value);
+extern DECLSPEC SDL_bool SDLCALL SDL_WriteU8(SDL_IOStream *dst, Uint8 value);
 
 /**
- * Use this function to write 16 bits in native format to an SDL_RWops as
+ * Use this function to write 16 bits in native format to an SDL_IOStream as
  * little-endian data.
  *
  * SDL byteswaps the data only if necessary, so the application always
@@ -813,10 +813,10 @@ extern DECLSPEC SDL_bool SDLCALL SDL_WriteU8(SDL_RWops *dst, Uint8 value);
  *
  * \since This function is available since SDL 3.0.0.
  */
-extern DECLSPEC SDL_bool SDLCALL SDL_WriteU16LE(SDL_RWops *dst, Uint16 value);
+extern DECLSPEC SDL_bool SDLCALL SDL_WriteU16LE(SDL_IOStream *dst, Uint16 value);
 
 /**
- * Use this function to write 16 bits in native format to an SDL_RWops as
+ * Use this function to write 16 bits in native format to an SDL_IOStream as
  * little-endian data.
  *
  * SDL byteswaps the data only if necessary, so the application always
@@ -830,10 +830,10 @@ extern DECLSPEC SDL_bool SDLCALL SDL_WriteU16LE(SDL_RWops *dst, Uint16 value);
  *
  * \since This function is available since SDL 3.0.0.
  */
-extern DECLSPEC SDL_bool SDLCALL SDL_WriteS16LE(SDL_RWops *dst, Sint16 value);
+extern DECLSPEC SDL_bool SDLCALL SDL_WriteS16LE(SDL_IOStream *dst, Sint16 value);
 
 /**
- * Use this function to write 16 bits in native format to an SDL_RWops as
+ * Use this function to write 16 bits in native format to an SDL_IOStream as
  * big-endian data.
  *
  * SDL byteswaps the data only if necessary, so the application always
@@ -846,10 +846,10 @@ extern DECLSPEC SDL_bool SDLCALL SDL_WriteS16LE(SDL_RWops *dst, Sint16 value);
  *
  * \since This function is available since SDL 3.0.0.
  */
-extern DECLSPEC SDL_bool SDLCALL SDL_WriteU16BE(SDL_RWops *dst, Uint16 value);
+extern DECLSPEC SDL_bool SDLCALL SDL_WriteU16BE(SDL_IOStream *dst, Uint16 value);
 
 /**
- * Use this function to write 16 bits in native format to an SDL_RWops as
+ * Use this function to write 16 bits in native format to an SDL_IOStream as
  * big-endian data.
  *
  * SDL byteswaps the data only if necessary, so the application always
@@ -862,10 +862,10 @@ extern DECLSPEC SDL_bool SDLCALL SDL_WriteU16BE(SDL_RWops *dst, Uint16 value);
  *
  * \since This function is available since SDL 3.0.0.
  */
-extern DECLSPEC SDL_bool SDLCALL SDL_WriteS16BE(SDL_RWops *dst, Sint16 value);
+extern DECLSPEC SDL_bool SDLCALL SDL_WriteS16BE(SDL_IOStream *dst, Sint16 value);
 
 /**
- * Use this function to write 32 bits in native format to an SDL_RWops as
+ * Use this function to write 32 bits in native format to an SDL_IOStream as
  * little-endian data.
  *
  * SDL byteswaps the data only if necessary, so the application always
@@ -879,10 +879,10 @@ extern DECLSPEC SDL_bool SDLCALL SDL_WriteS16BE(SDL_RWops *dst, Sint16 value);
  *
  * \since This function is available since SDL 3.0.0.
  */
-extern DECLSPEC SDL_bool SDLCALL SDL_WriteU32LE(SDL_RWops *dst, Uint32 value);
+extern DECLSPEC SDL_bool SDLCALL SDL_WriteU32LE(SDL_IOStream *dst, Uint32 value);
 
 /**
- * Use this function to write 32 bits in native format to an SDL_RWops as
+ * Use this function to write 32 bits in native format to an SDL_IOStream as
  * little-endian data.
  *
  * SDL byteswaps the data only if necessary, so the application always
@@ -896,10 +896,10 @@ extern DECLSPEC SDL_bool SDLCALL SDL_WriteU32LE(SDL_RWops *dst, Uint32 value);
  *
  * \since This function is available since SDL 3.0.0.
  */
-extern DECLSPEC SDL_bool SDLCALL SDL_WriteS32LE(SDL_RWops *dst, Sint32 value);
+extern DECLSPEC SDL_bool SDLCALL SDL_WriteS32LE(SDL_IOStream *dst, Sint32 value);
 
 /**
- * Use this function to write 32 bits in native format to an SDL_RWops as
+ * Use this function to write 32 bits in native format to an SDL_IOStream as
  * big-endian data.
  *
  * SDL byteswaps the data only if necessary, so the application always
@@ -912,10 +912,10 @@ extern DECLSPEC SDL_bool SDLCALL SDL_WriteS32LE(SDL_RWops *dst, Sint32 value);
  *
  * \since This function is available since SDL 3.0.0.
  */
-extern DECLSPEC SDL_bool SDLCALL SDL_WriteU32BE(SDL_RWops *dst, Uint32 value);
+extern DECLSPEC SDL_bool SDLCALL SDL_WriteU32BE(SDL_IOStream *dst, Uint32 value);
 
 /**
- * Use this function to write 32 bits in native format to an SDL_RWops as
+ * Use this function to write 32 bits in native format to an SDL_IOStream as
  * big-endian data.
  *
  * SDL byteswaps the data only if necessary, so the application always
@@ -928,10 +928,10 @@ extern DECLSPEC SDL_bool SDLCALL SDL_WriteU32BE(SDL_RWops *dst, Uint32 value);
  *
  * \since This function is available since SDL 3.0.0.
  */
-extern DECLSPEC SDL_bool SDLCALL SDL_WriteS32BE(SDL_RWops *dst, Sint32 value);
+extern DECLSPEC SDL_bool SDLCALL SDL_WriteS32BE(SDL_IOStream *dst, Sint32 value);
 
 /**
- * Use this function to write 64 bits in native format to an SDL_RWops as
+ * Use this function to write 64 bits in native format to an SDL_IOStream as
  * little-endian data.
  *
  * SDL byteswaps the data only if necessary, so the application always
@@ -945,10 +945,10 @@ extern DECLSPEC SDL_bool SDLCALL SDL_WriteS32BE(SDL_RWops *dst, Sint32 value);
  *
  * \since This function is available since SDL 3.0.0.
  */
-extern DECLSPEC SDL_bool SDLCALL SDL_WriteU64LE(SDL_RWops *dst, Uint64 value);
+extern DECLSPEC SDL_bool SDLCALL SDL_WriteU64LE(SDL_IOStream *dst, Uint64 value);
 
 /**
- * Use this function to write 64 bits in native format to an SDL_RWops as
+ * Use this function to write 64 bits in native format to an SDL_IOStream as
  * little-endian data.
  *
  * SDL byteswaps the data only if necessary, so the application always
@@ -962,10 +962,10 @@ extern DECLSPEC SDL_bool SDLCALL SDL_WriteU64LE(SDL_RWops *dst, Uint64 value);
  *
  * \since This function is available since SDL 3.0.0.
  */
-extern DECLSPEC SDL_bool SDLCALL SDL_WriteS64LE(SDL_RWops *dst, Sint64 value);
+extern DECLSPEC SDL_bool SDLCALL SDL_WriteS64LE(SDL_IOStream *dst, Sint64 value);
 
 /**
- * Use this function to write 64 bits in native format to an SDL_RWops as
+ * Use this function to write 64 bits in native format to an SDL_IOStream as
  * big-endian data.
  *
  * SDL byteswaps the data only if necessary, so the application always
@@ -978,10 +978,10 @@ extern DECLSPEC SDL_bool SDLCALL SDL_WriteS64LE(SDL_RWops *dst, Sint64 value);
  *
  * \since This function is available since SDL 3.0.0.
  */
-extern DECLSPEC SDL_bool SDLCALL SDL_WriteU64BE(SDL_RWops *dst, Uint64 value);
+extern DECLSPEC SDL_bool SDLCALL SDL_WriteU64BE(SDL_IOStream *dst, Uint64 value);
 
 /**
- * Use this function to write 64 bits in native format to an SDL_RWops as
+ * Use this function to write 64 bits in native format to an SDL_IOStream as
  * big-endian data.
  *
  * SDL byteswaps the data only if necessary, so the application always
@@ -994,7 +994,7 @@ extern DECLSPEC SDL_bool SDLCALL SDL_WriteU64BE(SDL_RWops *dst, Uint64 value);
  *
  * \since This function is available since SDL 3.0.0.
  */
-extern DECLSPEC SDL_bool SDLCALL SDL_WriteS64BE(SDL_RWops *dst, Sint64 value);
+extern DECLSPEC SDL_bool SDLCALL SDL_WriteS64BE(SDL_IOStream *dst, Sint64 value);
 
 /* @} *//* Write endian functions */
 

include/SDL3/SDL_surface.h

@@ -196,7 +196,7 @@ extern DECLSPEC SDL_Surface *SDLCALL SDL_CreateSurfaceFrom
  * \sa SDL_CreateSurface
  * \sa SDL_CreateSurfaceFrom
  * \sa SDL_LoadBMP
- * \sa SDL_LoadBMP_RW
+ * \sa SDL_LoadBMP_IO
  */
 extern DECLSPEC void SDLCALL SDL_DestroySurface(SDL_Surface *surface);
 
@@ -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_CloseRW() on `src` before returning,
+ * \param freesrc if SDL_TRUE, calls SDL_CloseIO() 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.
@@ -337,9 +337,9 @@ extern DECLSPEC void SDLCALL SDL_UnlockSurface(SDL_Surface *surface);
  *
  * \sa SDL_DestroySurface
  * \sa SDL_LoadBMP
- * \sa SDL_SaveBMP_RW
+ * \sa SDL_SaveBMP_IO
  */
-extern DECLSPEC SDL_Surface *SDLCALL SDL_LoadBMP_RW(SDL_RWops *src, SDL_bool freesrc);
+extern DECLSPEC SDL_Surface *SDLCALL SDL_LoadBMP_IO(SDL_IOStream *src, SDL_bool freesrc);
 
 /**
  * Load a BMP image from a file.
@@ -354,7 +354,7 @@ extern DECLSPEC SDL_Surface *SDLCALL SDL_LoadBMP_RW(SDL_RWops *src, SDL_bool fre
  * \since This function is available since SDL 3.0.0.
  *
  * \sa SDL_DestroySurface
- * \sa SDL_LoadBMP_RW
+ * \sa SDL_LoadBMP_IO
  * \sa SDL_SaveBMP
  */
 extern DECLSPEC SDL_Surface *SDLCALL SDL_LoadBMP(const char *file);
@@ -370,17 +370,17 @@ 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_CloseRW() on `dst` before returning,
+ * \param freedst if SDL_TRUE, calls SDL_CloseIO() 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.
  *
  * \since This function is available since SDL 3.0.0.
  *
- * \sa SDL_LoadBMP_RW
+ * \sa SDL_LoadBMP_IO
  * \sa SDL_SaveBMP
  */
-extern DECLSPEC int SDLCALL SDL_SaveBMP_RW(SDL_Surface *surface, SDL_RWops *dst, SDL_bool freedst);
+extern DECLSPEC int SDLCALL SDL_SaveBMP_IO(SDL_Surface *surface, SDL_IOStream *dst, SDL_bool freedst);
 
 /**
  * Save a surface to a file.
@@ -399,7 +399,7 @@ extern DECLSPEC int SDLCALL SDL_SaveBMP_RW(SDL_Surface *surface, SDL_RWops *dst,
  * \since This function is available since SDL 3.0.0.
  *
  * \sa SDL_LoadBMP
- * \sa SDL_SaveBMP_RW
+ * \sa SDL_SaveBMP_IO
  */
 extern DECLSPEC int SDLCALL SDL_SaveBMP(SDL_Surface *surface, const char *file);
 

src/audio/SDL_wave.c

@@ -1502,7 +1502,7 @@ static void WaveFreeChunkData(WaveChunk *chunk)
     chunk->size = 0;
 }
 
-static int WaveNextChunk(SDL_RWops *src, WaveChunk *chunk)
+static int WaveNextChunk(SDL_IOStream *src, WaveChunk *chunk)
 {
     Uint32 chunkheader[2];
     Sint64 nextposition = chunk->position + chunk->length;
@@ -1520,10 +1520,10 @@ static int WaveNextChunk(SDL_RWops *src, WaveChunk *chunk)
         nextposition++;
     }
 
-    if (SDL_SeekRW(src, nextposition, SDL_RW_SEEK_SET) != nextposition) {
+    if (SDL_SeekIO(src, nextposition, SDL_IO_SEEK_SET) != nextposition) {
         /* Not sure how we ended up here. Just abort. */
         return -2;
-    } else if (SDL_ReadRW(src, chunkheader, sizeof(Uint32) * 2) != (sizeof(Uint32) * 2)) {
+    } else if (SDL_ReadIO(src, chunkheader, sizeof(Uint32) * 2) != (sizeof(Uint32) * 2)) {
         return -1;
     }
 
@@ -1534,7 +1534,7 @@ static int WaveNextChunk(SDL_RWops *src, WaveChunk *chunk)
     return 0;
 }
 
-static int WaveReadPartialChunkData(SDL_RWops *src, WaveChunk *chunk, size_t length)
+static int WaveReadPartialChunkData(SDL_IOStream *src, WaveChunk *chunk, size_t length)
 {
     WaveFreeChunkData(chunk);
 
@@ -1548,12 +1548,12 @@ static int WaveReadPartialChunkData(SDL_RWops *src, WaveChunk *chunk, size_t len
             return -1;
         }
 
-        if (SDL_SeekRW(src, chunk->position, SDL_RW_SEEK_SET) != chunk->position) {
+        if (SDL_SeekIO(src, chunk->position, SDL_IO_SEEK_SET) != chunk->position) {
             /* Not sure how we ended up here. Just abort. */
             return -2;
         }
 
-        chunk->size = SDL_ReadRW(src, chunk->data, length);
+        chunk->size = SDL_ReadIO(src, chunk->data, length);
         if (chunk->size != length) {
             /* Expected to be handled by the caller. */
         }
@@ -1562,7 +1562,7 @@ static int WaveReadPartialChunkData(SDL_RWops *src, WaveChunk *chunk, size_t len
     return 0;
 }
 
-static int WaveReadChunkData(SDL_RWops *src, WaveChunk *chunk)
+static int WaveReadChunkData(SDL_IOStream *src, WaveChunk *chunk)
 {
     return WaveReadPartialChunkData(src, chunk, chunk->length);
 }
@@ -1602,14 +1602,14 @@ static int WaveReadFormat(WaveFile *file)
 {
     WaveChunk *chunk = &file->chunk;
     WaveFormat *format = &file->format;
-    SDL_RWops *fmtsrc;
+    SDL_IOStream *fmtsrc;
     size_t fmtlen = chunk->size;
 
     if (fmtlen > SDL_MAX_SINT32) {
-        /* Limit given by SDL_RWFromConstMem. */
+        /* Limit given by SDL_IOFromConstMem. */
         return SDL_SetError("Data of WAVE fmt chunk too big");
     }
-    fmtsrc = SDL_RWFromConstMem(chunk->data, (int)chunk->size);
+    fmtsrc = SDL_IOFromConstMem(chunk->data, (int)chunk->size);
     if (!fmtsrc) {
         return -1;
     }
@@ -1629,7 +1629,7 @@ static int WaveReadFormat(WaveFile *file)
             return -1;
         }
     } else if (format->encoding == PCM_CODE) {
-        SDL_CloseRW(fmtsrc);
+        SDL_CloseIO(fmtsrc);
         return SDL_SetError("Missing wBitsPerSample field in WAVE fmt chunk");
     }
 
@@ -1649,19 +1649,19 @@ static int WaveReadFormat(WaveFile *file)
 
         /* Extensible header must be at least 22 bytes. */
         if (fmtlen < 40 || format->extsize < 22) {
-            SDL_CloseRW(fmtsrc);
+            SDL_CloseIO(fmtsrc);
             return SDL_SetError("Extensible WAVE header too small");
         }
 
         if (!SDL_ReadU16LE(fmtsrc, &format->validsamplebits) ||
             !SDL_ReadU32LE(fmtsrc, &format->channelmask) ||
-            SDL_ReadRW(fmtsrc, format->subformat, 16) != 16) {
+            SDL_ReadIO(fmtsrc, format->subformat, 16) != 16) {
         }
         format->samplesperblock = format->validsamplebits;
         format->encoding = WaveGetFormatGUIDEncoding(format);
     }
 
-    SDL_CloseRW(fmtsrc);
+    SDL_CloseIO(fmtsrc);
 
     return 0;
 }
@@ -1769,7 +1769,7 @@ static int WaveCheckFormat(WaveFile *file, size_t datalength)
     return 0;
 }
 
-static int WaveLoad(SDL_RWops *src, WaveFile *file, SDL_AudioSpec *spec, Uint8 **audio_buf, Uint32 *audio_len)
+static int WaveLoad(SDL_IOStream *src, WaveFile *file, SDL_AudioSpec *spec, Uint8 **audio_buf, Uint32 *audio_len)
 {
     int result;
     Uint32 chunkcount = 0;
@@ -1795,7 +1795,7 @@ static int WaveLoad(SDL_RWops *src, WaveFile *file, SDL_AudioSpec *spec, Uint8 *
         }
     }
 
-    RIFFstart = SDL_TellRW(src);
+    RIFFstart = SDL_TellIO(src);
     if (RIFFstart < 0) {
         return SDL_SetError("Could not seek in file");
     }
@@ -1897,7 +1897,7 @@ static int WaveLoad(SDL_RWops *src, WaveFile *file, SDL_AudioSpec *spec, Uint8 *
                     file->fact.status = -1;
                 } else {
                     /* Let's use src directly, it's just too convenient. */
-                    Sint64 position = SDL_SeekRW(src, chunk->position, SDL_RW_SEEK_SET);
+                    Sint64 position = SDL_SeekIO(src, chunk->position, SDL_IO_SEEK_SET);
                     if (position == chunk->position && SDL_ReadU32LE(src, &file->fact.samplelength)) {
                         file->fact.status = 1;
                     } else {
@@ -1940,7 +1940,7 @@ static int WaveLoad(SDL_RWops *src, WaveFile *file, SDL_AudioSpec *spec, Uint8 *
         if (chunk->fourcc != DATA && chunk->length > 0) {
             Uint8 tmp;
             Uint64 position = (Uint64)chunk->position + chunk->length - 1;
-            if (position > SDL_MAX_SINT64 || SDL_SeekRW(src, (Sint64)position, SDL_RW_SEEK_SET) != (Sint64)position) {
+            if (position > SDL_MAX_SINT64 || SDL_SeekIO(src, (Sint64)position, SDL_IO_SEEK_SET) != (Sint64)position) {
                 return SDL_SetError("Could not seek to WAVE chunk data");
             } else if (!SDL_ReadU8(src, &tmp)) {
                 return SDL_SetError("RIFF size truncates chunk");
@@ -2075,14 +2075,14 @@ static int WaveLoad(SDL_RWops *src, WaveFile *file, SDL_AudioSpec *spec, Uint8 *
     return 0;
 }
 
-int SDL_LoadWAV_RW(SDL_RWops *src, SDL_bool freesrc, SDL_AudioSpec *spec, Uint8 **audio_buf, Uint32 *audio_len)
+int SDL_LoadWAV_IO(SDL_IOStream *src, SDL_bool freesrc, SDL_AudioSpec *spec, Uint8 **audio_buf, Uint32 *audio_len)
 {
     int result = -1;
     WaveFile file;
 
     /* Make sure we are passed a valid data source */
     if (!src) {
-        goto done;  /* Error may come from RWops. */
+        goto done;  /* Error may come from SDL_IOStream. */
     } else if (!spec) {
         SDL_InvalidParamError("spec");
         goto done;
@@ -2111,19 +2111,19 @@ int SDL_LoadWAV_RW(SDL_RWops *src, SDL_bool freesrc, SDL_AudioSpec *spec, Uint8
 
     /* Cleanup */
     if (!freesrc) {
-        SDL_SeekRW(src, file.chunk.position, SDL_RW_SEEK_SET);
+        SDL_SeekIO(src, file.chunk.position, SDL_IO_SEEK_SET);
     }
     WaveFreeChunkData(&file.chunk);
     SDL_free(file.decoderdata);
 done:
     if (freesrc && src) {
-        SDL_CloseRW(src);
+        SDL_CloseIO(src);
     }
     return result;
 }
 
 int SDL_LoadWAV(const char *path, SDL_AudioSpec *spec, Uint8 **audio_buf, Uint32 *audio_len)
 {
-    return SDL_LoadWAV_RW(SDL_RWFromFile(path, "rb"), 1, spec, audio_buf, audio_len);
+    return SDL_LoadWAV_IO(SDL_IOFromFile(path, "rb"), 1, spec, audio_buf, audio_len);
 }
 

src/audio/disk/SDL_diskaudio.c

@@ -43,7 +43,7 @@ static int DISKAUDIO_WaitDevice(SDL_AudioDevice *device)
 
 static int DISKAUDIO_PlayDevice(SDL_AudioDevice *device, const Uint8 *buffer, int buffer_size)
 {
-    const int written = (int)SDL_WriteRW(device->hidden->io, buffer, (size_t)buffer_size);
+    const int written = (int)SDL_WriteIO(device->hidden->io, buffer, (size_t)buffer_size);
     if (written != buffer_size) { // If we couldn't write, assume fatal error for now
         return -1;
     }
@@ -64,11 +64,11 @@ static int DISKAUDIO_CaptureFromDevice(SDL_AudioDevice *device, void *buffer, in
     const int origbuflen = buflen;
 
     if (h->io) {
-        const int br = (int)SDL_ReadRW(h->io, buffer, (size_t)buflen);
+        const int br = (int)SDL_ReadIO(h->io, buffer, (size_t)buflen);
         buflen -= br;
         buffer = ((Uint8 *)buffer) + br;
         if (buflen > 0) { // EOF (or error, but whatever).
-            SDL_CloseRW(h->io);
+            SDL_CloseIO(h->io);
             h->io = NULL;
         }
     }
@@ -88,7 +88,7 @@ static void DISKAUDIO_CloseDevice(SDL_AudioDevice *device)
 {
     if (device->hidden) {
         if (device->hidden->io) {
-            SDL_CloseRW(device->hidden->io);
+            SDL_CloseIO(device->hidden->io);
         }
         SDL_free(device->hidden->mixbuf);
         SDL_free(device->hidden);
@@ -123,7 +123,7 @@ static int DISKAUDIO_OpenDevice(SDL_AudioDevice *device)
     }
 
     // Open the "audio device"
-    device->hidden->io = SDL_RWFromFile(fname, iscapture ? "rb" : "wb");
+    device->hidden->io = SDL_IOFromFile(fname, iscapture ? "rb" : "wb");
     if (!device->hidden->io) {
         return -1;
     }

src/audio/disk/SDL_diskaudio.h

@@ -28,7 +28,7 @@
 struct SDL_PrivateAudioData
 {
     // The file descriptor for the audio device
-    SDL_RWops *io;
+    SDL_IOStream *io;
     Uint32 io_delay;
     Uint8 *mixbuf;
 };

src/dynapi/SDL_dynapi.c

@@ -146,13 +146,13 @@ static void SDL_InitDynamicAPI(void);
         va_end(ap);                                                                                                                       \
         return retval;                                                                                                                    \
     }                                                                                                                                     \
-    _static size_t SDLCALL SDL_RWprintf##name(SDL_RWops *context, SDL_PRINTF_FORMAT_STRING const char *fmt, ...)                          \
+    _static size_t SDLCALL SDL_IOprintf##name(SDL_IOStream *context, SDL_PRINTF_FORMAT_STRING const char *fmt, ...)                          \
     {                                                                                                                                     \
         size_t retval;                                                                                                                    \
         va_list ap;                                                                                                                       \
         initcall;                                                                                                                         \
         va_start(ap, fmt);                                                                                                                \
-        retval = jump_table.SDL_RWvprintf(context, fmt, ap);                                                                              \
+        retval = jump_table.SDL_IOvprintf(context, fmt, ap);                                                                              \
         va_end(ap);                                                                                                                       \
         return retval;                                                                                                                    \
     }                                                                                                                                     \
@@ -297,13 +297,13 @@ static int SDLCALL SDL_swprintf_LOGSDLCALLS(SDL_OUT_Z_CAP(maxlen) wchar_t *buf,
     va_end(ap);
     return retval;
 }
-_static size_t SDLCALL SDL_RWprintf_LOGSDLCALLS(SDL_RWops *context, SDL_PRINTF_FORMAT_STRING const char *fmt, ...)
+_static size_t SDLCALL SDL_IOprintf_LOGSDLCALLS(SDL_IOStream *context, SDL_PRINTF_FORMAT_STRING const char *fmt, ...)
 {
     size_t retval;
     va_list ap;
-    SDL_Log_REAL("SDL3CALL SDL_RWprintf");
+    SDL_Log_REAL("SDL3CALL SDL_IOprintf");
     va_start(ap, fmt);
-    retval = SDL_RWvprintf_REAL(context, fmt, ap);
+    retval = SDL_IOvprintf_REAL(context, fmt, ap);
     va_end(ap);
     return retval;
 }

src/dynapi/SDL_dynapi.sym

@@ -407,7 +407,7 @@ SDL3_0.0.0 {
     SDL_LinuxSetThreadPriority;
     SDL_LinuxSetThreadPriorityAndPolicy;
     SDL_LoadBMP;
-    SDL_LoadBMP_RW;
+    SDL_LoadBMP_IO;
     SDL_LoadFile;
     SDL_LoadFile_RW;
     SDL_LoadFunction;
@@ -464,14 +464,14 @@ SDL3_0.0.0 {
     SDL_QueryTexture;
     SDL_Quit;
     SDL_QuitSubSystem;
-    SDL_RWFromConstMem;
-    SDL_RWFromFile;
-    SDL_RWFromMem;
-    SDL_ReadRW;
-    SDL_SeekRW;
-    SDL_SizeRW;
-    SDL_TellRW;
-    SDL_WriteRW;
+    SDL_IOFromConstMem;
+    SDL_IOFromFile;
+    SDL_IOFromMem;
+    SDL_ReadIO;
+    SDL_SeekIO;
+    SDL_SizeIO;
+    SDL_TellIO;
+    SDL_WriteIO;
     SDL_RaiseWindow;
     SDL_ReadU16BE;
     SDL_ReadU32BE;
@@ -514,7 +514,7 @@ SDL3_0.0.0 {
     SDL_RunApp;
     SDL_SIMDGetAlignment;
     SDL_SaveBMP;
-    SDL_SaveBMP_RW;
+    SDL_SaveBMP_IO;
     SDL_ScreenKeyboardShown;
     SDL_ScreenSaverEnabled;
     SDL_SendGamepadEffect;
@@ -839,7 +839,7 @@ SDL3_0.0.0 {
     SDL_SetAudioStreamPutCallback;
     SDL_DestroyAudioStream;
     SDL_OpenAudioDeviceStream;
-    SDL_LoadWAV_RW;
+    SDL_LoadWAV_IO;
     SDL_LoadWAV;
     SDL_MixAudioFormat;
     SDL_ConvertAudioSamples;
@@ -884,8 +884,8 @@ SDL3_0.0.0 {
     SDL_GetWindowProperties;
     SDL_ClearProperty;
     SDL_EnterAppMainCallbacks;
-    SDL_RWprintf;
-    SDL_RWvprintf;
+    SDL_IOprintf;
+    SDL_IOvprintf;
     SDL_AllocateEventMemory;
     SDL_GetDisplayProperties;
     SDL_SetPropertyWithCleanup;
@@ -976,8 +976,8 @@ SDL3_0.0.0 {
     SDL_ShowOpenFileDialog;
     SDL_ShowSaveFileDialog;
     SDL_ShowOpenFolderDialog;
-    SDL_OpenRW;
-    SDL_CloseRW;
+    SDL_OpenIO;
+    SDL_CloseIO;
     SDL_GetRWStatus;
     # extra symbols go here (don't modify this line)
   local: *;

src/dynapi/SDL_dynapi_overrides.h

@@ -431,7 +431,7 @@
 #define SDL_LinuxSetThreadPriority  SDL_LinuxSetThreadPriority_REAL
 #define SDL_LinuxSetThreadPriorityAndPolicy SDL_LinuxSetThreadPriorityAndPolicy_REAL
 #define SDL_LoadBMP SDL_LoadBMP_REAL
-#define SDL_LoadBMP_RW SDL_LoadBMP_RW_REAL
+#define SDL_LoadBMP_IO SDL_LoadBMP_IO_REAL
 #define SDL_LoadFile SDL_LoadFile_REAL
 #define SDL_LoadFile_RW SDL_LoadFile_RW_REAL
 #define SDL_LoadFunction SDL_LoadFunction_REAL
@@ -488,14 +488,14 @@
 #define SDL_QueryTexture SDL_QueryTexture_REAL
 #define SDL_Quit SDL_Quit_REAL
 #define SDL_QuitSubSystem SDL_QuitSubSystem_REAL
-#define SDL_RWFromConstMem SDL_RWFromConstMem_REAL
-#define SDL_RWFromFile SDL_RWFromFile_REAL
-#define SDL_RWFromMem SDL_RWFromMem_REAL
-#define SDL_ReadRW SDL_ReadRW_REAL
-#define SDL_SeekRW SDL_SeekRW_REAL
-#define SDL_SizeRW SDL_SizeRW_REAL
-#define SDL_TellRW SDL_TellRW_REAL
-#define SDL_WriteRW SDL_WriteRW_REAL
+#define SDL_IOFromConstMem SDL_IOFromConstMem_REAL
+#define SDL_IOFromFile SDL_IOFromFile_REAL
+#define SDL_IOFromMem SDL_IOFromMem_REAL
+#define SDL_ReadIO SDL_ReadIO_REAL
+#define SDL_SeekIO SDL_SeekIO_REAL
+#define SDL_SizeIO SDL_SizeIO_REAL
+#define SDL_TellIO SDL_TellIO_REAL
+#define SDL_WriteIO SDL_WriteIO_REAL
 #define SDL_RaiseWindow SDL_RaiseWindow_REAL
 #define SDL_ReadU16BE SDL_ReadU16BE_REAL
 #define SDL_ReadU32BE SDL_ReadU32BE_REAL
@@ -538,7 +538,7 @@
 #define SDL_RunApp SDL_RunApp_REAL
 #define SDL_SIMDGetAlignment SDL_SIMDGetAlignment_REAL
 #define SDL_SaveBMP SDL_SaveBMP_REAL
-#define SDL_SaveBMP_RW SDL_SaveBMP_RW_REAL
+#define SDL_SaveBMP_IO SDL_SaveBMP_IO_REAL
 #define SDL_ScreenKeyboardShown SDL_ScreenKeyboardShown_REAL
 #define SDL_ScreenSaverEnabled SDL_ScreenSaverEnabled_REAL
 #define SDL_SendGamepadEffect SDL_SendGamepadEffect_REAL
@@ -864,7 +864,7 @@
 #define SDL_SetAudioStreamPutCallback SDL_SetAudioStreamPutCallback_REAL
 #define SDL_DestroyAudioStream SDL_DestroyAudioStream_REAL
 #define SDL_OpenAudioDeviceStream SDL_OpenAudioDeviceStream_REAL
-#define SDL_LoadWAV_RW SDL_LoadWAV_RW_REAL
+#define SDL_LoadWAV_IO SDL_LoadWAV_IO_REAL
 #define SDL_LoadWAV SDL_LoadWAV_REAL
 #define SDL_MixAudioFormat SDL_MixAudioFormat_REAL
 #define SDL_ConvertAudioSamples SDL_ConvertAudioSamples_REAL
@@ -909,8 +909,8 @@
 #define SDL_GetWindowProperties SDL_GetWindowProperties_REAL
 #define SDL_ClearProperty SDL_ClearProperty_REAL
 #define SDL_EnterAppMainCallbacks SDL_EnterAppMainCallbacks_REAL
-#define SDL_RWprintf SDL_RWprintf_REAL
-#define SDL_RWvprintf SDL_RWvprintf_REAL
+#define SDL_IOprintf SDL_IOprintf_REAL
+#define SDL_IOvprintf SDL_IOvprintf_REAL
 #define SDL_AllocateEventMemory SDL_AllocateEventMemory_REAL
 #define SDL_GetDisplayProperties SDL_GetDisplayProperties_REAL
 #define SDL_SetPropertyWithCleanup SDL_SetPropertyWithCleanup_REAL
@@ -1001,6 +1001,6 @@
 #define SDL_ShowOpenFileDialog SDL_ShowOpenFileDialog_REAL
 #define SDL_ShowSaveFileDialog SDL_ShowSaveFileDialog_REAL
 #define SDL_ShowOpenFolderDialog SDL_ShowOpenFolderDialog_REAL
-#define SDL_OpenRW SDL_OpenRW_REAL
-#define SDL_CloseRW SDL_CloseRW_REAL
+#define SDL_OpenIO SDL_OpenIO_REAL
+#define SDL_CloseIO SDL_CloseIO_REAL
 #define SDL_GetRWStatus SDL_GetRWStatus_REAL

src/dynapi/SDL_dynapi_procs.h

@@ -43,7 +43,7 @@ SDL_DYNAPI_PROC(int,SDL_asprintf,(char **a, SDL_PRINTF_FORMAT_STRING const char
 SDL_DYNAPI_PROC(int,SDL_snprintf,(SDL_OUT_Z_CAP(b) char *a, size_t b, SDL_PRINTF_FORMAT_STRING const char *c, ...),(a,b,c),return)
 SDL_DYNAPI_PROC(int,SDL_swprintf,(SDL_OUT_Z_CAP(b) wchar_t *a, size_t b, SDL_PRINTF_FORMAT_STRING const wchar_t *c, ...),(a,b,c),return)
 SDL_DYNAPI_PROC(int,SDL_sscanf,(const char *a, SDL_SCANF_FORMAT_STRING const char *b, ...),(a,b),return)
-SDL_DYNAPI_PROC(size_t,SDL_RWprintf,(SDL_RWops *a, SDL_PRINTF_FORMAT_STRING const char *b, ...),(a,b),return)
+SDL_DYNAPI_PROC(size_t,SDL_IOprintf,(SDL_IOStream *a, SDL_PRINTF_FORMAT_STRING const char *b, ...),(a,b),return)
 #endif
 
 #ifdef SDL_CreateThread
@@ -103,7 +103,7 @@ SDL_DYNAPI_PROC(SDL_bool,SDL_IsDeXMode,(void),(),return)
 
 SDL_DYNAPI_PROC(int,SDL_AddEventWatch,(SDL_EventFilter a, void *b),(a,b),return)
 SDL_DYNAPI_PROC(int,SDL_AddGamepadMapping,(const char *a),(a),return)
-SDL_DYNAPI_PROC(int,SDL_AddGamepadMappingsFromRW,(SDL_RWops *a, SDL_bool b),(a,b),return)
+SDL_DYNAPI_PROC(int,SDL_AddGamepadMappingsFromRW,(SDL_IOStream *a, SDL_bool b),(a,b),return)
 SDL_DYNAPI_PROC(int,SDL_AddHintCallback,(const char *a, SDL_HintCallback b, void *c),(a,b,c),return)
 SDL_DYNAPI_PROC(SDL_TimerID,SDL_AddTimer,(Uint32 a, SDL_TimerCallback b, void *c),(a,b,c),return)
 SDL_DYNAPI_PROC(int,SDL_AtomicAdd,(SDL_AtomicInt *a, int b),(a,b),return)
@@ -485,9 +485,9 @@ SDL_DYNAPI_PROC(SDL_bool,SDL_JoystickConnected,(SDL_Joystick *a),(a),return)
 SDL_DYNAPI_PROC(SDL_bool,SDL_JoystickEventsEnabled,(void),(),return)
 SDL_DYNAPI_PROC(SDL_bool,SDL_IsJoystickHaptic,(SDL_Joystick *a),(a),return)
 SDL_DYNAPI_PROC(SDL_Surface*,SDL_LoadBMP,(const char *a),(a),return)
-SDL_DYNAPI_PROC(SDL_Surface*,SDL_LoadBMP_RW,(SDL_RWops *a, SDL_bool b),(a,b),return)
+SDL_DYNAPI_PROC(SDL_Surface*,SDL_LoadBMP_IO,(SDL_IOStream *a, SDL_bool b),(a,b),return)
 SDL_DYNAPI_PROC(void*,SDL_LoadFile,(const char *a, size_t *b),(a,b),return)
-SDL_DYNAPI_PROC(void*,SDL_LoadFile_RW,(SDL_RWops *a, size_t *b, SDL_bool c),(a,b,c),return)
+SDL_DYNAPI_PROC(void*,SDL_LoadFile_RW,(SDL_IOStream *a, size_t *b, SDL_bool c),(a,b,c),return)
 SDL_DYNAPI_PROC(SDL_FunctionPointer,SDL_LoadFunction,(void *a, const char *b),(a,b),return)
 SDL_DYNAPI_PROC(void*,SDL_LoadObject,(const char *a),(a),return)
 SDL_DYNAPI_PROC(void,SDL_LockJoysticks,(void),(),)
@@ -533,22 +533,22 @@ SDL_DYNAPI_PROC(int,SDL_PushEvent,(SDL_Event *a),(a),return)
 SDL_DYNAPI_PROC(int,SDL_QueryTexture,(SDL_Texture *a, Uint32 *b, int *c, int *d, int *e),(a,b,c,d,e),return)
 SDL_DYNAPI_PROC(void,SDL_Quit,(void),(),)
 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(size_t,SDL_ReadRW,(SDL_RWops *a, void *b, size_t c),(a,b,c),return)
-SDL_DYNAPI_PROC(Sint64,SDL_SeekRW,(SDL_RWops *a, Sint64 b, int c),(a,b,c),return)
-SDL_DYNAPI_PROC(Sint64,SDL_SizeRW,(SDL_RWops *a),(a),return)
-SDL_DYNAPI_PROC(Sint64,SDL_TellRW,(SDL_RWops *a),(a),return)
-SDL_DYNAPI_PROC(size_t,SDL_WriteRW,(SDL_RWops *a, const void *b, size_t c),(a,b,c),return)
+SDL_DYNAPI_PROC(SDL_IOStream*,SDL_IOFromConstMem,(const void *a, size_t b),(a,b),return)
+SDL_DYNAPI_PROC(SDL_IOStream*,SDL_IOFromFile,(const char *a, const char *b),(a,b),return)
+SDL_DYNAPI_PROC(SDL_IOStream*,SDL_IOFromMem,(void *a, size_t b),(a,b),return)
+SDL_DYNAPI_PROC(size_t,SDL_ReadIO,(SDL_IOStream *a, void *b, size_t c),(a,b,c),return)
+SDL_DYNAPI_PROC(Sint64,SDL_SeekIO,(SDL_IOStream *a, Sint64 b, int c),(a,b,c),return)
+SDL_DYNAPI_PROC(Sint64,SDL_SizeIO,(SDL_IOStream *a),(a),return)
+SDL_DYNAPI_PROC(Sint64,SDL_TellIO,(SDL_IOStream *a),(a),return)
+SDL_DYNAPI_PROC(size_t,SDL_WriteIO,(SDL_IOStream *a, const void *b, size_t c),(a,b,c),return)
 SDL_DYNAPI_PROC(int,SDL_RaiseWindow,(SDL_Window *a),(a),return)
-SDL_DYNAPI_PROC(SDL_bool,SDL_ReadU16BE,(SDL_RWops *a, Uint16 *b),(a,b),return)
-SDL_DYNAPI_PROC(SDL_bool,SDL_ReadU32BE,(SDL_RWops *a, Uint32 *b),(a,b),return)
-SDL_DYNAPI_PROC(SDL_bool,SDL_ReadU64BE,(SDL_RWops *a, Uint64 *b),(a,b),return)
-SDL_DYNAPI_PROC(SDL_bool,SDL_ReadU16LE,(SDL_RWops *a, Uint16 *b),(a,b),return)
-SDL_DYNAPI_PROC(SDL_bool,SDL_ReadU32LE,(SDL_RWops *a, Uint32 *b),(a,b),return)
-SDL_DYNAPI_PROC(SDL_bool,SDL_ReadU64LE,(SDL_RWops *a, Uint64 *b),(a,b),return)
-SDL_DYNAPI_PROC(SDL_bool,SDL_ReadU8,(SDL_RWops *a, Uint8 *b),(a,b),return)
+SDL_DYNAPI_PROC(SDL_bool,SDL_ReadU16BE,(SDL_IOStream *a, Uint16 *b),(a,b),return)
+SDL_DYNAPI_PROC(SDL_bool,SDL_ReadU32BE,(SDL_IOStream *a, Uint32 *b),(a,b),return)
+SDL_DYNAPI_PROC(SDL_bool,SDL_ReadU64BE,(SDL_IOStream *a, Uint64 *b),(a,b),return)
+SDL_DYNAPI_PROC(SDL_bool,SDL_ReadU16LE,(SDL_IOStream *a, Uint16 *b),(a,b),return)
+SDL_DYNAPI_PROC(SDL_bool,SDL_ReadU32LE,(SDL_IOStream *a, Uint32 *b),(a,b),return)
+SDL_DYNAPI_PROC(SDL_bool,SDL_ReadU64LE,(SDL_IOStream *a, Uint64 *b),(a,b),return)
+SDL_DYNAPI_PROC(SDL_bool,SDL_ReadU8,(SDL_IOStream *a, Uint8 *b),(a,b),return)
 SDL_DYNAPI_PROC(Uint32,SDL_RegisterEvents,(int a),(a),return)
 SDL_DYNAPI_PROC(SDL_bool,SDL_RemoveTimer,(SDL_TimerID a),(a),return)
 SDL_DYNAPI_PROC(int,SDL_RenderClear,(SDL_Renderer *a),(a),return)
@@ -582,7 +582,7 @@ SDL_DYNAPI_PROC(int,SDL_RumbleJoystickTriggers,(SDL_Joystick *a, Uint16 b, Uint1
 SDL_DYNAPI_PROC(int,SDL_RunApp,(int a, char *b[], SDL_main_func c, void *d),(a,b,c,d),return)
 SDL_DYNAPI_PROC(size_t,SDL_SIMDGetAlignment,(void),(),return)
 SDL_DYNAPI_PROC(int,SDL_SaveBMP,(SDL_Surface *a, const char *b),(a,b),return)
-SDL_DYNAPI_PROC(int,SDL_SaveBMP_RW,(SDL_Surface *a, SDL_RWops *b, SDL_bool c),(a,b,c),return)
+SDL_DYNAPI_PROC(int,SDL_SaveBMP_IO,(SDL_Surface *a, SDL_IOStream *b, SDL_bool c),(a,b,c),return)
 SDL_DYNAPI_PROC(SDL_bool,SDL_ScreenKeyboardShown,(SDL_Window *a),(a),return)
 SDL_DYNAPI_PROC(SDL_bool,SDL_ScreenSaverEnabled,(void),(),return)
 SDL_DYNAPI_PROC(int,SDL_SendGamepadEffect,(SDL_Gamepad *a, const void *b, int c),(a,b,c),return)
@@ -699,13 +699,13 @@ SDL_DYNAPI_PROC(void,SDL_WaitThread,(SDL_Thread *a, int *b),(a,b),)
 SDL_DYNAPI_PROC(int,SDL_WarpMouseGlobal,(float a, float b),(a,b),return)
 SDL_DYNAPI_PROC(void,SDL_WarpMouseInWindow,(SDL_Window *a, float b, float c),(a,b,c),)
 SDL_DYNAPI_PROC(Uint32,SDL_WasInit,(Uint32 a),(a),return)
-SDL_DYNAPI_PROC(SDL_bool,SDL_WriteU16BE,(SDL_RWops *a, Uint16 b),(a,b),return)
-SDL_DYNAPI_PROC(SDL_bool,SDL_WriteU32BE,(SDL_RWops *a, Uint32 b),(a,b),return)
-SDL_DYNAPI_PROC(SDL_bool,SDL_WriteU64BE,(SDL_RWops *a, Uint64 b),(a,b),return)
-SDL_DYNAPI_PROC(SDL_bool,SDL_WriteU16LE,(SDL_RWops *a, Uint16 b),(a,b),return)
-SDL_DYNAPI_PROC(SDL_bool,SDL_WriteU32LE,(SDL_RWops *a, Uint32 b),(a,b),return)
-SDL_DYNAPI_PROC(SDL_bool,SDL_WriteU64LE,(SDL_RWops *a, Uint64 b),(a,b),return)
-SDL_DYNAPI_PROC(SDL_bool,SDL_WriteU8,(SDL_RWops *a, Uint8 b),(a,b),return)
+SDL_DYNAPI_PROC(SDL_bool,SDL_WriteU16BE,(SDL_IOStream *a, Uint16 b),(a,b),return)
+SDL_DYNAPI_PROC(SDL_bool,SDL_WriteU32BE,(SDL_IOStream *a, Uint32 b),(a,b),return)
+SDL_DYNAPI_PROC(SDL_bool,SDL_WriteU64BE,(SDL_IOStream *a, Uint64 b),(a,b),return)
+SDL_DYNAPI_PROC(SDL_bool,SDL_WriteU16LE,(SDL_IOStream *a, Uint16 b),(a,b),return)
+SDL_DYNAPI_PROC(SDL_bool,SDL_WriteU32LE,(SDL_IOStream *a, Uint32 b),(a,b),return)
+SDL_DYNAPI_PROC(SDL_bool,SDL_WriteU64LE,(SDL_IOStream *a, Uint64 b),(a,b),return)
+SDL_DYNAPI_PROC(SDL_bool,SDL_WriteU8,(SDL_IOStream *a, Uint8 b),(a,b),return)
 SDL_DYNAPI_PROC(int,SDL_abs,(int a),(a),return)
 SDL_DYNAPI_PROC(double,SDL_acos,(double a),(a),return)
 SDL_DYNAPI_PROC(float,SDL_acosf,(float a),(a),return)
@@ -896,7 +896,7 @@ SDL_DYNAPI_PROC(int,SDL_SetAudioStreamGetCallback,(SDL_AudioStream *a, SDL_Audio
 SDL_DYNAPI_PROC(int,SDL_SetAudioStreamPutCallback,(SDL_AudioStream *a, SDL_AudioStreamCallback b, void *c),(a,b,c),return)
 SDL_DYNAPI_PROC(void,SDL_DestroyAudioStream,(SDL_AudioStream *a),(a),)
 SDL_DYNAPI_PROC(SDL_AudioStream*,SDL_OpenAudioDeviceStream,(SDL_AudioDeviceID a, const SDL_AudioSpec *b, SDL_AudioStreamCallback c, void *d),(a,b,c,d),return)
-SDL_DYNAPI_PROC(int,SDL_LoadWAV_RW,(SDL_RWops *a, SDL_bool b, SDL_AudioSpec *c, Uint8 **d, Uint32 *e),(a,b,c,d,e),return)
+SDL_DYNAPI_PROC(int,SDL_LoadWAV_IO,(SDL_IOStream *a, SDL_bool b, SDL_AudioSpec *c, Uint8 **d, Uint32 *e),(a,b,c,d,e),return)
 SDL_DYNAPI_PROC(int,SDL_LoadWAV,(const char *a, SDL_AudioSpec *b, Uint8 **c, Uint32 *d),(a,b,c,d),return)
 SDL_DYNAPI_PROC(int,SDL_MixAudioFormat,(Uint8 *a, const Uint8 *b, SDL_AudioFormat c, Uint32 d, int e),(a,b,c,d,e),return)
 SDL_DYNAPI_PROC(int,SDL_ConvertAudioSamples,(const SDL_AudioSpec *a, const Uint8 *b, int c, const SDL_AudioSpec *d, Uint8 **e, int *f),(a,b,c,d,e,f),return)
@@ -906,18 +906,18 @@ SDL_DYNAPI_PROC(int,SDL_ResumeAudioDevice,(SDL_AudioDeviceID a),(a),return)
 SDL_DYNAPI_PROC(SDL_bool,SDL_AudioDevicePaused,(SDL_AudioDeviceID a),(a),return)
 SDL_DYNAPI_PROC(SDL_AudioDeviceID,SDL_GetAudioStreamDevice,(SDL_AudioStream *a),(a),return)
 SDL_DYNAPI_PROC(int,SDL_ShowWindowSystemMenu,(SDL_Window *a, int b, int c),(a,b,c),return)
-SDL_DYNAPI_PROC(SDL_bool,SDL_ReadS16LE,(SDL_RWops *a, Sint16 *b),(a,b),return)
-SDL_DYNAPI_PROC(SDL_bool,SDL_ReadS16BE,(SDL_RWops *a, Sint16 *b),(a,b),return)
-SDL_DYNAPI_PROC(SDL_bool,SDL_ReadS32LE,(SDL_RWops *a, Sint32 *b),(a,b),return)
-SDL_DYNAPI_PROC(SDL_bool,SDL_ReadS32BE,(SDL_RWops *a, Sint32 *b),(a,b),return)
-SDL_DYNAPI_PROC(SDL_bool,SDL_ReadS64LE,(SDL_RWops *a, Sint64 *b),(a,b),return)
-SDL_DYNAPI_PROC(SDL_bool,SDL_ReadS64BE,(SDL_RWops *a, Sint64 *b),(a,b),return)
-SDL_DYNAPI_PROC(SDL_bool,SDL_WriteS16LE,(SDL_RWops *a, Sint16 b),(a,b),return)
-SDL_DYNAPI_PROC(SDL_bool,SDL_WriteS16BE,(SDL_RWops *a, Sint16 b),(a,b),return)
-SDL_DYNAPI_PROC(SDL_bool,SDL_WriteS32LE,(SDL_RWops *a, Sint32 b),(a,b),return)
-SDL_DYNAPI_PROC(SDL_bool,SDL_WriteS32BE,(SDL_RWops *a, Sint32 b),(a,b),return)
-SDL_DYNAPI_PROC(SDL_bool,SDL_WriteS64LE,(SDL_RWops *a, Sint64 b),(a,b),return)
-SDL_DYNAPI_PROC(SDL_bool,SDL_WriteS64BE,(SDL_RWops *a, Sint64 b),(a,b),return)
+SDL_DYNAPI_PROC(SDL_bool,SDL_ReadS16LE,(SDL_IOStream *a, Sint16 *b),(a,b),return)
+SDL_DYNAPI_PROC(SDL_bool,SDL_ReadS16BE,(SDL_IOStream *a, Sint16 *b),(a,b),return)
+SDL_DYNAPI_PROC(SDL_bool,SDL_ReadS32LE,(SDL_IOStream *a, Sint32 *b),(a,b),return)
+SDL_DYNAPI_PROC(SDL_bool,SDL_ReadS32BE,(SDL_IOStream *a, Sint32 *b),(a,b),return)
+SDL_DYNAPI_PROC(SDL_bool,SDL_ReadS64LE,(SDL_IOStream *a, Sint64 *b),(a,b),return)
+SDL_DYNAPI_PROC(SDL_bool,SDL_ReadS64BE,(SDL_IOStream *a, Sint64 *b),(a,b),return)
+SDL_DYNAPI_PROC(SDL_bool,SDL_WriteS16LE,(SDL_IOStream *a, Sint16 b),(a,b),return)
+SDL_DYNAPI_PROC(SDL_bool,SDL_WriteS16BE,(SDL_IOStream *a, Sint16 b),(a,b),return)
+SDL_DYNAPI_PROC(SDL_bool,SDL_WriteS32LE,(SDL_IOStream *a, Sint32 b),(a,b),return)
+SDL_DYNAPI_PROC(SDL_bool,SDL_WriteS32BE,(SDL_IOStream *a, Sint32 b),(a,b),return)
+SDL_DYNAPI_PROC(SDL_bool,SDL_WriteS64LE,(SDL_IOStream *a, Sint64 b),(a,b),return)
+SDL_DYNAPI_PROC(SDL_bool,SDL_WriteS64BE,(SDL_IOStream *a, Sint64 b),(a,b),return)
 
 SDL_DYNAPI_PROC(int,SDL_GDKGetDefaultUser,(XUserHandle *a),(a),return)
 
@@ -937,13 +937,13 @@ SDL_DYNAPI_PROC(SDL_PropertiesID,SDL_GetGamepadProperties,(SDL_Gamepad *a),(a),r
 SDL_DYNAPI_PROC(SDL_PropertiesID,SDL_GetJoystickProperties,(SDL_Joystick *a),(a),return)
 SDL_DYNAPI_PROC(SDL_PropertiesID,SDL_GetRendererProperties,(SDL_Renderer *a),(a),return)
 SDL_DYNAPI_PROC(SDL_PropertiesID,SDL_GetTextureProperties,(SDL_Texture *a),(a),return)
-SDL_DYNAPI_PROC(SDL_PropertiesID,SDL_GetRWProperties,(SDL_RWops *a),(a),return)
+SDL_DYNAPI_PROC(SDL_PropertiesID,SDL_GetRWProperties,(SDL_IOStream *a),(a),return)
 SDL_DYNAPI_PROC(SDL_PropertiesID,SDL_GetSensorProperties,(SDL_Sensor *a),(a),return)
 SDL_DYNAPI_PROC(SDL_PropertiesID,SDL_GetSurfaceProperties,(SDL_Surface *a),(a),return)
 SDL_DYNAPI_PROC(SDL_PropertiesID,SDL_GetWindowProperties,(SDL_Window *a),(a),return)
 SDL_DYNAPI_PROC(int,SDL_ClearProperty,(SDL_PropertiesID a, const char *b),(a,b),return)
 SDL_DYNAPI_PROC(int,SDL_EnterAppMainCallbacks,(int a, char *b[], SDL_AppInit_func c, SDL_AppIterate_func d, SDL_AppEvent_func e, SDL_AppQuit_func f),(a,b,c,d,e,f),return)
-SDL_DYNAPI_PROC(size_t,SDL_RWvprintf,(SDL_RWops *a, SDL_PRINTF_FORMAT_STRING const char *b, va_list c),(a,b,c),return)
+SDL_DYNAPI_PROC(size_t,SDL_IOvprintf,(SDL_IOStream *a, SDL_PRINTF_FORMAT_STRING const char *b, va_list c),(a,b,c),return)
 SDL_DYNAPI_PROC(void*,SDL_AllocateEventMemory,(size_t a),(a),return)
 SDL_DYNAPI_PROC(SDL_PropertiesID,SDL_GetDisplayProperties,(SDL_DisplayID a),(a),return)
 SDL_DYNAPI_PROC(int,SDL_SetPropertyWithCleanup,(SDL_PropertiesID a, const char *b, void *c, void (SDLCALL *d)(void *userdata, void *value), void *e),(a,b,c,d,e),return)
@@ -1026,6 +1026,6 @@ SDL_DYNAPI_PROC(int,SDL_GetJoystickBall,(SDL_Joystick *a, int b, int *c, int *d)
 SDL_DYNAPI_PROC(void,SDL_ShowOpenFileDialog,(SDL_DialogFileCallback a, void *b, SDL_Window *c, const SDL_DialogFileFilter *d, const char *e, int f),(a,b,c,d,e,f),)
 SDL_DYNAPI_PROC(void,SDL_ShowSaveFileDialog,(SDL_DialogFileCallback a, void *b, SDL_Window *c, const SDL_DialogFileFilter *d, const char *e),(a,b,c,d,e),)
 SDL_DYNAPI_PROC(void,SDL_ShowOpenFolderDialog,(SDL_DialogFileCallback a, void *b, SDL_Window *c, const char *d, int e),(a,b,c,d,e),)
-SDL_DYNAPI_PROC(SDL_RWops*,SDL_OpenRW,(const SDL_RWopsInterface *a, void *b),(a,b),return)
-SDL_DYNAPI_PROC(int,SDL_CloseRW,(SDL_RWops *a),(a),return)
-SDL_DYNAPI_PROC(SDL_RWopsStatus,SDL_GetRWStatus,(SDL_RWops *a),(a),return)
+SDL_DYNAPI_PROC(SDL_IOStream*,SDL_OpenIO,(const SDL_IOStreamInterface *a, void *b),(a,b),return)
+SDL_DYNAPI_PROC(int,SDL_CloseIO,(SDL_IOStream *a),(a),return)
+SDL_DYNAPI_PROC(SDL_IOStatus,SDL_GetRWStatus,(SDL_IOStream *a),(a),return)

src/file/SDL_rwops.c

@@ -36,11 +36,11 @@
    data sources.  It can easily be extended to files, memory, etc.
 */
 
-struct SDL_RWops
+struct SDL_IOStream
 {
-    SDL_RWopsInterface iface;
+    SDL_IOStreamInterface iface;
     void *userdata;
-    SDL_RWopsStatus status;
+    SDL_IOStatus status;
     SDL_PropertiesID props;
 };
 
@@ -59,14 +59,14 @@ struct SDL_RWops
 
 #if defined(SDL_PLATFORM_WIN32) || defined(SDL_PLATFORM_GDK) || defined(SDL_PLATFORM_WINRT)
 
-typedef struct RWopsWindowsData
+typedef struct IOStreamWindowsData
 {
     SDL_bool append;
     HANDLE h;
     void *data;
     size_t size;
     size_t left;
-} RWopsWindowsData;
+} IOStreamWindowsData;
 
 
 /* Functions to read/write Win32 API file pointers */
@@ -76,7 +76,7 @@ typedef struct RWopsWindowsData
 
 #define READAHEAD_BUFFER_SIZE 1024
 
-static int SDLCALL windows_file_open(RWopsWindowsData *rwopsdata, const char *filename, const char *mode)
+static int SDLCALL windows_file_open(IOStreamWindowsData *iodata, const char *filename, const char *mode)
 {
 #if !defined(SDL_PLATFORM_XBOXONE) && !defined(SDL_PLATFORM_XBOXSERIES) && !defined(SDL_PLATFORM_WINRT)
     UINT old_error_mode;
@@ -86,8 +86,8 @@ static int SDLCALL windows_file_open(RWopsWindowsData *rwopsdata, const char *fi
     DWORD must_exist, truncate;
     int a_mode;
 
-    SDL_zerop(rwopsdata);
-    rwopsdata->h = INVALID_HANDLE_VALUE; /* mark this as unusable */
+    SDL_zerop(iodata);
+    iodata->h = INVALID_HANDLE_VALUE; /* mark this as unusable */
 
     /* "r" = reading, file must exist */
     /* "w" = writing, truncate existing, file may not exist */
@@ -107,8 +107,8 @@ static int SDLCALL windows_file_open(RWopsWindowsData *rwopsdata, const char *fi
     }
     /* failed (invalid call) */
 
-    rwopsdata->data = (char *)SDL_malloc(READAHEAD_BUFFER_SIZE);
-    if (!rwopsdata->data) {
+    iodata->data = (char *)SDL_malloc(READAHEAD_BUFFER_SIZE);
+    if (!iodata->data) {
         return -1;
     }
 #if !defined(SDL_PLATFORM_XBOXONE) && !defined(SDL_PLATFORM_XBOXSERIES) && !defined(SDL_PLATFORM_WINRT)
@@ -147,23 +147,23 @@ static int SDLCALL windows_file_open(RWopsWindowsData *rwopsdata, const char *fi
 #endif
 
     if (h == INVALID_HANDLE_VALUE) {
-        SDL_free(rwopsdata->data);
-        rwopsdata->data = NULL;
+        SDL_free(iodata->data);
+        iodata->data = NULL;
         SDL_SetError("Couldn't open %s", filename);
         return -2; /* failed (CreateFile) */
     }
-    rwopsdata->h = h;
-    rwopsdata->append = a_mode ? SDL_TRUE : SDL_FALSE;
+    iodata->h = h;
+    iodata->append = a_mode ? SDL_TRUE : SDL_FALSE;
 
     return 0; /* ok */
 }
 
 static Sint64 SDLCALL windows_file_size(void *userdata)
 {
-    RWopsWindowsData *rwopsdata = (RWopsWindowsData *) userdata;
+    IOStreamWindowsData *iodata = (IOStreamWindowsData *) userdata;
     LARGE_INTEGER size;
 
-    if (!GetFileSizeEx(rwopsdata->h, &size)) {
+    if (!GetFileSizeEx(iodata->h, &size)) {
         return WIN_SetError("windows_file_size");
     }
 
@@ -172,24 +172,24 @@ static Sint64 SDLCALL windows_file_size(void *userdata)
 
 static Sint64 SDLCALL windows_file_seek(void *userdata, Sint64 offset, int whence)
 {
-    RWopsWindowsData *rwopsdata = (RWopsWindowsData *) userdata;
+    IOStreamWindowsData *iodata = (IOStreamWindowsData *) userdata;
     DWORD windowswhence;
     LARGE_INTEGER windowsoffset;
 
     // FIXME: We may be able to satisfy the seek within buffered data
-    if ((whence == SDL_RW_SEEK_CUR) && (rwopsdata->left)) {
-        offset -= rwopsdata->left;
+    if ((whence == SDL_IO_SEEK_CUR) && (iodata->left)) {
+        offset -= iodata->left;
     }
-    rwopsdata->left = 0;
+    iodata->left = 0;
 
     switch (whence) {
-    case SDL_RW_SEEK_SET:
+    case SDL_IO_SEEK_SET:
         windowswhence = FILE_BEGIN;
         break;
-    case SDL_RW_SEEK_CUR:
+    case SDL_IO_SEEK_CUR:
         windowswhence = FILE_CURRENT;
         break;
-    case SDL_RW_SEEK_END:
+    case SDL_IO_SEEK_END:
         windowswhence = FILE_END;
         break;
     default:
@@ -197,27 +197,27 @@ static Sint64 SDLCALL windows_file_seek(void *userdata, Sint64 offset, int whenc
     }
 
     windowsoffset.QuadPart = offset;
-    if (!SetFilePointerEx(rwopsdata->h, windowsoffset, &windowsoffset, windowswhence)) {
+    if (!SetFilePointerEx(iodata->h, windowsoffset, &windowsoffset, windowswhence)) {
         return WIN_SetError("windows_file_seek");
     }
     return windowsoffset.QuadPart;
 }
 
-static size_t SDLCALL windows_file_read(void *userdata, void *ptr, size_t size, SDL_RWopsStatus *status)
+static size_t SDLCALL windows_file_read(void *userdata, void *ptr, size_t size, SDL_IOStatus *status)
 {
-    RWopsWindowsData *rwopsdata = (RWopsWindowsData *) userdata;
+    IOStreamWindowsData *iodata = (IOStreamWindowsData *) userdata;
     size_t total_need = size;
     size_t total_read = 0;
     size_t read_ahead;
     DWORD bytes;
 
-    if (rwopsdata->left > 0) {
-        void *data = (char *)rwopsdata->data +
-                     rwopsdata->size -
-                     rwopsdata->left;
-        read_ahead = SDL_min(total_need, rwopsdata->left);
+    if (iodata->left > 0) {
+        void *data = (char *)iodata->data +
+                     iodata->size -
+                     iodata->left;
+        read_ahead = SDL_min(total_need, iodata->left);
         SDL_memcpy(ptr, data, read_ahead);
-        rwopsdata->left -= read_ahead;
+        iodata->left -= read_ahead;
 
         if (read_ahead == total_need) {
             return size;
@@ -228,17 +228,17 @@ static size_t SDLCALL windows_file_read(void *userdata, void *ptr, size_t size,
     }
 
     if (total_need < READAHEAD_BUFFER_SIZE) {
-        if (!ReadFile(rwopsdata->h, rwopsdata->data, READAHEAD_BUFFER_SIZE, &bytes, NULL)) {
+        if (!ReadFile(iodata->h, iodata->data, READAHEAD_BUFFER_SIZE, &bytes, NULL)) {
             SDL_Error(SDL_EFREAD);
             return 0;
         }
         read_ahead = SDL_min(total_need, bytes);
-        SDL_memcpy(ptr, rwopsdata->data, read_ahead);
-        rwopsdata->size = bytes;
-        rwopsdata->left = bytes - read_ahead;
+        SDL_memcpy(ptr, iodata->data, read_ahead);
+        iodata->size = bytes;
+        iodata->left = bytes - read_ahead;
         total_read += read_ahead;
     } else {
-        if (!ReadFile(rwopsdata->h, ptr, (DWORD)total_need, &bytes, NULL)) {
+        if (!ReadFile(iodata->h, ptr, (DWORD)total_need, &bytes, NULL)) {
             SDL_Error(SDL_EFREAD);
             return 0;
         }
@@ -247,31 +247,31 @@ static size_t SDLCALL windows_file_read(void *userdata, void *ptr, size_t size,
     return total_read;
 }
 
-static size_t SDLCALL windows_file_write(void *userdata, const void *ptr, size_t size, SDL_RWopsStatus *status)
+static size_t SDLCALL windows_file_write(void *userdata, const void *ptr, size_t size, SDL_IOStatus *status)
 {
-    RWopsWindowsData *rwopsdata = (RWopsWindowsData *) userdata;
+    IOStreamWindowsData *iodata = (IOStreamWindowsData *) userdata;
     const size_t total_bytes = size;
     DWORD bytes;
 
-    if (rwopsdata->left) {
-        if (!SetFilePointer(rwopsdata->h, -(LONG)rwopsdata->left, NULL, FILE_CURRENT)) {
+    if (iodata->left) {
+        if (!SetFilePointer(iodata->h, -(LONG)iodata->left, NULL, FILE_CURRENT)) {
             SDL_Error(SDL_EFSEEK);
             return 0;
         }
-        rwopsdata->left = 0;
+        iodata->left = 0;
     }
 
     /* if in append mode, we must go to the EOF before write */
-    if (rwopsdata->append) {
+    if (iodata->append) {
         LARGE_INTEGER windowsoffset;
         windowsoffset.QuadPart = 0;
-        if (!SetFilePointerEx(rwopsdata->h, windowsoffset, &windowsoffset, FILE_END)) {
+        if (!SetFilePointerEx(iodata->h, windowsoffset, &windowsoffset, FILE_END)) {
             SDL_Error(SDL_EFSEEK);
             return 0;
         }
     }
 
-    if (!WriteFile(rwopsdata->h, ptr, (DWORD)total_bytes, &bytes, NULL)) {
+    if (!WriteFile(iodata->h, ptr, (DWORD)total_bytes, &bytes, NULL)) {
         SDL_Error(SDL_EFWRITE);
         return 0;
     }
@@ -281,13 +281,13 @@ static size_t SDLCALL windows_file_write(void *userdata, const void *ptr, size_t
 
 static int SDLCALL windows_file_close(void *userdata)
 {
-    RWopsWindowsData *rwopsdata = (RWopsWindowsData *) userdata;
-    if (rwopsdata->h != INVALID_HANDLE_VALUE) {
-        CloseHandle(rwopsdata->h);
-        rwopsdata->h = INVALID_HANDLE_VALUE; /* to be sure */
+    IOStreamWindowsData *iodata = (IOStreamWindowsData *) userdata;
+    if (iodata->h != INVALID_HANDLE_VALUE) {
+        CloseHandle(iodata->h);
+        iodata->h = INVALID_HANDLE_VALUE; /* to be sure */
     }
-    SDL_free(rwopsdata->data);
-    SDL_free(rwopsdata);
+    SDL_free(iodata->data);
+    SDL_free(iodata);
     return 0;
 }
 #endif /* defined(SDL_PLATFORM_WIN32) || defined(SDL_PLATFORM_GDK) */
@@ -296,11 +296,11 @@ static int SDLCALL windows_file_close(void *userdata)
 
 /* Functions to read/write stdio file pointers. Not used for windows. */
 
-typedef struct RWopsStdioData
+typedef struct IOStreamStdioData
 {
     FILE *fp;
     SDL_bool autoclose;
-} RWopsStdioData;
+} IOStreamStdioData;
 
 #ifdef HAVE_FOPEN64
 #define fopen fopen64
@@ -340,17 +340,17 @@ typedef struct RWopsStdioData
 
 static Sint64 SDLCALL stdio_seek(void *userdata, Sint64 offset, int whence)
 {
-    RWopsStdioData *rwopsdata = (RWopsStdioData *) userdata;
+    IOStreamStdioData *iodata = (IOStreamStdioData *) userdata;
     int stdiowhence;
 
     switch (whence) {
-    case SDL_RW_SEEK_SET:
+    case SDL_IO_SEEK_SET:
         stdiowhence = SEEK_SET;
         break;
-    case SDL_RW_SEEK_CUR:
+    case SDL_IO_SEEK_CUR:
         stdiowhence = SEEK_CUR;
         break;
-    case SDL_RW_SEEK_END:
+    case SDL_IO_SEEK_END:
         stdiowhence = SEEK_END;
         break;
     default:
@@ -363,8 +363,8 @@ static Sint64 SDLCALL stdio_seek(void *userdata, Sint64 offset, int whence)
     }
 #endif
 
-    if (fseek(rwopsdata->fp, (fseek_off_t)offset, stdiowhence) == 0) {
-        const Sint64 pos = ftell(rwopsdata->fp);
+    if (fseek(iodata->fp, (fseek_off_t)offset, stdiowhence) == 0) {
+        const Sint64 pos = ftell(iodata->fp);
         if (pos < 0) {
             return SDL_SetError("Couldn't get stream offset");
         }
@@ -373,21 +373,21 @@ static Sint64 SDLCALL stdio_seek(void *userdata, Sint64 offset, int whence)
     return SDL_Error(SDL_EFSEEK);
 }
 
-static size_t SDLCALL stdio_read(void *userdata, void *ptr, size_t size, SDL_RWopsStatus *status)
+static size_t SDLCALL stdio_read(void *userdata, void *ptr, size_t size, SDL_IOStatus *status)
 {
-    RWopsStdioData *rwopsdata = (RWopsStdioData *) userdata;
-    const size_t bytes = fread(ptr, 1, size, rwopsdata->fp);
-    if (bytes == 0 && ferror(rwopsdata->fp)) {
+    IOStreamStdioData *iodata = (IOStreamStdioData *) userdata;
+    const size_t bytes = fread(ptr, 1, size, iodata->fp);
+    if (bytes == 0 && ferror(iodata->fp)) {
         SDL_Error(SDL_EFREAD);
     }
     return bytes;
 }
 
-static size_t SDLCALL stdio_write(void *userdata, const void *ptr, size_t size, SDL_RWopsStatus *status)
+static size_t SDLCALL stdio_write(void *userdata, const void *ptr, size_t size, SDL_IOStatus *status)
 {
-    RWopsStdioData *rwopsdata = (RWopsStdioData *) userdata;
-    const size_t bytes = fwrite(ptr, 1, size, rwopsdata->fp);
-    if (bytes == 0 && ferror(rwopsdata->fp)) {
+    IOStreamStdioData *iodata = (IOStreamStdioData *) userdata;
+    const size_t bytes = fwrite(ptr, 1, size, iodata->fp);
+    if (bytes == 0 && ferror(iodata->fp)) {
         SDL_Error(SDL_EFWRITE);
     }
     return bytes;
@@ -395,117 +395,117 @@ static size_t SDLCALL stdio_write(void *userdata, const void *ptr, size_t size,
 
 static int SDLCALL stdio_close(void *userdata)
 {
-    RWopsStdioData *rwopsdata = (RWopsStdioData *) userdata;
+    IOStreamStdioData *iodata = (IOStreamStdioData *) userdata;
     int status = 0;
-    if (rwopsdata->autoclose) {
-        if (fclose(rwopsdata->fp) != 0) {
+    if (iodata->autoclose) {
+        if (fclose(iodata->fp) != 0) {
             status = SDL_Error(SDL_EFWRITE);
         }
     }
-    SDL_free(rwopsdata);
+    SDL_free(iodata);
     return status;
 }
 
-static SDL_RWops *SDL_RWFromFP(FILE *fp, SDL_bool autoclose)
+static SDL_IOStream *SDL_IOFromFP(FILE *fp, SDL_bool autoclose)
 {
-    RWopsStdioData *rwopsdata = (RWopsStdioData *) SDL_malloc(sizeof (*rwopsdata));
-    if (!rwopsdata) {
+    IOStreamStdioData *iodata = (IOStreamStdioData *) SDL_malloc(sizeof (*iodata));
+    if (!iodata) {
         return NULL;
     }
 
-    SDL_RWopsInterface iface;
+    SDL_IOStreamInterface iface;
     SDL_zero(iface);
-    // There's no stdio_size because SDL_SizeRW emulates it the same way we'd do it for stdio anyhow.
+    // There's no stdio_size because SDL_SizeIO 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;
+    iodata->fp = fp;
+    iodata->autoclose = autoclose;
 
-    SDL_RWops *rwops = SDL_OpenRW(&iface, rwopsdata);
-    if (!rwops) {
-        iface.close(rwopsdata);
+    SDL_IOStream *iostr = SDL_OpenIO(&iface, iodata);
+    if (!iostr) {
+        iface.close(iodata);
     } else {
-        const SDL_PropertiesID props = SDL_GetRWProperties(rwops);
+        const SDL_PropertiesID props = SDL_GetRWProperties(iostr);
         if (props) {
-            SDL_SetProperty(props, SDL_PROP_RWOPS_STDIO_HANDLE_POINTER, fp);
+            SDL_SetProperty(props, SDL_PROP_IOSTREAM_STDIO_HANDLE_POINTER, fp);
         }
     }
 
-    return rwops;
+    return iostr;
 }
 #endif /* !HAVE_STDIO_H && !(SDL_PLATFORM_WIN32 || SDL_PLATFORM_GDK) */
 
 /* Functions to read/write memory pointers */
 
-typedef struct RWopsMemData
+typedef struct IOStreamMemData
 {
     Uint8 *base;
     Uint8 *here;
     Uint8 *stop;
-} RWopsMemData;
+} IOStreamMemData;
 
 static Sint64 SDLCALL mem_size(void *userdata)
 {
-    const RWopsMemData *rwopsdata = (RWopsMemData *) userdata;
-    return (rwopsdata->stop - rwopsdata->base);
+    const IOStreamMemData *iodata = (IOStreamMemData *) userdata;
+    return (iodata->stop - iodata->base);
 }
 
 static Sint64 SDLCALL mem_seek(void *userdata, Sint64 offset, int whence)
 {
-    RWopsMemData *rwopsdata = (RWopsMemData *) userdata;
+    IOStreamMemData *iodata = (IOStreamMemData *) userdata;
     Uint8 *newpos;
 
     switch (whence) {
-    case SDL_RW_SEEK_SET:
-        newpos = rwopsdata->base + offset;
+    case SDL_IO_SEEK_SET:
+        newpos = iodata->base + offset;
         break;
-    case SDL_RW_SEEK_CUR:
-        newpos = rwopsdata->here + offset;
+    case SDL_IO_SEEK_CUR:
+        newpos = iodata->here + offset;
         break;
-    case SDL_RW_SEEK_END:
-        newpos = rwopsdata->stop + offset;
+    case SDL_IO_SEEK_END:
+        newpos = iodata->stop + offset;
         break;
     default:
         return SDL_SetError("Unknown value for 'whence'");
     }
-    if (newpos < rwopsdata->base) {
-        newpos = rwopsdata->base;
+    if (newpos < iodata->base) {
+        newpos = iodata->base;
     }
-    if (newpos > rwopsdata->stop) {
-        newpos = rwopsdata->stop;
+    if (newpos > iodata->stop) {
+        newpos = iodata->stop;
     }
-    rwopsdata->here = newpos;
-    return (Sint64)(rwopsdata->here - rwopsdata->base);
+    iodata->here = newpos;
+    return (Sint64)(iodata->here - iodata->base);
 }
 
 static size_t mem_io(void *userdata, void *dst, const void *src, size_t size)
 {
-    RWopsMemData *rwopsdata = (RWopsMemData *) userdata;
-    const size_t mem_available = (rwopsdata->stop - rwopsdata->here);
+    IOStreamMemData *iodata = (IOStreamMemData *) userdata;
+    const size_t mem_available = (iodata->stop - iodata->here);
     if (size > mem_available) {
         size = mem_available;
     }
     SDL_memcpy(dst, src, size);
-    rwopsdata->here += size;
+    iodata->here += size;
     return size;
 }
 
-static size_t SDLCALL mem_read(void *userdata, void *ptr, size_t size, SDL_RWopsStatus *status)
+static size_t SDLCALL mem_read(void *userdata, void *ptr, size_t size, SDL_IOStatus *status)
 {
-    const RWopsMemData *rwopsdata = (RWopsMemData *) userdata;
-    return mem_io(userdata, ptr, rwopsdata->here, size);
+    const IOStreamMemData *iodata = (IOStreamMemData *) userdata;
+    return mem_io(userdata, ptr, iodata->here, size);
 }
 
-static size_t SDLCALL mem_write(void *userdata, const void *ptr, size_t size, SDL_RWopsStatus *status)
+static size_t SDLCALL mem_write(void *userdata, const void *ptr, size_t size, SDL_IOStatus *status)
 {
-    const RWopsMemData *rwopsdata = (RWopsMemData *) userdata;
-    return mem_io(userdata, rwopsdata->here, ptr, size);
+    const IOStreamMemData *iodata = (IOStreamMemData *) userdata;
+    return mem_io(userdata, iodata->here, ptr, size);
 }
 
-/* Functions to create SDL_RWops structures from various data sources */
+/* Functions to create SDL_IOStream structures from various data sources */
 
 #if defined(HAVE_STDIO_H) && !defined(SDL_PLATFORM_WINDOWS)
 static SDL_bool IsRegularFileOrPipe(FILE *f)
@@ -526,11 +526,11 @@ static SDL_bool IsRegularFileOrPipe(FILE *f)
 }
 #endif
 
-SDL_RWops *SDL_RWFromFile(const char *file, const char *mode)
+SDL_IOStream *SDL_IOFromFile(const char *file, const char *mode)
 {
-    SDL_RWops *rwops = NULL;
+    SDL_IOStream *iostr = NULL;
     if (!file || !*file || !mode || !*mode) {
-        SDL_SetError("SDL_RWFromFile(): No file or no mode specified");
+        SDL_SetError("SDL_IOFromFile(): No file or no mode specified");
         return NULL;
     }
 #ifdef SDL_PLATFORM_ANDROID
@@ -544,7 +544,7 @@ SDL_RWops *SDL_RWFromFile(const char *file, const char *mode)
                 SDL_SetError("%s is not a regular file or pipe", file);
                 return NULL;
             }
-            return SDL_RWFromFP(fp, 1);
+            return SDL_IOFromFP(fp, 1);
         }
     } else {
         /* Try opening it from internal storage if it's a relative path */
@@ -561,7 +561,7 @@ SDL_RWops *SDL_RWFromFile(const char *file, const char *mode)
                     SDL_SetError("%s is not a regular file or pipe", path);
                     return NULL;
                 }
-                return SDL_RWFromFP(fp, 1);
+                return SDL_IOFromFP(fp, 1);
             }
         }
     }
@@ -569,13 +569,13 @@ SDL_RWops *SDL_RWFromFile(const char *file, const char *mode)
 
     /* Try to open the file from the asset system */
 
-    void *rwopsdata = NULL;
-    if (Android_JNI_FileOpen(&rwopsdata, file, mode) < 0) {
-        SDL_CloseRW(rwops);
+    void *iodata = NULL;
+    if (Android_JNI_FileOpen(&iodata, file, mode) < 0) {
+        SDL_CloseIO(iostr);
         return NULL;
     }
 
-    SDL_RWopsInterface iface;
+    SDL_IOStreamInterface iface;
     SDL_zero(iface);
     iface.size = Android_JNI_FileSize;
     iface.seek = Android_JNI_FileSeek;
@@ -583,31 +583,31 @@ SDL_RWops *SDL_RWFromFile(const char *file, const char *mode)
     iface.write = Android_JNI_FileWrite;
     iface.close = Android_JNI_FileClose;
 
-    rwops = SDL_OpenRW(&iface, rwopsdata);
-    if (!rwops) {
-        iface.close(rwopsdata);
+    iostr = SDL_OpenIO(&iface, iodata);
+    if (!iostr) {
+        iface.close(iodata);
     } else {
-        const SDL_PropertiesID props = SDL_GetRWProperties(rwops);
+        const SDL_PropertiesID props = SDL_GetRWProperties(iostr);
         if (props) {
-            SDL_SetProperty(props, SDL_PROP_RWOPS_ANDROID_AASSET_POINTER, rwopsdata);
+            SDL_SetProperty(props, SDL_PROP_IOSTREAM_ANDROID_AASSET_POINTER, iodata);
         }
     }
 
-    return rwops;
+    return iostr;
 
 
 #elif defined(SDL_PLATFORM_WIN32) || defined(SDL_PLATFORM_GDK) || defined(SDL_PLATFORM_WINRT)
-    RWopsWindowsData *rwopsdata = (RWopsWindowsData *) SDL_malloc(sizeof (*rwopsdata));
-    if (!rwopsdata) {
+    IOStreamWindowsData *iodata = (IOStreamWindowsData *) SDL_malloc(sizeof (*iodata));
+    if (!iodata) {
         return NULL;
     }
 
-    if (windows_file_open(rwopsdata, file, mode) < 0) {
-        SDL_CloseRW(rwops);
+    if (windows_file_open(iodata, file, mode) < 0) {
+        SDL_CloseIO(iostr);
         return NULL;
     }
 
-    SDL_RWopsInterface iface;
+    SDL_IOStreamInterface iface;
     SDL_zero(iface);
     iface.size = windows_file_size;
     iface.seek = windows_file_seek;
@@ -615,17 +615,17 @@ SDL_RWops *SDL_RWFromFile(const char *file, const char *mode)
     iface.write = windows_file_write;
     iface.close = windows_file_close;
 
-    rwops = SDL_OpenRW(&iface, rwopsdata);
-    if (!rwops) {
-        windows_file_close(rwopsdata);
+    iostr = SDL_OpenIO(&iface, iodata);
+    if (!iostr) {
+        windows_file_close(iodata);
     } else {
-        const SDL_PropertiesID props = SDL_GetRWProperties(rwops);
+        const SDL_PropertiesID props = SDL_GetRWProperties(iostr);
         if (props) {
-            SDL_SetProperty(props, SDL_PROP_RWOPS_WINDOWS_HANDLE_POINTER, rwopsdata->h);
+            SDL_SetProperty(props, SDL_PROP_IOSTREAM_WINDOWS_HANDLE_POINTER, iodata->h);
         }
     }
 
-    return rwops;
+    return iostr;
 
 #elif defined(HAVE_STDIO_H)
     {
@@ -647,7 +647,7 @@ SDL_RWops *SDL_RWFromFile(const char *file, const char *mode)
             fp = NULL;
             SDL_SetError("%s is not a regular file or pipe", file);
         } else {
-            rwops = SDL_RWFromFP(fp, SDL_TRUE);
+            iostr = SDL_IOFromFP(fp, SDL_TRUE);
         }
     }
 
@@ -655,10 +655,10 @@ SDL_RWops *SDL_RWFromFile(const char *file, const char *mode)
     SDL_SetError("SDL not compiled with stdio support");
 #endif /* !HAVE_STDIO_H */
 
-    return rwops;
+    return iostr;
 }
 
-SDL_RWops *SDL_RWFromMem(void *mem, size_t size)
+SDL_IOStream *SDL_IOFromMem(void *mem, size_t size)
 {
     if (!mem) {
         SDL_InvalidParamError("mem");
@@ -668,30 +668,30 @@ SDL_RWops *SDL_RWFromMem(void *mem, size_t size)
         return NULL;
     }
 
-    RWopsMemData *rwopsdata = (RWopsMemData *) SDL_malloc(sizeof (*rwopsdata));
-    if (!rwopsdata) {
+    IOStreamMemData *iodata = (IOStreamMemData *) SDL_malloc(sizeof (*iodata));
+    if (!iodata) {
         return NULL;
     }
 
-    SDL_RWopsInterface iface;
+    SDL_IOStreamInterface 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;
+    iodata->base = (Uint8 *)mem;
+    iodata->here = iodata->base;
+    iodata->stop = iodata->base + size;
 
-    SDL_RWops *rwops = SDL_OpenRW(&iface, rwopsdata);
-    if (!rwops) {
-        SDL_free(rwopsdata);
+    SDL_IOStream *iostr = SDL_OpenIO(&iface, iodata);
+    if (!iostr) {
+        SDL_free(iodata);
     }
-    return rwops;
+    return iostr;
 }
 
-SDL_RWops *SDL_RWFromConstMem(const void *mem, size_t size)
+SDL_IOStream *SDL_IOFromConstMem(const void *mem, size_t size)
 {
     if (!mem) {
         SDL_InvalidParamError("mem");
@@ -701,69 +701,69 @@ SDL_RWops *SDL_RWFromConstMem(const void *mem, size_t size)
         return NULL;
     }
 
-    RWopsMemData *rwopsdata = (RWopsMemData *) SDL_malloc(sizeof (*rwopsdata));
-    if (!rwopsdata) {
+    IOStreamMemData *iodata = (IOStreamMemData *) SDL_malloc(sizeof (*iodata));
+    if (!iodata) {
         return NULL;
     }
 
-    SDL_RWopsInterface iface;
+    SDL_IOStreamInterface 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;
+    iodata->base = (Uint8 *)mem;
+    iodata->here = iodata->base;
+    iodata->stop = iodata->base + size;
 
-    SDL_RWops *rwops = SDL_OpenRW(&iface, rwopsdata);
-    if (!rwops) {
-        SDL_free(rwopsdata);
+    SDL_IOStream *iostr = SDL_OpenIO(&iface, iodata);
+    if (!iostr) {
+        SDL_free(iodata);
     }
-    return rwops;
+    return iostr;
 }
 
-SDL_RWopsStatus SDL_GetRWStatus(SDL_RWops *context)
+SDL_IOStatus SDL_GetRWStatus(SDL_IOStream *context)
 {
     if (!context) {
         SDL_InvalidParamError("context");
-        return SDL_RWOPS_STATUS_ERROR;
+        return SDL_IO_STATUS_ERROR;
     }
     return context->status;
 }
 
 
-SDL_RWops *SDL_OpenRW(const SDL_RWopsInterface *iface, void *userdata)
+SDL_IOStream *SDL_OpenIO(const SDL_IOStreamInterface *iface, void *userdata)
 {
     if (!iface) {
         SDL_InvalidParamError("iface");
         return NULL;
     }
 
-    SDL_RWops *rwops = (SDL_RWops *)SDL_calloc(1, sizeof(*rwops));
-    if (rwops) {
-        SDL_copyp(&rwops->iface, iface);
-        rwops->userdata = userdata;
+    SDL_IOStream *iostr = (SDL_IOStream *)SDL_calloc(1, sizeof(*iostr));
+    if (iostr) {
+        SDL_copyp(&iostr->iface, iface);
+        iostr->userdata = userdata;
     }
-    return rwops;
+    return iostr;
 }
 
-int SDL_CloseRW(SDL_RWops *rwops)
+int SDL_CloseIO(SDL_IOStream *iostr)
 {
     int retval = 0;
-    if (rwops) {
-        if (rwops->iface.close) {
-            retval = rwops->iface.close(rwops->userdata);
+    if (iostr) {
+        if (iostr->iface.close) {
+            retval = iostr->iface.close(iostr->userdata);
         }
-        SDL_DestroyProperties(rwops->props);
-        SDL_free(rwops);
+        SDL_DestroyProperties(iostr->props);
+        SDL_free(iostr);
     }
     return retval;
 }
 
 /* Load all the data from an SDL data stream */
-void *SDL_LoadFile_RW(SDL_RWops *src, size_t *datasize, SDL_bool freesrc)
+void *SDL_LoadFile_RW(SDL_IOStream *src, size_t *datasize, SDL_bool freesrc)
 {
     const int FILE_CHUNK_SIZE = 1024;
     Sint64 size, size_total = 0;
@@ -776,7 +776,7 @@ void *SDL_LoadFile_RW(SDL_RWops *src, size_t *datasize, SDL_bool freesrc)
         goto done;
     }
 
-    size = SDL_SizeRW(src);
+    size = SDL_SizeIO(src);
     if (size < 0) {
         size = FILE_CHUNK_SIZE;
         loading_chunks = SDL_TRUE;
@@ -808,7 +808,7 @@ void *SDL_LoadFile_RW(SDL_RWops *src, size_t *datasize, SDL_bool freesrc)
             }
         }
 
-        size_read = SDL_ReadRW(src, data + size_total, (size_t)(size - size_total));
+        size_read = SDL_ReadIO(src, data + size_total, (size_t)(size - size_total));
         if (size_read > 0) {
             size_total += size_read;
             continue;
@@ -825,17 +825,17 @@ done:
         *datasize = (size_t)size_total;
     }
     if (freesrc && src) {
-        SDL_CloseRW(src);
+        SDL_CloseIO(src);
     }
     return data;
 }
 
 void *SDL_LoadFile(const char *file, size_t *datasize)
 {
-    return SDL_LoadFile_RW(SDL_RWFromFile(file, "rb"), datasize, SDL_TRUE);
+    return SDL_LoadFile_RW(SDL_IOFromFile(file, "rb"), datasize, SDL_TRUE);
 }
 
-SDL_PropertiesID SDL_GetRWProperties(SDL_RWops *context)
+SDL_PropertiesID SDL_GetRWProperties(SDL_IOStream *context)
 {
     if (!context) {
         SDL_InvalidParamError("context");
@@ -848,7 +848,7 @@ SDL_PropertiesID SDL_GetRWProperties(SDL_RWops *context)
     return context->props;
 }
 
-Sint64 SDL_SizeRW(SDL_RWops *context)
+Sint64 SDL_SizeIO(SDL_IOStream *context)
 {
     if (!context) {
         return SDL_InvalidParamError("context");
@@ -856,19 +856,19 @@ Sint64 SDL_SizeRW(SDL_RWops *context)
     if (!context->iface.size) {
         Sint64 pos, size;
 
-        pos = SDL_SeekRW(context, 0, SDL_RW_SEEK_CUR);
+        pos = SDL_SeekIO(context, 0, SDL_IO_SEEK_CUR);
         if (pos < 0) {
             return -1;
         }
-        size = SDL_SeekRW(context, 0, SDL_RW_SEEK_END);
+        size = SDL_SeekIO(context, 0, SDL_IO_SEEK_END);
 
-        SDL_SeekRW(context, pos, SDL_RW_SEEK_SET);
+        SDL_SeekIO(context, pos, SDL_IO_SEEK_SET);
         return size;
     }
     return context->iface.size(context->userdata);
 }
 
-Sint64 SDL_SeekRW(SDL_RWops *context, Sint64 offset, int whence)
+Sint64 SDL_SeekIO(SDL_IOStream *context, Sint64 offset, int whence)
 {
     if (!context) {
         return SDL_InvalidParamError("context");
@@ -878,12 +878,12 @@ Sint64 SDL_SeekRW(SDL_RWops *context, Sint64 offset, int whence)
     return context->iface.seek(context->userdata, offset, whence);
 }
 
-Sint64 SDL_TellRW(SDL_RWops *context)
+Sint64 SDL_TellIO(SDL_IOStream *context)
 {
-    return SDL_SeekRW(context, 0, SDL_RW_SEEK_CUR);
+    return SDL_SeekIO(context, 0, SDL_IO_SEEK_CUR);
 }
 
-size_t SDL_ReadRW(SDL_RWops *context, void *ptr, size_t size)
+size_t SDL_ReadIO(SDL_IOStream *context, void *ptr, size_t size)
 {
     size_t bytes;
 
@@ -891,12 +891,12 @@ size_t SDL_ReadRW(SDL_RWops *context, void *ptr, size_t size)
         SDL_InvalidParamError("context");
         return 0;
     } else if (!context->iface.read) {
-        context->status = SDL_RWOPS_STATUS_WRITEONLY;
+        context->status = SDL_IO_STATUS_WRITEONLY;
         SDL_Unsupported();
         return 0;
     }
 
-    context->status = SDL_RWOPS_STATUS_READY;
+    context->status = SDL_IO_STATUS_READY;
     SDL_ClearError();
 
     if (size == 0) {
@@ -904,17 +904,17 @@ size_t SDL_ReadRW(SDL_RWops *context, void *ptr, size_t size)
     }
 
     bytes = context->iface.read(context->userdata, ptr, size, &context->status);
-    if (bytes == 0 && context->status == SDL_RWOPS_STATUS_READY) {
+    if (bytes == 0 && context->status == SDL_IO_STATUS_READY) {
         if (*SDL_GetError()) {
-            context->status = SDL_RWOPS_STATUS_ERROR;
+            context->status = SDL_IO_STATUS_ERROR;
         } else {
-            context->status = SDL_RWOPS_STATUS_EOF;
+            context->status = SDL_IO_STATUS_EOF;
         }
     }
     return bytes;
 }
 
-size_t SDL_WriteRW(SDL_RWops *context, const void *ptr, size_t size)
+size_t SDL_WriteIO(SDL_IOStream *context, const void *ptr, size_t size)
 {
     size_t bytes;
 
@@ -922,12 +922,12 @@ size_t SDL_WriteRW(SDL_RWops *context, const void *ptr, size_t size)
         SDL_InvalidParamError("context");
         return 0;
     } else if (!context->iface.write) {
-        context->status = SDL_RWOPS_STATUS_READONLY;
+        context->status = SDL_IO_STATUS_READONLY;
         SDL_Unsupported();
         return 0;
     }
 
-    context->status = SDL_RWOPS_STATUS_READY;
+    context->status = SDL_IO_STATUS_READY;
     SDL_ClearError();
 
     if (size == 0) {
@@ -935,13 +935,13 @@ size_t SDL_WriteRW(SDL_RWops *context, const void *ptr, size_t size)
     }
 
     bytes = context->iface.write(context->userdata, ptr, size, &context->status);
-    if ((bytes == 0) && (context->status == SDL_RWOPS_STATUS_READY)) {
-        context->status = SDL_RWOPS_STATUS_ERROR;
+    if ((bytes == 0) && (context->status == SDL_IO_STATUS_READY)) {
+        context->status = SDL_IO_STATUS_ERROR;
     }
     return bytes;
 }
 
-size_t SDL_RWprintf(SDL_RWops *context, SDL_PRINTF_FORMAT_STRING const char *fmt, ...)
+size_t SDL_IOprintf(SDL_IOStream *context, SDL_PRINTF_FORMAT_STRING const char *fmt, ...)
 {
     va_list ap;
     int size;
@@ -955,12 +955,12 @@ size_t SDL_RWprintf(SDL_RWops *context, SDL_PRINTF_FORMAT_STRING const char *fmt
         return 0;
     }
 
-    bytes = SDL_WriteRW(context, string, (size_t)size);
+    bytes = SDL_WriteIO(context, string, (size_t)size);
     SDL_free(string);
     return bytes;
 }
 
-size_t SDL_RWvprintf(SDL_RWops *context, SDL_PRINTF_FORMAT_STRING const char *fmt, va_list ap)
+size_t SDL_IOvprintf(SDL_IOStream *context, SDL_PRINTF_FORMAT_STRING const char *fmt, va_list ap)
 {
     int size;
     char *string;
@@ -971,19 +971,19 @@ size_t SDL_RWvprintf(SDL_RWops *context, SDL_PRINTF_FORMAT_STRING const char *fm
         return 0;
     }
 
-    bytes = SDL_WriteRW(context, string, (size_t)size);
+    bytes = SDL_WriteIO(context, string, (size_t)size);
     SDL_free(string);
     return bytes;
 }
 
 /* Functions for dynamically reading and writing endian-specific values */
 
-SDL_bool SDL_ReadU8(SDL_RWops *src, Uint8 *value)
+SDL_bool SDL_ReadU8(SDL_IOStream *src, Uint8 *value)
 {
     Uint8 data = 0;
     SDL_bool result = SDL_FALSE;
 
-    if (SDL_ReadRW(src, &data, sizeof(data)) == sizeof(data)) {
+    if (SDL_ReadIO(src, &data, sizeof(data)) == sizeof(data)) {
         result = SDL_TRUE;
     }
     if (value) {
@@ -992,12 +992,12 @@ SDL_bool SDL_ReadU8(SDL_RWops *src, Uint8 *value)
     return result;
 }
 
-SDL_bool SDL_ReadU16LE(SDL_RWops *src, Uint16 *value)
+SDL_bool SDL_ReadU16LE(SDL_IOStream *src, Uint16 *value)
 {
     Uint16 data = 0;
     SDL_bool result = SDL_FALSE;
 
-    if (SDL_ReadRW(src, &data, sizeof(data)) == sizeof(data)) {
+    if (SDL_ReadIO(src, &data, sizeof(data)) == sizeof(data)) {
         result = SDL_TRUE;
     }
     if (value) {
@@ -1006,17 +1006,17 @@ SDL_bool SDL_ReadU16LE(SDL_RWops *src, Uint16 *value)
     return result;
 }
 
-SDL_bool SDL_ReadS16LE(SDL_RWops *src, Sint16 *value)
+SDL_bool SDL_ReadS16LE(SDL_IOStream *src, Sint16 *value)
 {
     return SDL_ReadU16LE(src, (Uint16 *)value);
 }
 
-SDL_bool SDL_ReadU16BE(SDL_RWops *src, Uint16 *value)
+SDL_bool SDL_ReadU16BE(SDL_IOStream *src, Uint16 *value)
 {
     Uint16 data = 0;
     SDL_bool result = SDL_FALSE;
 
-    if (SDL_ReadRW(src, &data, sizeof(data)) == sizeof(data)) {
+    if (SDL_ReadIO(src, &data, sizeof(data)) == sizeof(data)) {
         result = SDL_TRUE;
     }
     if (value) {
@@ -1025,17 +1025,17 @@ SDL_bool SDL_ReadU16BE(SDL_RWops *src, Uint16 *value)
     return result;
 }
 
-SDL_bool SDL_ReadS16BE(SDL_RWops *src, Sint16 *value)
+SDL_bool SDL_ReadS16BE(SDL_IOStream *src, Sint16 *value)
 {
     return SDL_ReadU16BE(src, (Uint16 *)value);
 }
 
-SDL_bool SDL_ReadU32LE(SDL_RWops *src, Uint32 *value)
+SDL_bool SDL_ReadU32LE(SDL_IOStream *src, Uint32 *value)
 {
     Uint32 data = 0;
     SDL_bool result = SDL_FALSE;
 
-    if (SDL_ReadRW(src, &data, sizeof(data)) == sizeof(data)) {
+    if (SDL_ReadIO(src, &data, sizeof(data)) == sizeof(data)) {
         result = SDL_TRUE;
     }
     if (value) {
@@ -1044,17 +1044,17 @@ SDL_bool SDL_ReadU32LE(SDL_RWops *src, Uint32 *value)
     return result;
 }
 
-SDL_bool SDL_ReadS32LE(SDL_RWops *src, Sint32 *value)
+SDL_bool SDL_ReadS32LE(SDL_IOStream *src, Sint32 *value)
 {
     return SDL_ReadU32LE(src, (Uint32 *)value);
 }
 
-SDL_bool SDL_ReadU32BE(SDL_RWops *src, Uint32 *value)
+SDL_bool SDL_ReadU32BE(SDL_IOStream *src, Uint32 *value)
 {
     Uint32 data = 0;
     SDL_bool result = SDL_FALSE;
 
-    if (SDL_ReadRW(src, &data, sizeof(data)) == sizeof(data)) {
+    if (SDL_ReadIO(src, &data, sizeof(data)) == sizeof(data)) {
         result = SDL_TRUE;
     }
     if (value) {
@@ -1063,17 +1063,17 @@ SDL_bool SDL_ReadU32BE(SDL_RWops *src, Uint32 *value)
     return result;
 }
 
-SDL_bool SDL_ReadS32BE(SDL_RWops *src, Sint32 *value)
+SDL_bool SDL_ReadS32BE(SDL_IOStream *src, Sint32 *value)
 {
     return SDL_ReadU32BE(src, (Uint32 *)value);
 }
 
-SDL_bool SDL_ReadU64LE(SDL_RWops *src, Uint64 *value)
+SDL_bool SDL_ReadU64LE(SDL_IOStream *src, Uint64 *value)
 {
     Uint64 data = 0;
     SDL_bool result = SDL_FALSE;
 
-    if (SDL_ReadRW(src, &data, sizeof(data)) == sizeof(data)) {
+    if (SDL_ReadIO(src, &data, sizeof(data)) == sizeof(data)) {
         result = SDL_TRUE;
     }
     if (value) {
@@ -1082,17 +1082,17 @@ SDL_bool SDL_ReadU64LE(SDL_RWops *src, Uint64 *value)
     return result;
 }
 
-SDL_bool SDL_ReadS64LE(SDL_RWops *src, Sint64 *value)
+SDL_bool SDL_ReadS64LE(SDL_IOStream *src, Sint64 *value)
 {
     return SDL_ReadU64LE(src, (Uint64 *)value);
 }
 
-SDL_bool SDL_ReadU64BE(SDL_RWops *src, Uint64 *value)
+SDL_bool SDL_ReadU64BE(SDL_IOStream *src, Uint64 *value)
 {
     Uint64 data = 0;
     SDL_bool result = SDL_FALSE;
 
-    if (SDL_ReadRW(src, &data, sizeof(data)) == sizeof(data)) {
+    if (SDL_ReadIO(src, &data, sizeof(data)) == sizeof(data)) {
         result = SDL_TRUE;
     }
     if (value) {
@@ -1101,78 +1101,78 @@ SDL_bool SDL_ReadU64BE(SDL_RWops *src, Uint64 *value)
     return result;
 }
 
-SDL_bool SDL_ReadS64BE(SDL_RWops *src, Sint64 *value)
+SDL_bool SDL_ReadS64BE(SDL_IOStream *src, Sint64 *value)
 {
     return SDL_ReadU64BE(src, (Uint64 *)value);
 }
 
-SDL_bool SDL_WriteU8(SDL_RWops *dst, Uint8 value)
+SDL_bool SDL_WriteU8(SDL_IOStream *dst, Uint8 value)
 {
-    return (SDL_WriteRW(dst, &value, sizeof(value)) == sizeof(value));
+    return (SDL_WriteIO(dst, &value, sizeof(value)) == sizeof(value));
 }
 
-SDL_bool SDL_WriteU16LE(SDL_RWops *dst, Uint16 value)
+SDL_bool SDL_WriteU16LE(SDL_IOStream *dst, Uint16 value)
 {
     const Uint16 swapped = SDL_SwapLE16(value);
-    return (SDL_WriteRW(dst, &swapped, sizeof(swapped)) == sizeof(swapped));
+    return (SDL_WriteIO(dst, &swapped, sizeof(swapped)) == sizeof(swapped));
 }
 
-SDL_bool SDL_WriteS16LE(SDL_RWops *dst, Sint16 value)
+SDL_bool SDL_WriteS16LE(SDL_IOStream *dst, Sint16 value)
 {
     return SDL_WriteU16LE(dst, (Uint16)value);
 }
 
-SDL_bool SDL_WriteU16BE(SDL_RWops *dst, Uint16 value)
+SDL_bool SDL_WriteU16BE(SDL_IOStream *dst, Uint16 value)
 {
     const Uint16 swapped = SDL_SwapBE16(value);
-    return (SDL_WriteRW(dst, &swapped, sizeof(swapped)) == sizeof(swapped));
+    return (SDL_WriteIO(dst, &swapped, sizeof(swapped)) == sizeof(swapped));
 }
 
-SDL_bool SDL_WriteS16BE(SDL_RWops *dst, Sint16 value)
+SDL_bool SDL_WriteS16BE(SDL_IOStream *dst, Sint16 value)
 {
     return SDL_WriteU16BE(dst, (Uint16)value);
 }
 
-SDL_bool SDL_WriteU32LE(SDL_RWops *dst, Uint32 value)
+SDL_bool SDL_WriteU32LE(SDL_IOStream *dst, Uint32 value)
 {
     const Uint32 swapped = SDL_SwapLE32(value);
-    return (SDL_WriteRW(dst, &swapped, sizeof(swapped)) == sizeof(swapped));
+    return (SDL_WriteIO(dst, &swapped, sizeof(swapped)) == sizeof(swapped));
 }
 
-SDL_bool SDL_WriteS32LE(SDL_RWops *dst, Sint32 value)
+SDL_bool SDL_WriteS32LE(SDL_IOStream *dst, Sint32 value)
 {
     return SDL_WriteU32LE(dst, (Uint32)value);
 }
 
-SDL_bool SDL_WriteU32BE(SDL_RWops *dst, Uint32 value)
+SDL_bool SDL_WriteU32BE(SDL_IOStream *dst, Uint32 value)
 {
     const Uint32 swapped = SDL_SwapBE32(value);
-    return (SDL_WriteRW(dst, &swapped, sizeof(swapped)) == sizeof(swapped));
+    return (SDL_WriteIO(dst, &swapped, sizeof(swapped)) == sizeof(swapped));
 }
 
-SDL_bool SDL_WriteS32BE(SDL_RWops *dst, Sint32 value)
+SDL_bool SDL_WriteS32BE(SDL_IOStream *dst, Sint32 value)
 {
     return SDL_WriteU32BE(dst, (Uint32)value);
 }
 
-SDL_bool SDL_WriteU64LE(SDL_RWops *dst, Uint64 value)
+SDL_bool SDL_WriteU64LE(SDL_IOStream *dst, Uint64 value)
 {
     const Uint64 swapped = SDL_SwapLE64(value);
-    return (SDL_WriteRW(dst, &swapped, sizeof(swapped)) == sizeof(swapped));
+    return (SDL_WriteIO(dst, &swapped, sizeof(swapped)) == sizeof(swapped));
 }
 
-SDL_bool SDL_WriteS64LE(SDL_RWops *dst, Sint64 value)
+SDL_bool SDL_WriteS64LE(SDL_IOStream *dst, Sint64 value)
 {
     return SDL_WriteU64LE(dst, (Uint64)value);
 }
 
-SDL_bool SDL_WriteU64BE(SDL_RWops *dst, Uint64 value)
+SDL_bool SDL_WriteU64BE(SDL_IOStream *dst, Uint64 value)
 {
     const Uint64 swapped = SDL_SwapBE64(value);
-    return (SDL_WriteRW(dst, &swapped, sizeof(swapped)) == sizeof(swapped));
+    return (SDL_WriteIO(dst, &swapped, sizeof(swapped)) == sizeof(swapped));
 }
 
-SDL_bool SDL_WriteS64BE(SDL_RWops *dst, Sint64 value)
+SDL_bool SDL_WriteS64BE(SDL_IOStream *dst, Sint64 value)
 {
     return SDL_WriteU64BE(dst, (Uint64)value);
 }

src/joystick/SDL_gamepad.c

@@ -1789,7 +1789,7 @@ static GamepadMapping_t *SDL_PrivateGetGamepadMapping(SDL_JoystickID instance_id
 /*
  * Add or update an entry into the Mappings Database
  */
-int SDL_AddGamepadMappingsFromRW(SDL_RWops *src, SDL_bool freesrc)
+int SDL_AddGamepadMappingsFromRW(SDL_IOStream *src, SDL_bool freesrc)
 {
     const char *platform = SDL_GetPlatform();
     int gamepads = 0;
@@ -1845,7 +1845,7 @@ int SDL_AddGamepadMappingsFromRW(SDL_RWops *src, SDL_bool freesrc)
 
 int SDL_AddGamepadMappingsFromFile(const char *file)
 {
-    return SDL_AddGamepadMappingsFromRW(SDL_RWFromFile(file, "rb"), 1);
+    return SDL_AddGamepadMappingsFromRW(SDL_IOFromFile(file, "rb"), 1);
 }
 
 int SDL_ReloadGamepadMappings(void)

src/test/SDL_test_common.c

@@ -1900,20 +1900,20 @@ static const void *SDLTest_ScreenShotClipboardProvider(void *context, const char
     SDL_Log("Providing screenshot image to clipboard!\n");
 
     if (!data->image) {
-        SDL_RWops *file;
+        SDL_IOStream *file;
 
-        file = SDL_RWFromFile(SCREENSHOT_FILE, "r");
+        file = SDL_IOFromFile(SCREENSHOT_FILE, "r");
         if (file) {
-            size_t length = (size_t)SDL_SizeRW(file);
+            size_t length = (size_t)SDL_SizeIO(file);
             void *image = SDL_malloc(length);
             if (image) {
-                if (SDL_ReadRW(file, image, length) != length) {
+                if (SDL_ReadIO(file, image, length) != length) {
                     SDL_Log("Couldn't read %s: %s\n", SCREENSHOT_FILE, SDL_GetError());
                     SDL_free(image);
                     image = NULL;
                 }
             }
-            SDL_CloseRW(file);
+            SDL_CloseIO(file);
 
             if (image) {
                 data->image = image;
@@ -1977,14 +1977,14 @@ static void SDLTest_PasteScreenShot(void)
         void *data = SDL_GetClipboardData(image_formats[i], &size);
         if (data) {
             char filename[16];
-            SDL_RWops *file;
+            SDL_IOStream *file;
 
             SDL_snprintf(filename, sizeof(filename), "clipboard.%s", image_formats[i] + 6);
-            file = SDL_RWFromFile(filename, "w");
+            file = SDL_IOFromFile(filename, "w");
             if (file) {
                 SDL_Log("Writing clipboard image to %s", filename);
-                SDL_WriteRW(file, data, size);
-                SDL_CloseRW(file);
+                SDL_WriteIO(file, data, size);
+                SDL_CloseIO(file);
             }
             SDL_free(data);
             return;

src/video/SDL_bmp.c

@@ -50,7 +50,7 @@
 #define LCS_WINDOWS_COLOR_SPACE 0x57696E20
 #endif
 
-static SDL_bool readRlePixels(SDL_Surface *surface, SDL_RWops *src, int isRle8)
+static SDL_bool readRlePixels(SDL_Surface *surface, SDL_IOStream *src, int isRle8)
 {
     /*
     | Sets the surface pixels from src.  A bmp image is upside down.
@@ -193,7 +193,7 @@ static void CorrectAlphaChannel(SDL_Surface *surface)
     }
 }
 
-SDL_Surface *SDL_LoadBMP_RW(SDL_RWops *src, SDL_bool freesrc)
+SDL_Surface *SDL_LoadBMP_IO(SDL_IOStream *src, SDL_bool freesrc)
 {
     SDL_bool was_error = SDL_TRUE;
     Sint64 fp_offset = 0;
@@ -239,12 +239,12 @@ SDL_Surface *SDL_LoadBMP_RW(SDL_RWops *src, SDL_bool freesrc)
     }
 
     /* Read in the BMP file header */
-    fp_offset = SDL_TellRW(src);
+    fp_offset = SDL_TellIO(src);
     if (fp_offset < 0) {
         goto done;
     }
     SDL_ClearError();
-    if (SDL_ReadRW(src, magic, 2) != 2) {
+    if (SDL_ReadIO(src, magic, 2) != 2) {
         goto done;
     }
     if (SDL_strncmp(magic, "BM", 2) != 0) {
@@ -340,9 +340,9 @@ SDL_Surface *SDL_LoadBMP_RW(SDL_RWops *src, SDL_bool freesrc)
         }
 
         /* skip any header bytes we didn't handle... */
-        headerSize = (Uint32)(SDL_TellRW(src) - (fp_offset + 14));
+        headerSize = (Uint32)(SDL_TellIO(src) - (fp_offset + 14));
         if (biSize > headerSize) {
-            if (SDL_SeekRW(src, (biSize - headerSize), SDL_RW_SEEK_CUR) < 0) {
+            if (SDL_SeekIO(src, (biSize - headerSize), SDL_IO_SEEK_CUR) < 0) {
                 goto done;
             }
         }
@@ -441,7 +441,7 @@ SDL_Surface *SDL_LoadBMP_RW(SDL_RWops *src, SDL_bool freesrc)
     /* Load the palette, if any */
     palette = (surface->format)->palette;
     if (palette) {
-        if (SDL_SeekRW(src, fp_offset + 14 + biSize, SDL_RW_SEEK_SET) < 0) {
+        if (SDL_SeekIO(src, fp_offset + 14 + biSize, SDL_IO_SEEK_SET) < 0) {
             SDL_Error(SDL_EFSEEK);
             goto done;
         }
@@ -492,7 +492,7 @@ SDL_Surface *SDL_LoadBMP_RW(SDL_RWops *src, SDL_bool freesrc)
     }
 
     /* Read the surface pixels.  Note that the bmp image is upside down */
-    if (SDL_SeekRW(src, fp_offset + bfOffBits, SDL_RW_SEEK_SET) < 0) {
+    if (SDL_SeekIO(src, fp_offset + bfOffBits, SDL_IO_SEEK_SET) < 0) {
         SDL_Error(SDL_EFSEEK);
         goto done;
     }
@@ -512,7 +512,7 @@ SDL_Surface *SDL_LoadBMP_RW(SDL_RWops *src, SDL_bool freesrc)
         bits = end - surface->pitch;
     }
     while (bits >= top && bits < end) {
-        if (SDL_ReadRW(src, bits, surface->pitch) != (size_t)surface->pitch) {
+        if (SDL_ReadIO(src, bits, surface->pitch) != (size_t)surface->pitch) {
             goto done;
         }
         if (biBitCount == 8 && palette && biClrUsed < (1u << biBitCount)) {
@@ -572,23 +572,23 @@ SDL_Surface *SDL_LoadBMP_RW(SDL_RWops *src, SDL_bool freesrc)
 done:
     if (was_error) {
         if (src) {
-            SDL_SeekRW(src, fp_offset, SDL_RW_SEEK_SET);
+            SDL_SeekIO(src, fp_offset, SDL_IO_SEEK_SET);
         }
         SDL_DestroySurface(surface);
         surface = NULL;
     }
     if (freesrc && src) {
-        SDL_CloseRW(src);
+        SDL_CloseIO(src);
     }
     return surface;
 }
 
 SDL_Surface *SDL_LoadBMP(const char *file)
 {
-    return SDL_LoadBMP_RW(SDL_RWFromFile(file, "rb"), 1);
+    return SDL_LoadBMP_IO(SDL_IOFromFile(file, "rb"), 1);
 }
 
-int SDL_SaveBMP_RW(SDL_Surface *surface, SDL_RWops *dst, SDL_bool freedst)
+int SDL_SaveBMP_IO(SDL_Surface *surface, SDL_IOStream *dst, SDL_bool freedst)
 {
     SDL_bool was_error = SDL_TRUE;
     Sint64 fp_offset, new_offset;
@@ -685,7 +685,7 @@ int SDL_SaveBMP_RW(SDL_Surface *surface, SDL_RWops *dst, SDL_bool freedst)
         }
     } else {
         /* Set no error here because it may overwrite a more useful message from
-           SDL_RWFromFile() if SDL_SaveBMP_RW() is called from SDL_SaveBMP(). */
+           SDL_IOFromFile() if SDL_SaveBMP_IO() is called from SDL_SaveBMP(). */
         goto done;
     }
 
@@ -703,11 +703,11 @@ int SDL_SaveBMP_RW(SDL_Surface *surface, SDL_RWops *dst, SDL_bool freedst)
         bfOffBits = 0; /* We'll write this when we're done */
 
         /* Write the BMP file header values */
-        fp_offset = SDL_TellRW(dst);
+        fp_offset = SDL_TellIO(dst);
         if (fp_offset < 0) {
             goto done;
         }
-        if (SDL_WriteRW(dst, magic, 2) != 2 ||
+        if (SDL_WriteIO(dst, magic, 2) != 2 ||
             !SDL_WriteU32LE(dst, bfSize) ||
             !SDL_WriteU16LE(dst, bfReserved1) ||
             !SDL_WriteU16LE(dst, bfReserved2) ||
@@ -801,14 +801,14 @@ int SDL_SaveBMP_RW(SDL_Surface *surface, SDL_RWops *dst, SDL_bool freedst)
         }
 
         /* Write the bitmap offset */
-        bfOffBits = (Uint32)(SDL_TellRW(dst) - fp_offset);
-        if (SDL_SeekRW(dst, fp_offset + 10, SDL_RW_SEEK_SET) < 0) {
+        bfOffBits = (Uint32)(SDL_TellIO(dst) - fp_offset);
+        if (SDL_SeekIO(dst, fp_offset + 10, SDL_IO_SEEK_SET) < 0) {
             goto done;
         }
         if (!SDL_WriteU32LE(dst, bfOffBits)) {
             goto done;
         }
-        if (SDL_SeekRW(dst, fp_offset + bfOffBits, SDL_RW_SEEK_SET) < 0) {
+        if (SDL_SeekIO(dst, fp_offset + bfOffBits, SDL_IO_SEEK_SET) < 0) {
             goto done;
         }
 
@@ -817,7 +817,7 @@ int SDL_SaveBMP_RW(SDL_Surface *surface, SDL_RWops *dst, SDL_bool freedst)
         pad = ((bw % 4) ? (4 - (bw % 4)) : 0);
         while (bits > (Uint8 *)intermediate_surface->pixels) {
             bits -= intermediate_surface->pitch;
-            if (SDL_WriteRW(dst, bits, bw) != bw) {
+            if (SDL_WriteIO(dst, bits, bw) != bw) {
                 goto done;
             }
             if (pad) {
@@ -831,18 +831,18 @@ int SDL_SaveBMP_RW(SDL_Surface *surface, SDL_RWops *dst, SDL_bool freedst)
         }
 
         /* Write the BMP file size */
-        new_offset = SDL_TellRW(dst);
+        new_offset = SDL_TellIO(dst);
         if (new_offset < 0) {
             goto done;
         }
         bfSize = (Uint32)(new_offset - fp_offset);
-        if (SDL_SeekRW(dst, fp_offset + 2, SDL_RW_SEEK_SET) < 0) {
+        if (SDL_SeekIO(dst, fp_offset + 2, SDL_IO_SEEK_SET) < 0) {
             goto done;
         }
         if (!SDL_WriteU32LE(dst, bfSize)) {
             goto done;
         }
-        if (SDL_SeekRW(dst, fp_offset + bfSize, SDL_RW_SEEK_SET) < 0) {
+        if (SDL_SeekIO(dst, fp_offset + bfSize, SDL_IO_SEEK_SET) < 0) {
             goto done;
         }
 
@@ -857,7 +857,7 @@ done:
         SDL_DestroySurface(intermediate_surface);
     }
     if (freedst && dst) {
-        if (SDL_CloseRW(dst) < 0) {
+        if (SDL_CloseIO(dst) < 0) {
             was_error = SDL_TRUE;
         }
     }
@@ -869,5 +869,5 @@ done:
 
 int SDL_SaveBMP(SDL_Surface *surface, const char *file)
 {
-    return SDL_SaveBMP_RW(surface, SDL_RWFromFile(file, "wb"), 1);
+    return SDL_SaveBMP_IO(surface, SDL_IOFromFile(file, "wb"), 1);
 }

test/gamepadutils.c

@@ -135,9 +135,9 @@ static SDL_Texture *CreateTexture(SDL_Renderer *renderer, unsigned char *data, u
 {
     SDL_Texture *texture = NULL;
     SDL_Surface *surface;
-    SDL_RWops *src = SDL_RWFromConstMem(data, len);
+    SDL_IOStream *src = SDL_IOFromConstMem(data, len);
     if (src) {
-        surface = SDL_LoadBMP_RW(src, SDL_TRUE);
+        surface = SDL_LoadBMP_IO(src, SDL_TRUE);
         if (surface) {
             texture = SDL_CreateTextureFromSurface(renderer, surface);
             SDL_DestroySurface(surface);

test/testautomation.c

@@ -40,7 +40,7 @@ static SDLTest_TestSuiteReference *testSuites[] = {
     &propertiesTestSuite,
     &rectTestSuite,
     &renderTestSuite,
-    &rwopsTestSuite,
+    &iostrmTestSuite,
     &sdltestTestSuite,
     &stdlibTestSuite,
     &surfaceTestSuite,

test/testautomation_rwops.c

@@ -1,6 +1,6 @@
 
 /**
- * Automated SDL_RWops test.
+ * Automated SDL_IOStream test.
  *
  * Original code written by Edgar Simo "bobbens"
  * Ported by Markus Kauppila (markus.kauppila@gmail.com)
@@ -22,17 +22,17 @@
 
 /* ================= Test Case Implementation ================== */
 
-static const char *RWopsReadTestFilename = "rwops_read";
-static const char *RWopsWriteTestFilename = "rwops_write";
-static const char *RWopsAlphabetFilename = "rwops_alphabet";
+static const char *IOStreamReadTestFilename = "iostrm_read";
+static const char *IOStreamWriteTestFilename = "iostrm_write";
+static const char *IOStreamAlphabetFilename = "iostrm_alphabet";
 
-static const char RWopsHelloWorldTestString[] = "Hello World!";
-static const char RWopsHelloWorldCompString[] = "Hello World!";
-static const char RWopsAlphabetString[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+static const char IOStreamHelloWorldTestString[] = "Hello World!";
+static const char IOStreamHelloWorldCompString[] = "Hello World!";
+static const char IOStreamAlphabetString[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
 
 /* Fixture */
 
-static void RWopsSetUp(void *arg)
+static void IOStreamSetUp(void *arg)
 {
     size_t fileLen;
     FILE *handle;
@@ -40,34 +40,34 @@ static void RWopsSetUp(void *arg)
     int result;
 
     /* Clean up from previous runs (if any); ignore errors */
-    (void)remove(RWopsReadTestFilename);
-    (void)remove(RWopsWriteTestFilename);
-    (void)remove(RWopsAlphabetFilename);
+    (void)remove(IOStreamReadTestFilename);
+    (void)remove(IOStreamWriteTestFilename);
+    (void)remove(IOStreamAlphabetFilename);
 
     /* Create a test file */
-    handle = fopen(RWopsReadTestFilename, "w");
-    SDLTest_AssertCheck(handle != NULL, "Verify creation of file '%s' returned non NULL handle", RWopsReadTestFilename);
+    handle = fopen(IOStreamReadTestFilename, "w");
+    SDLTest_AssertCheck(handle != NULL, "Verify creation of file '%s' returned non NULL handle", IOStreamReadTestFilename);
     if (handle == NULL) {
         return;
     }
 
     /* Write some known text into it */
-    fileLen = SDL_strlen(RWopsHelloWorldTestString);
-    writtenLen = fwrite(RWopsHelloWorldTestString, 1, fileLen, handle);
+    fileLen = SDL_strlen(IOStreamHelloWorldTestString);
+    writtenLen = fwrite(IOStreamHelloWorldTestString, 1, fileLen, handle);
     SDLTest_AssertCheck(fileLen == writtenLen, "Verify number of written bytes, expected %i, got %i", (int)fileLen, (int)writtenLen);
     result = fclose(handle);
     SDLTest_AssertCheck(result == 0, "Verify result from fclose, expected 0, got %i", result);
 
     /* Create a second test file */
-    handle = fopen(RWopsAlphabetFilename, "w");
-    SDLTest_AssertCheck(handle != NULL, "Verify creation of file '%s' returned non NULL handle", RWopsAlphabetFilename);
+    handle = fopen(IOStreamAlphabetFilename, "w");
+    SDLTest_AssertCheck(handle != NULL, "Verify creation of file '%s' returned non NULL handle", IOStreamAlphabetFilename);
     if (handle == NULL) {
         return;
     }
 
     /* Write alphabet text into it */
-    fileLen = SDL_strlen(RWopsAlphabetString);
-    writtenLen = fwrite(RWopsAlphabetString, 1, fileLen, handle);
+    fileLen = SDL_strlen(IOStreamAlphabetString);
+    writtenLen = fwrite(IOStreamAlphabetString, 1, fileLen, handle);
     SDLTest_AssertCheck(fileLen == writtenLen, "Verify number of written bytes, expected %i, got %i", (int)fileLen, (int)writtenLen);
     result = fclose(handle);
     SDLTest_AssertCheck(result == 0, "Verify result from fclose, expected 0, got %i", result);
@@ -75,16 +75,16 @@ static void RWopsSetUp(void *arg)
     SDLTest_AssertPass("Creation of test file completed");
 }
 
-static void RWopsTearDown(void *arg)
+static void IOStreamTearDown(void *arg)
 {
     int result;
 
     /* Remove the created files to clean up; ignore errors for write filename */
-    result = remove(RWopsReadTestFilename);
-    SDLTest_AssertCheck(result == 0, "Verify result from remove(%s), expected 0, got %i", RWopsReadTestFilename, result);
-    (void)remove(RWopsWriteTestFilename);
-    result = remove(RWopsAlphabetFilename);
-    SDLTest_AssertCheck(result == 0, "Verify result from remove(%s), expected 0, got %i", RWopsAlphabetFilename, result);
+    result = remove(IOStreamReadTestFilename);
+    SDLTest_AssertCheck(result == 0, "Verify result from remove(%s), expected 0, got %i", IOStreamReadTestFilename, result);
+    (void)remove(IOStreamWriteTestFilename);
+    result = remove(IOStreamAlphabetFilename);
+    SDLTest_AssertCheck(result == 0, "Verify result from remove(%s), expected 0, got %i", IOStreamAlphabetFilename, result);
 
     SDLTest_AssertPass("Cleanup of test files completed");
 }
@@ -92,12 +92,12 @@ static void RWopsTearDown(void *arg)
 /**
  * Makes sure parameters work properly. Local helper function.
  *
- * \sa SDL_SeekRW
- * \sa SDL_ReadRW
+ * \sa SDL_SeekIO
+ * \sa SDL_ReadIO
  */
-static void testGenericRWopsValidations(SDL_RWops *rw, SDL_bool write)
+static void testGenericIOStreamValidations(SDL_IOStream *rw, SDL_bool write)
 {
-    char buf[sizeof(RWopsHelloWorldTestString)];
+    char buf[sizeof(IOStreamHelloWorldTestString)];
     Sint64 i;
     size_t s;
     int seekPos = SDLTest_RandomIntegerInRange(4, 8);
@@ -106,140 +106,140 @@ static void testGenericRWopsValidations(SDL_RWops *rw, SDL_bool write)
     SDL_zeroa(buf);
 
     /* Set to start. */
-    i = SDL_SeekRW(rw, 0, SDL_RW_SEEK_SET);
-    SDLTest_AssertPass("Call to SDL_SeekRW succeeded");
-    SDLTest_AssertCheck(i == (Sint64)0, "Verify seek to 0 with SDL_SeekRW (SDL_RW_SEEK_SET), expected 0, got %" SDL_PRIs64, i);
+    i = SDL_SeekIO(rw, 0, SDL_IO_SEEK_SET);
+    SDLTest_AssertPass("Call to SDL_SeekIO succeeded");
+    SDLTest_AssertCheck(i == (Sint64)0, "Verify seek to 0 with SDL_SeekIO (SDL_IO_SEEK_SET), expected 0, got %" SDL_PRIs64, i);
 
     /* Test write */
-    s = SDL_WriteRW(rw, RWopsHelloWorldTestString, sizeof(RWopsHelloWorldTestString) - 1);
-    SDLTest_AssertPass("Call to SDL_WriteRW succeeded");
+    s = SDL_WriteIO(rw, IOStreamHelloWorldTestString, sizeof(IOStreamHelloWorldTestString) - 1);
+    SDLTest_AssertPass("Call to SDL_WriteIO succeeded");
     if (write) {
-        SDLTest_AssertCheck(s == sizeof(RWopsHelloWorldTestString) - 1, "Verify result of writing with SDL_WriteRW, expected %i, got %i", (int)sizeof(RWopsHelloWorldTestString) - 1, (int)s);
+        SDLTest_AssertCheck(s == sizeof(IOStreamHelloWorldTestString) - 1, "Verify result of writing with SDL_WriteIO, expected %i, got %i", (int)sizeof(IOStreamHelloWorldTestString) - 1, (int)s);
     } else {
-        SDLTest_AssertCheck(s == 0, "Verify result of writing with SDL_WriteRW, expected: 0, got %i", (int)s);
+        SDLTest_AssertCheck(s == 0, "Verify result of writing with SDL_WriteIO, expected: 0, got %i", (int)s);
     }
 
     /* Test seek to random position */
-    i = SDL_SeekRW(rw, seekPos, SDL_RW_SEEK_SET);
-    SDLTest_AssertPass("Call to SDL_SeekRW succeeded");
-    SDLTest_AssertCheck(i == (Sint64)seekPos, "Verify seek to %i with SDL_SeekRW (SDL_RW_SEEK_SET), expected %i, got %" SDL_PRIs64, seekPos, seekPos, i);
+    i = SDL_SeekIO(rw, seekPos, SDL_IO_SEEK_SET);
+    SDLTest_AssertPass("Call to SDL_SeekIO succeeded");
+    SDLTest_AssertCheck(i == (Sint64)seekPos, "Verify seek to %i with SDL_SeekIO (SDL_IO_SEEK_SET), expected %i, got %" SDL_PRIs64, seekPos, seekPos, i);
 
     /* Test seek back to start */
-    i = SDL_SeekRW(rw, 0, SDL_RW_SEEK_SET);
-    SDLTest_AssertPass("Call to SDL_SeekRW succeeded");
-    SDLTest_AssertCheck(i == (Sint64)0, "Verify seek to 0 with SDL_SeekRW (SDL_RW_SEEK_SET), expected 0, got %" SDL_PRIs64, i);
+    i = SDL_SeekIO(rw, 0, SDL_IO_SEEK_SET);
+    SDLTest_AssertPass("Call to SDL_SeekIO succeeded");
+    SDLTest_AssertCheck(i == (Sint64)0, "Verify seek to 0 with SDL_SeekIO (SDL_IO_SEEK_SET), expected 0, got %" SDL_PRIs64, i);
 
     /* Test read */
-    s = SDL_ReadRW(rw, buf, sizeof(RWopsHelloWorldTestString) - 1);
-    SDLTest_AssertPass("Call to SDL_ReadRW succeeded");
+    s = SDL_ReadIO(rw, buf, sizeof(IOStreamHelloWorldTestString) - 1);
+    SDLTest_AssertPass("Call to SDL_ReadIO succeeded");
     SDLTest_AssertCheck(
-        s == (sizeof(RWopsHelloWorldTestString) - 1),
-        "Verify result from SDL_ReadRW, expected %i, got %i",
-        (int)(sizeof(RWopsHelloWorldTestString) - 1),
+        s == (sizeof(IOStreamHelloWorldTestString) - 1),
+        "Verify result from SDL_ReadIO, expected %i, got %i",
+        (int)(sizeof(IOStreamHelloWorldTestString) - 1),
         (int)s);
     SDLTest_AssertCheck(
-        SDL_memcmp(buf, RWopsHelloWorldTestString, sizeof(RWopsHelloWorldTestString) - 1) == 0,
-        "Verify read bytes match expected string, expected '%s', got '%s'", RWopsHelloWorldTestString, buf);
+        SDL_memcmp(buf, IOStreamHelloWorldTestString, sizeof(IOStreamHelloWorldTestString) - 1) == 0,
+        "Verify read bytes match expected string, expected '%s', got '%s'", IOStreamHelloWorldTestString, buf);
 
     /* Test seek back to start */
-    i = SDL_SeekRW(rw, 0, SDL_RW_SEEK_SET);
-    SDLTest_AssertPass("Call to SDL_SeekRW succeeded");
-    SDLTest_AssertCheck(i == (Sint64)0, "Verify seek to 0 with SDL_SeekRW (SDL_RW_SEEK_SET), expected 0, got %" SDL_PRIs64, i);
+    i = SDL_SeekIO(rw, 0, SDL_IO_SEEK_SET);
+    SDLTest_AssertPass("Call to SDL_SeekIO succeeded");
+    SDLTest_AssertCheck(i == (Sint64)0, "Verify seek to 0 with SDL_SeekIO (SDL_IO_SEEK_SET), expected 0, got %" SDL_PRIs64, i);
 
     /* Test printf */
-    s = SDL_RWprintf(rw, "%s", RWopsHelloWorldTestString);
-    SDLTest_AssertPass("Call to SDL_RWprintf succeeded");
+    s = SDL_IOprintf(rw, "%s", IOStreamHelloWorldTestString);
+    SDLTest_AssertPass("Call to SDL_IOprintf succeeded");
     if (write) {
-        SDLTest_AssertCheck(s == sizeof(RWopsHelloWorldTestString) - 1, "Verify result of writing with SDL_RWprintf, expected %i, got %i", (int)sizeof(RWopsHelloWorldTestString) - 1, (int)s);
+        SDLTest_AssertCheck(s == sizeof(IOStreamHelloWorldTestString) - 1, "Verify result of writing with SDL_IOprintf, expected %i, got %i", (int)sizeof(IOStreamHelloWorldTestString) - 1, (int)s);
     } else {
-        SDLTest_AssertCheck(s == 0, "Verify result of writing with SDL_WriteRW, expected: 0, got %i", (int)s);
+        SDLTest_AssertCheck(s == 0, "Verify result of writing with SDL_WriteIO, expected: 0, got %i", (int)s);
     }
 
     /* Test seek back to start */
-    i = SDL_SeekRW(rw, 0, SDL_RW_SEEK_SET);
-    SDLTest_AssertPass("Call to SDL_SeekRW succeeded");
-    SDLTest_AssertCheck(i == (Sint64)0, "Verify seek to 0 with SDL_SeekRW (SDL_RW_SEEK_SET), expected 0, got %" SDL_PRIs64, i);
+    i = SDL_SeekIO(rw, 0, SDL_IO_SEEK_SET);
+    SDLTest_AssertPass("Call to SDL_SeekIO succeeded");
+    SDLTest_AssertCheck(i == (Sint64)0, "Verify seek to 0 with SDL_SeekIO (SDL_IO_SEEK_SET), expected 0, got %" SDL_PRIs64, i);
 
     /* Test read */
-    s = SDL_ReadRW(rw, buf, sizeof(RWopsHelloWorldTestString) - 1);
-    SDLTest_AssertPass("Call to SDL_ReadRW succeeded");
+    s = SDL_ReadIO(rw, buf, sizeof(IOStreamHelloWorldTestString) - 1);
+    SDLTest_AssertPass("Call to SDL_ReadIO succeeded");
     SDLTest_AssertCheck(
-        s == (sizeof(RWopsHelloWorldTestString) - 1),
-        "Verify result from SDL_ReadRW, expected %i, got %i",
-        (int)(sizeof(RWopsHelloWorldTestString) - 1),
+        s == (sizeof(IOStreamHelloWorldTestString) - 1),
+        "Verify result from SDL_ReadIO, expected %i, got %i",
+        (int)(sizeof(IOStreamHelloWorldTestString) - 1),
         (int)s);
     SDLTest_AssertCheck(
-        SDL_memcmp(buf, RWopsHelloWorldTestString, sizeof(RWopsHelloWorldTestString) - 1) == 0,
-        "Verify read bytes match expected string, expected '%s', got '%s'", RWopsHelloWorldTestString, buf);
+        SDL_memcmp(buf, IOStreamHelloWorldTestString, sizeof(IOStreamHelloWorldTestString) - 1) == 0,
+        "Verify read bytes match expected string, expected '%s', got '%s'", IOStreamHelloWorldTestString, buf);
 
     /* More seek tests. */
-    i = SDL_SeekRW(rw, -4, SDL_RW_SEEK_CUR);
-    SDLTest_AssertPass("Call to SDL_SeekRW(...,-4,SDL_RW_SEEK_CUR) succeeded");
+    i = SDL_SeekIO(rw, -4, SDL_IO_SEEK_CUR);
+    SDLTest_AssertPass("Call to SDL_SeekIO(...,-4,SDL_IO_SEEK_CUR) succeeded");
     SDLTest_AssertCheck(
-        i == (Sint64)(sizeof(RWopsHelloWorldTestString) - 5),
-        "Verify seek to -4 with SDL_SeekRW (SDL_RW_SEEK_CUR), expected %i, got %i",
-        (int)(sizeof(RWopsHelloWorldTestString) - 5),
+        i == (Sint64)(sizeof(IOStreamHelloWorldTestString) - 5),
+        "Verify seek to -4 with SDL_SeekIO (SDL_IO_SEEK_CUR), expected %i, got %i",
+        (int)(sizeof(IOStreamHelloWorldTestString) - 5),
         (int)i);
 
-    i = SDL_SeekRW(rw, -1, SDL_RW_SEEK_END);
-    SDLTest_AssertPass("Call to SDL_SeekRW(...,-1,SDL_RW_SEEK_END) succeeded");
+    i = SDL_SeekIO(rw, -1, SDL_IO_SEEK_END);
+    SDLTest_AssertPass("Call to SDL_SeekIO(...,-1,SDL_IO_SEEK_END) succeeded");
     SDLTest_AssertCheck(
-        i == (Sint64)(sizeof(RWopsHelloWorldTestString) - 2),
-        "Verify seek to -1 with SDL_SeekRW (SDL_RW_SEEK_END), expected %i, got %i",
-        (int)(sizeof(RWopsHelloWorldTestString) - 2),
+        i == (Sint64)(sizeof(IOStreamHelloWorldTestString) - 2),
+        "Verify seek to -1 with SDL_SeekIO (SDL_IO_SEEK_END), expected %i, got %i",
+        (int)(sizeof(IOStreamHelloWorldTestString) - 2),
         (int)i);
 
     /* Invalid whence seek */
-    i = SDL_SeekRW(rw, 0, 999);
-    SDLTest_AssertPass("Call to SDL_SeekRW(...,0,invalid_whence) succeeded");
+    i = SDL_SeekIO(rw, 0, 999);
+    SDLTest_AssertPass("Call to SDL_SeekIO(...,0,invalid_whence) succeeded");
     SDLTest_AssertCheck(
         i == (Sint64)(-1),
-        "Verify seek with SDL_SeekRW (invalid_whence); expected: -1, got %i",
+        "Verify seek with SDL_SeekIO (invalid_whence); expected: -1, got %i",
         (int)i);
 }
 
 /**
- * Negative test for SDL_RWFromFile parameters
+ * Negative test for SDL_IOFromFile parameters
  *
- * \sa SDL_RWFromFile
+ * \sa SDL_IOFromFile
  *
  */
-static int rwops_testParamNegative(void *arg)
+static int iostrm_testParamNegative(void *arg)
 {
-    SDL_RWops *rwops;
+    SDL_IOStream *iostrm;
 
     /* These should all fail. */
-    rwops = SDL_RWFromFile(NULL, NULL);
-    SDLTest_AssertPass("Call to SDL_RWFromFile(NULL, NULL) succeeded");
-    SDLTest_AssertCheck(rwops == NULL, "Verify SDL_RWFromFile(NULL, NULL) returns NULL");
+    iostrm = SDL_IOFromFile(NULL, NULL);
+    SDLTest_AssertPass("Call to SDL_IOFromFile(NULL, NULL) succeeded");
+    SDLTest_AssertCheck(iostrm == NULL, "Verify SDL_IOFromFile(NULL, NULL) returns NULL");
 
-    rwops = SDL_RWFromFile(NULL, "ab+");
-    SDLTest_AssertPass("Call to SDL_RWFromFile(NULL, \"ab+\") succeeded");
-    SDLTest_AssertCheck(rwops == NULL, "Verify SDL_RWFromFile(NULL, \"ab+\") returns NULL");
+    iostrm = SDL_IOFromFile(NULL, "ab+");
+    SDLTest_AssertPass("Call to SDL_IOFromFile(NULL, \"ab+\") succeeded");
+    SDLTest_AssertCheck(iostrm == NULL, "Verify SDL_IOFromFile(NULL, \"ab+\") returns NULL");
 
-    rwops = SDL_RWFromFile(NULL, "sldfkjsldkfj");
-    SDLTest_AssertPass("Call to SDL_RWFromFile(NULL, \"sldfkjsldkfj\") succeeded");
-    SDLTest_AssertCheck(rwops == NULL, "Verify SDL_RWFromFile(NULL, \"sldfkjsldkfj\") returns NULL");
+    iostrm = SDL_IOFromFile(NULL, "sldfkjsldkfj");
+    SDLTest_AssertPass("Call to SDL_IOFromFile(NULL, \"sldfkjsldkfj\") succeeded");
+    SDLTest_AssertCheck(iostrm == NULL, "Verify SDL_IOFromFile(NULL, \"sldfkjsldkfj\") returns NULL");
 
-    rwops = SDL_RWFromFile("something", "");
-    SDLTest_AssertPass("Call to SDL_RWFromFile(\"something\", \"\") succeeded");
-    SDLTest_AssertCheck(rwops == NULL, "Verify SDL_RWFromFile(\"something\", \"\") returns NULL");
+    iostrm = SDL_IOFromFile("something", "");
+    SDLTest_AssertPass("Call to SDL_IOFromFile(\"something\", \"\") succeeded");
+    SDLTest_AssertCheck(iostrm == NULL, "Verify SDL_IOFromFile(\"something\", \"\") returns NULL");
 
-    rwops = SDL_RWFromFile("something", NULL);
-    SDLTest_AssertPass("Call to SDL_RWFromFile(\"something\", NULL) succeeded");
-    SDLTest_AssertCheck(rwops == NULL, "Verify SDL_RWFromFile(\"something\", NULL) returns NULL");
+    iostrm = SDL_IOFromFile("something", NULL);
+    SDLTest_AssertPass("Call to SDL_IOFromFile(\"something\", NULL) succeeded");
+    SDLTest_AssertCheck(iostrm == NULL, "Verify SDL_IOFromFile(\"something\", NULL) returns NULL");
 
-    rwops = SDL_RWFromMem(NULL, 10);
-    SDLTest_AssertPass("Call to SDL_RWFromMem(NULL, 10) succeeded");
-    SDLTest_AssertCheck(rwops == NULL, "Verify SDL_RWFromMem(NULL, 10) returns NULL");
+    iostrm = SDL_IOFromMem(NULL, 10);
+    SDLTest_AssertPass("Call to SDL_IOFromMem(NULL, 10) succeeded");
+    SDLTest_AssertCheck(iostrm == NULL, "Verify SDL_IOFromMem(NULL, 10) returns NULL");
 
-    rwops = SDL_RWFromMem((void *)RWopsAlphabetString, 0);
-    SDLTest_AssertPass("Call to SDL_RWFromMem(data, 0) succeeded");
-    SDLTest_AssertCheck(rwops == NULL, "Verify SDL_RWFromMem(data, 0) returns NULL");
+    iostrm = SDL_IOFromMem((void *)IOStreamAlphabetString, 0);
+    SDLTest_AssertPass("Call to SDL_IOFromMem(data, 0) succeeded");
+    SDLTest_AssertCheck(iostrm == NULL, "Verify SDL_IOFromMem(data, 0) returns NULL");
 
-    rwops = SDL_RWFromConstMem((const void *)RWopsAlphabetString, 0);
-    SDLTest_AssertPass("Call to SDL_RWFromConstMem(data, 0) succeeded");
-    SDLTest_AssertCheck(rwops == NULL, "Verify SDL_RWFromConstMem(data, 0) returns NULL");
+    iostrm = SDL_IOFromConstMem((const void *)IOStreamAlphabetString, 0);
+    SDLTest_AssertPass("Call to SDL_IOFromConstMem(data, 0) succeeded");
+    SDLTest_AssertCheck(iostrm == NULL, "Verify SDL_IOFromConstMem(data, 0) returns NULL");
 
     return TEST_COMPLETED;
 }
@@ -247,22 +247,22 @@ static int rwops_testParamNegative(void *arg)
 /**
  * Tests opening from memory.
  *
- * \sa SDL_RWFromMem
- * \sa SDL_RWClose
+ * \sa SDL_IOFromMem
+ * \sa SDL_CloseIO
  */
-static int rwops_testMem(void *arg)
+static int iostrm_testMem(void *arg)
 {
-    char mem[sizeof(RWopsHelloWorldTestString)];
-    SDL_RWops *rw;
+    char mem[sizeof(IOStreamHelloWorldTestString)];
+    SDL_IOStream *rw;
     int result;
 
     /* Clear buffer */
     SDL_zeroa(mem);
 
     /* Open */
-    rw = SDL_RWFromMem(mem, sizeof(RWopsHelloWorldTestString) - 1);
-    SDLTest_AssertPass("Call to SDL_RWFromMem() succeeded");
-    SDLTest_AssertCheck(rw != NULL, "Verify opening memory with SDL_RWFromMem does not return NULL");
+    rw = SDL_IOFromMem(mem, sizeof(IOStreamHelloWorldTestString) - 1);
+    SDLTest_AssertPass("Call to SDL_IOFromMem() succeeded");
+    SDLTest_AssertCheck(rw != NULL, "Verify opening memory with SDL_IOFromMem does not return NULL");
 
     /* Bail out if NULL */
     if (rw == NULL) {
@@ -270,11 +270,11 @@ static int rwops_testMem(void *arg)
     }
 
     /* Run generic tests */
-    testGenericRWopsValidations(rw, SDL_TRUE);
+    testGenericIOStreamValidations(rw, SDL_TRUE);
 
     /* Close */
-    result = SDL_CloseRW(rw);
-    SDLTest_AssertPass("Call to SDL_CloseRW() succeeded");
+    result = SDL_CloseIO(rw);
+    SDLTest_AssertPass("Call to SDL_CloseIO() succeeded");
     SDLTest_AssertCheck(result == 0, "Verify result value is 0; got: %d", result);
 
     return TEST_COMPLETED;
@@ -283,18 +283,18 @@ static int rwops_testMem(void *arg)
 /**
  * Tests opening from memory.
  *
- * \sa SDL_RWFromConstMem
- * \sa SDL_RWClose
+ * \sa SDL_IOFromConstMem
+ * \sa SDL_CloseIO
  */
-static int rwops_testConstMem(void *arg)
+static int iostrm_testConstMem(void *arg)
 {
-    SDL_RWops *rw;
+    SDL_IOStream *rw;
     int result;
 
     /* Open handle */
-    rw = SDL_RWFromConstMem(RWopsHelloWorldCompString, sizeof(RWopsHelloWorldCompString) - 1);
-    SDLTest_AssertPass("Call to SDL_RWFromConstMem() succeeded");
-    SDLTest_AssertCheck(rw != NULL, "Verify opening memory with SDL_RWFromConstMem does not return NULL");
+    rw = SDL_IOFromConstMem(IOStreamHelloWorldCompString, sizeof(IOStreamHelloWorldCompString) - 1);
+    SDLTest_AssertPass("Call to SDL_IOFromConstMem() succeeded");
+    SDLTest_AssertCheck(rw != NULL, "Verify opening memory with SDL_IOFromConstMem does not return NULL");
 
     /* Bail out if NULL */
     if (rw == NULL) {
@@ -302,11 +302,11 @@ static int rwops_testConstMem(void *arg)
     }
 
     /* Run generic tests */
-    testGenericRWopsValidations(rw, SDL_FALSE);
+    testGenericIOStreamValidations(rw, SDL_FALSE);
 
     /* Close handle */
-    result = SDL_CloseRW(rw);
-    SDLTest_AssertPass("Call to SDL_CloseRW() succeeded");
+    result = SDL_CloseIO(rw);
+    SDLTest_AssertPass("Call to SDL_CloseIO() succeeded");
     SDLTest_AssertCheck(result == 0, "Verify result value is 0; got: %d", result);
 
     return TEST_COMPLETED;
@@ -315,18 +315,18 @@ static int rwops_testConstMem(void *arg)
 /**
  * Tests reading from file.
  *
- * \sa SDL_RWFromFile
- * \sa SDL_RWClose
+ * \sa SDL_IOFromFile
+ * \sa SDL_CloseIO
  */
-static int rwops_testFileRead(void *arg)
+static int iostrm_testFileRead(void *arg)
 {
-    SDL_RWops *rw;
+    SDL_IOStream *rw;
     int result;
 
     /* Read test. */
-    rw = SDL_RWFromFile(RWopsReadTestFilename, "r");
-    SDLTest_AssertPass("Call to SDL_RWFromFile(..,\"r\") succeeded");
-    SDLTest_AssertCheck(rw != NULL, "Verify opening file with SDL_RWFromFile in read mode does not return NULL");
+    rw = SDL_IOFromFile(IOStreamReadTestFilename, "r");
+    SDLTest_AssertPass("Call to SDL_IOFromFile(..,\"r\") succeeded");
+    SDLTest_AssertCheck(rw != NULL, "Verify opening file with SDL_IOFromFile in read mode does not return NULL");
 
     /* Bail out if NULL */
     if (rw == NULL) {
@@ -334,11 +334,11 @@ static int rwops_testFileRead(void *arg)
     }
 
     /* Run generic tests */
-    testGenericRWopsValidations(rw, SDL_FALSE);
+    testGenericIOStreamValidations(rw, SDL_FALSE);
 
     /* Close handle */
-    result = SDL_CloseRW(rw);
-    SDLTest_AssertPass("Call to SDL_CloseRW() succeeded");
+    result = SDL_CloseIO(rw);
+    SDLTest_AssertPass("Call to SDL_CloseIO() succeeded");
     SDLTest_AssertCheck(result == 0, "Verify result value is 0; got: %d", result);
 
     return TEST_COMPLETED;
@@ -347,18 +347,18 @@ static int rwops_testFileRead(void *arg)
 /**
  * Tests writing from file.
  *
- * \sa SDL_RWFromFile
- * \sa SDL_RWClose
+ * \sa SDL_IOFromFile
+ * \sa SDL_CloseIO
  */
-static int rwops_testFileWrite(void *arg)
+static int iostrm_testFileWrite(void *arg)
 {
-    SDL_RWops *rw;
+    SDL_IOStream *rw;
     int result;
 
     /* Write test. */
-    rw = SDL_RWFromFile(RWopsWriteTestFilename, "w+");
-    SDLTest_AssertPass("Call to SDL_RWFromFile(..,\"w+\") succeeded");
-    SDLTest_AssertCheck(rw != NULL, "Verify opening file with SDL_RWFromFile in write mode does not return NULL");
+    rw = SDL_IOFromFile(IOStreamWriteTestFilename, "w+");
+    SDLTest_AssertPass("Call to SDL_IOFromFile(..,\"w+\") succeeded");
+    SDLTest_AssertCheck(rw != NULL, "Verify opening file with SDL_IOFromFile in write mode does not return NULL");
 
     /* Bail out if NULL */
     if (rw == NULL) {
@@ -366,11 +366,11 @@ static int rwops_testFileWrite(void *arg)
     }
 
     /* Run generic tests */
-    testGenericRWopsValidations(rw, SDL_TRUE);
+    testGenericIOStreamValidations(rw, SDL_TRUE);
 
     /* Close handle */
-    result = SDL_CloseRW(rw);
-    SDLTest_AssertPass("Call to SDL_CloseRW() succeeded");
+    result = SDL_CloseIO(rw);
+    SDLTest_AssertPass("Call to SDL_CloseIO() succeeded");
     SDLTest_AssertCheck(result == 0, "Verify result value is 0; got: %d", result);
 
     return TEST_COMPLETED;
@@ -379,26 +379,26 @@ static int rwops_testFileWrite(void *arg)
 /**
  * Tests alloc and free RW context.
  *
- * \sa SDL_OpenRW
- * \sa SDL_CloseRW
+ * \sa SDL_OpenIO
+ * \sa SDL_CloseIO
  */
-static int rwops_testAllocFree(void *arg)
+static int iostrm_testAllocFree(void *arg)
 {
     /* Allocate context */
-    SDL_RWopsInterface iface;
-    SDL_RWops *rw;
+    SDL_IOStreamInterface iface;
+    SDL_IOStream *rw;
 
     SDL_zero(iface);
-    rw = SDL_OpenRW(&iface, NULL);
-    SDLTest_AssertPass("Call to SDL_OpenRW() succeeded");
-    SDLTest_AssertCheck(rw != NULL, "Validate result from SDL_OpenRW() is not NULL");
+    rw = SDL_OpenIO(&iface, NULL);
+    SDLTest_AssertPass("Call to SDL_OpenIO() succeeded");
+    SDLTest_AssertCheck(rw != NULL, "Validate result from SDL_OpenIO() is not NULL");
     if (rw == NULL) {
         return TEST_ABORTED;
     }
 
     /* Free context again */
-    SDL_CloseRW(rw);
-    SDLTest_AssertPass("Call to SDL_CloseRW() succeeded");
+    SDL_CloseIO(rw);
+    SDLTest_AssertPass("Call to SDL_CloseIO() succeeded");
 
     return TEST_COMPLETED;
 }
@@ -406,10 +406,10 @@ static int rwops_testAllocFree(void *arg)
 /**
  * Compare memory and file reads
  *
- * \sa SDL_RWFromMem
- * \sa SDL_RWFromFile
+ * \sa SDL_IOFromMem
+ * \sa SDL_IOFromFile
  */
-static int rwops_testCompareRWFromMemWithRWFromFile(void *arg)
+static int iostrm_testCompareRWFromMemWithRWFromFile(void *arg)
 {
     int slen = 26;
     char buffer_file[27];
@@ -418,8 +418,8 @@ static int rwops_testCompareRWFromMemWithRWFromFile(void *arg)
     size_t rv_mem;
     Uint64 sv_file;
     Uint64 sv_mem;
-    SDL_RWops *rwops_file;
-    SDL_RWops *rwops_mem;
+    SDL_IOStream *iostrm_file;
+    SDL_IOStream *iostrm_mem;
     int size;
     int result;
 
@@ -429,25 +429,25 @@ static int rwops_testCompareRWFromMemWithRWFromFile(void *arg)
         buffer_mem[slen] = 0;
 
         /* Read/seek from memory */
-        rwops_mem = SDL_RWFromMem((void *)RWopsAlphabetString, slen);
-        SDLTest_AssertPass("Call to SDL_RWFromMem()");
-        rv_mem = SDL_ReadRW(rwops_mem, buffer_mem, size * 6);
-        SDLTest_AssertPass("Call to SDL_ReadRW(mem, size=%d)", size * 6);
-        sv_mem = SDL_SeekRW(rwops_mem, 0, SEEK_END);
-        SDLTest_AssertPass("Call to SDL_SeekRW(mem,SEEK_END)");
-        result = SDL_CloseRW(rwops_mem);
-        SDLTest_AssertPass("Call to SDL_CloseRW(mem)");
+        iostrm_mem = SDL_IOFromMem((void *)IOStreamAlphabetString, slen);
+        SDLTest_AssertPass("Call to SDL_IOFromMem()");
+        rv_mem = SDL_ReadIO(iostrm_mem, buffer_mem, size * 6);
+        SDLTest_AssertPass("Call to SDL_ReadIO(mem, size=%d)", size * 6);
+        sv_mem = SDL_SeekIO(iostrm_mem, 0, SEEK_END);
+        SDLTest_AssertPass("Call to SDL_SeekIO(mem,SEEK_END)");
+        result = SDL_CloseIO(iostrm_mem);
+        SDLTest_AssertPass("Call to SDL_CloseIO(mem)");
         SDLTest_AssertCheck(result == 0, "Verify result value is 0; got: %d", result);
 
         /* Read/see from file */
-        rwops_file = SDL_RWFromFile(RWopsAlphabetFilename, "r");
-        SDLTest_AssertPass("Call to SDL_RWFromFile()");
-        rv_file = SDL_ReadRW(rwops_file, buffer_file, size * 6);
-        SDLTest_AssertPass("Call to SDL_ReadRW(file, size=%d)", size * 6);
-        sv_file = SDL_SeekRW(rwops_file, 0, SEEK_END);
-        SDLTest_AssertPass("Call to SDL_SeekRW(file,SEEK_END)");
-        result = SDL_CloseRW(rwops_file);
-        SDLTest_AssertPass("Call to SDL_CloseRW(file)");
+        iostrm_file = SDL_IOFromFile(IOStreamAlphabetFilename, "r");
+        SDLTest_AssertPass("Call to SDL_IOFromFile()");
+        rv_file = SDL_ReadIO(iostrm_file, buffer_file, size * 6);
+        SDLTest_AssertPass("Call to SDL_ReadIO(file, size=%d)", size * 6);
+        sv_file = SDL_SeekIO(iostrm_file, 0, SEEK_END);
+        SDLTest_AssertPass("Call to SDL_SeekIO(file,SEEK_END)");
+        result = SDL_CloseIO(iostrm_file);
+        SDLTest_AssertPass("Call to SDL_CloseIO(file)");
         SDLTest_AssertCheck(result == 0, "Verify result value is 0; got: %d", result);
 
         /* Compare */
@@ -456,11 +456,11 @@ static int rwops_testCompareRWFromMemWithRWFromFile(void *arg)
         SDLTest_AssertCheck(buffer_mem[slen] == 0, "Verify mem buffer termination; expected: 0, got: %d", buffer_mem[slen]);
         SDLTest_AssertCheck(buffer_file[slen] == 0, "Verify file buffer termination; expected: 0, got: %d", buffer_file[slen]);
         SDLTest_AssertCheck(
-            SDL_strncmp(buffer_mem, RWopsAlphabetString, slen) == 0,
-            "Verify mem buffer contain alphabet string; expected: %s, got: %s", RWopsAlphabetString, buffer_mem);
+            SDL_strncmp(buffer_mem, IOStreamAlphabetString, slen) == 0,
+            "Verify mem buffer contain alphabet string; expected: %s, got: %s", IOStreamAlphabetString, buffer_mem);
         SDLTest_AssertCheck(
-            SDL_strncmp(buffer_file, RWopsAlphabetString, slen) == 0,
-            "Verify file buffer contain alphabet string; expected: %s, got: %s", RWopsAlphabetString, buffer_file);
+            SDL_strncmp(buffer_file, IOStreamAlphabetString, slen) == 0,
+            "Verify file buffer contain alphabet string; expected: %s, got: %s", IOStreamAlphabetString, buffer_file);
     }
 
     return TEST_COMPLETED;
@@ -469,14 +469,14 @@ static int rwops_testCompareRWFromMemWithRWFromFile(void *arg)
 /**
  * Tests writing and reading from file using endian aware functions.
  *
- * \sa SDL_RWFromFile
- * \sa SDL_RWClose
+ * \sa SDL_IOFromFile
+ * \sa SDL_CloseIO
  * \sa SDL_ReadU16BE
  * \sa SDL_WriteU16BE
  */
-static int rwops_testFileWriteReadEndian(void *arg)
+static int iostrm_testFileWriteReadEndian(void *arg)
 {
-    SDL_RWops *rw;
+    SDL_IOStream *rw;
     Sint64 result;
     int mode;
     Uint16 BE16value;
@@ -529,9 +529,9 @@ static int rwops_testFileWriteReadEndian(void *arg)
         }
 
         /* Write test. */
-        rw = SDL_RWFromFile(RWopsWriteTestFilename, "w+");
-        SDLTest_AssertPass("Call to SDL_RWFromFile(..,\"w+\")");
-        SDLTest_AssertCheck(rw != NULL, "Verify opening file with SDL_RWFromFile in write mode does not return NULL");
+        rw = SDL_IOFromFile(IOStreamWriteTestFilename, "w+");
+        SDLTest_AssertPass("Call to SDL_IOFromFile(..,\"w+\")");
+        SDLTest_AssertCheck(rw != NULL, "Verify opening file with SDL_IOFromFile in write mode does not return NULL");
 
         /* Bail out if NULL */
         if (rw == NULL) {
@@ -559,9 +559,9 @@ static int rwops_testFileWriteReadEndian(void *arg)
         SDLTest_AssertCheck(bresult == SDL_TRUE, "Validate object written, expected: SDL_TRUE, got: SDL_FALSE");
 
         /* Test seek to start */
-        result = SDL_SeekRW(rw, 0, SDL_RW_SEEK_SET);
-        SDLTest_AssertPass("Call to SDL_SeekRW succeeded");
-        SDLTest_AssertCheck(result == 0, "Verify result from position 0 with SDL_SeekRW, expected 0, got %i", (int)result);
+        result = SDL_SeekIO(rw, 0, SDL_IO_SEEK_SET);
+        SDLTest_AssertPass("Call to SDL_SeekIO succeeded");
+        SDLTest_AssertCheck(result == 0, "Verify result from position 0 with SDL_SeekIO, expected 0, got %i", (int)result);
 
         /* Read test data */
         bresult = SDL_ReadU16BE(rw, &BE16test);
@@ -590,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_CloseRW(rw);
-        SDLTest_AssertPass("Call to SDL_CloseRW() succeeded");
+        cresult = SDL_CloseIO(rw);
+        SDLTest_AssertPass("Call to SDL_CloseIO() succeeded");
         SDLTest_AssertCheck(cresult == 0, "Verify result value is 0; got: %d", cresult);
     }
 
@@ -600,49 +600,49 @@ static int rwops_testFileWriteReadEndian(void *arg)
 
 /* ================= Test References ================== */
 
-/* RWops test cases */
-static const SDLTest_TestCaseReference rwopsTest1 = {
-    (SDLTest_TestCaseFp)rwops_testParamNegative, "rwops_testParamNegative", "Negative test for SDL_RWFromFile parameters", TEST_ENABLED
+/* IOStream test cases */
+static const SDLTest_TestCaseReference iostrmTest1 = {
+    (SDLTest_TestCaseFp)iostrm_testParamNegative, "iostrm_testParamNegative", "Negative test for SDL_IOFromFile parameters", TEST_ENABLED
 };
 
-static const SDLTest_TestCaseReference rwopsTest2 = {
-    (SDLTest_TestCaseFp)rwops_testMem, "rwops_testMem", "Tests opening from memory", TEST_ENABLED
+static const SDLTest_TestCaseReference iostrmTest2 = {
+    (SDLTest_TestCaseFp)iostrm_testMem, "iostrm_testMem", "Tests opening from memory", TEST_ENABLED
 };
 
-static const SDLTest_TestCaseReference rwopsTest3 = {
-    (SDLTest_TestCaseFp)rwops_testConstMem, "rwops_testConstMem", "Tests opening from (const) memory", TEST_ENABLED
+static const SDLTest_TestCaseReference iostrmTest3 = {
+    (SDLTest_TestCaseFp)iostrm_testConstMem, "iostrm_testConstMem", "Tests opening from (const) memory", TEST_ENABLED
 };
 
-static const SDLTest_TestCaseReference rwopsTest4 = {
-    (SDLTest_TestCaseFp)rwops_testFileRead, "rwops_testFileRead", "Tests reading from a file", TEST_ENABLED
+static const SDLTest_TestCaseReference iostrmTest4 = {
+    (SDLTest_TestCaseFp)iostrm_testFileRead, "iostrm_testFileRead", "Tests reading from a file", TEST_ENABLED
 };
 
-static const SDLTest_TestCaseReference rwopsTest5 = {
-    (SDLTest_TestCaseFp)rwops_testFileWrite, "rwops_testFileWrite", "Test writing to a file", TEST_ENABLED
+static const SDLTest_TestCaseReference iostrmTest5 = {
+    (SDLTest_TestCaseFp)iostrm_testFileWrite, "iostrm_testFileWrite", "Test writing to a file", TEST_ENABLED
 };
 
-static const SDLTest_TestCaseReference rwopsTest6 = {
-    (SDLTest_TestCaseFp)rwops_testAllocFree, "rwops_testAllocFree", "Test alloc and free of RW context", TEST_ENABLED
+static const SDLTest_TestCaseReference iostrmTest6 = {
+    (SDLTest_TestCaseFp)iostrm_testAllocFree, "iostrm_testAllocFree", "Test alloc and free of RW context", TEST_ENABLED
 };
 
-static const SDLTest_TestCaseReference rwopsTest7 = {
-    (SDLTest_TestCaseFp)rwops_testFileWriteReadEndian, "rwops_testFileWriteReadEndian", "Test writing and reading via the Endian aware functions", TEST_ENABLED
+static const SDLTest_TestCaseReference iostrmTest7 = {
+    (SDLTest_TestCaseFp)iostrm_testFileWriteReadEndian, "iostrm_testFileWriteReadEndian", "Test writing and reading via the Endian aware functions", TEST_ENABLED
 };
 
-static const SDLTest_TestCaseReference rwopsTest8 = {
-    (SDLTest_TestCaseFp)rwops_testCompareRWFromMemWithRWFromFile, "rwops_testCompareRWFromMemWithRWFromFile", "Compare RWFromMem and RWFromFile RWops for read and seek", TEST_ENABLED
+static const SDLTest_TestCaseReference iostrmTest8 = {
+    (SDLTest_TestCaseFp)iostrm_testCompareRWFromMemWithRWFromFile, "iostrm_testCompareRWFromMemWithRWFromFile", "Compare RWFromMem and RWFromFile IOStream for read and seek", TEST_ENABLED
 };
 
-/* Sequence of RWops test cases */
-static const SDLTest_TestCaseReference *rwopsTests[] = {
-    &rwopsTest1, &rwopsTest2, &rwopsTest3, &rwopsTest4, &rwopsTest5, &rwopsTest6,
-    &rwopsTest7, &rwopsTest8, NULL
+/* Sequence of IOStream test cases */
+static const SDLTest_TestCaseReference *iostrmTests[] = {
+    &iostrmTest1, &iostrmTest2, &iostrmTest3, &iostrmTest4, &iostrmTest5, &iostrmTest6,
+    &iostrmTest7, &iostrmTest8, NULL
 };
 
-/* RWops test suite (global) */
-SDLTest_TestSuiteReference rwopsTestSuite = {
-    "RWops",
-    RWopsSetUp,
-    rwopsTests,
-    RWopsTearDown
+/* IOStream test suite (global) */
+SDLTest_TestSuiteReference iostrmTestSuite = {
+    "IOStream",
+    IOStreamSetUp,
+    iostrmTests,
+    IOStreamTearDown
 };

test/testautomation_suites.h

@@ -27,7 +27,7 @@ extern SDLTest_TestSuiteReference platformTestSuite;
 extern SDLTest_TestSuiteReference propertiesTestSuite;
 extern SDLTest_TestSuiteReference rectTestSuite;
 extern SDLTest_TestSuiteReference renderTestSuite;
-extern SDLTest_TestSuiteReference rwopsTestSuite;
+extern SDLTest_TestSuiteReference iostrmTestSuite;
 extern SDLTest_TestSuiteReference sdltestTestSuite;
 extern SDLTest_TestSuiteReference stdlibTestSuite;
 extern SDLTest_TestSuiteReference subsystemsTestSuite;

test/testffmpeg.c

@@ -237,9 +237,9 @@ static SDL_bool CreateWindowAndRenderer(SDL_WindowFlags window_flags, const char
 static SDL_Texture *CreateTexture(SDL_Renderer *r, unsigned char *data, unsigned int len, int *w, int *h) {
     SDL_Texture *texture = NULL;
     SDL_Surface *surface;
-    SDL_RWops *src = SDL_RWFromConstMem(data, len);
+    SDL_IOStream *src = SDL_IOFromConstMem(data, len);
     if (src) {
-        surface = SDL_LoadBMP_RW(src, SDL_TRUE);
+        surface = SDL_LoadBMP_IO(src, SDL_TRUE);
         if (surface) {
             /* Treat white as transparent */
             SDL_SetSurfaceColorKey(surface, SDL_TRUE, SDL_MapRGB(surface->format, 255, 255, 255));

test/testfile.c

@@ -51,22 +51,22 @@ cleanup(void)
 }
 
 static void
-rwops_error_quit(unsigned line, SDL_RWops *rwops)
+iostrm_error_quit(unsigned line, SDL_IOStream *iostrm)
 {
     SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "testfile.c(%d): failed\n", line);
-    if (rwops) {
-        SDL_CloseRW(rwops);
+    if (iostrm) {
+        SDL_CloseIO(iostrm);
     }
     cleanup();
     SDLTest_CommonDestroyState(state);
-    exit(1); /* quit with rwops error (test failed) */
+    exit(1); /* quit with iostrm error (test failed) */
 }
 
-#define RWOP_ERR_QUIT(x) rwops_error_quit(__LINE__, (x))
+#define RWOP_ERR_QUIT(x) iostrm_error_quit(__LINE__, (x))
 
 int main(int argc, char *argv[])
 {
-    SDL_RWops *rwops = NULL;
+    SDL_IOStream *iostrm = NULL;
     char test_buf[30];
 
     /* Initialize test framework */
@@ -85,27 +85,27 @@ int main(int argc, char *argv[])
 
     cleanup();
 
-    /* test 1 : basic argument test: all those calls to SDL_RWFromFile should fail */
+    /* test 1 : basic argument test: all those calls to SDL_IOFromFile should fail */
 
-    rwops = SDL_RWFromFile(NULL, NULL);
-    if (rwops) {
-        RWOP_ERR_QUIT(rwops);
+    iostrm = SDL_IOFromFile(NULL, NULL);
+    if (iostrm) {
+        RWOP_ERR_QUIT(iostrm);
     }
-    rwops = SDL_RWFromFile(NULL, "ab+");
-    if (rwops) {
-        RWOP_ERR_QUIT(rwops);
+    iostrm = SDL_IOFromFile(NULL, "ab+");
+    if (iostrm) {
+        RWOP_ERR_QUIT(iostrm);
     }
-    rwops = SDL_RWFromFile(NULL, "sldfkjsldkfj");
-    if (rwops) {
-        RWOP_ERR_QUIT(rwops);
+    iostrm = SDL_IOFromFile(NULL, "sldfkjsldkfj");
+    if (iostrm) {
+        RWOP_ERR_QUIT(iostrm);
     }
-    rwops = SDL_RWFromFile("something", "");
-    if (rwops) {
-        RWOP_ERR_QUIT(rwops);
+    iostrm = SDL_IOFromFile("something", "");
+    if (iostrm) {
+        RWOP_ERR_QUIT(iostrm);
     }
-    rwops = SDL_RWFromFile("something", NULL);
-    if (rwops) {
-        RWOP_ERR_QUIT(rwops);
+    iostrm = SDL_IOFromFile("something", NULL);
+    if (iostrm) {
+        RWOP_ERR_QUIT(iostrm);
     }
     SDL_Log("test1 OK\n");
 
@@ -114,259 +114,259 @@ int main(int argc, char *argv[])
        modes : a, a+, w, w+ checks that it succeeds (file may not exists)
 
      */
-    rwops = SDL_RWFromFile(FBASENAME2, "rb"); /* this file doesn't exist that call must fail */
-    if (rwops) {
-        RWOP_ERR_QUIT(rwops);
+    iostrm = SDL_IOFromFile(FBASENAME2, "rb"); /* this file doesn't exist that call must fail */
+    if (iostrm) {
+        RWOP_ERR_QUIT(iostrm);
     }
-    rwops = SDL_RWFromFile(FBASENAME2, "rb+"); /* this file doesn't exist that call must fail */
-    if (rwops) {
-        RWOP_ERR_QUIT(rwops);
+    iostrm = SDL_IOFromFile(FBASENAME2, "rb+"); /* this file doesn't exist that call must fail */
+    if (iostrm) {
+        RWOP_ERR_QUIT(iostrm);
     }
-    rwops = SDL_RWFromFile(FBASENAME2, "wb");
-    if (!rwops) {
-        RWOP_ERR_QUIT(rwops);
+    iostrm = SDL_IOFromFile(FBASENAME2, "wb");
+    if (!iostrm) {
+        RWOP_ERR_QUIT(iostrm);
     }
-    SDL_CloseRW(rwops);
+    SDL_CloseIO(iostrm);
     unlink(FBASENAME2);
-    rwops = SDL_RWFromFile(FBASENAME2, "wb+");
-    if (!rwops) {
-        RWOP_ERR_QUIT(rwops);
+    iostrm = SDL_IOFromFile(FBASENAME2, "wb+");
+    if (!iostrm) {
+        RWOP_ERR_QUIT(iostrm);
     }
-    SDL_CloseRW(rwops);
+    SDL_CloseIO(iostrm);
     unlink(FBASENAME2);
-    rwops = SDL_RWFromFile(FBASENAME2, "ab");
-    if (!rwops) {
-        RWOP_ERR_QUIT(rwops);
+    iostrm = SDL_IOFromFile(FBASENAME2, "ab");
+    if (!iostrm) {
+        RWOP_ERR_QUIT(iostrm);
     }
-    SDL_CloseRW(rwops);
+    SDL_CloseIO(iostrm);
     unlink(FBASENAME2);
-    rwops = SDL_RWFromFile(FBASENAME2, "ab+");
-    if (!rwops) {
-        RWOP_ERR_QUIT(rwops);
+    iostrm = SDL_IOFromFile(FBASENAME2, "ab+");
+    if (!iostrm) {
+        RWOP_ERR_QUIT(iostrm);
     }
-    SDL_CloseRW(rwops);
+    SDL_CloseIO(iostrm);
     unlink(FBASENAME2);
     SDL_Log("test2 OK\n");
 
     /* test 3 : creation, writing , reading, seeking,
                 test : w mode, r mode, w+ mode
      */
-    rwops = SDL_RWFromFile(FBASENAME1, "wb"); /* write only */
-    if (!rwops) {
-        RWOP_ERR_QUIT(rwops);
+    iostrm = SDL_IOFromFile(FBASENAME1, "wb"); /* write only */
+    if (!iostrm) {
+        RWOP_ERR_QUIT(iostrm);
     }
-    if (10 != SDL_WriteRW(rwops, "1234567890", 10)) {
-        RWOP_ERR_QUIT(rwops);
+    if (10 != SDL_WriteIO(iostrm, "1234567890", 10)) {
+        RWOP_ERR_QUIT(iostrm);
     }
-    if (10 != SDL_WriteRW(rwops, "1234567890", 10)) {
-        RWOP_ERR_QUIT(rwops);
+    if (10 != SDL_WriteIO(iostrm, "1234567890", 10)) {
+        RWOP_ERR_QUIT(iostrm);
     }
-    if (7 != SDL_WriteRW(rwops, "1234567", 7)) {
-        RWOP_ERR_QUIT(rwops);
+    if (7 != SDL_WriteIO(iostrm, "1234567", 7)) {
+        RWOP_ERR_QUIT(iostrm);
     }
-    if (0 != SDL_SeekRW(rwops, 0L, SDL_RW_SEEK_SET)) {
-        RWOP_ERR_QUIT(rwops);
+    if (0 != SDL_SeekIO(iostrm, 0L, SDL_IO_SEEK_SET)) {
+        RWOP_ERR_QUIT(iostrm);
     }
-    if (0 != SDL_ReadRW(rwops, test_buf, 1)) {
-        RWOP_ERR_QUIT(rwops); /* we are in write only mode */
+    if (0 != SDL_ReadIO(iostrm, test_buf, 1)) {
+        RWOP_ERR_QUIT(iostrm); /* we are in write only mode */
     }
 
-    SDL_CloseRW(rwops);
+    SDL_CloseIO(iostrm);
 
-    rwops = SDL_RWFromFile(FBASENAME1, "rb"); /* read mode, file must exist */
-    if (!rwops) {
-        RWOP_ERR_QUIT(rwops);
+    iostrm = SDL_IOFromFile(FBASENAME1, "rb"); /* read mode, file must exist */
+    if (!iostrm) {
+        RWOP_ERR_QUIT(iostrm);
     }
-    if (0 != SDL_SeekRW(rwops, 0L, SDL_RW_SEEK_SET)) {
-        RWOP_ERR_QUIT(rwops);
+    if (0 != SDL_SeekIO(iostrm, 0L, SDL_IO_SEEK_SET)) {
+        RWOP_ERR_QUIT(iostrm);
     }
-    if (20 != SDL_SeekRW(rwops, -7, SDL_RW_SEEK_END)) {
-        RWOP_ERR_QUIT(rwops);
+    if (20 != SDL_SeekIO(iostrm, -7, SDL_IO_SEEK_END)) {
+        RWOP_ERR_QUIT(iostrm);
     }
-    if (7 != SDL_ReadRW(rwops, test_buf, 7)) {
-        RWOP_ERR_QUIT(rwops);
+    if (7 != SDL_ReadIO(iostrm, test_buf, 7)) {
+        RWOP_ERR_QUIT(iostrm);
     }
     if (SDL_memcmp(test_buf, "1234567", 7) != 0) {
-        RWOP_ERR_QUIT(rwops);
+        RWOP_ERR_QUIT(iostrm);
     }
-    if (0 != SDL_ReadRW(rwops, test_buf, 1)) {
-        RWOP_ERR_QUIT(rwops);
+    if (0 != SDL_ReadIO(iostrm, test_buf, 1)) {
+        RWOP_ERR_QUIT(iostrm);
     }
-    if (0 != SDL_ReadRW(rwops, test_buf, 1000)) {
-        RWOP_ERR_QUIT(rwops);
+    if (0 != SDL_ReadIO(iostrm, test_buf, 1000)) {
+        RWOP_ERR_QUIT(iostrm);
     }
-    if (0 != SDL_SeekRW(rwops, -27, SDL_RW_SEEK_CUR)) {
-        RWOP_ERR_QUIT(rwops);
+    if (0 != SDL_SeekIO(iostrm, -27, SDL_IO_SEEK_CUR)) {
+        RWOP_ERR_QUIT(iostrm);
     }
-    if (27 != SDL_ReadRW(rwops, test_buf, 30)) {
-        RWOP_ERR_QUIT(rwops);
+    if (27 != SDL_ReadIO(iostrm, test_buf, 30)) {
+        RWOP_ERR_QUIT(iostrm);
     }
     if (SDL_memcmp(test_buf, "12345678901234567890", 20) != 0) {
-        RWOP_ERR_QUIT(rwops);
+        RWOP_ERR_QUIT(iostrm);
     }
-    if (0 != SDL_WriteRW(rwops, test_buf, 1)) {
-        RWOP_ERR_QUIT(rwops); /* readonly mode */
+    if (0 != SDL_WriteIO(iostrm, test_buf, 1)) {
+        RWOP_ERR_QUIT(iostrm); /* readonly mode */
     }
 
-    SDL_CloseRW(rwops);
+    SDL_CloseIO(iostrm);
 
     /* test 3: same with w+ mode */
-    rwops = SDL_RWFromFile(FBASENAME1, "wb+"); /* write + read + truncation */
-    if (!rwops) {
-        RWOP_ERR_QUIT(rwops);
+    iostrm = SDL_IOFromFile(FBASENAME1, "wb+"); /* write + read + truncation */
+    if (!iostrm) {
+        RWOP_ERR_QUIT(iostrm);
     }
-    if (10 != SDL_WriteRW(rwops, "1234567890", 10)) {
-        RWOP_ERR_QUIT(rwops);
+    if (10 != SDL_WriteIO(iostrm, "1234567890", 10)) {
+        RWOP_ERR_QUIT(iostrm);
     }
-    if (10 != SDL_WriteRW(rwops, "1234567890", 10)) {
-        RWOP_ERR_QUIT(rwops);
+    if (10 != SDL_WriteIO(iostrm, "1234567890", 10)) {
+        RWOP_ERR_QUIT(iostrm);
     }
-    if (7 != SDL_WriteRW(rwops, "1234567", 7)) {
-        RWOP_ERR_QUIT(rwops);
+    if (7 != SDL_WriteIO(iostrm, "1234567", 7)) {
+        RWOP_ERR_QUIT(iostrm);
     }
-    if (0 != SDL_SeekRW(rwops, 0L, SDL_RW_SEEK_SET)) {
-        RWOP_ERR_QUIT(rwops);
+    if (0 != SDL_SeekIO(iostrm, 0L, SDL_IO_SEEK_SET)) {
+        RWOP_ERR_QUIT(iostrm);
     }
-    if (1 != SDL_ReadRW(rwops, test_buf, 1)) {
-        RWOP_ERR_QUIT(rwops); /* we are in read/write mode */
+    if (1 != SDL_ReadIO(iostrm, test_buf, 1)) {
+        RWOP_ERR_QUIT(iostrm); /* we are in read/write mode */
     }
 
-    if (0 != SDL_SeekRW(rwops, 0L, SDL_RW_SEEK_SET)) {
-        RWOP_ERR_QUIT(rwops);
+    if (0 != SDL_SeekIO(iostrm, 0L, SDL_IO_SEEK_SET)) {
+        RWOP_ERR_QUIT(iostrm);
     }
-    if (20 != SDL_SeekRW(rwops, -7, SDL_RW_SEEK_END)) {
-        RWOP_ERR_QUIT(rwops);
+    if (20 != SDL_SeekIO(iostrm, -7, SDL_IO_SEEK_END)) {
+        RWOP_ERR_QUIT(iostrm);
     }
-    if (7 != SDL_ReadRW(rwops, test_buf, 7)) {
-        RWOP_ERR_QUIT(rwops);
+    if (7 != SDL_ReadIO(iostrm, test_buf, 7)) {
+        RWOP_ERR_QUIT(iostrm);
     }
     if (SDL_memcmp(test_buf, "1234567", 7) != 0) {
-        RWOP_ERR_QUIT(rwops);
+        RWOP_ERR_QUIT(iostrm);
     }
-    if (0 != SDL_ReadRW(rwops, test_buf, 1)) {
-        RWOP_ERR_QUIT(rwops);
+    if (0 != SDL_ReadIO(iostrm, test_buf, 1)) {
+        RWOP_ERR_QUIT(iostrm);
     }
-    if (0 != SDL_ReadRW(rwops, test_buf, 1000)) {
-        RWOP_ERR_QUIT(rwops);
+    if (0 != SDL_ReadIO(iostrm, test_buf, 1000)) {
+        RWOP_ERR_QUIT(iostrm);
     }
-    if (0 != SDL_SeekRW(rwops, -27, SDL_RW_SEEK_CUR)) {
-        RWOP_ERR_QUIT(rwops);
+    if (0 != SDL_SeekIO(iostrm, -27, SDL_IO_SEEK_CUR)) {
+        RWOP_ERR_QUIT(iostrm);
     }
-    if (27 != SDL_ReadRW(rwops, test_buf, 30)) {
-        RWOP_ERR_QUIT(rwops);
+    if (27 != SDL_ReadIO(iostrm, test_buf, 30)) {
+        RWOP_ERR_QUIT(iostrm);
     }
     if (SDL_memcmp(test_buf, "12345678901234567890", 20) != 0) {
-        RWOP_ERR_QUIT(rwops);
+        RWOP_ERR_QUIT(iostrm);
     }
-    SDL_CloseRW(rwops);
+    SDL_CloseIO(iostrm);
     SDL_Log("test3 OK\n");
 
     /* test 4: same in r+ mode */
-    rwops = SDL_RWFromFile(FBASENAME1, "rb+"); /* write + read + file must exists, no truncation */
-    if (!rwops) {
-        RWOP_ERR_QUIT(rwops);
+    iostrm = SDL_IOFromFile(FBASENAME1, "rb+"); /* write + read + file must exists, no truncation */
+    if (!iostrm) {
+        RWOP_ERR_QUIT(iostrm);
     }
-    if (10 != SDL_WriteRW(rwops, "1234567890", 10)) {
-        RWOP_ERR_QUIT(rwops);
+    if (10 != SDL_WriteIO(iostrm, "1234567890", 10)) {
+        RWOP_ERR_QUIT(iostrm);
     }
-    if (10 != SDL_WriteRW(rwops, "1234567890", 10)) {
-        RWOP_ERR_QUIT(rwops);
+    if (10 != SDL_WriteIO(iostrm, "1234567890", 10)) {
+        RWOP_ERR_QUIT(iostrm);
     }
-    if (7 != SDL_WriteRW(rwops, "1234567", 7)) {
-        RWOP_ERR_QUIT(rwops);
+    if (7 != SDL_WriteIO(iostrm, "1234567", 7)) {
+        RWOP_ERR_QUIT(iostrm);
     }
-    if (0 != SDL_SeekRW(rwops, 0L, SDL_RW_SEEK_SET)) {
-        RWOP_ERR_QUIT(rwops);
+    if (0 != SDL_SeekIO(iostrm, 0L, SDL_IO_SEEK_SET)) {
+        RWOP_ERR_QUIT(iostrm);
     }
-    if (1 != SDL_ReadRW(rwops, test_buf, 1)) {
-        RWOP_ERR_QUIT(rwops); /* we are in read/write mode */
+    if (1 != SDL_ReadIO(iostrm, test_buf, 1)) {
+        RWOP_ERR_QUIT(iostrm); /* we are in read/write mode */
     }
 
-    if (0 != SDL_SeekRW(rwops, 0L, SDL_RW_SEEK_SET)) {
-        RWOP_ERR_QUIT(rwops);
+    if (0 != SDL_SeekIO(iostrm, 0L, SDL_IO_SEEK_SET)) {
+        RWOP_ERR_QUIT(iostrm);
     }
-    if (20 != SDL_SeekRW(rwops, -7, SDL_RW_SEEK_END)) {
-        RWOP_ERR_QUIT(rwops);
+    if (20 != SDL_SeekIO(iostrm, -7, SDL_IO_SEEK_END)) {
+        RWOP_ERR_QUIT(iostrm);
     }
-    if (7 != SDL_ReadRW(rwops, test_buf, 7)) {
-        RWOP_ERR_QUIT(rwops);
+    if (7 != SDL_ReadIO(iostrm, test_buf, 7)) {
+        RWOP_ERR_QUIT(iostrm);
     }
     if (SDL_memcmp(test_buf, "1234567", 7) != 0) {
-        RWOP_ERR_QUIT(rwops);
+        RWOP_ERR_QUIT(iostrm);
     }
-    if (0 != SDL_ReadRW(rwops, test_buf, 1)) {
-        RWOP_ERR_QUIT(rwops);
+    if (0 != SDL_ReadIO(iostrm, test_buf, 1)) {
+        RWOP_ERR_QUIT(iostrm);
     }
-    if (0 != SDL_ReadRW(rwops, test_buf, 1000)) {
-        RWOP_ERR_QUIT(rwops);
+    if (0 != SDL_ReadIO(iostrm, test_buf, 1000)) {
+        RWOP_ERR_QUIT(iostrm);
     }
-    if (0 != SDL_SeekRW(rwops, -27, SDL_RW_SEEK_CUR)) {
-        RWOP_ERR_QUIT(rwops);
+    if (0 != SDL_SeekIO(iostrm, -27, SDL_IO_SEEK_CUR)) {
+        RWOP_ERR_QUIT(iostrm);
     }
-    if (27 != SDL_ReadRW(rwops, test_buf, 30)) {
-        RWOP_ERR_QUIT(rwops);
+    if (27 != SDL_ReadIO(iostrm, test_buf, 30)) {
+        RWOP_ERR_QUIT(iostrm);
     }
     if (SDL_memcmp(test_buf, "12345678901234567890", 20) != 0) {
-        RWOP_ERR_QUIT(rwops);
+        RWOP_ERR_QUIT(iostrm);
     }
-    SDL_CloseRW(rwops);
+    SDL_CloseIO(iostrm);
     SDL_Log("test4 OK\n");
 
     /* test5 : append mode */
-    rwops = SDL_RWFromFile(FBASENAME1, "ab+"); /* write + read + append */
-    if (!rwops) {
-        RWOP_ERR_QUIT(rwops);
+    iostrm = SDL_IOFromFile(FBASENAME1, "ab+"); /* write + read + append */
+    if (!iostrm) {
+        RWOP_ERR_QUIT(iostrm);
     }
-    if (10 != SDL_WriteRW(rwops, "1234567890", 10)) {
-        RWOP_ERR_QUIT(rwops);
+    if (10 != SDL_WriteIO(iostrm, "1234567890", 10)) {
+        RWOP_ERR_QUIT(iostrm);
     }
-    if (10 != SDL_WriteRW(rwops, "1234567890", 10)) {
-        RWOP_ERR_QUIT(rwops);
+    if (10 != SDL_WriteIO(iostrm, "1234567890", 10)) {
+        RWOP_ERR_QUIT(iostrm);
     }
-    if (7 != SDL_WriteRW(rwops, "1234567", 7)) {
-        RWOP_ERR_QUIT(rwops);
+    if (7 != SDL_WriteIO(iostrm, "1234567", 7)) {
+        RWOP_ERR_QUIT(iostrm);
     }
-    if (0 != SDL_SeekRW(rwops, 0L, SDL_RW_SEEK_SET)) {
-        RWOP_ERR_QUIT(rwops);
+    if (0 != SDL_SeekIO(iostrm, 0L, SDL_IO_SEEK_SET)) {
+        RWOP_ERR_QUIT(iostrm);
     }
 
-    if (1 != SDL_ReadRW(rwops, test_buf, 1)) {
-        RWOP_ERR_QUIT(rwops);
+    if (1 != SDL_ReadIO(iostrm, test_buf, 1)) {
+        RWOP_ERR_QUIT(iostrm);
     }
-    if (0 != SDL_SeekRW(rwops, 0L, SDL_RW_SEEK_SET)) {
-        RWOP_ERR_QUIT(rwops);
+    if (0 != SDL_SeekIO(iostrm, 0L, SDL_IO_SEEK_SET)) {
+        RWOP_ERR_QUIT(iostrm);
     }
 
-    if (20 + 27 != SDL_SeekRW(rwops, -7, SDL_RW_SEEK_END)) {
-        RWOP_ERR_QUIT(rwops);
+    if (20 + 27 != SDL_SeekIO(iostrm, -7, SDL_IO_SEEK_END)) {
+        RWOP_ERR_QUIT(iostrm);
     }
-    if (7 != SDL_ReadRW(rwops, test_buf, 7)) {
-        RWOP_ERR_QUIT(rwops);
+    if (7 != SDL_ReadIO(iostrm, test_buf, 7)) {
+        RWOP_ERR_QUIT(iostrm);
     }
     if (SDL_memcmp(test_buf, "1234567", 7) != 0) {
-        RWOP_ERR_QUIT(rwops);
+        RWOP_ERR_QUIT(iostrm);
     }
-    if (0 != SDL_ReadRW(rwops, test_buf, 1)) {
-        RWOP_ERR_QUIT(rwops);
+    if (0 != SDL_ReadIO(iostrm, test_buf, 1)) {
+        RWOP_ERR_QUIT(iostrm);
     }
-    if (0 != SDL_ReadRW(rwops, test_buf, 1000)) {
-        RWOP_ERR_QUIT(rwops);
+    if (0 != SDL_ReadIO(iostrm, test_buf, 1000)) {
+        RWOP_ERR_QUIT(iostrm);
     }
 
-    if (27 != SDL_SeekRW(rwops, -27, SDL_RW_SEEK_CUR)) {
-        RWOP_ERR_QUIT(rwops);
+    if (27 != SDL_SeekIO(iostrm, -27, SDL_IO_SEEK_CUR)) {
+        RWOP_ERR_QUIT(iostrm);
     }
 
-    if (0 != SDL_SeekRW(rwops, 0L, SDL_RW_SEEK_SET)) {
-        RWOP_ERR_QUIT(rwops);
+    if (0 != SDL_SeekIO(iostrm, 0L, SDL_IO_SEEK_SET)) {
+        RWOP_ERR_QUIT(iostrm);
     }
-    if (30 != SDL_ReadRW(rwops, test_buf, 30)) {
-        RWOP_ERR_QUIT(rwops);
+    if (30 != SDL_ReadIO(iostrm, test_buf, 30)) {
+        RWOP_ERR_QUIT(iostrm);
     }
     if (SDL_memcmp(test_buf, "123456789012345678901234567123", 30) != 0) {
-        RWOP_ERR_QUIT(rwops);
+        RWOP_ERR_QUIT(iostrm);
     }
-    SDL_CloseRW(rwops);
+    SDL_CloseIO(iostrm);
     SDL_Log("test5 OK\n");
     cleanup();
     SDL_Quit();

test/testime.c

@@ -109,7 +109,7 @@ static int unifont_init(const char *fontname)
     Uint32 numGlyphs = 0;
     int lineNumber = 1;
     size_t bytesRead;
-    SDL_RWops *hexFile;
+    SDL_IOStream *hexFile;
     const size_t unifontGlyphSize = UNIFONT_NUM_GLYPHS * sizeof(struct UnifontGlyph);
     const size_t unifontTextureSize = UNIFONT_NUM_TEXTURES * state->num_windows * sizeof(void *);
     char *filename;
@@ -135,7 +135,7 @@ static int unifont_init(const char *fontname)
         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Out of memory\n");
         return -1;
     }
-    hexFile = SDL_RWFromFile(filename, "rb");
+    hexFile = SDL_IOFromFile(filename, "rb");
     SDL_free(filename);
     if (!hexFile) {
         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "unifont: Failed to open font file: %s\n", fontname);
@@ -149,7 +149,7 @@ static int unifont_init(const char *fontname)
         Uint8 glyphWidth;
         Uint32 codepoint;
 
-        bytesRead = SDL_ReadRW(hexFile, hexBuffer, 9);
+        bytesRead = SDL_ReadIO(hexFile, hexBuffer, 9);
         if (numGlyphs > 0 && bytesRead == 0) {
             break; /* EOF */
         }
@@ -185,7 +185,7 @@ static int unifont_init(const char *fontname)
         if (codepointHexSize < 8) {
             SDL_memmove(hexBuffer, hexBuffer + codepointHexSize + 1, bytesOverread);
         }
-        bytesRead = SDL_ReadRW(hexFile, hexBuffer + bytesOverread, 33 - bytesOverread);
+        bytesRead = SDL_ReadIO(hexFile, hexBuffer + bytesOverread, 33 - bytesOverread);
 
         if (bytesRead < (33 - bytesOverread)) {
             SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "unifont: Unexpected end of hex file.\n");
@@ -195,7 +195,7 @@ static int unifont_init(const char *fontname)
             glyphWidth = 8;
         } else {
             glyphWidth = 16;
-            bytesRead = SDL_ReadRW(hexFile, hexBuffer + 33, 32);
+            bytesRead = SDL_ReadIO(hexFile, hexBuffer + 33, 32);
             if (bytesRead < 32) {
                 SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "unifont: Unexpected end of hex file.\n");
                 return -1;
@@ -223,7 +223,7 @@ static int unifont_init(const char *fontname)
         lineNumber++;
     } while (bytesRead > 0);
 
-    SDL_CloseRW(hexFile);
+    SDL_CloseIO(hexFile);
     SDL_Log("unifont: Loaded %" SDL_PRIu32 " glyphs.\n", numGlyphs);
     return 0;
 }

test/testoverlay.c

@@ -318,7 +318,7 @@ static void loop(void)
 
 int main(int argc, char **argv)
 {
-    SDL_RWops *handle;
+    SDL_IOStream *handle;
     int i;
     int j;
     int fps = 12;
@@ -443,16 +443,16 @@ int main(int argc, char **argv)
         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Out of memory\n");
         quit(2);
     }
-    handle = SDL_RWFromFile(filename, "rb");
+    handle = SDL_IOFromFile(filename, "rb");
     SDL_free(filename);
     if (!handle) {
         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Can't find the file moose.dat !\n");
         quit(2);
     }
 
-    SDL_ReadRW(handle, RawMooseData, MOOSEFRAME_SIZE * MOOSEFRAMES_COUNT);
+    SDL_ReadIO(handle, RawMooseData, MOOSEFRAME_SIZE * MOOSEFRAMES_COUNT);
 
-    SDL_CloseRW(handle);
+    SDL_CloseIO(handle);
 
     /* Create the window and renderer */
     window_w = MOOSEPIC_W * scale;

test/testresample.c

@@ -30,7 +30,7 @@ int main(int argc, char **argv)
     int bitsize = 0;
     int blockalign = 0;
     int avgbytes = 0;
-    SDL_RWops *io = NULL;
+    SDL_IOStream *io = NULL;
     int dst_len;
     int ret = 0;
     int argpos = 0;
@@ -115,7 +115,7 @@ int main(int argc, char **argv)
     }
 
     /* write out a WAV header... */
-    io = SDL_RWFromFile(file_out, "wb");
+    io = SDL_IOFromFile(file_out, "wb");
     if (!io) {
         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "opening '%s' failed: %s\n", file_out, SDL_GetError());
         ret = 5;
@@ -139,9 +139,9 @@ int main(int argc, char **argv)
     SDL_WriteU16LE(io, (Uint16)bitsize);                        /* significant bits per sample */
     SDL_WriteU32LE(io, 0x61746164);                             /* data */
     SDL_WriteU32LE(io, dst_len);                                /* size */
-    SDL_WriteRW(io, dst_buf, dst_len);
+    SDL_WriteIO(io, dst_buf, dst_len);
 
-    if (SDL_CloseRW(io) == -1) {
+    if (SDL_CloseIO(io) == -1) {
         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "closing '%s' failed: %s\n", file_out, SDL_GetError());
         ret = 6;
         goto end;

test/testshape.c

@@ -60,7 +60,7 @@ int main(int argc, char *argv[])
             goto quit;
         }
     } else {
-        shape = SDL_LoadBMP_RW(SDL_RWFromConstMem(glass_bmp, sizeof(glass_bmp)), SDL_TRUE);
+        shape = SDL_LoadBMP_IO(SDL_IOFromConstMem(glass_bmp, sizeof(glass_bmp)), SDL_TRUE);
         if (!shape) {
             SDL_Log("Couldn't load glass.bmp: %s\n", SDL_GetError());
             goto quit;

test/testspriteminimal.c

@@ -39,9 +39,9 @@ static int done;
 static SDL_Texture *CreateTexture(SDL_Renderer *r, unsigned char *data, unsigned int len, int *w, int *h) {
     SDL_Texture *texture = NULL;
     SDL_Surface *surface;
-    SDL_RWops *src = SDL_RWFromConstMem(data, len);
+    SDL_IOStream *src = SDL_IOFromConstMem(data, len);
     if (src) {
-        surface = SDL_LoadBMP_RW(src, SDL_TRUE);
+        surface = SDL_LoadBMP_IO(src, SDL_TRUE);
         if (surface) {
             /* Treat white as transparent */
             SDL_SetSurfaceColorKey(surface, SDL_TRUE, SDL_MapRGB(surface->format, 255, 255, 255));

test/teststreaming.c

@@ -136,7 +136,7 @@ static void loop(void)
 int main(int argc, char **argv)
 {
     SDL_Window *window;
-    SDL_RWops *handle;
+    SDL_IOStream *handle;
     char *filename = NULL;
 
     /* Initialize test framework */
@@ -164,14 +164,14 @@ int main(int argc, char **argv)
         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Out of memory\n");
         return -1;
     }
-    handle = SDL_RWFromFile(filename, "rb");
+    handle = SDL_IOFromFile(filename, "rb");
     SDL_free(filename);
     if (!handle) {
         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Can't find the file moose.dat !\n");
         quit(2);
     }
-    SDL_ReadRW(handle, MooseFrames, MOOSEFRAME_SIZE * MOOSEFRAMES_COUNT);
-    SDL_CloseRW(handle);
+    SDL_ReadIO(handle, MooseFrames, MOOSEFRAME_SIZE * MOOSEFRAMES_COUNT);
+    SDL_CloseIO(handle);
 
     /* Create the window and renderer */
     window = SDL_CreateWindow("Happy Moose", MOOSEPIC_W * 4, MOOSEPIC_H * 4, SDL_WINDOW_RESIZABLE);

test/testutils.c

@@ -29,7 +29,7 @@ GetNearbyFilename(const char *file)
     base = SDL_GetBasePath();
 
     if (base) {
-        SDL_RWops *rw;
+        SDL_IOStream *rw;
         size_t len = SDL_strlen(base) + SDL_strlen(file) + 1;
 
         path = SDL_malloc(len);
@@ -42,9 +42,9 @@ GetNearbyFilename(const char *file)
         (void)SDL_snprintf(path, len, "%s%s", base, file);
         SDL_free(base);
 
-        rw = SDL_RWFromFile(path, "rb");
+        rw = SDL_IOFromFile(path, "rb");
         if (rw) {
-            SDL_CloseRW(rw);
+            SDL_CloseIO(rw);
             return path;
         }
 

test/testwaylandcustom.c

@@ -36,9 +36,9 @@ static SDL_Texture *CreateTexture(SDL_Renderer *r, unsigned char *data, unsigned
 {
     SDL_Texture *texture = NULL;
     SDL_Surface *surface;
-    SDL_RWops *src = SDL_RWFromConstMem(data, len);
+    SDL_IOStream *src = SDL_IOFromConstMem(data, len);
     if (src) {
-        surface = SDL_LoadBMP_RW(src, SDL_TRUE);
+        surface = SDL_LoadBMP_IO(src, SDL_TRUE);
         if (surface) {
             /* Treat white as transparent */
             SDL_SetSurfaceColorKey(surface, SDL_TRUE, SDL_MapRGB(surface->format, 255, 255, 255));