SDL/src/io/SDL_iostream.c at SDL3_win9x · nmlgc/SDL

Repository navigation

History

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

Simple DirectMedia Layer

This software is provided 'as-is', without any express or implied

warranty. In no event will the authors be held liable for any damages

arising from the use of this software.

Permission is granted to anyone to use this software for any purpose,

including commercial applications, and to alter it and redistribute it

freely, subject to the following restrictions:

1. The origin of this software must not be misrepresented; you must not

claim that you wrote the original software. If you use this software

in a product, an acknowledgment in the product documentation would be

appreciated but is not required.

2. Altered source versions must be plainly marked as such, and must not be

misrepresented as being the original software.

3. This notice may not be removed or altered from any source distribution.

#include "SDL_internal.h"

#if defined(SDL_PLATFORM_WINDOWS) && !defined(SDL_PLATFORM_CYGWIN)

#include "../core/windows/SDL_windows.h"

#else

#include <unistd.h>

#endif

#ifdef HAVE_STDIO_H

#include <stdio.h>

#include <errno.h>

#include <sys/stat.h>

#endif

#ifdef HAVE_LIMITS_H

#include <limits.h>

#endif

#ifdef SDL_PLATFORM_APPLE

#include <fcntl.h>

#endif

#include "SDL_iostream_c.h"

