bool settings_save(Settings *setfile)
{
char setfilename_tmp[1024];
RFILE *fp = NULL;
if (!setfile)
setfile = &normal_settings;
retro_create_path_string(setfilename_tmp, sizeof(setfilename_tmp), g_dir, setfilename);
fp = filestream_open(setfilename_tmp, RETRO_VFS_FILE_ACCESS_WRITE,
RETRO_VFS_FILE_ACCESS_HINT_NONE);
if (!fp)
{
NX_ERR("Couldn't open file %s.\n", setfilename_tmp);
return 1;
}
NX_LOG("Writing settings...\n");
for(int i=0;i<INPUT_COUNT;i++)
setfile->input_mappings[i] = input_get_mapping(i);
setfile->version = SETTINGS_VERSION;
filestream_write(fp, setfile, sizeof(Settings));
filestream_close(fp);
return 0;
}
void playlist_write_file(playlist_t *playlist)
{
size_t i;
RFILE *file = NULL;
if (!playlist || !playlist->modified)
return;
file = filestream_open(playlist->conf_path,
RETRO_VFS_FILE_ACCESS_WRITE, RETRO_VFS_FILE_ACCESS_HINT_NONE);
if (!file)
{
RARCH_ERR("Failed to write to playlist file: %s\n", playlist->conf_path);
return;
}
for (i = 0; i < playlist->size; i++)
filestream_printf(file, "%s\n%s\n%s\n%s\n%s\n%s\n",
playlist->entries[i].path ? playlist->entries[i].path : "",
playlist->entries[i].label ? playlist->entries[i].label : "",
playlist->entries[i].core_path,
playlist->entries[i].core_name,
playlist->entries[i].crc32 ? playlist->entries[i].crc32 : "",
playlist->entries[i].db_name ? playlist->entries[i].db_name : ""
);
playlist->modified = false;
RARCH_LOG("Written to playlist file: %s\n", playlist->conf_path);
filestream_close(file);
}
static bool tryload(Settings *setfile)
{
char setfilename_tmp[1024];
RFILE *fp = NULL;
retro_create_path_string(setfilename_tmp, sizeof(setfilename_tmp), g_dir, setfilename);
fp = filestream_open(setfilename_tmp, RETRO_VFS_FILE_ACCESS_READ,
RETRO_VFS_FILE_ACCESS_HINT_NONE);
if (!fp)
{
NX_ERR("Couldn't open file %s.\n", setfilename_tmp);
return 1;
}
NX_LOG("Loading settings...\n");
setfile->version = 0;
filestream_read(fp, setfile, sizeof(Settings));
if (setfile->version != SETTINGS_VERSION)
{
NX_ERR("Wrong settings version %04x.\n", setfile->version);
return 1;
}
filestream_close(fp);
return 0;
}
bool intfstream_open(intfstream_internal_t *intf, const char *path,
unsigned mode, unsigned hints)
{
if (!intf)
return false;
switch (intf->type)
{
case INTFSTREAM_FILE:
intf->file.fp = filestream_open(path, mode, hints);
if (!intf->file.fp)
return false;
break;
case INTFSTREAM_MEMORY:
intf->memory.fp = memstream_open(intf->memory.writable);
if (!intf->memory.fp)
return false;
break;
case INTFSTREAM_CHD:
#ifdef HAVE_CHD
intf->chd.fp = chdstream_open(path, intf->chd.track);
if (!intf->chd.fp)
return false;
break;
#else
return false;
#endif
}
return true;
}
static void gfx_ctx_mali_fbdev_destroy(void *data)
{
int fb;
RFILE *fd = NULL;
mali_ctx_data_t *mali = (mali_ctx_data_t*)data;
if (mali)
{
#ifdef HAVE_EGL
egl_destroy(&mali->egl);
#endif
mali->resize = false;
free(mali);
}
/* Clear framebuffer and set cursor on again */
fd = filestream_open("/dev/tty", RFILE_MODE_READ_WRITE, -1);
fb = filestream_get_fd(fd);
ioctl(fb, VT_ACTIVATE,5);
ioctl(fb, VT_ACTIVATE,1);
filestream_close(fd);
system("setterm -cursor on");
}
int detect_system(const char *track_path, const char **system_name)
{
int rv;
char magic[MAGIC_LEN];
int i;
RFILE *fd = filestream_open(track_path, RFILE_MODE_READ, -1);
if (!fd)
{
RARCH_LOG("Could not open data track of file '%s': %s\n",
track_path, strerror(errno));
rv = -errno;
goto clean;
}
RARCH_LOG("%s\n", msg_hash_to_str(MSG_COMPARING_WITH_KNOWN_MAGIC_NUMBERS));
for (i = 0; MAGIC_NUMBERS[i].system_name != NULL; i++)
{
filestream_seek(fd, MAGIC_NUMBERS[i].offset, SEEK_SET);
if (filestream_read(fd, magic, MAGIC_LEN) < MAGIC_LEN)
{
RARCH_LOG("Could not read data from file '%s' at offset %d: %s\n",
track_path, MAGIC_NUMBERS[i].offset, strerror(errno));
rv = -errno;
goto clean;
}
if (!string_is_empty(MAGIC_NUMBERS[i].magic) &&
!string_is_empty(magic) &&
string_is_equal_fast(MAGIC_NUMBERS[i].magic, magic, MAGIC_LEN))
{
*system_name = MAGIC_NUMBERS[i].system_name;
rv = 0;
goto clean;
}
}
filestream_seek(fd, 0x8008, SEEK_SET);
if (filestream_read(fd, magic, 8) > 0)
{
magic[8] = '\0';
if (!string_is_empty(magic) &&
string_is_equal_fast(magic, "PSP GAME", 8))
{
*system_name = "psp\0";
rv = 0;
goto clean;
}
}
RARCH_LOG("%s\n", msg_hash_to_str(MSG_COULD_NOT_FIND_COMPATIBLE_SYSTEM));
rv = -EINVAL;
clean:
filestream_close(fd);
return rv;
}
rxml_document_t *rxml_load_document(const char *path)
{
#ifndef RXML_TEST
RARCH_WARN("Using RXML as drop in for libxml2. Behavior might be very buggy.\n");
#endif
char *memory_buffer = NULL;
char *new_memory_buffer = NULL;
const char *mem_ptr = NULL;
long len = 0;
RFILE *file = filestream_open(path, RFILE_MODE_READ, -1);
if (!file)
return NULL;
rxml_document_t *doc = (rxml_document_t*)calloc(1, sizeof(*doc));
if (!doc)
goto error;
filestream_seek(file, 0, SEEK_END);
len = filestream_tell(file);
filestream_rewind(file);
memory_buffer = (char*)malloc(len + 1);
if (!memory_buffer)
goto error;
memory_buffer[len] = '\0';
if (filestream_read(file, memory_buffer, len) != (size_t)len)
goto error;
filestream_close(file);
file = NULL;
mem_ptr = memory_buffer;
if (!validate_header(&mem_ptr))
goto error;
new_memory_buffer = purge_xml_comments(mem_ptr);
if (!new_memory_buffer)
goto error;
free(memory_buffer);
mem_ptr = memory_buffer = new_memory_buffer;
doc->root_node = rxml_parse_node(&mem_ptr);
if (!doc->root_node)
goto error;
free(memory_buffer);
return doc;
error:
free(memory_buffer);
filestream_close(file);
rxml_free_document(doc);
return NULL;
}
/**
* filestream_read_file:
* @path : path to file.
* @buf : buffer to allocate and read the contents of the
* file into. Needs to be freed manually.
*
* Read the contents of a file into @buf.
*
* Returns: number of items read, -1 on error.
*/
int filestream_read_file(const char *path, void **buf, ssize_t *len)
{
ssize_t ret = 0;
ssize_t content_buf_size = 0;
void *content_buf = NULL;
RFILE *file = filestream_open(path, RFILE_MODE_READ, -1);
if (!file)
{
fprintf(stderr, "Failed to open %s: %s\n", path, strerror(errno));
goto error;
}
if (filestream_seek(file, 0, SEEK_END) != 0)
goto error;
content_buf_size = filestream_tell(file);
if (content_buf_size < 0)
goto error;
filestream_rewind(file);
content_buf = malloc(content_buf_size + 1);
if (!content_buf)
goto error;
ret = filestream_read(file, content_buf, content_buf_size);
if (ret < 0)
{
fprintf(stderr, "Failed to read %s: %s\n", path, strerror(errno));
goto error;
}
filestream_close(file);
*buf = content_buf;
/* Allow for easy reading of strings to be safe.
* Will only work with sane character formatting (Unix). */
((char*)content_buf)[content_buf_size] = '\0';
if (len)
*len = ret;
return 1;
error:
if (file)
filestream_close(file);
if (content_buf)
free(content_buf);
if (len)
*len = -1;
*buf = NULL;
return 0;
}
/**
* filestream_read_file:
* @path : path to file.
* @buf : buffer to allocate and read the contents of the
* file into. Needs to be freed manually.
*
* Read the contents of a file into @buf.
*
* Returns: number of items read, -1 on error.
*/
int64_t filestream_read_file(const char *path, void **buf, int64_t *len)
{
int64_t ret = 0;
int64_t content_buf_size = 0;
void *content_buf = NULL;
RFILE *file = filestream_open(path,
RETRO_VFS_FILE_ACCESS_READ,
RETRO_VFS_FILE_ACCESS_HINT_NONE);
if (!file)
{
fprintf(stderr, "Failed to open %s: %s\n", path, strerror(errno));
goto error;
}
content_buf_size = filestream_get_size(file);
if (content_buf_size < 0)
goto error;
content_buf = malloc((size_t)(content_buf_size + 1));
if (!content_buf)
goto error;
if ((int64_t)(uint64_t)(content_buf_size + 1) != (content_buf_size + 1))
goto error;
ret = filestream_read(file, content_buf, (int64_t)content_buf_size);
if (ret < 0)
{
fprintf(stderr, "Failed to read %s: %s\n", path, strerror(errno));
goto error;
}
filestream_close(file);
*buf = content_buf;
/* Allow for easy reading of strings to be safe.
* Will only work with sane character formatting (Unix). */
((char*)content_buf)[ret] = '\0';
if (len)
*len = ret;
return 1;
error:
if (file)
filestream_close(file);
if (content_buf)
free(content_buf);
if (len)
*len = -1;
*buf = NULL;
return 0;
}
rxml_document_t *rxml_load_document(const char *path)
{
rxml_document_t *doc;
char *memory_buffer = NULL;
char *new_memory_buffer = NULL;
const char *mem_ptr = NULL;
long len = 0;
RFILE *file = filestream_open(path,
RETRO_VFS_FILE_ACCESS_READ,
RETRO_VFS_FILE_ACCESS_HINT_NONE);
if (!file)
return NULL;
doc = (rxml_document_t*)calloc(1, sizeof(*doc));
if (!doc)
goto error;
len = filestream_get_size(file);
memory_buffer = (char*)malloc(len + 1);
if (!memory_buffer)
goto error;
memory_buffer[len] = '\0';
if (filestream_read(file, memory_buffer, len) != (size_t)len)
goto error;
filestream_close(file);
file = NULL;
mem_ptr = memory_buffer;
if (!validate_header(&mem_ptr))
goto error;
new_memory_buffer = purge_xml_comments(mem_ptr);
if (!new_memory_buffer)
goto error;
free(memory_buffer);
mem_ptr = memory_buffer = new_memory_buffer;
doc->root_node = rxml_parse_node(&mem_ptr);
if (!doc->root_node)
goto error;
free(memory_buffer);
return doc;
error:
free(memory_buffer);
filestream_close(file);
rxml_free_document(doc);
return NULL;
}
FileStream::FileStream(const char *path, const int mode)
{
fp = filestream_open(path, (mode == MODE_WRITE || mode == MODE_WRITE_INPLACE) ? RETRO_VFS_FILE_ACCESS_WRITE : RETRO_VFS_FILE_ACCESS_READ, RETRO_VFS_FILE_ACCESS_HINT_NONE);
if (!fp)
{
ErrnoHolder ene(errno);
MDFN_Error(ene.Errno(), "Error opening file:\n%s\n%s", path, ene.StrError());
}
}
int detect_system(const char *track_path, int32_t offset,
const char **system_name)
{
int rv;
char magic[MAGIC_LEN];
int i;
RFILE *fd = filestream_open(track_path, RFILE_MODE_READ, -1);
if (!fd)
{
RARCH_LOG("Could not open data track of file '%s': %s\n",
track_path, strerror(errno));
rv = -errno;
goto clean;
}
filestream_seek(fd, offset, SEEK_SET);
if (filestream_read(fd, magic, MAGIC_LEN) < MAGIC_LEN)
{
RARCH_LOG("Could not read data from file '%s' at offset %d: %s\n",
track_path, offset, strerror(errno));
rv = -errno;
goto clean;
}
RARCH_LOG("Comparing with known magic numbers...\n");
for (i = 0; MAGIC_NUMBERS[i].system_name != NULL; i++)
{
if (memcmp(MAGIC_NUMBERS[i].magic, magic, MAGIC_LEN) == 0)
{
*system_name = MAGIC_NUMBERS[i].system_name;
rv = 0;
goto clean;
}
}
filestream_seek(fd, 0x8008, SEEK_SET);
if (filestream_read(fd, magic, 8) > 0)
{
magic[8] = '\0';
if (string_is_equal(magic, "PSP GAME"))
{
*system_name = "psp\0";
rv = 0;
goto clean;
}
}
RARCH_LOG("Could not find compatible system\n");
rv = -EINVAL;
clean:
filestream_close(fd);
return rv;
}
static bool gfx_ctx_mali_fbdev_set_video_mode(void *data,
video_frame_info_t *video_info,
unsigned width, unsigned height,
bool fullscreen)
{
struct fb_var_screeninfo vinfo;
static const EGLint attribs[] = {
EGL_CONTEXT_CLIENT_VERSION, 2, /* Use version 2, even for GLES3. */
EGL_NONE
};
mali_ctx_data_t *mali = (mali_ctx_data_t*)data;
RFILE *fd = filestream_open("/dev/fb0", RFILE_MODE_READ_WRITE, -1);
int fb = filestream_get_fd(fd);
if (ioctl(fb, FBIOGET_VSCREENINFO, &vinfo) < 0)
{
RARCH_ERR("Error obtaining framebuffer info.\n");
goto error;
}
filestream_close(fd);
width = vinfo.xres;
height = vinfo.yres;
mali->width = width;
mali->height = height;
mali->native_window.width = vinfo.xres;
mali->native_window.height = vinfo.yres;
#ifdef HAVE_EGL
if (!egl_create_context(&mali->egl, attribs))
{
egl_report_error();
goto error;
}
#endif
#ifdef HAVE_EGL
if (!egl_create_surface(&mali->egl, &mali->native_window))
goto error;
#endif
return true;
error:
if (fd)
filestream_close(fd);
RARCH_ERR("[Mali fbdev]: EGL error: %d.\n", eglGetError());
gfx_ctx_mali_fbdev_destroy(data);
return false;
}
/**
* filestream_write_file:
* @path : path to file.
* @data : contents to write to the file.
* @size : size of the contents.
*
* Writes data to a file.
*
* Returns: true (1) on success, false (0) otherwise.
*/
bool filestream_write_file(const char *path, const void *data, ssize_t size)
{
ssize_t ret = 0;
RFILE *file = filestream_open(path, RFILE_MODE_WRITE, -1);
if (!file)
return false;
ret = filestream_write(file, data, size);
filestream_close(file);
return (ret == size);
}
/* Callback wrappers */
bool filestream_exists(const char *path)
{
RFILE *dummy = NULL;
if (!path || !*path)
return false;
dummy = filestream_open(path,
RETRO_VFS_FILE_ACCESS_READ,
RETRO_VFS_FILE_ACCESS_HINT_NONE);
if (!dummy)
return false;
filestream_close(dummy);
return true;
}
/**
* filestream_write_file:
* @path : path to file.
* @data : contents to write to the file.
* @size : size of the contents.
*
* Writes data to a file.
*
* Returns: true (1) on success, false (0) otherwise.
*/
bool filestream_write_file(const char *path, const void *data, int64_t size)
{
int64_t ret = 0;
RFILE *file = filestream_open(path,
RETRO_VFS_FILE_ACCESS_WRITE,
RETRO_VFS_FILE_ACCESS_HINT_NONE);
if (!file)
return false;
ret = filestream_write(file, data, size);
filestream_close(file);
if (ret != size)
return false;
return true;
}
/**
* libretrodb_cursor_open:
* @db : Handle to database.
* @cursor : Handle to database cursor.
* @q : Query to execute.
*
* Opens cursor to database based on query @q.
*
* Returns: 0 if successful, otherwise negative.
**/
int libretrodb_cursor_open(libretrodb_t *db, libretrodb_cursor_t *cursor,
libretrodb_query_t *q)
{
cursor->fd = filestream_open(db->path, RFILE_MODE_READ | RFILE_HINT_MMAP, -1);
if (!cursor->fd)
return -errno;
cursor->db = db;
cursor->is_valid = 1;
libretrodb_cursor_reset(cursor);
cursor->query = q;
if (q)
libretrodb_query_inc_ref(q);
return 0;
}
int libretrodb_open(const char *path, libretrodb_t *db)
{
libretrodb_header_t header;
libretrodb_metadata_t md;
int rv;
RFILE *fd = filestream_open(path, RFILE_MODE_READ, -1);
if (!fd)
return -errno;
strlcpy(db->path, path, sizeof(db->path));
db->root = filestream_seek(fd, 0, SEEK_CUR);
if ((rv = filestream_read(fd, &header, sizeof(header))) == -1)
{
rv = -errno;
goto error;
}
if (strncmp(header.magic_number, MAGIC_NUMBER, sizeof(MAGIC_NUMBER)) != 0)
{
rv = -EINVAL;
goto error;
}
header.metadata_offset = swap_if_little64(header.metadata_offset);
filestream_seek(fd, (ssize_t)header.metadata_offset, SEEK_SET);
if (libretrodb_read_metadata(fd, &md) < 0)
{
rv = -EINVAL;
goto error;
}
db->count = md.count;
db->first_index_offset = filestream_seek(fd, 0, SEEK_CUR);
db->fd = fd;
return 0;
error:
if (fd)
filestream_close(fd);
return rv;
}
int sha1_calculate(const char *path, char *result)
{
SHA1Context sha;
unsigned char buff[4096];
int rv = 1;
RFILE *fd = filestream_open(path, RFILE_MODE_READ, -1);
if (!fd)
goto error;
buff[0] = '\0';
SHA1Reset(&sha);
do
{
rv = filestream_read(fd, buff, 4096);
if (rv < 0)
goto error;
SHA1Input(&sha, buff, rv);
}while(rv);
if (!SHA1Result(&sha))
goto error;
sprintf(result, "%08X%08X%08X%08X%08X",
sha.Message_Digest[0],
sha.Message_Digest[1],
sha.Message_Digest[2],
sha.Message_Digest[3], sha.Message_Digest[4]);
filestream_close(fd);
return 0;
error:
if (fd)
filestream_close(fd);
return -1;
}
RFILE* rfopen(const char *path, const char *mode)
{
RFILE *output = NULL;
unsigned int retro_mode = RETRO_VFS_FILE_ACCESS_READ;
bool position_to_end = false;
if (strstr(mode, "r"))
{
retro_mode = RETRO_VFS_FILE_ACCESS_READ;
if (strstr(mode, "+"))
{
retro_mode = RETRO_VFS_FILE_ACCESS_READ_WRITE |
RETRO_VFS_FILE_ACCESS_UPDATE_EXISTING;
}
}
else if (strstr(mode, "w"))
{
retro_mode = RETRO_VFS_FILE_ACCESS_WRITE;
if (strstr(mode, "+"))
retro_mode = RETRO_VFS_FILE_ACCESS_READ_WRITE;
}
else if (strstr(mode, "a"))
{
retro_mode = RETRO_VFS_FILE_ACCESS_WRITE |
RETRO_VFS_FILE_ACCESS_UPDATE_EXISTING;
position_to_end = true;
if (strstr(mode, "+"))
{
retro_mode = RETRO_VFS_FILE_ACCESS_READ_WRITE |
RETRO_VFS_FILE_ACCESS_UPDATE_EXISTING;
}
}
output = filestream_open(path, retro_mode,
RETRO_VFS_FILE_ACCESS_HINT_NONE);
if (output && position_to_end)
filestream_seek(output, 0, RETRO_VFS_SEEK_POSITION_END);
return output;
}
bool intfstream_open(intfstream_internal_t *intf, const char *path,
unsigned mode, ssize_t len)
{
if (!intf)
return false;
switch (intf->type)
{
case INTFSTREAM_FILE:
intf->file.fp = filestream_open(path, mode, len);
if (!intf->file.fp)
return false;
break;
case INTFSTREAM_MEMORY:
intf->memory.fp = memstream_open(intf->memory.writable);
if (!intf->memory.fp)
return false;
break;
}
return true;
}
int find_first_data_track(const char *cue_path,
int32_t *offset, char *track_path, size_t max_len)
{
int rv, m, s, f;
char tmp_token[MAX_TOKEN_LEN];
char cue_dir[PATH_MAX_LENGTH];
RFILE *fd;
strlcpy(cue_dir, cue_path, sizeof(cue_dir));
path_basedir(cue_dir);
fd = filestream_open(cue_path, RFILE_MODE_READ, -1);
if (!fd)
{
RARCH_LOG("Could not open CUE file '%s': %s\n", cue_path,
strerror(errno));
return -errno;
}
RARCH_LOG("Parsing CUE file '%s'...\n", cue_path);
while (get_token(fd, tmp_token, MAX_TOKEN_LEN) > 0)
{
if (string_is_equal(tmp_token, "FILE"))
{
get_token(fd, tmp_token, MAX_TOKEN_LEN);
fill_pathname_join(track_path, cue_dir, tmp_token, max_len);
}
else if (string_is_equal_noncase(tmp_token, "TRACK"))
{
get_token(fd, tmp_token, MAX_TOKEN_LEN);
get_token(fd, tmp_token, MAX_TOKEN_LEN);
if (string_is_equal_noncase(tmp_token, "AUDIO"))
continue;
find_token(fd, "INDEX");
get_token(fd, tmp_token, MAX_TOKEN_LEN);
get_token(fd, tmp_token, MAX_TOKEN_LEN);
if (sscanf(tmp_token, "%02d:%02d:%02d", &m, &s, &f) < 3)
{
RARCH_LOG("Error parsing time stamp '%s'\n", tmp_token);
return -errno;
}
*offset = ((m * 60) * (s * 75) * f) * 25;
RARCH_LOG("Found 1st data track on file '%s+%d'\n",
track_path, *offset);
rv = 0;
goto clean;
}
}
rv = -EINVAL;
clean:
filestream_close(fd);
return rv;
}
/**
* video_shader_resolve_parameters:
* @conf : Preset file to read from.
* @shader : Shader passes handle.
*
* Resolves all shader parameters belonging to shaders.
*
* Returns: true (1) if successful, otherwise false (0).
**/
bool video_shader_resolve_parameters(config_file_t *conf,
struct video_shader *shader)
{
unsigned i;
struct video_shader_parameter *param = &shader->parameters[0];
shader->num_parameters = 0;
/* Find all parameters in our shaders. */
for (i = 0; i < shader->passes; i++)
{
#ifdef HAVE_SLANG
/* First try to use the more robust slang implementation to support #includes. */
/* FIXME: The check for slang can be removed if it's sufficiently tested for
* GLSL/Cg as well, it should be the same implementation. */
if (string_is_equal(path_get_extension(shader->pass[i].source.path), "slang") &&
slang_preprocess_parse_parameters(shader->pass[i].source.path, shader))
continue;
/* If that doesn't work, fallback to the old path.
* Ideally, we'd get rid of this path sooner or later. */
#endif
char line[4096];
RFILE *file = filestream_open(shader->pass[i].source.path, RFILE_MODE_READ_TEXT, -1);
if (!file)
continue;
line[0] = '\0';
while (shader->num_parameters < ARRAY_SIZE(shader->parameters)
&& filestream_gets(file, line, sizeof(line)))
{
int ret = sscanf(line,
"#pragma parameter %63s \"%63[^\"]\" %f %f %f %f",
param->id, param->desc, ¶m->initial,
¶m->minimum, ¶m->maximum, ¶m->step);
if (ret < 5)
continue;
param->id[63] = '\0';
param->desc[63] = '\0';
if (ret == 5)
param->step = 0.1f * (param->maximum - param->minimum);
RARCH_LOG("Found #pragma parameter %s (%s) %f %f %f %f\n",
param->desc, param->id, param->initial,
param->minimum, param->maximum, param->step);
param->current = param->initial;
shader->num_parameters++;
param++;
}
filestream_close(file);
}
if (conf && !video_shader_resolve_current_parameters(conf, shader))
return false;
return true;
}
int detect_psp_game(const char *track_path, char *game_id)
{
unsigned pos;
bool rv = false;
RFILE *fd = filestream_open(track_path, RFILE_MODE_READ, -1);
if (!fd)
{
RARCH_LOG("Could not open data track: %s\n", strerror(errno));
return -errno;
}
for (pos = 0; pos < 100000; pos++)
{
filestream_seek(fd, pos, SEEK_SET);
if (filestream_read(fd, game_id, 5) > 0)
{
game_id[5] = '\0';
if (string_is_equal(game_id, "ULES-")
|| string_is_equal(game_id, "ULUS-")
|| string_is_equal(game_id, "ULJS-")
|| string_is_equal(game_id, "ULEM-")
|| string_is_equal(game_id, "ULUM-")
|| string_is_equal(game_id, "ULJM-")
|| string_is_equal(game_id, "UCES-")
|| string_is_equal(game_id, "UCUS-")
|| string_is_equal(game_id, "UCJS-")
|| string_is_equal(game_id, "UCAS-")
|| string_is_equal(game_id, "NPEH-")
|| string_is_equal(game_id, "NPUH-")
|| string_is_equal(game_id, "NPJH-")
|| string_is_equal(game_id, "NPEG-")
|| string_is_equal(game_id, "NPUG-")
|| string_is_equal(game_id, "NPJG-")
|| string_is_equal(game_id, "NPHG-")
|| string_is_equal(game_id, "NPEZ-")
|| string_is_equal(game_id, "NPUZ-")
|| string_is_equal(game_id, "NPJZ-")
)
{
filestream_seek(fd, pos, SEEK_SET);
if (filestream_read(fd, game_id, 10) > 0)
{
#if 0
game_id[4] = '-';
game_id[8] = game_id[9];
game_id[9] = game_id[10];
#endif
game_id[10] = '\0';
rv = true;
}
break;
}
}
else
break;
}
filestream_close(fd);
return rv;
}
int find_first_data_track(const char *cue_path,
int32_t *offset, char *track_path, size_t max_len)
{
int rv;
char tmp_token[MAX_TOKEN_LEN];
RFILE *fd =
filestream_open(cue_path, RFILE_MODE_READ, -1);
if (!fd)
{
RARCH_LOG("Could not open CUE file '%s': %s\n", cue_path,
strerror(errno));
return -errno;
}
RARCH_LOG("Parsing CUE file '%s'...\n", cue_path);
tmp_token[0] = '\0';
while (get_token(fd, tmp_token, MAX_TOKEN_LEN) > 0)
{
if (!string_is_empty(tmp_token))
{
if (string_is_equal_fast(tmp_token, "FILE", 4))
{
char cue_dir[PATH_MAX_LENGTH];
cue_dir[0] = '\0';
fill_pathname_basedir(cue_dir, cue_path, sizeof(cue_dir));
get_token(fd, tmp_token, MAX_TOKEN_LEN);
fill_pathname_join(track_path, cue_dir, tmp_token, max_len);
}
else if (string_is_equal_fast(tmp_token, "TRACK", 5))
{
int m, s, f;
get_token(fd, tmp_token, MAX_TOKEN_LEN);
get_token(fd, tmp_token, MAX_TOKEN_LEN);
if (string_is_equal_fast(tmp_token, "AUDIO", 5))
continue;
find_token(fd, "INDEX");
get_token(fd, tmp_token, MAX_TOKEN_LEN);
get_token(fd, tmp_token, MAX_TOKEN_LEN);
if (sscanf(tmp_token, "%02d:%02d:%02d", &m, &s, &f) < 3)
{
RARCH_LOG("Error parsing time stamp '%s'\n", tmp_token);
filestream_close(fd);
return -errno;
}
*offset = ((m * 60) * (s * 75) * f) * 25;
RARCH_LOG("%s '%s+%d'\n",
msg_hash_to_str(MSG_FOUND_FIRST_DATA_TRACK_ON_FILE),
track_path, *offset);
rv = 0;
goto clean;
}
}
}
rv = -EINVAL;
clean:
filestream_close(fd);
return rv;
}
static int detect_ps1_game_sub(const char *track_path,
char *game_id, int sub_channel_mixed)
{
uint8_t* tmp;
uint8_t buffer[2048 * 2];
int skip, frame_size, is_mode1, cd_sector;
RFILE *fp = filestream_open(track_path, RFILE_MODE_READ, -1);
if (!fp)
return 0;
is_mode1 = 0;
filestream_seek(fp, 0, SEEK_END);
if (!sub_channel_mixed)
{
if (!(filestream_tell(fp) & 0x7FF))
{
unsigned int mode_test = 0;
filestream_seek(fp, 0, SEEK_SET);
filestream_read(fp, &mode_test, 4);
if (mode_test != MODETEST_VAL)
is_mode1 = 1;
}
}
skip = is_mode1? 0: 24;
frame_size = sub_channel_mixed? 2448: is_mode1? 2048: 2352;
filestream_seek(fp, 156 + skip + 16 * frame_size, SEEK_SET);
filestream_read(fp, buffer, 6);
cd_sector = buffer[2] | (buffer[3] << 8) | (buffer[4] << 16);
filestream_seek(fp, skip + cd_sector * frame_size, SEEK_SET);
filestream_read(fp, buffer, 2048 * 2);
tmp = buffer;
while (tmp < (buffer + 2048 * 2))
{
if (!*tmp)
return 0;
if (!strncasecmp((const char*)(tmp + 33), "SYSTEM.CNF;1", 12))
break;
tmp += *tmp;
}
if(tmp >= (buffer + 2048 * 2))
return 0;
cd_sector = tmp[2] | (tmp[3] << 8) | (tmp[4] << 16);
filestream_seek(fp, 13 + skip + cd_sector * frame_size, SEEK_SET);
filestream_read(fp, buffer, 256);
tmp = (uint8_t*)strrchr((const char*)buffer, '\\');
if(!tmp)
tmp = buffer;
else
tmp++;
*game_id++ = toupper(*tmp++);
*game_id++ = toupper(*tmp++);
*game_id++ = toupper(*tmp++);
*game_id++ = toupper(*tmp++);
*game_id++ = '-';
tmp++;
*game_id++ = *tmp++;
*game_id++ = *tmp++;
*game_id++ = *tmp++;
tmp++;
*game_id++ = *tmp++;
*game_id++ = *tmp++;
*game_id = 0;
filestream_close(fp);
return 1;
}
/* Parses log file referenced by runtime_log->path.
* Does nothing if log file does not exist. */
static void runtime_log_read_file(runtime_log_t *runtime_log)
{
unsigned runtime_hours = 0;
unsigned runtime_minutes = 0;
unsigned runtime_seconds = 0;
unsigned last_played_year = 0;
unsigned last_played_month = 0;
unsigned last_played_day = 0;
unsigned last_played_hour = 0;
unsigned last_played_minute = 0;
unsigned last_played_second = 0;
RtlJSONContext context = {0};
RFILE *file = NULL;
int ret = 0;
/* Check if log file exists */
if (!filestream_exists(runtime_log->path))
return;
/* Attempt to open log file */
file = filestream_open(runtime_log->path, RETRO_VFS_FILE_ACCESS_READ, RETRO_VFS_FILE_ACCESS_HINT_NONE);
if (!file)
{
RARCH_ERR("Failed to open runtime log file: %s\n", runtime_log->path);
return;
}
/* Initialise JSON parser */
context.runtime_string = NULL;
context.last_played_string = NULL;
context.parser = JSON_Parser_Create(NULL);
context.file = file;
if (!context.parser)
{
RARCH_ERR("Failed to create JSON parser.\n");
goto end;
}
/* Configure parser */
JSON_Parser_SetAllowBOM(context.parser, JSON_True);
JSON_Parser_SetStringHandler(context.parser, &RtlJSONStringHandler);
JSON_Parser_SetObjectMemberHandler(context.parser, &RtlJSONObjectMemberHandler);
JSON_Parser_SetUserData(context.parser, &context);
/* Read file */
while (!filestream_eof(file))
{
/* Runtime log files are tiny - use small chunk size */
char chunk[128] = {0};
int64_t length = filestream_read(file, chunk, sizeof(chunk));
/* Error checking... */
if (!length && !filestream_eof(file))
{
RARCH_ERR("Failed to read runtime log file: %s\n", runtime_log->path);
JSON_Parser_Free(context.parser);
goto end;
}
/* Parse chunk */
if (!JSON_Parser_Parse(context.parser, chunk, length, JSON_False))
{
RARCH_ERR("Error parsing chunk of runtime log file: %s\n---snip---\n%s\n---snip---\n", runtime_log->path, chunk);
RtlJSONLogError(&context);
JSON_Parser_Free(context.parser);
goto end;
}
}
/* Finalise parsing */
if (!JSON_Parser_Parse(context.parser, NULL, 0, JSON_True))
{
RARCH_WARN("Error parsing runtime log file: %s\n", runtime_log->path);
RtlJSONLogError(&context);
JSON_Parser_Free(context.parser);
goto end;
}
/* Free parser */
JSON_Parser_Free(context.parser);
/* Process string values read from JSON file */
/* Runtime */
ret = 0;
if (!string_is_empty(context.runtime_string))
ret = sscanf(context.runtime_string, LOG_FILE_RUNTIME_FORMAT_STR,
&runtime_hours, &runtime_minutes, &runtime_seconds);
if (ret != 3)
{
RARCH_ERR("Runtime log file - invalid 'runtime' entry detected: %s\n", runtime_log->path);
goto end;
}
/* Last played */
ret = 0;
if (!string_is_empty(context.last_played_string))
ret = sscanf(context.last_played_string, LOG_FILE_LAST_PLAYED_FORMAT_STR,
&last_played_year, &last_played_month, &last_played_day,
&last_played_hour, &last_played_minute, &last_played_second);
if (ret != 6)
{
RARCH_ERR("Runtime log file - invalid 'last played' entry detected: %s\n", runtime_log->path);
goto end;
}
/* If we reach this point then all is well
* > Assign values to runtime_log object */
runtime_log->runtime.hours = runtime_hours;
runtime_log->runtime.minutes = runtime_minutes;
runtime_log->runtime.seconds = runtime_seconds;
runtime_log->last_played.year = last_played_year;
runtime_log->last_played.month = last_played_month;
runtime_log->last_played.day = last_played_day;
runtime_log->last_played.hour = last_played_hour;
runtime_log->last_played.minute = last_played_minute;
runtime_log->last_played.second = last_played_second;
end:
/* Clean up leftover strings */
if (context.runtime_string)
free(context.runtime_string);
if (context.last_played_string)
free(context.last_played_string);
/* Close log file */
filestream_close(file);
}
static config_file_t *config_file_new_internal(
const char *path, unsigned depth, config_file_cb_t *cb)
{
RFILE *file = NULL;
struct config_file *conf = (struct config_file*)malloc(sizeof(*conf));
if (!conf)
return NULL;
conf->path = NULL;
conf->entries = NULL;
conf->tail = NULL;
conf->last = NULL;
conf->includes = NULL;
conf->include_depth = 0;
conf->guaranteed_no_duplicates = false ;
if (!path || !*path)
return conf;
if (path_is_directory(path))
goto error;
conf->path = strdup(path);
if (!conf->path)
goto error;
conf->include_depth = depth;
file = filestream_open(path,
RETRO_VFS_FILE_ACCESS_READ,
RETRO_VFS_FILE_ACCESS_HINT_NONE);
if (!file)
{
free(conf->path);
goto error;
}
while (!filestream_eof(file))
{
char *line = NULL;
struct config_entry_list *list = (struct config_entry_list*)malloc(sizeof(*list));
if (!list)
{
config_file_free(conf);
filestream_close(file);
return NULL;
}
list->readonly = false;
list->key = NULL;
list->value = NULL;
list->next = NULL;
line = filestream_getline(file);
if (!line)
{
free(list);
continue;
}
if (*line && parse_line(conf, list, line, cb))
{
if (conf->entries)
conf->tail->next = list;
else
conf->entries = list;
conf->tail = list;
if (cb != NULL && list->key != NULL && list->value != NULL)
cb->config_file_new_entry_cb(list->key, list->value) ;
}
free(line);
if (list != conf->tail)
free(list);
}
filestream_close(file);
return conf;
error:
free(conf);
return NULL;
}
/* Saves specified runtime log to disk */
void runtime_log_save(runtime_log_t *runtime_log)
{
RtlJSONContext context = {0};
RFILE *file = NULL;
char value_string[64]; /* 64 characters should be enough for a very long runtime... :) */
int n;
if (!runtime_log)
return;
RARCH_LOG("Saving runtime log file: %s\n", runtime_log->path);
/* Attempt to open log file */
file = filestream_open(runtime_log->path, RETRO_VFS_FILE_ACCESS_WRITE, RETRO_VFS_FILE_ACCESS_HINT_NONE);
if (!file)
{
RARCH_ERR("Failed to open runtime log file: %s\n", runtime_log->path);
return;
}
/* Initialise JSON writer */
context.writer = JSON_Writer_Create(NULL);
context.file = file;
if (!context.writer)
{
RARCH_ERR("Failed to create JSON writer.\n");
goto end;
}
/* Configure JSON writer */
JSON_Writer_SetOutputEncoding(context.writer, JSON_UTF8);
JSON_Writer_SetOutputHandler(context.writer, &RtlJSONOutputHandler);
JSON_Writer_SetUserData(context.writer, &context);
/* Write output file */
JSON_Writer_WriteStartObject(context.writer);
JSON_Writer_WriteNewLine(context.writer);
/* > Version entry */
JSON_Writer_WriteSpace(context.writer, 2);
JSON_Writer_WriteString(context.writer, "version", strlen("version"), JSON_UTF8);
JSON_Writer_WriteColon(context.writer);
JSON_Writer_WriteSpace(context.writer, 1);
JSON_Writer_WriteString(context.writer, "1.0", strlen("1.0"), JSON_UTF8);
JSON_Writer_WriteComma(context.writer);
JSON_Writer_WriteNewLine(context.writer);
/* > Runtime entry */
value_string[0] = '\0';
n = snprintf(value_string, sizeof(value_string), LOG_FILE_RUNTIME_FORMAT_STR,
runtime_log->runtime.hours, runtime_log->runtime.minutes, runtime_log->runtime.seconds);
if ((n < 0) || (n >= 64))
n = 0; /* Silence GCC warnings... */
JSON_Writer_WriteSpace(context.writer, 2);
JSON_Writer_WriteString(context.writer, "runtime", strlen("runtime"), JSON_UTF8);
JSON_Writer_WriteColon(context.writer);
JSON_Writer_WriteSpace(context.writer, 1);
JSON_Writer_WriteString(context.writer, value_string, strlen(value_string), JSON_UTF8);
JSON_Writer_WriteComma(context.writer);
JSON_Writer_WriteNewLine(context.writer);
/* > Last played entry */
value_string[0] = '\0';
n = snprintf(value_string, sizeof(value_string), LOG_FILE_LAST_PLAYED_FORMAT_STR,
runtime_log->last_played.year, runtime_log->last_played.month, runtime_log->last_played.day,
runtime_log->last_played.hour, runtime_log->last_played.minute, runtime_log->last_played.second);
if ((n < 0) || (n >= 64))
n = 0; /* Silence GCC warnings... */
JSON_Writer_WriteSpace(context.writer, 2);
JSON_Writer_WriteString(context.writer, "last_played", strlen("last_played"), JSON_UTF8);
JSON_Writer_WriteColon(context.writer);
JSON_Writer_WriteSpace(context.writer, 1);
JSON_Writer_WriteString(context.writer, value_string, strlen(value_string), JSON_UTF8);
JSON_Writer_WriteNewLine(context.writer);
/* > Finalise */
JSON_Writer_WriteEndObject(context.writer);
JSON_Writer_WriteNewLine(context.writer);
/* Free JSON writer */
JSON_Writer_Free(context.writer);
end:
/* Close log file */
filestream_close(file);
}
static void *gfx_ctx_drm_init(void *video_driver)
{
int fd, i;
unsigned monitor_index;
unsigned gpu_index = 0;
const char *gpu = NULL;
struct string_list *gpu_descriptors = NULL;
gfx_ctx_drm_data_t *drm = (gfx_ctx_drm_data_t*)
calloc(1, sizeof(gfx_ctx_drm_data_t));
if (!drm)
return NULL;
gpu_descriptors = dir_list_new("/dev/dri", NULL, false, true, false, false);
nextgpu:
free_drm_resources(drm);
if (!gpu_descriptors || gpu_index == gpu_descriptors->size)
{
RARCH_ERR("[KMS]: Couldn't find a suitable DRM device.\n");
goto error;
}
gpu = gpu_descriptors->elems[gpu_index++].data;
drm->drm = filestream_open(gpu, RFILE_MODE_READ_WRITE, -1);
if (!drm->drm)
{
RARCH_WARN("[KMS]: Couldn't open DRM device.\n");
goto nextgpu;
}
fd = filestream_get_fd(drm->drm);
if (!drm_get_resources(fd))
goto nextgpu;
if (!drm_get_connector(fd))
goto nextgpu;
if (!drm_get_encoder(fd))
goto nextgpu;
drm_setup(fd);
/* First mode is assumed to be the "optimal"
* one for get_video_size() purposes. */
drm->fb_width = g_drm_connector->modes[0].hdisplay;
drm->fb_height = g_drm_connector->modes[0].vdisplay;
g_gbm_dev = gbm_create_device(fd);
if (!g_gbm_dev)
{
RARCH_WARN("[KMS]: Couldn't create GBM device.\n");
goto nextgpu;
}
dir_list_free(gpu_descriptors);
/* Setup the flip handler. */
g_drm_fds.fd = fd;
g_drm_fds.events = POLLIN;
g_drm_evctx.version = DRM_EVENT_CONTEXT_VERSION;
g_drm_evctx.page_flip_handler = drm_flip_handler;
g_drm_fd = fd;
return drm;
error:
dir_list_free(gpu_descriptors);
gfx_ctx_drm_destroy_resources(drm);
if (drm)
free(drm);
return NULL;
}
