const struct file_archive_file_backend* file_archive_get_file_backend(const char *path)
{
char newpath[PATH_MAX_LENGTH];
const char *file_ext = NULL;
char *last = NULL;
newpath[0] = '\0';
strlcpy(newpath, path, sizeof(newpath));
last = (char*)path_get_archive_delim(newpath);
if (last)
*last = '\0';
file_ext = path_get_extension(newpath);
#ifdef HAVE_7ZIP
if (string_is_equal_noncase(file_ext, "7z"))
return &sevenzip_backend;
#endif
#ifdef HAVE_ZLIB
if ( string_is_equal_noncase(file_ext, "zip")
|| string_is_equal_noncase(file_ext, "apk")
)
return &zlib_backend;
#endif
return NULL;
}
static bool find_first_libretro(char *path, size_t size,
const char *dir, const char *rom_path)
{
bool ret = false;
const char *ext = path_get_extension(rom_path);
if (!ext || !*ext)
{
RARCH_ERR("Path has no extension. Cannot infer libretro implementation.\n");
return false;
}
RARCH_LOG("Searching for valid libretro implementation in: \"%s\".\n", dir);
struct string_list *list = dir_list_new(dir, DYNAMIC_EXT, false);
if (!list)
{
RARCH_ERR("Couldn't open directory: \"%s\".\n", dir);
return false;
}
for (size_t i = 0; i < list->size && !ret; i++)
{
RARCH_LOG("Checking library: \"%s\".\n", list->elems[i].data);
dylib_t lib = dylib_load(list->elems[i].data);
if (!lib)
continue;
void (*proc)(struct retro_system_info*) =
(void (*)(struct retro_system_info*))dylib_proc(lib, "retro_get_system_info");
if (!proc)
{
dylib_close(lib);
continue;
}
struct retro_system_info info = {0};
proc(&info);
if (!info.valid_extensions)
{
dylib_close(lib);
continue;
}
struct string_list *supported_ext = string_split(info.valid_extensions, "|");
if (string_list_find_elem(supported_ext, ext))
{
strlcpy(path, list->elems[i].data, size);
ret = true;
}
string_list_free(supported_ext);
dylib_close(lib);
}
dir_list_free(list);
return ret;
}
bool core_info_database_supports_content_path(const char *database_path, const char *path)
{
size_t i;
char *database = NULL;
if (!core_info_curr_list)
return false;
database = strdup(path_basename(database_path));
path_remove_extension(database);
for (i = 0; i < core_info_curr_list->count; i++)
{
const core_info_t *info = &core_info_curr_list->list[i];
if (string_list_find_elem(info->supported_extensions_list, path_get_extension(path)))
if (string_list_find_elem(info->databases_list, database))
{
free(database);
return true;
}
}
free(database);
return false;
}
void title_sequence_rename_save(int preset, int index, const char *newName)
{
if (preset >= TITLE_SEQUENCE_DEFAULT_PRESETS && preset < gConfigTitleSequences.num_presets && index >= 0 && index < gConfigTitleSequences.presets[preset].num_saves &&
filename_valid_characters(newName) && !title_sequence_save_exists(preset, newName)) {
// Rename the save file
char separator = platform_get_path_separator();
utf8 src[MAX_PATH], dest[MAX_PATH];
platform_get_user_directory(src, "title sequences");
platform_get_user_directory(dest, "title sequences");
strcat(src, gConfigTitleSequences.presets[preset].name);
strcat(dest, gConfigTitleSequences.presets[preset].name);
strncat(src, &separator, 1);
strncat(dest, &separator, 1);
strcat(src, gConfigTitleSequences.presets[preset].saves[index]);
strcat(dest, newName);
// Add the appropriate extension if needed
char *extension = (char*)path_get_extension(newName);
if (_stricmp(extension, ".sv6") != 0 && _stricmp(extension, ".sc6") != 0)
strcat(dest, ".sv6");
platform_file_move(src, dest);
safe_strncpy(gConfigTitleSequences.presets[preset].saves[index], newName, TITLE_SEQUENCE_MAX_SAVE_LENGTH);
// Add the appropriate extension if needed
if (_stricmp(extension, ".sv6") != 0 && _stricmp(extension, ".sc6") != 0)
strcat(gConfigTitleSequences.presets[preset].saves[index], ".sv6");
title_sequence_save_preset_script(preset);
}
}
static void *hlsl_init(void *data, const char *path)
{
unsigned i;
d3d_video_t *d3d = (d3d_video_t*)data;
hlsl_shader_data_t *hlsl_data = (hlsl_shader_data_t*)
calloc(1, sizeof(hlsl_shader_data_t));
if (!hlsl_data)
return NULL;
if (path && (string_is_equal_fast(path_get_extension(path), ".cgp", 4)))
{
if (!hlsl_load_preset(hlsl_data, d3d, path))
goto error;
}
else
{
if (!hlsl_load_plain(hlsl_data, d3d, path))
goto error;
}
for(i = 1; i <= hlsl_data->cg_shader->passes; i++)
hlsl_set_program_attributes(hlsl_data, i);
d3d_set_vertex_shader(d3d->dev, 1, hlsl_data->prg[1].vprg);
d3d->dev->SetPixelShader(hlsl_data->prg[1].fprg);
return hlsl_data;
error:
if (hlsl_data)
free(hlsl_data);
return NULL;
}
static bool cmd_set_shader(const char *arg)
{
if (!driver.video->set_shader)
return false;
enum rarch_shader_type type = RARCH_SHADER_NONE;
const char *ext = path_get_extension(arg);
if (strcmp(ext, "glsl") == 0 || strcmp(ext, "glslp") == 0)
type = RARCH_SHADER_GLSL;
else if (strcmp(ext, "cg") == 0 || strcmp(ext, "cgp") == 0)
type = RARCH_SHADER_CG;
if (type == RARCH_SHADER_NONE)
return false;
msg_queue_clear(g_extern.msg_queue);
char msg[PATH_MAX];
snprintf(msg, sizeof(msg), "Shader: \"%s\"", arg);
msg_queue_push(g_extern.msg_queue, msg, 1, 120);
RARCH_LOG("Applying shader \"%s\".\n", arg);
return video_set_shader_func(type, arg);
}
static int file_archive_extract_cb(const char *name, const char *valid_exts,
const uint8_t *cdata,
unsigned cmode, uint32_t csize, uint32_t size,
uint32_t checksum, void *userdata)
{
const char *ext = path_get_extension(name);
struct zip_extract_userdata *data = (struct zip_extract_userdata*)userdata;
/* Extract first content that matches our list. */
if (ext && string_list_find_elem(data->ext, ext))
{
char new_path[PATH_MAX_LENGTH] = {0};
if (data->extraction_directory)
fill_pathname_join(new_path, data->extraction_directory,
path_basename(name), sizeof(new_path));
else
fill_pathname_resolve_relative(new_path, data->zip_path,
path_basename(name), sizeof(new_path));
data->first_extracted_file_path = strdup(new_path);
data->found_content = file_archive_perform_mode(new_path,
valid_exts, cdata, cmode, csize, size,
0, NULL);
return 0;
}
return 1;
}
bool core_info_does_support_file(const core_info_t *core, const char *path)
{
if (!path || !core || !core->supported_extensions_list)
return false;
return string_list_find_elem_prefix(core->supported_extensions_list, ".", path_get_extension(path));
}
static bool hlsl_init(const char *path)
{
xdk_d3d_video_t *d3d = (xdk_d3d_video_t*)driver.video_data;
if (path && strcmp(path_get_extension(path), ".cgp") == 0)
{
if (!load_preset(path))
return false;
}
else
{
if (!load_plain(path))
return false;
}
for(unsigned i = 1; i <= cg_shader->passes; i++)
set_program_attributes(i);
d3d_device_ptr = d3d->d3d_render_device;
d3d->d3d_render_device->SetVertexShader(prg[1].vprg);
d3d->d3d_render_device->SetPixelShader(prg[1].fprg);
hlsl_active = true;
return true;
}
static bool cmd_set_shader(const char *arg)
{
char msg[PATH_MAX_LENGTH] = {0};
enum rarch_shader_type type = RARCH_SHADER_NONE;
const char *ext = path_get_extension(arg);
uint32_t ext_hash = msg_hash_calculate(ext);
switch (ext_hash)
{
case COMMAND_EXT_GLSL:
case COMMAND_EXT_GLSLP:
type = RARCH_SHADER_GLSL;
break;
case COMMAND_EXT_CG:
case COMMAND_EXT_CGP:
type = RARCH_SHADER_CG;
break;
default:
return false;
}
snprintf(msg, sizeof(msg), "Shader: \"%s\"", arg);
rarch_main_msg_queue_push(msg, 1, 120, true);
RARCH_LOG("%s \"%s\".\n",
msg_hash_to_str(MSG_APPLYING_SHADER),
arg);
return video_driver_set_shader(type, arg);
}
void title_sequence_add_save(int preset, const char *path, const char *newName)
{
utf8 newPath[MAX_PATH];
char *extension = (char*)path_get_extension(newName);
safe_strncpy(newPath, newName, MAX_PATH);
if (_stricmp(extension, ".sv6") != 0 && _stricmp(extension, ".sc6") != 0)
strcat(newPath, ".sv6");
if (preset >= TITLE_SEQUENCE_DEFAULT_PRESETS && preset < gConfigTitleSequences.num_presets && filename_valid_characters(newPath) && !title_sequence_save_exists(preset, newPath) && platform_file_exists(path)) {
// Copy the save file
char separator = platform_get_path_separator();
platform_get_user_directory(newPath, "title sequences");
strcat(newPath, gConfigTitleSequences.presets[preset].name);
strncat(newPath, &separator, 1);
strcat(newPath, newName);
// Add the appropriate extension if needed
if (_stricmp(extension, ".sv6") != 0 && _stricmp(extension, ".sc6") != 0)
strcat(newPath, ".sv6");
platform_file_copy(path, newPath, false);
gConfigTitleSequences.presets[preset].num_saves++;
gConfigTitleSequences.presets[preset].saves = realloc(gConfigTitleSequences.presets[preset].saves, sizeof(char[TITLE_SEQUENCE_MAX_SAVE_LENGTH]) * (size_t)gConfigTitleSequences.presets[preset].num_saves);
safe_strncpy(gConfigTitleSequences.presets[preset].saves[gConfigTitleSequences.presets[preset].num_saves - 1], newName, TITLE_SEQUENCE_MAX_SAVE_LENGTH);
// Add the appropriate extension if needed
if (_stricmp(extension, ".sv6") != 0 && _stricmp(extension, ".sc6") != 0)
strcat(gConfigTitleSequences.presets[preset].saves[gConfigTitleSequences.presets[preset].num_saves - 1], ".sv6");
}
}
bool d3d_process_shader(void *data)
{
D3DVideo *d3d = reinterpret_cast<D3DVideo*>(data);
if (strcmp(path_get_extension(d3d->cg_shader.c_str()), "cgp") == 0)
return d3d_init_multipass(d3d);
return d3d_init_singlepass(d3d);
}
enum rarch_content_type path_is_media_type(const char *path)
{
char ext_lower[128];
ext_lower[0] = '\0';
strlcpy(ext_lower, path_get_extension(path), sizeof(ext_lower));
string_to_lower(ext_lower);
switch (msg_hash_to_file_type(msg_hash_calculate(ext_lower)))
{
#ifdef HAVE_FFMPEG
case FILE_TYPE_OGM:
case FILE_TYPE_MKV:
case FILE_TYPE_AVI:
case FILE_TYPE_MP4:
case FILE_TYPE_FLV:
case FILE_TYPE_WEBM:
case FILE_TYPE_3GP:
case FILE_TYPE_3G2:
case FILE_TYPE_F4F:
case FILE_TYPE_F4V:
case FILE_TYPE_MOV:
case FILE_TYPE_WMV:
case FILE_TYPE_MPG:
case FILE_TYPE_MPEG:
case FILE_TYPE_VOB:
case FILE_TYPE_ASF:
case FILE_TYPE_DIVX:
case FILE_TYPE_M2P:
case FILE_TYPE_M2TS:
case FILE_TYPE_PS:
case FILE_TYPE_TS:
case FILE_TYPE_MXF:
return RARCH_CONTENT_MOVIE;
case FILE_TYPE_WMA:
case FILE_TYPE_OGG:
case FILE_TYPE_MP3:
case FILE_TYPE_M4A:
case FILE_TYPE_FLAC:
case FILE_TYPE_WAV:
return RARCH_CONTENT_MUSIC;
#endif
#ifdef HAVE_IMAGEVIEWER
case FILE_TYPE_JPEG:
case FILE_TYPE_PNG:
case FILE_TYPE_TGA:
case FILE_TYPE_BMP:
return RARCH_CONTENT_IMAGE;
#endif
case FILE_TYPE_NONE:
default:
break;
}
return RARCH_CONTENT_NONE;
}
static bool d3d_process_shader(d3d_video_t *d3d)
{
#ifdef HAVE_FBO
if (string_is_equal(path_get_extension(d3d->shader_path.c_str()), "cgp"))
return d3d_init_multipass(d3d);
#endif
return d3d_init_singlepass(d3d);
}
static bool d3d_process_shader(d3d_video_t *d3d)
{
#ifdef HAVE_FBO
if (strcmp(path_get_extension(d3d->cg_shader.c_str()), "cgp") == 0)
return d3d_init_multipass(d3d);
#endif
return d3d_init_singlepass(d3d);
}
static bool type_is_prioritized(const char *path)
{
const char *ext = path_get_extension(path);
if (string_is_equal_noncase(ext, "cue"))
return true;
if (string_is_equal_noncase(ext, "gdi"))
return true;
return false;
}
/**
* check_shader_dir:
* @pressed_next : was next shader key pressed?
* @pressed_previous : was previous shader key pressed?
*
* Checks if any one of the shader keys has been pressed for this frame:
* a) Next shader index.
* b) Previous shader index.
*
* Will also immediately apply the shader.
**/
static void check_shader_dir(rarch_dir_list_t *dir_list,
bool pressed_next, bool pressed_prev)
{
uint32_t ext_hash;
char msg[128];
const char *shader = NULL;
const char *ext = NULL;
enum rarch_shader_type type = RARCH_SHADER_NONE;
if (!dir_list || !dir_list->list)
return;
if (pressed_next)
{
dir_list->ptr = (dir_list->ptr + 1) %
dir_list->list->size;
}
else if (pressed_prev)
{
if (dir_list->ptr == 0)
dir_list->ptr = dir_list->list->size - 1;
else
dir_list->ptr--;
}
else
return;
shader = dir_list->list->elems[dir_list->ptr].data;
ext = path_get_extension(shader);
ext_hash = msg_hash_calculate(ext);
switch (ext_hash)
{
case SHADER_EXT_GLSL:
case SHADER_EXT_GLSLP:
type = RARCH_SHADER_GLSL;
break;
case SHADER_EXT_CG:
case SHADER_EXT_CGP:
type = RARCH_SHADER_CG;
break;
default:
return;
}
snprintf(msg, sizeof(msg), "%s #%u: \"%s\".",
msg_hash_to_str(MSG_SHADER),
(unsigned)dir_list->ptr, shader);
runloop_msg_queue_push(msg, 1, 120, true);
RARCH_LOG("%s \"%s\".\n",
msg_hash_to_str(MSG_APPLYING_SHADER),
shader);
if (!video_driver_set_shader(type, shader))
RARCH_WARN("%s\n", msg_hash_to_str(MSG_FAILED_TO_APPLY_SHADER));
}
static bool init_content_file_extract(
struct string_list *temporary_content,
struct string_list *content,
rarch_system_info_t *system,
const struct retro_subsystem_info *special,
union string_list_elem_attr *attr
)
{
unsigned i;
settings_t *settings = config_get_ptr();
for (i = 0; i < content->size; i++)
{
const char *ext = NULL;
const char *valid_ext = system->info.valid_extensions;
/* Block extract check. */
if (content->elems[i].attr.i & 1)
continue;
ext = path_get_extension(content->elems[i].data);
if (special)
valid_ext = special->roms[i].valid_extensions;
if (!ext)
continue;
if (string_is_equal_noncase(ext, "zip"))
{
char new_path[PATH_MAX_LENGTH];
char temp_content[PATH_MAX_LENGTH];
strlcpy(temp_content, content->elems[i].data,
sizeof(temp_content));
if (!file_archive_extract_first_content_file(temp_content,
sizeof(temp_content), valid_ext,
*settings->cache_directory ?
settings->cache_directory : NULL,
new_path, sizeof(new_path)))
{
RARCH_ERR("Failed to extract content from zipped file: %s.\n",
temp_content);
return false;
}
string_list_set(content, i, new_path);
if (!string_list_append(temporary_content,
new_path, *attr))
return false;
}
}
return true;
}
/**
* check_shader_dir:
* @pressed_next : was next shader key pressed?
* @pressed_previous : was previous shader key pressed?
*
* Checks if any one of the shader keys has been pressed for this frame:
* a) Next shader index.
* b) Previous shader index.
*
* Will also immediately apply the shader.
**/
static void check_shader_dir(global_t *global,
bool pressed_next, bool pressed_prev)
{
uint32_t ext_hash;
char msg[PATH_MAX_LENGTH] = {0};
const char *shader = NULL;
const char *ext = NULL;
enum rarch_shader_type type = RARCH_SHADER_NONE;
if (!global || !global->shader_dir.list)
return;
if (pressed_next)
{
global->shader_dir.ptr = (global->shader_dir.ptr + 1) %
global->shader_dir.list->size;
}
else if (pressed_prev)
{
if (global->shader_dir.ptr == 0)
global->shader_dir.ptr = global->shader_dir.list->size - 1;
else
global->shader_dir.ptr--;
}
else
return;
shader = global->shader_dir.list->elems[global->shader_dir.ptr].data;
ext = path_get_extension(shader);
ext_hash = msg_hash_calculate(ext);
switch (ext_hash)
{
case SHADER_EXT_GLSL:
case SHADER_EXT_GLSLP:
type = RARCH_SHADER_GLSL;
break;
case SHADER_EXT_CG:
case SHADER_EXT_CGP:
type = RARCH_SHADER_CG;
break;
default:
return;
}
snprintf(msg, sizeof(msg), "%s #%u: \"%s\".",
msg_hash_to_str(MSG_SHADER),
(unsigned)global->shader_dir.ptr, shader);
rarch_main_msg_queue_push(msg, 1, 120, true);
RARCH_LOG("%s \"%s\".\n",
msg_hash_to_str(MSG_APPLYING_SHADER),
shader);
if (!video_driver_set_shader(type, shader))
RARCH_WARN(msg_hash_to_str(MSG_FAILED_TO_APPLY_SHADER));
}
bool init_rom_file(enum rarch_game_type type)
{
#ifdef HAVE_ZLIB
if (*g_extern.fullpath && !g_extern.system.block_extract)
{
const char *ext = path_get_extension(g_extern.fullpath);
if (ext && !strcasecmp(ext, "zip"))
{
g_extern.rom_file_temporary = true;
if (!zlib_extract_first_rom(g_extern.fullpath, sizeof(g_extern.fullpath), g_extern.system.valid_extensions))
{
RARCH_ERR("Failed to extract ROM from zipped file: %s.\n", g_extern.fullpath);
g_extern.rom_file_temporary = false;
return false;
}
strlcpy(g_extern.last_rom, g_extern.fullpath, sizeof(g_extern.last_rom));
}
}
#endif
switch (type)
{
case RARCH_CART_SGB:
if (!load_sgb_rom())
return false;
break;
case RARCH_CART_NORMAL:
if (!load_normal_rom())
return false;
break;
case RARCH_CART_BSX:
if (!load_bsx_rom(false))
return false;
break;
case RARCH_CART_BSX_SLOTTED:
if (!load_bsx_rom(true))
return false;
break;
case RARCH_CART_SUFAMI:
if (!load_sufami_rom())
return false;
break;
default:
RARCH_ERR("Invalid ROM type.\n");
return false;
}
return true;
}
bool core_info_database_supports_content_path(const char *database_path, const char *path)
{
size_t i;
char *database = NULL;
const char *delim = NULL;
const char *archive_path = NULL;
if (!core_info_curr_list)
return false;
database = strdup(path_basename(database_path));
path_remove_extension(database);
delim = path_get_archive_delim(path);
if (delim)
archive_path = delim - 1;
/* if the path contains a compressed file and the core supports archives,
* we don't want to look at this file */
if (archive_path)
{
for (i = 0; i < core_info_curr_list->count; i++)
{
const core_info_t *info = &core_info_curr_list->list[i];
if (!string_list_find_elem(info->databases_list, database))
continue;
if ( !string_list_find_elem(info->supported_extensions_list, "zip")
&& !string_list_find_elem(info->supported_extensions_list, "7z"))
continue;
free(database);
return false;
}
}
for (i = 0; i < core_info_curr_list->count; i++)
{
const core_info_t *info = &core_info_curr_list->list[i];
if (!string_list_find_elem(info->supported_extensions_list, path_get_extension(path)))
continue;
if (!string_list_find_elem(info->databases_list, database))
continue;
free(database);
return true;
}
free(database);
return false;
}
/**
* video_shader_parse_type:
* @path : Shader path.
* @fallback : Fallback shader type in case no
* type could be found.
*
* Parses type of shader.
*
* Returns: value of shader type on success, otherwise will return
* user-supplied @fallback value.
**/
enum rarch_shader_type video_shader_parse_type(const char *path,
enum rarch_shader_type fallback)
{
bool is_preset = false;
if (!path)
return fallback;
return video_shader_get_type_from_ext(path_get_extension(path),
&is_preset);
}
void visit(const char* name)
{
const char* subname = path_make_relative(name, m_directory);
if(subname != name)
{
if(subname[0] == '/')
++subname;
if(m_extension[0] == '*' || extension_equal(path_get_extension(subname), m_extension))
pathlist_prepend_unique(m_matches, g_strdup (subname));
}
}
static int zip_extract_cb(const char *name, const char *valid_exts,
const uint8_t *cdata,
unsigned cmode, uint32_t csize, uint32_t size,
uint32_t checksum, void *userdata)
{
struct zip_extract_userdata *data = (struct zip_extract_userdata*)userdata;
/* Extract first content that matches our list. */
const char *ext = path_get_extension(name);
if (ext && string_list_find_elem(data->ext, ext))
{
char new_path[PATH_MAX_LENGTH] = {0};
if (data->extraction_directory)
fill_pathname_join(new_path, data->extraction_directory,
path_basename(name), sizeof(new_path));
else
fill_pathname_resolve_relative(new_path, data->zip_path,
path_basename(name), sizeof(new_path));
switch (cmode)
{
case ZLIB_MODE_UNCOMPRESSED:
data->found_content = zlib_write_file(new_path, cdata, size);
return false;
case ZLIB_MODE_DEFLATE:
{
int ret = 0;
zlib_file_handle_t handle = {0};
if (!zlib_inflate_data_to_file_init(&handle, cdata, csize, size))
return 0;
do{
ret = zlib_inflate_data_to_file_iterate(handle.stream);
}while(ret == 0);
if (zlib_inflate_data_to_file(&handle, ret, new_path, valid_exts,
cdata, csize, size, checksum))
{
strlcpy(data->zip_path, new_path, data->zip_path_size);
data->found_content = true;
return 0;
}
return 0;
}
default:
return 0;
}
}
return 1;
}
bool core_info_does_support_any_file(const core_info_t *core, const struct string_list *list)
{
size_t i;
if (!list || !core || !core->supported_extensions_list)
return false;
for (i = 0; i < list->size; i++)
if (string_list_find_elem_prefix(core->supported_extensions_list, ".", path_get_extension(list->elems[i].data)))
return true;
return false;
}
/**
* path_is_compressed_file:
* @path : path
*
* Checks if path is a compressed file.
*
* Returns: true (1) if path is a compressed file, otherwise false (0).
**/
bool path_is_compressed_file(const char* path)
{
const char *ext = path_get_extension(path);
if ( strcasestr(ext, "zip")
|| strcasestr(ext, "apk")
|| strcasestr(ext, "7z"))
return true;
return false;
}
static int file_archive_get_file_list_cb(
const char *path,
const char *valid_exts,
const uint8_t *cdata,
unsigned cmode,
uint32_t csize,
uint32_t size,
uint32_t checksum,
void *userdata)
{
union string_list_elem_attr attr;
struct string_list *ext_list = NULL;
const char *file_ext = NULL;
struct string_list *list = (struct string_list*)userdata;
(void)cdata;
(void)cmode;
(void)csize;
(void)size;
(void)checksum;
(void)valid_exts;
(void)file_ext;
(void)ext_list;
memset(&attr, 0, sizeof(attr));
if (valid_exts)
ext_list = string_split(valid_exts, "|");
if (ext_list)
{
/* Checks if this entry is a directory or a file. */
char last_char = path[strlen(path)-1];
/* Skip if directory. */
if (last_char == '/' || last_char == '\\' )
goto error;
file_ext = path_get_extension(path);
if (!file_ext ||
!string_list_find_elem_prefix(ext_list, ".", file_ext))
goto error;
attr.i = RARCH_COMPRESSED_FILE_IN_ARCHIVE;
string_list_free(ext_list);
}
return string_list_append(list, path, attr);
error:
string_list_free(ext_list);
return 0;
}
/**
* dir_list_new:
* @dir : directory path.
* @ext : allowed extensions of file directory entries to include.
* @include_dirs : include directories as part of the finished directory listing?
* @include_compressed : Only include files which match ext. Do not try to match compressed files, etc.
*
* Create a directory listing.
*
* Returns: pointer to a directory listing of type 'struct string_list *' on success,
* NULL in case of error. Has to be freed manually.
**/
struct string_list *dir_list_new(const char *dir,
const char *ext, bool include_dirs, bool include_compressed)
{
struct RDIR *entry = NULL;
struct string_list *ext_list = NULL;
struct string_list *list = NULL;
if (!(list = string_list_new()))
return NULL;
if (ext)
ext_list = string_split(ext, "|");
entry = retro_opendir(dir);
if (!entry)
goto error;
if (retro_dirent_error(entry))
goto error;
while (retro_readdir(entry))
{
char file_path[PATH_MAX_LENGTH];
bool is_dir;
int ret = 0;
const char *name = retro_dirent_get_name(entry);
const char *file_ext = path_get_extension(name);
fill_pathname_join(file_path, dir, name, sizeof(file_path));
is_dir = retro_dirent_is_dir(entry, file_path);
ret = parse_dir_entry(name, file_path, is_dir,
include_dirs, include_compressed, list, ext_list, file_ext);
if (ret == -1)
goto error;
if (ret == 1)
continue;
}
retro_closedir(entry);
string_list_free(ext_list);
return list;
error:
retro_closedir(entry);
string_list_free(list);
string_list_free(ext_list);
return NULL;
}
static int database_info_iterate_playlist(
database_state_handle_t *db_state,
database_info_handle_t *db, const char *name)
{
uint32_t extension_hash = 0;
char parent_dir[PATH_MAX_LENGTH] = {0};
path_parent_dir(parent_dir);
extension_hash = msg_hash_calculate(path_get_extension(name));
switch (extension_hash)
{
case HASH_EXTENSION_ZIP:
#ifdef HAVE_ZLIB
db->type = DATABASE_TYPE_ITERATE_ZIP;
memset(&db->state, 0, sizeof(zlib_transfer_t));
db_state->zip_name[0] = '\0';
db->state.type = ZLIB_TRANSFER_INIT;
return 1;
#endif
case HASH_EXTENSION_CUE:
case HASH_EXTENSION_CUE_UPPERCASE:
db_state->serial[0] = '\0';
cue_get_serial(db_state, db, name, db_state->serial);
db->type = DATABASE_TYPE_SERIAL_LOOKUP;
return 1;
case HASH_EXTENSION_ISO:
case HASH_EXTENSION_ISO_UPPERCASE:
db_state->serial[0] = '\0';
iso_get_serial(db_state, db, name, db_state->serial);
db->type = DATABASE_TYPE_SERIAL_LOOKUP;
return 1;
default:
{
ssize_t ret;
int read_from = read_file(name, (void**)&db_state->buf, &ret);
if (read_from != 1 || ret <= 0)
return 0;
#ifdef HAVE_ZLIB
db_state->crc = zlib_crc32_calculate(db_state->buf, ret);
#endif
db->type = DATABASE_TYPE_CRC_LOOKUP;
}
break;
}
return 1;
}
MapFormatPtr Map::getFormatForFile(const std::string& filename)
{
// Look up the module name which loads the given extension
std::string gameType = GlobalGameManager().currentGame()->getKeyValue("type");
MapFormatPtr mapFormat = GlobalMapFormatManager().getMapFormatForGameType(
gameType, path_get_extension(filename.c_str()));
ASSERT_MESSAGE(mapFormat != NULL, "map format not found for file " + filename);
return mapFormat;
}