mirror of
https://github.com/libretro/RetroArch.git
synced 2024-11-30 19:50:24 +00:00
5fdb9004d5
If there is no RARCH_ENABLE_HOTKEY set in retroarch.cfg RARCH_ENABLE_HOTKEY set in a autoconf file is not respected. The new solution only checks the first autoconf input device. https://github.com/libretro/RetroArch/issues/1310
778 lines
21 KiB
C
778 lines
21 KiB
C
/* RetroArch - A frontend for libretro.
|
|
* Copyright (C) 2010-2014 - Hans-Kristian Arntzen
|
|
* Copyright (C) 2011-2014 - Daniel De Matteis
|
|
* Copyright (C) 2012-2014 - Michael Lelli
|
|
*
|
|
* RetroArch is free software: you can redistribute it and/or modify it under the terms
|
|
* of the GNU General Public License as published by the Free Software Found-
|
|
* ation, either version 3 of the License, or (at your option) any later version.
|
|
*
|
|
* RetroArch is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
|
|
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
|
|
* PURPOSE. See the GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License along with RetroArch.
|
|
* If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include <file/file_path.h>
|
|
#include "dynamic.h"
|
|
#include "performance.h"
|
|
#include "retroarch_logger.h"
|
|
#include "intl/intl.h"
|
|
|
|
#ifdef HAVE_MENU
|
|
#include "menu/menu_common.h"
|
|
#endif
|
|
|
|
#ifdef HAVE_NETPLAY
|
|
#include "netplay.h"
|
|
#endif
|
|
|
|
static void set_volume(float gain)
|
|
{
|
|
char msg[PATH_MAX];
|
|
|
|
g_settings.audio.volume += gain;
|
|
g_settings.audio.volume = max(g_settings.audio.volume, -80.0f);
|
|
g_settings.audio.volume = min(g_settings.audio.volume, 12.0f);
|
|
|
|
snprintf(msg, sizeof(msg), "Volume: %.1f dB", g_settings.audio.volume);
|
|
msg_queue_clear(g_extern.msg_queue);
|
|
msg_queue_push(g_extern.msg_queue, msg, 1, 180);
|
|
RARCH_LOG("%s\n", msg);
|
|
|
|
g_extern.audio_data.volume_gain = db_to_gain(g_settings.audio.volume);
|
|
}
|
|
|
|
static bool check_pause(bool pressed, bool frameadvance_pressed)
|
|
{
|
|
static bool old_focus = true;
|
|
bool focus = true;
|
|
bool old_is_paused = g_extern.is_paused;
|
|
unsigned cmd = RARCH_CMD_NONE;
|
|
|
|
/* FRAMEADVANCE will set us into pause mode. */
|
|
pressed |= !g_extern.is_paused && frameadvance_pressed;
|
|
|
|
if (g_settings.pause_nonactive)
|
|
focus = driver.video->focus(driver.video_data);
|
|
|
|
if (focus && pressed)
|
|
cmd = RARCH_CMD_PAUSE_TOGGLE;
|
|
else if (focus && !old_focus)
|
|
cmd = RARCH_CMD_UNPAUSE;
|
|
else if (!focus && old_focus)
|
|
cmd = RARCH_CMD_PAUSE;
|
|
|
|
old_focus = focus;
|
|
|
|
if (cmd != RARCH_CMD_NONE)
|
|
rarch_main_command(cmd);
|
|
|
|
if (g_extern.is_paused == old_is_paused)
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
/* Rewind buttons works like FRAMEREWIND when paused.
|
|
* We will one-shot in that case. */
|
|
static inline bool check_is_oneshot(bool oneshot_pressed, bool rewind_pressed)
|
|
{
|
|
return (oneshot_pressed | rewind_pressed);
|
|
}
|
|
|
|
/* To avoid continous switching if we hold the button down, we require
|
|
* that the button must go from pressed to unpressed back to pressed
|
|
* to be able to toggle between then.
|
|
*/
|
|
static void check_fast_forward_button(bool fastforward_pressed,
|
|
bool hold_pressed, bool old_hold_pressed)
|
|
{
|
|
if (fastforward_pressed)
|
|
driver.nonblock_state = !driver.nonblock_state;
|
|
else if (old_hold_pressed != hold_pressed)
|
|
driver.nonblock_state = hold_pressed;
|
|
else
|
|
return;
|
|
|
|
driver_set_nonblock_state(driver.nonblock_state);
|
|
}
|
|
|
|
static void check_stateslots(bool pressed_increase, bool pressed_decrease)
|
|
{
|
|
char msg[PATH_MAX];
|
|
|
|
/* Save state slots */
|
|
if (pressed_increase)
|
|
g_settings.state_slot++;
|
|
else if (pressed_decrease)
|
|
{
|
|
if (g_settings.state_slot > 0)
|
|
g_settings.state_slot--;
|
|
}
|
|
else
|
|
return;
|
|
|
|
|
|
if (g_extern.msg_queue)
|
|
msg_queue_clear(g_extern.msg_queue);
|
|
|
|
snprintf(msg, sizeof(msg), "State slot: %d",
|
|
g_settings.state_slot);
|
|
|
|
if (g_extern.msg_queue)
|
|
msg_queue_push(g_extern.msg_queue, msg, 1, 180);
|
|
|
|
RARCH_LOG("%s\n", msg);
|
|
}
|
|
|
|
static inline void setup_rewind_audio(void)
|
|
{
|
|
unsigned i;
|
|
|
|
/* Push audio ready to be played. */
|
|
g_extern.audio_data.rewind_ptr = g_extern.audio_data.rewind_size;
|
|
|
|
for (i = 0; i < g_extern.audio_data.data_ptr; i += 2)
|
|
{
|
|
g_extern.audio_data.rewind_buf[--g_extern.audio_data.rewind_ptr] =
|
|
g_extern.audio_data.conv_outsamples[i + 1];
|
|
|
|
g_extern.audio_data.rewind_buf[--g_extern.audio_data.rewind_ptr] =
|
|
g_extern.audio_data.conv_outsamples[i + 0];
|
|
}
|
|
|
|
g_extern.audio_data.data_ptr = 0;
|
|
}
|
|
|
|
static void check_rewind(bool pressed)
|
|
{
|
|
static bool first = true;
|
|
|
|
if (g_extern.frame_is_reverse)
|
|
{
|
|
/* We just rewound. Flush rewind audio buffer. */
|
|
retro_flush_audio(g_extern.audio_data.rewind_buf
|
|
+ g_extern.audio_data.rewind_ptr,
|
|
g_extern.audio_data.rewind_size - g_extern.audio_data.rewind_ptr);
|
|
|
|
g_extern.frame_is_reverse = false;
|
|
}
|
|
|
|
if (first)
|
|
{
|
|
first = false;
|
|
return;
|
|
}
|
|
|
|
if (!g_extern.state_manager)
|
|
return;
|
|
|
|
if (pressed)
|
|
{
|
|
const void *buf = NULL;
|
|
|
|
msg_queue_clear(g_extern.msg_queue);
|
|
if (state_manager_pop(g_extern.state_manager, &buf))
|
|
{
|
|
g_extern.frame_is_reverse = true;
|
|
setup_rewind_audio();
|
|
|
|
msg_queue_push(g_extern.msg_queue, RETRO_MSG_REWINDING, 0,
|
|
g_extern.is_paused ? 1 : 30);
|
|
pretro_unserialize(buf, g_extern.state_size);
|
|
|
|
if (g_extern.bsv.movie)
|
|
bsv_movie_frame_rewind(g_extern.bsv.movie);
|
|
}
|
|
else
|
|
msg_queue_push(g_extern.msg_queue,
|
|
RETRO_MSG_REWIND_REACHED_END, 0, 30);
|
|
}
|
|
else
|
|
{
|
|
static unsigned cnt = 0;
|
|
|
|
cnt = (cnt + 1) % (g_settings.rewind_granularity ?
|
|
g_settings.rewind_granularity : 1); /* Avoid possible SIGFPE. */
|
|
|
|
if ((cnt == 0) || g_extern.bsv.movie)
|
|
{
|
|
void *state = NULL;
|
|
state_manager_push_where(g_extern.state_manager, &state);
|
|
|
|
RARCH_PERFORMANCE_INIT(rewind_serialize);
|
|
RARCH_PERFORMANCE_START(rewind_serialize);
|
|
pretro_serialize(state, g_extern.state_size);
|
|
RARCH_PERFORMANCE_STOP(rewind_serialize);
|
|
|
|
state_manager_push_do(g_extern.state_manager);
|
|
}
|
|
}
|
|
|
|
retro_set_rewind_callbacks();
|
|
}
|
|
|
|
static void check_slowmotion(bool pressed)
|
|
{
|
|
g_extern.is_slowmotion = pressed;
|
|
|
|
if (!g_extern.is_slowmotion)
|
|
return;
|
|
|
|
if (g_settings.video.black_frame_insertion)
|
|
rarch_render_cached_frame();
|
|
|
|
msg_queue_clear(g_extern.msg_queue);
|
|
msg_queue_push(g_extern.msg_queue, g_extern.frame_is_reverse ?
|
|
"Slow motion rewind." : "Slow motion.", 0, 30);
|
|
}
|
|
|
|
static bool check_movie_init(void)
|
|
{
|
|
char path[PATH_MAX], msg[PATH_MAX];
|
|
bool ret = true;
|
|
|
|
if (g_extern.bsv.movie)
|
|
return false;
|
|
|
|
g_settings.rewind_granularity = 1;
|
|
|
|
if (g_settings.state_slot > 0)
|
|
{
|
|
snprintf(path, sizeof(path), "%s%d.bsv",
|
|
g_extern.bsv.movie_path, g_settings.state_slot);
|
|
}
|
|
else
|
|
{
|
|
snprintf(path, sizeof(path), "%s.bsv",
|
|
g_extern.bsv.movie_path);
|
|
}
|
|
|
|
snprintf(msg, sizeof(msg), "Starting movie record to \"%s\".", path);
|
|
|
|
g_extern.bsv.movie = bsv_movie_init(path, RARCH_MOVIE_RECORD);
|
|
|
|
if (!g_extern.bsv.movie)
|
|
ret = false;
|
|
|
|
msg_queue_clear(g_extern.msg_queue);
|
|
msg_queue_push(g_extern.msg_queue, g_extern.bsv.movie ?
|
|
msg : "Failed to start movie record.", 1, 180);
|
|
|
|
if (g_extern.bsv.movie)
|
|
RARCH_LOG("Starting movie record to \"%s\".\n", path);
|
|
else
|
|
RARCH_ERR("Failed to start movie record.\n");
|
|
|
|
return ret;
|
|
}
|
|
|
|
static bool check_movie_record(void)
|
|
{
|
|
if (!g_extern.bsv.movie)
|
|
return false;
|
|
|
|
msg_queue_clear(g_extern.msg_queue);
|
|
msg_queue_push(g_extern.msg_queue,
|
|
RETRO_MSG_MOVIE_RECORD_STOPPING, 2, 180);
|
|
RARCH_LOG(RETRO_LOG_MOVIE_RECORD_STOPPING);
|
|
|
|
rarch_main_command(RARCH_CMD_BSV_MOVIE_DEINIT);
|
|
|
|
return true;
|
|
}
|
|
|
|
static bool check_movie_playback(void)
|
|
{
|
|
if (!g_extern.bsv.movie_end)
|
|
return false;
|
|
|
|
msg_queue_push(g_extern.msg_queue,
|
|
RETRO_MSG_MOVIE_PLAYBACK_ENDED, 1, 180);
|
|
RARCH_LOG(RETRO_LOG_MOVIE_PLAYBACK_ENDED);
|
|
|
|
rarch_main_command(RARCH_CMD_BSV_MOVIE_DEINIT);
|
|
|
|
g_extern.bsv.movie_end = false;
|
|
g_extern.bsv.movie_playback = false;
|
|
|
|
return true;
|
|
}
|
|
|
|
static bool check_movie(void)
|
|
{
|
|
if (g_extern.bsv.movie_playback)
|
|
return check_movie_playback();
|
|
if (!g_extern.bsv.movie)
|
|
return check_movie_init();
|
|
return check_movie_record();
|
|
}
|
|
|
|
static void check_shader_dir(bool pressed_next, bool pressed_prev)
|
|
{
|
|
char msg[PATH_MAX];
|
|
const char *shader = NULL, *ext = NULL;
|
|
enum rarch_shader_type type = RARCH_SHADER_NONE;
|
|
|
|
if (!g_extern.shader_dir.list || !driver.video->set_shader)
|
|
return;
|
|
|
|
if (pressed_next)
|
|
{
|
|
g_extern.shader_dir.ptr = (g_extern.shader_dir.ptr + 1) %
|
|
g_extern.shader_dir.list->size;
|
|
}
|
|
else if (pressed_prev)
|
|
{
|
|
if (g_extern.shader_dir.ptr == 0)
|
|
g_extern.shader_dir.ptr = g_extern.shader_dir.list->size - 1;
|
|
else
|
|
g_extern.shader_dir.ptr--;
|
|
}
|
|
else
|
|
return;
|
|
|
|
shader = g_extern.shader_dir.list->elems[g_extern.shader_dir.ptr].data;
|
|
ext = path_get_extension(shader);
|
|
|
|
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;
|
|
else
|
|
return;
|
|
|
|
msg_queue_clear(g_extern.msg_queue);
|
|
|
|
snprintf(msg, sizeof(msg), "Shader #%u: \"%s\".",
|
|
(unsigned)g_extern.shader_dir.ptr, shader);
|
|
msg_queue_push(g_extern.msg_queue, msg, 1, 120);
|
|
RARCH_LOG("Applying shader \"%s\".\n", shader);
|
|
|
|
if (!driver.video->set_shader(driver.video_data, type, shader))
|
|
RARCH_WARN("Failed to apply shader.\n");
|
|
}
|
|
|
|
/*
|
|
* Checks for stuff like fullscreen, save states, etc.
|
|
*
|
|
* Returns:
|
|
* 0 - normal operation.
|
|
* 1 - when RetroArch is paused.
|
|
*/
|
|
|
|
static void check_cheats(retro_input_t trigger_input)
|
|
{
|
|
if (BIT64_GET(trigger_input, RARCH_CHEAT_INDEX_PLUS))
|
|
cheat_manager_index_next(g_extern.cheat);
|
|
else if (BIT64_GET(trigger_input, RARCH_CHEAT_INDEX_MINUS))
|
|
cheat_manager_index_prev(g_extern.cheat);
|
|
else if (BIT64_GET(trigger_input, RARCH_CHEAT_TOGGLE))
|
|
cheat_manager_toggle(g_extern.cheat);
|
|
}
|
|
|
|
static int do_state_checks(
|
|
retro_input_t input, retro_input_t old_input,
|
|
retro_input_t trigger_input)
|
|
{
|
|
if (BIT64_GET(trigger_input, RARCH_SCREENSHOT))
|
|
rarch_main_command(RARCH_CMD_TAKE_SCREENSHOT);
|
|
|
|
if (BIT64_GET(trigger_input, RARCH_MUTE))
|
|
rarch_main_command(RARCH_CMD_AUDIO_MUTE_TOGGLE);
|
|
|
|
if (BIT64_GET(input, RARCH_VOLUME_UP))
|
|
set_volume(0.5f);
|
|
else if (BIT64_GET(input, RARCH_VOLUME_DOWN))
|
|
set_volume(-0.5f);
|
|
|
|
if (BIT64_GET(trigger_input, RARCH_GRAB_MOUSE_TOGGLE))
|
|
rarch_main_command(RARCH_CMD_GRAB_MOUSE_TOGGLE);
|
|
|
|
if (BIT64_GET(trigger_input, RARCH_OVERLAY_NEXT))
|
|
rarch_main_command(RARCH_CMD_OVERLAY_NEXT);
|
|
|
|
if (!g_extern.is_paused)
|
|
{
|
|
if (BIT64_GET(trigger_input, RARCH_FULLSCREEN_TOGGLE_KEY))
|
|
rarch_main_command(RARCH_CMD_FULLSCREEN_TOGGLE);
|
|
}
|
|
|
|
#ifdef HAVE_NETPLAY
|
|
if (driver.netplay_data)
|
|
{
|
|
if (BIT64_GET(trigger_input, RARCH_NETPLAY_FLIP))
|
|
rarch_main_command(RARCH_CMD_NETPLAY_FLIP_PLAYERS);
|
|
|
|
if (BIT64_GET(trigger_input, RARCH_FULLSCREEN_TOGGLE_KEY))
|
|
rarch_main_command(RARCH_CMD_FULLSCREEN_TOGGLE);
|
|
return 0;
|
|
}
|
|
#endif
|
|
check_pause_func(trigger_input);
|
|
|
|
if (g_extern.is_paused)
|
|
{
|
|
if (BIT64_GET(trigger_input, RARCH_FULLSCREEN_TOGGLE_KEY))
|
|
{
|
|
rarch_main_command(RARCH_CMD_FULLSCREEN_TOGGLE);
|
|
rarch_render_cached_frame();
|
|
}
|
|
|
|
if (!check_oneshot_func(trigger_input))
|
|
return 1;
|
|
}
|
|
|
|
check_fast_forward_button_func(input, old_input, trigger_input);
|
|
|
|
check_stateslots_func(trigger_input);
|
|
|
|
if (BIT64_GET(trigger_input, RARCH_SAVE_STATE_KEY))
|
|
rarch_main_command(RARCH_CMD_SAVE_STATE);
|
|
else if (BIT64_GET(trigger_input, RARCH_LOAD_STATE_KEY))
|
|
rarch_main_command(RARCH_CMD_LOAD_STATE);
|
|
|
|
check_rewind_func(input);
|
|
|
|
check_slowmotion_func(input);
|
|
|
|
if (BIT64_GET(trigger_input, RARCH_MOVIE_RECORD_TOGGLE))
|
|
check_movie();
|
|
|
|
check_shader_dir_func(trigger_input);
|
|
|
|
if (BIT64_GET(trigger_input, RARCH_DISK_EJECT_TOGGLE))
|
|
rarch_main_command(RARCH_CMD_DISK_EJECT_TOGGLE);
|
|
else if (BIT64_GET(trigger_input, RARCH_DISK_NEXT))
|
|
rarch_main_command(RARCH_CMD_DISK_NEXT);
|
|
else if (BIT64_GET(trigger_input, RARCH_DISK_PREV))
|
|
rarch_main_command(RARCH_CMD_DISK_PREV);
|
|
|
|
if (BIT64_GET(trigger_input, RARCH_RESET))
|
|
rarch_main_command(RARCH_CMD_RESET);
|
|
|
|
if (g_extern.cheat)
|
|
check_cheats(trigger_input);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static inline int time_to_exit(retro_input_t input)
|
|
{
|
|
if (
|
|
g_extern.system.shutdown
|
|
|| check_quit_key_func(input)
|
|
|| (g_extern.max_frames && g_extern.frame_count >=
|
|
g_extern.max_frames)
|
|
|| (g_extern.bsv.movie_end && g_extern.bsv.eof_exit)
|
|
|| !driver.video->alive(driver.video_data)
|
|
)
|
|
return 1;
|
|
return 0;
|
|
}
|
|
|
|
static void update_frame_time(void)
|
|
{
|
|
retro_time_t curr_time = rarch_get_time_usec();
|
|
retro_time_t delta = curr_time - g_extern.system.frame_time_last;
|
|
bool is_locked_fps = g_extern.is_paused || driver.nonblock_state;
|
|
is_locked_fps |= !!driver.recording_data;
|
|
|
|
if (!g_extern.system.frame_time_last || is_locked_fps)
|
|
delta = g_extern.system.frame_time.reference;
|
|
|
|
if (!is_locked_fps && g_extern.is_slowmotion)
|
|
delta /= g_settings.slowmotion_ratio;
|
|
|
|
g_extern.system.frame_time_last = is_locked_fps ? 0 : curr_time;
|
|
g_extern.system.frame_time.callback(delta);
|
|
}
|
|
|
|
#ifdef HAVE_MENU
|
|
static void do_state_check_menu_toggle(void)
|
|
{
|
|
if (g_extern.is_menu)
|
|
{
|
|
if (g_extern.main_is_init && !g_extern.libretro_dummy)
|
|
rarch_main_set_state(RARCH_ACTION_STATE_MENU_RUNNING_FINISHED);
|
|
return;
|
|
}
|
|
|
|
rarch_main_set_state(RARCH_ACTION_STATE_MENU_RUNNING);
|
|
}
|
|
#endif
|
|
|
|
static void limit_frame_time(void)
|
|
{
|
|
retro_time_t current = rarch_get_time_usec();
|
|
retro_time_t target = 0, to_sleep_ms = 0;
|
|
double effective_fps = g_extern.system.av_info.timing.fps
|
|
* g_settings.fastforward_ratio;
|
|
double mft_f = 1000000.0f / effective_fps;
|
|
|
|
g_extern.frame_limit.minimum_frame_time = (retro_time_t) roundf(mft_f);
|
|
|
|
target = g_extern.frame_limit.last_frame_time +
|
|
g_extern.frame_limit.minimum_frame_time;
|
|
to_sleep_ms = (target - current) / 1000;
|
|
|
|
if (to_sleep_ms > 0)
|
|
{
|
|
rarch_sleep((unsigned int)to_sleep_ms);
|
|
|
|
/* Combat jitter a bit. */
|
|
g_extern.frame_limit.last_frame_time +=
|
|
g_extern.frame_limit.minimum_frame_time;
|
|
}
|
|
else
|
|
g_extern.frame_limit.last_frame_time = rarch_get_time_usec();
|
|
}
|
|
|
|
static void check_block_hotkey(bool enable_hotkey)
|
|
{
|
|
bool use_hotkey_enable;
|
|
static const struct retro_keybind *bind =
|
|
&g_settings.input.binds[0][RARCH_ENABLE_HOTKEY];
|
|
static const struct retro_keybind *autoconf_bind =
|
|
&g_settings.input.autoconf_binds[0][RARCH_ENABLE_HOTKEY];
|
|
|
|
/* Don't block the check to RARCH_ENABLE_HOTKEY
|
|
* unless we're really supposed to. */
|
|
driver.block_hotkey = driver.block_input;
|
|
|
|
// If we haven't bound anything to this, always allow hotkeys.
|
|
use_hotkey_enable = bind->key != RETROK_UNKNOWN ||
|
|
bind->joykey != NO_BTN ||
|
|
bind->joyaxis != AXIS_NONE ||
|
|
autoconf_bind->key != RETROK_UNKNOWN ||
|
|
autoconf_bind->joykey != NO_BTN ||
|
|
autoconf_bind->joyaxis != AXIS_NONE;;
|
|
|
|
driver.block_hotkey = driver.block_input ||
|
|
(use_hotkey_enable && !enable_hotkey);
|
|
|
|
/* If we hold ENABLE_HOTKEY button, block all libretro input to allow
|
|
* hotkeys to be bound to same keys as RetroPad. */
|
|
driver.block_libretro_input = use_hotkey_enable && enable_hotkey;
|
|
}
|
|
|
|
/* We query all known keys per frame. Returns a 64-bit mask
|
|
* of all pressed keys.
|
|
*
|
|
* TODO: In case RARCH_BIND_LIST_END starts exceeding 64,
|
|
* and you need a bitmask of more than 64 entries, reimplement
|
|
* it to use something like rarch_bits_t.
|
|
*/
|
|
|
|
static inline retro_input_t input_keys_pressed(void)
|
|
{
|
|
static const struct retro_keybind *binds[MAX_PLAYERS] = {
|
|
g_settings.input.binds[0],
|
|
g_settings.input.binds[1],
|
|
g_settings.input.binds[2],
|
|
g_settings.input.binds[3],
|
|
g_settings.input.binds[4],
|
|
g_settings.input.binds[5],
|
|
g_settings.input.binds[6],
|
|
g_settings.input.binds[7],
|
|
g_settings.input.binds[8],
|
|
g_settings.input.binds[9],
|
|
g_settings.input.binds[10],
|
|
g_settings.input.binds[11],
|
|
g_settings.input.binds[12],
|
|
g_settings.input.binds[13],
|
|
g_settings.input.binds[14],
|
|
g_settings.input.binds[15],
|
|
};
|
|
retro_input_t ret = 0;
|
|
int i, key;
|
|
|
|
g_extern.turbo_count++;
|
|
|
|
check_block_hotkey(driver.input->key_pressed(driver.input_data,
|
|
RARCH_ENABLE_HOTKEY));
|
|
|
|
input_push_analog_dpad((struct retro_keybind*)binds[0],
|
|
(g_settings.input.analog_dpad_mode[0] == ANALOG_DPAD_NONE) ?
|
|
ANALOG_DPAD_LSTICK : g_settings.input.analog_dpad_mode[0]);
|
|
|
|
for (i = 0; i < MAX_PLAYERS; i++)
|
|
{
|
|
input_push_analog_dpad(g_settings.input.autoconf_binds[i],
|
|
g_settings.input.analog_dpad_mode[i]);
|
|
|
|
if (driver.block_libretro_input)
|
|
g_extern.turbo_frame_enable[i] = 0;
|
|
else
|
|
g_extern.turbo_frame_enable[i] =
|
|
driver.input->input_state(driver.input_data, binds, i,
|
|
RETRO_DEVICE_JOYPAD, 0, RARCH_TURBO_ENABLE);
|
|
}
|
|
|
|
for (key = 0; key < RARCH_BIND_LIST_END; key++)
|
|
{
|
|
bool state = false;
|
|
|
|
if (
|
|
(!driver.block_libretro_input && (key < RARCH_FIRST_META_KEY)) ||
|
|
!driver.block_hotkey)
|
|
state = driver.input->key_pressed(driver.input_data, key);
|
|
|
|
#ifdef HAVE_OVERLAY
|
|
state = state || (driver.overlay_state.buttons & (1ULL << key));
|
|
#endif
|
|
|
|
#ifdef HAVE_COMMAND
|
|
if (driver.command)
|
|
state = state || rarch_cmd_get(driver.command, key);
|
|
#endif
|
|
|
|
if (state)
|
|
ret |= (1ULL << key);
|
|
}
|
|
|
|
input_pop_analog_dpad((struct retro_keybind*)binds[0]);
|
|
for (i = 0; i < MAX_PLAYERS; i++)
|
|
input_pop_analog_dpad(g_settings.input.autoconf_binds[i]);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static bool input_flush(retro_input_t *input)
|
|
{
|
|
*input = 0;
|
|
|
|
/* If core was paused before entering menu, evoke
|
|
* pause toggle to wake it up. */
|
|
if (g_extern.is_paused)
|
|
BIT64_SET(*input, RARCH_PAUSE_TOGGLE);
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
* RetroArch's main iteration loop.
|
|
*
|
|
* Returns:
|
|
* 0 - Forcibly wake up the loop.
|
|
* 1 - Wait until input to wake up the loop
|
|
* -1 - Quit out of iteration loop.
|
|
*/
|
|
|
|
int rarch_main_iterate(void)
|
|
{
|
|
unsigned i;
|
|
retro_input_t trigger_input;
|
|
int ret = 0;
|
|
static retro_input_t last_input = 0;
|
|
retro_input_t old_input = last_input;
|
|
retro_input_t input = input_keys_pressed();
|
|
|
|
last_input = input;
|
|
|
|
if (driver.flushing_input)
|
|
driver.flushing_input = (input) ? input_flush(&input) : false;
|
|
|
|
trigger_input = input & ~old_input;
|
|
|
|
if (time_to_exit(input))
|
|
return -1;
|
|
|
|
if (g_extern.system.frame_time.callback)
|
|
update_frame_time();
|
|
|
|
#ifdef HAVE_MENU
|
|
if (check_enter_menu_func(trigger_input) || (g_extern.libretro_dummy))
|
|
do_state_check_menu_toggle();
|
|
|
|
if (g_extern.is_menu)
|
|
{
|
|
if (menu_iterate(input, old_input, trigger_input) == -1)
|
|
rarch_main_set_state(RARCH_ACTION_STATE_MENU_RUNNING_FINISHED);
|
|
|
|
if (!input && g_settings.menu.pause_libretro)
|
|
ret = 1;
|
|
goto success;
|
|
}
|
|
#endif
|
|
|
|
if (g_extern.exec)
|
|
{
|
|
g_extern.exec = false;
|
|
return -1;
|
|
}
|
|
|
|
if (do_state_checks(input, old_input, trigger_input))
|
|
{
|
|
/* RetroArch has been paused */
|
|
driver.retro_ctx.poll_cb();
|
|
rarch_sleep(10);
|
|
|
|
return 1;
|
|
}
|
|
|
|
#if defined(HAVE_THREADS)
|
|
lock_autosave();
|
|
#endif
|
|
|
|
#ifdef HAVE_NETPLAY
|
|
if (driver.netplay_data)
|
|
netplay_pre_frame((netplay_t*)driver.netplay_data);
|
|
#endif
|
|
|
|
if (g_extern.bsv.movie)
|
|
bsv_movie_set_frame_start(g_extern.bsv.movie);
|
|
|
|
if (g_extern.system.camera_callback.caps)
|
|
driver_camera_poll();
|
|
|
|
/* Update binds for analog dpad modes. */
|
|
for (i = 0; i < MAX_PLAYERS; i++)
|
|
{
|
|
if (!g_settings.input.analog_dpad_mode[i])
|
|
continue;
|
|
|
|
input_push_analog_dpad(g_settings.input.binds[i],
|
|
g_settings.input.analog_dpad_mode[i]);
|
|
input_push_analog_dpad(g_settings.input.autoconf_binds[i],
|
|
g_settings.input.analog_dpad_mode[i]);
|
|
}
|
|
|
|
if ((g_settings.video.frame_delay > 0) && !driver.nonblock_state)
|
|
rarch_sleep(g_settings.video.frame_delay);
|
|
|
|
|
|
/* Run libretro for one frame. */
|
|
pretro_run();
|
|
|
|
for (i = 0; i < MAX_PLAYERS; i++)
|
|
{
|
|
if (!g_settings.input.analog_dpad_mode[i])
|
|
continue;
|
|
|
|
input_pop_analog_dpad(g_settings.input.binds[i]);
|
|
input_pop_analog_dpad(g_settings.input.autoconf_binds[i]);
|
|
}
|
|
|
|
if (g_extern.bsv.movie)
|
|
bsv_movie_set_frame_end(g_extern.bsv.movie);
|
|
|
|
#ifdef HAVE_NETPLAY
|
|
if (driver.netplay_data)
|
|
netplay_post_frame((netplay_t*)driver.netplay_data);
|
|
#endif
|
|
|
|
#if defined(HAVE_THREADS)
|
|
unlock_autosave();
|
|
#endif
|
|
|
|
success:
|
|
if (g_settings.fastforward_ratio_throttle_enable)
|
|
limit_frame_time();
|
|
|
|
return ret;
|
|
}
|