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;
}
/**
* runloop_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 runloop_check_shader_dir(rarch_dir_list_t *dir_list,
bool pressed_next, bool pressed_prev)
{
char msg[128] = {0};
const char *shader = 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;
switch (msg_hash_to_file_type(msg_hash_calculate(path_get_extension(shader))))
{
case FILE_TYPE_SHADER_GLSL:
case FILE_TYPE_SHADER_PRESET_GLSLP:
type = RARCH_SHADER_GLSL;
break;
case FILE_TYPE_SHADER_SLANG:
case FILE_TYPE_SHADER_PRESET_SLANGP:
type = RARCH_SHADER_SLANG;
break;
case FILE_TYPE_SHADER_CG:
case FILE_TYPE_SHADER_PRESET_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 int task_database_iterate_playlist(
database_state_handle_t *db_state,
database_info_handle_t *db, const char *name)
{
switch (msg_hash_to_file_type(msg_hash_calculate(path_get_extension(name))))
{
case FILE_TYPE_COMPRESSED:
#ifdef HAVE_COMPRESSION
database_info_set_type(db, DATABASE_TYPE_CRC_LOOKUP);
/* first check crc of archive itself */
return file_get_crc(db_state, name, &db_state->archive_crc);
#else
break;
#endif
case FILE_TYPE_CUE:
db_state->serial[0] = '\0';
if (cue_get_serial(db_state, db, name, db_state->serial))
{
database_info_set_type(db, DATABASE_TYPE_SERIAL_LOOKUP);
}
else
{
database_info_set_type(db, DATABASE_TYPE_CRC_LOOKUP);
return file_get_crc(db_state, name, &db_state->crc);
}
break;
case FILE_TYPE_ISO:
db_state->serial[0] = '\0';
iso_get_serial(db_state, db, name, db_state->serial);
database_info_set_type(db, DATABASE_TYPE_SERIAL_LOOKUP);
break;
case FILE_TYPE_CHD:
db_state->serial[0] = '\0';
if (chd_get_serial(db_state, db, name, db_state->serial))
{
database_info_set_type(db, DATABASE_TYPE_SERIAL_LOOKUP);
}
else
{
database_info_set_type(db, DATABASE_TYPE_CRC_LOOKUP);
return chd_get_crc(db_state, name, &db_state->crc);
}
break;
case FILE_TYPE_LUTRO:
database_info_set_type(db, DATABASE_TYPE_ITERATE_LUTRO);
break;
default:
database_info_set_type(db, DATABASE_TYPE_CRC_LOOKUP);
return file_get_crc(db_state, name, &db_state->crc);
}
return 1;
}
static int task_database_iterate_playlist(
database_state_handle_t *db_state,
database_info_handle_t *db, const char *name)
{
char parent_dir[PATH_MAX_LENGTH] = {0};
path_parent_dir(parent_dir);
switch (msg_hash_to_file_type(msg_hash_calculate(path_get_extension(name))))
{
case FILE_TYPE_COMPRESSED:
#ifdef HAVE_ZLIB
db->type = DATABASE_TYPE_ITERATE_ZIP;
memset(&db->state, 0, sizeof(file_archive_transfer_t));
db_state->zip_name[0] = '\0';
db->state.type = ZLIB_TRANSFER_INIT;
return file_get_crc(db_state, name, &db_state->zip_crc);
#else
break;
#endif
case FILE_TYPE_CUE:
db_state->serial[0] = '\0';
cue_get_serial(db_state, db, name, db_state->serial);
db->type = DATABASE_TYPE_SERIAL_LOOKUP;
break;
case FILE_TYPE_ISO:
db_state->serial[0] = '\0';
iso_get_serial(db_state, db, name, db_state->serial);
db->type = DATABASE_TYPE_SERIAL_LOOKUP;
break;
case FILE_TYPE_LUTRO:
db->type = DATABASE_TYPE_ITERATE_LUTRO;
break;
default:
db->type = DATABASE_TYPE_CRC_LOOKUP;
return file_get_crc(db_state, name, &db_state->crc);
}
return 1;
}
/**
* 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)
{
if (!path)
return fallback;
switch (msg_hash_to_file_type(msg_hash_calculate(path_get_extension(path))))
{
case FILE_TYPE_SHADER_CG:
case FILE_TYPE_SHADER_PRESET_CGP:
return RARCH_SHADER_CG;
case FILE_TYPE_SHADER_GLSL:
case FILE_TYPE_SHADER_PRESET_GLSLP:
return RARCH_SHADER_GLSL;
case FILE_TYPE_SHADER_SLANG:
case FILE_TYPE_SHADER_PRESET_SLANGP:
return RARCH_SHADER_SLANG;
default:
break;
}
return fallback;
}
/**
* menu_shader_manager_init:
*
* Initializes shader manager.
**/
void menu_shader_manager_init(void)
{
#ifdef HAVE_SHADER_MANAGER
struct video_shader *shader = NULL;
config_file_t *conf = NULL;
settings_t *settings = config_get_ptr();
const char *config_path = path_get(RARCH_PATH_CONFIG);
menu_driver_ctl(RARCH_MENU_CTL_SHADER_GET,
&shader);
/* In a multi-config setting, we can't have
* conflicts on menu.cgp/menu.glslp. */
if (config_path)
{
fill_pathname_base_ext(default_glslp, config_path,
file_path_str(FILE_PATH_GLSLP_EXTENSION),
sizeof(default_glslp));
fill_pathname_base_ext(default_cgp, config_path,
file_path_str(FILE_PATH_CGP_EXTENSION),
sizeof(default_cgp));
fill_pathname_base_ext(default_slangp, config_path,
file_path_str(FILE_PATH_SLANGP_EXTENSION),
sizeof(default_slangp));
}
else
{
strlcpy(default_glslp, "menu.glslp",
sizeof(default_glslp));
strlcpy(default_cgp, "menu.cgp",
sizeof(default_cgp));
strlcpy(default_slangp, "menu.slangp",
sizeof(default_slangp));
}
switch (msg_hash_to_file_type(msg_hash_calculate(
path_get_extension(settings->path.shader))))
{
case FILE_TYPE_SHADER_PRESET_GLSLP:
case FILE_TYPE_SHADER_PRESET_CGP:
case FILE_TYPE_SHADER_PRESET_SLANGP:
conf = config_file_new(settings->path.shader);
if (conf)
{
if (video_shader_read_conf_cgp(conf, shader))
{
video_shader_resolve_relative(shader,
settings->path.shader);
video_shader_resolve_parameters(conf, shader);
}
config_file_free(conf);
}
break;
case FILE_TYPE_SHADER_GLSL:
case FILE_TYPE_SHADER_CG:
case FILE_TYPE_SHADER_SLANG:
strlcpy(shader->pass[0].source.path, settings->path.shader,
sizeof(shader->pass[0].source.path));
shader->passes = 1;
break;
default:
{
char preset_path[PATH_MAX_LENGTH];
const char *shader_dir =
*settings->directory.video_shader ?
settings->directory.video_shader : settings->directory.system;
preset_path[0] = '\0';
fill_pathname_join(preset_path, shader_dir,
"menu.glslp", sizeof(preset_path));
conf = config_file_new(preset_path);
if (!conf)
{
fill_pathname_join(preset_path, shader_dir,
"menu.cgp", sizeof(preset_path));
conf = config_file_new(preset_path);
}
if (!conf)
{
fill_pathname_join(preset_path, shader_dir,
"menu.slangp", sizeof(preset_path));
conf = config_file_new(preset_path);
}
if (conf)
{
if (video_shader_read_conf_cgp(conf, shader))
{
video_shader_resolve_relative(shader, preset_path);
video_shader_resolve_parameters(conf, shader);
}
config_file_free(conf);
}
}
break;
}
#endif
}
bool task_push_decompress(
const char *source_file,
const char *target_dir,
const char *target_file,
const char *subdir,
const char *valid_ext,
retro_task_callback_t cb,
void *user_data)
{
char tmp[PATH_MAX_LENGTH] = {0};
decompress_state_t *s = NULL;
retro_task_t *t = NULL;
if (string_is_empty(target_dir) || string_is_empty(source_file))
{
RARCH_WARN("[decompress] Empty or null source file or"
" target directory arguments.\n");
return false;
}
/* ZIP or APK only */
if (!path_file_exists(source_file) ||
msg_hash_to_file_type(msg_hash_calculate(path_get_extension(source_file)))
!= FILE_TYPE_COMPRESSED)
{
RARCH_WARN("[decompress] File '%s' does not exist or is not a compressed file.\n",
source_file);
return false;
}
if (!valid_ext || !valid_ext[0])
valid_ext = NULL;
if (task_check_decompress(source_file))
{
RARCH_LOG("[decompress] File '%s' already being decompressed.\n",
source_file);
return false;
}
RARCH_LOG("[decompress] File '%s.\n", source_file);
s = (decompress_state_t*)calloc(1, sizeof(*s));
if (!s)
goto error;
s->source_file = strdup(source_file);
s->target_dir = strdup(target_dir);
s->valid_ext = valid_ext ? strdup(valid_ext) : NULL;
s->zlib.type = ZLIB_TRANSFER_INIT;
t = (retro_task_t*)calloc(1, sizeof(*t));
if (!t)
goto error;
t->state = s;
t->handler = task_decompress_handler;
if (!string_is_empty(subdir))
{
s->subdir = strdup(subdir);
t->handler = task_decompress_handler_subdir;
}
else if (!string_is_empty(target_file))
{
s->target_file = strdup(target_file);
t->handler = task_decompress_handler_target_file;
}
t->callback = cb;
t->user_data = user_data;
snprintf(tmp, sizeof(tmp), "%s '%s'",
msg_hash_to_str(MSG_EXTRACTING), path_basename(source_file));
t->title = strdup(tmp);
task_queue_ctl(TASK_QUEUE_CTL_PUSH, t);
return true;
error:
if (s)
free(s);
return false;
}
