SDL_rwops.c File Reference

#include "../SDL_internal.h"
#include "SDL_endian.h"
#include "SDL_rwops.h"

Include dependency graph for SDL_rwops.c:

Go to the source code of this file.

Macros
#define	_LARGEFILE64_SOURCE

Functions
static Sint64	mem_size (SDL_RWops *context)
static Sint64	mem_seek (SDL_RWops *context, Sint64 offset, int whence)
static size_t	mem_read (SDL_RWops *context, void *ptr, size_t size, size_t maxnum)
static size_t	mem_write (SDL_RWops *context, const void *ptr, size_t size, size_t num)
static size_t	mem_writeconst (SDL_RWops *context, const void *ptr, size_t size, size_t num)
static int	mem_close (SDL_RWops *context)
SDL_RWops *	SDL_RWFromFile (const char *file, const char *mode)
SDL_RWops *	SDL_RWFromFP (void *fp, SDL_bool autoclose)
SDL_RWops *	SDL_RWFromMem (void *mem, int size)
SDL_RWops *	SDL_RWFromConstMem (const void *mem, int size)
SDL_RWops *	SDL_AllocRW (void)
void	SDL_FreeRW (SDL_RWops *area)
void *	SDL_LoadFile_RW (SDL_RWops *src, size_t *datasize, int freesrc)
Uint8	SDL_ReadU8 (SDL_RWops *src)
Uint16	SDL_ReadLE16 (SDL_RWops *src)
Uint16	SDL_ReadBE16 (SDL_RWops *src)
Uint32	SDL_ReadLE32 (SDL_RWops *src)
Uint32	SDL_ReadBE32 (SDL_RWops *src)
Uint64	SDL_ReadLE64 (SDL_RWops *src)
Uint64	SDL_ReadBE64 (SDL_RWops *src)
size_t	SDL_WriteU8 (SDL_RWops *dst, Uint8 value)
size_t	SDL_WriteLE16 (SDL_RWops *dst, Uint16 value)
size_t	SDL_WriteBE16 (SDL_RWops *dst, Uint16 value)
size_t	SDL_WriteLE32 (SDL_RWops *dst, Uint32 value)
size_t	SDL_WriteBE32 (SDL_RWops *dst, Uint32 value)
size_t	SDL_WriteLE64 (SDL_RWops *dst, Uint64 value)
size_t	SDL_WriteBE64 (SDL_RWops *dst, Uint64 value)

Macro Definition Documentation

#define _LARGEFILE64_SOURCE

Definition at line 26 of file SDL_rwops.c.

Function Documentation

static int mem_close ( SDL_RWops *  context )

static

Definition at line 499 of file SDL_rwops.c.

References SDL_FreeRW.

Referenced by SDL_RWFromConstMem(), and SDL_RWFromMem().

{
    if (context) {
        SDL_FreeRW(context);
    }
    return 0;
}

static size_t mem_read ( SDL_RWops *  context, void *  ptr, size_t  size, size_t  maxnum  )

static

Definition at line 458 of file SDL_rwops.c.

References SDL_RWops::hidden, SDL_RWops::mem, and SDL_memcpy.

Referenced by SDL_RWFromConstMem(), and SDL_RWFromMem().

{
    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);
}

static Sint64 mem_seek ( SDL_RWops *  context, Sint64  offset, int  whence  )

static

Definition at line 430 of file SDL_rwops.c.

References SDL_RWops::hidden, SDL_RWops::mem, RW_SEEK_CUR, RW_SEEK_END, RW_SEEK_SET, and SDL_SetError.

Referenced by SDL_RWFromConstMem(), and SDL_RWFromMem().

{
    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:
        return SDL_SetError("Unknown value for 'whence'");
    }
    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;
    return (Sint64)(context->hidden.mem.here - context->hidden.mem.base);
}

static Sint64 mem_size ( SDL_RWops *  context )

static

Definition at line 424 of file SDL_rwops.c.

References SDL_RWops::hidden, and SDL_RWops::mem.

Referenced by SDL_RWFromConstMem(), and SDL_RWFromMem().

{
    return (Sint64)(context->hidden.mem.stop - context->hidden.mem.base);
}

static size_t mem_write ( SDL_RWops *  context, const void *  ptr, size_t  size, size_t  num  )

static

Definition at line 481 of file SDL_rwops.c.

References SDL_RWops::hidden, SDL_RWops::mem, and SDL_memcpy.

Referenced by SDL_RWFromMem().

{
    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;
}

