SDL_RWops *
SDL_RWFromFile(const char *file, const char *mode)
{
SDL_RWops *rwops = NULL;
#ifdef HAVE_STDIO_H
FILE *fp = NULL;
#endif
if (!file || !*file || !mode || !*mode) {
SDL_SetError("SDL_RWFromFile(): No file or no mode specified");
return NULL;
}
#if defined(ANDROID) && 0
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->seek = Android_JNI_FileSeek;
rwops->read = Android_JNI_FileRead;
rwops->write = Android_JNI_FileWrite;
rwops->close = Android_JNI_FileClose;
#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->seek = windows_file_seek;
rwops->read = windows_file_read;
rwops->write = windows_file_write;
rwops->close = windows_file_close;
#elif HAVE_STDIO_H
#ifdef __APPLE__
fp = SDL_OpenFPFromBundleOrFallback(file, mode);
#else
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);
}
static SDL_RWops* common_alloc(SDL_RWops *wrapped, size_t bufsize, bool autoclose) {
SDL_RWops *rw = SDL_AllocRW();
if(!rw) {
return NULL;
}
if(bufsize < MIN_CHUNK_SIZE) {
bufsize = MIN_CHUNK_SIZE;
}
memset(rw, 0, sizeof(SDL_RWops));
rw->type = SDL_RWOPS_UNKNOWN;
rw->size = common_size;
rw->seek = common_seek;
rw->close = common_close;
ZData *z = calloc(1, sizeof(ZData));
z->stream = calloc(1, sizeof(z_stream));
z->buffer_size = bufsize;
z->buffer = z->buffer_ptr = calloc(1, bufsize);
z->wrapped = wrapped;
z->autoclose = autoclose;
rw->hidden.unknown.data1 = z;
return rw;
}
static SDL_RWops* getFileForSDL(const char * filename)
{
filesystem::ReadFile * file = new filesystem::ReadFile(filename);
if ( ! file->isOpen() )
{
delete file;
return 0;
}
SDL_RWops * rwops = SDL_AllocRW();
if ( ! rwops )
{
delete file;
return 0;
}
rwops->seek =RWOps_Seek;
rwops->read =RWOps_Read;
rwops->write=RWOps_Write;
rwops->close=RWOps_Close;
rwops->type =0xdeadbeef;
rwops->hidden.unknown.data1 = file;
return rwops;
}
SDL_RWops *SDL_RWFromZZIP(const char* file, const char* mode)
{
register SDL_RWops* rwops;
register ZZIP_FILE* zzip_file;
if (! strchr (mode, 'r'))
return SDL_RWFromFile(file, mode);
zzip_file = zzip_fopen (file, mode);
if (! zzip_file) return 0;
rwops = SDL_AllocRW ();
if (! rwops) {
errno=ENOMEM;
zzip_close (zzip_file);
return 0;
}
SDL_RWOPS_ZZIP_DATA(rwops) = zzip_file;
rwops->read = _zzip_read;
rwops->write = _zzip_write;
rwops->seek = _zzip_seek;
rwops->close = _zzip_close;
return rwops;
}
SDL_RWops* RWopsFromPythonThreaded(PyObject* obj)
{
SDL_RWops* rw;
RWHelper* helper;
PyInterpreterState* interp;
PyThreadState* thread;
if(!obj)
return (SDL_RWops*)RAISE(PyExc_TypeError, "Invalid filetype object");
rw = get_standard_rwop(obj);
if(rw)
return rw;
#ifndef WITH_THREAD
return (SDL_RWops*)RAISE(PyExc_NotImplementedError, "Python built without thread support");
#else
helper = PyMem_New(RWHelper, 1);
fetch_object_methods(helper, obj);
rw = SDL_AllocRW();
rw->hidden.unknown.data1 = (void*)helper;
rw->seek = rw_seek_th;
rw->read = rw_read_th;
rw->write = rw_write_th;
rw->close = rw_close_th;
PyEval_InitThreads();
thread = PyThreadState_Get();
interp = thread->interp;
helper->thread = PyThreadState_New(interp);
return rw;
#endif
}
Music::Music(asset::istream stream) throw(Music_loading_failed) :
_handle(nullptr, Mix_FreeMusic), _stream(std::make_unique<asset::istream>(std::move(stream))){
auto id = _stream->aid();
#ifndef EMSCRIPTEN
SDL_RWops *rwops = SDL_AllocRW();
INVARIANT(rwops, "SDL_AllocRW failed");
rwops->seek = istream_seek;
rwops->read = istream_read;
rwops->write = NULL;
rwops->close = istream_close;
rwops->hidden.unknown.data1 = _stream.get();
_handle.reset(Mix_LoadMUS_RW(rwops, 1));
#else
auto location = _stream->physical_location();
_stream.reset();
if(location.is_nothing())
return;
_handle.reset(Mix_LoadMUS(location.get_or_throw().c_str()));
#endif
if(!_handle){
WARN("Mix_LoadMUS_RW ("<<id.str()<<") failed: " << Mix_GetError());
}
}
SDL_RWops *
SDL_RWFromConstMem(const void *mem, int size)
{
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_RWFromFP(FILE *fp, int autoclose)
{
SDL_RWops *rwops;
#ifdef WIN32
if ( ! in_sdl ) {
SDL_SetError("You can't pass a FILE pointer to a DLL (??)");
/*return(NULL);*/
}
#endif
rwops = SDL_AllocRW();
if ( rwops != NULL ) {
rwops->seek = stdio_seek;
rwops->read = stdio_read;
rwops->write = stdio_write;
rwops->close = stdio_close;
rwops->Getc = stdio_getc; //maks
rwops->Putc = stdio_putc; //maks
rwops->hidden.stdio.fp = fp;
rwops->hidden.stdio.autoclose = autoclose;
//maks
rwops->filePosition = rwops->stdioFilePosition = ftell(rwops->hidden.stdio.fp);
}
return(rwops);
}
static VALUE
fileIntForPath(const char *path, bool rubyExc)
{
SDL_RWops *ops = SDL_AllocRW();
try
{
shState->fileSystem().openRead(*ops, path);
}
catch (const Exception &e)
{
SDL_FreeRW(ops);
if (rubyExc)
raiseRbExc(e);
else
throw e;
}
VALUE klass = rb_const_get(rb_cObject, rb_intern("FileInt"));
VALUE obj = rb_obj_alloc(klass);
setPrivateData(obj, ops);
return obj;
}
_TTF_Font *SharedFontState::getFont(std::string family,
int size)
{
/* Check for substitutions */
if (p->subs.contains(family))
family = p->subs[family];
/* Find out if the font asset exists */
const FontSet &req = p->sets[family];
if (req.regular.empty() && req.other.empty())
{
/* Doesn't exist; use built-in font */
family = "";
}
FontKey key(family, size);
TTF_Font *font = p->pool.value(key);
if (font)
return font;
/* Not in pool; open new handle */
SDL_RWops *ops;
if (family.empty())
{
/* Built-in font */
ops = openBundledFont();
}
else
{
/* Use 'other' path as alternative in case
* we have no 'regular' styled font asset */
const char *path = !req.regular.empty()
? req.regular.c_str() : req.other.c_str();
ops = SDL_AllocRW();
shState->fileSystem().openReadRaw(*ops, path, true);
}
// FIXME 0.9 is guesswork at this point
// float gamma = (96.0/45.0)*(5.0/14.0)*(size-5);
// font = TTF_OpenFontRW(ops, 1, gamma /** .90*/);
font = TTF_OpenFontRW(ops, 1, size* .90);
if (!font)
throw Exception(Exception::SDLError, "%s", SDL_GetError());
p->pool.insert(key, font);
return font;
}
SDL_RWops *stream::rwops()
{
SDL_RWops *rw = SDL_AllocRW();
if(!rw) return NULL;
rw->hidden.unknown.data1 = this;
rw->seek = rwopsseek;
rw->read = rwopsread;
rw->write = rwopswrite;
rw->close = rwopsclose;
return rw;
}
static SDL_RWops*
PyRWops_NewRW (PyObject *obj, int *canautoclose)
{
_RWWrapper *wrapper;
SDL_RWops *ops;
if (!obj || !canautoclose)
{
PyErr_SetString (PyExc_TypeError, "argument is NULL");
return NULL;
}
/* If we have a text object, assume it is a file, which is automatically
* closed. */
if (IsTextObj (obj))
{
PyObject *tmp;
char *filename;
if (!UTF8FromObj (obj, &filename, &tmp))
return NULL;
Py_XDECREF (tmp);
*canautoclose = 1;
ops = SDL_RWFromFile ((const char *)filename, "wb");
if (!ops)
PyErr_SetString (PyExc_PyGameError, SDL_GetError ());
return ops;
}
/* No text object, so its a buffer or something like that. Try to get the
* necessary information. */
ops = SDL_AllocRW ();
if (!ops)
{
PyErr_SetString (PyExc_PyGameError, SDL_GetError ());
return NULL;
}
wrapper = PyMem_New (_RWWrapper, 1);
if (!wrapper)
{
SDL_FreeRW (ops);
return NULL;
}
_bind_python_methods (wrapper, obj);
ops->read = _pyobj_read;
ops->write = _pyobj_write;
ops->seek = _pyobj_seek;
ops->close = _pyobj_close;
ops->hidden.unknown.data1 = (void*) wrapper;
*canautoclose = 0;
return ops;
}
SDL_RWops* UUT_API Stream::CreatReadRWops(Stream* source)
{
SDL_RWops* ops = SDL_AllocRW();
ops->hidden.unknown.data1 = source;
ops->size = &funcRWopsSize;
ops->seek = &funcRWopsSeek;
ops->read = &funcRWopsRead;
ops->write = &funcRWopsWrite;
ops->close = &funcRWopsClose;
return ops;
}
static VALUE
fileIntForPath(const char *path)
{
SDL_RWops *ops = SDL_AllocRW();
shState->fileSystem().openRead(*ops, path);
VALUE klass = rb_const_get(rb_cObject, rb_intern("FileInt"));
VALUE obj = rb_obj_alloc(klass);
setPrivateData(obj, ops);
return obj;
}
SDL_RWops *SDL_RWFromFP(FILE *fp, int autoclose)
{
SDL_RWops *rwops = NULL;
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);
}
SDL_RWops *SDL_RWFromFD(file_t fd, int autoclose)
{
SDL_RWops *rwops = NULL;
rwops = SDL_AllocRW();
if ( rwops != NULL ) {
rwops->seek = dc_seek;
rwops->read = dc_read;
rwops->write = dc_write;
rwops->close = dc_close;
rwops->hidden.dc.fd = fd;
rwops->hidden.dc.autoclose = autoclose;
}
return(rwops);
}
/**
* @brief Tests alloc and free RW context.
*
* \sa http://wiki.libsdl.org/moin.cgi/SDL_AllocRW
* \sa http://wiki.libsdl.org/moin.cgi/SDL_FreeRW
*/
int
rwops_testAllocFree (void)
{
/* Allocate context */
SDL_RWops *rw = SDL_AllocRW();
SDLTest_AssertPass("Call to SDL_AllocRW() succeeded");
SDLTest_AssertCheck(rw != NULL, "Validate result from SDL_AllocRW() is not NULL");
if (rw==NULL) return TEST_ABORTED;
/* Free context again */
SDL_FreeRW(rw);
SDLTest_AssertPass("Call to SDL_FreeRW() succeeded");
return TEST_COMPLETED;
}
SDL_RWops *SDL_RWFromConstMem(const void *mem, int size)
{
SDL_RWops *rwops;
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);
}
SDL_RWops *SDL_RWFromRW(SDL_RWops *src, Sint64 off, Sint64 size) {
SDL_RWops *c = SDL_AllocRW();
if (c == NULL) return NULL;
c->seek = rw_seekfunc;
c->size = rw_sizefunc;
c->read = rw_readfunc;
c->write = rw_writefunc;
c->close = rw_closefunc;
c->type = SDL_RW_TAG_CURRENT;
c->hidden.rwops.baseRW = src;
c->hidden.rwops.current = off;
c->hidden.rwops.begin = off;
c->hidden.rwops.end = off + size;
return c;
}
SDL_RWops *SDL_RWFromMem(void *mem, int size)
{
SDL_RWops *rwops;
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 = (unsigned char *)mem;
rwops->hidden.mem.here = rwops->hidden.mem.base;
rwops->hidden.mem.stop = rwops->hidden.mem.base+size;
}
return(rwops);
}
SDL_RWops *SDL_RWFromFile(const char *file, const char *mode)
{
SDL_RWops *rwops = NULL;
#ifdef HAVE_STDIO_H
FILE *fp = NULL;
#endif
if ( !file || !*file || !mode || !*mode ) {
SDL_SetError("SDL_RWFromFile(): No file or no mode specified");
return NULL;
}
#if defined(__WIN32__) && !defined(__SYMBIAN32__)
rwops = SDL_AllocRW();
if (!rwops)
return NULL; /* SDL_SetError already setup by SDL_AllocRW() */
if (win32_file_open(rwops,file,mode) < 0) {
SDL_FreeRW(rwops);
return NULL;
}
rwops->seek = win32_file_seek;
rwops->read = win32_file_read;
rwops->write = win32_file_write;
rwops->close = win32_file_close;
#elif HAVE_STDIO_H
#ifdef __MACOS__
{
char *mpath = unix_to_mac(file);
fp = fopen(mpath, mode);
SDL_free(mpath);
}
#else
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_RWFromMultipleArchive(const char *file, const char *mode)
{
SDL_RWops *rwops;
SDL_RWIndex *index = indexArchive;
if(!multipleFile || !file || mode[0] != 'r' || mode[1] != 'b') //Read binary
return NULL;
//Search file in table index
while(index)
{
if(dirStrcmp(index->fileName, file) == 0)
{
break;
}
index = index->next;
}
if(!index) return NULL;
if(!multipleArchiveMutEx)
{
multipleArchiveMutEx = SDL_CreateMutex();
}
rwops = SDL_AllocRW();
if ( rwops != NULL )
{
rwops->seek = multiple_seek;
rwops->read = multiple_read;
rwops->write = multiple_write;
rwops->close = multiple_close;
rwops->Getc = multiple_getc;
rwops->Putc = multiple_putc;
rwops->hidden.multiple.base = index->offset;
rwops->hidden.multiple.here = rwops->hidden.multiple.base;
rwops->hidden.multiple.stop = rwops->hidden.multiple.base + index->size;
}
openFileCount++;
return(rwops);
}
SDL_RWops *
SDL_RWFromFP(FILE * fp, SDL_bool autoclose)
{
SDL_RWops *rwops = NULL;
rwops = SDL_AllocRW();
if (rwops != NULL) {
rwops->size = stdio_size;
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;
rwops->type = SDL_RWOPS_STDFILE;
}
return rwops;
}
/**
* @brief Tests alloc and free RW context.
*
* \sa http://wiki.libsdl.org/moin.cgi/SDL_AllocRW
* \sa http://wiki.libsdl.org/moin.cgi/SDL_FreeRW
*/
int
rwops_testAllocFree (void)
{
/* Allocate context */
SDL_RWops *rw = SDL_AllocRW();
SDLTest_AssertPass("Call to SDL_AllocRW() succeeded");
SDLTest_AssertCheck(rw != NULL, "Validate result from SDL_AllocRW() is not NULL");
if (rw==NULL) return TEST_ABORTED;
/* Check type */
SDLTest_AssertCheck(
rw->type == SDL_RWOPS_UNKNOWN,
"Verify RWops type is SDL_RWOPS_UNKNOWN; expected: %d, got: %d", SDL_RWOPS_UNKNOWN, rw->type);
/* Free context again */
SDL_FreeRW(rw);
SDLTest_AssertPass("Call to SDL_FreeRW() succeeded");
return TEST_COMPLETED;
}
static SDL_RWops *create_rwops(PHYSFS_File *handle)
{
SDL_RWops *retval = NULL;
if (handle == NULL)
SDL_SetError("PhysicsFS error: %s", PHYSFS_getLastError());
else
{
retval = SDL_AllocRW();
if (retval != NULL)
{
retval->seek = physfsrwops_seek;
retval->read = physfsrwops_read;
retval->write = physfsrwops_write;
retval->close = physfsrwops_close;
retval->hidden.unknown.data1 = handle;
} /* if */
} /* else */
return retval;
} /* create_rwops */
SDL_RWops *SDL_RWFromBundle(Bundle *bundle, const char *filename)
{
SDL_RWops *rwops;
RWOpsBundle * b = calloc(1, sizeof(RWOpsBundle));
b->handle = bundle->handle;
for (int i = 0 ; i < bundle->n_files ; ++i)
{
if (strcmp(bundle->file[i].name, filename) == 0)
{
b->file = &bundle->file[i];
break;
}
}
if (!b->file)
{
free(b);
return NULL;
}
rwops = SDL_AllocRW();
if (rwops != NULL)
{
rwops->seek = bnd_seek;
rwops->read = bnd_read;
rwops->write = NULL;
rwops->close = bnd_close;
rwops->hidden.unknown.data1 = b;
rwops->seek(rwops, 0, SEEK_SET);
}
else
{
free(b);
}
return rwops;
}
SDL_RWops *SDL_RWFromConstMem(const void *mem, int size)
{
SDL_RWops *rwops;
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;
//Maks: memory map files
rwops->hidden.mem.hFile = NULL;
rwops->hidden.mem.hMapping = NULL;
rwops->hidden.mem.bAutoExpand = 0;
}
return(rwops);
}
rwops_ptr make_write_RWops(const std::string &path) {
rwops_ptr rw(SDL_AllocRW(), &SDL_FreeRW);
rw->size = &ofs_size;
rw->seek = &ofs_seek;
rw->read = &ofs_read;
rw->write = &ofs_write;
rw->close = &ofs_close;
rw->type = write_type;
scoped_ostream ofs = ostream_file(path);
if(!ofs) {
ERR_FS << "make_write_RWops: ostream_file returned NULL on " << path << '\n';
rw.reset();
return rw;
}
rw->hidden.unknown.data1 = ofs.release();
return rw;
}
SDL_RWops *SDL_RWFromZip(struct zip *z,const char *fname) {
zip_file_t* zf;
struct zip_stat st;
Sint64 idx = zip_name_locate(z, fname, 0);
if ( idx < 0){
SDL_SetError("Can't find file %s",fname);
return NULL;
}
//printf("Found file %s with idx %ld\n",fname,idx);
zf=zip_fopen_index(z,idx,ZIP_FL_UNCHANGED);
if(zf == NULL ){
zip_error_t *error = zip_get_error(z);
SDL_SetError("PCK_RWFromZip failed for idx=%ld:%s", idx,zip_error_strerror(error));
zip_error_fini(error);
return NULL;
}
zip_stat_init(&st);
if (zip_stat_index(z, idx, 0, &st) == 0) {
}
SDL_RWops *c = SDL_AllocRW();
if (c == NULL) return NULL;
c->seek = sdl_zip_seekfunc;
c->size = sdl_zip_sizefunc;
c->read = sdl_zip_readfunc;
c->write = sdl_zip_writefunc;
c->close = sdl_zip_closefunc;
c->type = SDL_RW_TAG_CURRENT;
ZipInfo* zi = SDL_malloc(sizeof(ZipInfo));
zi->size = st.size;
zi->zip = z;
c->hidden.unknown.data1 = zf;
c->hidden.unknown.data2 = zi;
return c;
}
SDL_RWops *sdl_rw_from_rfork(const char *file, bool writable)
{
SDL_RWops *rwops = NULL;
int fd = open(file, writable ? O_RDWR : O_RDONLY);
if (fd < 0) {
SDL_SetError("Couldn't open %s", file);
return NULL;
} else {
struct attr_info info;
fs_stat_attr(fd, ATTR_NAME, &info);
rwops = SDL_AllocRW();
if (rwops == NULL) {
close(fd);
return NULL;
}
rfork_data *d = (rfork_data *)malloc(sizeof(struct rfork_data));
if (d == NULL) {
free(rwops);
close(fd);
return NULL;
}
d->fd = fd;
d->current = 0;
d->size = info.size;
rwops->seek = rfork_seek;
rwops->read = rfork_read;
rwops->write = rfork_write;
rwops->close = rfork_close;
rwops->hidden.unknown.data1 = d;
return rwops;
}
}