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