RetroArch/retroarch.c

1641 lines
54 KiB
C
Raw Normal View History

2012-04-21 21:13:50 +00:00
/* RetroArch - A frontend for libretro.
2014-01-01 00:50:59 +00:00
* Copyright (C) 2010-2014 - Hans-Kristian Arntzen
2016-01-10 03:06:50 +00:00
* Copyright (C) 2011-2016 - Daniel De Matteis
2015-01-07 16:46:50 +00:00
* Copyright (C) 2012-2015 - Michael Lelli
2014-04-12 11:25:48 +00:00
*
2012-04-21 21:13:50 +00:00
* RetroArch is free software: you can redistribute it and/or modify it under the terms
2010-05-28 16:21:33 +00:00
* 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.
*
2012-04-21 21:13:50 +00:00
* RetroArch is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
2010-05-28 16:21:33 +00:00
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
* PURPOSE. See the GNU General Public License for more details.
*
2012-04-21 21:31:57 +00:00
* You should have received a copy of the GNU General Public License along with RetroArch.
2010-05-28 16:21:33 +00:00
* If not, see <http://www.gnu.org/licenses/>.
*/
2016-09-06 21:52:33 +00:00
#ifdef _WIN32
#ifdef _XBOX
#include <xtl.h>
#else
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#endif
#endif
2010-05-26 19:27:37 +00:00
#include <stdlib.h>
#include <stdint.h>
2010-05-26 19:27:37 +00:00
#include <string.h>
2011-09-27 13:31:25 +00:00
#include <ctype.h>
2011-10-06 21:43:48 +00:00
#include <errno.h>
2015-12-05 20:31:46 +00:00
#include <setjmp.h>
#include <boolean.h>
2015-12-26 06:07:01 +00:00
#include <string/stdstring.h>
#include <lists/string_list.h>
#include <compat/strl.h>
#include <compat/getopt.h>
#include <compat/posix_string.h>
#include <file/file_path.h>
2015-09-21 23:45:16 +00:00
#include <retro_stat.h>
2016-02-05 12:51:30 +00:00
#include <retro_assert.h>
#include <retro_miscellaneous.h>
#include <rthreads/rthreads.h>
#include <features/features_cpu.h>
2016-09-08 04:07:43 +00:00
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#ifdef HAVE_COMMAND
#include "command.h"
#endif
#ifdef HAVE_MENU
#include "menu/menu_driver.h"
#endif
#ifdef HAVE_NETWORKING
#include "network/netplay/netplay.h"
#endif
2016-09-08 04:07:43 +00:00
#include "config.features.h"
#include "content.h"
2016-03-22 01:56:06 +00:00
#include "core_type.h"
#include "core_info.h"
2016-03-22 02:49:05 +00:00
#include "dynamic.h"
2016-09-11 14:31:23 +00:00
#include "driver.h"
2015-07-01 17:30:34 +00:00
#include "msg_hash.h"
2015-12-01 00:47:26 +00:00
#include "movie.h"
2016-09-17 12:49:35 +00:00
#include "dirs.h"
2016-09-17 10:10:46 +00:00
#include "paths.h"
#include "file_path_special.h"
2015-11-23 11:03:38 +00:00
#include "verbosity.h"
#include "frontend/frontend_driver.h"
2015-11-29 20:34:45 +00:00
#include "audio/audio_driver.h"
#include "record/record_driver.h"
2016-05-08 03:29:10 +00:00
#include "core.h"
2015-04-07 01:22:33 +00:00
#include "configuration.h"
2015-11-30 14:35:57 +00:00
#include "runloop.h"
#include "managers/cheat_manager.h"
2016-05-16 15:19:16 +00:00
#include "tasks/tasks_internal.h"
2015-01-24 22:42:31 +00:00
#include "version.h"
#include "version_git.h"
2015-10-27 23:55:11 +00:00
#include "retroarch.h"
2016-05-09 18:30:47 +00:00
#include "command.h"
2016-09-17 12:23:44 +00:00
#define _PSUPP(var, name, desc) printf(" %s:\n\t\t%s: %s\n", name, desc, _##var##_supp ? "yes" : "no")
#define FAIL_CPU(simd_type) do { \
RARCH_ERR(simd_type " code is compiled in, but CPU does not support this feature. Cannot continue.\n"); \
retroarch_fail(1, "validate_cpu_features()"); \
} while(0)
2016-01-26 04:38:40 +00:00
/* Descriptive names for options without short variant.
*
* Please keep the name in sync with the option name.
* Order does not matter. */
enum
{
RA_OPT_MENU = 256, /* must be outside the range of a char */
RA_OPT_CHECK_FRAMES,
RA_OPT_PORT,
RA_OPT_SPECTATE,
RA_OPT_NICK,
RA_OPT_COMMAND,
RA_OPT_APPENDCONFIG,
RA_OPT_BPS,
RA_OPT_IPS,
RA_OPT_NO_PATCH,
RA_OPT_RECORDCONFIG,
RA_OPT_SUBSYSTEM,
RA_OPT_SIZE,
RA_OPT_FEATURES,
RA_OPT_VERSION,
RA_OPT_EOF_EXIT,
RA_OPT_LOG_FILE,
RA_OPT_MAX_FRAMES
};
2016-09-17 12:23:44 +00:00
static jmp_buf error_sjlj_context;
2016-09-11 18:04:41 +00:00
static enum rarch_core_type current_core_type = CORE_TYPE_PLAIN;
static enum rarch_core_type explicit_current_core_type = CORE_TYPE_PLAIN;
2016-10-27 08:33:50 +00:00
static char error_string[255] = {0};
2015-11-30 18:30:05 +00:00
2016-10-01 07:52:07 +00:00
static retro_bits_t has_set_libretro_device;
2016-10-03 14:42:08 +00:00
static bool has_set_core = false;
2016-09-17 12:23:44 +00:00
static bool has_set_username = false;
static bool rarch_is_inited = false;
static bool rarch_error_on_init = false;
static bool rarch_block_config_read = false;
static bool rarch_force_fullscreen = false;
static bool has_set_verbosity = false;
static bool has_set_libretro = false;
static bool has_set_libretro_directory = false;
static bool has_set_save_path = false;
static bool has_set_state_path = false;
static bool has_set_netplay_mode = false;
static bool has_set_netplay_ip_address = false;
static bool has_set_netplay_ip_port = false;
static bool has_set_netplay_delay_frames = false;
static bool has_set_netplay_check_frames = false;
static bool has_set_ups_pref = false;
static bool has_set_bps_pref = false;
static bool has_set_ips_pref = false;
2016-05-09 05:24:28 +00:00
static void retroarch_print_features(void)
{
puts("");
puts("Features:");
2016-06-20 02:51:36 +00:00
_PSUPP(libretrodb, "LibretroDB", "LibretroDB support");
_PSUPP(command, "Command", "Command interface support");
2016-01-26 04:38:40 +00:00
_PSUPP(network_command, "Network Command", "Network Command interface "
"support");
2016-06-20 02:51:36 +00:00
_PSUPP(sdl, "SDL", "SDL input/audio/video drivers");
_PSUPP(sdl2, "SDL2", "SDL2 input/audio/video drivers");
_PSUPP(x11, "X11", "X11 input/video drivers");
_PSUPP(wayland, "wayland", "Wayland input/video drivers");
_PSUPP(thread, "Threads", "Threading support");
_PSUPP(vulkan, "Vulkan", "Vulkan video driver");
_PSUPP(opengl, "OpenGL", "OpenGL video driver support");
_PSUPP(opengles, "OpenGL ES", "OpenGLES video driver support");
_PSUPP(xvideo, "XVideo", "Video driver");
_PSUPP(udev, "UDEV", "UDEV/EVDEV input driver support");
_PSUPP(egl, "EGL", "Video context driver");
_PSUPP(kms, "KMS", "Video context driver");
_PSUPP(vg, "OpenVG", "Video context driver");
_PSUPP(coreaudio, "CoreAudio", "Audio driver");
_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(al, "OpenAL", "Audio driver");
_PSUPP(sl, "OpenSL", "Audio driver");
_PSUPP(7zip, "7zip", "7zip extraction support");
_PSUPP(zlib, "zlib", ".zip extraction support");
_PSUPP(dylib, "External", "External filter and plugin support");
_PSUPP(cg, "Cg", "Fragment/vertex shader driver");
_PSUPP(glsl, "GLSL", "Fragment/vertex shader driver");
_PSUPP(glsl, "HLSL", "Fragment/vertex shader driver");
_PSUPP(libxml2, "libxml2", "libxml2 XML parsing");
_PSUPP(sdl_image, "SDL_image", "SDL_image image loading");
_PSUPP(rpng, "rpng", "PNG image loading/encoding");
_PSUPP(rpng, "rjpeg", "JPEG 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 driver");
_PSUPP(coretext, "CoreText", "TTF font rendering driver "
"(for OSX and/or iOS)");
_PSUPP(netplay, "Netplay", "Peer-to-peer netplay");
_PSUPP(python, "Python", "Script support in shaders");
_PSUPP(libusb, "Libusb", "Libusb support");
_PSUPP(cocoa, "Cocoa", "Cocoa UI companion support "
"(for OSX and/or iOS)");
2016-11-29 13:23:26 +00:00
_PSUPP(qt, "Qt", "Qt UI companion support");
2016-06-20 02:51:36 +00:00
_PSUPP(avfoundation, "AVFoundation", "Camera driver");
_PSUPP(v4l2, "Video4Linux2", "Camera driver");
}
#undef _PSUPP
2016-05-09 05:09:26 +00:00
static void retroarch_print_version(void)
2010-10-01 19:39:15 +00:00
{
char str[255];
2016-10-21 03:57:40 +00:00
str[0] = '\0';
2015-04-16 18:17:05 +00:00
2016-06-20 01:54:42 +00:00
fprintf(stderr, "%s: %s -- v%s",
msg_hash_to_str(MSG_PROGRAM),
msg_hash_to_str(MSG_LIBRETRO_FRONTEND),
PACKAGE_VERSION);
#ifdef HAVE_GIT_VERSION
printf(" -- %s --\n", retroarch_git_version);
#endif
2016-05-09 05:09:26 +00:00
retroarch_get_capabilities(RARCH_CAPABILITIES_COMPILER, str, sizeof(str));
2015-04-16 18:19:53 +00:00
fprintf(stdout, "%s", str);
2015-04-16 18:17:05 +00:00
fprintf(stdout, "Built: %s\n", __DATE__);
2015-06-12 14:42:29 +00:00
}
/**
2016-05-09 05:09:26 +00:00
* retroarch_print_help:
2015-06-12 14:42:29 +00:00
*
* Prints help message explaining the program's commandline switches.
2015-06-12 14:42:29 +00:00
**/
2016-05-09 05:09:26 +00:00
static void retroarch_print_help(const char *arg0)
2015-06-12 14:42:29 +00:00
{
puts("===================================================================");
2016-05-09 05:09:26 +00:00
retroarch_print_version();
puts("===================================================================");
printf("Usage: %s [OPTIONS]... [FILE]\n", arg0);
2015-06-12 14:18:36 +00:00
puts(" -h, --help Show this help message.");
2015-06-12 14:42:29 +00:00
puts(" -v, --verbose Verbose logging.");
2015-07-02 22:16:46 +00:00
puts(" --log-file=FILE Log messages to FILE.");
puts(" --version Show version.");
2016-01-26 04:38:40 +00:00
puts(" --features Prints available features compiled into "
"program.");
2015-10-28 07:02:39 +00:00
#ifdef HAVE_MENU
2016-01-26 04:38:40 +00:00
puts(" --menu Do not require content or libretro core to "
"be loaded,\n"
" starts directly in menu. If no arguments "
"are passed to\n"
" the program, it is equivalent to using "
"--menu as only argument.");
2015-10-28 07:02:39 +00:00
#endif
puts(" -s, --save=PATH Path for save files (*.srm).");
puts(" -S, --savestate=PATH Path for the save state files (*.state).");
2016-01-26 04:38:40 +00:00
puts(" -f, --fullscreen Start the program in fullscreen regardless "
"of config settings.");
2015-07-02 22:16:46 +00:00
puts(" -c, --config=FILE Path for config file."
#ifdef _WIN32
2016-01-26 04:38:40 +00:00
"\n\t\tDefaults to retroarch.cfg in same directory as retroarch.exe."
"\n\t\tIf a default config is not found, the program will attempt to"
"create one."
2015-07-02 22:16:46 +00:00
#else
2016-01-26 04:38:40 +00:00
"\n\t\tBy default looks for config in $XDG_CONFIG_HOME/retroarch/"
"retroarch.cfg,\n\t\t$HOME/.config/retroarch/retroarch.cfg,\n\t\t"
"and $HOME/.retroarch.cfg.\n\t\tIf a default config is not found, "
"the program will attempt to create one based on the \n\t\t"
"skeleton config (" GLOBAL_CONFIG_DIR "/retroarch.cfg). \n"
2015-07-02 22:16:46 +00:00
#endif
);
2015-06-12 14:18:36 +00:00
puts(" --appendconfig=FILE\n"
2016-01-26 04:38:40 +00:00
" Extra config files are loaded in, "
"and take priority over\n"
" config selected in -c (or default). "
"Multiple configs are\n"
2015-06-12 14:18:36 +00:00
" delimited by '|'.");
2011-11-15 20:15:12 +00:00
#ifdef HAVE_DYNAMIC
2016-01-26 04:38:40 +00:00
puts(" -L, --libretro=FILE Path to libretro implementation. "
"Overrides any config setting.");
#endif
2016-01-26 04:38:40 +00:00
puts(" --subsystem=NAME Use a subsystem of the libretro core. "
"Multiple content\n"
" files are loaded as multiple arguments. "
"If a content\n"
" file is skipped, use a blank (\"\") "
"command line argument.\n"
" Content must be loaded in an order "
"which depends on the\n"
" particular subsystem used. See verbose "
"log output to learn\n"
" how a particular subsystem wants content "
"to be loaded.\n");
2012-08-16 19:20:38 +00:00
2015-06-12 14:18:36 +00:00
printf(" -N, --nodevice=PORT\n"
2016-01-26 04:38:40 +00:00
" Disconnects controller device connected "
"to PORT (1 to %d).\n", MAX_USERS);
2015-06-12 14:18:36 +00:00
printf(" -A, --dualanalog=PORT\n"
2016-01-26 04:38:40 +00:00
" Connect a DualAnalog controller to PORT "
"(1 to %d).\n", MAX_USERS);
2015-06-12 14:18:36 +00:00
printf(" -d, --device=PORT:ID\n"
2016-01-26 04:38:40 +00:00
" Connect a generic device into PORT of "
"the device (1 to %d).\n", MAX_USERS);
puts(" Format is PORT:ID, where ID is a number "
"corresponding to the particular device.");
2012-08-16 19:20:38 +00:00
2015-06-12 14:18:36 +00:00
puts(" -P, --bsvplay=FILE Playback a BSV movie file.");
2016-01-26 04:38:40 +00:00
puts(" -R, --bsvrecord=FILE Start recording a BSV movie file from "
"the beginning.");
puts(" --eof-exit Exit upon reaching the end of the "
"BSV movie file.");
puts(" -M, --sram-mode=MODE SRAM handling mode. MODE can be "
"'noload-nosave',\n"
" 'noload-save', 'load-nosave' or "
"'load-save'.\n"
" Note: 'noload-save' implies that "
"save files *WILL BE OVERWRITTEN*.");
2011-11-20 19:19:05 +00:00
2016-09-29 19:07:10 +00:00
#ifdef HAVE_NETWORKING
2015-06-12 14:18:36 +00:00
puts(" -H, --host Host netplay as user 1.");
puts(" -C, --connect=HOST Connect to netplay server as user 2.");
puts(" --port=PORT Port used to netplay. Default is 55435.");
puts(" -F, --frames=NUMBER Delay frames when using netplay.");
puts(" --check-frames=NUMBER\n"
" Check frames when using netplay.");
2015-06-12 14:18:36 +00:00
puts(" --spectate Connect to netplay server as spectator.");
2016-09-29 19:10:35 +00:00
#if defined(HAVE_NETWORK_CMD)
2016-01-26 04:38:40 +00:00
puts(" --command Sends a command over UDP to an already "
"running program process.");
2015-06-12 14:18:36 +00:00
puts(" Available commands are listed if command is invalid.");
#endif
2011-01-07 16:59:53 +00:00
2016-09-29 19:10:35 +00:00
#endif
puts(" --nick=NICK Picks a username (for use with netplay). "
"Not mandatory.");
2016-01-26 04:38:40 +00:00
puts(" -r, --record=FILE Path to record video file.\n "
"Using .mkv extension is recommended.");
2015-06-12 14:18:36 +00:00
puts(" --recordconfig Path to settings used during recording.");
puts(" --size=WIDTHxHEIGHT\n"
" Overrides output video size when recording.");
2016-01-26 04:38:40 +00:00
puts(" -U, --ups=FILE Specifies path for UPS patch that will be "
"applied to content.");
puts(" --bps=FILE Specifies path for BPS patch that will be "
"applied to content.");
puts(" --ips=FILE Specifies path for IPS patch that will be "
"applied to content.");
2015-06-12 14:18:36 +00:00
puts(" --no-patch Disables all forms of content patching.");
2016-01-26 04:38:40 +00:00
puts(" -D, --detach Detach program from the running console. "
"Not relevant for all platforms.");
2015-06-12 14:18:36 +00:00
puts(" --max-frames=NUMBER\n"
2016-01-26 04:38:40 +00:00
" Runs for the specified number of frames, "
"then exits.\n");
2010-10-01 19:39:15 +00:00
}
2015-06-26 17:19:36 +00:00
#define FFMPEG_RECORD_ARG "r:"
#ifdef HAVE_DYNAMIC
#define DYNAMIC_ARG "L:"
#else
#define DYNAMIC_ARG
#endif
2016-09-29 19:07:10 +00:00
#ifdef HAVE_NETWORKING
2015-06-26 17:19:36 +00:00
#define NETPLAY_ARG "HC:F:"
#else
#define NETPLAY_ARG
#endif
#define BSV_MOVIE_ARG "P:R:M:"
2015-01-11 01:21:18 +00:00
/**
2016-05-09 05:24:28 +00:00
* retroarch_parse_input:
2015-01-11 01:21:18 +00:00
* @argc : Count of (commandline) arguments.
* @argv : (Commandline) arguments.
2015-01-11 01:21:18 +00:00
*
* Parses (commandline) arguments passed to program.
2015-01-11 01:21:18 +00:00
*
**/
2016-05-09 05:24:28 +00:00
static void retroarch_parse_input(int argc, char *argv[])
2010-05-26 19:27:37 +00:00
{
2015-06-26 17:19:36 +00:00
const char *optstring = NULL;
bool explicit_menu = false;
settings_t *settings = config_get_ptr();
global_t *global = global_get_ptr();
2011-02-18 13:49:15 +00:00
2012-01-05 20:43:55 +00:00
const struct option opts[] = {
2011-11-15 20:15:12 +00:00
#ifdef HAVE_DYNAMIC
2015-06-12 14:27:39 +00:00
{ "libretro", 1, NULL, 'L' },
2011-11-15 20:15:12 +00:00
#endif
{ "menu", 0, NULL, RA_OPT_MENU },
2015-06-12 14:27:39 +00:00
{ "help", 0, NULL, 'h' },
{ "save", 1, NULL, 's' },
{ "fullscreen", 0, NULL, 'f' },
{ "record", 1, NULL, 'r' },
{ "recordconfig", 1, NULL, RA_OPT_RECORDCONFIG },
{ "size", 1, NULL, RA_OPT_SIZE },
2015-06-12 14:27:39 +00:00
{ "verbose", 0, NULL, 'v' },
{ "config", 1, NULL, 'c' },
{ "appendconfig", 1, NULL, RA_OPT_APPENDCONFIG },
2015-06-12 14:27:39 +00:00
{ "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' },
2016-09-29 19:07:10 +00:00
#ifdef HAVE_NETWORKING
2015-06-12 14:27:39 +00:00
{ "host", 0, NULL, 'H' },
{ "connect", 1, NULL, 'C' },
{ "frames", 1, NULL, 'F' },
{ "check-frames", 1, NULL, RA_OPT_CHECK_FRAMES },
{ "port", 1, NULL, RA_OPT_PORT },
{ "spectate", 0, NULL, RA_OPT_SPECTATE },
2016-09-29 19:07:10 +00:00
#if defined(HAVE_NETWORK_CMD)
{ "command", 1, NULL, RA_OPT_COMMAND },
#endif
2016-09-29 19:07:10 +00:00
#endif
{ "nick", 1, NULL, RA_OPT_NICK },
2015-06-12 14:27:39 +00:00
{ "ups", 1, NULL, 'U' },
{ "bps", 1, NULL, RA_OPT_BPS },
{ "ips", 1, NULL, RA_OPT_IPS },
{ "no-patch", 0, NULL, RA_OPT_NO_PATCH },
2015-06-12 14:27:39 +00:00
{ "detach", 0, NULL, 'D' },
{ "features", 0, NULL, RA_OPT_FEATURES },
{ "subsystem", 1, NULL, RA_OPT_SUBSYSTEM },
{ "max-frames", 1, NULL, RA_OPT_MAX_FRAMES },
{ "eof-exit", 0, NULL, RA_OPT_EOF_EXIT },
{ "version", 0, NULL, RA_OPT_VERSION },
#ifdef HAVE_FILE_LOGGER
{ "log-file", 1, NULL, RA_OPT_LOG_FILE },
#endif
2010-10-01 19:39:15 +00:00
{ NULL, 0, NULL, 0 }
};
/* Handling the core type is finicky. Based on the arguments we pass in,
* we handle it differently.
* Some current cases which track desired behavior and how it is supposed to work:
*
* Dynamically linked RA:
* ./retroarch -> CORE_TYPE_DUMMY
* ./retroarch -v -> CORE_TYPE_DUMMY + verbose
* ./retroarch --menu -> CORE_TYPE_DUMMY
* ./retroarch --menu -v -> CORE_TYPE_DUMMY + verbose
* ./retroarch -L contentless-core -> CORE_TYPE_PLAIN
* ./retroarch -L content-core -> CORE_TYPE_PLAIN + FAIL (This currently crashes)
* ./retroarch [-L content-core] ROM -> CORE_TYPE_PLAIN
* ./retroarch <-L or ROM> --menu -> FAIL
*
* The heuristic here seems to be that if we use the -L CLI option or
* optind < argc at the end we should set CORE_TYPE_PLAIN.
* To handle --menu, we should ensure that CORE_TYPE_DUMMY is still set
* otherwise, fail early, since the CLI options are non-sensical.
* We could also simply ignore --menu in this case to be more friendly with
* bogus arguments.
*/
2016-10-03 14:42:08 +00:00
if (!has_set_core)
retroarch_set_current_core_type(CORE_TYPE_DUMMY, false);
2016-09-30 02:31:19 +00:00
path_clear(RARCH_PATH_SUBSYSTEM);
2016-08-01 18:48:02 +00:00
retroarch_override_setting_free_state();
2016-04-05 22:30:21 +00:00
rarch_ctl(RARCH_CTL_USERNAME_UNSET, NULL);
2016-09-29 03:46:31 +00:00
rarch_ctl(RARCH_CTL_UNSET_UPS_PREF, NULL);
rarch_ctl(RARCH_CTL_UNSET_IPS_PREF, NULL);
rarch_ctl(RARCH_CTL_UNSET_BPS_PREF, NULL);
*global->name.ups = '\0';
*global->name.bps = '\0';
*global->name.ips = '\0';
runloop_ctl(RUNLOOP_CTL_UNSET_OVERRIDES_ACTIVE, NULL);
2014-09-02 15:05:15 +00:00
2016-05-09 05:24:28 +00:00
/* Make sure we can call retroarch_parse_input several times ... */
2015-06-26 17:19:36 +00:00
optind = 0;
optstring = "hs:fvS:A:c:U:DN:d:"
2016-01-26 04:38:40 +00:00
BSV_MOVIE_ARG NETPLAY_ARG DYNAMIC_ARG FFMPEG_RECORD_ARG;
#ifndef HAVE_MENU
if (argc == 1)
{
2016-11-08 14:17:02 +00:00
printf("%s\n", msg_hash_to_str(MSG_NO_ARGUMENTS_SUPPLIED_AND_NO_MENU_BUILTIN));
retroarch_print_help(argv[0]);
exit(0);
}
#endif
2011-10-15 10:56:48 +00:00
for (;;)
2010-05-29 13:21:30 +00:00
{
2015-03-20 19:20:33 +00:00
int port;
2016-04-05 18:53:02 +00:00
int c = getopt_long(argc, argv, optstring, opts, NULL);
2015-06-26 18:35:02 +00:00
2016-06-28 02:23:57 +00:00
#if 0
RARCH_LOG("c is: %c, optarg is: [%s]\n", c, string_is_empty(optarg) ? "" : optarg);
#endif
2010-10-01 19:39:15 +00:00
if (c == -1)
break;
switch (c)
2010-10-01 19:39:15 +00:00
{
case 'h':
2016-05-09 05:09:26 +00:00
retroarch_print_help(argv[0]);
2010-10-01 19:39:15 +00:00
exit(0);
case 'd':
{
unsigned new_port;
unsigned id = 0;
struct string_list *list = string_split(optarg, ":");
2015-03-22 07:39:26 +00:00
port = 0;
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);
2015-01-05 00:58:00 +00:00
if (port < 1 || port > MAX_USERS)
{
2016-08-22 11:11:40 +00:00
RARCH_ERR("%s\n", msg_hash_to_str(MSG_VALUE_CONNECT_DEVICE_FROM_A_VALID_PORT));
2016-05-09 05:09:26 +00:00
retroarch_print_help(argv[0]);
2016-05-09 05:24:28 +00:00
retroarch_fail(1, "retroarch_parse_input()");
}
new_port = port -1;
settings->input.libretro_device[new_port] = id;
retroarch_override_setting_set(
RARCH_OVERRIDE_SETTING_LIBRETRO_DEVICE, &new_port);
2014-04-04 12:58:42 +00:00
break;
}
2014-04-04 12:58:42 +00:00
2012-08-16 19:20:38 +00:00
case 'A':
{
unsigned new_port;
2012-08-16 19:20:38 +00:00
port = strtol(optarg, NULL, 0);
2015-01-05 00:58:00 +00:00
if (port < 1 || port > MAX_USERS)
2012-08-16 19:20:38 +00:00
{
RARCH_ERR("Connect dualanalog to a valid port.\n");
2016-05-09 05:09:26 +00:00
retroarch_print_help(argv[0]);
2016-05-09 05:24:28 +00:00
retroarch_fail(1, "retroarch_parse_input()");
2012-08-16 19:20:38 +00:00
}
new_port = port - 1;
settings->input.libretro_device[new_port] = RETRO_DEVICE_ANALOG;
retroarch_override_setting_set(
RARCH_OVERRIDE_SETTING_LIBRETRO_DEVICE, &new_port);
}
2012-08-16 19:20:38 +00:00
break;
2010-10-01 19:39:15 +00:00
case 's':
strlcpy(global->name.savefile, optarg,
sizeof(global->name.savefile));
2016-09-17 12:23:44 +00:00
retroarch_override_setting_set(
2016-10-01 03:51:03 +00:00
RARCH_OVERRIDE_SETTING_SAVE_PATH, NULL);
break;
case 'f':
2015-11-30 21:02:54 +00:00
rarch_ctl(RARCH_CTL_SET_FORCE_FULLSCREEN, NULL);
break;
case 'S':
strlcpy(global->name.savestate, optarg,
sizeof(global->name.savestate));
2016-09-17 12:23:44 +00:00
retroarch_override_setting_set(
2016-10-01 03:51:03 +00:00
RARCH_OVERRIDE_SETTING_STATE_PATH, NULL);
2010-10-01 19:39:15 +00:00
break;
2010-10-01 20:10:28 +00:00
case 'v':
verbosity_enable();
2016-09-17 12:23:44 +00:00
retroarch_override_setting_set(
2016-10-01 03:51:03 +00:00
RARCH_OVERRIDE_SETTING_VERBOSITY, NULL);
2010-10-01 20:10:28 +00:00
break;
2011-06-19 09:11:04 +00:00
case 'N':
{
unsigned new_port;
port = strtol(optarg, NULL, 0);
if (port < 1 || port > MAX_USERS)
{
RARCH_ERR("%s\n",
2016-10-22 22:35:40 +00:00
msg_hash_to_str(MSG_DISCONNECT_DEVICE_FROM_A_VALID_PORT));
retroarch_print_help(argv[0]);
retroarch_fail(1, "retroarch_parse_input()");
}
new_port = port - 1;
settings->input.libretro_device[port - 1] = RETRO_DEVICE_NONE;
retroarch_override_setting_set(
RARCH_OVERRIDE_SETTING_LIBRETRO_DEVICE, &new_port);
2011-06-19 09:11:04 +00:00
}
break;
2010-12-29 20:12:56 +00:00
case 'c':
2016-09-29 05:46:21 +00:00
path_set(RARCH_PATH_CONFIG, optarg);
2010-12-29 20:12:56 +00:00
break;
case 'r':
strlcpy(global->record.path, optarg,
sizeof(global->record.path));
{
bool *recording_enabled = recording_is_enabled();
if (recording_enabled)
*recording_enabled = true;
}
break;
2011-11-15 20:15:12 +00:00
#ifdef HAVE_DYNAMIC
case 'L':
if (path_is_directory(optarg))
{
2016-09-30 02:31:19 +00:00
path_clear(RARCH_PATH_CORE);
2016-04-28 17:26:02 +00:00
strlcpy(settings->directory.libretro, optarg,
sizeof(settings->directory.libretro));
2016-08-01 18:47:19 +00:00
2016-10-01 03:51:03 +00:00
retroarch_override_setting_set(RARCH_OVERRIDE_SETTING_LIBRETRO, NULL);
retroarch_override_setting_set(RARCH_OVERRIDE_SETTING_LIBRETRO_DIRECTORY, NULL);
2016-01-26 04:38:40 +00:00
RARCH_WARN("Using old --libretro behavior. "
"Setting libretro_directory to \"%s\" instead.\n",
optarg);
}
else if (path_file_exists(optarg))
{
2015-11-30 20:42:59 +00:00
runloop_ctl(RUNLOOP_CTL_SET_LIBRETRO_PATH, optarg);
2016-10-01 03:51:03 +00:00
retroarch_override_setting_set(RARCH_OVERRIDE_SETTING_LIBRETRO, NULL);
/* We requested explicit core, so use PLAIN core type. */
retroarch_set_current_core_type(CORE_TYPE_PLAIN, false);
}
else
{
RARCH_WARN("--libretro argument \"%s\" is neither a file nor directory. Ignoring.\n",
optarg);
}
2011-11-15 20:15:12 +00:00
break;
2014-09-02 15:05:15 +00:00
#endif
2011-02-02 11:10:27 +00:00
case 'P':
2011-11-20 19:19:05 +00:00
case 'R':
bsv_movie_set_start_path(optarg);
if (c == 'P')
bsv_movie_ctl(BSV_MOVIE_CTL_SET_START_PLAYBACK, NULL);
else
bsv_movie_ctl(BSV_MOVIE_CTL_UNSET_START_PLAYBACK, NULL);
if (c == 'R')
bsv_movie_ctl(BSV_MOVIE_CTL_SET_START_RECORDING, NULL);
else
bsv_movie_ctl(BSV_MOVIE_CTL_UNSET_START_RECORDING, NULL);
2011-11-18 17:03:24 +00:00
break;
2011-11-20 19:19:05 +00:00
case 'M':
2016-01-20 03:07:24 +00:00
if (string_is_equal(optarg, "noload-nosave"))
2011-11-18 17:03:24 +00:00
{
2016-09-28 05:27:39 +00:00
rarch_ctl(RARCH_CTL_SET_SRAM_LOAD_DISABLED, NULL);
rarch_ctl(RARCH_CTL_SET_SRAM_SAVE_DISABLED, NULL);
2011-11-18 17:03:24 +00:00
}
2016-01-20 03:07:24 +00:00
else if (string_is_equal(optarg, "noload-save"))
2016-09-28 05:27:39 +00:00
rarch_ctl(RARCH_CTL_SET_SRAM_LOAD_DISABLED, NULL);
2016-01-20 03:07:24 +00:00
else if (string_is_equal(optarg, "load-nosave"))
2016-09-28 05:27:39 +00:00
rarch_ctl(RARCH_CTL_SET_SRAM_SAVE_DISABLED, NULL);
2016-01-20 03:07:24 +00:00
else if (!string_is_equal(optarg, "load-save"))
2011-11-18 17:03:24 +00:00
{
2012-04-21 21:25:32 +00:00
RARCH_ERR("Invalid argument in --sram-mode.\n");
2016-05-09 05:09:26 +00:00
retroarch_print_help(argv[0]);
2016-05-09 05:24:28 +00:00
retroarch_fail(1, "retroarch_parse_input()");
2011-11-18 17:03:24 +00:00
}
2011-02-02 11:10:27 +00:00
break;
2016-09-29 19:07:10 +00:00
#ifdef HAVE_NETWORKING
2011-02-13 15:40:24 +00:00
case 'H':
2016-09-17 12:23:44 +00:00
retroarch_override_setting_set(
RARCH_OVERRIDE_SETTING_NETPLAY_MODE, NULL);
netplay_driver_ctl(RARCH_NETPLAY_CTL_ENABLE_SERVER, NULL);
2011-02-13 15:40:24 +00:00
break;
case 'C':
retroarch_override_setting_set(
RARCH_OVERRIDE_SETTING_NETPLAY_MODE, NULL);
2016-09-17 12:23:44 +00:00
retroarch_override_setting_set(
2016-10-01 03:51:03 +00:00
RARCH_OVERRIDE_SETTING_NETPLAY_IP_ADDRESS, NULL);
netplay_driver_ctl(RARCH_NETPLAY_CTL_ENABLE_CLIENT, NULL);
strlcpy(settings->netplay.server, optarg,
sizeof(settings->netplay.server));
2011-02-13 15:40:24 +00:00
break;
2011-02-15 14:32:26 +00:00
case 'F':
settings->netplay.delay_frames = strtol(optarg, NULL, 0);
2016-09-17 12:23:44 +00:00
retroarch_override_setting_set(
2016-10-01 03:51:03 +00:00
RARCH_OVERRIDE_SETTING_NETPLAY_DELAY_FRAMES, NULL);
2011-02-15 14:32:26 +00:00
break;
2016-09-29 19:10:35 +00:00
case RA_OPT_CHECK_FRAMES:
retroarch_override_setting_set(
2016-10-01 03:51:03 +00:00
RARCH_OVERRIDE_SETTING_NETPLAY_CHECK_FRAMES, NULL);
settings->netplay.check_frames = strtoul(optarg, NULL, 0);
2016-09-29 19:10:35 +00:00
break;
case RA_OPT_PORT:
retroarch_override_setting_set(
2016-10-01 03:51:03 +00:00
RARCH_OVERRIDE_SETTING_NETPLAY_IP_PORT, NULL);
settings->netplay.port = strtoul(optarg, NULL, 0);
2016-09-29 19:10:35 +00:00
break;
case RA_OPT_SPECTATE:
retroarch_override_setting_set(
2016-10-01 03:51:03 +00:00
RARCH_OVERRIDE_SETTING_NETPLAY_MODE, NULL);
settings->netplay.is_spectate = true;
2016-09-29 19:10:35 +00:00
break;
#if defined(HAVE_NETWORK_CMD)
case RA_OPT_COMMAND:
if (command_network_send((const char*)optarg))
exit(0);
else
retroarch_fail(1, "network_cmd_send()");
break;
#endif
#endif
2011-02-15 14:32:26 +00:00
case RA_OPT_BPS:
strlcpy(global->name.bps, optarg,
sizeof(global->name.bps));
2016-09-29 03:46:31 +00:00
rarch_ctl(RARCH_CTL_SET_BPS_PREF, NULL);
2016-10-01 03:51:03 +00:00
retroarch_override_setting_set(RARCH_OVERRIDE_SETTING_BPS_PREF, NULL);
break;
case 'U':
strlcpy(global->name.ups, optarg,
sizeof(global->name.ups));
2016-09-29 03:46:31 +00:00
rarch_ctl(RARCH_CTL_SET_UPS_PREF, NULL);
2016-10-01 03:51:03 +00:00
retroarch_override_setting_set(RARCH_OVERRIDE_SETTING_UPS_PREF, NULL);
break;
2011-04-23 12:47:50 +00:00
case RA_OPT_IPS:
strlcpy(global->name.ips, optarg,
sizeof(global->name.ips));
2016-09-29 03:46:31 +00:00
rarch_ctl(RARCH_CTL_SET_IPS_PREF, NULL);
2016-10-01 03:51:03 +00:00
retroarch_override_setting_set(RARCH_OVERRIDE_SETTING_IPS_PREF, NULL);
break;
case RA_OPT_NO_PATCH:
2016-09-29 03:46:31 +00:00
rarch_ctl(RARCH_CTL_SET_PATCH_BLOCKED, NULL);
break;
2011-04-23 12:47:50 +00:00
case 'D':
frontend_driver_detach_console();
2011-04-23 12:47:50 +00:00
break;
case RA_OPT_MENU:
explicit_menu = true;
break;
2013-04-14 14:24:19 +00:00
2016-09-29 19:07:10 +00:00
case RA_OPT_NICK:
rarch_ctl(RARCH_CTL_USERNAME_SET, NULL);
strlcpy(settings->username, optarg,
sizeof(settings->username));
break;
case RA_OPT_APPENDCONFIG:
2016-09-29 05:49:54 +00:00
path_set(RARCH_PATH_CONFIG_APPEND, optarg);
break;
case RA_OPT_SIZE:
2016-09-30 22:47:05 +00:00
if (sscanf(optarg, "%ux%u",
recording_driver_get_width(),
recording_driver_get_height()) != 2)
{
RARCH_ERR("Wrong format for --size.\n");
2016-05-09 05:09:26 +00:00
retroarch_print_help(argv[0]);
2016-05-09 05:24:28 +00:00
retroarch_fail(1, "retroarch_parse_input()");
2011-02-18 13:49:15 +00:00
}
break;
case RA_OPT_RECORDCONFIG:
strlcpy(global->record.config, optarg,
sizeof(global->record.config));
break;
case RA_OPT_MAX_FRAMES:
{
unsigned max_frames = strtoul(optarg, NULL, 10);
2015-11-30 20:42:59 +00:00
runloop_ctl(RUNLOOP_CTL_SET_MAX_FRAMES, &max_frames);
}
break;
case RA_OPT_SUBSYSTEM:
2016-09-29 05:36:09 +00:00
path_set(RARCH_PATH_SUBSYSTEM, optarg);
break;
case RA_OPT_FEATURES:
2016-05-09 05:24:28 +00:00
retroarch_print_features();
exit(0);
case RA_OPT_EOF_EXIT:
2015-12-01 00:29:16 +00:00
bsv_movie_ctl(BSV_MOVIE_CTL_SET_END_EOF, NULL);
break;
case RA_OPT_VERSION:
2016-05-09 05:09:26 +00:00
retroarch_print_version();
exit(0);
2010-10-01 19:39:15 +00:00
#ifdef HAVE_FILE_LOGGER
case RA_OPT_LOG_FILE:
2015-11-23 14:45:02 +00:00
retro_main_log_file_init(optarg);
break;
#endif
case '?':
2016-05-09 05:09:26 +00:00
retroarch_print_help(argv[0]);
2016-05-09 05:24:28 +00:00
retroarch_fail(1, "retroarch_parse_input()");
2010-10-01 19:39:15 +00:00
default:
2016-06-20 01:54:42 +00:00
RARCH_ERR("%s\n", msg_hash_to_str(MSG_ERROR_PARSING_ARGUMENTS));
2016-05-09 05:24:28 +00:00
retroarch_fail(1, "retroarch_parse_input()");
2010-10-01 19:39:15 +00:00
}
2010-05-29 13:21:30 +00:00
}
if (explicit_menu)
2013-04-14 14:24:19 +00:00
{
if (optind < argc)
{
RARCH_ERR("--menu was used, but content file was passed as well.\n");
2016-05-09 05:24:28 +00:00
retroarch_fail(1, "retroarch_parse_input()");
}
#ifdef HAVE_DYNAMIC
else
{
2016-09-17 12:23:44 +00:00
/* Allow stray -L arguments to go through to workaround cases
* where it's used as "config file".
*
* This seems to still be the case for Android, which
* should be properly fixed. */
retroarch_set_current_core_type(CORE_TYPE_DUMMY, false);
}
#endif
2013-04-14 14:24:19 +00:00
}
2016-09-30 02:43:16 +00:00
if (path_is_empty(RARCH_PATH_SUBSYSTEM) && optind < argc)
2016-02-15 20:30:11 +00:00
{
/* We requested explicit ROM, so use PLAIN core type. */
retroarch_set_current_core_type(CORE_TYPE_PLAIN, false);
path_set(RARCH_PATH_NAMES, (const char*)argv[optind]);
2016-02-15 20:30:11 +00:00
}
2016-09-30 02:43:16 +00:00
else if (!path_is_empty(RARCH_PATH_SUBSYSTEM) && optind < argc)
{
/* We requested explicit ROM, so use PLAIN core type. */
retroarch_set_current_core_type(CORE_TYPE_PLAIN, false);
2016-09-17 10:19:17 +00:00
path_set_special(argv + optind, argc - optind);
}
2011-08-24 13:47:39 +00:00
else
2016-05-08 03:17:31 +00:00
content_set_does_not_need_content();
/* Copy SRM/state dirs used, so they can be reused on reentrancy. */
2016-10-01 04:05:08 +00:00
if (retroarch_override_setting_is_set(RARCH_OVERRIDE_SETTING_SAVE_PATH, NULL) &&
path_is_directory(global->name.savefile))
2016-10-03 06:20:33 +00:00
dir_set(RARCH_DIR_SAVEFILE, global->name.savefile);
2016-10-01 06:24:02 +00:00
if (retroarch_override_setting_is_set(RARCH_OVERRIDE_SETTING_STATE_PATH, NULL) &&
path_is_directory(global->name.savestate))
2016-10-03 06:20:33 +00:00
dir_set(RARCH_DIR_SAVESTATE, global->name.savestate);
2010-10-01 19:39:15 +00:00
}
2010-08-15 08:02:04 +00:00
2016-05-09 05:09:26 +00:00
static bool retroarch_init_state(void)
2011-08-26 15:32:04 +00:00
{
2016-05-08 12:00:51 +00:00
video_driver_set_active();
2016-05-08 16:24:25 +00:00
audio_driver_set_active();
2015-03-22 06:28:45 +00:00
rarch_ctl(RARCH_CTL_UNSET_FORCE_FULLSCREEN, NULL);
2015-11-30 21:02:54 +00:00
2015-03-22 06:28:45 +00:00
return true;
}
2016-05-09 05:09:26 +00:00
bool retroarch_validate_game_options(char *s, size_t len, bool mkdir)
{
2016-10-21 03:57:40 +00:00
char core_path[PATH_MAX_LENGTH];
char config_directory[PATH_MAX_LENGTH];
2016-05-27 15:27:38 +00:00
const char *core_name = NULL;
const char *game_name = NULL;
rarch_system_info_t *system = NULL;
runloop_ctl(RUNLOOP_CTL_SYSTEM_INFO_GET, &system);
if (system)
core_name = system->info.library_name;
2016-09-17 17:41:16 +00:00
2016-09-29 06:46:41 +00:00
game_name = path_basename(path_get(RARCH_PATH_BASENAME));
if (string_is_empty(core_name) || string_is_empty(game_name))
return false;
2016-10-21 03:57:40 +00:00
config_directory[0] = core_path[0] = '\0';
fill_pathname_application_special(config_directory, sizeof(config_directory),
APPLICATION_SPECIAL_DIRECTORY_CONFIG);
/* Concatenate strings into full paths for game_path */
2016-06-30 02:59:57 +00:00
fill_pathname_join_special_ext(s,
config_directory, core_name, game_name,
file_path_str(FILE_PATH_OPT_EXTENSION),
len);
fill_pathname_join(core_path,
config_directory, core_name, sizeof(core_path));
if (!path_is_directory(core_path) && mkdir)
path_mkdir(core_path);
return true;
}
2016-05-11 19:48:30 +00:00
/* Validates CPU features for given processor architecture.
* 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 retroarch_validate_cpu_features(void)
{
uint64_t cpu = cpu_features_get();
(void)cpu;
#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
}
2016-09-11 17:57:06 +00:00
static void retroarch_main_init_media(void)
{
2016-10-03 13:39:48 +00:00
settings_t *settings = config_get_ptr();
const char *fullpath = path_get(RARCH_PATH_CONTENT);
2016-09-11 17:57:06 +00:00
if (!settings)
return;
if ( !settings->multimedia.builtin_mediaplayer_enable &&
!settings->multimedia.builtin_imageviewer_enable
)
return;
if (string_is_empty(fullpath))
return;
switch (path_is_media_type(fullpath))
2016-09-11 17:57:06 +00:00
{
case RARCH_CONTENT_MOVIE:
case RARCH_CONTENT_MUSIC:
if (settings->multimedia.builtin_mediaplayer_enable)
{
#ifdef HAVE_FFMPEG
2016-10-01 03:51:03 +00:00
retroarch_override_setting_set(RARCH_OVERRIDE_SETTING_LIBRETRO, NULL);
2016-09-11 17:57:06 +00:00
retroarch_set_current_core_type(CORE_TYPE_FFMPEG, false);
#endif
}
break;
#ifdef HAVE_IMAGEVIEWER
case RARCH_CONTENT_IMAGE:
if (settings->multimedia.builtin_imageviewer_enable)
{
2016-10-01 03:51:03 +00:00
retroarch_override_setting_set(RARCH_OVERRIDE_SETTING_LIBRETRO, NULL);
2016-09-11 17:57:06 +00:00
retroarch_set_current_core_type(CORE_TYPE_IMAGEVIEWER, false);
}
break;
#endif
default:
break;
}
}
2015-01-11 01:21:18 +00:00
/**
2016-05-09 05:09:26 +00:00
* retroarch_main_init:
2015-01-11 01:21:18 +00:00
* @argc : Count of (commandline) arguments.
* @argv : (Commandline) arguments.
2015-01-11 01:21:18 +00:00
*
* Initializes the program.
2015-01-11 01:21:18 +00:00
*
* Returns: 0 on success, otherwise 1 if there was an error.
**/
2016-05-11 18:50:34 +00:00
bool retroarch_main_init(int argc, char *argv[])
{
2016-07-19 04:33:56 +00:00
bool init_failed = false;
2016-05-09 05:09:26 +00:00
retroarch_init_state();
2011-12-25 20:39:58 +00:00
2016-05-16 06:46:06 +00:00
if (setjmp(error_sjlj_context) > 0)
{
2016-06-20 01:54:42 +00:00
RARCH_ERR("%s: \"%s\"\n",
msg_hash_to_str(MSG_FATAL_ERROR_RECEIVED_IN), error_string);
2016-05-11 18:50:34 +00:00
return false;
}
2015-11-30 18:30:05 +00:00
rarch_ctl(RARCH_CTL_SET_ERROR_ON_INIT, NULL);
2015-11-23 14:45:02 +00:00
retro_main_log_file_init(NULL);
2016-05-09 05:24:28 +00:00
retroarch_parse_input(argc, argv);
2012-05-03 22:14:42 +00:00
2016-05-31 02:42:04 +00:00
if (verbosity_is_enabled())
2011-12-25 20:39:58 +00:00
{
char str[255];
2016-10-21 03:57:40 +00:00
str[0] = '\0';
2015-04-16 18:17:05 +00:00
2016-05-25 02:40:44 +00:00
RARCH_LOG_OUTPUT("=== Build =======================================\n");
2016-05-09 05:09:26 +00:00
retroarch_get_capabilities(RARCH_CAPABILITIES_CPU, str, sizeof(str));
2016-11-08 14:17:02 +00:00
fprintf(stderr, "%s: %s\n", msg_hash_to_str(MSG_CAPABILITIES), str);
2015-04-16 18:17:05 +00:00
fprintf(stderr, "Built: %s\n", __DATE__);
RARCH_LOG_OUTPUT("Version: %s\n", PACKAGE_VERSION);
#ifdef HAVE_GIT_VERSION
RARCH_LOG_OUTPUT("Git: %s\n", retroarch_git_version);
#endif
RARCH_LOG_OUTPUT("=================================================\n");
2011-12-25 20:39:58 +00:00
}
2016-05-11 19:48:30 +00:00
retroarch_validate_cpu_features();
2012-01-28 14:47:02 +00:00
config_load();
runloop_ctl(RUNLOOP_CTL_TASK_INIT, NULL);
2010-12-30 12:54:49 +00:00
2016-09-11 17:57:06 +00:00
retroarch_main_init_media();
2016-01-27 18:30:13 +00:00
driver_ctl(RARCH_DRIVER_CTL_INIT_PRE, NULL);
/* Attempt to initialize core */
2016-10-03 14:42:08 +00:00
if (has_set_core)
{
2016-10-03 14:42:08 +00:00
has_set_core = false;
if (!command_event(CMD_EVENT_CORE_INIT, &explicit_current_core_type))
init_failed = true;
}
else if (!command_event(CMD_EVENT_CORE_INIT, &current_core_type))
init_failed = true;
/* Handle core initialization failure */
2016-07-19 04:33:56 +00:00
if (init_failed)
{
#ifdef HAVE_MENU
/* Check if menu was active prior to core initialization */
2016-09-11 17:53:34 +00:00
if (menu_driver_ctl(RARCH_MENU_CTL_IS_ALIVE, NULL))
2016-07-19 04:33:56 +00:00
{
2016-09-11 17:53:34 +00:00
/* Attempt initializing dummy core */
2016-07-19 04:33:56 +00:00
current_core_type = CORE_TYPE_DUMMY;
if (!command_event(CMD_EVENT_CORE_INIT, &current_core_type))
goto error;
2016-07-19 04:33:56 +00:00
}
else
2016-09-11 17:53:34 +00:00
#endif
2016-07-19 04:33:56 +00:00
{
/* Fall back to regular error handling */
goto error;
}
}
2010-10-01 19:39:15 +00:00
2016-04-10 14:40:36 +00:00
driver_ctl(RARCH_DRIVER_CTL_INIT_ALL, NULL);
2016-05-09 18:51:53 +00:00
command_event(CMD_EVENT_COMMAND_INIT, NULL);
command_event(CMD_EVENT_REMOTE_INIT, NULL);
command_event(CMD_EVENT_REWIND_INIT, NULL);
command_event(CMD_EVENT_CONTROLLERS_INIT, NULL);
command_event(CMD_EVENT_RECORD_INIT, NULL);
command_event(CMD_EVENT_CHEATS_INIT, NULL);
2016-09-19 01:03:31 +00:00
path_init_savefile();
2016-05-09 18:51:53 +00:00
command_event(CMD_EVENT_SET_PER_GAME_RESOLUTION, NULL);
rarch_ctl(RARCH_CTL_UNSET_ERROR_ON_INIT, NULL);
rarch_ctl(RARCH_CTL_SET_INITED, NULL);
2016-05-11 18:50:34 +00:00
return true;
2011-08-13 02:09:08 +00:00
error:
2016-05-09 18:51:53 +00:00
command_event(CMD_EVENT_CORE_DEINIT, NULL);
rarch_ctl(RARCH_CTL_UNSET_INITED, NULL);
2016-05-11 18:50:34 +00:00
return false;
}
2015-09-27 00:16:24 +00:00
2015-09-27 00:04:53 +00:00
bool rarch_ctl(enum rarch_ctl_state state, void *data)
{
2016-09-28 05:23:14 +00:00
static bool rarch_is_sram_load_disabled = false;
static bool rarch_is_sram_save_disabled = false;
static bool rarch_use_sram = false;
2016-09-29 03:36:21 +00:00
static bool rarch_ups_pref = false;
static bool rarch_bps_pref = false;
static bool rarch_ips_pref = false;
static bool rarch_patch_blocked = false;
settings_t *settings = config_get_ptr();
2016-10-18 00:21:51 +00:00
#ifdef HAVE_THREAD_STORAGE
static sthread_tls_t rarch_tls;
const void *MAGIC_POINTER = (void*)0xB16B00B5;
#endif
2015-03-18 05:47:22 +00:00
switch(state)
{
2016-09-29 03:36:21 +00:00
case RARCH_CTL_IS_PATCH_BLOCKED:
return rarch_patch_blocked;
case RARCH_CTL_SET_PATCH_BLOCKED:
rarch_patch_blocked = true;
break;
case RARCH_CTL_UNSET_PATCH_BLOCKED:
rarch_patch_blocked = false;
break;
case RARCH_CTL_IS_BPS_PREF:
return rarch_bps_pref;
case RARCH_CTL_SET_BPS_PREF:
rarch_bps_pref = true;
break;
case RARCH_CTL_UNSET_BPS_PREF:
rarch_bps_pref = false;
break;
case RARCH_CTL_IS_UPS_PREF:
return rarch_ups_pref;
case RARCH_CTL_SET_UPS_PREF:
rarch_ups_pref = true;
break;
case RARCH_CTL_UNSET_UPS_PREF:
rarch_ups_pref = false;
break;
case RARCH_CTL_IS_IPS_PREF:
return rarch_ips_pref;
case RARCH_CTL_SET_IPS_PREF:
rarch_ips_pref = true;
break;
case RARCH_CTL_UNSET_IPS_PREF:
rarch_ips_pref = false;
break;
2016-01-20 02:10:52 +00:00
case RARCH_CTL_IS_PLAIN_CORE:
return (current_core_type == CORE_TYPE_PLAIN);
2016-01-19 22:44:32 +00:00
case RARCH_CTL_IS_DUMMY_CORE:
return (current_core_type == CORE_TYPE_DUMMY);
2016-04-05 22:30:21 +00:00
case RARCH_CTL_USERNAME_SET:
has_set_username = true;
break;
case RARCH_CTL_USERNAME_UNSET:
has_set_username = false;
break;
case RARCH_CTL_HAS_SET_USERNAME:
return has_set_username;
case RARCH_CTL_IS_INITED:
return rarch_is_inited;
case RARCH_CTL_UNSET_INITED:
rarch_is_inited = false;
break;
case RARCH_CTL_SET_INITED:
rarch_is_inited = true;
break;
2015-12-07 14:03:54 +00:00
case RARCH_CTL_DESTROY:
2016-04-10 14:40:36 +00:00
has_set_username = false;
rarch_is_inited = false;
rarch_error_on_init = false;
rarch_block_config_read = false;
rarch_force_fullscreen = false;
runloop_ctl(RUNLOOP_CTL_MSG_QUEUE_DEINIT, NULL);
driver_ctl(RARCH_DRIVER_CTL_UNINIT_ALL, NULL);
2016-05-09 18:51:53 +00:00
command_event(CMD_EVENT_LOG_FILE_DEINIT, NULL);
2016-04-10 14:40:36 +00:00
runloop_ctl(RUNLOOP_CTL_STATE_FREE, NULL);
runloop_ctl(RUNLOOP_CTL_GLOBAL_FREE, NULL);
runloop_ctl(RUNLOOP_CTL_DATA_DEINIT, NULL);
config_free();
break;
case RARCH_CTL_DEINIT:
2016-04-10 14:40:36 +00:00
if (!rarch_ctl(RARCH_CTL_IS_INITED, NULL))
return false;
2016-02-04 19:26:36 +00:00
2016-04-10 14:40:36 +00:00
driver_ctl(RARCH_DRIVER_CTL_UNINIT_ALL, NULL);
break;
2015-12-07 14:01:53 +00:00
case RARCH_CTL_PREINIT:
2016-05-09 18:51:53 +00:00
command_event(CMD_EVENT_HISTORY_DEINIT, NULL);
2016-05-27 03:05:27 +00:00
config_init();
2015-12-07 14:01:53 +00:00
runloop_ctl(RUNLOOP_CTL_CLEAR_STATE, NULL);
break;
case RARCH_CTL_MAIN_DEINIT:
if (!rarch_ctl(RARCH_CTL_IS_INITED, NULL))
return false;
2016-05-09 18:51:53 +00:00
command_event(CMD_EVENT_NETPLAY_DEINIT, NULL);
command_event(CMD_EVENT_COMMAND_DEINIT, NULL);
command_event(CMD_EVENT_REMOTE_DEINIT, NULL);
2016-04-10 13:52:06 +00:00
2016-05-09 18:51:53 +00:00
command_event(CMD_EVENT_AUTOSAVE_DEINIT, NULL);
2016-04-10 13:52:06 +00:00
2016-05-09 18:51:53 +00:00
command_event(CMD_EVENT_RECORD_DEINIT, NULL);
event_save_files();
2016-04-10 13:52:06 +00:00
2016-05-09 18:51:53 +00:00
command_event(CMD_EVENT_REWIND_DEINIT, NULL);
command_event(CMD_EVENT_CHEATS_DEINIT, NULL);
command_event(CMD_EVENT_BSV_MOVIE_DEINIT, NULL);
2016-04-10 13:52:06 +00:00
2016-05-09 18:51:53 +00:00
command_event(CMD_EVENT_CORE_DEINIT, NULL);
2016-04-10 13:52:06 +00:00
2016-05-09 18:51:53 +00:00
command_event(CMD_EVENT_TEMPORARY_CONTENT_DEINIT, NULL);
2016-09-19 01:03:31 +00:00
2016-09-25 13:49:09 +00:00
path_deinit_subsystem();
2016-09-19 01:03:31 +00:00
path_deinit_savefile();
2016-04-10 13:52:06 +00:00
rarch_ctl(RARCH_CTL_UNSET_INITED, NULL);
2016-10-18 00:21:51 +00:00
#ifdef HAVE_THREAD_STORAGE
sthread_tls_delete(&rarch_tls);
#endif
break;
case RARCH_CTL_INIT:
rarch_ctl(RARCH_CTL_DEINIT, NULL);
2016-10-18 00:21:51 +00:00
#ifdef HAVE_THREAD_STORAGE
sthread_tls_create(&rarch_tls);
sthread_tls_set(&rarch_tls, MAGIC_POINTER);
#endif
2016-05-09 05:09:26 +00:00
retroarch_init_state();
{
unsigned i;
for (i = 0; i < MAX_USERS; i++)
settings->input.libretro_device[i] = RETRO_DEVICE_JOYPAD;
}
runloop_ctl(RUNLOOP_CTL_HTTPSERVER_INIT, NULL);
runloop_ctl(RUNLOOP_CTL_MSG_QUEUE_INIT, NULL);
break;
2015-12-07 13:30:36 +00:00
case RARCH_CTL_SET_PATHS_REDIRECT:
if (content_does_not_need_content())
return false;
2016-09-17 10:16:11 +00:00
path_set_redirect();
2015-12-07 13:30:36 +00:00
break;
2016-09-28 05:23:14 +00:00
case RARCH_CTL_IS_SRAM_LOAD_DISABLED:
return rarch_is_sram_load_disabled;
case RARCH_CTL_SET_SRAM_LOAD_DISABLED:
rarch_is_sram_load_disabled = true;
break;
case RARCH_CTL_UNSET_SRAM_LOAD_DISABLED:
rarch_is_sram_load_disabled = false;
break;
case RARCH_CTL_IS_SRAM_SAVE_DISABLED:
return rarch_is_sram_save_disabled;
case RARCH_CTL_SET_SRAM_SAVE_DISABLED:
rarch_is_sram_save_disabled = true;
break;
case RARCH_CTL_UNSET_SRAM_SAVE_DISABLED:
rarch_is_sram_save_disabled = false;
break;
case RARCH_CTL_IS_SRAM_USED:
return rarch_use_sram;
2016-01-27 18:53:07 +00:00
case RARCH_CTL_SET_SRAM_ENABLE:
rarch_use_sram = rarch_ctl(RARCH_CTL_IS_PLAIN_CORE, NULL)
&& !content_does_not_need_content();
break;
case RARCH_CTL_SET_SRAM_ENABLE_FORCE:
rarch_use_sram = true;
break;
case RARCH_CTL_UNSET_SRAM_ENABLE:
rarch_use_sram = false;
2016-01-27 18:53:07 +00:00
break;
case RARCH_CTL_SET_ERROR_ON_INIT:
rarch_error_on_init = true;
break;
case RARCH_CTL_UNSET_ERROR_ON_INIT:
rarch_error_on_init = false;
break;
case RARCH_CTL_IS_ERROR_ON_INIT:
return rarch_error_on_init;
2015-11-30 21:02:54 +00:00
case RARCH_CTL_SET_FORCE_FULLSCREEN:
rarch_force_fullscreen = true;
break;
case RARCH_CTL_UNSET_FORCE_FULLSCREEN:
rarch_force_fullscreen = false;
break;
2015-11-30 21:02:54 +00:00
case RARCH_CTL_IS_FORCE_FULLSCREEN:
return rarch_force_fullscreen;
2015-11-30 21:09:28 +00:00
case RARCH_CTL_SET_BLOCK_CONFIG_READ:
rarch_block_config_read = true;
break;
case RARCH_CTL_UNSET_BLOCK_CONFIG_READ:
rarch_block_config_read = false;
break;
case RARCH_CTL_IS_BLOCK_CONFIG_READ:
return rarch_block_config_read;
case RARCH_CTL_MENU_RUNNING:
#ifdef HAVE_MENU
2015-12-06 16:41:00 +00:00
menu_driver_ctl(RARCH_MENU_CTL_SET_TOGGLE, NULL);
#endif
#ifdef HAVE_OVERLAY
if (settings->input.overlay_hide_in_menu)
2016-05-09 18:51:53 +00:00
command_event(CMD_EVENT_OVERLAY_DEINIT, NULL);
2015-06-28 15:21:32 +00:00
#endif
break;
case RARCH_CTL_MENU_RUNNING_FINISHED:
#ifdef HAVE_MENU
2015-12-06 16:41:00 +00:00
menu_driver_ctl(RARCH_MENU_CTL_UNSET_TOGGLE, NULL);
#endif
video_driver_set_texture_enable(false, false);
#ifdef HAVE_OVERLAY
2015-07-18 13:07:16 +00:00
if (settings && settings->input.overlay_hide_in_menu)
2016-05-09 18:51:53 +00:00
command_event(CMD_EVENT_OVERLAY_INIT, NULL);
#endif
break;
case RARCH_CTL_IS_MAIN_THREAD:
2016-10-18 00:21:51 +00:00
#ifdef HAVE_THREAD_STORAGE
return sthread_tls_get(&rarch_tls) == MAGIC_POINTER;
#else
return true;
#endif
case RARCH_CTL_NONE:
default:
2015-09-27 00:04:53 +00:00
return false;
}
2015-09-27 00:04:53 +00:00
return true;
}
2016-08-01 18:47:19 +00:00
2016-10-01 04:05:08 +00:00
bool retroarch_override_setting_is_set(enum rarch_override_setting enum_idx, void *data)
{
switch (enum_idx)
{
2016-10-01 04:06:07 +00:00
case RARCH_OVERRIDE_SETTING_LIBRETRO_DEVICE:
{
unsigned *val = (unsigned*)data;
if (val)
{
unsigned bit = *val;
return BIT128_GET(has_set_libretro_device, bit);
}
}
break;
case RARCH_OVERRIDE_SETTING_VERBOSITY:
return has_set_verbosity;
2016-08-01 18:47:19 +00:00
case RARCH_OVERRIDE_SETTING_LIBRETRO:
return has_set_libretro;
2016-08-01 19:51:23 +00:00
case RARCH_OVERRIDE_SETTING_LIBRETRO_DIRECTORY:
return has_set_libretro_directory;
case RARCH_OVERRIDE_SETTING_SAVE_PATH:
return has_set_save_path;
case RARCH_OVERRIDE_SETTING_STATE_PATH:
return has_set_state_path;
case RARCH_OVERRIDE_SETTING_NETPLAY_MODE:
return has_set_netplay_mode;
case RARCH_OVERRIDE_SETTING_NETPLAY_IP_ADDRESS:
return has_set_netplay_ip_address;
case RARCH_OVERRIDE_SETTING_NETPLAY_IP_PORT:
return has_set_netplay_ip_port;
case RARCH_OVERRIDE_SETTING_NETPLAY_DELAY_FRAMES:
return has_set_netplay_delay_frames;
case RARCH_OVERRIDE_SETTING_NETPLAY_CHECK_FRAMES:
return has_set_netplay_check_frames;
2016-08-01 19:51:23 +00:00
case RARCH_OVERRIDE_SETTING_UPS_PREF:
return has_set_ups_pref;
case RARCH_OVERRIDE_SETTING_BPS_PREF:
return has_set_bps_pref;
case RARCH_OVERRIDE_SETTING_IPS_PREF:
return has_set_ips_pref;
case RARCH_OVERRIDE_SETTING_NONE:
default:
break;
}
return false;
}
2016-10-01 03:51:03 +00:00
void retroarch_override_setting_set(enum rarch_override_setting enum_idx, void *data)
2016-08-01 18:41:42 +00:00
{
switch (enum_idx)
{
case RARCH_OVERRIDE_SETTING_LIBRETRO_DEVICE:
{
unsigned *val = (unsigned*)data;
if (val)
{
unsigned bit = *val;
BIT128_SET(has_set_libretro_device, bit);
}
}
break;
case RARCH_OVERRIDE_SETTING_VERBOSITY:
has_set_verbosity = true;
break;
2016-08-01 18:47:19 +00:00
case RARCH_OVERRIDE_SETTING_LIBRETRO:
has_set_libretro = true;
break;
2016-08-01 19:51:23 +00:00
case RARCH_OVERRIDE_SETTING_LIBRETRO_DIRECTORY:
has_set_libretro_directory = true;
break;
case RARCH_OVERRIDE_SETTING_SAVE_PATH:
has_set_save_path = true;
break;
case RARCH_OVERRIDE_SETTING_STATE_PATH:
has_set_state_path = true;
break;
case RARCH_OVERRIDE_SETTING_NETPLAY_MODE:
has_set_netplay_mode = true;
break;
case RARCH_OVERRIDE_SETTING_NETPLAY_IP_ADDRESS:
has_set_netplay_ip_address = true;
break;
case RARCH_OVERRIDE_SETTING_NETPLAY_IP_PORT:
has_set_netplay_ip_port = true;
break;
case RARCH_OVERRIDE_SETTING_NETPLAY_DELAY_FRAMES:
has_set_netplay_delay_frames = true;
break;
case RARCH_OVERRIDE_SETTING_NETPLAY_CHECK_FRAMES:
has_set_netplay_check_frames = true;
break;
2016-08-01 19:51:23 +00:00
case RARCH_OVERRIDE_SETTING_UPS_PREF:
has_set_ups_pref = true;
break;
case RARCH_OVERRIDE_SETTING_BPS_PREF:
has_set_bps_pref = true;
break;
case RARCH_OVERRIDE_SETTING_IPS_PREF:
has_set_ips_pref = true;
break;
2016-08-01 18:41:42 +00:00
case RARCH_OVERRIDE_SETTING_NONE:
default:
break;
}
}
void retroarch_override_setting_unset(enum rarch_override_setting enum_idx, void *data)
2016-08-01 18:41:42 +00:00
{
switch (enum_idx)
{
case RARCH_OVERRIDE_SETTING_LIBRETRO_DEVICE:
{
unsigned *val = (unsigned*)data;
if (val)
{
unsigned bit = *val;
BIT128_CLEAR(has_set_libretro_device, bit);
}
}
break;
case RARCH_OVERRIDE_SETTING_VERBOSITY:
has_set_verbosity = false;
break;
2016-08-01 18:47:19 +00:00
case RARCH_OVERRIDE_SETTING_LIBRETRO:
has_set_libretro = false;
break;
2016-08-01 19:51:23 +00:00
case RARCH_OVERRIDE_SETTING_LIBRETRO_DIRECTORY:
has_set_libretro_directory = false;
break;
case RARCH_OVERRIDE_SETTING_SAVE_PATH:
has_set_save_path = false;
break;
case RARCH_OVERRIDE_SETTING_STATE_PATH:
has_set_state_path = false;
break;
case RARCH_OVERRIDE_SETTING_NETPLAY_MODE:
has_set_netplay_mode = false;
break;
case RARCH_OVERRIDE_SETTING_NETPLAY_IP_ADDRESS:
has_set_netplay_ip_address = false;
break;
case RARCH_OVERRIDE_SETTING_NETPLAY_IP_PORT:
has_set_netplay_ip_port = false;
break;
case RARCH_OVERRIDE_SETTING_NETPLAY_DELAY_FRAMES:
has_set_netplay_delay_frames = false;
break;
case RARCH_OVERRIDE_SETTING_NETPLAY_CHECK_FRAMES:
has_set_netplay_check_frames = false;
break;
2016-08-01 19:51:23 +00:00
case RARCH_OVERRIDE_SETTING_UPS_PREF:
has_set_ups_pref = false;
break;
case RARCH_OVERRIDE_SETTING_BPS_PREF:
has_set_bps_pref = false;
break;
case RARCH_OVERRIDE_SETTING_IPS_PREF:
has_set_ips_pref = false;
break;
2016-08-01 18:41:42 +00:00
case RARCH_OVERRIDE_SETTING_NONE:
default:
break;
}
}
void retroarch_override_setting_free_state(void)
{
2016-08-01 18:48:02 +00:00
unsigned i;
for (i = 0; i < RARCH_OVERRIDE_SETTING_LAST; i++)
{
if (i == RARCH_OVERRIDE_SETTING_LIBRETRO_DEVICE)
{
unsigned j;
for (j = 0; j < MAX_USERS; j++)
retroarch_override_setting_unset((enum rarch_override_setting)(i), &j);
}
else
retroarch_override_setting_unset((enum rarch_override_setting)(i), NULL);
}
2016-08-01 18:41:42 +00:00
}
2016-05-09 05:09:26 +00:00
int retroarch_get_capabilities(enum rarch_capabilities type,
2016-01-26 04:38:40 +00:00
char *s, size_t len)
2015-11-28 19:11:55 +00:00
{
switch (type)
{
case RARCH_CAPABILITIES_CPU:
{
2016-05-10 07:17:04 +00:00
uint64_t cpu = cpu_features_get();
2015-11-28 19:11:55 +00:00
if (cpu & RETRO_SIMD_MMX)
strlcat(s, "MMX ", len);
if (cpu & RETRO_SIMD_MMXEXT)
strlcat(s, "MMXEXT ", len);
if (cpu & RETRO_SIMD_SSE)
strlcat(s, "SSE1 ", len);
if (cpu & RETRO_SIMD_SSE2)
strlcat(s, "SSE2 ", len);
if (cpu & RETRO_SIMD_SSE3)
strlcat(s, "SSE3 ", len);
if (cpu & RETRO_SIMD_SSSE3)
strlcat(s, "SSSE3 ", len);
if (cpu & RETRO_SIMD_SSE4)
strlcat(s, "SSE4 ", len);
if (cpu & RETRO_SIMD_SSE42)
strlcat(s, "SSE4.2 ", len);
if (cpu & RETRO_SIMD_AVX)
strlcat(s, "AVX ", len);
if (cpu & RETRO_SIMD_AVX2)
strlcat(s, "AVX2 ", len);
if (cpu & RETRO_SIMD_VFPU)
strlcat(s, "VFPU ", len);
if (cpu & RETRO_SIMD_NEON)
strlcat(s, "NEON ", len);
2016-05-14 11:37:07 +00:00
if (cpu & RETRO_SIMD_VFPV3)
strlcat(s, "VFPv3 ", len);
if (cpu & RETRO_SIMD_VFPV4)
strlcat(s, "VFPv4 ", len);
2015-11-28 19:11:55 +00:00
if (cpu & RETRO_SIMD_PS)
strlcat(s, "PS ", len);
if (cpu & RETRO_SIMD_AES)
strlcat(s, "AES ", len);
if (cpu & RETRO_SIMD_VMX)
strlcat(s, "VMX ", len);
if (cpu & RETRO_SIMD_VMX128)
strlcat(s, "VMX128 ", len);
2016-10-18 15:39:02 +00:00
if (cpu & RETRO_SIMD_ASIMD)
strlcat(s, "ASIMD ", len);
2015-11-28 19:11:55 +00:00
}
break;
case RARCH_CAPABILITIES_COMPILER:
#if defined(_MSC_VER)
2016-11-08 14:17:02 +00:00
snprintf(s, len, "%s: MSVC (%d) %u-bit",
msg_hash_to_str(MSG_COMPILER),
_MSC_VER, (unsigned)
2015-11-28 19:11:55 +00:00
(CHAR_BIT * sizeof(size_t)));
#elif defined(__SNC__)
2016-11-08 14:17:02 +00:00
snprintf(s, len, "%s: SNC (%d) %u-bit",
msg_hash_to_str(MSG_COMPILER),
2015-11-28 19:11:55 +00:00
__SN_VER__, (unsigned)(CHAR_BIT * sizeof(size_t)));
#elif defined(_WIN32) && defined(__GNUC__)
2016-11-08 14:17:02 +00:00
snprintf(s, len, "%s: MinGW (%d.%d.%d) %u-bit",
msg_hash_to_str(MSG_COMPILER),
2015-11-28 19:11:55 +00:00
__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__, (unsigned)
(CHAR_BIT * sizeof(size_t)));
#elif defined(__clang__)
2016-11-08 14:17:02 +00:00
snprintf(s, len, "%s: Clang/LLVM (%s) %u-bit",
msg_hash_to_str(MSG_COMPILER),
2015-11-28 19:11:55 +00:00
__clang_version__, (unsigned)(CHAR_BIT * sizeof(size_t)));
#elif defined(__GNUC__)
2016-11-08 14:17:02 +00:00
snprintf(s, len, "%s: GCC (%d.%d.%d) %u-bit",
msg_hash_to_str(MSG_COMPILER),
2015-11-28 19:11:55 +00:00
__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__, (unsigned)
(CHAR_BIT * sizeof(size_t)));
#else
2016-11-08 14:17:02 +00:00
snprintf(s, len, "%s %u-bit",
msg_hash_to_str(MSG_UNKNOWN_COMPILER),
2015-11-28 19:11:55 +00:00
(unsigned)(CHAR_BIT * sizeof(size_t)));
#endif
break;
default:
case RARCH_CAPABILITIES_NONE:
break;
}
return 0;
}
2015-11-29 01:27:48 +00:00
void retroarch_set_current_core_type(enum rarch_core_type type, bool explicitly_set)
2016-05-27 17:26:45 +00:00
{
2016-10-03 14:42:08 +00:00
if (explicitly_set && !has_set_core)
{
2016-10-03 14:42:08 +00:00
has_set_core = true;
explicit_current_core_type = type;
current_core_type = type;
}
2016-10-03 14:42:08 +00:00
else if (!has_set_core)
current_core_type = type;
2016-05-27 17:26:45 +00:00
}
2015-11-29 01:27:48 +00:00
/**
2016-05-09 05:09:26 +00:00
* retroarch_fail:
2015-11-29 01:27:48 +00:00
* @error_code : Error code.
* @error : Error message to show.
*
* Sanely kills the program.
**/
2016-05-09 05:09:26 +00:00
void retroarch_fail(int error_code, const char *error)
2015-11-29 01:27:48 +00:00
{
2016-05-09 05:09:26 +00:00
/* We cannot longjmp unless we're in retroarch_main_init().
* If not, something went very wrong, and we should
2015-11-29 01:27:48 +00:00
* just exit right away. */
retro_assert(rarch_ctl(RARCH_CTL_IS_ERROR_ON_INIT, NULL));
2015-11-29 01:27:48 +00:00
2015-11-30 18:30:05 +00:00
strlcpy(error_string, error, sizeof(error_string));
longjmp(error_sjlj_context, error_code);
2015-11-29 01:27:48 +00:00
}