static size_t mem_writeconst ( SDL_RWops *  context, const void *  ptr, size_t  size, size_t  num  )

static

Definition at line 492 of file SDL_rwops.c.

References SDL_SetError.

Referenced by SDL_RWFromConstMem().

{
    SDL_SetError("Can't write to read-only memory");
    return 0;
}

SDL_RWops* SDL_AllocRW

(

void

)

Definition at line 682 of file SDL_rwops.c.

References NULL, SDL_malloc, SDL_OutOfMemory, SDL_RWOPS_UNKNOWN, and SDL_RWops::type.

{
    SDL_RWops *area;

    area = (SDL_RWops *) SDL_malloc(sizeof *area);
    if (area == NULL) {
        SDL_OutOfMemory();
    } else {
        area->type = SDL_RWOPS_UNKNOWN;
    }
    return area;
}

void SDL_FreeRW

(

SDL_RWops *

area

)

Definition at line 696 of file SDL_rwops.c.

References SDL_free.

{
    SDL_free(area);
}

void* SDL_LoadFile_RW	(	SDL_RWops *	src,
		size_t *	datasize,
		int	freesrc
	)

Load all the data from an SDL data stream.

The data is allocated with a zero byte at the end (null terminated)

If datasize is not NULL, it is filled with the size of the data read.

If freesrc is non-zero, the stream will be closed after being read.

The data should be freed with SDL_free().

Returns

the data, or NULL if there was an error.

Definition at line 703 of file SDL_rwops.c.

References done, NULL, SDL_free, SDL_InvalidParamError, SDL_malloc, SDL_OutOfMemory, SDL_realloc, SDL_RWclose, SDL_RWread, and SDL_RWsize.

{
    const int FILE_CHUNK_SIZE = 1024;
    Sint64 size;
    size_t size_read, size_total;
    void *data = NULL, *newdata;

    if (!src) {
        SDL_InvalidParamError("src");
        return NULL;
    }

    size = SDL_RWsize(src);
    if (size < 0) {
        size = FILE_CHUNK_SIZE;
    }
    data = SDL_malloc((size_t)(size + 1));

    size_total = 0;
    for (;;) {
        if ((((Sint64)size_total) + FILE_CHUNK_SIZE) > size) {
            size = (size_total + FILE_CHUNK_SIZE);
            newdata = SDL_realloc(data, (size_t)(size + 1));
            if (!newdata) {
                SDL_free(data);
                data = NULL;
                SDL_OutOfMemory();
                goto done;
            }
            data = newdata;
        }

        size_read = SDL_RWread(src, (char *)data+size_total, 1, (size_t)(size-size_total));
        if (size_read == 0) {
            break;
        }
        size_total += size_read;
    }

    if (datasize) {
        *datasize = size_total;
    }
    ((char *)data)[size_total] = '\0';

done:
    if (freesrc && src) {
        SDL_RWclose(src);
    }
    return data;
}

Uint16 SDL_ReadBE16

(

SDL_RWops *

src

)

Definition at line 775 of file SDL_rwops.c.

References SDL_RWread, and SDL_SwapBE16.

{
    Uint16 value = 0;

    SDL_RWread(src, &value, sizeof (value), 1);
    return SDL_SwapBE16(value);
}

Uint32 SDL_ReadBE32

(

SDL_RWops *

src

)

Definition at line 793 of file SDL_rwops.c.

References SDL_RWread, and SDL_SwapBE32.

{
    Uint32 value = 0;

    SDL_RWread(src, &value, sizeof (value), 1);
    return SDL_SwapBE32(value);
}

Uint64 SDL_ReadBE64

(

SDL_RWops *

src

)

Definition at line 811 of file SDL_rwops.c.

References SDL_RWread, and SDL_SwapBE64.

{
    Uint64 value = 0;

    SDL_RWread(src, &value, sizeof (value), 1);
    return SDL_SwapBE64(value);
}

Uint16 SDL_ReadLE16

(

SDL_RWops *

src

)

Definition at line 766 of file SDL_rwops.c.

References SDL_RWread, and SDL_SwapLE16.

{
    Uint16 value = 0;

    SDL_RWread(src, &value, sizeof (value), 1);
    return SDL_SwapLE16(value);
}

Uint32 SDL_ReadLE32

(

SDL_RWops *

src

)

Definition at line 784 of file SDL_rwops.c.

References SDL_RWread, and SDL_SwapLE32.

{
    Uint32 value = 0;

    SDL_RWread(src, &value, sizeof (value), 1);
    return SDL_SwapLE32(value);
}

