src/file/SDL_rwops.c

   1 /*
   2     SDL - Simple DirectMedia Layer
   3     Copyright (C) 1997-2009 Sam Lantinga
   4
   5     This library is free software; you can redistribute it and/or
   6     modify it under the terms of the GNU Lesser General Public
   7     License as published by the Free Software Foundation; either
   8     version 2.1 of the License, or (at your option) any later version.
   9
  10     This library is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13     Lesser General Public License for more details.
  14
  15     You should have received a copy of the GNU Lesser General Public
  16     License along with this library; if not, write to the Free Software
  17     Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  18
  19     Sam Lantinga
  20     slouken@libsdl.org
  21 */
  22 #include "SDL_config.h"
  23
  24 /* This file provides a general interface for SDL to read and write
  25    data sources.  It can easily be extended to files, memory, etc.
  26 */
  27
  28 #include "SDL_endian.h"
  29 #include "SDL_rwops.h"
  30
  31
  32 #if defined(__WIN32__) && !defined(__SYMBIAN32__)
  33
  34 /* Functions to read/write Win32 API file pointers */
  35 /* Will not use it on WinCE because stdio is buffered, it means
  36    faster, and all stdio functions anyway are embedded in coredll.dll -
  37    the main wince dll*/
  38
  39 #define WINDOWS_LEAN_AND_MEAN
  40 #include <windows.h>
  41
  42 #ifndef INVALID_SET_FILE_POINTER
  43 #define INVALID_SET_FILE_POINTER 0xFFFFFFFF
  44 #endif
  45
  46 #define READAHEAD_BUFFER_SIZE   1024
  47
  48 static int SDLCALL win32_file_open(SDL_RWops *context, const char *filename, const char *mode)
  49 {
  50 #ifndef _WIN32_WCE
  51         UINT    old_error_mode;
  52 #endif
  53         HANDLE  h;
  54         DWORD   r_right, w_right;
  55         DWORD   must_exist, truncate;
  56         int             a_mode;
  57
  58         if (!context)
  59                 return -1; /* failed (invalid call) */
  60
  61         context->hidden.win32io.h = INVALID_HANDLE_VALUE; /* mark this as unusable */
  62         context->hidden.win32io.buffer.data = NULL;
  63         context->hidden.win32io.buffer.size = 0;
  64         context->hidden.win32io.buffer.left = 0;
  65
  66         /* "r" = reading, file must exist */
  67         /* "w" = writing, truncate existing, file may not exist */
  68         /* "r+"= reading or writing, file must exist            */
  69         /* "a" = writing, append file may not exist             */
  70         /* "a+"= append + read, file may not exist              */
  71         /* "w+" = read, write, truncate. file may not exist    */
  72
  73         must_exist = ( SDL_strchr(mode,'r') != NULL ) ? OPEN_EXISTING : 0;
  74         truncate   = ( SDL_strchr(mode,'w') != NULL ) ? CREATE_ALWAYS : 0;
  75         r_right    = ( SDL_strchr(mode,'+') != NULL || must_exist ) ? GENERIC_READ : 0;
  76         a_mode     = ( SDL_strchr(mode,'a') != NULL ) ? OPEN_ALWAYS : 0;
  77         w_right    = ( a_mode || SDL_strchr(mode,'+') || truncate ) ? GENERIC_WRITE : 0;
  78
  79         if (!r_right && !w_right) /* inconsistent mode */
  80                 return -1; /* failed (invalid call) */
  81
  82         context->hidden.win32io.buffer.data = (char *)SDL_malloc(READAHEAD_BUFFER_SIZE);
  83         if (!context->hidden.win32io.buffer.data) {
  84                 SDL_OutOfMemory();
  85                 return -1;
  86         }
  87
  88 #ifdef _WIN32_WCE
  89         {
  90                 size_t size = SDL_strlen(filename)+1;
  91                 wchar_t *filenameW = SDL_stack_alloc(wchar_t, size);
  92
  93                 if ( MultiByteToWideChar(CP_UTF8, 0, filename, -1, filenameW, size) == 0 ) {
  94                         SDL_stack_free(filenameW);
  95                         SDL_free(context->hidden.win32io.buffer.data);
  96                         context->hidden.win32io.buffer.data = NULL;
  97                         SDL_SetError("Unable to convert filename to Unicode");
  98                         return -1;
  99                 }
 100                 h = CreateFile(filenameW, (w_right|r_right), (w_right)? 0 : FILE_SHARE_READ,
 101                                            NULL, (must_exist|truncate|a_mode), FILE_ATTRIBUTE_NORMAL,NULL);
 102                 SDL_stack_free(filenameW);
 103         }
 104 #else
 105         {
 106
 107         /* handle Unicode filenames.  We do some tapdancing here to make sure this
 108            works on Win9x, which doesn't support anything but 1-byte codepages. */
 109         const size_t size = SDL_strlen(filename)+1;
 110         static int unicode_support = -1;
 111
 112         if (unicode_support == -1) {
 113                 OSVERSIONINFO osVerInfo;     /* Information about the OS */
 114                 osVerInfo.dwOSVersionInfoSize = sizeof(osVerInfo);
 115                 if (!GetVersionEx(&osVerInfo)) {
 116                         unicode_support = 0;
 117                 } else if (osVerInfo.dwPlatformId != VER_PLATFORM_WIN32_WINDOWS) {
 118                         unicode_support = 1;  /* Not Win95/98/ME. */
 119                 } else {
 120                         unicode_support = 0;
 121                 }
 122         }
 123
 124         if (unicode_support) {  /* everything but Win95/98/ME. */
 125                 wchar_t *filenameW = SDL_stack_alloc(wchar_t, size);
 126                 if ( MultiByteToWideChar(CP_UTF8, 0, filename, -1, filenameW, size) == 0 ) {
 127                         SDL_stack_free(filenameW);
 128                         SDL_free(context->hidden.win32io.buffer.data);
 129                         context->hidden.win32io.buffer.data = NULL;
 130                         SDL_SetError("Unable to convert filename to Unicode");
 131                         return -1;
 132                 }
 133
 134                 /* Do not open a dialog box if failure */
 135                 old_error_mode = SetErrorMode(SEM_NOOPENFILEERRORBOX|SEM_FAILCRITICALERRORS);
 136                 h = CreateFileW(filenameW, (w_right|r_right), (w_right)? 0 : FILE_SHARE_READ,
 137                                            NULL, (must_exist|truncate|a_mode), FILE_ATTRIBUTE_NORMAL,NULL);
 138                 /* restore old behaviour */
 139                 SetErrorMode(old_error_mode);
 140
 141                 SDL_stack_free(filenameW);
 142         } else {
 143                 /* CP_UTF8 might not be supported (Win95), so use SDL_iconv to get wchars. */
 144                 /* Use UCS2: no UTF-16 support here. Try again in SDL 1.3.  :) */
 145                 char *utf16 = SDL_iconv_string("UCS2", "UTF8", filename, SDL_strlen(filename) + 1);
 146                 char *filenameA = SDL_stack_alloc(char, size * 6);  /* 6, just in case. */
 147                 BOOL bDefCharUsed = FALSE;
 148
 149                 /* Dither down to a codepage and hope for the best. */
 150                 if (!utf16 ||
 151                         !WideCharToMultiByte(CP_ACP, 0, (LPCWSTR)utf16, -1, filenameA, size*6, 0, &bDefCharUsed) ||
 152                         bDefCharUsed) {
 153                         SDL_stack_free(filenameA);
 154                         SDL_free(utf16);
 155                         SDL_free(context->hidden.win32io.buffer.data);
 156                         context->hidden.win32io.buffer.data = NULL;
 157                         SDL_SetError("Unable to convert filename to Unicode");
 158                         return -1;
 159                 }
 160
 161                 /* Do not open a dialog box if failure */
 162                 old_error_mode = SetErrorMode(SEM_NOOPENFILEERRORBOX|SEM_FAILCRITICALERRORS);
 163                 h = CreateFile(filenameA, (w_right|r_right), (w_right)? 0 : FILE_SHARE_READ,
 164                                NULL, (must_exist|truncate|a_mode), FILE_ATTRIBUTE_NORMAL,NULL);
 165                 /* restore old behaviour */
 166                 SetErrorMode(old_error_mode);
 167
 168                 SDL_stack_free(filenameA);
 169                 SDL_free(utf16);
 170         }
 171
 172         }
 173 #endif /* _WIN32_WCE */
 174
 175         if (h==INVALID_HANDLE_VALUE) {
 176                 SDL_free(context->hidden.win32io.buffer.data);
 177                 context->hidden.win32io.buffer.data = NULL;
 178                 SDL_SetError("Couldn't open %s",filename);
 179                 return -2; /* failed (CreateFile) */
 180         }
 181         context->hidden.win32io.h = h;
 182         context->hidden.win32io.append = a_mode;
 183
 184         return 0; /* ok */
 185 }
 186 static int SDLCALL win32_file_seek(SDL_RWops *context, int offset, int whence)
 187 {
 188         DWORD win32whence;
 189         int   file_pos;
 190
 191         if (!context || context->hidden.win32io.h == INVALID_HANDLE_VALUE) {
 192                 SDL_SetError("win32_file_seek: invalid context/file not opened");
 193                 return -1;
 194         }
 195
 196         /* FIXME: We may be able to satisfy the seek within buffered data */
 197         if (whence == RW_SEEK_CUR && context->hidden.win32io.buffer.left) {
 198                 offset -= context->hidden.win32io.buffer.left;
 199     }
 200     context->hidden.win32io.buffer.left = 0;
 201
 202         switch (whence) {
 203                 case RW_SEEK_SET:
 204                         win32whence = FILE_BEGIN; break;
 205                 case RW_SEEK_CUR:
 206                         win32whence = FILE_CURRENT; break;
 207                 case RW_SEEK_END:
 208                         win32whence = FILE_END; break;
 209                 default:
 210                         SDL_SetError("win32_file_seek: Unknown value for 'whence'");
 211                         return -1;
 212         }
 213
 214         file_pos = SetFilePointer(context->hidden.win32io.h,offset,NULL,win32whence);
 215
 216         if ( file_pos != INVALID_SET_FILE_POINTER )
 217                 return file_pos; /* success */
 218
 219         SDL_Error(SDL_EFSEEK);
 220         return -1; /* error */
 221 }
 222 static int SDLCALL win32_file_read(SDL_RWops *context, void *ptr, int size, int maxnum)
 223 {
 224         int             total_need;
 225         int             total_read = 0;
 226     int     read_ahead;
 227         DWORD   byte_read;
 228
 229         total_need = size*maxnum;
 230
 231         if (!context || context->hidden.win32io.h == INVALID_HANDLE_VALUE || total_need<=0 || !size)
 232                 return 0;
 233
 234     if (context->hidden.win32io.buffer.left > 0) {
 235         void *data = (char *)context->hidden.win32io.buffer.data +
 236                              context->hidden.win32io.buffer.size -
 237                              context->hidden.win32io.buffer.left;
 238         read_ahead = SDL_min(total_need, context->hidden.win32io.buffer.left);
 239         SDL_memcpy(ptr, data, read_ahead);
 240         context->hidden.win32io.buffer.left -= read_ahead;
 241
 242         if (read_ahead == total_need) {
 243             return maxnum;
 244         }
 245         ptr = (char *)ptr + read_ahead;
 246         total_need -= read_ahead;
 247                 total_read += read_ahead;
 248     }
 249
 250     if (total_need < READAHEAD_BUFFER_SIZE) {
 251         if (!ReadFile(context->hidden.win32io.h,context->hidden.win32io.buffer.data,READAHEAD_BUFFER_SIZE,&byte_read,NULL)) {
 252             SDL_Error(SDL_EFREAD);
 253             return 0;
 254         }
 255         read_ahead = SDL_min(total_need, (int)byte_read);
 256         SDL_memcpy(ptr, context->hidden.win32io.buffer.data, read_ahead);
 257         context->hidden.win32io.buffer.size = byte_read;
 258         context->hidden.win32io.buffer.left = byte_read-read_ahead;
 259         total_read += read_ahead;
 260     } else {
 261         if (!ReadFile(context->hidden.win32io.h,ptr,total_need,&byte_read,NULL)) {
 262             SDL_Error(SDL_EFREAD);
 263             return 0;
 264         }
 265         total_read += byte_read;
 266     }
 267         return (total_read/size);
 268 }
 269 static int SDLCALL win32_file_write(SDL_RWops *context, const void *ptr, int size, int num)
 270 {
 271
 272         int             total_bytes;
 273         DWORD   byte_written,nwritten;
 274
 275         total_bytes = size*num;
 276
 277         if (!context || context->hidden.win32io.h==INVALID_HANDLE_VALUE || total_bytes<=0 || !size)
 278                 return 0;
 279
 280         if (context->hidden.win32io.buffer.left) {
 281                 SetFilePointer(context->hidden.win32io.h,-context->hidden.win32io.buffer.left,NULL,FILE_CURRENT);
 282                 context->hidden.win32io.buffer.left = 0;
 283         }
 284
 285         /* if in append mode, we must go to the EOF before write */
 286         if (context->hidden.win32io.append) {
 287                 if ( SetFilePointer(context->hidden.win32io.h,0L,NULL,FILE_END) == INVALID_SET_FILE_POINTER ) {
 288                         SDL_Error(SDL_EFWRITE);
 289                         return 0;
 290                 }
 291         }
 292
 293         if (!WriteFile(context->hidden.win32io.h,ptr,total_bytes,&byte_written,NULL)) {
 294                 SDL_Error(SDL_EFWRITE);
 295                 return 0;
 296         }
 297
 298         nwritten = byte_written/size;
 299         return nwritten;
 300 }
 301 static int SDLCALL win32_file_close(SDL_RWops *context)
 302 {
 303
 304         if ( context ) {
 305                 if (context->hidden.win32io.h != INVALID_HANDLE_VALUE) {
 306                         CloseHandle(context->hidden.win32io.h);
 307                         context->hidden.win32io.h = INVALID_HANDLE_VALUE; /* to be sure */
 308                 }
 309                 if (context->hidden.win32io.buffer.data) {
 310                         SDL_free(context->hidden.win32io.buffer.data);
 311                         context->hidden.win32io.buffer.data = NULL;
 312                 }
 313                 SDL_FreeRW(context);
 314         }
 315         return(0);
 316 }
 317 #endif /* __WIN32__ */
 318
 319 #ifdef HAVE_STDIO_H
 320
 321 /* Functions to read/write stdio file pointers */
 322
 323 static int SDLCALL stdio_seek(SDL_RWops *context, int offset, int whence)
 324 {
 325         if ( fseek(context->hidden.stdio.fp, offset, whence) == 0 ) {
 326                 return(ftell(context->hidden.stdio.fp));
 327         } else {
 328                 SDL_Error(SDL_EFSEEK);
 329                 return(-1);
 330         }
 331 }
 332 static int SDLCALL stdio_read(SDL_RWops *context, void *ptr, int size, int maxnum)
 333 {
 334         size_t nread;
 335
 336         nread = fread(ptr, size, maxnum, context->hidden.stdio.fp);
 337         if ( nread == 0 && ferror(context->hidden.stdio.fp) ) {
 338                 SDL_Error(SDL_EFREAD);
 339         }
 340         return(nread);
 341 }
 342 static int SDLCALL stdio_write(SDL_RWops *context, const void *ptr, int size, int num)
 343 {
 344         size_t nwrote;
 345
 346         nwrote = fwrite(ptr, size, num, context->hidden.stdio.fp);
 347         if ( nwrote == 0 && ferror(context->hidden.stdio.fp) ) {
 348                 SDL_Error(SDL_EFWRITE);
 349         }
 350         return(nwrote);
 351 }
 352 static int SDLCALL stdio_close(SDL_RWops *context)
 353 {
 354         if ( context ) {
 355                 if ( context->hidden.stdio.autoclose ) {
 356                         /* WARNING:  Check the return value here! */
 357                         fclose(context->hidden.stdio.fp);
 358                 }
 359                 SDL_FreeRW(context);
 360         }
 361         return(0);
 362 }
 363 #endif /* !HAVE_STDIO_H */
 364
 365 /* Functions to read/write memory pointers */
 366
 367 static int SDLCALL mem_seek(SDL_RWops *context, int offset, int whence)
 368 {
 369         Uint8 *newpos;
 370
 371         switch (whence) {
 372                 case RW_SEEK_SET:
 373                         newpos = context->hidden.mem.base+offset;
 374                         break;
 375                 case RW_SEEK_CUR:
 376                         newpos = context->hidden.mem.here+offset;
 377                         break;
 378                 case RW_SEEK_END:
 379                         newpos = context->hidden.mem.stop+offset;
 380                         break;
 381                 default:
 382                         SDL_SetError("Unknown value for 'whence'");
 383                         return(-1);
 384         }
 385         if ( newpos < context->hidden.mem.base ) {
 386                 newpos = context->hidden.mem.base;
 387         }
 388         if ( newpos > context->hidden.mem.stop ) {
 389                 newpos = context->hidden.mem.stop;
 390         }
 391         context->hidden.mem.here = newpos;
 392         return(context->hidden.mem.here-context->hidden.mem.base);
 393 }
 394 static int SDLCALL mem_read(SDL_RWops *context, void *ptr, int size, int maxnum)
 395 {
 396         size_t total_bytes;
 397         size_t mem_available;
 398
 399         total_bytes = (maxnum * size);
 400         if ( (maxnum <= 0) || (size <= 0) || ((total_bytes / maxnum) != (size_t) size) ) {
 401                 return 0;
 402         }
 403
 404         mem_available = (context->hidden.mem.stop - context->hidden.mem.here);
 405         if (total_bytes > mem_available) {
 406                 total_bytes = mem_available;
 407         }
 408
 409         SDL_memcpy(ptr, context->hidden.mem.here, total_bytes);
 410         context->hidden.mem.here += total_bytes;
 411
 412         return (total_bytes / size);
 413 }
 414 static int SDLCALL mem_write(SDL_RWops *context, const void *ptr, int size, int num)
 415 {
 416         if ( (context->hidden.mem.here + (num*size)) > context->hidden.mem.stop ) {
 417                 num = (context->hidden.mem.stop-context->hidden.mem.here)/size;
 418         }
 419         SDL_memcpy(context->hidden.mem.here, ptr, num*size);
 420         context->hidden.mem.here += num*size;
 421         return(num);
 422 }
 423 static int SDLCALL mem_writeconst(SDL_RWops *context, const void *ptr, int size, int num)
 424 {
 425         SDL_SetError("Can't write to read-only memory");
 426         return(-1);
 427 }
 428 static int SDLCALL mem_close(SDL_RWops *context)
 429 {
 430         if ( context ) {
 431                 SDL_FreeRW(context);
 432         }
 433         return(0);
 434 }
 435
 436
 437 /* Functions to create SDL_RWops structures from various data sources */
 438
 439 #ifdef __MACOS__
 440 /*
 441  * translate unix-style slash-separated filename to mac-style colon-separated
 442  * name; return malloced string
 443  */
 444 static char *unix_to_mac(const char *file)
 445 {
 446         int flen = SDL_strlen(file);
 447         char *path = SDL_malloc(flen + 2);
 448         const char *src = file;
 449         char *dst = path;
 450         if(*src == '/') {
 451                 /* really depends on filesystem layout, hope for the best */
 452                 src++;
 453         } else {
 454                 /* Check if this is a MacOS path to begin with */
 455                 if(*src != ':')
 456                         *dst++ = ':';   /* relative paths begin with ':' */
 457         }
 458         while(src < file + flen) {
 459                 const char *end = SDL_strchr(src, '/');
 460                 int len;
 461                 if(!end)
 462                         end = file + flen; /* last component */
 463                 len = end - src;
 464                 if(len == 0 || (len == 1 && src[0] == '.')) {
 465                         /* remove repeated slashes and . */
 466                 } else {
 467                         if(len == 2 && src[0] == '.' && src[1] == '.') {
 468                                 /* replace .. with the empty string */
 469                         } else {
 470                                 SDL_memcpy(dst, src, len);
 471                                 dst += len;
 472                         }
 473                         if(end < file + flen)
 474                                 *dst++ = ':';
 475                 }
 476                 src = end + 1;
 477         }
 478         *dst++ = '\0';
 479         return path;
 480 }
 481 #endif /* __MACOS__ */
 482
 483 SDL_RWops *SDL_RWFromFile(const char *file, const char *mode)
 484 {
 485         SDL_RWops *rwops = NULL;
 486 #ifdef HAVE_STDIO_H
 487         FILE *fp = NULL;
 488 #endif
 489         if ( !file || !*file || !mode || !*mode ) {
 490                 SDL_SetError("SDL_RWFromFile(): No file or no mode specified");
 491                 return NULL;
 492         }
 493
 494 #if defined(__WIN32__) && !defined(__SYMBIAN32__)
 495         rwops = SDL_AllocRW();
 496         if (!rwops)
 497                 return NULL; /* SDL_SetError already setup by SDL_AllocRW() */
 498         if (win32_file_open(rwops,file,mode) < 0) {
 499                 SDL_FreeRW(rwops);
 500                 return NULL;
 501         }
 502         rwops->seek  = win32_file_seek;
 503         rwops->read  = win32_file_read;
 504         rwops->write = win32_file_write;
 505         rwops->close = win32_file_close;
 506
 507 #elif HAVE_STDIO_H
 508
 509 #ifdef __MACOS__
 510         {
 511                 char *mpath = unix_to_mac(file);
 512                 fp = fopen(mpath, mode);
 513                 SDL_free(mpath);
 514         }
 515 #else
 516         fp = fopen(file, mode);
 517 #endif
 518         if ( fp == NULL ) {
 519                 SDL_SetError("Couldn't open %s", file);
 520         } else {
 521                 rwops = SDL_RWFromFP(fp, 1);
 522         }
 523 #else
 524         SDL_SetError("SDL not compiled with stdio support");
 525 #endif /* !HAVE_STDIO_H */
 526
 527         return(rwops);
 528 }
 529
 530 #ifdef HAVE_STDIO_H
 531 SDL_RWops *SDL_RWFromFP(FILE *fp, int autoclose)
 532 {
 533         SDL_RWops *rwops = NULL;
 534
 535         rwops = SDL_AllocRW();
 536         if ( rwops != NULL ) {
 537                 rwops->seek = stdio_seek;
 538                 rwops->read = stdio_read;
 539                 rwops->write = stdio_write;
 540                 rwops->close = stdio_close;
 541                 rwops->hidden.stdio.fp = fp;
 542                 rwops->hidden.stdio.autoclose = autoclose;
 543         }
 544         return(rwops);
 545 }
 546 #endif /* HAVE_STDIO_H */
 547
 548 SDL_RWops *SDL_RWFromMem(void *mem, int size)
 549 {
 550         SDL_RWops *rwops;
 551
 552         rwops = SDL_AllocRW();
 553         if ( rwops != NULL ) {
 554                 rwops->seek = mem_seek;
 555                 rwops->read = mem_read;
 556                 rwops->write = mem_write;
 557                 rwops->close = mem_close;
 558                 rwops->hidden.mem.base = (Uint8 *)mem;
 559                 rwops->hidden.mem.here = rwops->hidden.mem.base;
 560                 rwops->hidden.mem.stop = rwops->hidden.mem.base+size;
 561         }
 562         return(rwops);
 563 }
 564
 565 SDL_RWops *SDL_RWFromConstMem(const void *mem, int size)
 566 {
 567         SDL_RWops *rwops;
 568
 569         rwops = SDL_AllocRW();
 570         if ( rwops != NULL ) {
 571                 rwops->seek = mem_seek;
 572                 rwops->read = mem_read;
 573                 rwops->write = mem_writeconst;
 574                 rwops->close = mem_close;
 575                 rwops->hidden.mem.base = (Uint8 *)mem;
 576                 rwops->hidden.mem.here = rwops->hidden.mem.base;
 577                 rwops->hidden.mem.stop = rwops->hidden.mem.base+size;
 578         }
 579         return(rwops);
 580 }
 581
 582 SDL_RWops *SDL_AllocRW(void)
 583 {
 584         SDL_RWops *area;
 585
 586         area = (SDL_RWops *)SDL_malloc(sizeof *area);
 587         if ( area == NULL ) {
 588                 SDL_OutOfMemory();
 589         }
 590         return(area);
 591 }
 592
 593 void SDL_FreeRW(SDL_RWops *area)
 594 {
 595         SDL_free(area);
 596 }
 597
 598 /* Functions for dynamically reading and writing endian-specific values */
 599
 600 Uint16 SDL_ReadLE16 (SDL_RWops *src)
 601 {
 602         Uint16 value;
 603
 604         SDL_RWread(src, &value, (sizeof value), 1);
 605         return(SDL_SwapLE16(value));
 606 }
 607 Uint16 SDL_ReadBE16 (SDL_RWops *src)
 608 {
 609         Uint16 value;
 610
 611         SDL_RWread(src, &value, (sizeof value), 1);
 612         return(SDL_SwapBE16(value));
 613 }
 614 Uint32 SDL_ReadLE32 (SDL_RWops *src)
 615 {
 616         Uint32 value;
 617
 618         SDL_RWread(src, &value, (sizeof value), 1);
 619         return(SDL_SwapLE32(value));
 620 }
 621 Uint32 SDL_ReadBE32 (SDL_RWops *src)
 622 {
 623         Uint32 value;
 624
 625         SDL_RWread(src, &value, (sizeof value), 1);
 626         return(SDL_SwapBE32(value));
 627 }
 628 Uint64 SDL_ReadLE64 (SDL_RWops *src)
 629 {
 630         Uint64 value;
 631
 632         SDL_RWread(src, &value, (sizeof value), 1);
 633         return(SDL_SwapLE64(value));
 634 }
 635 Uint64 SDL_ReadBE64 (SDL_RWops *src)
 636 {
 637         Uint64 value;
 638
 639         SDL_RWread(src, &value, (sizeof value), 1);
 640         return(SDL_SwapBE64(value));
 641 }
 642
 643 int SDL_WriteLE16 (SDL_RWops *dst, Uint16 value)
 644 {
 645         value = SDL_SwapLE16(value);
 646         return(SDL_RWwrite(dst, &value, (sizeof value), 1));
 647 }
 648 int SDL_WriteBE16 (SDL_RWops *dst, Uint16 value)
 649 {
 650         value = SDL_SwapBE16(value);
 651         return(SDL_RWwrite(dst, &value, (sizeof value), 1));
 652 }
 653 int SDL_WriteLE32 (SDL_RWops *dst, Uint32 value)
 654 {
 655         value = SDL_SwapLE32(value);
 656         return(SDL_RWwrite(dst, &value, (sizeof value), 1));
 657 }
 658 int SDL_WriteBE32 (SDL_RWops *dst, Uint32 value)
 659 {
 660         value = SDL_SwapBE32(value);
 661         return(SDL_RWwrite(dst, &value, (sizeof value), 1));
 662 }
 663 int SDL_WriteLE64 (SDL_RWops *dst, Uint64 value)
 664 {
 665         value = SDL_SwapLE64(value);
 666         return(SDL_RWwrite(dst, &value, (sizeof value), 1));
 667 }
 668 int SDL_WriteBE64 (SDL_RWops *dst, Uint64 value)
 669 {
 670         value = SDL_SwapBE64(value);
 671         return(SDL_RWwrite(dst, &value, (sizeof value), 1));
 672 }