void path_set_basename(const char *path) { char *dst = NULL; path_set(RARCH_PATH_CONTENT, path); path_set(RARCH_PATH_BASENAME, path); #ifdef HAVE_COMPRESSION /* Removing extension is a bit tricky for compressed files. * Basename means: * /file/to/path/game.extension should be: * /file/to/path/game * * Two things to consider here are: /file/to/path/ is expected * to be a directory and "game" is a single file. This is used for * states and srm default paths. * * For compressed files we have: * * /file/to/path/comp.7z#game.extension and * /file/to/path/comp.7z#folder/game.extension * * The choice I take here is: * /file/to/path/game as basename. We might end up in a writable * directory then and the name of srm and states are meaningful. * */ path_basedir_wrapper(path_main_basename); fill_pathname_dir(path_main_basename, path, "", sizeof(path_main_basename)); #endif if ((dst = strrchr(path_main_basename, '.'))) *dst = '\0'; }
static bool command_event_cmd_exec(const char *data, content_information_ctx_t *content_ctx, enum content_mode_load mode, char **error_string) { #if defined(HAVE_DYNAMIC) content_ctx_info_t content_info; content_info.argc = 0; content_info.argv = NULL; content_info.args = NULL; #ifdef HAVE_MENU content_info.environ_get = menu_content_environment_get; #else content_info.environ_get = NULL; #endif #endif if (path_get(RARCH_PATH_CONTENT) != (void*)data) { path_clear(RARCH_PATH_CONTENT); if (!string_is_empty(data)) path_set(RARCH_PATH_CONTENT, data); } #if defined(HAVE_DYNAMIC) if (!task_load_content(&content_info, content_ctx, false, mode, error_string)) return false; #else frontend_driver_set_fork(FRONTEND_FORK_CORE_WITH_ARGS); #endif return true; }
static void frontend_gx_exitspawn(char *s, size_t len) { bool should_load_game = false; #if defined(IS_SALAMANDER) if (!string_is_empty(gx_rom_path)) should_load_game = true; #elif defined(HW_RVL) char salamander_basename[PATH_MAX_LENGTH]; if (gx_fork_mode == FRONTEND_FORK_NONE) return; switch (gx_fork_mode) { case FRONTEND_FORK_CORE_WITH_ARGS: should_load_game = true; break; case FRONTEND_FORK_CORE: /* fall-through */ case FRONTEND_FORK_RESTART: { char new_path[PATH_MAX_LENGTH]; char salamander_name[PATH_MAX_LENGTH]; if (frontend_driver_get_salamander_basename(salamander_name, sizeof(salamander_name))) { fill_pathname_join(new_path, g_defaults.dirs[DEFAULT_DIR_CORE], salamander_name, sizeof(new_path)); path_set(RARCH_PATH_CONTENT, new_path); } } break; case FRONTEND_FORK_NONE: default: break; } frontend_gx_exec(s, should_load_game); frontend_driver_get_salamander_basename(salamander_basename, sizeof(salamander_basename)); /* FIXME/TODO - hack * direct loading failed (out of memory), * try to jump to Salamander, * then load the correct core */ fill_pathname_join(s, g_defaults.dirs[DEFAULT_DIR_CORE], salamander_basename, len); #endif frontend_gx_exec(s, should_load_game); }
void FD::set_path (const char *path, int flags) { size_t charc = 0; reset (); if (_num > NO_FD && (close (_num)) == -1) { throw strerror (errno); } if (path && (charc = strlen (path)) > 0) path_set (path, charc); _flags = flags; _num = NO_FD; (void) fd_open (); }
LRESULT win32_menu_loop(HWND owner, WPARAM wparam) { WPARAM mode = wparam & 0xffff; enum event_command cmd = CMD_EVENT_NONE; bool do_wm_close = false; settings_t *settings = config_get_ptr(); switch (mode) { case ID_M_LOAD_CORE: case ID_M_LOAD_CONTENT: { char win32_file[PATH_MAX_LENGTH] = {0}; const char *extensions = NULL; const char *title = NULL; const char *initial_dir = NULL; switch (mode) { case ID_M_LOAD_CORE: extensions = "Libretro core (.dll)\0*.dll\0All Files\0*.*\0"; title = msg_hash_to_str(MENU_ENUM_LABEL_VALUE_CORE_LIST); initial_dir = settings->directory.libretro; break; case ID_M_LOAD_CONTENT: extensions = "All Files\0*.*\0"; title = msg_hash_to_str( MENU_ENUM_LABEL_VALUE_LOAD_CONTENT_LIST); initial_dir = settings->directory.menu_content; break; } if (!win32_browser(owner, win32_file, extensions, title, initial_dir)) break; switch (mode) { case ID_M_LOAD_CORE: runloop_ctl(RUNLOOP_CTL_SET_LIBRETRO_PATH, win32_file); cmd = CMD_EVENT_LOAD_CORE; break; case ID_M_LOAD_CONTENT: { content_ctx_info_t content_info = {0}; path_set(RARCH_PATH_CONTENT, win32_file); do_wm_close = true; task_push_content_load_default( NULL, NULL, &content_info, CORE_TYPE_PLAIN, CONTENT_MODE_LOAD_CONTENT_WITH_CURRENT_CORE_FROM_COMPANION_UI, NULL, NULL); } break; } } break; case ID_M_RESET: cmd = CMD_EVENT_RESET; break; case ID_M_MUTE_TOGGLE: cmd = CMD_EVENT_AUDIO_MUTE_TOGGLE; break; case ID_M_MENU_TOGGLE: cmd = CMD_EVENT_MENU_TOGGLE; break; case ID_M_PAUSE_TOGGLE: cmd = CMD_EVENT_PAUSE_TOGGLE; break; case ID_M_LOAD_STATE: cmd = CMD_EVENT_LOAD_STATE; break; case ID_M_SAVE_STATE: cmd = CMD_EVENT_SAVE_STATE; break; case ID_M_DISK_CYCLE: cmd = CMD_EVENT_DISK_EJECT_TOGGLE; break; case ID_M_DISK_NEXT: cmd = CMD_EVENT_DISK_NEXT; break; case ID_M_DISK_PREV: cmd = CMD_EVENT_DISK_PREV; break; case ID_M_FULL_SCREEN: cmd = CMD_EVENT_FULLSCREEN_TOGGLE; break; #ifndef _XBOX case ID_M_SHADER_PARAMETERS: shader_dlg_show(owner); break; #endif case ID_M_MOUSE_GRAB: cmd = CMD_EVENT_GRAB_MOUSE_TOGGLE; break; case ID_M_TAKE_SCREENSHOT: cmd = CMD_EVENT_TAKE_SCREENSHOT; break; case ID_M_QUIT: do_wm_close = true; break; default: if (mode >= ID_M_WINDOW_SCALE_1X && mode <= ID_M_WINDOW_SCALE_10X) { unsigned idx = (mode - (ID_M_WINDOW_SCALE_1X-1)); runloop_ctl(RUNLOOP_CTL_SET_WINDOWED_SCALE, &idx); cmd = CMD_EVENT_RESIZE_WINDOWED_SCALE; } else if (mode == ID_M_STATE_INDEX_AUTO) { signed idx = -1; settings->state_slot = idx; } else if (mode >= (ID_M_STATE_INDEX_AUTO+1) && mode <= (ID_M_STATE_INDEX_AUTO+10)) { signed idx = (mode - (ID_M_STATE_INDEX_AUTO+1)); settings->state_slot = idx; } break; } if (cmd != CMD_EVENT_NONE) command_event(cmd, NULL); if (do_wm_close) PostMessage(owner, WM_CLOSE, 0, 0); return 0L; }
bool task_push_content_load_default( const char *core_path, const char *fullpath, content_ctx_info_t *content_info, enum rarch_core_type type, enum content_mode_load mode, retro_task_callback_t cb, void *user_data) { content_information_ctx_t content_ctx; bool loading_from_menu = false; char *error_string = NULL; settings_t *settings = config_get_ptr(); if (!content_info) return false; content_ctx.history_list_enable = false; content_ctx.directory_system = NULL; content_ctx.directory_cache = NULL; content_ctx.valid_extensions = NULL; content_ctx.block_extract = false; content_ctx.need_fullpath = false; content_ctx.set_supports_no_game_enable = false; content_ctx.subsystem.data = NULL; content_ctx.subsystem.size = 0; if (settings) { content_ctx.history_list_enable = settings->history_list_enable; if (!string_is_empty(settings->directory.system)) content_ctx.directory_system = strdup(settings->directory.system); } /* First we determine if we are loading from a menu */ switch (mode) { case CONTENT_MODE_LOAD_NOTHING_WITH_NEW_CORE_FROM_MENU: #if defined(HAVE_VIDEO_PROCESSOR) case CONTENT_MODE_LOAD_NOTHING_WITH_VIDEO_PROCESSOR_CORE_FROM_MENU: #endif #if defined(HAVE_NETWORKING) && defined(HAVE_NETWORKGAMEPAD) case CONTENT_MODE_LOAD_NOTHING_WITH_NET_RETROPAD_CORE_FROM_MENU: #endif case CONTENT_MODE_LOAD_NOTHING_WITH_CURRENT_CORE_FROM_MENU: case CONTENT_MODE_LOAD_CONTENT_WITH_CURRENT_CORE_FROM_MENU: case CONTENT_MODE_LOAD_CONTENT_WITH_CURRENT_CORE_FROM_COMPANION_UI: case CONTENT_MODE_LOAD_CONTENT_WITH_NEW_CORE_FROM_COMPANION_UI: #ifdef HAVE_DYNAMIC case CONTENT_MODE_LOAD_CONTENT_WITH_NEW_CORE_FROM_MENU: #endif case CONTENT_MODE_LOAD_CONTENT_WITH_FFMPEG_CORE_FROM_MENU: case CONTENT_MODE_LOAD_CONTENT_WITH_IMAGEVIEWER_CORE_FROM_MENU: loading_from_menu = true; break; default: break; } switch (mode) { case CONTENT_MODE_LOAD_NOTHING_WITH_CURRENT_CORE_FROM_MENU: case CONTENT_MODE_LOAD_NOTHING_WITH_VIDEO_PROCESSOR_CORE_FROM_MENU: case CONTENT_MODE_LOAD_NOTHING_WITH_NET_RETROPAD_CORE_FROM_MENU: case CONTENT_MODE_LOAD_CONTENT_FROM_PLAYLIST_FROM_MENU: case CONTENT_MODE_LOAD_CONTENT_WITH_NEW_CORE_FROM_MENU: case CONTENT_MODE_LOAD_CONTENT_WITH_FFMPEG_CORE_FROM_MENU: case CONTENT_MODE_LOAD_CONTENT_WITH_CURRENT_CORE_FROM_MENU: case CONTENT_MODE_LOAD_CONTENT_WITH_IMAGEVIEWER_CORE_FROM_MENU: case CONTENT_MODE_LOAD_CONTENT_WITH_CURRENT_CORE_FROM_COMPANION_UI: case CONTENT_MODE_LOAD_CONTENT_WITH_NEW_CORE_FROM_COMPANION_UI: case CONTENT_MODE_LOAD_NOTHING_WITH_DUMMY_CORE: #ifdef HAVE_MENU if (!content_info->environ_get) content_info->environ_get = menu_content_environment_get; #endif break; default: break; } /* Clear content path */ switch (mode) { case CONTENT_MODE_LOAD_NOTHING_WITH_DUMMY_CORE: case CONTENT_MODE_LOAD_NOTHING_WITH_CURRENT_CORE_FROM_MENU: case CONTENT_MODE_LOAD_NOTHING_WITH_VIDEO_PROCESSOR_CORE_FROM_MENU: case CONTENT_MODE_LOAD_NOTHING_WITH_NET_RETROPAD_CORE_FROM_MENU: path_clear(RARCH_PATH_CONTENT); break; default: break; } /* Set content path */ switch (mode) { case CONTENT_MODE_LOAD_CONTENT_WITH_CURRENT_CORE_FROM_MENU: case CONTENT_MODE_LOAD_CONTENT_WITH_CURRENT_CORE_FROM_COMPANION_UI: case CONTENT_MODE_LOAD_CONTENT_WITH_NEW_CORE_FROM_COMPANION_UI: case CONTENT_MODE_LOAD_CONTENT_WITH_FFMPEG_CORE_FROM_MENU: case CONTENT_MODE_LOAD_CONTENT_WITH_IMAGEVIEWER_CORE_FROM_MENU: case CONTENT_MODE_LOAD_CONTENT_WITH_NEW_CORE_FROM_MENU: path_set(RARCH_PATH_CONTENT, fullpath); break; default: break; } /* Set libretro core path */ switch (mode) { case CONTENT_MODE_LOAD_NOTHING_WITH_NEW_CORE_FROM_MENU: case CONTENT_MODE_LOAD_CONTENT_WITH_NEW_CORE_FROM_MENU: case CONTENT_MODE_LOAD_CONTENT_WITH_NEW_CORE_FROM_COMPANION_UI: case CONTENT_MODE_LOAD_CONTENT_FROM_PLAYLIST_FROM_MENU: runloop_ctl(RUNLOOP_CTL_SET_LIBRETRO_PATH, (void*)core_path); break; default: break; } /* Is content required by this core? */ switch (mode) { case CONTENT_MODE_LOAD_CONTENT_FROM_PLAYLIST_FROM_MENU: #ifdef HAVE_MENU if (fullpath) menu_driver_ctl(RARCH_MENU_CTL_UNSET_LOAD_NO_CONTENT, NULL); else menu_driver_ctl(RARCH_MENU_CTL_SET_LOAD_NO_CONTENT, NULL); #endif break; default: break; } /* On targets that have no dynamic core loading support, we'd * execute the new core from this point. If this returns false, * we assume we can dynamically load the core. */ switch (mode) { case CONTENT_MODE_LOAD_CONTENT_FROM_PLAYLIST_FROM_MENU: if (!command_event_cmd_exec(fullpath, &content_ctx, mode, &error_string)) goto error; #ifndef HAVE_DYNAMIC runloop_ctl(RUNLOOP_CTL_SET_SHUTDOWN, NULL); #ifdef HAVE_MENU rarch_ctl(RARCH_CTL_MENU_RUNNING_FINISHED, NULL); #endif #endif break; default: break; } /* Load core */ switch (mode) { case CONTENT_MODE_LOAD_NOTHING_WITH_NEW_CORE_FROM_MENU: #ifdef HAVE_DYNAMIC case CONTENT_MODE_LOAD_CONTENT_WITH_NEW_CORE_FROM_MENU: case CONTENT_MODE_LOAD_CONTENT_WITH_NEW_CORE_FROM_COMPANION_UI: case CONTENT_MODE_LOAD_CONTENT_FROM_PLAYLIST_FROM_MENU: #endif command_event(CMD_EVENT_LOAD_CORE, NULL); break; default: break; } #ifndef HAVE_DYNAMIC /* Fork core? */ switch (mode) { case CONTENT_MODE_LOAD_NOTHING_WITH_NEW_CORE_FROM_MENU: if (!frontend_driver_set_fork(FRONTEND_FORK_CORE)) goto cleanup; break; default: break; } #endif /* Preliminary stuff that has to be done before we * load the actual content. Can differ per mode. */ switch (mode) { case CONTENT_MODE_LOAD_NOTHING_WITH_DUMMY_CORE: runloop_ctl(RUNLOOP_CTL_STATE_FREE, NULL); #ifdef HAVE_MENU menu_driver_ctl(RARCH_MENU_CTL_UNSET_LOAD_NO_CONTENT, NULL); #endif runloop_ctl(RUNLOOP_CTL_DATA_DEINIT, NULL); runloop_ctl(RUNLOOP_CTL_TASK_INIT, NULL); break; case CONTENT_MODE_LOAD_NOTHING_WITH_CURRENT_CORE_FROM_MENU: case CONTENT_MODE_LOAD_NOTHING_WITH_NEW_CORE_FROM_MENU: retroarch_set_current_core_type(type, true); break; case CONTENT_MODE_LOAD_NOTHING_WITH_NET_RETROPAD_CORE_FROM_MENU: #if defined(HAVE_NETWORKING) && defined(HAVE_NETWORKGAMEPAD) retroarch_set_current_core_type(CORE_TYPE_NETRETROPAD, true); break; #endif case CONTENT_MODE_LOAD_NOTHING_WITH_VIDEO_PROCESSOR_CORE_FROM_MENU: #ifdef HAVE_VIDEO_PROCESSOR retroarch_set_current_core_type(CORE_TYPE_VIDEO_PROCESSOR, true); break; #endif default: break; } /* Load content */ switch (mode) { case CONTENT_MODE_LOAD_NOTHING_WITH_DUMMY_CORE: if (!task_load_content(content_info, &content_ctx, loading_from_menu, mode, &error_string)) goto error; break; case CONTENT_MODE_LOAD_FROM_CLI: #if defined(HAVE_NETWORKING) && defined(HAVE_NETWORKGAMEPAD) case CONTENT_MODE_LOAD_NOTHING_WITH_NET_RETROPAD_CORE_FROM_MENU: #endif #ifdef HAVE_VIDEO_PROCESSOR case CONTENT_MODE_LOAD_NOTHING_WITH_VIDEO_PROCESSOR_CORE_FROM_MENU: #endif case CONTENT_MODE_LOAD_NOTHING_WITH_CURRENT_CORE_FROM_MENU: case CONTENT_MODE_LOAD_CONTENT_WITH_CURRENT_CORE_FROM_MENU: case CONTENT_MODE_LOAD_CONTENT_WITH_CURRENT_CORE_FROM_COMPANION_UI: case CONTENT_MODE_LOAD_CONTENT_WITH_NEW_CORE_FROM_COMPANION_UI: #ifdef HAVE_DYNAMIC case CONTENT_MODE_LOAD_CONTENT_WITH_NEW_CORE_FROM_MENU: #endif case CONTENT_MODE_LOAD_CONTENT_WITH_FFMPEG_CORE_FROM_MENU: case CONTENT_MODE_LOAD_CONTENT_WITH_IMAGEVIEWER_CORE_FROM_MENU: task_push_content_update_firmware_status(&content_ctx); if(runloop_ctl(RUNLOOP_CTL_IS_MISSING_BIOS, NULL) && settings->check_firmware_before_loading) goto skip; if (!task_load_content(content_info, &content_ctx, loading_from_menu, mode, &error_string)) goto error; break; #ifndef HAVE_DYNAMIC case CONTENT_MODE_LOAD_CONTENT_WITH_NEW_CORE_FROM_MENU: command_event_cmd_exec(path_get(RARCH_PATH_CONTENT), &content_ctx, mode, &error_string); command_event(CMD_EVENT_QUIT, NULL); break; #endif case CONTENT_MODE_LOAD_NONE: default: break; } /* Push quick menu onto menu stack */ switch (mode) { case CONTENT_MODE_LOAD_CONTENT_FROM_PLAYLIST_FROM_MENU: case CONTENT_MODE_LOAD_NOTHING_WITH_NEW_CORE_FROM_MENU: break; default: #ifdef HAVE_MENU if (type != CORE_TYPE_DUMMY && mode != CONTENT_MODE_LOAD_FROM_CLI) menu_driver_ctl(RARCH_MENU_CTL_SET_PENDING_QUICK_MENU, NULL); #endif break; } if (content_ctx.directory_system) free(content_ctx.directory_system); return true; error: if (error_string) { runloop_msg_queue_push(error_string, 2, 90, true); free(error_string); } #ifdef HAVE_MENU switch (mode) { case CONTENT_MODE_LOAD_CONTENT_FROM_PLAYLIST_FROM_MENU: case CONTENT_MODE_LOAD_NOTHING_WITH_CURRENT_CORE_FROM_MENU: case CONTENT_MODE_LOAD_NOTHING_WITH_NET_RETROPAD_CORE_FROM_MENU: case CONTENT_MODE_LOAD_NOTHING_WITH_VIDEO_PROCESSOR_CORE_FROM_MENU: case CONTENT_MODE_LOAD_CONTENT_WITH_CURRENT_CORE_FROM_MENU: case CONTENT_MODE_LOAD_CONTENT_WITH_FFMPEG_CORE_FROM_MENU: case CONTENT_MODE_LOAD_CONTENT_WITH_IMAGEVIEWER_CORE_FROM_MENU: case CONTENT_MODE_LOAD_CONTENT_WITH_NEW_CORE_FROM_MENU: rarch_ctl(RARCH_CTL_MENU_RUNNING, NULL); break; default: break; } #endif if (content_ctx.directory_system) free(content_ctx.directory_system); return false; skip: runloop_msg_queue_push(msg_hash_to_str(MSG_FIRMWARE), 100, 500, true); RARCH_LOG("Load content blocked. Reason: %s\n", msg_hash_to_str(MSG_FIRMWARE)); return true; #ifndef HAVE_DYNAMIC cleanup: if (content_ctx.directory_system) free(content_ctx.directory_system); return false; #endif }
/* Get the count of the files dropped */ static int win32_drag_query_file(HWND hwnd, WPARAM wparam) { char szFilename[1024]; szFilename[0] = '\0'; if (DragQueryFile((HDROP)wparam, 0xFFFFFFFF, NULL, 0)) { /*poll list of current cores */ size_t list_size; content_ctx_info_t content_info = {0}; core_info_list_t *core_info_list = NULL; const core_info_t *core_info = NULL; DragQueryFile((HDROP)wparam, 0, szFilename, sizeof(szFilename)); core_info_get_list(&core_info_list); if (!core_info_list) return 0; core_info_list_get_supported_cores(core_info_list, (const char*)szFilename, &core_info, &list_size); if (!list_size) return 0; path_set(RARCH_PATH_CONTENT, szFilename); if (!path_is_empty(RARCH_PATH_CONTENT)) { unsigned i; core_info_t *current_core = NULL; core_info_get_current_core(¤t_core); /*we already have path for libretro core */ for (i = 0; i < list_size; i++) { const core_info_t *info = (const core_info_t*)&core_info[i]; if(!string_is_equal(info->systemname, current_core->systemname)) break; if(string_is_equal(path_get(RARCH_PATH_CORE), info->path)) { /* Our previous core supports the current rom */ content_ctx_info_t content_info = {0}; task_push_content_load_default( NULL, NULL, &content_info, CORE_TYPE_PLAIN, CONTENT_MODE_LOAD_CONTENT_WITH_CURRENT_CORE_FROM_COMPANION_UI, NULL, NULL); return 0; } } } /* Poll for cores for current rom since none exist. */ if(list_size ==1) { /*pick core that only exists and is bound to work. Ish. */ const core_info_t *info = (const core_info_t*)&core_info[0]; if (info) task_push_content_load_default( info->path, NULL, &content_info, CORE_TYPE_PLAIN, CONTENT_MODE_LOAD_CONTENT_WITH_NEW_CORE_FROM_COMPANION_UI, NULL, NULL); } else { /* Pick one core that could be compatible, ew */ if(DialogBoxParam(GetModuleHandle(NULL),MAKEINTRESOURCE(IDD_PICKCORE), hwnd,PickCoreProc,(LPARAM)NULL)==IDOK) { task_push_content_load_default( NULL, NULL, &content_info, CORE_TYPE_PLAIN, CONTENT_MODE_LOAD_CONTENT_WITH_CURRENT_CORE_FROM_COMPANION_UI, NULL, NULL); } } } return 0; }
bool runloop_ctl(enum runloop_ctl_state state, void *data) { switch (state) { case RUNLOOP_CTL_SYSTEM_INFO_INIT: core_get_system_info(&runloop_system.info); if (!runloop_system.info.library_name) runloop_system.info.library_name = msg_hash_to_str(MSG_UNKNOWN); if (!runloop_system.info.library_version) runloop_system.info.library_version = "v0"; video_driver_set_title_buf(); strlcpy(runloop_system.valid_extensions, runloop_system.info.valid_extensions ? runloop_system.info.valid_extensions : DEFAULT_EXT, sizeof(runloop_system.valid_extensions)); break; case RUNLOOP_CTL_GET_CORE_OPTION_SIZE: { unsigned *idx = (unsigned*)data; if (!idx) return false; *idx = core_option_manager_size(runloop_core_options); } break; case RUNLOOP_CTL_HAS_CORE_OPTIONS: return runloop_core_options; case RUNLOOP_CTL_CORE_OPTIONS_LIST_GET: { core_option_manager_t **coreopts = (core_option_manager_t**)data; if (!coreopts) return false; *coreopts = runloop_core_options; } break; case RUNLOOP_CTL_SYSTEM_INFO_GET: { rarch_system_info_t **system = (rarch_system_info_t**)data; if (!system) return false; *system = &runloop_system; } break; case RUNLOOP_CTL_SYSTEM_INFO_FREE: /* No longer valid. */ if (runloop_system.subsystem.data) free(runloop_system.subsystem.data); runloop_system.subsystem.data = NULL; runloop_system.subsystem.size = 0; if (runloop_system.ports.data) free(runloop_system.ports.data); runloop_system.ports.data = NULL; runloop_system.ports.size = 0; if (runloop_system.mmaps.descriptors) free((void *)runloop_system.mmaps.descriptors); runloop_system.mmaps.descriptors = NULL; runloop_system.mmaps.num_descriptors = 0; runloop_key_event = NULL; runloop_frontend_key_event = NULL; audio_driver_unset_callback(); memset(&runloop_system, 0, sizeof(rarch_system_info_t)); break; case RUNLOOP_CTL_SET_FRAME_TIME_LAST: runloop_frame_time_last_enable = true; break; case RUNLOOP_CTL_SET_OVERRIDES_ACTIVE: runloop_overrides_active = true; break; case RUNLOOP_CTL_UNSET_OVERRIDES_ACTIVE: runloop_overrides_active = false; break; case RUNLOOP_CTL_IS_OVERRIDES_ACTIVE: return runloop_overrides_active; case RUNLOOP_CTL_SET_GAME_OPTIONS_ACTIVE: runloop_game_options_active = true; break; case RUNLOOP_CTL_UNSET_GAME_OPTIONS_ACTIVE: runloop_game_options_active = false; break; case RUNLOOP_CTL_IS_GAME_OPTIONS_ACTIVE: return runloop_game_options_active; case RUNLOOP_CTL_SET_FRAME_LIMIT: runloop_set_frame_limit = true; break; case RUNLOOP_CTL_GET_PERFCNT: { bool **perfcnt = (bool**)data; if (!perfcnt) return false; *perfcnt = &runloop_perfcnt_enable; } break; case RUNLOOP_CTL_SET_PERFCNT_ENABLE: runloop_perfcnt_enable = true; break; case RUNLOOP_CTL_UNSET_PERFCNT_ENABLE: runloop_perfcnt_enable = false; break; case RUNLOOP_CTL_IS_PERFCNT_ENABLE: return runloop_perfcnt_enable; case RUNLOOP_CTL_SET_NONBLOCK_FORCED: runloop_force_nonblock = true; break; case RUNLOOP_CTL_UNSET_NONBLOCK_FORCED: runloop_force_nonblock = false; break; case RUNLOOP_CTL_IS_NONBLOCK_FORCED: return runloop_force_nonblock; case RUNLOOP_CTL_SET_FRAME_TIME: { const struct retro_frame_time_callback *info = (const struct retro_frame_time_callback*)data; #ifdef HAVE_NETWORKING /* retro_run() will be called in very strange and * mysterious ways, have to disable it. */ if (netplay_driver_ctl(RARCH_NETPLAY_CTL_IS_ENABLED, NULL)) return false; #endif runloop_frame_time = *info; } break; case RUNLOOP_CTL_GET_WINDOWED_SCALE: { unsigned **scale = (unsigned**)data; if (!scale) return false; *scale = (unsigned*)&runloop_pending_windowed_scale; } break; case RUNLOOP_CTL_SET_WINDOWED_SCALE: { unsigned *idx = (unsigned*)data; if (!idx) return false; runloop_pending_windowed_scale = *idx; } break; case RUNLOOP_CTL_SET_LIBRETRO_PATH: return path_set(RARCH_PATH_CORE, (const char*)data); case RUNLOOP_CTL_FRAME_TIME_FREE: memset(&runloop_frame_time, 0, sizeof(struct retro_frame_time_callback)); runloop_frame_time_last = 0; runloop_max_frames = 0; break; case RUNLOOP_CTL_STATE_FREE: runloop_perfcnt_enable = false; runloop_idle = false; runloop_paused = false; runloop_slowmotion = false; runloop_frame_time_last_enable = false; runloop_set_frame_limit = false; runloop_overrides_active = false; runloop_ctl(RUNLOOP_CTL_FRAME_TIME_FREE, NULL); break; case RUNLOOP_CTL_GLOBAL_FREE: { global_t *global = NULL; command_event(CMD_EVENT_TEMPORARY_CONTENT_DEINIT, NULL); path_deinit_subsystem(); command_event(CMD_EVENT_RECORD_DEINIT, NULL); command_event(CMD_EVENT_LOG_FILE_DEINIT, NULL); rarch_ctl(RARCH_CTL_UNSET_BLOCK_CONFIG_READ, NULL); rarch_ctl(RARCH_CTL_UNSET_SRAM_LOAD_DISABLED, NULL); rarch_ctl(RARCH_CTL_UNSET_SRAM_SAVE_DISABLED, NULL); rarch_ctl(RARCH_CTL_UNSET_SRAM_ENABLE, NULL); rarch_ctl(RARCH_CTL_UNSET_BPS_PREF, NULL); rarch_ctl(RARCH_CTL_UNSET_IPS_PREF, NULL); rarch_ctl(RARCH_CTL_UNSET_UPS_PREF, NULL); rarch_ctl(RARCH_CTL_UNSET_PATCH_BLOCKED, NULL); runloop_overrides_active = false; core_unset_input_descriptors(); global = global_get_ptr(); path_clear_all(); dir_clear_all(); memset(global, 0, sizeof(struct global)); retroarch_override_setting_free_state(); } break; case RUNLOOP_CTL_CLEAR_STATE: driver_ctl(RARCH_DRIVER_CTL_DEINIT, NULL); runloop_ctl(RUNLOOP_CTL_STATE_FREE, NULL); runloop_ctl(RUNLOOP_CTL_GLOBAL_FREE, NULL); break; case RUNLOOP_CTL_SET_MAX_FRAMES: { unsigned *ptr = (unsigned*)data; if (!ptr) return false; runloop_max_frames = *ptr; } break; case RUNLOOP_CTL_IS_IDLE: return runloop_idle; case RUNLOOP_CTL_SET_IDLE: { bool *ptr = (bool*)data; if (!ptr) return false; runloop_idle = *ptr; } break; case RUNLOOP_CTL_IS_SLOWMOTION: return runloop_slowmotion; case RUNLOOP_CTL_SET_SLOWMOTION: { bool *ptr = (bool*)data; if (!ptr) return false; runloop_slowmotion = *ptr; } break; case RUNLOOP_CTL_SET_PAUSED: { bool *ptr = (bool*)data; if (!ptr) return false; runloop_paused = *ptr; } break; case RUNLOOP_CTL_IS_PAUSED: return runloop_paused; case RUNLOOP_CTL_MSG_QUEUE_PULL: #ifdef HAVE_THREADS slock_lock(_runloop_msg_queue_lock); #endif { const char **ret = (const char**)data; if (!ret) { #ifdef HAVE_THREADS slock_unlock(_runloop_msg_queue_lock); #endif return false; } *ret = msg_queue_pull(runloop_msg_queue); } #ifdef HAVE_THREADS slock_unlock(_runloop_msg_queue_lock); #endif break; case RUNLOOP_CTL_MSG_QUEUE_DEINIT: if (!runloop_msg_queue) return true; #ifdef HAVE_THREADS slock_lock(_runloop_msg_queue_lock); #endif msg_queue_free(runloop_msg_queue); #ifdef HAVE_THREADS slock_unlock(_runloop_msg_queue_lock); #endif #ifdef HAVE_THREADS slock_free(_runloop_msg_queue_lock); _runloop_msg_queue_lock = NULL; #endif runloop_msg_queue = NULL; break; case RUNLOOP_CTL_MSG_QUEUE_INIT: runloop_ctl(RUNLOOP_CTL_MSG_QUEUE_DEINIT, NULL); runloop_msg_queue = msg_queue_new(8); retro_assert(runloop_msg_queue); #ifdef HAVE_THREADS _runloop_msg_queue_lock = slock_new(); retro_assert(_runloop_msg_queue_lock); #endif break; case RUNLOOP_CTL_TASK_INIT: { #ifdef HAVE_THREADS settings_t *settings = config_get_ptr(); bool threaded_enable = settings->threaded_data_runloop_enable; #else bool threaded_enable = false; #endif task_queue_ctl(TASK_QUEUE_CTL_DEINIT, NULL); task_queue_ctl(TASK_QUEUE_CTL_INIT, &threaded_enable); } break; case RUNLOOP_CTL_SET_CORE_SHUTDOWN: runloop_core_shutdown_initiated = true; break; case RUNLOOP_CTL_SET_SHUTDOWN: runloop_shutdown_initiated = true; break; case RUNLOOP_CTL_IS_SHUTDOWN: return runloop_shutdown_initiated; case RUNLOOP_CTL_SET_EXEC: runloop_exec = true; break; case RUNLOOP_CTL_DATA_DEINIT: task_queue_ctl(TASK_QUEUE_CTL_DEINIT, NULL); break; case RUNLOOP_CTL_IS_CORE_OPTION_UPDATED: if (!runloop_core_options) return false; return core_option_manager_updated(runloop_core_options); case RUNLOOP_CTL_CORE_OPTION_PREV: { unsigned *idx = (unsigned*)data; if (!idx) return false; core_option_manager_prev(runloop_core_options, *idx); if (ui_companion_is_on_foreground()) ui_companion_driver_notify_refresh(); } break; case RUNLOOP_CTL_CORE_OPTION_NEXT: { unsigned *idx = (unsigned*)data; if (!idx) return false; core_option_manager_next(runloop_core_options, *idx); if (ui_companion_is_on_foreground()) ui_companion_driver_notify_refresh(); } break; case RUNLOOP_CTL_CORE_OPTIONS_GET: { struct retro_variable *var = (struct retro_variable*)data; if (!runloop_core_options || !var) return false; RARCH_LOG("Environ GET_VARIABLE %s:\n", var->key); core_option_manager_get(runloop_core_options, var); RARCH_LOG("\t%s\n", var->value ? var->value : msg_hash_to_str(MENU_ENUM_LABEL_VALUE_NOT_AVAILABLE)); } break; case RUNLOOP_CTL_CORE_OPTIONS_INIT: { settings_t *settings = config_get_ptr(); char *game_options_path = NULL; bool ret = false; const struct retro_variable *vars = (const struct retro_variable*)data; if (settings && settings->game_specific_options) ret = rarch_game_specific_options(&game_options_path); if(ret) { runloop_ctl(RUNLOOP_CTL_SET_GAME_OPTIONS_ACTIVE, NULL); runloop_core_options = core_option_manager_new(game_options_path, vars); free(game_options_path); } else { char buf[PATH_MAX_LENGTH]; const char *options_path = NULL; buf[0] = '\0'; if (settings) options_path = settings->path.core_options; if (string_is_empty(options_path) && !path_is_empty(RARCH_PATH_CONFIG)) { fill_pathname_resolve_relative(buf, path_get(RARCH_PATH_CONFIG), file_path_str(FILE_PATH_CORE_OPTIONS_CONFIG), sizeof(buf)); options_path = buf; } runloop_ctl(RUNLOOP_CTL_UNSET_GAME_OPTIONS_ACTIVE, NULL); if (!string_is_empty(options_path)) runloop_core_options = core_option_manager_new(options_path, vars); } } break; case RUNLOOP_CTL_CORE_OPTIONS_FREE: if (runloop_core_options) core_option_manager_free(runloop_core_options); runloop_core_options = NULL; break; case RUNLOOP_CTL_CORE_OPTIONS_DEINIT: { if (!runloop_core_options) return false; /* check if game options file was just created and flush to that file instead */ if(!path_is_empty(RARCH_PATH_CORE_OPTIONS)) { core_option_manager_flush_game_specific(runloop_core_options, path_get(RARCH_PATH_CORE_OPTIONS)); path_clear(RARCH_PATH_CORE_OPTIONS); } else core_option_manager_flush(runloop_core_options); if (runloop_ctl(RUNLOOP_CTL_IS_GAME_OPTIONS_ACTIVE, NULL)) runloop_ctl(RUNLOOP_CTL_UNSET_GAME_OPTIONS_ACTIVE, NULL); runloop_ctl(RUNLOOP_CTL_CORE_OPTIONS_FREE, NULL); } break; case RUNLOOP_CTL_KEY_EVENT_GET: { retro_keyboard_event_t **key_event = (retro_keyboard_event_t**)data; if (!key_event) return false; *key_event = &runloop_key_event; } break; case RUNLOOP_CTL_FRONTEND_KEY_EVENT_GET: { retro_keyboard_event_t **key_event = (retro_keyboard_event_t**)data; if (!key_event) return false; *key_event = &runloop_frontend_key_event; } break; case RUNLOOP_CTL_HTTPSERVER_INIT: #if defined(HAVE_HTTPSERVER) && defined(HAVE_ZLIB) httpserver_init(8888); #endif break; case RUNLOOP_CTL_HTTPSERVER_DESTROY: #if defined(HAVE_HTTPSERVER) && defined(HAVE_ZLIB) httpserver_destroy(); #endif break; case RUNLOOP_CTL_NONE: default: break; } return true; }
LRESULT win32_menu_loop(HWND owner, WPARAM wparam) { WPARAM mode = wparam & 0xffff; enum event_command cmd = CMD_EVENT_NONE; bool do_wm_close = false; settings_t *settings = config_get_ptr(); switch (mode) { case ID_M_LOAD_CORE: case ID_M_LOAD_CONTENT: { char win32_file[PATH_MAX_LENGTH] = {0}; wchar_t title_wide[PATH_MAX]; char title_cp[PATH_MAX]; const char *extensions = NULL; const char *title = NULL; const char *initial_dir = NULL; size_t converted = 0; switch (mode) { /* OPENFILENAME.lpstrFilter requires a null separated list of name/ext pairs terminated by a second null at the end. */ case ID_M_LOAD_CORE: extensions = "Libretro core (.dll)\0*.dll\0All Files\0*.*\0\0"; title = msg_hash_to_str(MENU_ENUM_LABEL_VALUE_CORE_LIST); initial_dir = settings->paths.directory_libretro; break; case ID_M_LOAD_CONTENT: extensions = "All Files (*.*)\0*.*\0\0"; title = msg_hash_to_str( MENU_ENUM_LABEL_VALUE_LOAD_CONTENT_LIST); initial_dir = settings->paths.directory_menu_content; break; } /* Convert UTF8 to UTF16, then back to the local code page. * This is needed for proper multi-byte string display until Unicode is fully supported. */ MultiByteToWideChar(CP_UTF8, 0, title, -1, title_wide, sizeof(title_wide) / sizeof(title_wide[0])); wcstombs(title_cp, title_wide, sizeof(title_cp) - 1); if (!win32_browser(owner, win32_file, sizeof(win32_file), extensions, title_cp, initial_dir)) break; switch (mode) { case ID_M_LOAD_CORE: rarch_ctl(RARCH_CTL_SET_LIBRETRO_PATH, win32_file); cmd = CMD_EVENT_LOAD_CORE; break; case ID_M_LOAD_CONTENT: { content_ctx_info_t content_info = {0}; path_set(RARCH_PATH_CONTENT, win32_file); do_wm_close = true; task_push_load_content_with_current_core_from_companion_ui( NULL, &content_info, CORE_TYPE_PLAIN, NULL, NULL); } break; } } break; case ID_M_RESET: cmd = CMD_EVENT_RESET; break; case ID_M_MUTE_TOGGLE: cmd = CMD_EVENT_AUDIO_MUTE_TOGGLE; break; case ID_M_MENU_TOGGLE: cmd = CMD_EVENT_MENU_TOGGLE; break; case ID_M_PAUSE_TOGGLE: cmd = CMD_EVENT_PAUSE_TOGGLE; break; case ID_M_LOAD_STATE: cmd = CMD_EVENT_LOAD_STATE; break; case ID_M_SAVE_STATE: cmd = CMD_EVENT_SAVE_STATE; break; case ID_M_DISK_CYCLE: cmd = CMD_EVENT_DISK_EJECT_TOGGLE; break; case ID_M_DISK_NEXT: cmd = CMD_EVENT_DISK_NEXT; break; case ID_M_DISK_PREV: cmd = CMD_EVENT_DISK_PREV; break; case ID_M_FULL_SCREEN: cmd = CMD_EVENT_FULLSCREEN_TOGGLE; break; #ifndef _XBOX case ID_M_SHADER_PARAMETERS: shader_dlg_show(owner); break; #endif case ID_M_MOUSE_GRAB: cmd = CMD_EVENT_GRAB_MOUSE_TOGGLE; break; case ID_M_TAKE_SCREENSHOT: cmd = CMD_EVENT_TAKE_SCREENSHOT; break; case ID_M_QUIT: do_wm_close = true; break; default: if (mode >= ID_M_WINDOW_SCALE_1X && mode <= ID_M_WINDOW_SCALE_10X) { unsigned idx = (mode - (ID_M_WINDOW_SCALE_1X-1)); rarch_ctl(RARCH_CTL_SET_WINDOWED_SCALE, &idx); cmd = CMD_EVENT_RESIZE_WINDOWED_SCALE; } else if (mode == ID_M_STATE_INDEX_AUTO) { signed idx = -1; configuration_set_int(settings, settings->ints.state_slot, idx); } else if (mode >= (ID_M_STATE_INDEX_AUTO+1) && mode <= (ID_M_STATE_INDEX_AUTO+10)) { signed idx = (mode - (ID_M_STATE_INDEX_AUTO+1)); configuration_set_int(settings, settings->ints.state_slot, idx); } break; } if (cmd != CMD_EVENT_NONE) command_event(cmd, NULL); if (do_wm_close) PostMessage(owner, WM_CLOSE, 0, 0); return 0L; }
int main(int argc, char ** argv) { //set up logging //g_log_set_default_handler(log_write, NULL); path_set(".", NULL); const char * prefix = path_resolve(argv[1]); if (prefix == NULL) { return EXIT_FAILURE; } string_t file = string_new("%s/%s", prefix, argv[1]); meta_t * meta = meta_parse(file.string); GHashTableIter itr; List * next; block_t * block; LOG(LOG_INFO, "Module: %s", file.string); LOG(LOG_INFO, "=================================="); LOG(LOG_INFO, "Author:\t %s", meta->author); LOG(LOG_INFO, "Version:\t %s", meta->version); LOG(LOG_INFO, "Pre-Activater:\t %s", meta->preactivate); LOG(LOG_INFO, "Post-Activator: %s", meta->postactivate); LOG(LOG_INFO, "Initializer:\t %s", meta->initialize); LOG(LOG_INFO, "Description:\t %s\n", meta->description); if (list_length(meta->dependencies) > 0) { LOG(LOG_INFO, "Dependencies"); LOG(LOG_INFO, "=================================="); next = meta->dependencies; while (next != NULL) { LOG(LOG_INFO, "%s", (gchar *)next->data); next = next->next; } } if (list_length(meta->cfgentries) > 0) { LOG(LOG_INFO, " "); LOG(LOG_INFO, "Configuration Params"); LOG(LOG_INFO, "=================================="); next = meta->cfgentries; while (next != NULL) { cfgentry_t * cfg = next->data; if (cfg->desc == NULL) LOG(LOG_INFO, "(%c) %s", cfg->type, cfg->name); else LOG(LOG_INFO, "(%c) %s - %s", cfg->type, cfg->name, cfg->desc); next = next->next; } } if (list_length(meta->calentries) > 0) { LOG(LOG_INFO, " "); LOG(LOG_INFO, "Calibration Params"); LOG(LOG_INFO, "=================================="); if (meta->calupdate != NULL) LOG(LOG_INFO, "Update: %s", meta->calupdate); next = meta->calentries; while (next != NULL) { calentry_t * cal = next->data; if (cal->desc == NULL) LOG(LOG_INFO, "(%s)\t%s", cal->sig, cal->name); else LOG(LOG_INFO, "(%s)\t%s - %s", cal->sig, cal->name, cal->desc); next = next->next; } } if (list_length(meta->syscalls) > 0) { LOG(LOG_INFO, " "); LOG(LOG_INFO, "Syscalls"); LOG(LOG_INFO, "=================================="); next = meta->syscalls; while (next != NULL) { syscall_t * syscall = next->data; if (syscall->desc == NULL) LOG(LOG_INFO, "%s(%s)", syscall->name, syscall->sig); else LOG(LOG_INFO, "%s(%s) - %s", syscall->name, syscall->sig, syscall->desc); next = next->next; } } if (g_hash_table_size(meta->blocks) > 0) { LOG(LOG_INFO, " "); LOG(LOG_INFO, "Blocks"); LOG(LOG_INFO, "=================================="); g_hash_table_iter_init(&itr, meta->blocks); while (g_hash_table_iter_next(&itr, NULL, (gpointer *)&block)) { if (block->desc == NULL) LOG(LOG_INFO, "%s", block->name); else LOG(LOG_INFO, "%s - %s", block->name, block->desc); if (block->new_name != NULL) LOG(LOG_INFO, " Constructor: %s(%s)", block->new_name, block->new_sig); if (block->ondestroy_name != NULL) LOG(LOG_INFO, " Destructor: %s()", block->ondestroy_name); LOG(LOG_INFO, " Update: %s", block->onupdate_name); next = block->inputs; while (next != NULL) { bio_t * in = next->data; if (in->desc == NULL) LOG(LOG_INFO, " -> input (%c) %s", in->sig, in->name); else LOG(LOG_INFO, " -> input (%c) %s - %s", in->sig, in->name, in->desc); next = next->next; } next = block->outputs; while (next != NULL) { bio_t * out = next->data; if (out->desc == NULL) LOG(LOG_INFO, " <- output (%c) %s", out->sig, out->name); else LOG(LOG_INFO, " <- output (%c) %s - %s", out->sig, out->name, out->desc); next = next->next; } } } LOG(LOG_INFO, " "); //empty line return 0; }