Uint64 SDL_ReadLE64

(

SDL_RWops *

src

)

Definition at line 802 of file SDL_rwops.c.

References SDL_RWread, and SDL_SwapLE64.

{
    Uint64 value = 0;

    SDL_RWread(src, &value, sizeof (value), 1);
    return SDL_SwapLE64(value);
}

Uint8 SDL_ReadU8

(

SDL_RWops *

src

)

Definition at line 757 of file SDL_rwops.c.

References SDL_RWread.

{
    Uint8 value = 0;

    SDL_RWread(src, &value, sizeof (value), 1);
    return value;
}

SDL_RWops* SDL_RWFromConstMem	(	const void *	mem,
		int	size
	)

Definition at line 654 of file SDL_rwops.c.

References SDL_RWops::close, SDL_RWops::hidden, SDL_RWops::mem, mem_close(), mem_read(), mem_seek(), mem_size(), mem_writeconst(), NULL, SDL_RWops::read, SDL_AllocRW, SDL_InvalidParamError, SDL_RWOPS_MEMORY_RO, SDL_RWops::seek, SDL_RWops::size, SDL_RWops::type, and SDL_RWops::write.

{
    SDL_RWops *rwops = NULL;
    if (!mem) {
      SDL_InvalidParamError("mem");
      return rwops;
    }
    if (!size) {
      SDL_InvalidParamError("size");
      return rwops;
    }

    rwops = SDL_AllocRW();
    if (rwops != NULL) {
        rwops->size = mem_size;
        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;
        rwops->type = SDL_RWOPS_MEMORY_RO;
    }
    return rwops;
}

SDL_RWops* SDL_RWFromFile	(	const char *	file,
		const char *	mode
	)

Definition at line 511 of file SDL_rwops.c.

References Android_JNI_FileClose(), Android_JNI_FileOpen(), Android_JNI_FileRead(), Android_JNI_FileSeek(), Android_JNI_FileSize(), Android_JNI_FileWrite(), SDL_RWops::close, NULL, SDL_RWops::read, SDL_AllocRW, SDL_AndroidGetInternalStoragePath, SDL_FreeRW, SDL_RWFromFP, SDL_RWOPS_JNIFILE, SDL_RWOPS_WINFILE, SDL_SetError, SDL_snprintf, SDL_stack_alloc, SDL_stack_free, SDL_RWops::seek, SDL_RWops::size, SDL_RWops::type, and SDL_RWops::write.

{
    SDL_RWops *rwops = NULL;
    if (!file || !*file || !mode || !*mode) {
        SDL_SetError("SDL_RWFromFile(): No file or no mode specified");
        return NULL;
    }
#if defined(__ANDROID__)
#ifdef HAVE_STDIO_H
    /* Try to open the file on the filesystem first */
    if (*file == '/') {
        FILE *fp = fopen(file, mode);
        if (fp) {
            return SDL_RWFromFP(fp, 1);
        }
    } else {
        /* Try opening it from internal storage if it's a relative path */
        char *path;
        FILE *fp;

        path = SDL_stack_alloc(char, PATH_MAX);
        if (path) {
            SDL_snprintf(path, PATH_MAX, "%s/%s",
                         SDL_AndroidGetInternalStoragePath(), file);
            fp = fopen(path, mode);
            SDL_stack_free(path);
            if (fp) {
                return SDL_RWFromFP(fp, 1);
            }
        }
    }
#endif /* HAVE_STDIO_H */

    /* Try to open the file from the asset system */
    rwops = SDL_AllocRW();
    if (!rwops)
        return NULL;            /* SDL_SetError already setup by SDL_AllocRW() */
    if (Android_JNI_FileOpen(rwops, file, mode) < 0) {
        SDL_FreeRW(rwops);
        return NULL;
    }
    rwops->size = Android_JNI_FileSize;
    rwops->seek = Android_JNI_FileSeek;
    rwops->read = Android_JNI_FileRead;
    rwops->write = Android_JNI_FileWrite;
    rwops->close = Android_JNI_FileClose;
    rwops->type = SDL_RWOPS_JNIFILE;

#elif defined(__WIN32__)
    rwops = SDL_AllocRW();
    if (!rwops)
        return NULL;            /* SDL_SetError already setup by SDL_AllocRW() */
    if (windows_file_open(rwops, file, mode) < 0) {
        SDL_FreeRW(rwops);
        return NULL;
    }
    rwops->size = windows_file_size;
    rwops->seek = windows_file_seek;
    rwops->read = windows_file_read;
    rwops->write = windows_file_write;
    rwops->close = windows_file_close;
    rwops->type = SDL_RWOPS_WINFILE;

#elif HAVE_STDIO_H
    {
        #ifdef __APPLE__
        FILE *fp = SDL_OpenFPFromBundleOrFallback(file, mode);
        #elif __WINRT__
        FILE *fp = NULL;
        fopen_s(&fp, file, mode);
        #else
        FILE *fp = fopen(file, mode);
        #endif
        if (fp == NULL) {
            SDL_SetError("Couldn't open %s", file);
        } else {
            rwops = SDL_RWFromFP(fp, 1);
        }
    }
#else
    SDL_SetError("SDL not compiled with stdio support");
#endif /* !HAVE_STDIO_H */

    return rwops;
}