/* This file provides a general interface for SDL to read and write

data sources. It can easily be extended to files, memory, etc.

// IOStreams have various Properties. The first time SDL_GetIOProperties() is

// called, it creates the SDL_PropertiesID and then uses this function

// interface to fill in the appropriate props for the stream on-demand.

typedef void (*SetIOPropertiesFn)(SDL_PropertiesID props, void *userdata);

struct SDL_IOStream

{

SDL_IOStreamInterface iface;

void *userdata;

SetIOPropertiesFn setioprops;

SDL_IOStatus status;

SDL_PropertiesID props;

};

#ifdef SDL_PLATFORM_3DS

#include "n3ds/SDL_iostreamromfs.h"

#endif // SDL_PLATFORM_3DS

#ifdef SDL_PLATFORM_ANDROID

#include <unistd.h>

#include "../core/android/SDL_android.h"

#endif

#if defined(SDL_PLATFORM_WINDOWS) && !defined(SDL_PLATFORM_CYGWIN)

typedef struct IOStreamWindowsData

{

HANDLE h;

void *data;

size_t size;

size_t left;

void *write_data;

size_t write_pos;

bool writable;

bool append;

bool autoclose;

} IOStreamWindowsData;

// Functions to read/write Win32 API file pointers

#ifndef INVALID_SET_FILE_POINTER

#define INVALID_SET_FILE_POINTER 0xFFFFFFFF

#endif

#define READAHEAD_BUFFER_SIZE 1024

#define WRITEBEHIND_BUFFER_SIZE 1024

static HANDLE SDLCALL windows_file_open(const char *filename, const char *mode)

{

#if !defined(SDL_PLATFORM_XBOXONE) && !defined(SDL_PLATFORM_XBOXSERIES)

UINT old_error_mode;

#endif

HANDLE h;

DWORD r_right, w_right;

DWORD must_exist, truncate;

int a_mode;

// "r" = reading, file must exist

// "w" = writing, truncate existing, file may not exist

// "wx"= writing, file must 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

// "w+x"= read, write, file must 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 (truncate && (SDL_strchr(mode, 'x') != NULL)) {

truncate = CREATE_NEW;

}

if (!r_right && !w_right) {

return INVALID_HANDLE_VALUE; // inconsistent mode

}

// failed (invalid call)

#if !defined(SDL_PLATFORM_XBOXONE) && !defined(SDL_PLATFORM_XBOXSERIES)

// Do not open a dialog box if failure

old_error_mode = SetErrorMode(SEM_NOOPENFILEERRORBOX | SEM_FAILCRITICALERRORS);

#endif

{

LPWSTR str = WIN_UTF8ToStringW(filename);

h = CreateFileW(str,

(w_right | r_right),

(w_right) ? 0 : FILE_SHARE_READ,

NULL,

(must_exist | truncate | a_mode),

FILE_ATTRIBUTE_NORMAL,

NULL);

SDL_free(str);

}

#if !defined(SDL_PLATFORM_XBOXONE) && !defined(SDL_PLATFORM_XBOXSERIES)

// restore old behavior

SetErrorMode(old_error_mode);

#endif

if (h == INVALID_HANDLE_VALUE) {

char *error;

if (SDL_asprintf(&error, "Couldn't open %s", filename) > 0) {

WIN_SetError(error);

SDL_free(error);

} else {

SDL_SetError("Couldn't open %s", filename);

}

return h;

}

static bool windows_flush_write_buffer(IOStreamWindowsData *iodata,

SDL_IOStatus *status)

{

if (iodata->write_pos == 0) {

return true; // Nothing to flush

}

// In append mode, seek to EOF before writing

if (iodata->append) {

LARGE_INTEGER windowsoffset;

windowsoffset.QuadPart = 0;

if (!SetFilePointerEx(iodata->h, windowsoffset,

&windowsoffset, FILE_END)) {

if (status) {

*status = SDL_IO_STATUS_ERROR;

}

WIN_SetError("Error seeking in datastream");

return false;

}

DWORD bytes;

if (!WriteFile(iodata->h, iodata->write_data,

(DWORD)iodata->write_pos, &bytes, NULL)) {

if (status) {

*status = SDL_IO_STATUS_ERROR;

}

WIN_SetError("Error writing to datastream");

return false;

}

iodata->write_pos = 0;

return true;

}

static Sint64 SDLCALL windows_file_size(void *userdata)

{

IOStreamWindowsData *iodata = (IOStreamWindowsData *) userdata;

LARGE_INTEGER size;

if (!GetFileSizeEx(iodata->h, &size)) {

return WIN_SetError("windows_file_size");

}

return size.QuadPart;

}

static Sint64 SDLCALL windows_file_seek(void *userdata, Sint64 offset, SDL_IOWhence whence)

{

IOStreamWindowsData *iodata = (IOStreamWindowsData *) userdata;

DWORD windowswhence;

LARGE_INTEGER windowsoffset;

if (!windows_flush_write_buffer(iodata, NULL)) {

return -1;

}

// FIXME: We may be able to satisfy the seek within buffered data

if ((whence == SDL_IO_SEEK_CUR) && (iodata->left)) {

offset -= iodata->left;

}

iodata->left = 0;

switch (whence) {

case SDL_IO_SEEK_SET:

windowswhence = FILE_BEGIN;

break;

case SDL_IO_SEEK_CUR:

windowswhence = FILE_CURRENT;

break;

case SDL_IO_SEEK_END:

windowswhence = FILE_END;

break;

default:

SDL_SetError("windows_file_seek: Unknown value for 'whence'");

return -1;

}

windowsoffset.QuadPart = offset;

if (!SetFilePointerEx(iodata->h, windowsoffset, &windowsoffset, windowswhence)) {

return WIN_SetError("Error seeking in datastream");

}

return windowsoffset.QuadPart;

}

static size_t SDLCALL windows_file_read(void *userdata, void *ptr, size_t size, SDL_IOStatus *status)

{

IOStreamWindowsData *iodata = (IOStreamWindowsData *) userdata;

size_t total_need = size;

size_t total_read = 0;

size_t read_ahead;

DWORD bytes;

if (!windows_flush_write_buffer(iodata, status)) {

return 0;

}

if (iodata->left > 0) {

void *data = (char *)iodata->data +

iodata->size -

iodata->left;

read_ahead = SDL_min(total_need, iodata->left);

SDL_memcpy(ptr, data, read_ahead);

iodata->left -= read_ahead;

if (read_ahead == total_need) {

return size; 1798

}

ptr = (char *)ptr + read_ahead;

total_need -= read_ahead;

total_read += read_ahead;

}

if (total_need < READAHEAD_BUFFER_SIZE) {

if (!ReadFile(iodata->h, iodata->data, READAHEAD_BUFFER_SIZE, &bytes, NULL)) {

DWORD error = GetLastError();

switch (error) {

case ERROR_BROKEN_PIPE:

*status = SDL_IO_STATUS_EOF;

break;

case ERROR_NO_DATA:

*status = SDL_IO_STATUS_NOT_READY;

break;

default:

*status = SDL_IO_STATUS_ERROR;

WIN_SetError("Error reading from datastream");

break;

}

return 0; // !!! FIXME: this should return the bytes read from any readahead we finished out before this (the `iodata->left > 0` code above). In that case, fail on the next read.

F438 } else if (bytes == 0) {

*status = SDL_IO_STATUS_EOF;

}

read_ahead = SDL_min(total_need, bytes);

SDL_memcpy(ptr, iodata->data, read_ahead);

iodata->size = bytes;

iodata->left = bytes - read_ahead;

total_read += read_ahead;

} else {

if (!ReadFile(iodata->h, ptr, (DWORD)total_need, &bytes, NULL)) {

DWORD error = GetLastError();

switch (error) {

case ERROR_BROKEN_PIPE:

*status = SDL_IO_STATUS_EOF;

break;

case ERROR_NO_DATA:

*status = SDL_IO_STATUS_NOT_READY;

break;

default:

*status = SDL_IO_STATUS_ERROR;

WIN_SetError("Error reading from datastream");

break;

}

return 0; // !!! FIXME: this should return the bytes read from any readahead we finished out before this (the `iodata->left > 0` code above). In that case, fail on the next read.

} else if (bytes == 0) {

*status = SDL_IO_STATUS_EOF;

}

total_read += bytes;

}

return total_read;

}

static size_t SDLCALL windows_file_write(void *userdata, const void *ptr, size_t size, SDL_IOStatus *status)

{

IOStreamWindowsData *iodata = (IOStreamWindowsData *)userdata;

const Uint8 *src = (const Uint8 *)ptr;

size_t remaining = size;

size_t total_written = 0;

if (!iodata->writable) {

*status = SDL_IO_STATUS_READONLY;

return 0;

}

// Invalidate read-ahead buffer if it has data

if (iodata->left) {

if (!SetFilePointer(iodata->h, -(LONG)iodata->left,

NULL, FILE_CURRENT)) {

*status = SDL_IO_STATUS_ERROR;

WIN_SetError("Error seeking in datastream");

return 0;

}

iodata->left = 0;

}

// For large writes, flush buffer and write directly

if (size >= WRITEBEHIND_BUFFER_SIZE) {

if (!windows_flush_write_buffer(iodata, status)) {

return 0;

}

// In append mode, seek to EOF before direct write

if (iodata->append) {

LARGE_INTEGER windowsoffset;

windowsoffset.QuadPart = 0;

if (!SetFilePointerEx(iodata->h, windowsoffset,

&windowsoffset, FILE_END)) {

*status = SDL_IO_STATUS_ERROR;

WIN_SetError("Error seeking in datastream");

return 0;

}

DWORD bytes;

if (!WriteFile(iodata->h, ptr, (DWORD)size, &bytes, NULL)) {

*status = SDL_IO_STATUS_ERROR;

WIN_SetError("Error writing to datastream");

return 0;

} else if (bytes == 0 && size > 0) {

*status = SDL_IO_STATUS_NOT_READY;

}

return bytes;

}

// Buffer small writes

while (remaining > 0) {

size_t space = WRITEBEHIND_BUFFER_SIZE - iodata->write_pos;

size_t to_buffer = SDL_min(remaining, space);

SDL_memcpy((char *)iodata->write_data + iodata->write_pos,

src, to_buffer);

iodata->write_pos += to_buffer;

src += to_buffer;

remaining -= to_buffer;

total_written += to_buffer;

if (iodata->write_pos == WRITEBEHIND_BUFFER_SIZE) {

if (!windows_flush_write_buffer(iodata, status)) {

return total_written;

}

return total_written;

}

static bool SDLCALL windows_file_flush(void *userdata, SDL_IOStatus *status)

{

IOStreamWindowsData *iodata = (IOStreamWindowsData *)userdata;

if (!windows_flush_write_buffer(iodata, status)) {

return false;

}

// Sync to disk

if (!FlushFileBuffers(iodata->h)) {

return WIN_SetError("Error flushing datastream");

}

return true;

}

static bool SDLCALL windows_file_close(void *userdata)

{

IOStreamWindowsData *iodata = (IOStreamWindowsData *)userdata;

bool result = true;

if (!windows_flush_write_buffer(iodata, NULL)) {

result = false;

}

if (iodata->h != INVALID_HANDLE_VALUE) {

if (iodata->autoclose) {

CloseHandle(iodata->h);

}

iodata->h = INVALID_HANDLE_VALUE;

}

SDL_free(iodata->data);

SDL_free(iodata->write_data);

SDL_free(iodata);

return result;

}

static void windows_setioprops(SDL_PropertiesID props, void *userdata)

{

const IOStreamWindowsData *iodata = (const IOStreamWindowsData *) userdata;

SDL_SetPointerProperty(props, SDL_PROP_IOSTREAM_WINDOWS_HANDLE_POINTER, iodata->h);

}

SDL_IOStream *SDL_IOFromHandle(HANDLE handle, const char *mode, bool autoclose)

{

IOStreamWindowsData *iodata = (IOStreamWindowsData *) SDL_calloc(1, sizeof (*iodata));

if (!iodata) {

if (autoclose) {

CloseHandle(handle);

}

return NULL;

}

SDL_IOStreamInterface iface;

SDL_INIT_INTERFACE(&iface);

if (GetFileType(handle) == FILE_TYPE_DISK) {

iface.size = windows_file_size;

iface.seek = windows_file_seek;

}

iface.read = windows_file_read;

iface.write = windows_file_write;

iface.flush = windows_file_flush;

iface.close = windows_file_close;

iodata->h = handle;

iodata->writable = (SDL_strchr(mode, 'w') != NULL) ||

(SDL_strchr(mode, 'a') != NULL) ||

(SDL_strchr(mode, '+') != NULL);

iodata->append = (SDL_strchr(mode, 'a') != NULL);

iodata->autoclose = autoclose;

iodata->data = (char *)SDL_malloc(READAHEAD_BUFFER_SIZE);

if (!iodata->data) {

iface.close(iodata);

return NULL;

}

iodata->write_data = (char *)SDL_malloc(WRITEBEHIND_BUFFER_SIZE);

if (!iodata->write_data) {

iface.close(iodata);

return NULL;

}

iodata->write_pos = 0;

SDL_IOStream *iostr = SDL_OpenIO(&iface, iodata);

if (!iostr) {

iface.close(iodata);

} else {

iostr->setioprops = windows_setioprops;

}

return iostr;

}

#else

// Functions to read/write file descriptors. Not used for windows.

typedef struct IOStreamFDData

{

int fd;

bool autoclose;

} IOStreamFDData;

static int SDL_fdatasync(int fd)

{

int result = 0;

#if defined(SDL_PLATFORM_APPLE) // Apple doesn't have fdatasync (rather, the symbol exists as an incompatible system call).

result = fcntl(fd, F_FULLFSYNC);

#elif defined(SDL_PLATFORM_HAIKU)

result = fsync(fd);

#elif defined(HAVE_FDATASYNC)

result = fdatasync(fd);

#endif

return result;

}

static Sint64 SDLCALL fd_seek(void *userdata, Sint64 offset, SDL_IOWhence whence)

{

IOStreamFDData *iodata = (IOStreamFDData *) userdata;

int fdwhence;

switch (whence) {

case SDL_IO_SEEK_SET:

fdwhence = SEEK_SET;

break;

case SDL_IO_SEEK_CUR:

fdwhence = SEEK_CUR;

break;

case SDL_IO_SEEK_END:

fdwhence = SEEK_END;

break;

default:

SDL_SetError("Unknown value for 'whence'");

return -1;

}

off_t result = lseek(iodata->fd, (off_t)offset, fdwhence);

if (result < 0) {

SDL_SetError("Couldn't get stream offset: %s", strerror(errno));

}

return result;

}

< 10BC8 div>

static size_t SDLCALL fd_read(void *userdata, void *ptr, size_t size, SDL_IOStatus *status)

{

IOStreamFDData *iodata = (IOStreamFDData *) userdata;

ssize_t bytes;

do {

bytes = read(iodata->fd, ptr, size);

} while ((bytes < 0) && (errno == EINTR));

ssize_t result = bytes;

if ((bytes > 0) && (bytes < size)) { // was it a short read, EOF, or error?

// try to read the difference, so we can rule out a short read.

do {

result = read(iodata->fd, ((Uint8 *) ptr) + bytes, size - bytes);

} while ((result < 0) && (errno == EINTR));

if (result > 0) {

bytes += result;

result = bytes;

SDL_assert(bytes <= size);

}

if (result < 0) {

if (errno == EAGAIN) {

*status = SDL_IO_STATUS_NOT_READY;

} else {

*status = SDL_IO_STATUS_ERROR;

SDL_SetError("Error reading from datastream: %s", strerror(errno));

}

if (bytes < 0) {

bytes = 0;

}

} else if (result == 0) {

*status = SDL_IO_STATUS_EOF;

} else if (result < size) {

*status = SDL_IO_STATUS_NOT_READY;

}

return (size_t)bytes;

}

static size_t SDLCALL fd_write(void *userdata, const void *ptr, size_t size, SDL_IOStatus *status)

{

IOStreamFDData *iodata = (IOStreamFDData *) userdata;

ssize_t bytes;

do {

bytes = write(iodata->fd, ptr, size);

} while ((bytes < 0) && (errno == EINTR));

ssize_t result = bytes;

if ((bytes > 0) && (bytes < size)) { // was it a short write, or error?

// try to write the difference, so we can rule out a short read.

do {

result = write(iodata->fd, ((Uint8 *) ptr) + bytes, size - bytes);

} while ((result < 0) && (errno == EINTR));

if (result > 0) {

bytes += result;

result = bytes;

SDL_assert(bytes <= size);

}

if (result < 0) {

if (errno == EAGAIN) {

*status = SDL_IO_STATUS_NOT_READY;

} else {

*status = SDL_IO_STATUS_ERROR;

SDL_SetError("Error writing to datastream: %s", strerror(errno));

}

if (bytes < 0) {

bytes = 0;

}

} else if (result < size) {

*status = SDL_IO_STATUS_NOT_READY;

}

return (size_t)bytes;

}

static bool SDLCALL fd_flush(void *userdata, SDL_IOStatus *status)

{

IOStreamFDData *iodata = (IOStreamFDData *) userdata;

int result;

do {

result = SDL_fdatasync(iodata->fd);

} while (result < 0 && errno == EINTR);

// We get EINVAL when flushing a pipe, just make that a no-op

if (result < 0 && errno != EINVAL) {

return SDL_SetError("Error flushing datastream: %s", strerror(errno));

}

return true;

}

static bool SDLCALL fd_close(void *userdata)

{

IOStreamFDData *iodata = (IOStreamFDData *) userdata;

bool status = true;

if (iodata->autoclose) {

if (close(iodata->fd) < 0) {

status = SDL_SetError("Error closing datastream: %s", strerror(errno));

}

SDL_free(iodata);

return status;

}

static void fd_setioprops(SDL_PropertiesID props, void *userdata)

{

const IOStreamFDData *iodata = (const IOStreamFDData *) userdata;

SDL_SetNumberProperty(props, SDL_PROP_IOSTREAM_FILE_DESCRIPTOR_NUMBER, iodata->fd);

}

SDL_IOStream *SDL_IOFromFD(int fd, bool autoclose)

{

IOStreamFDData *iodata = (IOStreamFDData *) SDL_calloc(1, sizeof (*iodata));

if (!iodata) {

if (autoclose) {

close(fd);

}

return NULL;

}

SDL_IOStreamInterface iface;

SDL_INIT_INTERFACE(&iface);

// There's no fd_size because SDL_GetIOSize emulates it the same way we'd do it for fd anyhow.

iface.seek = fd_seek;

iface.read = fd_read;

iface.write = fd_write;

iface.flush = fd_flush;

iface.close = fd_close;

iodata->fd = fd;

iodata->autoclose = autoclose;

SDL_IOStream *iostr = SDL_OpenIO(&iface, iodata);

if (!iostr) {

iface.close(iodata);

} else {

iostr->setioprops = fd_setioprops;

}

return iostr;

}

#endif // SDL_PLATFORM_WINDOWS && !SDL_PLATFORM_CYGWIN

#if defined(HAVE_STDIO_H) && !(defined(SDL_PLATFORM_WINDOWS) && !defined(SDL_PLATFORM_CYGWIN))

// Functions to read/write stdio file pointers. Not used for windows.

typedef struct IOStreamStdioData

{

FILE *fp;

bool autoclose;

} IOStreamStdioData;

#ifdef HAVE_FOPEN64

#define fopen fopen64

#endif

#ifdef HAVE_FSEEKO64

#define fseek_off_t off64_t

#define fseek fseeko64

#define ftell ftello64

#elif defined(HAVE_FSEEKO)

#if defined(OFF_MIN) && defined(OFF_MAX)

#define FSEEK_OFF_MIN OFF_MIN

#define FSEEK_OFF_MAX OFF_MAX

#elif defined(HAVE_LIMITS_H)

/* POSIX doesn't specify the minimum and maximum macros for off_t so

* we have to improvise and dance around implementation-defined

* behavior. This may fail if the off_t type has padding bits or

* is not a two's-complement representation. The compilers will detect

* and eliminate the dead code if off_t has 64 bits.

#define FSEEK_OFF_MAX (((((off_t)1 << (sizeof(off_t) * CHAR_BIT - 2)) - 1) << 1) + 1)

#define FSEEK_OFF_MIN (-(FSEEK_OFF_MAX)-1)

#endif

#define fseek_off_t off_t

#define fseek fseeko

#define ftell ftello

#elif defined(HAVE__FSEEKI64)

#define fseek_off_t __int64

#define fseek _fseeki64

#define ftell _ftelli64

#else

#ifdef HAVE_LIMITS_H

#define FSEEK_OFF_MIN LONG_MIN

#define FSEEK_OFF_MAX LONG_MAX

#endif

#define fseek_off_t long

#endif

static Sint64 SDLCALL stdio_seek(void *userdata, Sint64 offset, SDL_IOWhence whence)

{

IOStreamStdioData *iodata = (IOStreamStdioData *) userdata;

int stdiowhence;

switch (whence) {

case SDL_IO_SEEK_SET:

stdiowhence = SEEK_SET;

break;

case SDL_IO_SEEK_CUR:

stdiowhence = SEEK_CUR;

break;

case SDL_IO_SEEK_END:

stdiowhence = SEEK_END;

break;

default:

SDL_SetError("Unknown value for 'whence'");

return -1;

}

#if defined(FSEEK_OFF_MIN) && defined(FSEEK_OFF_MAX)

if (offset < (Sint64)(FSEEK_OFF_MIN) || offset > (Sint64)(FSEEK_OFF_MAX)) {

SDL_SetError("Seek offset out of range");

return -1;

}

#endif

// don't make a possibly-costly API call for the noop seek from SDL_TellIO

const bool is_noop = (whence == SDL_IO_SEEK_CUR) && (offset == 0);

if (is_noop || fseek(iodata->fp, (fseek_off_t)offset, stdiowhence) == 0) {

const Sint64 pos = ftell(iodata->fp);

if (pos < 0) {

SDL_SetError("Couldn't get stream offset: %s", strerror(errno));

return -1;

}

return pos;

}

SDL_SetError("Error seeking in datastream: %s", strerror(errno));

return -1;

}

static size_t SDLCALL stdio_read(void *userdata, void *ptr, size_t size, SDL_IOStatus *status)

{

IOStreamStdioData *iodata = (IOStreamStdioData *) userdata;

const size_t bytes = fread(ptr, 1, size, iodata->fp);

if (bytes < size) {

if (ferror(iodata->fp)) {

if (errno == EAGAIN) {

*status = SDL_IO_STATUS_NOT_READY;

clearerr(iodata->fp);

} else {

*status = SDL_IO_STATUS_ERROR;

SDL_SetError("Error reading from datastream: %s", strerror(errno));

}

} else {

SDL_assert(feof(iodata->fp));

*status = SDL_IO_STATUS_EOF;

}

return bytes;

}

static size_t SDLCALL stdio_write(void *userdata, const void *ptr, size_t size, SDL_IOStatus *status)

{

IOStreamStdioData *iodata = (IOStreamStdioData *) userdata;

const size_t bytes = fwrite(ptr, 1, size, iodata->fp);

if (bytes == 0 && ferror(iodata->fp)) {

if (errno == EAGAIN) {

*status = SDL_IO_STATUS_NOT_READY;

clearerr(iodata->fp);

} else {

*status = SDL_IO_STATUS_ERROR;

SDL_SetError("Error writing to datastream: %s", strerror(errno));

}

return bytes;

}

static bool SDLCALL stdio_flush(void *userdata, SDL_IOStatus *status)

{

IOStreamStdioData *iodata = (IOStreamStdioData *) userdata;

if (fflush(iodata->fp) != 0) {

if (errno == EAGAIN) {

*status = SDL_IO_STATUS_NOT_READY;

return false;

} else {

return SDL_SetError("Error flushing datastream: %s", strerror(errno));

}

int result;

int fd = fileno(iodata->fp);

do {

result = SDL_fdatasync(fd);

} while (result < 0 && errno == EINTR);

if (result < 0) {

return SDL_SetError("Error flushing datastream: %s", strerror(errno));

}

return true;

}

static bool SDLCALL stdio_close(void *userdata)

{

IOStreamStdioData *iodata = (IOStreamStdioData *) userdata;

bool status = true;

if (iodata->autoclose) {

if (fclose(iodata->fp) != 0) {

status = SDL_SetError("Error closing datastream: %s", strerror(errno));

}

SDL_free(iodata);

return status;

}

static void stdio_setioprops(SDL_PropertiesID props, void *userdata)

{

const IOStreamStdioData *iodata = (const IOStreamStdioData *) userdata;

FILE *fp = iodata->fp;

SDL_SetPointerProperty(props, SDL_PROP_IOSTREAM_STDIO_FILE_POINTER, fp);

SDL_SetNumberProperty(props, SDL_PROP_IOSTREAM_FILE_DESCRIPTOR_NUMBER, fileno(fp));

}

SDL_IOStream *SDL_IOFromFP(FILE *fp, bool autoclose)

{

IOStreamStdioData *iodata = (IOStreamStdioData *) SDL_calloc(1, sizeof (*iodata));

if (!iodata) {

if (autoclose) {

fclose(fp);

}

return NULL;

}

SDL_IOStreamInterface iface;

SDL_INIT_INTERFACE(&iface);

// There's no stdio_size because SDL_GetIOSize emulates it the same way we'd do it for stdio anyhow.

iface.seek = stdio_seek;

iface.read = stdio_read;

iface.write = stdio_write;

iface.flush = stdio_flush;

iface.close = stdio_close;

iodata->fp = fp;

iodata->autoclose = autoclose;

SDL_IOStream *iostr = SDL_OpenIO(&iface, iodata);

if (!iostr) {

iface.close(iodata);

} else {

iostr->setioprops = stdio_setioprops;

}

return iostr;

}

#endif // HAVE_STDIO_H && !SDL_PLATFORM_WINDOWS && !SDL_PLATFORM_CYGWIN

// Functions to read/write memory pointers

typedef struct IOStreamMemData

{

Uint8 *base;

Uint8 *here;

Uint8 *stop;

size_t size;

SDL_PropertiesID props;

} IOStreamMemData;

static Sint64 SDLCALL mem_size(void *userdata)

{

const IOStreamMemData *iodata = (IOStreamMemData *) userdata;

return (iodata->stop - iodata->base);

}

static Sint64 SDLCALL mem_seek(void *userdata, Sint64 offset, SDL_IOWhence whence)

{

IOStreamMemData *iodata = (IOStreamMemData *) userdata;

Uint8 *newpos;

switch (whence) {

case SDL_IO_SEEK_SET:

newpos = iodata->base + offset;

break;

case SDL_IO_SEEK_CUR:

newpos = iodata->here + offset;

break;

case SDL_IO_SEEK_END:

newpos = iodata->stop + offset;

break;

default:

SDL_SetError("Unknown value for 'whence'");

return -1;

}

if (newpos < iodata->base) {

newpos = iodata->base;

}

if (newpos > iodata->stop) {

newpos = iodata->stop;

}

iodata->here = newpos;

return (Sint64)(iodata->here - iodata->base);

}

static size_t mem_io(void *userdata, void *dst, const void *src, size_t size)

{

IOStreamMemData *iodata = (IOStreamMemData *) userdata;

const size_t mem_available = (iodata->stop - iodata->here);

if (size > mem_available) {

size = mem_available;

}

SDL_memcpy(dst, src, size);

iodata->here += size;

return size;

}

static size_t SDLCALL mem_read(void *userdata, void *ptr, size_t size, SDL_IOStatus *status)

{

IOStreamMemData *iodata = (IOStreamMemData *) userdata;

const size_t retval = mem_io(userdata, ptr, iodata->here, size);

if ((retval < size) && (iodata->stop == iodata->here)) {

*status = SDL_IO_STATUS_EOF;

}

return retval;

}

static size_t SDLCALL mem_write(void *userdata, const void *ptr, size_t size, SDL_IOStatus *status)

{

IOStreamMemData *iodata = (IOStreamMemData *) userdata;

const size_t retval = mem_io(userdata, iodata->here, ptr, size);

if ((retval < size) && (iodata->stop == iodata->here)) {

SDL_SetError("Memory buffer is full");

*status = SDL_IO_STATUS_ERROR;

}

return retval;

}

static bool SDLCALL mem_close(void *userdata)

{

IOStreamMemData *iodata = (IOStreamMemData *) userdata;

SDL_free_func free_func = SDL_GetPointerProperty(iodata->props, SDL_PROP_IOSTREAM_MEMORY_FREE_FUNC_POINTER, NULL);

if (free_func) {

free_func(iodata->base);

}

SDL_free(userdata);

return true;

}

static void mem_setioprops(SDL_PropertiesID props, void *userdata)

{

IOStreamMemData *iodata = (IOStreamMemData *) userdata;

SDL_SetPointerProperty(props, SDL_PROP_IOSTREAM_MEMORY_POINTER, iodata->base);

SDL_SetNumberProperty(props, SDL_PROP_IOSTREAM_MEMORY_SIZE_NUMBER, iodata->size);

SDL_assert(iodata->props == 0);

iodata->props = props;

}

// Functions to create SDL_IOStream structures from various data sources

// private platforms might define SKIP_STDIO_DIR_TEST in their build configs, too.

#if (defined(SDL_PLATFORM_WINDOWS) && !defined(SDL_PLATFORM_CYGWIN)) || defined(SDL_PLATFORM_EMSCRIPTEN)

#define SKIP_STDIO_DIR_TEST 1

#endif

#if defined(HAVE_STDIO_H) && !defined(SKIP_STDIO_DIR_TEST)

static bool IsStdioFileADirectory(FILE *f)

{

struct stat st;

View remainder of file in raw view

FilesExpand file tree

SDL_iostream.c

Latest commit

History

SDL_iostream.c

File metadata and controls