CTCaer/RetroArch
1
0
Fork 0
mirror of https://github.com/CTCaer/RetroArch.git synced 2024-12-27 13:16:14 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
a7e6df69c8
RetroArch/retroarch.c

3468 lines
101 KiB
C
Raw Blame History

/* 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 "boolean.h"
#include "libretro.h"
#include "retro.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <errno.h>
#include "driver.h"
#include "file.h"
#include "general.h"
#include "dynamic.h"
#include "performance.h"
#include "audio/utils.h"
#include "record/ffemu.h"
#include "rewind.h"
#include "movie.h"
#include "compat/strl.h"
#include "screenshot.h"
#include "cheats.h"
#include "compat/getopt_rarch.h"
#include "compat/posix_string.h"
#include "input/keyboard_line.h"
#include "input/input_common.h"
#include "git_version.h"
#include "intl/intl.h"
#ifdef HAVE_MENU
#include "frontend/menu/menu_common.h"
#include "frontend/menu/menu_input_line_cb.h"
#endif
#ifdef _WIN32
#ifdef _XBOX
#include <xtl.h>
#else
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#endif
#include "msvc/msvc_compat.h"
#endif
/* 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;
driver_set_nonblock_state(driver.nonblock_state);
}
else if (old_hold_pressed != hold_pressed)
{
driver.nonblock_state = hold_pressed;
driver_set_nonblock_state(driver.nonblock_state);
}
}
static bool take_screenshot_viewport(void)
{
char screenshot_path[PATH_MAX];
const char *screenshot_dir = NULL;
uint8_t *buffer = NULL;
bool retval = false;
struct rarch_viewport vp = {0};
if (driver.video && driver.video->viewport_info)
driver.video->viewport_info(driver.video_data, &vp);
if (!vp.width || !vp.height)
return false;
if (!(buffer = (uint8_t*)malloc(vp.width * vp.height * 3)))
return false;
if (driver.video && driver.video->read_viewport)
if (!driver.video->read_viewport(driver.video_data, buffer))
goto done;
screenshot_dir = g_settings.screenshot_directory;
if (!*g_settings.screenshot_directory)
{
fill_pathname_basedir(screenshot_path, g_extern.basename,
sizeof(screenshot_path));
screenshot_dir = screenshot_path;
}
/* Data read from viewport is in bottom-up order, suitable for BMP. */
if (!screenshot_dump(screenshot_dir, buffer, vp.width, vp.height,
vp.width * 3, true))
goto done;
retval = true;
done:
if (buffer)
free(buffer);
return retval;
}
static bool take_screenshot_raw(void)
{
char screenshot_path[PATH_MAX];
const void *data = g_extern.frame_cache.data;
unsigned width = g_extern.frame_cache.width;
unsigned height = g_extern.frame_cache.height;
int pitch = g_extern.frame_cache.pitch;
const char *screenshot_dir = g_settings.screenshot_directory;
if (!*g_settings.screenshot_directory)
{
fill_pathname_basedir(screenshot_path, g_extern.basename,
sizeof(screenshot_path));
screenshot_dir = screenshot_path;
}
/* Negative pitch is needed as screenshot takes bottom-up,
* but we use top-down.
*/
return screenshot_dump(screenshot_dir,
(const uint8_t*)data + (height - 1) * pitch,
width, height, -pitch, false);
}
static void take_screenshot(void)
{
bool viewport_read = false;
bool ret = false;
const char *msg = NULL;
/* No way to infer screenshot directory. */
if ((!*g_settings.screenshot_directory) && (!*g_extern.basename))
return;
viewport_read = (g_settings.video.gpu_screenshot ||
g_extern.system.hw_render_callback.context_type
!= RETRO_HW_CONTEXT_NONE) && driver.video->read_viewport &&
driver.video->viewport_info;
/* Clear out message queue to avoid OSD fonts to appear on screenshot. */
msg_queue_clear(g_extern.msg_queue);
if (viewport_read)
{
/* Avoid taking screenshot of GUI overlays. */
if (driver.video_poke && driver.video_poke->set_texture_enable)
driver.video_poke->set_texture_enable(driver.video_data,
false, false);
if (driver.video)
rarch_render_cached_frame();
}
if (viewport_read)
ret = take_screenshot_viewport();
else if (g_extern.frame_cache.data &&
(g_extern.frame_cache.data != RETRO_HW_FRAME_BUFFER_VALID))
ret = take_screenshot_raw();
else
RARCH_ERR(RETRO_LOG_TAKE_SCREENSHOT_ERROR);
if (ret)
{
RARCH_LOG(RETRO_LOG_TAKE_SCREENSHOT);
msg = RETRO_MSG_TAKE_SCREENSHOT;
}
else
{
RARCH_WARN(RETRO_LOG_TAKE_SCREENSHOT_FAILED);
msg = RETRO_MSG_TAKE_SCREENSHOT_FAILED;
}
msg_queue_push(g_extern.msg_queue, msg, 1, g_extern.is_paused ? 1 : 180);
if (g_extern.is_paused)
rarch_render_cached_frame();
}
static void readjust_audio_input_rate(void)
{
int avail = driver.audio->write_avail(driver.audio_data);
//RARCH_LOG_OUTPUT("Audio buffer is %u%% full\n",
// (unsigned)(100 - (avail * 100) / g_extern.audio_data.driver_buffer_size));
unsigned write_index = g_extern.measure_data.buffer_free_samples_count++ &
(AUDIO_BUFFER_FREE_SAMPLES_COUNT - 1);
int half_size = g_extern.audio_data.driver_buffer_size / 2;
int delta_mid = avail - half_size;
double direction = (double)delta_mid / half_size;
double adjust = 1.0 + g_settings.audio.rate_control_delta *
direction;
g_extern.measure_data.buffer_free_samples[write_index] = avail;
g_extern.audio_data.src_ratio = g_extern.audio_data.orig_src_ratio * adjust;
//RARCH_LOG_OUTPUT("New rate: %lf, Orig rate: %lf\n",
// g_extern.audio_data.src_ratio, g_extern.audio_data.orig_src_ratio);
}
void rarch_deinit_gpu_recording(void)
{
if (g_extern.record_gpu_buffer)
free(g_extern.record_gpu_buffer);
g_extern.record_gpu_buffer = NULL;
}
static void init_recording(void)
{
struct ffemu_params params = {0};
const struct retro_system_av_info *info = {0};
if (!g_extern.recording_enable)
return;
if (g_extern.libretro_dummy)
{
RARCH_WARN(RETRO_LOG_INIT_RECORDING_SKIPPED);
return;
}
if (!g_settings.video.gpu_record
&& g_extern.system.hw_render_callback.context_type)
{
RARCH_WARN("Libretro core is hardware rendered. Must use post-shaded recording as well.\n");
return;
}
RARCH_LOG("Custom timing given: FPS: %.4f, Sample rate: %.4f\n",
(float)g_extern.system.av_info.timing.fps,
(float)g_extern.system.av_info.timing.sample_rate);
info = (const struct retro_system_av_info*)&g_extern.system.av_info;
params.out_width = info->geometry.base_width;
params.out_height = info->geometry.base_height;
params.fb_width = info->geometry.max_width;
params.fb_height = info->geometry.max_height;
params.channels = 2;
params.filename = g_extern.record_path;
params.fps = g_extern.system.av_info.timing.fps;
params.samplerate = g_extern.system.av_info.timing.sample_rate;
params.pix_fmt = (g_extern.system.pix_fmt == RETRO_PIXEL_FORMAT_XRGB8888) ?
FFEMU_PIX_ARGB8888 : FFEMU_PIX_RGB565;
params.config = NULL;
if (*g_extern.record_config)
params.config = g_extern.record_config;
if (g_settings.video.gpu_record && driver.video->read_viewport)
{
struct rarch_viewport vp = {0};
if (driver.video && driver.video->viewport_info)
driver.video->viewport_info(driver.video_data, &vp);
if (!vp.width || !vp.height)
{
RARCH_ERR("Failed to get viewport information from video driver. "
"Cannot start recording ...\n");
return;
}
params.out_width = vp.width;
params.out_height = vp.height;
params.fb_width = next_pow2(vp.width);
params.fb_height = next_pow2(vp.height);
if (g_settings.video.force_aspect &&
(g_extern.system.aspect_ratio > 0.0f))
params.aspect_ratio = g_extern.system.aspect_ratio;
else
params.aspect_ratio = (float)vp.width / vp.height;
params.pix_fmt = FFEMU_PIX_BGR24;
g_extern.record_gpu_width = vp.width;
g_extern.record_gpu_height = vp.height;
RARCH_LOG("Detected viewport of %u x %u\n",
vp.width, vp.height);
g_extern.record_gpu_buffer = (uint8_t*)malloc(vp.width * vp.height * 3);
if (!g_extern.record_gpu_buffer)
{
RARCH_ERR("Failed to allocate GPU record buffer.\n");
return;
}
}
else
{
if (g_extern.record_width || g_extern.record_height)
{
params.out_width = g_extern.record_width;
params.out_height = g_extern.record_height;
}
if (g_settings.video.force_aspect &&
(g_extern.system.aspect_ratio > 0.0f))
params.aspect_ratio = g_extern.system.aspect_ratio;
else
params.aspect_ratio = (float)params.out_width / params.out_height;
if (g_settings.video.post_filter_record && g_extern.filter.filter)
{
unsigned max_width = 0;
unsigned max_height = 0;
if (g_extern.filter.out_rgb32)
params.pix_fmt = FFEMU_PIX_ARGB8888;
else
params.pix_fmt = FFEMU_PIX_RGB565;
rarch_softfilter_get_max_output_size(g_extern.filter.filter,
&max_width, &max_height);
params.fb_width = next_pow2(max_width);
params.fb_height = next_pow2(max_height);
}
}
RARCH_LOG("Recording to %s @ %ux%u. (FB size: %ux%u pix_fmt: %u)\n",
g_extern.record_path,
params.out_width, params.out_height,
params.fb_width, params.fb_height,
(unsigned)params.pix_fmt);
if (!ffemu_init_first(&g_extern.rec_driver, &g_extern.rec, &params))
{
RARCH_ERR(RETRO_LOG_INIT_RECORDING_FAILED);
rarch_deinit_gpu_recording();
}
}
void rarch_deinit_recording(void)
{
if (!g_extern.rec || !g_extern.rec_driver)
return;
if (g_extern.rec_driver->finalize)
g_extern.rec_driver->finalize(g_extern.rec);
if (g_extern.rec_driver->free)
g_extern.rec_driver->free(g_extern.rec);
g_extern.rec = NULL;
g_extern.rec_driver = NULL;
rarch_deinit_gpu_recording();
}
void rarch_render_cached_frame(void)
{
const void *frame = g_extern.frame_cache.data;
void *recording = g_extern.rec;
/* Cannot allow recording when pushing duped frames. */
g_extern.rec = NULL;
if (frame == RETRO_HW_FRAME_BUFFER_VALID)
frame = NULL; /* Dupe */
/* Not 100% safe, since the library might have
* freed the memory, but no known implementations do this.
* It would be really stupid at any rate ...
*/
retro_video_frame(frame,
g_extern.frame_cache.width,
g_extern.frame_cache.height,
g_extern.frame_cache.pitch);
g_extern.rec = recording;
}
bool rarch_audio_flush(const int16_t *data, size_t samples)
{
const void *output_data = NULL;
unsigned output_frames = 0;
size_t output_size = sizeof(float);
struct resampler_data src_data = {0};
struct rarch_dsp_data dsp_data = {0};
if (g_extern.rec)
{
struct ffemu_audio_data ffemu_data = {0};
ffemu_data.data = data;
ffemu_data.frames = samples / 2;
if (g_extern.rec_driver && g_extern.rec_driver->push_audio)
g_extern.rec_driver->push_audio(g_extern.rec, &ffemu_data);
}
if (g_extern.is_paused || g_extern.audio_data.mute)
return true;
if (!g_extern.audio_active)
return false;
RARCH_PERFORMANCE_INIT(audio_convert_s16);
RARCH_PERFORMANCE_START(audio_convert_s16);
audio_convert_s16_to_float(g_extern.audio_data.data, data, samples,
g_extern.audio_data.volume_gain);
RARCH_PERFORMANCE_STOP(audio_convert_s16);
dsp_data.input = g_extern.audio_data.data;
dsp_data.input_frames = samples >> 1;
if (g_extern.audio_data.dsp)
{
RARCH_PERFORMANCE_INIT(audio_dsp);
RARCH_PERFORMANCE_START(audio_dsp);
rarch_dsp_filter_process(g_extern.audio_data.dsp, &dsp_data);
RARCH_PERFORMANCE_STOP(audio_dsp);
}
src_data.data_in = dsp_data.output ?
dsp_data.output : g_extern.audio_data.data;
src_data.input_frames = dsp_data.output ?
dsp_data.output_frames : (samples >> 1);
src_data.data_out = g_extern.audio_data.outsamples;
if (g_extern.audio_data.rate_control)
readjust_audio_input_rate();
src_data.ratio = g_extern.audio_data.src_ratio;
if (g_extern.is_slowmotion)
src_data.ratio *= g_settings.slowmotion_ratio;
RARCH_PERFORMANCE_INIT(resampler_proc);
RARCH_PERFORMANCE_START(resampler_proc);
rarch_resampler_process(g_extern.audio_data.resampler,
g_extern.audio_data.resampler_data, &src_data);
RARCH_PERFORMANCE_STOP(resampler_proc);
output_data = g_extern.audio_data.outsamples;
output_frames = src_data.output_frames;
if (!g_extern.audio_data.use_float)
{
RARCH_PERFORMANCE_INIT(audio_convert_float);
RARCH_PERFORMANCE_START(audio_convert_float);
audio_convert_float_to_s16(g_extern.audio_data.conv_outsamples,
(const float*)output_data, output_frames * 2);
RARCH_PERFORMANCE_STOP(audio_convert_float);
output_data = g_extern.audio_data.conv_outsamples;
output_size = sizeof(int16_t);
}
if (driver.audio->write(driver.audio_data, output_data,
output_frames * output_size * 2) < 0)
{
RARCH_ERR(RETRO_LOG_AUDIO_WRITE_FAILED);
return false;
}
return true;
}
#ifdef HAVE_OVERLAY
static inline void input_poll_overlay(void)
{
input_overlay_state_t old_key_state;
unsigned i, j, device;
uint16_t key_mod = 0;
bool polled = false;
memcpy(old_key_state.keys, driver.overlay_state.keys,
sizeof(driver.overlay_state.keys));
memset(&driver.overlay_state, 0, sizeof(driver.overlay_state));
device = input_overlay_full_screen(driver.overlay) ?
RARCH_DEVICE_POINTER_SCREEN : RETRO_DEVICE_POINTER;
for (i = 0;
driver.input->input_state(driver.input_data, NULL, 0, device, i,
RETRO_DEVICE_ID_POINTER_PRESSED);
i++)
{
int16_t x = driver.input->input_state(driver.input_data, NULL, 0,
device, i, RETRO_DEVICE_ID_POINTER_X);
int16_t y = driver.input->input_state(driver.input_data, NULL, 0,
device, i, RETRO_DEVICE_ID_POINTER_Y);
input_overlay_state_t polled_data;
input_overlay_poll(driver.overlay, &polled_data, x, y);
driver.overlay_state.buttons |= polled_data.buttons;
for (j = 0; j < ARRAY_SIZE(driver.overlay_state.keys); j++)
driver.overlay_state.keys[j] |= polled_data.keys[j];
/* Fingers pressed later take prio and matched up
* with overlay poll priorities. */
for (j = 0; j < 4; j++)
if (polled_data.analog[j])
driver.overlay_state.analog[j] = polled_data.analog[j];
polled = true;
}
key_mod |= (OVERLAY_GET_KEY(&driver.overlay_state, RETROK_LSHIFT) ||
OVERLAY_GET_KEY(&driver.overlay_state, RETROK_RSHIFT)) ?
RETROKMOD_SHIFT : 0;
key_mod |= (OVERLAY_GET_KEY(&driver.overlay_state, RETROK_LCTRL) ||
OVERLAY_GET_KEY(&driver.overlay_state, RETROK_RCTRL)) ?
RETROKMOD_CTRL : 0;
key_mod |= (OVERLAY_GET_KEY(&driver.overlay_state, RETROK_LALT) ||
OVERLAY_GET_KEY(&driver.overlay_state, RETROK_RALT)) ?
RETROKMOD_ALT : 0;
key_mod |= (OVERLAY_GET_KEY(&driver.overlay_state, RETROK_LMETA) ||
OVERLAY_GET_KEY(&driver.overlay_state, RETROK_RMETA)) ?
RETROKMOD_META : 0;
/* CAPSLOCK SCROLLOCK NUMLOCK */
for (i = 0; i < ARRAY_SIZE(driver.overlay_state.keys); i++)
{
if (driver.overlay_state.keys[i] != old_key_state.keys[i])
{
uint32_t orig_bits = old_key_state.keys[i];
uint32_t new_bits = driver.overlay_state.keys[i];
for (j = 0; j < 32; j++)
if ((orig_bits & (1 << j)) != (new_bits & (1 << j)))
input_keyboard_event(new_bits & (1 << j), i * 32 + j, 0, key_mod);
}
}
/* Map "analog" buttons to analog axes like regular input drivers do. */
for (j = 0; j < 4; j++)
{
if (!driver.overlay_state.analog[j])
{
unsigned bind_plus = RARCH_ANALOG_LEFT_X_PLUS + 2 * j;
unsigned bind_minus = bind_plus + 1;
driver.overlay_state.analog[j] += (driver.overlay_state.buttons &
(1ULL << bind_plus)) ? 0x7fff : 0;
driver.overlay_state.analog[j] -= (driver.overlay_state.buttons &
(1ULL << bind_minus)) ? 0x7fff : 0;
}
}
/* Check for analog_dpad_mode.
* Map analogs to d-pad buttons when configured. */
switch (g_settings.input.analog_dpad_mode[0])
{
case ANALOG_DPAD_LSTICK:
case ANALOG_DPAD_RSTICK:
{
unsigned analog_base = g_settings.input.analog_dpad_mode[0] ==
ANALOG_DPAD_LSTICK ? 0 : 2;
float analog_x = (float)driver.overlay_state.analog[analog_base + 0] / 0x7fff;
float analog_y = (float)driver.overlay_state.analog[analog_base + 1] / 0x7fff;
driver.overlay_state.buttons |=
(analog_x <= -g_settings.input.axis_threshold) ?
(1ULL << RETRO_DEVICE_ID_JOYPAD_LEFT) : 0;
driver.overlay_state.buttons |=
(analog_x >= g_settings.input.axis_threshold) ?
(1ULL << RETRO_DEVICE_ID_JOYPAD_RIGHT) : 0;
driver.overlay_state.buttons |=
(analog_y <= -g_settings.input.axis_threshold) ?
(1ULL << RETRO_DEVICE_ID_JOYPAD_UP) : 0;
driver.overlay_state.buttons |=
(analog_y >= g_settings.input.axis_threshold) ?
(1ULL << RETRO_DEVICE_ID_JOYPAD_DOWN) : 0;
break;
}
default:
break;
}
if (polled)
input_overlay_post_poll(driver.overlay);
else
input_overlay_poll_clear(driver.overlay);
}
#endif
void rarch_input_poll(void)
{
driver.input->poll(driver.input_data);
#ifdef HAVE_OVERLAY
if (driver.overlay)
input_poll_overlay();
#endif
#ifdef HAVE_COMMAND
if (driver.command)
rarch_cmd_poll(driver.command);
#endif
}
#if !defined(_WIN32) && !defined(GLOBAL_CONFIG_DIR)
#if defined(__HAIKU__)
#define GLOBAL_CONFIG_DIR "/system/settings"
#else
#define GLOBAL_CONFIG_DIR "/etc"
#endif
#endif
#ifdef _WIN32
#define RARCH_DEFAULT_CONF_PATH_STR "\n\t\tDefaults to retroarch.cfg in same directory as retroarch.exe.\n\t\tIf a default config is not found, " RETRO_FRONTEND " will attempt to create one."
#else
#define RARCH_DEFAULT_CONF_PATH_STR "\n\t\tBy default looks for config in $XDG_CONFIG_HOME/retroarch/retroarch.cfg,\n\t\t$HOME/.config/retroarch/retroarch.cfg,\n\t\tand $HOME/.retroarch.cfg.\n\t\tIf a default config is not found," RETRO_FRONTEND " will attempt to create one based on the skeleton config (" GLOBAL_CONFIG_DIR "/retroarch.cfg)."
#endif
#include "config.features.h"
#define _PSUPP(var, name, desc) printf("\t%s:\n\t\t%s: %s\n", name, desc, _##var##_supp ? "yes" : "no")
static void print_features(void)
{
puts("");
puts("Features:");
_PSUPP(sdl, "SDL", "SDL drivers");
_PSUPP(sdl2, "SDL2", "SDL2 drivers");
_PSUPP(x11, "X11", "X11 drivers");
_PSUPP(wayland, "wayland", "Wayland drivers");
_PSUPP(thread, "Threads", "Threading support");
_PSUPP(opengl, "OpenGL", "OpenGL driver");
_PSUPP(kms, "KMS", "KMS/EGL context support");
_PSUPP(udev, "UDEV", "UDEV/EVDEV input driver support");
_PSUPP(egl, "EGL", "EGL context support");
_PSUPP(vg, "OpenVG", "OpenVG output support");
_PSUPP(xvideo, "XVideo", "XVideo output");
_PSUPP(alsa, "ALSA", "audio driver");
_PSUPP(oss, "OSS", "audio driver");
_PSUPP(jack, "Jack", "audio driver");
_PSUPP(rsound, "RSound", "audio driver");
_PSUPP(roar, "RoarAudio", "audio driver");
_PSUPP(pulse, "PulseAudio", "audio driver");
_PSUPP(dsound, "DirectSound", "audio driver");
_PSUPP(xaudio, "XAudio2", "audio driver");
_PSUPP(zlib, "zlib", "PNG encode/decode and .zip extraction");
_PSUPP(al, "OpenAL", "audio driver");
_PSUPP(dylib, "External", "External filter and plugin support");
_PSUPP(cg, "Cg", "Cg pixel shaders");
_PSUPP(libxml2, "libxml2", "libxml2 XML parsing");
_PSUPP(sdl_image, "SDL_image", "SDL_image image loading");
_PSUPP(fbo, "FBO", "OpenGL render-to-texture (multi-pass shaders)");
_PSUPP(dynamic, "Dynamic", "Dynamic run-time loading of libretro library");
_PSUPP(ffmpeg, "FFmpeg", "On-the-fly recording of gameplay with libavcodec");
_PSUPP(freetype, "FreeType", "TTF font rendering with FreeType");
_PSUPP(netplay, "Netplay", "Peer-to-peer netplay");
_PSUPP(python, "Python", "Script support in shaders");
}
#undef _PSUPP
static void print_compiler(FILE *file)
{
fprintf(file, "\nCompiler: ");
#if defined(_MSC_VER)
fprintf(file, "MSVC (%d) %u-bit\n", _MSC_VER, (unsigned)
(CHAR_BIT * sizeof(size_t)));
#elif defined(__SNC__)
fprintf(file, "SNC (%d) %u-bit\n",
__SN_VER__, (unsigned)(CHAR_BIT * sizeof(size_t)));
#elif defined(_WIN32) && defined(__GNUC__)
fprintf(file, "MinGW (%d.%d.%d) %u-bit\n",
__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__, (unsigned)
(CHAR_BIT * sizeof(size_t)));
#elif defined(__clang__)
fprintf(file, "Clang/LLVM (%s) %u-bit\n",
__clang_version__, (unsigned)(CHAR_BIT * sizeof(size_t)));
#elif defined(__GNUC__)
fprintf(file, "GCC (%d.%d.%d) %u-bit\n",
__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__, (unsigned)
(CHAR_BIT * sizeof(size_t)));
#else
fprintf(file, "Unknown compiler %u-bit\n",
(unsigned)(CHAR_BIT * sizeof(size_t)));
#endif
fprintf(file, "Built: %s\n", __DATE__);
}
static void print_help(void)
{
puts("===================================================================");
#ifdef HAVE_GIT_VERSION
printf(RETRO_FRONTEND ": Frontend for libretro -- v" PACKAGE_VERSION " -- %s --\n", rarch_git_version);
#else
puts(RETRO_FRONTEND ": Frontend for libretro -- v" PACKAGE_VERSION " --");
#endif
print_compiler(stdout);
puts("===================================================================");
puts("Usage: retroarch [content file] [options...]");
puts("\t-h/--help: Show this help message.");
puts("\t--menu: Do not require content or libretro core to be loaded, starts directly in menu.");
puts("\t\tIf no arguments are passed to " RETRO_FRONTEND ", it is equivalent to using --menu as only argument.");
puts("\t--features: Prints available features compiled into " RETRO_FRONTEND ".");
puts("\t-s/--save: Path for save file (*.srm).");
puts("\t-f/--fullscreen: Start " RETRO_FRONTEND " in fullscreen regardless of config settings.");
puts("\t-S/--savestate: Path to use for save states. If not selected, *.state will be assumed.");
puts("\t-c/--config: Path for config file." RARCH_DEFAULT_CONF_PATH_STR);
puts("\t--appendconfig: Extra config files are loaded in, and take priority over config selected in -c (or default).");
puts("\t\tMultiple configs are delimited by ','.");
#ifdef HAVE_DYNAMIC
puts("\t-L/--libretro: Path to libretro implementation. Overrides any config setting.");
#endif
puts("\t--subsystem: Use a subsystem of the libretro core. Multiple content files are loaded as multiple arguments.");
puts("\t\tIf a content file is skipped, use a blank (\"\") command line argument");
puts("\t\tContent must be loaded in an order which depends on the particular subsystem used.");
puts("\t\tSee verbose log output to learn how a particular subsystem wants content to be loaded.");
printf("\t-N/--nodevice: Disconnects controller device connected to port (1 to %d).\n", MAX_PLAYERS);
printf("\t-A/--dualanalog: Connect a DualAnalog controller to port (1 to %d).\n", MAX_PLAYERS);
printf("\t-d/--device: Connect a generic device into port of the device (1 to %d).\n", MAX_PLAYERS);
puts("\t\tFormat is port:ID, where ID is an unsigned number corresponding to the particular device.\n");
puts("\t-P/--bsvplay: Playback a BSV movie file.");
puts("\t-R/--bsvrecord: Start recording a BSV movie file from the beginning.");
puts("\t-M/--sram-mode: Takes an argument telling how SRAM should be handled in the session.");
puts("\t\t{no,}load-{no,}save describes if SRAM should be loaded, and if SRAM should be saved.");
puts("\t\tDo note that noload-save implies that save files will be deleted and overwritten.");
#ifdef HAVE_NETPLAY
puts("\t-H/--host: Host netplay as player 1.");
puts("\t-C/--connect: Connect to netplay as player 2.");
puts("\t--port: Port used to netplay. Default is 55435.");
puts("\t-F/--frames: Sync frames when using netplay.");
puts("\t--spectate: Netplay will become spectating mode.");
puts("\t\tHost can live stream the game content to players that connect.");
puts("\t\tHowever, the client will not be able to play. Multiple clients can connect to the host.");
#endif
puts("\t--nick: Picks a username (for use with netplay). Not mandatory.");
#if defined(HAVE_NETWORK_CMD) && defined(HAVE_NETPLAY)
puts("\t--command: Sends a command over UDP to an already running " RETRO_FRONTEND " process.");
puts("\t\tAvailable commands are listed if command is invalid.");
#endif
puts("\t-r/--record: Path to record video file.\n\t\tUsing .mkv extension is recommended.");
puts("\t--recordconfig: Path to settings used during recording.");
puts("\t--size: Overrides output video size when recording (format: WIDTHxHEIGHT).");
puts("\t-v/--verbose: Verbose logging.");
puts("\t-U/--ups: Specifies path for UPS patch that will be applied to content.");
puts("\t--bps: Specifies path for BPS patch that will be applied to content.");
puts("\t--ips: Specifies path for IPS patch that will be applied to content.");
puts("\t--no-patch: Disables all forms of content patching.");
puts("\t-D/--detach: Detach " RETRO_FRONTEND " from the running console. Not relevant for all platforms.\n");
}
static void set_basename(const char *path)
{
char *dst = NULL;
strlcpy(g_extern.fullpath, path, sizeof(g_extern.fullpath));
strlcpy(g_extern.basename, path, sizeof(g_extern.basename));
/* 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 dir then
* and the name of srm and states are meaningful.
*
*/
#ifdef HAVE_COMPRESSION
path_basedir(g_extern.basename);
fill_pathname_dir(g_extern.basename,path,"",sizeof(g_extern.basename));
#endif
if ((dst = strrchr(g_extern.basename, '.')))
*dst = '\0';
}
static void set_special_paths(char **argv, unsigned num_content)
{
unsigned i;
union string_list_elem_attr attr;
/* First content file is the significant one. */
set_basename(argv[0]);
g_extern.subsystem_fullpaths = string_list_new();
rarch_assert(g_extern.subsystem_fullpaths);
attr.i = 0;
for (i = 0; i < num_content; i++)
string_list_append(g_extern.subsystem_fullpaths, argv[i], attr);
/* We defer SRAM path updates until we can resolve it.
* It is more complicated for special content types. */
if (!g_extern.has_set_state_path)
fill_pathname_noext(g_extern.savestate_name, g_extern.basename,
".state", sizeof(g_extern.savestate_name));
if (path_is_directory(g_extern.savestate_name))
{
fill_pathname_dir(g_extern.savestate_name, g_extern.basename,
".state", sizeof(g_extern.savestate_name));
RARCH_LOG("Redirecting save state to \"%s\".\n",
g_extern.savestate_name);
}
/* If this is already set,
* do not overwrite it as this was initialized before in
* a menu or otherwise. */
if (!*g_settings.system_directory)
fill_pathname_basedir(g_settings.system_directory, argv[0],
sizeof(g_settings.system_directory));
}
static void set_paths(const char *path)
{
set_basename(path);
if (!g_extern.has_set_save_path)
fill_pathname_noext(g_extern.savefile_name, g_extern.basename,
".srm", sizeof(g_extern.savefile_name));
if (!g_extern.has_set_state_path)
fill_pathname_noext(g_extern.savestate_name, g_extern.basename,
".state", sizeof(g_extern.savestate_name));
if (path_is_directory(g_extern.savefile_name))
{
fill_pathname_dir(g_extern.savefile_name, g_extern.basename,
".srm", sizeof(g_extern.savefile_name));
RARCH_LOG("Redirecting save file to \"%s\".\n", g_extern.savefile_name);
}
if (path_is_directory(g_extern.savestate_name))
{
fill_pathname_dir(g_extern.savestate_name, g_extern.basename,
".state", sizeof(g_extern.savestate_name));
RARCH_LOG("Redirecting save state to \"%s\".\n", g_extern.savestate_name);
}
/* If this is already set, do not overwrite it
* as this was initialized before in a menu or otherwise. */
if (!*g_settings.system_directory)
fill_pathname_basedir(g_settings.system_directory, path,
sizeof(g_settings.system_directory));
}
static void parse_input(int argc, char *argv[])
{
g_extern.libretro_no_content = false;
g_extern.libretro_dummy = false;
g_extern.has_set_save_path = false;
g_extern.has_set_state_path = false;
g_extern.has_set_libretro = false;
g_extern.has_set_libretro_directory = false;
g_extern.has_set_verbosity = false;
g_extern.has_set_netplay_mode = false;
g_extern.has_set_username = false;
g_extern.has_set_netplay_ip_address = false;
g_extern.has_set_netplay_delay_frames = false;
g_extern.has_set_netplay_ip_port = false;
g_extern.ups_pref = false;
g_extern.bps_pref = false;
g_extern.ips_pref = false;
*g_extern.ups_name = '\0';
*g_extern.bps_name = '\0';
*g_extern.ips_name = '\0';
*g_extern.subsystem = '\0';
if (argc < 2)
{
g_extern.libretro_dummy = true;
return;
}
/* Make sure we can call parse_input several times ... */
optind = 0;
int val = 0;
const struct option opts[] = {
#ifdef HAVE_DYNAMIC
{ "libretro", 1, NULL, 'L' },
#endif
{ "menu", 0, &val, 'M' },
{ "help", 0, NULL, 'h' },
{ "save", 1, NULL, 's' },
{ "fullscreen", 0, NULL, 'f' },
{ "record", 1, NULL, 'r' },
{ "recordconfig", 1, &val, 'R' },
{ "size", 1, &val, 's' },
{ "verbose", 0, NULL, 'v' },
{ "config", 1, NULL, 'c' },
{ "appendconfig", 1, &val, 'C' },
{ "nodevice", 1, NULL, 'N' },
{ "dualanalog", 1, NULL, 'A' },
{ "device", 1, NULL, 'd' },
{ "savestate", 1, NULL, 'S' },
{ "bsvplay", 1, NULL, 'P' },
{ "bsvrecord", 1, NULL, 'R' },
{ "sram-mode", 1, NULL, 'M' },
#ifdef HAVE_NETPLAY
{ "host", 0, NULL, 'H' },
{ "connect", 1, NULL, 'C' },
{ "frames", 1, NULL, 'F' },
{ "port", 1, &val, 'p' },
{ "spectate", 0, &val, 'S' },
#endif
{ "nick", 1, &val, 'N' },
#if defined(HAVE_NETWORK_CMD) && defined(HAVE_NETPLAY)
{ "command", 1, &val, 'c' },
#endif
{ "ups", 1, NULL, 'U' },
{ "bps", 1, &val, 'B' },
{ "ips", 1, &val, 'I' },
{ "no-patch", 0, &val, 'n' },
{ "detach", 0, NULL, 'D' },
{ "features", 0, &val, 'f' },
{ "subsystem", 1, NULL, 'Z' },
{ NULL, 0, NULL, 0 }
};
#define FFMPEG_RECORD_ARG "r:"
#ifdef HAVE_DYNAMIC
#define DYNAMIC_ARG "L:"
#else
#define DYNAMIC_ARG
#endif
#ifdef HAVE_NETPLAY
#define NETPLAY_ARG "HC:F:"
#else
#define NETPLAY_ARG
#endif
#define BSV_MOVIE_ARG "P:R:M:"
const char *optstring = "hs:fvS:A:c:U:DN:d:" BSV_MOVIE_ARG NETPLAY_ARG DYNAMIC_ARG FFMPEG_RECORD_ARG;
for (;;)
{
val = 0;
int c = getopt_long(argc, argv, optstring, opts, NULL);
int port;
if (c == -1)
break;
switch (c)
{
case 'h':
print_help();
exit(0);
case 'Z':
strlcpy(g_extern.subsystem, optarg, sizeof(g_extern.subsystem));
break;
case 'd':
{
unsigned id = 0;
port = 0;
struct string_list *list = string_split(optarg, ":");
if (list && list->size == 2)
{
port = strtol(list->elems[0].data, NULL, 0);
id = strtoul(list->elems[1].data, NULL, 0);
}
string_list_free(list);
if (port < 1 || port > MAX_PLAYERS)
{
RARCH_ERR("Connect device to a valid port.\n");
print_help();
rarch_fail(1, "parse_input()");
}
g_settings.input.libretro_device[port - 1] = id;
g_extern.has_set_libretro_device[port - 1] = true;
break;
}
case 'A':
port = strtol(optarg, NULL, 0);
if (port < 1 || port > MAX_PLAYERS)
{
RARCH_ERR("Connect dualanalog to a valid port.\n");
print_help();
rarch_fail(1, "parse_input()");
}
g_settings.input.libretro_device[port - 1] = RETRO_DEVICE_ANALOG;
g_extern.has_set_libretro_device[port - 1] = true;
break;
case 's':
strlcpy(g_extern.savefile_name, optarg,
sizeof(g_extern.savefile_name));
g_extern.has_set_save_path = true;
break;
case 'f':
g_extern.force_fullscreen = true;
break;
case 'S':
strlcpy(g_extern.savestate_name, optarg,
sizeof(g_extern.savestate_name));
g_extern.has_set_state_path = true;
break;
case 'v':
g_extern.verbosity = true;
g_extern.has_set_verbosity = true;
break;
case 'N':
port = strtol(optarg, NULL, 0);
if (port < 1 || port > MAX_PLAYERS)
{
RARCH_ERR("Disconnect device from a valid port.\n");
print_help();
rarch_fail(1, "parse_input()");
}
g_settings.input.libretro_device[port - 1] = RETRO_DEVICE_NONE;
g_extern.has_set_libretro_device[port - 1] = true;
break;
case 'c':
strlcpy(g_extern.config_path, optarg,
sizeof(g_extern.config_path));
break;
case 'r':
strlcpy(g_extern.record_path, optarg,
sizeof(g_extern.record_path));
g_extern.recording_enable = true;
break;
#ifdef HAVE_DYNAMIC
case 'L':
if (path_is_directory(optarg))
{
*g_settings.libretro = '\0';
strlcpy(g_settings.libretro_directory, optarg,
sizeof(g_settings.libretro_directory));
g_extern.has_set_libretro = true;
g_extern.has_set_libretro_directory = true;
RARCH_WARN("Using old --libretro behavior. Setting libretro_directory to \"%s\" instead.\n", optarg);
}
else
{
strlcpy(g_settings.libretro, optarg,
sizeof(g_settings.libretro));
g_extern.has_set_libretro = true;
}
break;
#endif
case 'P':
case 'R':
strlcpy(g_extern.bsv.movie_start_path, optarg,
sizeof(g_extern.bsv.movie_start_path));
g_extern.bsv.movie_start_playback = (c == 'P');
g_extern.bsv.movie_start_recording = (c == 'R');
break;
case 'M':
if (strcmp(optarg, "noload-nosave") == 0)
{
g_extern.sram_load_disable = true;
g_extern.sram_save_disable = true;
}
else if (strcmp(optarg, "noload-save") == 0)
g_extern.sram_load_disable = true;
else if (strcmp(optarg, "load-nosave") == 0)
g_extern.sram_save_disable = true;
else if (strcmp(optarg, "load-save") != 0)
{
RARCH_ERR("Invalid argument in --sram-mode.\n");
print_help();
rarch_fail(1, "parse_input()");
}
break;
#ifdef HAVE_NETPLAY
case 'H':
g_extern.has_set_netplay_ip_address = true;
g_extern.netplay_enable = true;
*g_extern.netplay_server = '\0';
break;
case 'C':
g_extern.has_set_netplay_ip_address = true;
g_extern.netplay_enable = true;
strlcpy(g_extern.netplay_server, optarg,
sizeof(g_extern.netplay_server));
break;
case 'F':
g_extern.netplay_sync_frames = strtol(optarg, NULL, 0);
g_extern.has_set_netplay_delay_frames = true;
break;
#endif
case 'U':
strlcpy(g_extern.ups_name, optarg,
sizeof(g_extern.ups_name));
g_extern.ups_pref = true;
break;
case 'D':
#if defined(_WIN32) && !defined(_XBOX)
FreeConsole();
#endif
break;
case 0:
switch (val)
{
case 'M':
g_extern.libretro_dummy = true;
break;
#ifdef HAVE_NETPLAY
case 'p':
g_extern.has_set_netplay_ip_port = true;
g_extern.netplay_port = strtoul(optarg, NULL, 0);
break;
case 'S':
g_extern.has_set_netplay_mode = true;
g_extern.netplay_is_spectate = true;
break;
#endif
case 'N':
g_extern.has_set_username = true;
strlcpy(g_settings.username, optarg,
sizeof(g_settings.username));
break;
#if defined(HAVE_NETWORK_CMD) && defined(HAVE_NETPLAY)
case 'c':
if (network_cmd_send(optarg))
exit(0);
else
rarch_fail(1, "network_cmd_send()");
break;
#endif
case 'C':
strlcpy(g_extern.append_config_path, optarg,
sizeof(g_extern.append_config_path));
break;
case 'B':
strlcpy(g_extern.bps_name, optarg,
sizeof(g_extern.bps_name));
g_extern.bps_pref = true;
break;
case 'I':
strlcpy(g_extern.ips_name, optarg,
sizeof(g_extern.ips_name));
g_extern.ips_pref = true;
break;
case 'n':
g_extern.block_patch = true;
break;
case 's':
{
if (sscanf(optarg, "%ux%u", &g_extern.record_width,
&g_extern.record_height) != 2)
{
RARCH_ERR("Wrong format for --size.\n");
print_help();
rarch_fail(1, "parse_input()");
}
break;
}
case 'R':
strlcpy(g_extern.record_config, optarg,
sizeof(g_extern.record_config));
break;
case 'f':
print_features();
exit(0);
default:
break;
}
break;
case '?':
print_help();
rarch_fail(1, "parse_input()");
default:
RARCH_ERR("Error parsing arguments.\n");
rarch_fail(1, "parse_input()");
}
}
if (g_extern.libretro_dummy)
{
if (optind < argc)
{
RARCH_ERR("--menu was used, but content file was passed as well.\n");
rarch_fail(1, "parse_input()");
}
}
else if (!*g_extern.subsystem && optind < argc)
set_paths(argv[optind]);
else if (*g_extern.subsystem && optind < argc)
set_special_paths(argv + optind, argc - optind);
else
g_extern.libretro_no_content = true;
/* Copy SRM/state dirs used, so they can be reused on reentrancy. */
if (g_extern.has_set_save_path &&
path_is_directory(g_extern.savefile_name))
strlcpy(g_extern.savefile_dir, g_extern.savefile_name,
sizeof(g_extern.savefile_dir));
if (g_extern.has_set_state_path &&
path_is_directory(g_extern.savestate_name))
strlcpy(g_extern.savestate_dir, g_extern.savestate_name,
sizeof(g_extern.savestate_dir));
}
static void init_controllers(void)
{
unsigned i;
for (i = 0; i < MAX_PLAYERS; i++)
{
unsigned device = g_settings.input.libretro_device[i];
const struct retro_controller_description *desc = NULL;
const char *ident = NULL;
if (i < g_extern.system.num_ports)
desc = libretro_find_controller_description(
&g_extern.system.ports[i], device);
if (desc)
ident = desc->desc;
if (!ident)
{
/* If we're trying to connect a completely unknown device,
* revert back to JOYPAD. */
if (device != RETRO_DEVICE_JOYPAD && device != RETRO_DEVICE_NONE)
{
/* Do not fix g_settings.input.libretro_device[i],
* because any use of dummy core will reset this,
* which is not a good idea. */
RARCH_WARN("Input device ID %u is unknown to this libretro implementation. Using RETRO_DEVICE_JOYPAD.\n", device);
device = RETRO_DEVICE_JOYPAD;
}
ident = "Joypad";
}
if (device == RETRO_DEVICE_NONE)
{
RARCH_LOG("Disconnecting device from port %u.\n", i + 1);
pretro_set_controller_port_device(i, device);
}
else if (device != RETRO_DEVICE_JOYPAD)
{
/* Some cores do not properly range check port argument.
* This is broken behavior of course, but avoid breaking
* cores needlessly. */
RARCH_LOG("Connecting %s (ID: %u) to port %u.\n", ident,
device, i + 1);
pretro_set_controller_port_device(i, device);
}
}
}
static inline bool load_save_files(void)
{
unsigned i;
if (!g_extern.savefiles || g_extern.sram_load_disable)
return false;
for (i = 0; i < g_extern.savefiles->size; i++)
load_ram_file(g_extern.savefiles->elems[i].data,
g_extern.savefiles->elems[i].attr.i);
return true;
}
static inline bool save_files(void)
{
unsigned i;
if (!g_extern.savefiles || !g_extern.use_sram)
return false;
for (i = 0; i < g_extern.savefiles->size; i++)
{
unsigned type = g_extern.savefiles->elems[i].attr.i;
const char *path = g_extern.savefiles->elems[i].data;
RARCH_LOG("Saving RAM type #%u to \"%s\".\n", type, path);
save_ram_file(path, type);
}
return true;
}
static void init_msg_queue(void)
{
if (!g_extern.msg_queue)
rarch_assert(g_extern.msg_queue = msg_queue_new(8));
}
void rarch_deinit_msg_queue(void)
{
if (g_extern.msg_queue)
msg_queue_free(g_extern.msg_queue);
g_extern.msg_queue = NULL;
}
static void init_cheats(void)
{
bool allow_cheats = true;
#ifdef HAVE_NETPLAY
allow_cheats &= !g_extern.netplay;
#endif
allow_cheats &= !g_extern.bsv.movie;
if (!allow_cheats)
return;
if (*g_settings.cheat_database)
g_extern.cheat = cheat_manager_new(g_settings.cheat_database);
}
static void deinit_cheats(void)
{
if (g_extern.cheat)
cheat_manager_free(g_extern.cheat);
g_extern.cheat = NULL;
}
static void init_rewind(void)
{
void *state = NULL;
#ifdef HAVE_NETPLAY
if (g_extern.netplay)
return;
#endif
if (!g_settings.rewind_enable || g_extern.state_manager)
return;
if (g_extern.system.audio_callback.callback)
{
RARCH_ERR(RETRO_LOG_REWIND_INIT_FAILED_THREADED_AUDIO);
return;
}
g_extern.state_size = pretro_serialize_size();
if (!g_extern.state_size)
{
RARCH_ERR(RETRO_LOG_REWIND_INIT_FAILED_NO_SAVESTATES);
return;
}
RARCH_LOG(RETRO_MSG_REWIND_INIT "%u MB\n",
(unsigned)(g_settings.rewind_buffer_size / 1000000));
g_extern.state_manager = state_manager_new(g_extern.state_size,
g_settings.rewind_buffer_size);
if (!g_extern.state_manager)
RARCH_WARN(RETRO_LOG_REWIND_INIT_FAILED);
state_manager_push_where(g_extern.state_manager, &state);
pretro_serialize(state, g_extern.state_size);
state_manager_push_do(g_extern.state_manager);
}
static void deinit_rewind(void)
{
#ifdef HAVE_NETPLAY
if (g_extern.netplay)
return;
#endif
if (g_extern.state_manager)
state_manager_free(g_extern.state_manager);
g_extern.state_manager = NULL;
}
static void init_movie(void)
{
if (g_extern.bsv.movie_start_playback)
{
if (!(g_extern.bsv.movie = bsv_movie_init(g_extern.bsv.movie_start_path,
RARCH_MOVIE_PLAYBACK)))
{
RARCH_ERR("Failed to load movie file: \"%s\".\n",
g_extern.bsv.movie_start_path);
rarch_fail(1, "init_movie()");
}
g_extern.bsv.movie_playback = true;
msg_queue_push(g_extern.msg_queue, "Starting movie playback.", 2, 180);
RARCH_LOG("Starting movie playback.\n");
g_settings.rewind_granularity = 1;
}
else if (g_extern.bsv.movie_start_recording)
{
char msg[PATH_MAX];
snprintf(msg, sizeof(msg), "Starting movie record to \"%s\".",
g_extern.bsv.movie_start_path);
msg_queue_clear(g_extern.msg_queue);
if ((g_extern.bsv.movie = bsv_movie_init(g_extern.bsv.movie_start_path,
RARCH_MOVIE_RECORD)))
{
msg_queue_push(g_extern.msg_queue, msg, 1, 180);
RARCH_LOG("Starting movie record to \"%s\".\n",
g_extern.bsv.movie_start_path);
g_settings.rewind_granularity = 1;
}
else
{
msg_queue_push(g_extern.msg_queue, "Failed to start movie record.", 1, 180);
RARCH_ERR("Failed to start movie record.\n");
}
}
}
static void deinit_movie(void)
{
if (g_extern.bsv.movie)
bsv_movie_free(g_extern.bsv.movie);
g_extern.bsv.movie = NULL;
}
#define RARCH_DEFAULT_PORT 55435
#ifdef HAVE_NETPLAY
static void init_netplay(void)
{
struct retro_callbacks cbs = {0};
if (!g_extern.netplay_enable)
return;
if (g_extern.bsv.movie_start_playback)
{
RARCH_WARN(RETRO_LOG_MOVIE_STARTED_INIT_NETPLAY_FAILED);
return;
}
retro_set_default_callbacks(&cbs);
if (*g_extern.netplay_server)
{
RARCH_LOG("Connecting to netplay host...\n");
g_extern.netplay_is_client = true;
}
else
RARCH_LOG("Waiting for client...\n");
g_extern.netplay = netplay_new(
g_extern.netplay_is_client ? g_extern.netplay_server : NULL,
g_extern.netplay_port ? g_extern.netplay_port : RARCH_DEFAULT_PORT,
g_extern.netplay_sync_frames, &cbs, g_extern.netplay_is_spectate,
g_settings.username);
if (!g_extern.netplay)
{
g_extern.netplay_is_client = false;
RARCH_WARN(RETRO_LOG_INIT_NETPLAY_FAILED);
if (g_extern.msg_queue)
msg_queue_push(g_extern.msg_queue,
RETRO_MSG_INIT_NETPLAY_FAILED,
0, 180);
}
}
static void deinit_netplay(void)
{
if (g_extern.netplay)
netplay_free(g_extern.netplay);
g_extern.netplay = NULL;
}
#endif
#ifdef HAVE_COMMAND
static void init_command(void)
{
if (!g_settings.stdin_cmd_enable && !g_settings.network_cmd_enable)
return;
if (g_settings.stdin_cmd_enable && driver.stdin_claimed)
{
RARCH_WARN("stdin command interface is desired, but input driver has already claimed stdin.\n"
"Cannot use this command interface.\n");
}
if (!(driver.command = rarch_cmd_new(g_settings.stdin_cmd_enable
&& !driver.stdin_claimed,
g_settings.network_cmd_enable, g_settings.network_cmd_port)))
RARCH_ERR("Failed to initialize command interface.\n");
}
static void deinit_command(void)
{
if (driver.command)
rarch_cmd_free(driver.command);
driver.command = NULL;
}
#endif
#if defined(HAVE_THREADS)
static void init_autosave(void)
{
unsigned i;
if (g_settings.autosave_interval < 1 || !g_extern.savefiles)
return;
if (!(g_extern.autosave = (autosave_t**)calloc(g_extern.savefiles->size,
sizeof(*g_extern.autosave))))
return;
g_extern.num_autosave = g_extern.savefiles->size;
for (i = 0; i < g_extern.savefiles->size; i++)
{
const char *path = g_extern.savefiles->elems[i].data;
unsigned type = g_extern.savefiles->elems[i].attr.i;
if (pretro_get_memory_size(type) > 0)
{
g_extern.autosave[i] = autosave_new(path,
pretro_get_memory_data(type),
pretro_get_memory_size(type),
g_settings.autosave_interval);
if (!g_extern.autosave[i])
RARCH_WARN(RETRO_LOG_INIT_AUTOSAVE_FAILED);
}
}
}
static void deinit_autosave(void)
{
unsigned i;
for (i = 0; i < g_extern.num_autosave; i++)
autosave_free(g_extern.autosave[i]);
if (g_extern.autosave)
free(g_extern.autosave);
g_extern.autosave = NULL;
g_extern.num_autosave = 0;
}
#endif
static void set_savestate_auto_index(void)
{
char state_dir[PATH_MAX], state_base[PATH_MAX];
size_t i;
struct string_list *dir_list = NULL;
unsigned max_index = 0;
if (!g_settings.savestate_auto_index)
return;
/* Find the file in the same directory as g_extern.savestate_name
* with the largest numeral suffix.
*
* E.g. /foo/path/content.state, will try to find
* /foo/path/content.state%d, where %d is the largest number available.
*/
fill_pathname_basedir(state_dir, g_extern.savestate_name,
sizeof(state_dir));
fill_pathname_base(state_base, g_extern.savestate_name,
sizeof(state_base));
if (!(dir_list = dir_list_new(state_dir, NULL, false)))
return;
for (i = 0; i < dir_list->size; i++)
{
char elem_base[PATH_MAX];
const char *dir_elem = dir_list->elems[i].data;
fill_pathname_base(elem_base, dir_elem, sizeof(elem_base));
if (strstr(elem_base, state_base) != elem_base)
continue;
const char *end = dir_elem + strlen(dir_elem);
while ((end > dir_elem) && isdigit(end[-1])) end--;
unsigned index = strtoul(end, NULL, 0);
if (index > max_index)
max_index = index;
}
dir_list_free(dir_list);
g_settings.state_slot = max_index;
RARCH_LOG("Found last state slot: #%d\n", g_settings.state_slot);
}
static void deinit_savefiles(void)
{
if (g_extern.savefiles)
string_list_free(g_extern.savefiles);
g_extern.savefiles = NULL;
}
static void fill_pathnames(void)
{
deinit_savefiles();
g_extern.savefiles = string_list_new();
rarch_assert(g_extern.savefiles);
if (*g_extern.subsystem)
{
/* For subsystems, we know exactly which RAM types are supported. */
unsigned i, j;
const struct retro_subsystem_info *info =
(const struct retro_subsystem_info*)libretro_find_subsystem_info(
g_extern.system.special, g_extern.system.num_special,
g_extern.subsystem);
/* We'll handle this error gracefully later. */
unsigned num_content = min(info ? info->num_roms : 0,
g_extern.subsystem_fullpaths ?
g_extern.subsystem_fullpaths->size : 0);
bool use_sram_dir = path_is_directory(g_extern.savefile_name);
for (i = 0; i < num_content; i++)
{
for (j = 0; j < info->roms[i].num_memory; j++)
{
union string_list_elem_attr attr;
char path[PATH_MAX], ext[32];
const struct retro_subsystem_memory_info *mem =
(const struct retro_subsystem_memory_info*)
&info->roms[i].memory[j];
snprintf(ext, sizeof(ext), ".%s", mem->extension);
if (use_sram_dir)
{
/* Redirect content fullpath to save directory. */
strlcpy(path, g_extern.savefile_name, sizeof(path));
fill_pathname_dir(path,
g_extern.subsystem_fullpaths->elems[i].data, ext,
sizeof(path));
}
else
{
fill_pathname(path, g_extern.subsystem_fullpaths->elems[i].data,
ext, sizeof(path));
}
attr.i = mem->type;
string_list_append(g_extern.savefiles, path, attr);
}
}
/* Let other relevant paths be inferred from the main SRAM location. */
if (!g_extern.has_set_save_path)
fill_pathname_noext(g_extern.savefile_name, g_extern.basename, ".srm",
sizeof(g_extern.savefile_name));
if (path_is_directory(g_extern.savefile_name))
{
fill_pathname_dir(g_extern.savefile_name, g_extern.basename, ".srm",
sizeof(g_extern.savefile_name));
RARCH_LOG("Redirecting save file to \"%s\".\n",
g_extern.savefile_name);
}
}
else
{
char savefile_name_rtc[PATH_MAX];
union string_list_elem_attr attr;
attr.i = RETRO_MEMORY_SAVE_RAM;
string_list_append(g_extern.savefiles, g_extern.savefile_name, attr);
/* Infer .rtc save path from save ram path. */
attr.i = RETRO_MEMORY_RTC;
fill_pathname(savefile_name_rtc,
g_extern.savefile_name, ".rtc", sizeof(savefile_name_rtc));
string_list_append(g_extern.savefiles, savefile_name_rtc, attr);
}
fill_pathname(g_extern.bsv.movie_path, g_extern.savefile_name, "",
sizeof(g_extern.bsv.movie_path));
if (*g_extern.basename)
{
if (!*g_extern.ups_name)
fill_pathname_noext(g_extern.ups_name, g_extern.basename, ".ups",
sizeof(g_extern.ups_name));
if (!*g_extern.bps_name)
fill_pathname_noext(g_extern.bps_name, g_extern.basename, ".bps",
sizeof(g_extern.bps_name));
if (!*g_extern.ips_name)
fill_pathname_noext(g_extern.ips_name, g_extern.basename, ".ips",
sizeof(g_extern.ips_name));
}
}
static void load_auto_state(void)
{
char savestate_name_auto[PATH_MAX];
#ifdef HAVE_NETPLAY
if (g_extern.netplay_enable && !g_extern.netplay_is_spectate)
return;
#endif
if (!g_settings.savestate_auto_load)
return;
fill_pathname_noext(savestate_name_auto, g_extern.savestate_name,
".auto", sizeof(savestate_name_auto));
if (path_file_exists(savestate_name_auto))
{
char msg[PATH_MAX];
bool ret = load_state(savestate_name_auto);
RARCH_LOG("Found auto savestate in: %s\n", savestate_name_auto);
snprintf(msg, sizeof(msg), "Auto-loading savestate from \"%s\" %s.",
savestate_name_auto, ret ? "succeeded" : "failed");
msg_queue_push(g_extern.msg_queue, msg, 1, 180);
RARCH_LOG("%s\n", msg);
}
}
static bool save_auto_state(void)
{
char savestate_name_auto[PATH_MAX];
if (!g_settings.savestate_auto_save || g_extern.libretro_dummy ||
g_extern.libretro_no_content)
return false;
fill_pathname_noext(savestate_name_auto, g_extern.savestate_name,
".auto", sizeof(savestate_name_auto));
bool ret = save_state(savestate_name_auto);
RARCH_LOG("Auto save state to \"%s\" %s.\n", savestate_name_auto, ret ?
"succeeded" : "failed");
return true;
}
/* Save or load state here. */
static void rarch_load_state(const char *path,
char *msg, size_t sizeof_msg)
{
if (load_state(path))
{
if (g_settings.state_slot < 0)
snprintf(msg, sizeof_msg,
"Loaded state from slot #-1 (auto).");
else
snprintf(msg, sizeof_msg,
"Loaded state from slot #%d.", g_settings.state_slot);
}
else
snprintf(msg, sizeof_msg,
"Failed to load state from \"%s\".", path);
}
static void rarch_save_state(const char *path,
char *msg, size_t sizeof_msg)
{
if (save_state(path))
{
if (g_settings.state_slot < 0)
snprintf(msg, sizeof_msg,
"Saved state to slot #-1 (auto).");
else
snprintf(msg, sizeof_msg,
"Saved state to slot #%d.", g_settings.state_slot);
}
else
snprintf(msg, sizeof_msg,
"Failed to save state to \"%s\".", path);
}
static void main_state(unsigned cmd)
{
char path[PATH_MAX], msg[PATH_MAX];
if (g_settings.state_slot > 0)
snprintf(path, sizeof(path), "%s%d",
g_extern.savestate_name, g_settings.state_slot);
else if (g_settings.state_slot < 0)
snprintf(path, sizeof(path), "%s.auto",
g_extern.savestate_name);
else
strlcpy(path, g_extern.savestate_name, sizeof(path));
if (pretro_serialize_size())
{
if (cmd == RARCH_CMD_SAVE_STATE)
rarch_save_state(path, msg, sizeof(msg));
else if (cmd == RARCH_CMD_LOAD_STATE)
rarch_load_state(path, msg, sizeof(msg));
}
else
strlcpy(msg, "Core does not support save states.", sizeof(msg));
msg_queue_clear(g_extern.msg_queue);
msg_queue_push(g_extern.msg_queue, msg, 2, 180);
RARCH_LOG("%s\n", msg);
}
static void set_fullscreen(bool fullscreen)
{
g_settings.video.fullscreen = fullscreen;
driver.video_cache_context =
g_extern.system.hw_render_callback.cache_context;
driver.video_cache_context_ack = false;
rarch_main_command(RARCH_CMD_RESET_CONTEXT);
driver.video_cache_context = false;
/* Poll input to avoid possibly stale data to corrupt things. */
driver.input->poll(driver.input_data);
}
bool rarch_check_fullscreen(bool pressed)
{
if (pressed)
{
/* If we go fullscreen we drop all drivers and
* reinitialize to be safe. */
g_settings.video.fullscreen = !g_settings.video.fullscreen;
rarch_main_command(RARCH_CMD_REINIT);
}
return pressed;
}
static void state_slot(void)
{
char msg[PATH_MAX];
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 void check_stateslots(
bool pressed_increase, bool pressed_decrease)
{
/* Save state slots */
if (pressed_increase)
{
g_settings.state_slot++;
state_slot();
}
if (pressed_decrease)
{
if (g_settings.state_slot > 0)
g_settings.state_slot--;
state_slot();
}
}
static inline void flush_rewind_audio(void)
{
/* We just rewound. Flush rewind audio buffer. */
g_extern.audio_active = rarch_audio_flush(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.audio_active;
g_extern.frame_is_reverse = false;
}
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)
flush_rewind_audio();
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);
deinit_movie();
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);
deinit_movie();
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_pause(bool pressed, bool frameadvance_pressed)
{
static bool old_focus = true;
bool focus = true;
bool has_set_audio_stop = false;
bool has_set_audio_start = false;
/* 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)
{
g_extern.is_paused = !g_extern.is_paused;
if (g_extern.is_paused)
{
RARCH_LOG("Paused.\n");
has_set_audio_stop = true;
}
else
{
RARCH_LOG("Unpaused.\n");
has_set_audio_start = true;
}
}
else if (focus && !old_focus)
{
RARCH_LOG("Unpaused.\n");
g_extern.is_paused = false;
has_set_audio_start = true;
}
else if (!focus && old_focus)
{
RARCH_LOG("Paused.\n");
g_extern.is_paused = true;
has_set_audio_stop = true;
}
if (has_set_audio_stop)
rarch_main_command(RARCH_CMD_AUDIO_STOP);
if (has_set_audio_start)
rarch_main_command(RARCH_CMD_AUDIO_START);
if (g_extern.is_paused && g_settings.video.black_frame_insertion)
rarch_render_cached_frame();
old_focus = focus;
}
static void check_oneshot(
bool oneshot_pressed,
bool rewind_pressed)
{
/* Rewind buttons works like FRAMEREWIND when paused.
* We will one-shot in that case. */
g_extern.is_oneshot = oneshot_pressed | rewind_pressed;
}
static void check_turbo(void)
{
unsigned i;
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],
};
g_extern.turbo_count++;
if (driver.block_libretro_input)
{
memset(g_extern.turbo_frame_enable, 0,
sizeof(g_extern.turbo_frame_enable));
return;
}
for (i = 0; i < MAX_PLAYERS; i++)
g_extern.turbo_frame_enable[i] =
driver.input->input_state(driver.input_data, binds, i,
RETRO_DEVICE_JOYPAD, 0, RARCH_TURBO_ENABLE);
}
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;
bool should_apply = false;
if (!g_extern.shader_dir.list || !driver.video->set_shader)
return;
if (pressed_next)
{
should_apply = true;
g_extern.shader_dir.ptr = (g_extern.shader_dir.ptr + 1) %
g_extern.shader_dir.list->size;
}
else if (pressed_prev)
{
should_apply = true;
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--;
}
if (!should_apply)
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;
if (type == RARCH_SHADER_NONE)
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");
}
}
void rarch_disk_control_append_image(const char *path)
{
char msg[PATH_MAX];
unsigned new_index;
const struct retro_disk_control_callback *control =
(const struct retro_disk_control_callback*)&g_extern.system.disk_control;
struct retro_game_info info = {0};
rarch_disk_control_set_eject(true, false);
control->add_image_index();
new_index = control->get_num_images();
if (!new_index)
return;
new_index--;
info.path = path;
control->replace_image_index(new_index, &info);
rarch_disk_control_set_index(new_index);
snprintf(msg, sizeof(msg), "Appended disk: %s", path);
RARCH_LOG("%s\n", msg);
msg_queue_clear(g_extern.msg_queue);
msg_queue_push(g_extern.msg_queue, msg, 0, 180);
#if defined(HAVE_THREADS)
deinit_autosave();
#endif
/* TODO: Need to figure out what to do with subsystems case. */
if (!*g_extern.subsystem)
{
/* Update paths for our new image.
* If we actually use append_image, we assume that we
* started out in a single disk case, and that this way
* of doing it makes the most sense. */
set_paths(path);
fill_pathnames();
}
#if defined(HAVE_THREADS)
init_autosave();
#endif
rarch_disk_control_set_eject(false, false);
}
void rarch_disk_control_set_eject(bool new_state, bool log)
{
char msg[PATH_MAX];
const struct retro_disk_control_callback *control =
(const struct retro_disk_control_callback*)&g_extern.system.disk_control;
bool error = false;
if (!control->get_num_images)
return;
*msg = '\0';
if (control->set_eject_state(new_state))
snprintf(msg, sizeof(msg), "%s virtual disk tray.",
new_state ? "Ejected" : "Closed");
else
{
error = true;
snprintf(msg, sizeof(msg), "Failed to %s virtual disk tray.",
new_state ? "eject" : "close");
}
if (*msg)
{
if (error)
RARCH_ERR("%s\n", msg);
else
RARCH_LOG("%s\n", msg);
/* Only noise in menu. */
if (log)
{
msg_queue_clear(g_extern.msg_queue);
msg_queue_push(g_extern.msg_queue, msg, 1, 180);
}
}
}
void rarch_disk_control_set_index(unsigned next_index)
{
char msg[PATH_MAX];
unsigned num_disks;
const struct retro_disk_control_callback *control =
(const struct retro_disk_control_callback*)&g_extern.system.disk_control;
bool error = false;
if (!control->get_num_images)
return;
*msg = '\0';
num_disks = control->get_num_images();
if (control->set_image_index(next_index))
{
if (next_index < num_disks)
snprintf(msg, sizeof(msg), "Setting disk %u of %u in tray.",
next_index + 1, num_disks);
else
strlcpy(msg, "Removed disk from tray.", sizeof(msg));
}
else
{
if (next_index < num_disks)
snprintf(msg, sizeof(msg), "Failed to set disk %u of %u.",
next_index + 1, num_disks);
else
strlcpy(msg, "Failed to remove disk from tray.", sizeof(msg));
error = true;
}
if (*msg)
{
if (error)
RARCH_ERR("%s\n", msg);
else
RARCH_LOG("%s\n", msg);
msg_queue_clear(g_extern.msg_queue);
msg_queue_push(g_extern.msg_queue, msg, 1, 180);
}
}
static void check_mute(void)
{
const char *msg = !g_extern.audio_data.mute ?
"Audio muted." : "Audio unmuted.";
g_extern.audio_data.mute = !g_extern.audio_data.mute;
msg_queue_clear(g_extern.msg_queue);
msg_queue_push(g_extern.msg_queue, msg, 1, 180);
if (driver.audio_data)
{
if (g_extern.audio_data.mute)
driver.audio->stop(driver.audio_data);
else if (!driver.audio->start(driver.audio_data))
{
RARCH_ERR("Failed to unmute audio.\n");
g_extern.audio_active = false;
}
}
RARCH_LOG("%s\n", msg);
}
static void check_volume(bool pressed_up, bool pressed_down)
{
char msg[256];
float db_change = 0.0f;
if (!pressed_up && !pressed_down)
return;
if (pressed_up)
db_change += 0.5f;
if (pressed_down)
db_change -= 0.5f;
g_extern.audio_data.volume_db += db_change;
g_extern.audio_data.volume_db = max(g_extern.audio_data.volume_db, -80.0f);
g_extern.audio_data.volume_db = min(g_extern.audio_data.volume_db, 12.0f);
snprintf(msg, sizeof(msg), "Volume: %.1f dB", g_extern.audio_data.volume_db);
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_extern.audio_data.volume_db);
}
#ifdef HAVE_NETPLAY
static void check_netplay_flip(bool pressed, bool fullscreen_toggle_pressed)
{
if (pressed)
netplay_flip_players(g_extern.netplay);
rarch_check_fullscreen(fullscreen_toggle_pressed);
}
#endif
void rarch_check_block_hotkey(bool enable_hotkey)
{
static const struct retro_keybind *bind =
&g_settings.input.binds[0][RARCH_ENABLE_HOTKEY];
bool use_hotkey_enable;
/* 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;
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;
}
static void check_grab_mouse_toggle(void)
{
static bool grab_mouse_state = false;
grab_mouse_state = !grab_mouse_state;
RARCH_LOG("Grab mouse state: %s.\n", grab_mouse_state ? "yes" : "no");
driver.input->grab_mouse(driver.input_data, grab_mouse_state);
if (driver.video_poke && driver.video_poke->show_mouse)
driver.video_poke->show_mouse(driver.video_data, !grab_mouse_state);
}
static void check_disk_eject(
const struct retro_disk_control_callback *control)
{
bool new_state = !control->get_eject_state();
rarch_disk_control_set_eject(new_state, true);
}
static void check_disk_next(
const struct retro_disk_control_callback *control)
{
unsigned num_disks = control->get_num_images();
unsigned current = control->get_image_index();
if (num_disks && num_disks != UINT_MAX)
{
/* Use "no disk" state when index == num_disks. */
unsigned next_index = current >= num_disks ?
0 : ((current + 1) % (num_disks + 1));
rarch_disk_control_set_index(next_index);
}
else
RARCH_ERR("Got invalid disk index from libretro.\n");
}
/* Checks for stuff like fullscreen, save states, etc.
* Return false when RetroArch is paused. */
static bool do_state_checks(
retro_input_t input, retro_input_t old_input,
retro_input_t trigger_input)
{
if (BIND_PRESSED(trigger_input, RARCH_SCREENSHOT))
rarch_main_command(RARCH_CMD_TAKE_SCREENSHOT);
if (g_extern.audio_active)
{
if (BIND_PRESSED(trigger_input, RARCH_MUTE))
check_mute();
}
check_volume_func(input, old_input);
check_turbo();
if (driver.input->grab_mouse)
{
if (BIND_PRESSED(trigger_input, RARCH_GRAB_MOUSE_TOGGLE))
check_grab_mouse_toggle();
}
#ifdef HAVE_OVERLAY
if (driver.overlay)
{
if (BIND_PRESSED(trigger_input, RARCH_OVERLAY_NEXT))
input_overlay_next(driver.overlay);
}
#endif
#ifdef HAVE_NETPLAY
if (g_extern.netplay)
{
check_netplay_flip_func(trigger_input);
return true;
}
#endif
check_pause_func(trigger_input);
check_oneshot_func(trigger_input);
if (check_fullscreen_func(trigger_input) && g_extern.is_paused)
rarch_render_cached_frame();
if (g_extern.is_paused && !g_extern.is_oneshot)
return false;
check_fast_forward_button_func(input, old_input, trigger_input);
check_stateslots_func(trigger_input);
if (BIND_PRESSED(trigger_input, RARCH_SAVE_STATE_KEY))
rarch_main_command(RARCH_CMD_SAVE_STATE);
else if (!g_extern.bsv.movie) /* Immutable */
{
if (BIND_PRESSED(trigger_input, RARCH_LOAD_STATE_KEY))
rarch_main_command(RARCH_CMD_LOAD_STATE);
}
check_rewind_func(input);
check_slowmotion_func(input);
if (BIND_PRESSED(trigger_input, RARCH_MOVIE_RECORD_TOGGLE))
check_movie();
check_shader_dir_func(trigger_input);
if (g_extern.cheat)
{
if (BIND_PRESSED(trigger_input, RARCH_CHEAT_INDEX_PLUS))
cheat_manager_index_next(g_extern.cheat);
else if (BIND_PRESSED(trigger_input, RARCH_CHEAT_INDEX_MINUS))
cheat_manager_index_prev(g_extern.cheat);
else if (BIND_PRESSED(trigger_input, RARCH_CHEAT_TOGGLE))
cheat_manager_toggle(g_extern.cheat);
}
if (g_extern.system.disk_control.get_num_images)
{
const struct retro_disk_control_callback *control =
(const struct retro_disk_control_callback*)
&g_extern.system.disk_control;
if (BIND_PRESSED(trigger_input, RARCH_DISK_EJECT_TOGGLE))
check_disk_eject(control);
else if (BIND_PRESSED(trigger_input, RARCH_DISK_NEXT))
check_disk_next(control);
}
if (BIND_PRESSED(trigger_input, RARCH_RESET))
rarch_main_command(RARCH_CMD_RESET);
return true;
}
static void init_state(void)
{
g_extern.video_active = true;
g_extern.audio_active = true;
}
static void deinit_log_file(void)
{
if (g_extern.log_file)
fclose(g_extern.log_file);
g_extern.log_file = NULL;
}
void rarch_main_clear_state(void)
{
unsigned i;
memset(&g_settings, 0, sizeof(g_settings));
deinit_log_file();
memset(&g_extern, 0, sizeof(g_extern));
init_state();
for (i = 0; i < MAX_PLAYERS; i++)
g_settings.input.libretro_device[i] = RETRO_DEVICE_JOYPAD;
init_msg_queue();
}
#ifdef HAVE_ZLIB
#define DEFAULT_EXT "zip"
#else
#define DEFAULT_EXT ""
#endif
static void init_system_info(void)
{
struct retro_system_info *info = (struct retro_system_info*)
&g_extern.system.info;
pretro_get_system_info(info);
if (!info->library_name)
info->library_name = "Unknown";
if (!info->library_version)
info->library_version = "v0";
#ifdef RARCH_CONSOLE
snprintf(g_extern.title_buf, sizeof(g_extern.title_buf), "%s %s",
info->library_name, info->library_version);
#else
snprintf(g_extern.title_buf, sizeof(g_extern.title_buf),
RETRO_FRONTEND " : %s %s",
info->library_name, info->library_version);
#endif
strlcpy(g_extern.system.valid_extensions, info->valid_extensions ?
info->valid_extensions : DEFAULT_EXT,
sizeof(g_extern.system.valid_extensions));
g_extern.system.block_extract = info->block_extract;
}
static void init_system_av_info(void)
{
pretro_get_system_av_info(&g_extern.system.av_info);
g_extern.frame_limit.last_frame_time = rarch_get_time_usec();
}
static void verify_api_version(void)
{
RARCH_LOG("Version of libretro API: %u\n", pretro_api_version());
RARCH_LOG("Compiled against API: %u\n", RETRO_API_VERSION);
if (pretro_api_version() != RETRO_API_VERSION)
RARCH_WARN(RETRO_LOG_LIBRETRO_ABI_BREAK);
}
/* Make sure we haven't compiled for something we cannot run.
* Ideally, code would get swapped out depending on CPU support,
* but this will do for now.
*/
static void validate_cpu_features(void)
{
uint64_t cpu = rarch_get_cpu_features();
(void)cpu;
#define FAIL_CPU(simd_type) do { \
RARCH_ERR(simd_type " code is compiled in, but CPU does not support this feature. Cannot continue.\n"); \
rarch_fail(1, "validate_cpu_features()"); \
} while(0)
#ifdef __SSE__
if (!(cpu & RETRO_SIMD_SSE))
FAIL_CPU("SSE");
#endif
#ifdef __SSE2__
if (!(cpu & RETRO_SIMD_SSE2))
FAIL_CPU("SSE2");
#endif
#ifdef __AVX__
if (!(cpu & RETRO_SIMD_AVX))
FAIL_CPU("AVX");
#endif
}
static void init_sram(void)
{
g_extern.use_sram = g_extern.use_sram && !g_extern.sram_save_disable
#ifdef HAVE_NETPLAY
&& (!g_extern.netplay || !g_extern.netplay_is_client)
#endif
;
if (g_extern.use_sram)
{
#if defined(HAVE_THREADS)
init_autosave();
#endif
}
else
RARCH_LOG("SRAM will not be saved.\n");
}
static void deinit_core(void)
{
pretro_unload_game();
pretro_deinit();
uninit_drivers();
uninit_libretro_sym();
}
int rarch_main_init(int argc, char *argv[])
{
int sjlj_ret;
init_state();
if ((sjlj_ret = setjmp(g_extern.error_sjlj_context)) > 0)
{
RARCH_ERR("Fatal error received in: \"%s\"\n", g_extern.error_string);
return sjlj_ret;
}
g_extern.error_in_init = true;
parse_input(argc, argv);
if (g_extern.verbosity)
{
RARCH_LOG_OUTPUT("=== Build =======================================");
print_compiler(stderr);
RARCH_LOG_OUTPUT("Version: %s\n", PACKAGE_VERSION);
#ifdef HAVE_GIT_VERSION
RARCH_LOG_OUTPUT("Git: %s\n", rarch_git_version);
#endif
RARCH_LOG_OUTPUT("=================================================\n");
}
validate_cpu_features();
config_load();
init_libretro_sym(g_extern.libretro_dummy);
init_system_info();
init_drivers_pre();
verify_api_version();
pretro_init();
g_extern.use_sram = !g_extern.libretro_dummy &&
!g_extern.libretro_no_content;
if (g_extern.libretro_no_content && !g_extern.libretro_dummy)
{
if (!init_content_file())
goto error;
}
else if (!g_extern.libretro_dummy)
{
fill_pathnames();
if (!init_content_file())
goto error;
set_savestate_auto_index();
if (load_save_files())
RARCH_LOG("Skipping SRAM load.\n");
load_auto_state();
init_movie();
#ifdef HAVE_NETPLAY
init_netplay();
#endif
}
retro_init_libretro_cbs();
init_system_av_info();
init_drivers();
#ifdef HAVE_COMMAND
init_command();
#endif
init_rewind();
init_controllers();
init_recording();
init_sram();
init_cheats();
g_extern.error_in_init = false;
g_extern.main_is_init = true;
return 0;
error:
deinit_core();
g_extern.main_is_init = false;
return 1;
}
static inline void update_frame_time(void)
{
retro_time_t time = 0;
retro_time_t delta = 0;
bool is_locked_fps = false;
if (!g_extern.system.frame_time.callback)
return;
time = rarch_get_time_usec();
is_locked_fps = g_extern.is_paused || driver.nonblock_state;
is_locked_fps |= !!g_extern.rec;
if (!g_extern.system.frame_time_last || is_locked_fps)
delta = g_extern.system.frame_time.reference;
else
delta = time - g_extern.system.frame_time_last;
if (!is_locked_fps && g_extern.is_slowmotion)
delta /= g_settings.slowmotion_ratio;
g_extern.system.frame_time_last = is_locked_fps ? 0 : time;
g_extern.system.frame_time.callback(delta);
}
static inline void limit_frame_time(void)
{
if (g_settings.fastforward_ratio < 0.0f)
return;
g_extern.frame_limit.minimum_frame_time = (retro_time_t)
roundf(1000000.0f / (g_extern.system.av_info.timing.fps *
g_settings.fastforward_ratio));
retro_time_t current = rarch_get_time_usec();
retro_time_t target = g_extern.frame_limit.last_frame_time +
g_extern.frame_limit.minimum_frame_time;
retro_time_t 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();
}
/* TODO - can we refactor command.c to do this? Should be local and not
* stdin or network-based */
void rarch_main_set_state(unsigned cmd)
{
switch (cmd)
{
case RARCH_ACTION_STATE_MENU_PREINIT:
{
int i;
/* Menu should always run with vsync on. */
rarch_main_command(RARCH_CMD_VIDEO_SET_BLOCKING_STATE);
/* Stop all rumbling before entering the menu. */
for (i = 0; i < MAX_PLAYERS; i++)
{
driver_set_rumble_state(i, RETRO_RUMBLE_STRONG, 0);
driver_set_rumble_state(i, RETRO_RUMBLE_WEAK, 0);
}
rarch_main_command(RARCH_CMD_AUDIO_STOP);
#ifdef HAVE_MENU
if (driver.menu)
{
/* Override keyboard callback to redirect to menu instead.
* We'll use this later for something ...
* FIXME: This should probably be moved to menu_common somehow. */
g_extern.frontend_key_event = g_extern.system.key_event;
g_extern.system.key_event = menu_key_event;
driver.menu->need_refresh = true;
rarch_main_set_state(RARCH_ACTION_STATE_MENU_RUNNING);
}
#endif
g_extern.system.frame_time_last = 0;
}
break;
case RARCH_ACTION_STATE_LOAD_CONTENT:
#ifdef HAVE_MENU
if (!load_menu_content())
{
/* If content loading fails, we go back to menu. */
if (driver.menu)
rarch_main_set_state(RARCH_ACTION_STATE_MENU_PREINIT);
}
#endif
break;
case RARCH_ACTION_STATE_MENU_RUNNING:
g_extern.lifecycle_state |= (1ULL << MODE_MENU);
break;
case RARCH_ACTION_STATE_MENU_RUNNING_FINISHED:
g_extern.lifecycle_state &= ~(1ULL << MODE_MENU);
break;
case RARCH_ACTION_STATE_EXITSPAWN:
g_extern.lifecycle_state |= (1ULL << MODE_EXITSPAWN);
break;
case RARCH_ACTION_STATE_QUIT:
g_extern.system.shutdown = true;
rarch_main_set_state(RARCH_ACTION_STATE_MENU_RUNNING_FINISHED);
break;
case RARCH_ACTION_STATE_FORCE_QUIT:
g_extern.lifecycle_state = 0;
rarch_main_set_state(RARCH_ACTION_STATE_QUIT);
break;
case RARCH_ACTION_STATE_FLUSH_INPUT:
rarch_input_poll();
#ifdef HAVE_MENU
menu_input();
#endif
/* Restore libretro keyboard callback. */
g_extern.system.key_event = g_extern.frontend_key_event;
break;
case RARCH_ACTION_STATE_NONE:
default:
break;
}
}
void rarch_main_command(unsigned cmd)
{
bool boolean = false;
switch (cmd)
{
case RARCH_CMD_LOAD_CONTENT_PERSIST:
rarch_main_command(RARCH_CMD_LOAD_CORE);
rarch_main_set_state(RARCH_ACTION_STATE_LOAD_CONTENT);
break;
case RARCH_CMD_LOAD_CONTENT:
#ifdef HAVE_DYNAMIC
rarch_main_command(RARCH_CMD_LOAD_CONTENT_PERSIST);
#else
rarch_environment_cb(RETRO_ENVIRONMENT_SET_LIBRETRO_PATH,
(void*)g_settings.libretro);
rarch_environment_cb(RETRO_ENVIRONMENT_EXEC,
(void*)g_extern.fullpath);
#endif
break;
case RARCH_CMD_LOAD_CORE:
#ifdef HAVE_MENU
if (driver.menu)
rarch_update_system_info(&g_extern.menu.info,
&driver.menu->load_no_content);
#endif
break;
case RARCH_CMD_LOAD_STATE:
/* Disallow savestate load when we absolutely
* cannot change game state. */
if (g_extern.bsv.movie)
return;
#ifdef HAVE_NETPLAY
if (g_extern.netplay)
return;
#endif
main_state(cmd);
break;
case RARCH_CMD_RESET:
RARCH_LOG(RETRO_LOG_RESETTING_CONTENT);
msg_queue_clear(g_extern.msg_queue);
msg_queue_push(g_extern.msg_queue, "Reset.", 1, 120);
pretro_reset();
/* bSNES since v073r01 resets controllers to JOYPAD
* after a reset, so just enforce it here. */
init_controllers();
break;
case RARCH_CMD_SAVE_STATE:
if (g_settings.savestate_auto_index)
g_settings.state_slot++;
main_state(cmd);
break;
case RARCH_CMD_TAKE_SCREENSHOT:
take_screenshot();
break;
case RARCH_CMD_PREPARE_DUMMY:
*g_extern.fullpath = '\0';
#ifdef HAVE_MENU
if (driver.menu)
driver.menu->load_no_content = false;
#endif
rarch_main_set_state(RARCH_ACTION_STATE_LOAD_CONTENT);
g_extern.system.shutdown = false;
break;
case RARCH_CMD_QUIT:
g_extern.system.shutdown = true;
break;
case RARCH_CMD_REINIT:
set_fullscreen(g_settings.video.fullscreen);
break;
case RARCH_CMD_REWIND:
if (g_settings.rewind_enable)
init_rewind();
else
deinit_rewind();
break;
case RARCH_CMD_AUTOSAVE:
#ifdef HAVE_THREADS
deinit_autosave();
init_autosave();
#endif
break;
case RARCH_CMD_AUDIO_STOP:
if (driver.audio_data)
driver.audio->stop(driver.audio_data);
break;
case RARCH_CMD_AUDIO_START:
if (driver.audio_data && !g_extern.audio_data.mute
&& !driver.audio->start(driver.audio_data))
{
RARCH_ERR("Failed to start audio driver. Will continue without audio.\n");
g_extern.audio_active = false;
}
break;
case RARCH_CMD_OVERLAY_INIT:
#ifdef HAVE_OVERLAY
if (!*g_settings.input.overlay)
break;
driver.overlay = input_overlay_new(g_settings.input.overlay);
if (!driver.overlay)
RARCH_ERR("Failed to load overlay.\n");
#endif
break;
case RARCH_CMD_OVERLAY_DEINIT:
#ifdef HAVE_OVERLAY
if (driver.overlay)
input_overlay_free(driver.overlay);
driver.overlay = NULL;
memset(&driver.overlay_state, 0, sizeof(driver.overlay_state));
#endif
break;
case RARCH_CMD_OVERLAY_REINIT:
rarch_main_command(RARCH_CMD_OVERLAY_DEINIT);
rarch_main_command(RARCH_CMD_OVERLAY_INIT);
break;
case RARCH_CMD_DSP_FILTER_INIT:
rarch_main_command(RARCH_CMD_DSP_FILTER_DEINIT);
if (!*g_settings.audio.dsp_plugin)
break;
g_extern.audio_data.dsp = rarch_dsp_filter_new(
g_settings.audio.dsp_plugin, g_extern.audio_data.in_rate);
if (!g_extern.audio_data.dsp)
RARCH_ERR("[DSP]: Failed to initialize DSP filter \"%s\".\n",
g_settings.audio.dsp_plugin);
break;
case RARCH_CMD_DSP_FILTER_DEINIT:
if (g_extern.audio_data.dsp)
rarch_dsp_filter_free(g_extern.audio_data.dsp);
g_extern.audio_data.dsp = NULL;
break;
case RARCH_CMD_RECORD_INIT:
init_recording();
break;
case RARCH_CMD_RECORD_DEINIT:
rarch_deinit_recording();
break;
case RARCH_CMD_HISTORY_INIT:
if (!g_extern.history)
{
bool init_history = true;
if (!path_file_exists(g_settings.content_history_path))
init_history = write_empty_file(
g_settings.content_history_path);
if (init_history)
g_extern.history = content_playlist_init(
g_settings.content_history_path,
g_settings.content_history_size);
}
break;
case RARCH_CMD_HISTORY_DEINIT:
if (g_extern.history)
content_playlist_free(g_extern.history);
g_extern.history = NULL;
break;
case RARCH_CMD_CORE_INFO_INIT:
core_info_list_free(g_extern.core_info);
g_extern.core_info = NULL;
if (*g_settings.libretro_directory)
g_extern.core_info = core_info_list_new(g_settings.libretro_directory);
#ifdef HAVE_MENU
if (driver.menu_ctx && driver.menu_ctx->init_core_info)
driver.menu_ctx->init_core_info(driver.menu);
#endif
break;
case RARCH_CMD_VIDEO_APPLY_STATE_CHANGES:
if (driver.video_data && driver.video_poke
&& driver.video_poke->apply_state_changes)
driver.video_poke->apply_state_changes(driver.video_data);
break;
case RARCH_CMD_VIDEO_SET_NONBLOCKING_STATE:
boolean = true; /* fall-through */
case RARCH_CMD_VIDEO_SET_BLOCKING_STATE:
if (driver.video && driver.video->set_nonblock_state)
driver.video->set_nonblock_state(driver.video_data, boolean);
break;
case RARCH_CMD_VIDEO_SET_ASPECT_RATIO:
if (driver.video_data && driver.video_poke
&& driver.video_poke->set_aspect_ratio)
driver.video_poke->set_aspect_ratio(driver.video_data,
g_settings.video.aspect_ratio_idx);
break;
case RARCH_CMD_AUDIO_SET_NONBLOCKING_STATE:
boolean = true; /* fall-through */
case RARCH_CMD_AUDIO_SET_BLOCKING_STATE:
if (driver.audio && driver.audio->set_nonblock_state)
driver.audio->set_nonblock_state(driver.audio_data, boolean);
break;
case RARCH_CMD_OVERLAY_SET_SCALE_FACTOR:
#ifdef HAVE_OVERLAY
if (driver.overlay)
input_overlay_set_scale_factor(driver.overlay,
g_settings.input.overlay_scale);
#endif
break;
case RARCH_CMD_OVERLAY_SET_ALPHA_MOD:
#ifdef HAVE_OVERLAY
if (driver.overlay)
input_overlay_set_alpha_mod(driver.overlay,
g_settings.input.overlay_opacity);
#endif
break;
case RARCH_CMD_RESET_CONTEXT:
uninit_drivers();
init_drivers();
break;
case RARCH_CMD_QUIT_RETROARCH:
rarch_main_set_state(RARCH_ACTION_STATE_FORCE_QUIT);
break;
case RARCH_CMD_RESUME:
#ifdef HAVE_MENU
rarch_main_set_state(RARCH_ACTION_STATE_MENU_RUNNING_FINISHED);
#endif
break;
case RARCH_CMD_RESTART_RETROARCH:
#if defined(GEKKO) && defined(HW_RVL)
fill_pathname_join(g_extern.fullpath, g_defaults.core_dir,
SALAMANDER_FILE,
sizeof(g_extern.fullpath));
#endif
rarch_main_set_state(RARCH_ACTION_STATE_EXITSPAWN);
break;
case RARCH_CMD_MENU_SAVE_CONFIG:
{
/* Save a new config to a file. Filename is based
* on heuristics to avoid typing. */
char config_dir[PATH_MAX], config_name[PATH_MAX],
config_path[PATH_MAX], msg[PATH_MAX];
bool found_path = false;
*config_dir = '\0';
if (*g_settings.menu_config_directory)
strlcpy(config_dir, g_settings.menu_config_directory,
sizeof(config_dir));
else if (*g_extern.config_path) /* Fallback */
fill_pathname_basedir(config_dir, g_extern.config_path,
sizeof(config_dir));
else
{
const char *msg = "Config directory not set. Cannot save new config.";
msg_queue_clear(g_extern.msg_queue);
msg_queue_push(g_extern.msg_queue, msg, 1, 180);
RARCH_ERR("%s\n", msg);
return;
}
/* Infer file name based on libretro core. */
if (*g_settings.libretro && path_file_exists(g_settings.libretro))
{
unsigned i;
/* In case of collision, find an alternative name. */
for (i = 0; i < 16; i++)
{
char tmp[64];
fill_pathname_base(config_name, g_settings.libretro,
sizeof(config_name));
path_remove_extension(config_name);
fill_pathname_join(config_path, config_dir, config_name,
sizeof(config_path));
*tmp = '\0';
if (i)
snprintf(tmp, sizeof(tmp), "-%u.cfg", i);
else
strlcpy(tmp, ".cfg", sizeof(tmp));
strlcat(config_path, tmp, sizeof(config_path));
if (!path_file_exists(config_path))
{
found_path = true;
break;
}
}
}
/* Fallback to system time... */
if (!found_path)
{
RARCH_WARN("Cannot infer new config path. Use current time.\n");
fill_dated_filename(config_name, "cfg", sizeof(config_name));
fill_pathname_join(config_path, config_dir, config_name,
sizeof(config_path));
}
if (config_save_file(config_path))
{
strlcpy(g_extern.config_path, config_path,
sizeof(g_extern.config_path));
snprintf(msg, sizeof(msg), "Saved new config to \"%s\".",
config_path);
RARCH_LOG("%s\n", msg);
}
else
{
snprintf(msg, sizeof(msg), "Failed saving config to \"%s\".",
config_path);
RARCH_ERR("%s\n", msg);
}
msg_queue_clear(g_extern.msg_queue);
msg_queue_push(g_extern.msg_queue, msg, 1, 180);
}
break;
case RARCH_CMD_SHADERS_APPLY_CHANGES:
#ifdef HAVE_MENU
{
unsigned shader_type = RARCH_SHADER_NONE;
if (driver.menu_ctx && driver.menu_ctx->backend &&
driver.menu_ctx->backend->shader_manager_get_type)
shader_type = driver.menu_ctx->backend->shader_manager_get_type(
driver.menu->shader);
if (driver.menu->shader->passes && shader_type != RARCH_SHADER_NONE
&& driver.menu_ctx && driver.menu_ctx->backend &&
driver.menu_ctx->backend->shader_manager_save_preset)
driver.menu_ctx->backend->shader_manager_save_preset(NULL, true);
else
{
#if defined(HAVE_CG) || defined(HAVE_HLSL) || defined(HAVE_GLSL)
shader_type = gfx_shader_parse_type("", DEFAULT_SHADER_TYPE);
#endif
if (shader_type == RARCH_SHADER_NONE)
{
#if defined(HAVE_GLSL)
shader_type = RARCH_SHADER_GLSL;
#elif defined(HAVE_CG) || defined(HAVE_HLSL)
shader_type = RARCH_SHADER_CG;
#endif
}
if (driver.menu_ctx && driver.menu_ctx->backend &&
driver.menu_ctx->backend->shader_manager_set_preset)
driver.menu_ctx->backend->shader_manager_set_preset(
NULL, shader_type, NULL);
}
}
#endif
break;
}
}
bool rarch_main_iterate(void)
{
unsigned i;
retro_input_t old_input, trigger_input;
retro_input_t input = input_keys_pressed_func(RARCH_FIRST_META_KEY,
RARCH_BIND_LIST_END, &old_input);
trigger_input = input & ~old_input;
/* Time to drop? */
if (
g_extern.system.shutdown ||
check_quit_key_func(input) ||
!driver.video->alive(driver.video_data))
return false;
if (g_extern.lifecycle_state & (1ULL << MODE_MENU))
{
if (!menu_iterate(input, old_input, trigger_input))
{
rarch_main_set_state(RARCH_ACTION_STATE_MENU_RUNNING_FINISHED);
driver_set_nonblock_state(driver.nonblock_state);
rarch_main_command(RARCH_CMD_AUDIO_START);
rarch_main_set_state(RARCH_ACTION_STATE_FLUSH_INPUT);
}
return true;
}
if (check_enter_menu_func(trigger_input) || (g_extern.libretro_dummy))
{
/* Always go into menu if dummy core is loaded. */
rarch_main_set_state(RARCH_ACTION_STATE_MENU_PREINIT);
return true; /* Enter menu on next run. */
}
if (g_extern.exec)
{
g_extern.exec = false;
return false;
}
if (!do_state_checks(input, old_input, trigger_input))
{
rarch_input_poll();
rarch_sleep(10);
return true;
}
#if defined(HAVE_THREADS)
lock_autosave();
#endif
#ifdef HAVE_NETPLAY
if (g_extern.netplay)
netplay_pre_frame(g_extern.netplay);
#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++)
{
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. */
update_frame_time();
pretro_run();
limit_frame_time();
for (i = 0; i < MAX_PLAYERS; i++)
{
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 (g_extern.netplay)
netplay_post_frame(g_extern.netplay);
#endif
#if defined(HAVE_THREADS)
unlock_autosave();
#endif
return true;
}
static void free_temporary_content(void)
{
unsigned i;
for (i = 0; i < g_extern.temporary_content->size; i++)
{
const char *path = g_extern.temporary_content->elems[i].data;
RARCH_LOG("Removing temporary content file: %s.\n", path);
if (remove(path) < 0)
RARCH_ERR("Failed to remove temporary file: %s.\n", path);
}
string_list_free(g_extern.temporary_content);
}
static void deinit_temporary_content(void)
{
if (g_extern.temporary_content)
free_temporary_content();
g_extern.temporary_content = NULL;
}
static void deinit_subsystem_fullpaths(void)
{
if (g_extern.subsystem_fullpaths)
string_list_free(g_extern.subsystem_fullpaths);
g_extern.subsystem_fullpaths = NULL;
}
void rarch_main_deinit(void)
{
#ifdef HAVE_NETPLAY
deinit_netplay();
#endif
#ifdef HAVE_COMMAND
deinit_command();
#endif
#if defined(HAVE_THREADS)
if (g_extern.use_sram)
deinit_autosave();
#endif
rarch_deinit_recording();
save_files();
deinit_rewind();
deinit_cheats();
deinit_movie();
save_auto_state();
deinit_core();
deinit_temporary_content();
deinit_subsystem_fullpaths();
deinit_savefiles();
g_extern.main_is_init = false;
}
Reference in New Issue View Git Blame Copy Permalink