SDL_RWops* SDL_RWFromFP	(	void *	fp,
		SDL_bool	autoclose
	)

Definition at line 618 of file SDL_rwops.c.

References NULL, and SDL_SetError.

{
    SDL_SetError("SDL not compiled with stdio support");
    return NULL;
}

SDL_RWops* SDL_RWFromMem	(	void *	mem,
		int	size
	)

Definition at line 626 of file SDL_rwops.c.

References SDL_RWops::close, SDL_RWops::hidden, SDL_RWops::mem, mem_close(), mem_read(), mem_seek(), mem_size(), mem_write(), NULL, SDL_RWops::read, SDL_AllocRW, SDL_InvalidParamError, SDL_RWOPS_MEMORY, SDL_RWops::seek, SDL_RWops::size, SDL_RWops::type, and SDL_RWops::write.

{
    SDL_RWops *rwops = NULL;
    if (!mem) {
      SDL_InvalidParamError("mem");
      return rwops;
    }
    if (!size) {
      SDL_InvalidParamError("size");
      return rwops;
    }

    rwops = SDL_AllocRW();
    if (rwops != NULL) {
        rwops->size = mem_size;
        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;
        rwops->type = SDL_RWOPS_MEMORY;
    }
    return rwops;
}

size_t SDL_WriteBE16	(	SDL_RWops *	dst,
		Uint16	value
	)

Definition at line 833 of file SDL_rwops.c.

References SDL_RWwrite, and SDL_SwapBE16.

{
    const Uint16 swapped = SDL_SwapBE16(value);
    return SDL_RWwrite(dst, &swapped, sizeof (swapped), 1);
}

size_t SDL_WriteBE32	(	SDL_RWops *	dst,
		Uint32	value
	)

Definition at line 847 of file SDL_rwops.c.

References SDL_RWwrite, and SDL_SwapBE32.

{
    const Uint32 swapped = SDL_SwapBE32(value);
    return SDL_RWwrite(dst, &swapped, sizeof (swapped), 1);
}

size_t SDL_WriteBE64	(	SDL_RWops *	dst,
		Uint64	value
	)

Definition at line 861 of file SDL_rwops.c.

References SDL_RWwrite, and SDL_SwapBE64.

{
    const Uint64 swapped = SDL_SwapBE64(value);
    return SDL_RWwrite(dst, &swapped, sizeof (swapped), 1);
}

size_t SDL_WriteLE16	(	SDL_RWops *	dst,
		Uint16	value
	)

Definition at line 826 of file SDL_rwops.c.

References SDL_RWwrite, and SDL_SwapLE16.

{
    const Uint16 swapped = SDL_SwapLE16(value);
    return SDL_RWwrite(dst, &swapped, sizeof (swapped), 1);
}

size_t SDL_WriteLE32	(	SDL_RWops *	dst,
		Uint32	value
	)

Definition at line 840 of file SDL_rwops.c.

References SDL_RWwrite, and SDL_SwapLE32.

{
    const Uint32 swapped = SDL_SwapLE32(value);
    return SDL_RWwrite(dst, &swapped, sizeof (swapped), 1);
}

size_t SDL_WriteLE64	(	SDL_RWops *	dst,
		Uint64	value
	)

Definition at line 854 of file SDL_rwops.c.

References SDL_RWwrite, and SDL_SwapLE64.

{
    const Uint64 swapped = SDL_SwapLE64(value);
    return SDL_RWwrite(dst, &swapped, sizeof (swapped), 1);
}

size_t SDL_WriteU8	(	SDL_RWops *	dst,
		Uint8	value
	)

Definition at line 820 of file SDL_rwops.c.

References SDL_RWwrite.

{
    return SDL_RWwrite(dst, &value, sizeof (value), 1);
}