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; }