1 /*
2 SDL - Simple DirectMedia Layer
3 Copyright (C) 1997-2012 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
win32_file_open(SDL_RWops * context,const char * filename,const char * mode)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 }
win32_file_seek(SDL_RWops * context,int offset,int whence)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 }
win32_file_read(SDL_RWops * context,void * ptr,int size,int maxnum)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 }
win32_file_write(SDL_RWops * context,const void * ptr,int size,int num)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 }
win32_file_close(SDL_RWops * context)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
stdio_seek(SDL_RWops * context,int offset,int whence)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 }
stdio_read(SDL_RWops * context,void * ptr,int size,int maxnum)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 }
stdio_write(SDL_RWops * context,const void * ptr,int size,int num)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 }
stdio_close(SDL_RWops * context)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
mem_seek(SDL_RWops * context,int offset,int whence)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 }
mem_read(SDL_RWops * context,void * ptr,int size,int maxnum)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 }
mem_write(SDL_RWops * context,const void * ptr,int size,int num)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 }
mem_writeconst(SDL_RWops * context,const void * ptr,int size,int num)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 }
mem_close(SDL_RWops * context)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 */
unix_to_mac(const char * file)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
SDL_RWFromFile(const char * file,const char * mode)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 (void) fp;
489 #endif
490 if ( !file || !*file || !mode || !*mode ) {
491 SDL_SetError("SDL_RWFromFile(): No file or no mode specified");
492 return NULL;
493 }
494
495 #if defined(__WIN32__) && !defined(__SYMBIAN32__)
496 rwops = SDL_AllocRW();
497 if (!rwops)
498 return NULL; /* SDL_SetError already setup by SDL_AllocRW() */
499 if (win32_file_open(rwops,file,mode) < 0) {
500 SDL_FreeRW(rwops);
501 return NULL;
502 }
503 rwops->seek = win32_file_seek;
504 rwops->read = win32_file_read;
505 rwops->write = win32_file_write;
506 rwops->close = win32_file_close;
507
508 #elif HAVE_STDIO_H
509
510 #ifdef __MACOS__
511 {
512 char *mpath = unix_to_mac(file);
513 fp = fopen(mpath, mode);
514 SDL_free(mpath);
515 }
516 #else
517 fp = fopen(file, mode);
518 #endif
519 if ( fp == NULL ) {
520 SDL_SetError("Couldn't open %s", file);
521 } else {
522 rwops = SDL_RWFromFP(fp, 1);
523 }
524 #else
525 SDL_SetError("SDL not compiled with stdio support");
526 #endif /* !HAVE_STDIO_H */
527
528 return(rwops);
529 }
530
531 #ifdef HAVE_STDIO_H
SDL_RWFromFP(FILE * fp,int autoclose)532 SDL_RWops *SDL_RWFromFP(FILE *fp, int autoclose)
533 {
534 SDL_RWops *rwops = NULL;
535
536 rwops = SDL_AllocRW();
537 if ( rwops != NULL ) {
538 rwops->seek = stdio_seek;
539 rwops->read = stdio_read;
540 rwops->write = stdio_write;
541 rwops->close = stdio_close;
542 rwops->hidden.stdio.fp = fp;
543 rwops->hidden.stdio.autoclose = autoclose;
544 }
545 return(rwops);
546 }
547 #endif /* HAVE_STDIO_H */
548
SDL_RWFromMem(void * mem,int size)549 SDL_RWops *SDL_RWFromMem(void *mem, int size)
550 {
551 SDL_RWops *rwops;
552
553 rwops = SDL_AllocRW();
554 if ( rwops != NULL ) {
555 rwops->seek = mem_seek;
556 rwops->read = mem_read;
557 rwops->write = mem_write;
558 rwops->close = mem_close;
559 rwops->hidden.mem.base = (Uint8 *)mem;
560 rwops->hidden.mem.here = rwops->hidden.mem.base;
561 rwops->hidden.mem.stop = rwops->hidden.mem.base+size;
562 }
563 return(rwops);
564 }
565
SDL_RWFromConstMem(const void * mem,int size)566 SDL_RWops *SDL_RWFromConstMem(const void *mem, int size)
567 {
568 SDL_RWops *rwops;
569
570 rwops = SDL_AllocRW();
571 if ( rwops != NULL ) {
572 rwops->seek = mem_seek;
573 rwops->read = mem_read;
574 rwops->write = mem_writeconst;
575 rwops->close = mem_close;
576 rwops->hidden.mem.base = (Uint8 *)mem;
577 rwops->hidden.mem.here = rwops->hidden.mem.base;
578 rwops->hidden.mem.stop = rwops->hidden.mem.base+size;
579 }
580 return(rwops);
581 }
582
SDL_AllocRW(void)583 SDL_RWops *SDL_AllocRW(void)
584 {
585 SDL_RWops *area;
586
587 area = (SDL_RWops *)SDL_malloc(sizeof *area);
588 if ( area == NULL ) {
589 SDL_OutOfMemory();
590 }
591 return(area);
592 }
593
SDL_FreeRW(SDL_RWops * area)594 void SDL_FreeRW(SDL_RWops *area)
595 {
596 SDL_free(area);
597 }
598
599 /* Functions for dynamically reading and writing endian-specific values */
600
SDL_ReadLE16(SDL_RWops * src)601 Uint16 SDL_ReadLE16 (SDL_RWops *src)
602 {
603 Uint16 value;
604
605 SDL_RWread(src, &value, (sizeof value), 1);
606 return(SDL_SwapLE16(value));
607 }
SDL_ReadBE16(SDL_RWops * src)608 Uint16 SDL_ReadBE16 (SDL_RWops *src)
609 {
610 Uint16 value;
611
612 SDL_RWread(src, &value, (sizeof value), 1);
613 return(SDL_SwapBE16(value));
614 }
SDL_ReadLE32(SDL_RWops * src)615 Uint32 SDL_ReadLE32 (SDL_RWops *src)
616 {
617 Uint32 value;
618
619 SDL_RWread(src, &value, (sizeof value), 1);
620 return(SDL_SwapLE32(value));
621 }
SDL_ReadBE32(SDL_RWops * src)622 Uint32 SDL_ReadBE32 (SDL_RWops *src)
623 {
624 Uint32 value;
625
626 SDL_RWread(src, &value, (sizeof value), 1);
627 return(SDL_SwapBE32(value));
628 }
SDL_ReadLE64(SDL_RWops * src)629 Uint64 SDL_ReadLE64 (SDL_RWops *src)
630 {
631 Uint64 value;
632
633 SDL_RWread(src, &value, (sizeof value), 1);
634 return(SDL_SwapLE64(value));
635 }
SDL_ReadBE64(SDL_RWops * src)636 Uint64 SDL_ReadBE64 (SDL_RWops *src)
637 {
638 Uint64 value;
639
640 SDL_RWread(src, &value, (sizeof value), 1);
641 return(SDL_SwapBE64(value));
642 }
643
SDL_WriteLE16(SDL_RWops * dst,Uint16 value)644 int SDL_WriteLE16 (SDL_RWops *dst, Uint16 value)
645 {
646 value = SDL_SwapLE16(value);
647 return(SDL_RWwrite(dst, &value, (sizeof value), 1));
648 }
SDL_WriteBE16(SDL_RWops * dst,Uint16 value)649 int SDL_WriteBE16 (SDL_RWops *dst, Uint16 value)
650 {
651 value = SDL_SwapBE16(value);
652 return(SDL_RWwrite(dst, &value, (sizeof value), 1));
653 }
SDL_WriteLE32(SDL_RWops * dst,Uint32 value)654 int SDL_WriteLE32 (SDL_RWops *dst, Uint32 value)
655 {
656 value = SDL_SwapLE32(value);
657 return(SDL_RWwrite(dst, &value, (sizeof value), 1));
658 }
SDL_WriteBE32(SDL_RWops * dst,Uint32 value)659 int SDL_WriteBE32 (SDL_RWops *dst, Uint32 value)
660 {
661 value = SDL_SwapBE32(value);
662 return(SDL_RWwrite(dst, &value, (sizeof value), 1));
663 }
SDL_WriteLE64(SDL_RWops * dst,Uint64 value)664 int SDL_WriteLE64 (SDL_RWops *dst, Uint64 value)
665 {
666 value = SDL_SwapLE64(value);
667 return(SDL_RWwrite(dst, &value, (sizeof value), 1));
668 }
SDL_WriteBE64(SDL_RWops * dst,Uint64 value)669 int SDL_WriteBE64 (SDL_RWops *dst, Uint64 value)
670 {
671 value = SDL_SwapBE64(value);
672 return(SDL_RWwrite(dst, &value, (sizeof value), 1));
673 }
674