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
|
2017-03-22 02:09:18 +00:00
|
|
|
* Copyright (C) 2011-2017 - Daniel De Matteis
|
|
|
|
* Copyright (C) 2014-2017 - Jean-André Santoni
|
2019-06-16 18:32:27 +00:00
|
|
|
* Copyright (C) 2015-2019 - Andrés Suárez
|
2019-01-09 22:19:19 +00:00
|
|
|
* Copyright (C) 2016-2019 - Brad Parker
|
2015-04-05 16:14:24 +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-12-30 00:50:37 +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-12-30 00:50:37 +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-12-30 00:50:37 +00:00
|
|
|
* If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
*/
|
|
|
|
|
2015-06-22 18:42:41 +00:00
|
|
|
#include <ctype.h>
|
|
|
|
|
2017-12-11 11:15:00 +00:00
|
|
|
#include <libretro.h>
|
2014-10-22 01:35:04 +00:00
|
|
|
#include <file/config_file.h>
|
2015-06-22 18:42:41 +00:00
|
|
|
#include <file/file_path.h>
|
2014-10-21 05:58:58 +00:00
|
|
|
#include <compat/strl.h>
|
|
|
|
#include <compat/posix_string.h>
|
2016-02-05 12:51:30 +00:00
|
|
|
#include <retro_assert.h>
|
2015-12-26 06:19:04 +00:00
|
|
|
#include <string/stdstring.h>
|
2017-10-29 16:08:20 +00:00
|
|
|
#include <streams/file_stream.h>
|
2015-06-22 18:42:41 +00:00
|
|
|
|
2016-09-08 03:48:43 +00:00
|
|
|
#ifdef HAVE_CONFIG_H
|
|
|
|
#include "config.h"
|
|
|
|
#endif
|
|
|
|
|
2016-05-01 13:07:45 +00:00
|
|
|
#include "file_path_special.h"
|
2015-12-02 02:16:04 +00:00
|
|
|
#include "configuration.h"
|
2016-05-27 14:42:20 +00:00
|
|
|
#include "content.h"
|
2011-01-08 21:15:02 +00:00
|
|
|
#include "config.def.h"
|
2017-06-21 23:28:40 +00:00
|
|
|
#include "config.features.h"
|
2015-01-12 01:52:52 +00:00
|
|
|
#include "input/input_keymaps.h"
|
2015-01-24 22:49:35 +00:00
|
|
|
#include "input/input_remapping.h"
|
2017-12-27 16:05:12 +00:00
|
|
|
#include "led/led_defines.h"
|
2015-12-06 21:48:57 +00:00
|
|
|
#include "defaults.h"
|
2016-05-08 03:29:10 +00:00
|
|
|
#include "core.h"
|
2016-09-17 10:35:29 +00:00
|
|
|
#include "paths.h"
|
2015-11-30 21:02:54 +00:00
|
|
|
#include "retroarch.h"
|
2015-11-23 11:03:38 +00:00
|
|
|
#include "verbosity.h"
|
2016-03-21 22:46:36 +00:00
|
|
|
#include "lakka.h"
|
2011-01-07 16:59:53 +00:00
|
|
|
|
2019-01-20 02:16:58 +00:00
|
|
|
#include "tasks/task_content.h"
|
2016-05-27 14:42:20 +00:00
|
|
|
#include "tasks/tasks_internal.h"
|
|
|
|
|
2019-07-23 03:34:14 +00:00
|
|
|
#include "list_special.h"
|
2018-06-04 05:48:08 +00:00
|
|
|
|
2019-01-02 12:30:58 +00:00
|
|
|
#if defined(__WINRT__) || defined(WINAPI_FAMILY) && WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP
|
2018-12-28 11:41:38 +00:00
|
|
|
#include "uwp/uwp_func.h"
|
|
|
|
#endif
|
|
|
|
|
2017-11-13 21:59:23 +00:00
|
|
|
static const char* invalid_filename_chars[] = {
|
|
|
|
/* https://support.microsoft.com/en-us/help/905231/information-about-the-characters-that-you-cannot-use-in-site-names--fo */
|
|
|
|
"~", "#", "%", "&", "*", "{", "}", "\\", ":", "[", "]", "?", "/", "|", "\'", "\"",
|
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
2016-09-01 16:53:34 +00:00
|
|
|
/* All config related settings go here. */
|
|
|
|
|
2016-09-05 15:16:37 +00:00
|
|
|
struct config_bool_setting
|
2017-07-14 19:11:27 +00:00
|
|
|
{
|
2016-09-01 16:53:34 +00:00
|
|
|
const char *ident;
|
|
|
|
bool *ptr;
|
|
|
|
bool def_enable;
|
|
|
|
bool def;
|
|
|
|
bool handle;
|
2018-03-09 22:23:34 +00:00
|
|
|
enum rarch_override_setting override;
|
2016-09-01 16:53:34 +00:00
|
|
|
};
|
|
|
|
|
2016-09-05 15:16:37 +00:00
|
|
|
struct config_int_setting
|
2017-07-14 19:11:27 +00:00
|
|
|
{
|
2017-04-28 17:55:09 +00:00
|
|
|
const char *ident;
|
2017-09-08 22:12:40 +00:00
|
|
|
int *ptr;
|
2017-09-08 22:17:14 +00:00
|
|
|
bool def_enable;
|
2017-09-08 22:12:40 +00:00
|
|
|
int def;
|
2017-09-08 22:17:14 +00:00
|
|
|
bool handle;
|
2018-03-09 22:23:34 +00:00
|
|
|
enum rarch_override_setting override;
|
2017-04-28 17:55:09 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
struct config_uint_setting
|
2017-07-14 19:11:27 +00:00
|
|
|
{
|
2016-09-01 16:53:34 +00:00
|
|
|
const char *ident;
|
2017-09-08 22:12:40 +00:00
|
|
|
unsigned *ptr;
|
2017-09-08 22:17:14 +00:00
|
|
|
bool def_enable;
|
2017-09-08 22:12:40 +00:00
|
|
|
unsigned def;
|
2017-09-08 22:17:14 +00:00
|
|
|
bool handle;
|
2018-03-09 22:23:34 +00:00
|
|
|
enum rarch_override_setting override;
|
2016-09-01 16:53:34 +00:00
|
|
|
};
|
|
|
|
|
2018-07-13 20:12:09 +00:00
|
|
|
struct config_size_setting
|
|
|
|
{
|
|
|
|
const char *ident;
|
|
|
|
size_t *ptr;
|
|
|
|
bool def_enable;
|
|
|
|
size_t def;
|
|
|
|
bool handle;
|
|
|
|
enum rarch_override_setting override;
|
|
|
|
};
|
|
|
|
|
2016-09-05 15:16:37 +00:00
|
|
|
struct config_float_setting
|
2017-07-14 19:11:27 +00:00
|
|
|
{
|
2016-09-01 16:53:34 +00:00
|
|
|
const char *ident;
|
2017-09-08 22:12:40 +00:00
|
|
|
float *ptr;
|
2017-09-08 22:17:14 +00:00
|
|
|
bool def_enable;
|
2017-09-08 22:12:40 +00:00
|
|
|
float def;
|
2017-09-08 22:17:14 +00:00
|
|
|
bool handle;
|
2018-03-09 22:23:34 +00:00
|
|
|
enum rarch_override_setting override;
|
2016-09-01 16:53:34 +00:00
|
|
|
};
|
|
|
|
|
2016-09-05 15:16:37 +00:00
|
|
|
struct config_array_setting
|
2017-07-14 19:11:27 +00:00
|
|
|
{
|
2016-09-01 16:53:34 +00:00
|
|
|
const char *ident;
|
|
|
|
char *ptr;
|
2017-09-08 22:12:40 +00:00
|
|
|
bool def_enable;
|
2017-09-08 22:17:14 +00:00
|
|
|
const char *def;
|
2016-09-01 16:53:34 +00:00
|
|
|
bool handle;
|
2018-03-09 22:23:34 +00:00
|
|
|
enum rarch_override_setting override;
|
2016-09-01 16:53:34 +00:00
|
|
|
};
|
|
|
|
|
2016-09-05 15:16:37 +00:00
|
|
|
struct config_path_setting
|
2017-07-14 19:11:27 +00:00
|
|
|
{
|
2016-09-01 16:53:34 +00:00
|
|
|
const char *ident;
|
|
|
|
char *ptr;
|
2017-09-08 22:12:40 +00:00
|
|
|
bool def_enable;
|
2017-09-08 22:17:14 +00:00
|
|
|
char *def;
|
2016-09-01 16:53:34 +00:00
|
|
|
bool handle;
|
|
|
|
};
|
|
|
|
|
2017-05-08 00:25:55 +00:00
|
|
|
enum video_driver_enum
|
|
|
|
{
|
|
|
|
VIDEO_GL = 0,
|
2019-04-24 01:23:57 +00:00
|
|
|
VIDEO_GL1,
|
|
|
|
VIDEO_GL_CORE,
|
2017-05-08 00:25:55 +00:00
|
|
|
VIDEO_VULKAN,
|
2018-07-13 04:33:18 +00:00
|
|
|
VIDEO_METAL,
|
2017-05-08 00:25:55 +00:00
|
|
|
VIDEO_DRM,
|
|
|
|
VIDEO_XVIDEO,
|
|
|
|
VIDEO_SDL,
|
|
|
|
VIDEO_SDL2,
|
|
|
|
VIDEO_EXT,
|
|
|
|
VIDEO_WII,
|
|
|
|
VIDEO_WIIU,
|
|
|
|
VIDEO_XENON360,
|
|
|
|
VIDEO_PSP1,
|
|
|
|
VIDEO_VITA2D,
|
2018-09-18 06:08:06 +00:00
|
|
|
VIDEO_PS2,
|
2017-05-08 00:25:55 +00:00
|
|
|
VIDEO_CTR,
|
2017-12-24 01:26:58 +00:00
|
|
|
VIDEO_SWITCH,
|
2018-01-23 01:55:33 +00:00
|
|
|
VIDEO_D3D8,
|
2017-05-08 00:25:55 +00:00
|
|
|
VIDEO_D3D9,
|
2018-01-23 17:04:55 +00:00
|
|
|
VIDEO_D3D10,
|
2018-01-21 03:10:45 +00:00
|
|
|
VIDEO_D3D11,
|
|
|
|
VIDEO_D3D12,
|
2017-05-08 00:25:55 +00:00
|
|
|
VIDEO_VG,
|
|
|
|
VIDEO_OMAP,
|
|
|
|
VIDEO_EXYNOS,
|
|
|
|
VIDEO_SUNXI,
|
|
|
|
VIDEO_DISPMANX,
|
|
|
|
VIDEO_CACA,
|
|
|
|
VIDEO_GDI,
|
|
|
|
VIDEO_VGA,
|
2019-09-17 06:16:50 +00:00
|
|
|
VIDEO_FPGA,
|
2017-05-08 00:25:55 +00:00
|
|
|
VIDEO_NULL
|
|
|
|
};
|
|
|
|
|
|
|
|
enum audio_driver_enum
|
|
|
|
{
|
|
|
|
AUDIO_RSOUND = VIDEO_NULL + 1,
|
2019-05-09 17:30:44 +00:00
|
|
|
AUDIO_AUDIOIO,
|
2017-05-08 00:25:55 +00:00
|
|
|
AUDIO_OSS,
|
|
|
|
AUDIO_ALSA,
|
|
|
|
AUDIO_ALSATHREAD,
|
2017-06-24 01:44:00 +00:00
|
|
|
AUDIO_TINYALSA,
|
2017-05-08 00:25:55 +00:00
|
|
|
AUDIO_ROAR,
|
|
|
|
AUDIO_AL,
|
|
|
|
AUDIO_SL,
|
|
|
|
AUDIO_JACK,
|
|
|
|
AUDIO_SDL,
|
|
|
|
AUDIO_SDL2,
|
|
|
|
AUDIO_XAUDIO,
|
|
|
|
AUDIO_PULSE,
|
|
|
|
AUDIO_EXT,
|
|
|
|
AUDIO_DSOUND,
|
|
|
|
AUDIO_WASAPI,
|
|
|
|
AUDIO_COREAUDIO,
|
2019-01-31 22:14:20 +00:00
|
|
|
AUDIO_COREAUDIO3,
|
2017-05-08 00:25:55 +00:00
|
|
|
AUDIO_PS3,
|
|
|
|
AUDIO_XENON360,
|
|
|
|
AUDIO_WII,
|
|
|
|
AUDIO_WIIU,
|
|
|
|
AUDIO_RWEBAUDIO,
|
|
|
|
AUDIO_PSP,
|
2018-09-18 06:08:06 +00:00
|
|
|
AUDIO_PS2,
|
2017-05-08 00:25:55 +00:00
|
|
|
AUDIO_CTR,
|
2017-12-24 22:33:48 +00:00
|
|
|
AUDIO_SWITCH,
|
2017-05-08 00:25:55 +00:00
|
|
|
AUDIO_NULL
|
|
|
|
};
|
|
|
|
|
|
|
|
enum audio_resampler_driver_enum
|
|
|
|
{
|
|
|
|
AUDIO_RESAMPLER_CC = AUDIO_NULL + 1,
|
|
|
|
AUDIO_RESAMPLER_SINC,
|
|
|
|
AUDIO_RESAMPLER_NEAREST,
|
|
|
|
AUDIO_RESAMPLER_NULL
|
|
|
|
};
|
|
|
|
|
|
|
|
enum input_driver_enum
|
|
|
|
{
|
|
|
|
INPUT_ANDROID = AUDIO_RESAMPLER_NULL + 1,
|
|
|
|
INPUT_SDL,
|
|
|
|
INPUT_SDL2,
|
|
|
|
INPUT_X,
|
|
|
|
INPUT_WAYLAND,
|
|
|
|
INPUT_DINPUT,
|
2018-12-30 00:29:34 +00:00
|
|
|
INPUT_PS4,
|
2017-05-08 00:25:55 +00:00
|
|
|
INPUT_PS3,
|
|
|
|
INPUT_PSP,
|
2018-09-18 06:08:06 +00:00
|
|
|
INPUT_PS2,
|
2017-05-08 00:25:55 +00:00
|
|
|
INPUT_CTR,
|
2017-12-24 01:26:58 +00:00
|
|
|
INPUT_SWITCH,
|
2017-05-08 00:25:55 +00:00
|
|
|
INPUT_XENON360,
|
|
|
|
INPUT_WII,
|
|
|
|
INPUT_WIIU,
|
|
|
|
INPUT_XINPUT,
|
2018-12-28 11:29:04 +00:00
|
|
|
INPUT_UWP,
|
2017-05-08 00:25:55 +00:00
|
|
|
INPUT_UDEV,
|
|
|
|
INPUT_LINUXRAW,
|
|
|
|
INPUT_COCOA,
|
|
|
|
INPUT_QNX,
|
|
|
|
INPUT_RWEBINPUT,
|
|
|
|
INPUT_DOS,
|
2019-02-26 13:20:00 +00:00
|
|
|
INPUT_WINRAW,
|
2017-05-08 00:25:55 +00:00
|
|
|
INPUT_NULL
|
|
|
|
};
|
|
|
|
|
|
|
|
enum joypad_driver_enum
|
|
|
|
{
|
|
|
|
JOYPAD_PS3 = INPUT_NULL + 1,
|
|
|
|
JOYPAD_XINPUT,
|
|
|
|
JOYPAD_GX,
|
|
|
|
JOYPAD_WIIU,
|
|
|
|
JOYPAD_XDK,
|
2018-12-30 13:00:18 +00:00
|
|
|
JOYPAD_PS4,
|
2017-05-08 00:25:55 +00:00
|
|
|
JOYPAD_PSP,
|
2018-09-18 06:08:06 +00:00
|
|
|
JOYPAD_PS2,
|
2017-05-08 00:25:55 +00:00
|
|
|
JOYPAD_CTR,
|
2017-12-24 01:26:58 +00:00
|
|
|
JOYPAD_SWITCH,
|
2017-05-08 00:25:55 +00:00
|
|
|
JOYPAD_DINPUT,
|
|
|
|
JOYPAD_UDEV,
|
|
|
|
JOYPAD_LINUXRAW,
|
|
|
|
JOYPAD_ANDROID,
|
|
|
|
JOYPAD_SDL,
|
|
|
|
JOYPAD_DOS,
|
|
|
|
JOYPAD_HID,
|
|
|
|
JOYPAD_QNX,
|
2018-01-15 06:06:57 +00:00
|
|
|
JOYPAD_RWEBPAD,
|
2018-01-25 01:20:52 +00:00
|
|
|
JOYPAD_MFI,
|
2017-05-08 00:25:55 +00:00
|
|
|
JOYPAD_NULL
|
|
|
|
};
|
|
|
|
|
|
|
|
enum camera_driver_enum
|
|
|
|
{
|
|
|
|
CAMERA_V4L2 = JOYPAD_NULL + 1,
|
|
|
|
CAMERA_RWEBCAM,
|
|
|
|
CAMERA_ANDROID,
|
|
|
|
CAMERA_AVFOUNDATION,
|
|
|
|
CAMERA_NULL
|
|
|
|
};
|
|
|
|
|
|
|
|
enum wifi_driver_enum
|
|
|
|
{
|
|
|
|
WIFI_CONNMANCTL = CAMERA_NULL + 1,
|
|
|
|
WIFI_NULL
|
|
|
|
};
|
|
|
|
|
|
|
|
enum location_driver_enum
|
|
|
|
{
|
|
|
|
LOCATION_ANDROID = WIFI_NULL + 1,
|
|
|
|
LOCATION_CORELOCATION,
|
|
|
|
LOCATION_NULL
|
|
|
|
};
|
|
|
|
|
|
|
|
enum osk_driver_enum
|
|
|
|
{
|
|
|
|
OSK_PS3 = LOCATION_NULL + 1,
|
|
|
|
OSK_NULL
|
|
|
|
};
|
|
|
|
|
|
|
|
enum menu_driver_enum
|
|
|
|
{
|
|
|
|
MENU_RGUI = OSK_NULL + 1,
|
|
|
|
MENU_XUI,
|
|
|
|
MENU_MATERIALUI,
|
|
|
|
MENU_XMB,
|
2018-04-08 02:55:16 +00:00
|
|
|
MENU_STRIPES,
|
2018-09-18 13:13:33 +00:00
|
|
|
MENU_OZONE,
|
2017-05-08 00:25:55 +00:00
|
|
|
MENU_NULL
|
|
|
|
};
|
|
|
|
|
|
|
|
enum record_driver_enum
|
|
|
|
{
|
|
|
|
RECORD_FFMPEG = MENU_NULL + 1,
|
|
|
|
RECORD_NULL
|
|
|
|
};
|
|
|
|
|
2018-06-04 05:48:08 +00:00
|
|
|
enum midi_driver_enum
|
|
|
|
{
|
|
|
|
MIDI_WINMM = RECORD_NULL + 1,
|
2018-09-28 14:07:51 +00:00
|
|
|
MIDI_ALSA,
|
2018-06-04 05:48:08 +00:00
|
|
|
MIDI_NULL
|
|
|
|
};
|
2017-05-08 00:25:55 +00:00
|
|
|
|
2019-02-28 20:38:36 +00:00
|
|
|
#if defined(HAVE_METAL)
|
2018-07-13 04:33:18 +00:00
|
|
|
static enum video_driver_enum VIDEO_DEFAULT_DRIVER = VIDEO_METAL;
|
2019-04-24 01:23:57 +00:00
|
|
|
#elif defined(HAVE_OPENGL) || defined(HAVE_OPENGLES) || defined(__CELLOS_LV2__)
|
2019-02-28 20:38:36 +00:00
|
|
|
static enum video_driver_enum VIDEO_DEFAULT_DRIVER = VIDEO_GL;
|
2019-04-24 01:23:57 +00:00
|
|
|
#elif defined(HAVE_OPENGL_CORE)
|
|
|
|
static enum video_driver_enum VIDEO_DEFAULT_DRIVER = VIDEO_GL_CORE;
|
|
|
|
#elif defined(HAVE_OPENGL1)
|
|
|
|
static enum video_driver_enum VIDEO_DEFAULT_DRIVER = VIDEO_GL1;
|
2017-05-08 00:25:55 +00:00
|
|
|
#elif defined(GEKKO)
|
|
|
|
static enum video_driver_enum VIDEO_DEFAULT_DRIVER = VIDEO_WII;
|
|
|
|
#elif defined(WIIU)
|
|
|
|
static enum video_driver_enum VIDEO_DEFAULT_DRIVER = VIDEO_WIIU;
|
|
|
|
#elif defined(XENON)
|
|
|
|
static enum video_driver_enum VIDEO_DEFAULT_DRIVER = VIDEO_XENON360;
|
2018-12-28 11:41:38 +00:00
|
|
|
#elif defined(HAVE_D3D11)
|
|
|
|
static enum video_driver_enum VIDEO_DEFAULT_DRIVER = VIDEO_D3D11;
|
2019-02-28 20:38:36 +00:00
|
|
|
#elif defined(HAVE_D3D12)
|
|
|
|
/* FIXME/WARNING: DX12 performance on Xbox is horrible for
|
|
|
|
* some reason. For now, we will default to D3D11 when possible. */
|
|
|
|
static enum video_driver_enum VIDEO_DEFAULT_DRIVER = VIDEO_D3D12;
|
2018-12-28 11:41:38 +00:00
|
|
|
#elif defined(HAVE_D3D10)
|
|
|
|
static enum video_driver_enum VIDEO_DEFAULT_DRIVER = VIDEO_D3D10;
|
2017-05-08 00:25:55 +00:00
|
|
|
#elif defined(HAVE_D3D9)
|
|
|
|
static enum video_driver_enum VIDEO_DEFAULT_DRIVER = VIDEO_D3D9;
|
2018-01-23 01:55:33 +00:00
|
|
|
#elif defined(HAVE_D3D8)
|
|
|
|
static enum video_driver_enum VIDEO_DEFAULT_DRIVER = VIDEO_D3D8;
|
2017-05-08 00:25:55 +00:00
|
|
|
#elif defined(HAVE_VG)
|
|
|
|
static enum video_driver_enum VIDEO_DEFAULT_DRIVER = VIDEO_VG;
|
|
|
|
#elif defined(HAVE_VITA2D)
|
|
|
|
static enum video_driver_enum VIDEO_DEFAULT_DRIVER = VIDEO_VITA2D;
|
|
|
|
#elif defined(PSP)
|
|
|
|
static enum video_driver_enum VIDEO_DEFAULT_DRIVER = VIDEO_PSP1;
|
2018-09-18 06:08:06 +00:00
|
|
|
#elif defined(PS2)
|
|
|
|
static enum video_driver_enum VIDEO_DEFAULT_DRIVER = VIDEO_PS2;
|
2017-05-08 00:25:55 +00:00
|
|
|
#elif defined(_3DS)
|
|
|
|
static enum video_driver_enum VIDEO_DEFAULT_DRIVER = VIDEO_CTR;
|
2017-12-24 01:26:58 +00:00
|
|
|
#elif defined(SWITCH)
|
|
|
|
static enum video_driver_enum VIDEO_DEFAULT_DRIVER = VIDEO_SWITCH;
|
2017-05-08 00:25:55 +00:00
|
|
|
#elif defined(HAVE_XVIDEO)
|
|
|
|
static enum video_driver_enum VIDEO_DEFAULT_DRIVER = VIDEO_XVIDEO;
|
|
|
|
#elif defined(HAVE_SDL)
|
|
|
|
static enum video_driver_enum VIDEO_DEFAULT_DRIVER = VIDEO_SDL;
|
|
|
|
#elif defined(HAVE_SDL2)
|
|
|
|
static enum video_driver_enum VIDEO_DEFAULT_DRIVER = VIDEO_SDL2;
|
|
|
|
#elif defined(_WIN32) && !defined(_XBOX)
|
|
|
|
static enum video_driver_enum VIDEO_DEFAULT_DRIVER = VIDEO_GDI;
|
|
|
|
#elif defined(DJGPP)
|
|
|
|
static enum video_driver_enum VIDEO_DEFAULT_DRIVER = VIDEO_VGA;
|
2019-09-17 06:16:50 +00:00
|
|
|
#elif defined(HAVE_FPGA)
|
|
|
|
static enum video_driver_enum VIDEO_DEFAULT_DRIVER = VIDEO_FPGA;
|
2017-05-08 00:25:55 +00:00
|
|
|
#elif defined(HAVE_DYLIB) && !defined(ANDROID)
|
|
|
|
static enum video_driver_enum VIDEO_DEFAULT_DRIVER = VIDEO_EXT;
|
|
|
|
#else
|
|
|
|
static enum video_driver_enum VIDEO_DEFAULT_DRIVER = VIDEO_NULL;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if defined(__CELLOS_LV2__)
|
|
|
|
static enum audio_driver_enum AUDIO_DEFAULT_DRIVER = AUDIO_PS3;
|
|
|
|
#elif defined(XENON)
|
|
|
|
static enum audio_driver_enum AUDIO_DEFAULT_DRIVER = AUDIO_XENON360;
|
|
|
|
#elif defined(GEKKO)
|
|
|
|
static enum audio_driver_enum AUDIO_DEFAULT_DRIVER = AUDIO_WII;
|
|
|
|
#elif defined(WIIU)
|
|
|
|
static enum audio_driver_enum AUDIO_DEFAULT_DRIVER = AUDIO_WIIU;
|
2018-12-30 23:37:08 +00:00
|
|
|
#elif defined(PSP) || defined(VITA) || defined(ORBIS)
|
2017-05-08 00:25:55 +00:00
|
|
|
static enum audio_driver_enum AUDIO_DEFAULT_DRIVER = AUDIO_PSP;
|
2018-09-18 06:08:06 +00:00
|
|
|
#elif defined(PS2)
|
|
|
|
static enum audio_driver_enum AUDIO_DEFAULT_DRIVER = AUDIO_PS2;
|
2017-05-08 00:25:55 +00:00
|
|
|
#elif defined(_3DS)
|
|
|
|
static enum audio_driver_enum AUDIO_DEFAULT_DRIVER = AUDIO_CTR;
|
2017-12-24 22:33:48 +00:00
|
|
|
#elif defined(SWITCH)
|
|
|
|
static enum audio_driver_enum AUDIO_DEFAULT_DRIVER = AUDIO_SWITCH;
|
2017-05-08 00:25:55 +00:00
|
|
|
#elif defined(HAVE_PULSE)
|
|
|
|
static enum audio_driver_enum AUDIO_DEFAULT_DRIVER = AUDIO_PULSE;
|
|
|
|
#elif defined(HAVE_ALSA) && defined(HAVE_VIDEOCORE)
|
|
|
|
static enum audio_driver_enum AUDIO_DEFAULT_DRIVER = AUDIO_ALSATHREAD;
|
|
|
|
#elif defined(HAVE_ALSA)
|
|
|
|
static enum audio_driver_enum AUDIO_DEFAULT_DRIVER = AUDIO_ALSA;
|
2017-06-24 01:44:00 +00:00
|
|
|
#elif defined(HAVE_TINYALSA)
|
|
|
|
static enum audio_driver_enum AUDIO_DEFAULT_DRIVER = AUDIO_TINYALSA;
|
2019-05-09 17:30:44 +00:00
|
|
|
#elif defined(HAVE_AUDIOIO)
|
|
|
|
static enum audio_driver_enum AUDIO_DEFAULT_DRIVER = AUDIO_AUDIOIO;
|
2017-05-08 00:25:55 +00:00
|
|
|
#elif defined(HAVE_OSS)
|
|
|
|
static enum audio_driver_enum AUDIO_DEFAULT_DRIVER = AUDIO_OSS;
|
|
|
|
#elif defined(HAVE_JACK)
|
|
|
|
static enum audio_driver_enum AUDIO_DEFAULT_DRIVER = AUDIO_JACK;
|
2019-09-22 21:03:14 +00:00
|
|
|
#elif defined(HAVE_COREAUDIO) && !defined(HAVE_COCOA_METAL)
|
2017-05-08 00:25:55 +00:00
|
|
|
static enum audio_driver_enum AUDIO_DEFAULT_DRIVER = AUDIO_COREAUDIO;
|
2019-02-28 19:49:38 +00:00
|
|
|
#elif defined(HAVE_COREAUDIO3)
|
|
|
|
static enum audio_driver_enum AUDIO_DEFAULT_DRIVER = AUDIO_COREAUDIO3;
|
2017-05-08 00:25:55 +00:00
|
|
|
#elif defined(HAVE_XAUDIO)
|
|
|
|
static enum audio_driver_enum AUDIO_DEFAULT_DRIVER = AUDIO_XAUDIO;
|
|
|
|
#elif defined(HAVE_DSOUND)
|
|
|
|
static enum audio_driver_enum AUDIO_DEFAULT_DRIVER = AUDIO_DSOUND;
|
|
|
|
#elif defined(HAVE_WASAPI)
|
|
|
|
static enum audio_driver_enum AUDIO_DEFAULT_DRIVER = AUDIO_WASAPI;
|
|
|
|
#elif defined(HAVE_AL)
|
|
|
|
static enum audio_driver_enum AUDIO_DEFAULT_DRIVER = AUDIO_AL;
|
|
|
|
#elif defined(HAVE_SL)
|
|
|
|
static enum audio_driver_enum AUDIO_DEFAULT_DRIVER = AUDIO_SL;
|
|
|
|
#elif defined(EMSCRIPTEN)
|
|
|
|
static enum audio_driver_enum AUDIO_DEFAULT_DRIVER = AUDIO_RWEBAUDIO;
|
|
|
|
#elif defined(HAVE_SDL)
|
|
|
|
static enum audio_driver_enum AUDIO_DEFAULT_DRIVER = AUDIO_SDL;
|
|
|
|
#elif defined(HAVE_SDL2)
|
|
|
|
static enum audio_driver_enum AUDIO_DEFAULT_DRIVER = AUDIO_SDL2;
|
|
|
|
#elif defined(HAVE_RSOUND)
|
|
|
|
static enum audio_driver_enum AUDIO_DEFAULT_DRIVER = AUDIO_RSOUND;
|
|
|
|
#elif defined(HAVE_ROAR)
|
|
|
|
static enum audio_driver_enum AUDIO_DEFAULT_DRIVER = AUDIO_ROAR;
|
|
|
|
#elif defined(HAVE_DYLIB) && !defined(ANDROID)
|
|
|
|
static enum audio_driver_enum AUDIO_DEFAULT_DRIVER = AUDIO_EXT;
|
|
|
|
#else
|
|
|
|
static enum audio_driver_enum AUDIO_DEFAULT_DRIVER = AUDIO_NULL;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if defined(PSP) || defined(EMSCRIPTEN)
|
|
|
|
static enum audio_resampler_driver_enum AUDIO_DEFAULT_RESAMPLER_DRIVER = AUDIO_RESAMPLER_CC;
|
|
|
|
#else
|
|
|
|
static enum audio_resampler_driver_enum AUDIO_DEFAULT_RESAMPLER_DRIVER = AUDIO_RESAMPLER_SINC;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if defined(HAVE_FFMPEG)
|
|
|
|
static enum record_driver_enum RECORD_DEFAULT_DRIVER = RECORD_FFMPEG;
|
|
|
|
#else
|
|
|
|
static enum record_driver_enum RECORD_DEFAULT_DRIVER = RECORD_NULL;
|
|
|
|
#endif
|
|
|
|
|
2018-06-04 05:48:08 +00:00
|
|
|
#ifdef HAVE_WINMM
|
|
|
|
static enum midi_driver_enum MIDI_DEFAULT_DRIVER = MIDI_WINMM;
|
2019-09-29 20:44:58 +00:00
|
|
|
#elif defined(HAVE_ALSA) && !defined(HAVE_HAKCHI) && !defined(HAVE_SEGAM)
|
2018-09-28 14:07:51 +00:00
|
|
|
static enum midi_driver_enum MIDI_DEFAULT_DRIVER = MIDI_ALSA;
|
2018-06-04 05:48:08 +00:00
|
|
|
#else
|
|
|
|
static enum midi_driver_enum MIDI_DEFAULT_DRIVER = MIDI_NULL;
|
|
|
|
#endif
|
|
|
|
|
2019-01-02 12:30:58 +00:00
|
|
|
#if defined(__WINRT__) || defined(WINAPI_FAMILY) && WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP
|
2018-12-28 11:29:04 +00:00
|
|
|
static enum input_driver_enum INPUT_DEFAULT_DRIVER = INPUT_UWP;
|
|
|
|
#elif defined(XENON)
|
2017-05-08 00:25:55 +00:00
|
|
|
static enum input_driver_enum INPUT_DEFAULT_DRIVER = INPUT_XENON360;
|
|
|
|
#elif defined(_XBOX360) || defined(_XBOX) || defined(HAVE_XINPUT2) || defined(HAVE_XINPUT_XBOX1)
|
|
|
|
static enum input_driver_enum INPUT_DEFAULT_DRIVER = INPUT_XINPUT;
|
|
|
|
#elif defined(ANDROID)
|
|
|
|
static enum input_driver_enum INPUT_DEFAULT_DRIVER = INPUT_ANDROID;
|
|
|
|
#elif defined(EMSCRIPTEN) && defined(HAVE_SDL2)
|
|
|
|
static enum input_driver_enum INPUT_DEFAULT_DRIVER = INPUT_SDL2;
|
|
|
|
#elif defined(EMSCRIPTEN)
|
|
|
|
static enum input_driver_enum INPUT_DEFAULT_DRIVER = INPUT_RWEBINPUT;
|
2019-02-26 13:20:00 +00:00
|
|
|
#elif defined(_WIN32) && defined(HAVE_DINPUT)
|
2017-05-08 00:25:55 +00:00
|
|
|
static enum input_driver_enum INPUT_DEFAULT_DRIVER = INPUT_DINPUT;
|
2019-02-26 13:20:00 +00:00
|
|
|
#elif defined(_WIN32) && !defined(HAVE_DINPUT) && _WIN32_WINNT >= 0x0501
|
|
|
|
static enum input_driver_enum INPUT_DEFAULT_DRIVER = INPUT_WINRAW;
|
2018-12-30 00:29:34 +00:00
|
|
|
#elif defined(ORBIS)
|
|
|
|
static enum input_driver_enum INPUT_DEFAULT_DRIVER = INPUT_PS4;
|
2017-05-08 00:25:55 +00:00
|
|
|
#elif defined(__CELLOS_LV2__)
|
|
|
|
static enum input_driver_enum INPUT_DEFAULT_DRIVER = INPUT_PS3;
|
|
|
|
#elif defined(PSP) || defined(VITA)
|
|
|
|
static enum input_driver_enum INPUT_DEFAULT_DRIVER = INPUT_PSP;
|
2018-09-18 06:08:06 +00:00
|
|
|
#elif defined(PS2)
|
|
|
|
static enum input_driver_enum INPUT_DEFAULT_DRIVER = INPUT_PS2;
|
2017-05-08 00:25:55 +00:00
|
|
|
#elif defined(_3DS)
|
|
|
|
static enum input_driver_enum INPUT_DEFAULT_DRIVER = INPUT_CTR;
|
2017-12-24 01:26:58 +00:00
|
|
|
#elif defined(SWITCH)
|
|
|
|
static enum input_driver_enum INPUT_DEFAULT_DRIVER = INPUT_SWITCH;
|
2017-05-08 00:25:55 +00:00
|
|
|
#elif defined(GEKKO)
|
|
|
|
static enum input_driver_enum INPUT_DEFAULT_DRIVER = INPUT_WII;
|
|
|
|
#elif defined(WIIU)
|
|
|
|
static enum input_driver_enum INPUT_DEFAULT_DRIVER = INPUT_WIIU;
|
2017-06-06 19:03:37 +00:00
|
|
|
#elif defined(HAVE_X11)
|
|
|
|
static enum input_driver_enum INPUT_DEFAULT_DRIVER = INPUT_X;
|
2017-05-08 00:25:55 +00:00
|
|
|
#elif defined(HAVE_UDEV)
|
|
|
|
static enum input_driver_enum INPUT_DEFAULT_DRIVER = INPUT_UDEV;
|
|
|
|
#elif defined(__linux__) && !defined(ANDROID)
|
|
|
|
static enum input_driver_enum INPUT_DEFAULT_DRIVER = INPUT_LINUXRAW;
|
|
|
|
#elif defined(HAVE_WAYLAND)
|
|
|
|
static enum input_driver_enum INPUT_DEFAULT_DRIVER = INPUT_WAYLAND;
|
2018-11-04 16:29:40 +00:00
|
|
|
#elif defined(HAVE_COCOA) || defined(HAVE_COCOATOUCH) || defined(HAVE_COCOA_METAL)
|
2017-05-08 00:25:55 +00:00
|
|
|
static enum input_driver_enum INPUT_DEFAULT_DRIVER = INPUT_COCOA;
|
|
|
|
#elif defined(__QNX__)
|
|
|
|
static enum input_driver_enum INPUT_DEFAULT_DRIVER = INPUT_QNX;
|
|
|
|
#elif defined(HAVE_SDL)
|
|
|
|
static enum input_driver_enum INPUT_DEFAULT_DRIVER = INPUT_SDL;
|
|
|
|
#elif defined(HAVE_SDL2)
|
|
|
|
static enum input_driver_enum INPUT_DEFAULT_DRIVER = INPUT_SDL2;
|
|
|
|
#elif defined(DJGPP)
|
|
|
|
static enum input_driver_enum INPUT_DEFAULT_DRIVER = INPUT_DOS;
|
|
|
|
#else
|
|
|
|
static enum input_driver_enum INPUT_DEFAULT_DRIVER = INPUT_NULL;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if defined(__CELLOS_LV2__)
|
|
|
|
static enum joypad_driver_enum JOYPAD_DEFAULT_DRIVER = JOYPAD_PS3;
|
|
|
|
#elif defined(HAVE_XINPUT)
|
|
|
|
static enum joypad_driver_enum JOYPAD_DEFAULT_DRIVER = JOYPAD_XINPUT;
|
|
|
|
#elif defined(GEKKO)
|
|
|
|
static enum joypad_driver_enum JOYPAD_DEFAULT_DRIVER = JOYPAD_GX;
|
|
|
|
#elif defined(WIIU)
|
|
|
|
static enum joypad_driver_enum JOYPAD_DEFAULT_DRIVER = JOYPAD_WIIU;
|
|
|
|
#elif defined(_XBOX)
|
|
|
|
static enum joypad_driver_enum JOYPAD_DEFAULT_DRIVER = JOYPAD_XDK;
|
2018-12-30 13:00:18 +00:00
|
|
|
#elif defined(ORBIS)
|
|
|
|
static enum joypad_driver_enum JOYPAD_DEFAULT_DRIVER = JOYPAD_PS4;
|
2017-05-08 00:25:55 +00:00
|
|
|
#elif defined(PSP) || defined(VITA)
|
|
|
|
static enum joypad_driver_enum JOYPAD_DEFAULT_DRIVER = JOYPAD_PSP;
|
2018-09-18 06:08:06 +00:00
|
|
|
#elif defined(PS2)
|
|
|
|
static enum joypad_driver_enum JOYPAD_DEFAULT_DRIVER = JOYPAD_PS2;
|
2017-05-08 00:25:55 +00:00
|
|
|
#elif defined(_3DS)
|
|
|
|
static enum joypad_driver_enum JOYPAD_DEFAULT_DRIVER = JOYPAD_CTR;
|
2017-12-24 01:26:58 +00:00
|
|
|
#elif defined(SWITCH)
|
|
|
|
static enum joypad_driver_enum JOYPAD_DEFAULT_DRIVER = JOYPAD_SWITCH;
|
2017-05-08 00:25:55 +00:00
|
|
|
#elif defined(HAVE_DINPUT)
|
|
|
|
static enum joypad_driver_enum JOYPAD_DEFAULT_DRIVER = JOYPAD_DINPUT;
|
|
|
|
#elif defined(HAVE_UDEV)
|
|
|
|
static enum joypad_driver_enum JOYPAD_DEFAULT_DRIVER = JOYPAD_UDEV;
|
|
|
|
#elif defined(__linux) && !defined(ANDROID)
|
|
|
|
static enum joypad_driver_enum JOYPAD_DEFAULT_DRIVER = JOYPAD_LINUXRAW;
|
|
|
|
#elif defined(ANDROID)
|
|
|
|
static enum joypad_driver_enum JOYPAD_DEFAULT_DRIVER = JOYPAD_ANDROID;
|
|
|
|
#elif defined(HAVE_SDL) || defined(HAVE_SDL2)
|
|
|
|
static enum joypad_driver_enum JOYPAD_DEFAULT_DRIVER = JOYPAD_SDL;
|
|
|
|
#elif defined(DJGPP)
|
|
|
|
static enum joypad_driver_enum JOYPAD_DEFAULT_DRIVER = JOYPAD_DOS;
|
2019-02-01 01:40:23 +00:00
|
|
|
#elif defined(IOS)
|
|
|
|
static enum joypad_driver_enum JOYPAD_DEFAULT_DRIVER = JOYPAD_MFI;
|
2017-05-08 00:25:55 +00:00
|
|
|
#elif defined(HAVE_HID)
|
|
|
|
static enum joypad_driver_enum JOYPAD_DEFAULT_DRIVER = JOYPAD_HID;
|
|
|
|
#elif defined(__QNX__)
|
|
|
|
static enum joypad_driver_enum JOYPAD_DEFAULT_DRIVER = JOYPAD_QNX;
|
2018-01-15 06:06:57 +00:00
|
|
|
#elif defined(EMSCRIPTEN)
|
|
|
|
static enum joypad_driver_enum JOYPAD_DEFAULT_DRIVER = JOYPAD_RWEBPAD;
|
2017-05-08 00:25:55 +00:00
|
|
|
#else
|
|
|
|
static enum joypad_driver_enum JOYPAD_DEFAULT_DRIVER = JOYPAD_NULL;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if defined(HAVE_V4L2)
|
|
|
|
static enum camera_driver_enum CAMERA_DEFAULT_DRIVER = CAMERA_V4L2;
|
|
|
|
#elif defined(EMSCRIPTEN)
|
|
|
|
static enum camera_driver_enum CAMERA_DEFAULT_DRIVER = CAMERA_RWEBCAM;
|
|
|
|
#elif defined(ANDROID)
|
|
|
|
static enum camera_driver_enum CAMERA_DEFAULT_DRIVER = CAMERA_ANDROID;
|
|
|
|
#else
|
|
|
|
static enum camera_driver_enum CAMERA_DEFAULT_DRIVER = CAMERA_NULL;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if defined(HAVE_LAKKA)
|
|
|
|
static enum wifi_driver_enum WIFI_DEFAULT_DRIVER = WIFI_CONNMANCTL;
|
|
|
|
#else
|
|
|
|
static enum wifi_driver_enum WIFI_DEFAULT_DRIVER = WIFI_NULL;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if defined(ANDROID)
|
|
|
|
static enum location_driver_enum LOCATION_DEFAULT_DRIVER = LOCATION_ANDROID;
|
|
|
|
#else
|
|
|
|
static enum location_driver_enum LOCATION_DEFAULT_DRIVER = LOCATION_NULL;
|
|
|
|
#endif
|
|
|
|
|
2018-12-07 14:18:43 +00:00
|
|
|
#if defined(_3DS) && defined(HAVE_RGUI)
|
|
|
|
static enum menu_driver_enum MENU_DEFAULT_DRIVER = MENU_RGUI;
|
|
|
|
#else
|
2017-05-08 00:25:55 +00:00
|
|
|
#if defined(HAVE_XUI)
|
|
|
|
static enum menu_driver_enum MENU_DEFAULT_DRIVER = MENU_XUI;
|
|
|
|
#elif defined(HAVE_MATERIALUI) && defined(RARCH_MOBILE)
|
|
|
|
static enum menu_driver_enum MENU_DEFAULT_DRIVER = MENU_MATERIALUI;
|
2019-02-03 23:49:35 +00:00
|
|
|
#elif defined(HAVE_OZONE) && (defined(HAVE_LIBNX) || TARGET_OS_TV)
|
2018-11-15 17:46:38 +00:00
|
|
|
static enum menu_driver_enum MENU_DEFAULT_DRIVER = MENU_OZONE;
|
2018-01-20 05:47:46 +00:00
|
|
|
#elif defined(HAVE_XMB) && !defined(_XBOX)
|
2017-05-08 00:25:55 +00:00
|
|
|
static enum menu_driver_enum MENU_DEFAULT_DRIVER = MENU_XMB;
|
|
|
|
#elif defined(HAVE_RGUI)
|
|
|
|
static enum menu_driver_enum MENU_DEFAULT_DRIVER = MENU_RGUI;
|
|
|
|
#else
|
|
|
|
static enum menu_driver_enum MENU_DEFAULT_DRIVER = MENU_NULL;
|
|
|
|
#endif
|
2018-12-07 14:18:43 +00:00
|
|
|
#endif
|
2017-05-08 00:25:55 +00:00
|
|
|
|
2016-09-01 01:51:54 +00:00
|
|
|
#define GENERAL_SETTING(key, configval, default_enable, default_setting, type, handle_setting) \
|
2016-08-29 17:10:00 +00:00
|
|
|
{ \
|
2016-08-29 17:26:08 +00:00
|
|
|
tmp[count].ident = key; \
|
|
|
|
tmp[count].ptr = configval; \
|
|
|
|
tmp[count].def_enable = default_enable; \
|
|
|
|
if (default_enable) \
|
|
|
|
tmp[count].def = default_setting; \
|
2016-09-01 01:51:54 +00:00
|
|
|
tmp[count].handle = handle_setting; \
|
2016-08-29 17:10:00 +00:00
|
|
|
count++; \
|
2017-07-14 19:11:27 +00:00
|
|
|
}
|
2016-08-29 17:10:00 +00:00
|
|
|
|
2016-09-01 01:51:54 +00:00
|
|
|
#define SETTING_BOOL(key, configval, default_enable, default_setting, handle_setting) \
|
2017-04-28 22:43:20 +00:00
|
|
|
GENERAL_SETTING(key, configval, default_enable, default_setting, struct config_bool_setting, handle_setting)
|
2016-08-30 02:05:27 +00:00
|
|
|
|
2016-09-01 01:51:54 +00:00
|
|
|
#define SETTING_FLOAT(key, configval, default_enable, default_setting, handle_setting) \
|
2017-04-28 22:43:20 +00:00
|
|
|
GENERAL_SETTING(key, configval, default_enable, default_setting, struct config_float_setting, handle_setting)
|
2016-08-29 17:10:00 +00:00
|
|
|
|
2016-09-01 01:51:54 +00:00
|
|
|
#define SETTING_INT(key, configval, default_enable, default_setting, handle_setting) \
|
2017-04-28 22:43:20 +00:00
|
|
|
GENERAL_SETTING(key, configval, default_enable, default_setting, struct config_int_setting, handle_setting)
|
2016-08-30 02:05:27 +00:00
|
|
|
|
2017-04-28 17:55:09 +00:00
|
|
|
#define SETTING_UINT(key, configval, default_enable, default_setting, handle_setting) \
|
2017-04-28 22:43:20 +00:00
|
|
|
GENERAL_SETTING(key, configval, default_enable, default_setting, struct config_uint_setting, handle_setting)
|
2017-04-28 17:55:09 +00:00
|
|
|
|
2018-07-13 20:12:09 +00:00
|
|
|
#define SETTING_SIZE(key, configval, default_enable, default_setting, handle_setting) \
|
|
|
|
GENERAL_SETTING(key, configval, default_enable, default_setting, struct config_size_setting, handle_setting)
|
|
|
|
|
2016-09-01 01:51:54 +00:00
|
|
|
#define SETTING_PATH(key, configval, default_enable, default_setting, handle_setting) \
|
2016-09-05 15:16:37 +00:00
|
|
|
GENERAL_SETTING(key, configval, default_enable, default_setting, struct config_path_setting, handle_setting)
|
2016-08-29 17:10:00 +00:00
|
|
|
|
2016-09-01 00:53:04 +00:00
|
|
|
#define SETTING_ARRAY(key, configval, default_enable, default_setting, handle_setting) \
|
2017-04-28 22:43:20 +00:00
|
|
|
GENERAL_SETTING(key, configval, default_enable, default_setting, struct config_array_setting, handle_setting)
|
2016-08-29 17:10:00 +00:00
|
|
|
|
2018-03-09 22:23:34 +00:00
|
|
|
#define SETTING_OVERRIDE(override_setting) \
|
|
|
|
tmp[count-1].override = override_setting
|
|
|
|
|
2014-06-12 16:06:29 +00:00
|
|
|
struct defaults g_defaults;
|
2015-12-04 08:02:30 +00:00
|
|
|
|
2015-01-11 04:29:32 +00:00
|
|
|
/**
|
|
|
|
* config_get_default_audio:
|
|
|
|
*
|
|
|
|
* Gets default audio driver.
|
|
|
|
*
|
|
|
|
* Returns: Default audio driver.
|
|
|
|
**/
|
2012-05-07 21:20:13 +00:00
|
|
|
const char *config_get_default_audio(void)
|
2010-12-29 18:00:21 +00:00
|
|
|
{
|
2016-12-05 05:37:26 +00:00
|
|
|
enum audio_driver_enum default_driver = AUDIO_DEFAULT_DRIVER;
|
|
|
|
|
|
|
|
switch (default_driver)
|
2010-12-29 19:50:50 +00:00
|
|
|
{
|
|
|
|
case AUDIO_RSOUND:
|
2012-05-07 21:20:13 +00:00
|
|
|
return "rsound";
|
2019-05-09 17:30:44 +00:00
|
|
|
case AUDIO_AUDIOIO:
|
|
|
|
return "audioio";
|
2010-12-29 19:50:50 +00:00
|
|
|
case AUDIO_OSS:
|
2012-05-07 21:20:13 +00:00
|
|
|
return "oss";
|
2010-12-29 19:50:50 +00:00
|
|
|
case AUDIO_ALSA:
|
2012-05-07 21:20:13 +00:00
|
|
|
return "alsa";
|
2013-01-04 19:58:34 +00:00
|
|
|
case AUDIO_ALSATHREAD:
|
|
|
|
return "alsathread";
|
2017-06-24 01:44:00 +00:00
|
|
|
case AUDIO_TINYALSA:
|
|
|
|
return "tinyalsa";
|
2010-12-29 19:50:50 +00:00
|
|
|
case AUDIO_ROAR:
|
2012-05-07 21:20:13 +00:00
|
|
|
return "roar";
|
2011-08-08 15:27:52 +00:00
|
|
|
case AUDIO_COREAUDIO:
|
2012-05-07 21:20:13 +00:00
|
|
|
return "coreaudio";
|
2019-02-01 16:33:28 +00:00
|
|
|
case AUDIO_COREAUDIO3:
|
|
|
|
return "coreaudio3";
|
2010-12-29 19:50:50 +00:00
|
|
|
case AUDIO_AL:
|
2012-05-07 21:20:13 +00:00
|
|
|
return "openal";
|
2012-10-18 03:45:21 +00:00
|
|
|
case AUDIO_SL:
|
|
|
|
return "opensl";
|
2011-01-07 16:59:53 +00:00
|
|
|
case AUDIO_SDL:
|
2012-05-07 21:20:13 +00:00
|
|
|
return "sdl";
|
2014-08-22 22:15:44 +00:00
|
|
|
case AUDIO_SDL2:
|
|
|
|
return "sdl2";
|
2011-08-04 16:45:40 +00:00
|
|
|
case AUDIO_DSOUND:
|
2012-05-07 21:20:13 +00:00
|
|
|
return "dsound";
|
2017-04-09 21:53:55 +00:00
|
|
|
case AUDIO_WASAPI:
|
|
|
|
return "wasapi";
|
2011-01-27 00:46:00 +00:00
|
|
|
case AUDIO_XAUDIO:
|
2012-05-07 21:20:13 +00:00
|
|
|
return "xaudio";
|
2011-01-29 00:15:09 +00:00
|
|
|
case AUDIO_PULSE:
|
2012-05-07 21:20:13 +00:00
|
|
|
return "pulse";
|
2011-05-14 23:46:11 +00:00
|
|
|
case AUDIO_EXT:
|
2012-05-07 21:20:13 +00:00
|
|
|
return "ext";
|
2011-12-13 22:17:37 +00:00
|
|
|
case AUDIO_XENON360:
|
2012-05-07 21:20:13 +00:00
|
|
|
return "xenon360";
|
2011-12-14 11:49:13 +00:00
|
|
|
case AUDIO_PS3:
|
2012-05-07 21:20:13 +00:00
|
|
|
return "ps3";
|
2011-12-14 11:49:13 +00:00
|
|
|
case AUDIO_WII:
|
2012-08-09 01:54:27 +00:00
|
|
|
return "gx";
|
2016-11-06 22:42:05 +00:00
|
|
|
case AUDIO_WIIU:
|
|
|
|
return "AX";
|
2015-08-12 10:18:45 +00:00
|
|
|
case AUDIO_PSP:
|
2018-12-30 23:37:08 +00:00
|
|
|
#if defined(VITA)
|
2015-08-31 13:26:37 +00:00
|
|
|
return "vita";
|
2018-12-30 23:37:08 +00:00
|
|
|
#elif defined(ORBIS)
|
|
|
|
return "orbis";
|
2015-08-31 13:26:37 +00:00
|
|
|
#else
|
2015-08-12 10:18:45 +00:00
|
|
|
return "psp";
|
2015-08-31 13:26:37 +00:00
|
|
|
#endif
|
2018-09-18 06:08:06 +00:00
|
|
|
case AUDIO_PS2:
|
|
|
|
return "ps2";
|
2015-04-01 21:14:13 +00:00
|
|
|
case AUDIO_CTR:
|
2018-12-07 14:18:43 +00:00
|
|
|
return "dsp";
|
2017-12-24 22:33:48 +00:00
|
|
|
case AUDIO_SWITCH:
|
2019-07-07 13:30:04 +00:00
|
|
|
#if defined(HAVE_LIBNX)
|
|
|
|
return "switch_thread";
|
|
|
|
#else
|
2017-12-24 22:33:48 +00:00
|
|
|
return "switch";
|
2019-07-07 13:30:04 +00:00
|
|
|
#endif
|
2013-08-28 04:03:25 +00:00
|
|
|
case AUDIO_RWEBAUDIO:
|
|
|
|
return "rwebaudio";
|
2016-12-05 05:37:26 +00:00
|
|
|
case AUDIO_JACK:
|
|
|
|
return "jack";
|
|
|
|
case AUDIO_NULL:
|
2015-01-09 01:15:12 +00:00
|
|
|
break;
|
2010-12-29 19:50:50 +00:00
|
|
|
}
|
2014-10-03 15:07:51 +00:00
|
|
|
|
2015-01-09 00:08:54 +00:00
|
|
|
return "null";
|
2012-05-07 21:20:13 +00:00
|
|
|
}
|
2010-12-29 19:50:50 +00:00
|
|
|
|
2015-04-15 11:37:38 +00:00
|
|
|
const char *config_get_default_record(void)
|
|
|
|
{
|
2016-12-05 05:37:26 +00:00
|
|
|
enum record_driver_enum default_driver = RECORD_DEFAULT_DRIVER;
|
|
|
|
|
|
|
|
switch (default_driver)
|
2015-04-15 11:37:38 +00:00
|
|
|
{
|
|
|
|
case RECORD_FFMPEG:
|
|
|
|
return "ffmpeg";
|
2016-12-05 05:37:26 +00:00
|
|
|
case RECORD_NULL:
|
2015-04-15 11:37:38 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return "null";
|
|
|
|
}
|
|
|
|
|
2015-01-11 04:29:32 +00:00
|
|
|
/**
|
|
|
|
* config_get_default_audio_resampler:
|
|
|
|
*
|
|
|
|
* Gets default audio resampler driver.
|
|
|
|
*
|
|
|
|
* Returns: Default audio resampler driver.
|
|
|
|
**/
|
2014-07-18 17:11:53 +00:00
|
|
|
const char *config_get_default_audio_resampler(void)
|
|
|
|
{
|
2016-12-05 05:37:26 +00:00
|
|
|
enum audio_resampler_driver_enum default_driver = AUDIO_DEFAULT_RESAMPLER_DRIVER;
|
|
|
|
|
|
|
|
switch (default_driver)
|
2014-07-18 17:11:53 +00:00
|
|
|
{
|
|
|
|
case AUDIO_RESAMPLER_CC:
|
|
|
|
return "cc";
|
|
|
|
case AUDIO_RESAMPLER_SINC:
|
|
|
|
return "sinc";
|
2014-10-03 11:34:55 +00:00
|
|
|
case AUDIO_RESAMPLER_NEAREST:
|
|
|
|
return "nearest";
|
2016-12-05 05:37:26 +00:00
|
|
|
case AUDIO_RESAMPLER_NULL:
|
2015-01-09 01:15:12 +00:00
|
|
|
break;
|
2014-07-18 17:11:53 +00:00
|
|
|
}
|
2014-10-03 15:07:51 +00:00
|
|
|
|
2015-01-09 00:08:54 +00:00
|
|
|
return "null";
|
2014-07-18 17:11:53 +00:00
|
|
|
}
|
|
|
|
|
2015-01-11 04:29:32 +00:00
|
|
|
/**
|
|
|
|
* config_get_default_video:
|
|
|
|
*
|
|
|
|
* Gets default video driver.
|
|
|
|
*
|
|
|
|
* Returns: Default video driver.
|
|
|
|
**/
|
2012-05-07 21:20:13 +00:00
|
|
|
const char *config_get_default_video(void)
|
|
|
|
{
|
2016-12-05 05:37:26 +00:00
|
|
|
enum video_driver_enum default_driver = VIDEO_DEFAULT_DRIVER;
|
|
|
|
|
|
|
|
switch (default_driver)
|
2012-05-07 21:20:13 +00:00
|
|
|
{
|
|
|
|
case VIDEO_GL:
|
|
|
|
return "gl";
|
2019-04-24 01:23:57 +00:00
|
|
|
case VIDEO_GL1:
|
|
|
|
return "gl1";
|
|
|
|
case VIDEO_GL_CORE:
|
|
|
|
return "glcore";
|
2016-07-01 10:14:06 +00:00
|
|
|
case VIDEO_VULKAN:
|
|
|
|
return "vulkan";
|
2018-07-13 04:33:18 +00:00
|
|
|
case VIDEO_METAL:
|
|
|
|
return "metal";
|
2016-07-03 08:37:07 +00:00
|
|
|
case VIDEO_DRM:
|
|
|
|
return "drm";
|
2012-05-07 21:20:13 +00:00
|
|
|
case VIDEO_WII:
|
2012-08-09 01:54:27 +00:00
|
|
|
return "gx";
|
2016-10-27 00:34:10 +00:00
|
|
|
case VIDEO_WIIU:
|
|
|
|
return "gx2";
|
2012-05-07 21:20:13 +00:00
|
|
|
case VIDEO_XENON360:
|
|
|
|
return "xenon360";
|
2018-01-23 01:55:33 +00:00
|
|
|
case VIDEO_D3D8:
|
|
|
|
return "d3d8";
|
2012-10-26 19:09:30 +00:00
|
|
|
case VIDEO_D3D9:
|
2018-01-23 01:55:33 +00:00
|
|
|
return "d3d9";
|
2018-01-23 17:04:55 +00:00
|
|
|
case VIDEO_D3D10:
|
|
|
|
return "d3d10";
|
2018-01-21 03:10:45 +00:00
|
|
|
case VIDEO_D3D11:
|
|
|
|
return "d3d11";
|
|
|
|
case VIDEO_D3D12:
|
|
|
|
return "d3d12";
|
2012-11-23 04:20:05 +00:00
|
|
|
case VIDEO_PSP1:
|
|
|
|
return "psp1";
|
2018-09-18 06:08:06 +00:00
|
|
|
case VIDEO_PS2:
|
|
|
|
return "ps2";
|
2015-08-30 18:47:17 +00:00
|
|
|
case VIDEO_VITA2D:
|
|
|
|
return "vita2d";
|
2015-04-01 21:14:13 +00:00
|
|
|
case VIDEO_CTR:
|
|
|
|
return "ctr";
|
2017-12-24 01:26:58 +00:00
|
|
|
case VIDEO_SWITCH:
|
|
|
|
return "switch";
|
2012-05-07 21:20:13 +00:00
|
|
|
case VIDEO_XVIDEO:
|
|
|
|
return "xvideo";
|
|
|
|
case VIDEO_SDL:
|
|
|
|
return "sdl";
|
2014-08-22 22:15:44 +00:00
|
|
|
case VIDEO_SDL2:
|
|
|
|
return "sdl2";
|
2012-05-07 21:20:13 +00:00
|
|
|
case VIDEO_EXT:
|
|
|
|
return "ext";
|
2012-09-24 19:19:07 +00:00
|
|
|
case VIDEO_VG:
|
|
|
|
return "vg";
|
2013-07-28 16:37:31 +00:00
|
|
|
case VIDEO_OMAP:
|
|
|
|
return "omap";
|
2013-11-24 16:28:21 +00:00
|
|
|
case VIDEO_EXYNOS:
|
|
|
|
return "exynos";
|
2015-03-13 04:59:52 +00:00
|
|
|
case VIDEO_DISPMANX:
|
|
|
|
return "dispmanx";
|
2016-01-10 11:04:32 +00:00
|
|
|
case VIDEO_SUNXI:
|
|
|
|
return "sunxi";
|
2017-01-04 07:07:19 +00:00
|
|
|
case VIDEO_CACA:
|
|
|
|
return "caca";
|
|
|
|
case VIDEO_GDI:
|
|
|
|
return "gdi";
|
2017-01-21 22:41:20 +00:00
|
|
|
case VIDEO_VGA:
|
|
|
|
return "vga";
|
2019-09-17 06:16:50 +00:00
|
|
|
case VIDEO_FPGA:
|
|
|
|
return "fpga";
|
2016-12-05 05:37:26 +00:00
|
|
|
case VIDEO_NULL:
|
2015-01-09 01:15:12 +00:00
|
|
|
break;
|
2012-05-07 21:20:13 +00:00
|
|
|
}
|
2014-10-03 15:07:51 +00:00
|
|
|
|
2015-01-09 00:08:54 +00:00
|
|
|
return "null";
|
2012-05-07 21:20:13 +00:00
|
|
|
}
|
|
|
|
|
2015-01-11 04:29:32 +00:00
|
|
|
/**
|
|
|
|
* config_get_default_input:
|
|
|
|
*
|
|
|
|
* Gets default input driver.
|
|
|
|
*
|
|
|
|
* Returns: Default input driver.
|
|
|
|
**/
|
2012-05-07 21:20:13 +00:00
|
|
|
const char *config_get_default_input(void)
|
|
|
|
{
|
2016-12-05 05:37:26 +00:00
|
|
|
enum input_driver_enum default_driver = INPUT_DEFAULT_DRIVER;
|
|
|
|
|
|
|
|
switch (default_driver)
|
2011-01-06 17:34:11 +00:00
|
|
|
{
|
2012-10-16 17:46:31 +00:00
|
|
|
case INPUT_ANDROID:
|
2015-04-29 00:49:23 +00:00
|
|
|
return "android";
|
2018-12-30 00:29:34 +00:00
|
|
|
case INPUT_PS4:
|
|
|
|
return "ps4";
|
2011-11-30 16:24:18 +00:00
|
|
|
case INPUT_PS3:
|
2012-05-07 21:20:13 +00:00
|
|
|
return "ps3";
|
2012-11-23 01:40:03 +00:00
|
|
|
case INPUT_PSP:
|
2015-08-31 13:26:37 +00:00
|
|
|
#ifdef VITA
|
|
|
|
return "vita";
|
|
|
|
#else
|
2012-11-23 01:40:03 +00:00
|
|
|
return "psp";
|
2015-08-31 13:26:37 +00:00
|
|
|
#endif
|
2018-09-18 06:08:06 +00:00
|
|
|
case INPUT_PS2:
|
|
|
|
return "ps2";
|
2015-04-01 21:14:13 +00:00
|
|
|
case INPUT_CTR:
|
|
|
|
return "ctr";
|
2017-12-24 01:26:58 +00:00
|
|
|
case INPUT_SWITCH:
|
|
|
|
return "switch";
|
2011-01-06 17:34:11 +00:00
|
|
|
case INPUT_SDL:
|
2012-05-07 21:20:13 +00:00
|
|
|
return "sdl";
|
2014-08-22 22:15:44 +00:00
|
|
|
case INPUT_SDL2:
|
|
|
|
return "sdl2";
|
2012-09-30 09:26:26 +00:00
|
|
|
case INPUT_DINPUT:
|
|
|
|
return "dinput";
|
2019-02-26 13:20:00 +00:00
|
|
|
case INPUT_WINRAW:
|
|
|
|
return "raw";
|
2011-03-13 03:51:09 +00:00
|
|
|
case INPUT_X:
|
2012-05-07 21:20:13 +00:00
|
|
|
return "x";
|
2014-08-09 19:35:27 +00:00
|
|
|
case INPUT_WAYLAND:
|
|
|
|
return "wayland";
|
2011-12-14 00:35:17 +00:00
|
|
|
case INPUT_XENON360:
|
2012-05-07 21:20:13 +00:00
|
|
|
return "xenon360";
|
2012-07-07 17:56:46 +00:00
|
|
|
case INPUT_XINPUT:
|
|
|
|
return "xinput";
|
2018-12-28 11:29:04 +00:00
|
|
|
case INPUT_UWP:
|
|
|
|
return "uwp";
|
2011-12-14 12:20:22 +00:00
|
|
|
case INPUT_WII:
|
2012-08-09 01:54:27 +00:00
|
|
|
return "gx";
|
2016-10-27 00:34:10 +00:00
|
|
|
case INPUT_WIIU:
|
|
|
|
return "wiiu";
|
2012-05-25 19:44:39 +00:00
|
|
|
case INPUT_LINUXRAW:
|
|
|
|
return "linuxraw";
|
2014-01-03 19:18:50 +00:00
|
|
|
case INPUT_UDEV:
|
|
|
|
return "udev";
|
2015-04-19 15:58:15 +00:00
|
|
|
case INPUT_COCOA:
|
|
|
|
return "cocoa";
|
2013-03-18 22:56:07 +00:00
|
|
|
case INPUT_QNX:
|
2018-01-15 06:06:57 +00:00
|
|
|
return "qnx_input";
|
2013-09-11 00:21:48 +00:00
|
|
|
case INPUT_RWEBINPUT:
|
2018-01-15 06:06:57 +00:00
|
|
|
return "rwebinput";
|
2017-01-24 05:55:55 +00:00
|
|
|
case INPUT_DOS:
|
|
|
|
return "dos";
|
2016-12-05 05:37:26 +00:00
|
|
|
case INPUT_NULL:
|
|
|
|
break;
|
2011-01-06 17:34:11 +00:00
|
|
|
}
|
2014-10-03 15:07:51 +00:00
|
|
|
|
2015-01-09 00:08:54 +00:00
|
|
|
return "null";
|
2012-05-07 21:20:13 +00:00
|
|
|
}
|
|
|
|
|
2015-01-11 04:29:32 +00:00
|
|
|
/**
|
|
|
|
* config_get_default_joypad:
|
|
|
|
*
|
|
|
|
* Gets default input joypad driver.
|
|
|
|
*
|
|
|
|
* Returns: Default input joypad driver.
|
|
|
|
**/
|
2014-10-03 00:40:47 +00:00
|
|
|
const char *config_get_default_joypad(void)
|
|
|
|
{
|
2016-12-05 05:37:26 +00:00
|
|
|
enum joypad_driver_enum default_driver = JOYPAD_DEFAULT_DRIVER;
|
|
|
|
|
|
|
|
switch (default_driver)
|
2014-10-03 00:40:47 +00:00
|
|
|
{
|
2018-12-30 13:00:18 +00:00
|
|
|
case JOYPAD_PS4:
|
|
|
|
return "ps4";
|
2014-10-03 00:40:47 +00:00
|
|
|
case JOYPAD_PS3:
|
|
|
|
return "ps3";
|
2015-04-05 18:43:24 +00:00
|
|
|
case JOYPAD_XINPUT:
|
|
|
|
return "xinput";
|
2014-10-03 00:40:47 +00:00
|
|
|
case JOYPAD_GX:
|
|
|
|
return "gx";
|
2016-10-27 00:34:10 +00:00
|
|
|
case JOYPAD_WIIU:
|
|
|
|
return "wiiu";
|
2014-10-03 00:40:47 +00:00
|
|
|
case JOYPAD_XDK:
|
|
|
|
return "xdk";
|
|
|
|
case JOYPAD_PSP:
|
2015-08-31 13:26:37 +00:00
|
|
|
#ifdef VITA
|
|
|
|
return "vita";
|
|
|
|
#else
|
2014-10-03 00:40:47 +00:00
|
|
|
return "psp";
|
2015-08-31 13:26:37 +00:00
|
|
|
#endif
|
2018-09-18 06:08:06 +00:00
|
|
|
case JOYPAD_PS2:
|
|
|
|
return "ps2";
|
2015-04-01 21:14:13 +00:00
|
|
|
case JOYPAD_CTR:
|
|
|
|
return "ctr";
|
2017-12-24 01:26:58 +00:00
|
|
|
case JOYPAD_SWITCH:
|
|
|
|
return "switch";
|
2014-10-03 00:40:47 +00:00
|
|
|
case JOYPAD_DINPUT:
|
|
|
|
return "dinput";
|
|
|
|
case JOYPAD_UDEV:
|
|
|
|
return "udev";
|
|
|
|
case JOYPAD_LINUXRAW:
|
|
|
|
return "linuxraw";
|
|
|
|
case JOYPAD_ANDROID:
|
|
|
|
return "android";
|
|
|
|
case JOYPAD_SDL:
|
|
|
|
#ifdef HAVE_SDL2
|
|
|
|
return "sdl2";
|
|
|
|
#else
|
|
|
|
return "sdl";
|
|
|
|
#endif
|
2015-04-01 18:00:38 +00:00
|
|
|
case JOYPAD_HID:
|
|
|
|
return "hid";
|
2014-10-03 00:40:47 +00:00
|
|
|
case JOYPAD_QNX:
|
|
|
|
return "qnx";
|
2018-01-15 06:06:57 +00:00
|
|
|
case JOYPAD_RWEBPAD:
|
|
|
|
return "rwebpad";
|
2017-01-24 05:55:55 +00:00
|
|
|
case JOYPAD_DOS:
|
|
|
|
return "dos";
|
2018-01-25 01:20:52 +00:00
|
|
|
case JOYPAD_MFI:
|
|
|
|
return "mfi";
|
2016-12-05 05:37:26 +00:00
|
|
|
case JOYPAD_NULL:
|
2015-01-09 01:15:12 +00:00
|
|
|
break;
|
2014-10-03 00:40:47 +00:00
|
|
|
}
|
2014-10-03 15:07:51 +00:00
|
|
|
|
2015-01-09 00:08:54 +00:00
|
|
|
return "null";
|
2014-10-03 00:40:47 +00:00
|
|
|
}
|
|
|
|
|
2015-01-11 04:29:32 +00:00
|
|
|
/**
|
|
|
|
* config_get_default_camera:
|
|
|
|
*
|
|
|
|
* Gets default camera driver.
|
|
|
|
*
|
|
|
|
* Returns: Default camera driver.
|
|
|
|
**/
|
2013-11-11 13:26:57 +00:00
|
|
|
const char *config_get_default_camera(void)
|
|
|
|
{
|
2016-12-05 05:37:26 +00:00
|
|
|
enum camera_driver_enum default_driver = CAMERA_DEFAULT_DRIVER;
|
|
|
|
|
|
|
|
switch (default_driver)
|
2013-11-11 13:26:57 +00:00
|
|
|
{
|
|
|
|
case CAMERA_V4L2:
|
|
|
|
return "video4linux2";
|
2013-11-13 00:48:36 +00:00
|
|
|
case CAMERA_RWEBCAM:
|
|
|
|
return "rwebcam";
|
2013-11-17 18:47:37 +00:00
|
|
|
case CAMERA_ANDROID:
|
|
|
|
return "android";
|
2015-04-19 18:46:49 +00:00
|
|
|
case CAMERA_AVFOUNDATION:
|
|
|
|
return "avfoundation";
|
2016-12-05 05:37:26 +00:00
|
|
|
case CAMERA_NULL:
|
2015-01-09 01:15:12 +00:00
|
|
|
break;
|
2013-11-11 13:26:57 +00:00
|
|
|
}
|
2014-10-03 15:07:51 +00:00
|
|
|
|
2015-01-09 00:08:54 +00:00
|
|
|
return "null";
|
2013-11-11 13:26:57 +00:00
|
|
|
}
|
|
|
|
|
2016-09-21 16:51:40 +00:00
|
|
|
/**
|
|
|
|
* config_get_default_wifi:
|
|
|
|
*
|
|
|
|
* Gets default wifi driver.
|
|
|
|
*
|
|
|
|
* Returns: Default wifi driver.
|
|
|
|
**/
|
|
|
|
const char *config_get_default_wifi(void)
|
|
|
|
{
|
2016-12-05 05:37:26 +00:00
|
|
|
enum wifi_driver_enum default_driver = WIFI_DEFAULT_DRIVER;
|
|
|
|
|
|
|
|
switch (default_driver)
|
2016-09-21 16:51:40 +00:00
|
|
|
{
|
|
|
|
case WIFI_CONNMANCTL:
|
|
|
|
return "connmanctl";
|
2016-12-05 05:37:26 +00:00
|
|
|
case WIFI_NULL:
|
2016-09-21 16:51:40 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return "null";
|
|
|
|
}
|
|
|
|
|
2017-12-27 16:05:12 +00:00
|
|
|
/**
|
|
|
|
* config_get_default_led:
|
|
|
|
*
|
|
|
|
* Gets default led driver.
|
|
|
|
*
|
|
|
|
* Returns: Default led driver.
|
|
|
|
**/
|
|
|
|
const char *config_get_default_led(void)
|
|
|
|
{
|
|
|
|
return "null";
|
|
|
|
}
|
|
|
|
|
2015-01-11 04:29:32 +00:00
|
|
|
/**
|
|
|
|
* config_get_default_location:
|
|
|
|
*
|
|
|
|
* Gets default location driver.
|
|
|
|
*
|
|
|
|
* Returns: Default location driver.
|
|
|
|
**/
|
2013-12-19 00:51:51 +00:00
|
|
|
const char *config_get_default_location(void)
|
|
|
|
{
|
2016-12-05 05:37:26 +00:00
|
|
|
enum location_driver_enum default_driver = LOCATION_DEFAULT_DRIVER;
|
|
|
|
|
|
|
|
switch (default_driver)
|
2013-12-19 00:51:51 +00:00
|
|
|
{
|
|
|
|
case LOCATION_ANDROID:
|
|
|
|
return "android";
|
2015-04-20 09:41:33 +00:00
|
|
|
case LOCATION_CORELOCATION:
|
|
|
|
return "corelocation";
|
2016-12-05 05:37:26 +00:00
|
|
|
case LOCATION_NULL:
|
2015-01-09 01:15:12 +00:00
|
|
|
break;
|
2013-12-19 00:51:51 +00:00
|
|
|
}
|
2014-10-03 15:07:51 +00:00
|
|
|
|
2015-01-09 00:08:54 +00:00
|
|
|
return "null";
|
2013-12-19 00:51:51 +00:00
|
|
|
}
|
|
|
|
|
2016-09-16 23:40:11 +00:00
|
|
|
/**
|
|
|
|
* config_get_default_menu:
|
|
|
|
*
|
|
|
|
* Gets default menu driver.
|
|
|
|
*
|
|
|
|
* Returns: Default menu driver.
|
|
|
|
**/
|
|
|
|
const char *config_get_default_menu(void)
|
2016-08-01 12:14:21 +00:00
|
|
|
{
|
2017-09-27 22:01:42 +00:00
|
|
|
#ifdef HAVE_MENU
|
2016-12-05 05:37:26 +00:00
|
|
|
enum menu_driver_enum default_driver = MENU_DEFAULT_DRIVER;
|
|
|
|
|
2016-09-16 23:40:11 +00:00
|
|
|
if (!string_is_empty(g_defaults.settings.menu))
|
|
|
|
return g_defaults.settings.menu;
|
|
|
|
|
2016-12-05 05:37:26 +00:00
|
|
|
switch (default_driver)
|
2016-09-16 23:40:11 +00:00
|
|
|
{
|
|
|
|
case MENU_RGUI:
|
|
|
|
return "rgui";
|
|
|
|
case MENU_XUI:
|
|
|
|
return "xui";
|
2018-09-18 13:13:33 +00:00
|
|
|
case MENU_OZONE:
|
|
|
|
return "ozone";
|
2016-09-16 23:40:11 +00:00
|
|
|
case MENU_MATERIALUI:
|
|
|
|
return "glui";
|
|
|
|
case MENU_XMB:
|
|
|
|
return "xmb";
|
2018-04-08 02:55:16 +00:00
|
|
|
case MENU_STRIPES:
|
|
|
|
return "stripes";
|
2016-12-05 05:37:26 +00:00
|
|
|
case MENU_NULL:
|
2016-09-16 23:40:11 +00:00
|
|
|
break;
|
|
|
|
}
|
2017-09-27 22:01:42 +00:00
|
|
|
#endif
|
2016-09-16 23:40:11 +00:00
|
|
|
|
|
|
|
return "null";
|
2016-08-01 12:14:21 +00:00
|
|
|
}
|
|
|
|
|
2018-06-04 05:48:08 +00:00
|
|
|
const char *config_get_default_midi(void)
|
|
|
|
{
|
|
|
|
enum midi_driver_enum default_driver = MIDI_DEFAULT_DRIVER;
|
|
|
|
|
|
|
|
switch (default_driver)
|
|
|
|
{
|
|
|
|
case MIDI_WINMM:
|
|
|
|
return "winmm";
|
2018-09-28 14:07:51 +00:00
|
|
|
case MIDI_ALSA:
|
|
|
|
return "alsa";
|
2018-06-04 05:48:08 +00:00
|
|
|
case MIDI_NULL:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return "null";
|
|
|
|
}
|
|
|
|
|
|
|
|
const char *config_get_midi_driver_options(void)
|
|
|
|
{
|
|
|
|
return char_list_new_special(STRING_LIST_MIDI_DRIVERS, NULL);
|
|
|
|
}
|
|
|
|
|
2016-09-16 23:40:11 +00:00
|
|
|
bool config_overlay_enable_default(void)
|
|
|
|
{
|
|
|
|
if (g_defaults.overlay.set)
|
|
|
|
return g_defaults.overlay.enable;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2016-12-26 03:14:09 +00:00
|
|
|
static struct config_array_setting *populate_settings_array(settings_t *settings, int *size)
|
2012-05-07 21:20:13 +00:00
|
|
|
{
|
2016-08-29 17:10:00 +00:00
|
|
|
unsigned count = 0;
|
2018-08-18 04:48:40 +00:00
|
|
|
struct config_array_setting *tmp = (struct config_array_setting*)calloc(1, (*size + 1) * sizeof(struct config_array_setting));
|
2016-09-01 01:01:04 +00:00
|
|
|
|
2019-01-10 21:24:43 +00:00
|
|
|
if (!tmp)
|
|
|
|
return NULL;
|
|
|
|
|
2016-09-01 00:46:09 +00:00
|
|
|
/* Arrays */
|
2017-04-28 20:59:13 +00:00
|
|
|
SETTING_ARRAY("video_driver", settings->arrays.video_driver, false, NULL, true);
|
|
|
|
SETTING_ARRAY("record_driver", settings->arrays.record_driver, false, NULL, true);
|
|
|
|
SETTING_ARRAY("camera_driver", settings->arrays.camera_driver, false, NULL, true);
|
|
|
|
SETTING_ARRAY("wifi_driver", settings->arrays.wifi_driver, false, NULL, true);
|
|
|
|
SETTING_ARRAY("location_driver", settings->arrays.location_driver,false, NULL, true);
|
2014-05-27 15:13:53 +00:00
|
|
|
#ifdef HAVE_MENU
|
2017-04-28 20:59:13 +00:00
|
|
|
SETTING_ARRAY("menu_driver", settings->arrays.menu_driver, false, NULL, true);
|
2016-07-09 11:05:58 +00:00
|
|
|
#endif
|
2017-04-28 20:59:13 +00:00
|
|
|
SETTING_ARRAY("audio_device", settings->arrays.audio_device, false, NULL, true);
|
|
|
|
SETTING_ARRAY("camera_device", settings->arrays.camera_device, false, NULL, true);
|
2016-08-29 17:10:00 +00:00
|
|
|
#ifdef HAVE_CHEEVOS
|
2017-04-28 20:59:13 +00:00
|
|
|
SETTING_ARRAY("cheevos_username", settings->arrays.cheevos_username, false, NULL, true);
|
|
|
|
SETTING_ARRAY("cheevos_password", settings->arrays.cheevos_password, false, NULL, true);
|
2018-04-25 02:31:07 +00:00
|
|
|
SETTING_ARRAY("cheevos_token", settings->arrays.cheevos_token, false, NULL, true);
|
2017-04-28 20:59:13 +00:00
|
|
|
#endif
|
|
|
|
SETTING_ARRAY("video_context_driver", settings->arrays.video_context_driver, false, NULL, true);
|
|
|
|
SETTING_ARRAY("audio_driver", settings->arrays.audio_driver, false, NULL, true);
|
|
|
|
SETTING_ARRAY("audio_resampler", settings->arrays.audio_resampler, false, NULL, true);
|
|
|
|
SETTING_ARRAY("input_driver", settings->arrays.input_driver, false, NULL, true);
|
|
|
|
SETTING_ARRAY("input_joypad_driver", settings->arrays.input_joypad_driver, false, NULL, true);
|
|
|
|
SETTING_ARRAY("input_keyboard_layout", settings->arrays.input_keyboard_layout, false, NULL, true);
|
|
|
|
SETTING_ARRAY("bundle_assets_src_path", settings->arrays.bundle_assets_src, false, NULL, true);
|
|
|
|
SETTING_ARRAY("bundle_assets_dst_path", settings->arrays.bundle_assets_dst, false, NULL, true);
|
|
|
|
SETTING_ARRAY("bundle_assets_dst_path_subdir", settings->arrays.bundle_assets_dst_subdir, false, NULL, true);
|
2017-12-27 16:05:12 +00:00
|
|
|
SETTING_ARRAY("led_driver", settings->arrays.led_driver, false, NULL, true);
|
2018-02-02 20:37:02 +00:00
|
|
|
SETTING_ARRAY("netplay_mitm_server", settings->arrays.netplay_mitm_server, false, NULL, true);
|
2018-06-04 05:48:08 +00:00
|
|
|
SETTING_ARRAY("midi_driver", settings->arrays.midi_driver, false, NULL, true);
|
|
|
|
SETTING_ARRAY("midi_input", settings->arrays.midi_input, true, midi_input, true);
|
|
|
|
SETTING_ARRAY("midi_output", settings->arrays.midi_output, true, midi_output, true);
|
2018-09-26 21:22:12 +00:00
|
|
|
SETTING_ARRAY("youtube_stream_key", settings->arrays.youtube_stream_key, true, NULL, true);
|
2019-05-19 16:47:38 +00:00
|
|
|
SETTING_ARRAY("twitch_stream_key", settings->arrays.twitch_stream_key, true, NULL, true);
|
2018-10-13 23:17:17 +00:00
|
|
|
SETTING_ARRAY("discord_app_id", settings->arrays.discord_app_id, true, default_discord_app_id, true);
|
2019-08-22 05:07:07 +00:00
|
|
|
SETTING_ARRAY("ai_service_url", settings->arrays.ai_service_url, true, DEFAULT_AI_SERVICE_URL, true);
|
2019-05-11 05:15:39 +00:00
|
|
|
|
2016-12-26 03:14:09 +00:00
|
|
|
*size = count;
|
|
|
|
|
|
|
|
return tmp;
|
2016-08-29 17:10:00 +00:00
|
|
|
}
|
2014-06-12 23:10:14 +00:00
|
|
|
|
2016-12-26 03:14:09 +00:00
|
|
|
static struct config_path_setting *populate_settings_path(settings_t *settings, int *size)
|
2016-08-29 17:10:00 +00:00
|
|
|
{
|
|
|
|
unsigned count = 0;
|
2018-08-18 04:56:10 +00:00
|
|
|
struct config_path_setting *tmp = (struct config_path_setting*)calloc(1, (*size + 1) * sizeof(struct config_path_setting));
|
2014-06-12 23:10:14 +00:00
|
|
|
|
2019-01-10 21:24:43 +00:00
|
|
|
if (!tmp)
|
|
|
|
return NULL;
|
|
|
|
|
2016-09-01 01:00:27 +00:00
|
|
|
/* Paths */
|
2016-09-01 02:37:22 +00:00
|
|
|
#ifdef HAVE_XMB
|
2017-04-28 22:39:29 +00:00
|
|
|
SETTING_PATH("xmb_font", settings->paths.path_menu_xmb_font, false, NULL, true);
|
2016-09-01 02:37:22 +00:00
|
|
|
#endif
|
2018-01-01 18:38:16 +00:00
|
|
|
SETTING_PATH("content_show_settings_password", settings->paths.menu_content_show_settings_password, false, NULL, true);
|
2017-10-11 09:30:53 +00:00
|
|
|
SETTING_PATH("kiosk_mode_password", settings->paths.kiosk_mode_password, false, NULL, true);
|
2017-04-28 22:39:29 +00:00
|
|
|
SETTING_PATH("netplay_nickname", settings->paths.username, false, NULL, true);
|
|
|
|
SETTING_PATH("video_filter", settings->paths.path_softfilter_plugin, false, NULL, true);
|
|
|
|
SETTING_PATH("audio_dsp_plugin", settings->paths.path_audio_dsp_plugin, false, NULL, true);
|
2019-08-26 18:48:19 +00:00
|
|
|
SETTING_PATH("core_updater_buildbot_cores_url", settings->paths.network_buildbot_url, false, NULL, true);
|
2017-04-28 22:39:29 +00:00
|
|
|
SETTING_PATH("core_updater_buildbot_assets_url", settings->paths.network_buildbot_assets_url, false, NULL, true);
|
2016-09-29 19:07:10 +00:00
|
|
|
#ifdef HAVE_NETWORKING
|
2017-04-28 22:39:29 +00:00
|
|
|
SETTING_PATH("netplay_ip_address", settings->paths.netplay_server, false, NULL, true);
|
|
|
|
SETTING_PATH("netplay_password", settings->paths.netplay_password, false, NULL, true);
|
|
|
|
SETTING_PATH("netplay_spectate_password", settings->paths.netplay_spectate_password, false, NULL, true);
|
2016-09-01 01:41:10 +00:00
|
|
|
#endif
|
|
|
|
SETTING_PATH("libretro_directory",
|
2017-04-28 22:39:29 +00:00
|
|
|
settings->paths.directory_libretro, false, NULL, false);
|
2016-09-01 01:41:10 +00:00
|
|
|
SETTING_PATH("core_options_path",
|
2017-04-28 22:39:29 +00:00
|
|
|
settings->paths.path_core_options, false, NULL, true);
|
2016-09-01 01:41:10 +00:00
|
|
|
SETTING_PATH("libretro_info_path",
|
2017-04-28 22:39:29 +00:00
|
|
|
settings->paths.path_libretro_info, false, NULL, true);
|
2016-09-01 01:41:10 +00:00
|
|
|
SETTING_PATH("content_database_path",
|
2017-04-28 22:39:29 +00:00
|
|
|
settings->paths.path_content_database, false, NULL, true);
|
2016-09-01 01:41:10 +00:00
|
|
|
SETTING_PATH("cheat_database_path",
|
2017-04-28 22:39:29 +00:00
|
|
|
settings->paths.path_cheat_database, false, NULL, true);
|
2016-08-29 17:10:00 +00:00
|
|
|
#ifdef HAVE_MENU
|
2017-07-14 19:11:27 +00:00
|
|
|
SETTING_PATH("menu_wallpaper",
|
2017-04-28 22:39:29 +00:00
|
|
|
settings->paths.path_menu_wallpaper, false, NULL, true);
|
2019-01-29 17:03:44 +00:00
|
|
|
SETTING_PATH("rgui_menu_theme_preset",
|
|
|
|
settings->paths.path_rgui_theme_preset, false, NULL, true);
|
2016-09-01 01:41:10 +00:00
|
|
|
#endif
|
|
|
|
SETTING_PATH("content_history_path",
|
2017-04-28 22:39:29 +00:00
|
|
|
settings->paths.path_content_history, false, NULL, true);
|
2017-08-12 15:10:14 +00:00
|
|
|
SETTING_PATH("content_favorites_path",
|
|
|
|
settings->paths.path_content_favorites, false, NULL, true);
|
2016-09-01 01:41:10 +00:00
|
|
|
SETTING_PATH("content_music_history_path",
|
2017-04-28 22:39:29 +00:00
|
|
|
settings->paths.path_content_music_history, false, NULL, true);
|
2016-09-01 01:41:10 +00:00
|
|
|
SETTING_PATH("content_video_history_path",
|
2017-04-28 22:39:29 +00:00
|
|
|
settings->paths.path_content_video_history, false, NULL, true);
|
2016-09-01 01:41:10 +00:00
|
|
|
SETTING_PATH("content_image_history_path",
|
2017-04-28 22:39:29 +00:00
|
|
|
settings->paths.path_content_image_history, false, NULL, true);
|
2016-08-29 17:10:00 +00:00
|
|
|
#ifdef HAVE_OVERLAY
|
2016-09-01 01:41:10 +00:00
|
|
|
SETTING_PATH("input_overlay",
|
2017-04-28 22:39:29 +00:00
|
|
|
settings->paths.path_overlay, false, NULL, true);
|
2019-04-16 16:41:06 +00:00
|
|
|
#endif
|
|
|
|
#ifdef HAVE_VIDEO_LAYOUT
|
|
|
|
SETTING_PATH("video_layout_path",
|
|
|
|
settings->paths.path_video_layout, false, NULL, true);
|
|
|
|
SETTING_PATH("video_layout_directory",
|
|
|
|
settings->paths.directory_video_layout, true, NULL, true);
|
2018-09-15 22:44:46 +00:00
|
|
|
#endif
|
|
|
|
SETTING_PATH("video_record_config",
|
|
|
|
settings->paths.path_record_config, false, NULL, true);
|
|
|
|
SETTING_PATH("video_stream_config",
|
|
|
|
settings->paths.path_stream_config, false, NULL, true);
|
|
|
|
SETTING_PATH("video_stream_url",
|
|
|
|
settings->paths.path_stream_url, false, NULL, true);
|
2016-09-01 01:41:10 +00:00
|
|
|
SETTING_PATH("video_font_path",
|
2017-04-28 22:39:29 +00:00
|
|
|
settings->paths.path_font, false, NULL, true);
|
2016-09-01 01:41:10 +00:00
|
|
|
SETTING_PATH("cursor_directory",
|
2017-04-28 22:39:29 +00:00
|
|
|
settings->paths.directory_cursor, false, NULL, true);
|
2017-07-14 19:11:27 +00:00
|
|
|
SETTING_PATH("content_history_dir",
|
2017-04-28 22:39:29 +00:00
|
|
|
settings->paths.directory_content_history, false, NULL, true);
|
2016-09-01 01:41:10 +00:00
|
|
|
SETTING_PATH("screenshot_directory",
|
2017-04-28 22:39:29 +00:00
|
|
|
settings->paths.directory_screenshot, true, NULL, true);
|
2016-09-01 01:41:10 +00:00
|
|
|
SETTING_PATH("system_directory",
|
2017-04-28 22:39:29 +00:00
|
|
|
settings->paths.directory_system, true, NULL, true);
|
2016-09-01 01:41:10 +00:00
|
|
|
SETTING_PATH("cache_directory",
|
2017-04-28 22:39:29 +00:00
|
|
|
settings->paths.directory_cache, false, NULL, true);
|
2016-09-01 01:41:10 +00:00
|
|
|
SETTING_PATH("input_remapping_directory",
|
2017-04-28 22:39:29 +00:00
|
|
|
settings->paths.directory_input_remapping, false, NULL, true);
|
2016-09-01 01:41:10 +00:00
|
|
|
SETTING_PATH("resampler_directory",
|
2017-04-28 22:39:29 +00:00
|
|
|
settings->paths.directory_resampler, false, NULL, true);
|
2016-09-01 01:41:10 +00:00
|
|
|
SETTING_PATH("video_shader_dir",
|
2017-04-28 22:39:29 +00:00
|
|
|
settings->paths.directory_video_shader, true, NULL, true);
|
2016-09-01 01:41:10 +00:00
|
|
|
SETTING_PATH("video_filter_dir",
|
2017-04-28 22:39:29 +00:00
|
|
|
settings->paths.directory_video_filter, true, NULL, true);
|
2016-09-01 01:41:10 +00:00
|
|
|
SETTING_PATH("core_assets_directory",
|
2017-04-28 22:39:29 +00:00
|
|
|
settings->paths.directory_core_assets, true, NULL, true);
|
2016-09-01 01:41:10 +00:00
|
|
|
SETTING_PATH("assets_directory",
|
2017-04-28 22:39:29 +00:00
|
|
|
settings->paths.directory_assets, true, NULL, true);
|
2016-09-01 01:41:10 +00:00
|
|
|
SETTING_PATH("dynamic_wallpapers_directory",
|
2017-04-28 22:39:29 +00:00
|
|
|
settings->paths.directory_dynamic_wallpapers, true, NULL, true);
|
2016-09-01 01:41:10 +00:00
|
|
|
SETTING_PATH("thumbnails_directory",
|
2017-04-28 22:39:29 +00:00
|
|
|
settings->paths.directory_thumbnails, true, NULL, true);
|
2016-09-01 01:41:10 +00:00
|
|
|
SETTING_PATH("playlist_directory",
|
2017-04-28 22:39:29 +00:00
|
|
|
settings->paths.directory_playlist, true, NULL, true);
|
2019-03-11 12:50:46 +00:00
|
|
|
SETTING_PATH("runtime_log_directory",
|
|
|
|
settings->paths.directory_runtime_log, true, NULL, true);
|
2016-09-01 01:41:10 +00:00
|
|
|
SETTING_PATH("joypad_autoconfig_dir",
|
2017-04-28 22:39:29 +00:00
|
|
|
settings->paths.directory_autoconfig, false, NULL, true);
|
2016-09-01 01:41:10 +00:00
|
|
|
SETTING_PATH("audio_filter_dir",
|
2017-04-28 22:39:29 +00:00
|
|
|
settings->paths.directory_audio_filter, true, NULL, true);
|
2017-07-14 19:11:27 +00:00
|
|
|
SETTING_PATH("savefile_directory",
|
2016-10-03 06:15:41 +00:00
|
|
|
dir_get_ptr(RARCH_DIR_SAVEFILE), true, NULL, false);
|
2016-09-01 01:41:10 +00:00
|
|
|
SETTING_PATH("savestate_directory",
|
2016-10-03 06:15:41 +00:00
|
|
|
dir_get_ptr(RARCH_DIR_SAVESTATE), true, NULL, false);
|
2016-08-29 17:10:00 +00:00
|
|
|
#ifdef HAVE_MENU
|
2016-09-01 01:41:10 +00:00
|
|
|
SETTING_PATH("rgui_browser_directory",
|
2017-04-28 22:39:29 +00:00
|
|
|
settings->paths.directory_menu_content, true, NULL, true);
|
2016-09-01 01:41:10 +00:00
|
|
|
SETTING_PATH("rgui_config_directory",
|
2017-04-28 22:39:29 +00:00
|
|
|
settings->paths.directory_menu_config, true, NULL, true);
|
2016-08-29 17:10:00 +00:00
|
|
|
#endif
|
|
|
|
#ifdef HAVE_OVERLAY
|
2016-09-01 01:41:10 +00:00
|
|
|
SETTING_PATH("overlay_directory",
|
2017-04-28 22:39:29 +00:00
|
|
|
settings->paths.directory_overlay, true, NULL, true);
|
2016-08-29 17:10:00 +00:00
|
|
|
#endif
|
2019-04-16 16:41:06 +00:00
|
|
|
#ifdef HAVE_VIDEO_LAYOUT
|
|
|
|
SETTING_PATH("video_layout_directory",
|
|
|
|
settings->paths.directory_video_layout, true, NULL, true);
|
|
|
|
#endif
|
2016-08-29 17:10:00 +00:00
|
|
|
#ifndef HAVE_DYNAMIC
|
2017-07-14 19:11:27 +00:00
|
|
|
SETTING_PATH("libretro_path",
|
2016-10-03 13:46:07 +00:00
|
|
|
path_get_ptr(RARCH_PATH_CORE), false, NULL, false);
|
2016-08-29 17:10:00 +00:00
|
|
|
#endif
|
|
|
|
SETTING_PATH(
|
2017-07-14 19:11:27 +00:00
|
|
|
"screenshot_directory",
|
2017-04-28 22:39:29 +00:00
|
|
|
settings->paths.directory_screenshot, true, NULL, false);
|
2016-08-29 17:10:00 +00:00
|
|
|
|
2016-12-26 02:16:27 +00:00
|
|
|
{
|
2019-07-04 15:21:58 +00:00
|
|
|
global_t *global = global_get_ptr();
|
|
|
|
if (global)
|
|
|
|
{
|
|
|
|
SETTING_PATH("recording_output_directory",
|
|
|
|
global->record.output_dir, false, NULL, true);
|
|
|
|
SETTING_PATH("recording_config_directory",
|
|
|
|
global->record.config_dir, false, NULL, true);
|
|
|
|
}
|
2016-12-26 02:16:27 +00:00
|
|
|
}
|
|
|
|
|
2019-03-21 16:56:24 +00:00
|
|
|
SETTING_ARRAY("log_dir", settings->paths.log_dir, true, NULL, true);
|
2019-03-05 22:34:05 +00:00
|
|
|
|
2016-12-26 03:14:09 +00:00
|
|
|
*size = count;
|
|
|
|
|
|
|
|
return tmp;
|
2016-08-29 17:10:00 +00:00
|
|
|
}
|
|
|
|
|
2016-12-26 03:14:09 +00:00
|
|
|
static struct config_bool_setting *populate_settings_bool(settings_t *settings, int *size)
|
2016-08-29 17:10:00 +00:00
|
|
|
{
|
2019-02-06 20:25:22 +00:00
|
|
|
struct config_bool_setting *tmp = (struct config_bool_setting*)calloc(1, (*size + 1) * sizeof(struct config_bool_setting));
|
2016-08-29 17:10:00 +00:00
|
|
|
unsigned count = 0;
|
|
|
|
|
2019-08-24 16:18:24 +00:00
|
|
|
SETTING_BOOL("frame_time_counter_reset_after_fastforwarding", &settings->bools.frame_time_counter_reset_after_fastforwarding, true, false, false);
|
|
|
|
SETTING_BOOL("frame_time_counter_reset_after_load_state", &settings->bools.frame_time_counter_reset_after_load_state, true, false, false);
|
|
|
|
SETTING_BOOL("frame_time_counter_reset_after_save_state", &settings->bools.frame_time_counter_reset_after_save_state, true, false, false);
|
|
|
|
SETTING_BOOL("crt_switch_resolution_use_custom_refresh_rate", &settings->bools.crt_switch_custom_refresh_enable, true, false, false);
|
2019-07-19 11:30:11 +00:00
|
|
|
SETTING_BOOL("automatically_add_content_to_playlist", &settings->bools.automatically_add_content_to_playlist, true, DEFAULT_AUTOMATICALLY_ADD_CONTENT_TO_PLAYLIST, false);
|
2017-04-27 22:53:06 +00:00
|
|
|
SETTING_BOOL("ui_companion_start_on_boot", &settings->bools.ui_companion_start_on_boot, true, ui_companion_start_on_boot, false);
|
|
|
|
SETTING_BOOL("ui_companion_enable", &settings->bools.ui_companion_enable, true, ui_companion_enable, false);
|
2018-04-30 18:33:05 +00:00
|
|
|
SETTING_BOOL("ui_companion_toggle", &settings->bools.ui_companion_toggle, false, ui_companion_toggle, false);
|
2018-04-30 23:11:38 +00:00
|
|
|
SETTING_BOOL("desktop_menu_enable", &settings->bools.desktop_menu_enable, true, desktop_menu_enable, false);
|
2019-06-14 09:13:02 +00:00
|
|
|
SETTING_BOOL("video_gpu_record", &settings->bools.video_gpu_record, true, DEFAULT_GPU_RECORD, false);
|
2017-04-28 11:43:47 +00:00
|
|
|
SETTING_BOOL("input_remap_binds_enable", &settings->bools.input_remap_binds_enable, true, true, false);
|
2019-06-14 11:01:22 +00:00
|
|
|
SETTING_BOOL("all_users_control_menu", &settings->bools.input_all_users_control_menu, true, DEFAULT_ALL_USERS_CONTROL_MENU, false);
|
2019-07-19 11:30:11 +00:00
|
|
|
SETTING_BOOL("menu_swap_ok_cancel_buttons", &settings->bools.input_menu_swap_ok_cancel_buttons, true, DEFAULT_MENU_SWAP_OK_CANCEL_BUTTONS, false);
|
2016-10-03 03:06:01 +00:00
|
|
|
#ifdef HAVE_NETWORKING
|
2019-06-02 15:18:52 +00:00
|
|
|
SETTING_BOOL("netplay_public_announce", &settings->bools.netplay_public_announce, true, DEFAULT_NETPLAY_PUBLIC_ANNOUNCE, false);
|
2017-04-28 11:43:47 +00:00
|
|
|
SETTING_BOOL("netplay_start_as_spectator", &settings->bools.netplay_start_as_spectator, false, netplay_start_as_spectator, false);
|
|
|
|
SETTING_BOOL("netplay_allow_slaves", &settings->bools.netplay_allow_slaves, true, netplay_allow_slaves, false);
|
|
|
|
SETTING_BOOL("netplay_require_slaves", &settings->bools.netplay_require_slaves, true, netplay_require_slaves, false);
|
|
|
|
SETTING_BOOL("netplay_stateless_mode", &settings->bools.netplay_stateless_mode, true, netplay_stateless_mode, false);
|
2018-03-09 22:23:34 +00:00
|
|
|
SETTING_OVERRIDE(RARCH_OVERRIDE_SETTING_NETPLAY_STATELESS_MODE);
|
2017-04-28 11:43:47 +00:00
|
|
|
SETTING_BOOL("netplay_use_mitm_server", &settings->bools.netplay_use_mitm_server, true, netplay_use_mitm_server, false);
|
2018-01-23 07:51:39 +00:00
|
|
|
SETTING_BOOL("netplay_request_device_p1", &settings->bools.netplay_request_devices[0], true, false, false);
|
|
|
|
SETTING_BOOL("netplay_request_device_p2", &settings->bools.netplay_request_devices[1], true, false, false);
|
|
|
|
SETTING_BOOL("netplay_request_device_p3", &settings->bools.netplay_request_devices[2], true, false, false);
|
|
|
|
SETTING_BOOL("netplay_request_device_p4", &settings->bools.netplay_request_devices[3], true, false, false);
|
|
|
|
SETTING_BOOL("netplay_request_device_p5", &settings->bools.netplay_request_devices[4], true, false, false);
|
|
|
|
SETTING_BOOL("netplay_request_device_p6", &settings->bools.netplay_request_devices[5], true, false, false);
|
|
|
|
SETTING_BOOL("netplay_request_device_p7", &settings->bools.netplay_request_devices[6], true, false, false);
|
|
|
|
SETTING_BOOL("netplay_request_device_p8", &settings->bools.netplay_request_devices[7], true, false, false);
|
|
|
|
SETTING_BOOL("netplay_request_device_p9", &settings->bools.netplay_request_devices[8], true, false, false);
|
|
|
|
SETTING_BOOL("netplay_request_device_p10", &settings->bools.netplay_request_devices[9], true, false, false);
|
|
|
|
SETTING_BOOL("netplay_request_device_p11", &settings->bools.netplay_request_devices[10], true, false, false);
|
|
|
|
SETTING_BOOL("netplay_request_device_p12", &settings->bools.netplay_request_devices[11], true, false, false);
|
|
|
|
SETTING_BOOL("netplay_request_device_p13", &settings->bools.netplay_request_devices[12], true, false, false);
|
|
|
|
SETTING_BOOL("netplay_request_device_p14", &settings->bools.netplay_request_devices[13], true, false, false);
|
|
|
|
SETTING_BOOL("netplay_request_device_p15", &settings->bools.netplay_request_devices[14], true, false, false);
|
|
|
|
SETTING_BOOL("netplay_request_device_p16", &settings->bools.netplay_request_devices[15], true, false, false);
|
2019-05-24 11:02:02 +00:00
|
|
|
SETTING_BOOL("network_on_demand_thumbnails", &settings->bools.network_on_demand_thumbnails, true, network_on_demand_thumbnails, false);
|
2017-04-28 11:43:47 +00:00
|
|
|
#endif
|
|
|
|
SETTING_BOOL("input_descriptor_label_show", &settings->bools.input_descriptor_label_show, true, input_descriptor_label_show, false);
|
|
|
|
SETTING_BOOL("input_descriptor_hide_unbound", &settings->bools.input_descriptor_hide_unbound, true, input_descriptor_hide_unbound, false);
|
2019-06-02 19:02:59 +00:00
|
|
|
SETTING_BOOL("load_dummy_on_core_shutdown", &settings->bools.load_dummy_on_core_shutdown, true, DEFAULT_LOAD_DUMMY_ON_CORE_SHUTDOWN, false);
|
|
|
|
SETTING_BOOL("check_firmware_before_loading", &settings->bools.check_firmware_before_loading, true, DEFAULT_CHECK_FIRMWARE_BEFORE_LOADING, false);
|
2017-04-28 11:43:47 +00:00
|
|
|
SETTING_BOOL("builtin_mediaplayer_enable", &settings->bools.multimedia_builtin_mediaplayer_enable, false, false /* TODO */, false);
|
|
|
|
SETTING_BOOL("builtin_imageviewer_enable", &settings->bools.multimedia_builtin_imageviewer_enable, true, true, false);
|
2019-06-02 15:18:52 +00:00
|
|
|
SETTING_BOOL("fps_show", &settings->bools.video_fps_show, true, DEFAULT_FPS_SHOW, false);
|
|
|
|
SETTING_BOOL("statistics_show", &settings->bools.video_statistics_show, true, DEFAULT_STATISTICS_SHOW, false);
|
|
|
|
SETTING_BOOL("framecount_show", &settings->bools.video_framecount_show, true, DEFAULT_FRAMECOUNT_SHOW, false);
|
|
|
|
SETTING_BOOL("memory_show", &settings->bools.video_memory_show, true, DEFAULT_MEMORY_SHOW, false);
|
2019-07-19 18:00:31 +00:00
|
|
|
SETTING_BOOL("ui_menubar_enable", &settings->bools.ui_menubar_enable, true, DEFAULT_UI_MENUBAR_ENABLE, false);
|
2017-04-27 22:53:06 +00:00
|
|
|
SETTING_BOOL("suspend_screensaver_enable", &settings->bools.ui_suspend_screensaver_enable, true, true, false);
|
2019-06-02 15:18:52 +00:00
|
|
|
SETTING_BOOL("rewind_enable", &settings->bools.rewind_enable, true, DEFAULT_REWIND_ENABLE, false);
|
|
|
|
SETTING_BOOL("vrr_runloop_enable", &settings->bools.vrr_runloop_enable, true, DEFAULT_VRR_RUNLOOP_ENABLE, false);
|
|
|
|
SETTING_BOOL("apply_cheats_after_toggle", &settings->bools.apply_cheats_after_toggle, true, DEFAULT_APPLY_CHEATS_AFTER_TOGGLE, false);
|
|
|
|
SETTING_BOOL("apply_cheats_after_load", &settings->bools.apply_cheats_after_load, true, DEFAULT_APPLY_CHEATS_AFTER_LOAD, false);
|
2018-03-28 19:22:07 +00:00
|
|
|
SETTING_BOOL("run_ahead_enabled", &settings->bools.run_ahead_enabled, true, false, false);
|
|
|
|
SETTING_BOOL("run_ahead_secondary_instance", &settings->bools.run_ahead_secondary_instance, true, false, false);
|
2018-05-10 00:08:16 +00:00
|
|
|
SETTING_BOOL("run_ahead_hide_warnings", &settings->bools.run_ahead_hide_warnings, true, false, false);
|
2019-06-02 15:18:52 +00:00
|
|
|
SETTING_BOOL("audio_sync", &settings->bools.audio_sync, true, DEFAULT_AUDIO_SYNC, false);
|
2019-06-02 16:09:33 +00:00
|
|
|
SETTING_BOOL("video_shader_enable", &settings->bools.video_shader_enable, true, DEFAULT_SHADER_ENABLE, false);
|
2019-06-14 09:13:02 +00:00
|
|
|
SETTING_BOOL("video_shader_watch_files", &settings->bools.video_shader_watch_files, true, DEFAULT_VIDEO_SHADER_WATCH_FILES, false);
|
2016-08-29 19:03:01 +00:00
|
|
|
|
|
|
|
/* Let implementation decide if automatic, or 1:1 PAR. */
|
2019-06-02 15:18:52 +00:00
|
|
|
SETTING_BOOL("video_aspect_ratio_auto", &settings->bools.video_aspect_ratio_auto, true, DEFAULT_ASPECT_RATIO_AUTO, false);
|
2017-04-27 22:53:06 +00:00
|
|
|
|
2019-06-14 09:13:02 +00:00
|
|
|
SETTING_BOOL("video_allow_rotate", &settings->bools.video_allow_rotate, true, DEFAULT_ALLOW_ROTATE, false);
|
2019-06-02 15:18:52 +00:00
|
|
|
SETTING_BOOL("video_windowed_fullscreen", &settings->bools.video_windowed_fullscreen, true, DEFAULT_WINDOWED_FULLSCREEN, false);
|
2019-06-02 16:09:33 +00:00
|
|
|
SETTING_BOOL("video_crop_overscan", &settings->bools.video_crop_overscan, true, DEFAULT_CROP_OVERSCAN, false);
|
|
|
|
SETTING_BOOL("video_scale_integer", &settings->bools.video_scale_integer, true, DEFAULT_SCALE_INTEGER, false);
|
2019-06-02 15:18:52 +00:00
|
|
|
SETTING_BOOL("video_smooth", &settings->bools.video_smooth, true, DEFAULT_VIDEO_SMOOTH, false);
|
|
|
|
SETTING_BOOL("video_force_aspect", &settings->bools.video_force_aspect, true, DEFAULT_FORCE_ASPECT, false);
|
2019-05-31 13:59:49 +00:00
|
|
|
SETTING_BOOL("video_threaded", video_driver_get_threaded(), true, DEFAULT_VIDEO_THREADED, false);
|
2019-06-02 16:09:33 +00:00
|
|
|
SETTING_BOOL("video_shared_context", &settings->bools.video_shared_context, true, DEFAULT_VIDEO_SHARED_CONTEXT, false);
|
2019-06-14 09:13:02 +00:00
|
|
|
SETTING_BOOL("auto_screenshot_filename", &settings->bools.auto_screenshot_filename, true, DEFAULT_AUTO_SCREENSHOT_FILENAME, false);
|
2017-04-27 22:53:06 +00:00
|
|
|
SETTING_BOOL("video_force_srgb_disable", &settings->bools.video_force_srgb_disable, true, false, false);
|
2019-06-02 15:18:52 +00:00
|
|
|
SETTING_BOOL("video_fullscreen", &settings->bools.video_fullscreen, true, DEFAULT_FULLSCREEN, false);
|
2019-05-31 13:59:49 +00:00
|
|
|
SETTING_BOOL("bundle_assets_extract_enable", &settings->bools.bundle_assets_extract_enable, true, DEFAULT_BUNDLE_ASSETS_EXTRACT_ENABLE, false);
|
2019-06-02 15:18:52 +00:00
|
|
|
SETTING_BOOL("video_vsync", &settings->bools.video_vsync, true, DEFAULT_VSYNC, false);
|
|
|
|
SETTING_BOOL("video_adaptive_vsync", &settings->bools.video_adaptive_vsync, true, DEFAULT_ADAPTIVE_VSYNC, false);
|
|
|
|
SETTING_BOOL("video_hard_sync", &settings->bools.video_hard_sync, true, DEFAULT_HARD_SYNC, false);
|
|
|
|
SETTING_BOOL("video_black_frame_insertion", &settings->bools.video_black_frame_insertion, true, DEFAULT_BLACK_FRAME_INSERTION, false);
|
|
|
|
SETTING_BOOL("video_disable_composition", &settings->bools.video_disable_composition, true, DEFAULT_DISABLE_COMPOSITION, false);
|
|
|
|
SETTING_BOOL("pause_nonactive", &settings->bools.pause_nonactive, true, DEFAULT_PAUSE_NONACTIVE, false);
|
2019-06-14 09:13:02 +00:00
|
|
|
SETTING_BOOL("video_gpu_screenshot", &settings->bools.video_gpu_screenshot, true, DEFAULT_GPU_SCREENSHOT, false);
|
|
|
|
SETTING_BOOL("video_post_filter_record", &settings->bools.video_post_filter_record, true, DEFAULT_POST_FILTER_RECORD, false);
|
2017-04-28 11:43:47 +00:00
|
|
|
SETTING_BOOL("keyboard_gamepad_enable", &settings->bools.input_keyboard_gamepad_enable, true, true, false);
|
|
|
|
SETTING_BOOL("core_set_supports_no_game_enable", &settings->bools.set_supports_no_game_enable, true, true, false);
|
2019-06-02 15:18:52 +00:00
|
|
|
SETTING_BOOL("audio_enable", &settings->bools.audio_enable, true, DEFAULT_AUDIO_ENABLE, false);
|
2019-06-14 09:13:02 +00:00
|
|
|
SETTING_BOOL("menu_enable_widgets", &settings->bools.menu_enable_widgets, true, DEFAULT_MENU_ENABLE_WIDGETS, false);
|
2019-01-27 16:22:16 +00:00
|
|
|
SETTING_BOOL("audio_enable_menu", &settings->bools.audio_enable_menu, true, audio_enable_menu, false);
|
|
|
|
SETTING_BOOL("audio_enable_menu_ok", &settings->bools.audio_enable_menu_ok, true, audio_enable_menu_ok, false);
|
|
|
|
SETTING_BOOL("audio_enable_menu_cancel", &settings->bools.audio_enable_menu_cancel, true, audio_enable_menu_cancel, false);
|
|
|
|
SETTING_BOOL("audio_enable_menu_notice", &settings->bools.audio_enable_menu_notice, true, audio_enable_menu_notice, false);
|
|
|
|
SETTING_BOOL("audio_enable_menu_bgm", &settings->bools.audio_enable_menu_bgm, true, audio_enable_menu_bgm, false);
|
2017-05-08 19:39:08 +00:00
|
|
|
SETTING_BOOL("audio_mute_enable", audio_get_bool_ptr(AUDIO_ACTION_MUTE_ENABLE), true, false, false);
|
2019-07-11 09:51:06 +00:00
|
|
|
#ifdef HAVE_AUDIOMIXER
|
2017-06-08 21:53:24 +00:00
|
|
|
SETTING_BOOL("audio_mixer_mute_enable", audio_get_bool_ptr(AUDIO_ACTION_MIXER_MUTE_ENABLE), true, false, false);
|
2019-07-11 09:51:06 +00:00
|
|
|
#endif
|
2017-04-28 11:43:47 +00:00
|
|
|
SETTING_BOOL("location_allow", &settings->bools.location_allow, true, false, false);
|
2019-06-14 09:13:02 +00:00
|
|
|
SETTING_BOOL("video_font_enable", &settings->bools.video_font_enable, true, DEFAULT_FONT_ENABLE, false);
|
2017-04-28 11:43:47 +00:00
|
|
|
SETTING_BOOL("core_updater_auto_extract_archive", &settings->bools.network_buildbot_auto_extract_archive, true, true, false);
|
|
|
|
SETTING_BOOL("camera_allow", &settings->bools.camera_allow, true, false, false);
|
2018-05-29 10:18:01 +00:00
|
|
|
SETTING_BOOL("discord_allow", &settings->bools.discord_enable, true, false, false);
|
2016-10-14 19:57:18 +00:00
|
|
|
#if defined(VITA)
|
2017-04-28 11:43:47 +00:00
|
|
|
SETTING_BOOL("input_backtouch_enable", &settings->bools.input_backtouch_enable, false, false, false);
|
|
|
|
SETTING_BOOL("input_backtouch_toggle", &settings->bools.input_backtouch_toggle, false, false, false);
|
2016-10-14 19:57:18 +00:00
|
|
|
#endif
|
2016-08-29 17:10:00 +00:00
|
|
|
#if TARGET_OS_IPHONE
|
2017-04-28 11:43:47 +00:00
|
|
|
SETTING_BOOL("small_keyboard_enable", &settings->bools.input_small_keyboard_enable, true, false, false);
|
2016-08-29 17:10:00 +00:00
|
|
|
#endif
|
|
|
|
#ifdef GEKKO
|
2019-06-02 19:02:59 +00:00
|
|
|
SETTING_BOOL("video_vfilter", &settings->bools.video_vfilter, true, DEFAULT_VIDEO_VFILTER, false);
|
2016-08-29 17:10:00 +00:00
|
|
|
#endif
|
|
|
|
#ifdef HAVE_THREADS
|
2019-06-02 16:09:33 +00:00
|
|
|
SETTING_BOOL("threaded_data_runloop_enable", &settings->bools.threaded_data_runloop_enable, true, DEFAULT_THREADED_DATA_RUNLOOP_ENABLE, false);
|
2017-04-28 11:43:47 +00:00
|
|
|
#endif
|
2019-01-08 06:39:15 +00:00
|
|
|
#ifdef HAVE_MENU
|
|
|
|
SETTING_BOOL("menu_unified_controls", &settings->bools.menu_unified_controls, true, false, false);
|
2017-04-28 11:43:47 +00:00
|
|
|
SETTING_BOOL("menu_throttle_framerate", &settings->bools.menu_throttle_framerate, true, true, false);
|
|
|
|
SETTING_BOOL("menu_linear_filter", &settings->bools.menu_linear_filter, true, true, false);
|
2017-07-14 19:11:27 +00:00
|
|
|
SETTING_BOOL("menu_horizontal_animation", &settings->bools.menu_horizontal_animation, true, true, false);
|
2019-07-19 11:20:13 +00:00
|
|
|
SETTING_BOOL("dpi_override_enable", &settings->bools.menu_dpi_override_enable, true, DEFAULT_MENU_DPI_OVERRIDE_ENABLE, false);
|
2017-04-28 11:43:47 +00:00
|
|
|
SETTING_BOOL("menu_pause_libretro", &settings->bools.menu_pause_libretro, true, true, false);
|
2019-07-05 12:25:13 +00:00
|
|
|
SETTING_BOOL("menu_savestate_resume", &settings->bools.menu_savestate_resume, true, menu_savestate_resume, false);
|
2019-06-02 15:18:52 +00:00
|
|
|
SETTING_BOOL("menu_mouse_enable", &settings->bools.menu_mouse_enable, true, DEFAULT_MOUSE_ENABLE, false);
|
2019-05-31 13:59:49 +00:00
|
|
|
SETTING_BOOL("menu_pointer_enable", &settings->bools.menu_pointer_enable, true, DEFAULT_POINTER_ENABLE, false);
|
2017-04-28 11:43:47 +00:00
|
|
|
SETTING_BOOL("menu_timedate_enable", &settings->bools.menu_timedate_enable, true, true, false);
|
|
|
|
SETTING_BOOL("menu_battery_level_enable", &settings->bools.menu_battery_level_enable, true, true, false);
|
|
|
|
SETTING_BOOL("menu_core_enable", &settings->bools.menu_core_enable, true, true, false);
|
2019-02-11 14:38:10 +00:00
|
|
|
SETTING_BOOL("menu_show_sublabels", &settings->bools.menu_show_sublabels, true, menu_show_sublabels, false);
|
2017-04-28 11:43:47 +00:00
|
|
|
SETTING_BOOL("menu_dynamic_wallpaper_enable", &settings->bools.menu_dynamic_wallpaper_enable, true, false, false);
|
2019-08-21 16:52:08 +00:00
|
|
|
SETTING_BOOL("menu_ticker_smooth", &settings->bools.menu_ticker_smooth, true, DEFAULT_MENU_TICKER_SMOOTH, false);
|
2019-08-23 01:06:38 +00:00
|
|
|
SETTING_BOOL("settings_show_drivers", &settings->bools.settings_show_drivers, true, DEFAULT_SETTINGS_SHOW_DRIVERS, false);
|
|
|
|
SETTING_BOOL("settings_show_video", &settings->bools.settings_show_video, true, DEFAULT_SETTINGS_SHOW_VIDEO, false);
|
|
|
|
SETTING_BOOL("settings_show_audio", &settings->bools.settings_show_audio, true, DEFAULT_SETTINGS_SHOW_AUDIO, false);
|
2019-08-20 22:27:40 +00:00
|
|
|
SETTING_BOOL("settings_show_input", &settings->bools.settings_show_input, true, DEFAULT_SETTINGS_SHOW_INPUT, false);
|
2019-08-23 01:06:38 +00:00
|
|
|
SETTING_BOOL("settings_show_latency", &settings->bools.settings_show_latency, true, DEFAULT_SETTINGS_SHOW_LATENCY, false);
|
|
|
|
SETTING_BOOL("settings_show_core", &settings->bools.settings_show_core, true, DEFAULT_SETTINGS_SHOW_CORE, false);
|
|
|
|
SETTING_BOOL("settings_show_configuration", &settings->bools.settings_show_configuration, true, DEFAULT_SETTINGS_SHOW_CONFIGURATION, false);
|
|
|
|
SETTING_BOOL("settings_show_saving", &settings->bools.settings_show_saving, true, DEFAULT_SETTINGS_SHOW_SAVING, false);
|
|
|
|
SETTING_BOOL("settings_show_logging", &settings->bools.settings_show_logging, true, DEFAULT_SETTINGS_SHOW_LOGGING, false);
|
|
|
|
SETTING_BOOL("settings_show_frame_throttle", &settings->bools.settings_show_frame_throttle, true, DEFAULT_SETTINGS_SHOW_FRAME_THROTTLE, false);
|
|
|
|
SETTING_BOOL("settings_show_recording", &settings->bools.settings_show_recording, true, DEFAULT_SETTINGS_SHOW_RECORDING, false);
|
|
|
|
SETTING_BOOL("settings_show_onscreen_display", &settings->bools.settings_show_onscreen_display, true, DEFAULT_SETTINGS_SHOW_ONSCREEN_DISPLAY, false);
|
|
|
|
SETTING_BOOL("settings_show_user_interface", &settings->bools.settings_show_user_interface, true, DEFAULT_SETTINGS_SHOW_USER_INTERFACE, false);
|
|
|
|
SETTING_BOOL("settings_show_ai_service", &settings->bools.settings_show_ai_service, true, DEFAULT_SETTINGS_SHOW_AI_SERVICE, false);
|
|
|
|
SETTING_BOOL("settings_show_power_management", &settings->bools.settings_show_power_management, true, DEFAULT_SETTINGS_SHOW_POWER_MANAGEMENT, false);
|
|
|
|
SETTING_BOOL("settings_show_achievements", &settings->bools.settings_show_achievements, true, DEFAULT_SETTINGS_SHOW_ACHIEVEMENTS, false);
|
|
|
|
SETTING_BOOL("settings_show_network", &settings->bools.settings_show_network, true, DEFAULT_SETTINGS_SHOW_NETWORK, false);
|
|
|
|
SETTING_BOOL("settings_show_playlists", &settings->bools.settings_show_playlists, true, DEFAULT_SETTINGS_SHOW_PLAYLISTS, false);
|
|
|
|
SETTING_BOOL("settings_show_user", &settings->bools.settings_show_user, true, DEFAULT_SETTINGS_SHOW_USER, false);
|
|
|
|
SETTING_BOOL("settings_show_directory", &settings->bools.settings_show_directory, true, DEFAULT_SETTINGS_SHOW_DIRECTORY, false);
|
2019-08-20 16:08:44 +00:00
|
|
|
SETTING_BOOL("quick_menu_show_resume_content", &settings->bools.quick_menu_show_resume_content, true, DEFAULT_QUICK_MENU_SHOW_RESUME_CONTENT, false);
|
|
|
|
SETTING_BOOL("quick_menu_show_restart_content", &settings->bools.quick_menu_show_restart_content, true, DEFAULT_QUICK_MENU_SHOW_RESTART_CONTENT, false);
|
|
|
|
SETTING_BOOL("quick_menu_show_close_content", &settings->bools.quick_menu_show_close_content, true, DEFAULT_QUICK_MENU_SHOW_CLOSE_CONTENT, false);
|
2018-09-17 07:06:24 +00:00
|
|
|
SETTING_BOOL("quick_menu_show_recording", &settings->bools.quick_menu_show_recording, true, quick_menu_show_recording, false);
|
|
|
|
SETTING_BOOL("quick_menu_show_streaming", &settings->bools.quick_menu_show_streaming, true, quick_menu_show_streaming, false);
|
|
|
|
SETTING_BOOL("quick_menu_show_save_load_state", &settings->bools.quick_menu_show_save_load_state, true, quick_menu_show_save_load_state, false);
|
2017-10-09 07:30:53 +00:00
|
|
|
SETTING_BOOL("quick_menu_show_take_screenshot", &settings->bools.quick_menu_show_take_screenshot, true, quick_menu_show_take_screenshot, false);
|
|
|
|
SETTING_BOOL("quick_menu_show_save_load_state", &settings->bools.quick_menu_show_save_load_state, true, quick_menu_show_save_load_state, false);
|
|
|
|
SETTING_BOOL("quick_menu_show_undo_save_load_state", &settings->bools.quick_menu_show_undo_save_load_state, true, quick_menu_show_undo_save_load_state, false);
|
2017-10-09 07:46:42 +00:00
|
|
|
SETTING_BOOL("quick_menu_show_add_to_favorites", &settings->bools.quick_menu_show_add_to_favorites, true, quick_menu_show_add_to_favorites, false);
|
2018-12-14 01:59:07 +00:00
|
|
|
SETTING_BOOL("quick_menu_show_start_recording", &settings->bools.quick_menu_show_start_recording, true, quick_menu_show_start_recording, false);
|
|
|
|
SETTING_BOOL("quick_menu_show_start_streaming", &settings->bools.quick_menu_show_start_streaming, true, quick_menu_show_start_streaming, false);
|
2019-07-03 15:29:51 +00:00
|
|
|
SETTING_BOOL("quick_menu_show_set_core_association", &settings->bools.quick_menu_show_set_core_association, true, quick_menu_show_set_core_association, false);
|
2018-12-10 01:42:15 +00:00
|
|
|
SETTING_BOOL("quick_menu_show_reset_core_association", &settings->bools.quick_menu_show_reset_core_association, true, quick_menu_show_reset_core_association, false);
|
2017-10-09 07:56:27 +00:00
|
|
|
SETTING_BOOL("quick_menu_show_options", &settings->bools.quick_menu_show_options, true, quick_menu_show_options, false);
|
2017-10-09 08:05:32 +00:00
|
|
|
SETTING_BOOL("quick_menu_show_controls", &settings->bools.quick_menu_show_controls, true, quick_menu_show_controls, false);
|
2017-10-09 08:17:15 +00:00
|
|
|
SETTING_BOOL("quick_menu_show_cheats", &settings->bools.quick_menu_show_cheats, true, quick_menu_show_cheats, false);
|
2017-10-09 08:30:25 +00:00
|
|
|
SETTING_BOOL("quick_menu_show_shaders", &settings->bools.quick_menu_show_shaders, true, quick_menu_show_shaders, false);
|
2017-10-09 08:44:37 +00:00
|
|
|
SETTING_BOOL("quick_menu_show_save_core_overrides", &settings->bools.quick_menu_show_save_core_overrides, true, quick_menu_show_save_core_overrides, false);
|
2017-10-09 08:53:58 +00:00
|
|
|
SETTING_BOOL("quick_menu_show_save_game_overrides", &settings->bools.quick_menu_show_save_game_overrides, true, quick_menu_show_save_game_overrides, false);
|
2018-05-14 03:33:06 +00:00
|
|
|
SETTING_BOOL("quick_menu_show_save_content_dir_overrides", &settings->bools.quick_menu_show_save_content_dir_overrides, true, quick_menu_show_save_content_dir_overrides, false);
|
2017-10-09 09:16:04 +00:00
|
|
|
SETTING_BOOL("quick_menu_show_information", &settings->bools.quick_menu_show_information, true, quick_menu_show_information, false);
|
2019-05-16 13:32:25 +00:00
|
|
|
#ifdef HAVE_NETWORKING
|
|
|
|
SETTING_BOOL("quick_menu_show_download_thumbnails", &settings->bools.quick_menu_show_download_thumbnails, true, quick_menu_show_download_thumbnails, false);
|
|
|
|
#endif
|
2017-10-11 09:30:53 +00:00
|
|
|
SETTING_BOOL("kiosk_mode_enable", &settings->bools.kiosk_mode_enable, true, kiosk_mode_enable, false);
|
2019-06-14 09:13:02 +00:00
|
|
|
SETTING_BOOL("menu_use_preferred_system_color_theme", &settings->bools.menu_use_preferred_system_color_theme, true, DEFAULT_MENU_USE_PREFERRED_SYSTEM_COLOR_THEME, false);
|
2018-01-01 18:38:16 +00:00
|
|
|
SETTING_BOOL("content_show_settings", &settings->bools.menu_content_show_settings, true, content_show_settings, false);
|
|
|
|
SETTING_BOOL("content_show_favorites", &settings->bools.menu_content_show_favorites, true, content_show_favorites, false);
|
2016-08-29 17:10:00 +00:00
|
|
|
#ifdef HAVE_IMAGEVIEWER
|
2018-01-01 18:38:16 +00:00
|
|
|
SETTING_BOOL("content_show_images", &settings->bools.menu_content_show_images, true, content_show_images, false);
|
|
|
|
#endif
|
|
|
|
SETTING_BOOL("content_show_music", &settings->bools.menu_content_show_music, true, content_show_music, false);
|
2018-06-20 02:50:58 +00:00
|
|
|
#if defined(HAVE_FFMPEG) || defined(HAVE_MPV)
|
2018-01-01 18:38:16 +00:00
|
|
|
SETTING_BOOL("content_show_video", &settings->bools.menu_content_show_video, true, content_show_video, false);
|
|
|
|
#endif
|
|
|
|
#ifdef HAVE_NETWORKING
|
|
|
|
SETTING_BOOL("content_show_netplay", &settings->bools.menu_content_show_netplay, true, content_show_netplay, false);
|
|
|
|
#endif
|
|
|
|
SETTING_BOOL("content_show_history", &settings->bools.menu_content_show_history, true, content_show_history, false);
|
|
|
|
#ifdef HAVE_LIBRETRODB
|
|
|
|
SETTING_BOOL("content_show_add", &settings->bools.menu_content_show_add, true, content_show_add, false);
|
2016-08-29 17:10:00 +00:00
|
|
|
#endif
|
2018-04-17 15:53:24 +00:00
|
|
|
SETTING_BOOL("content_show_playlists", &settings->bools.menu_content_show_playlists, true, content_show_playlists, false);
|
2017-10-05 07:14:05 +00:00
|
|
|
SETTING_BOOL("menu_show_load_core", &settings->bools.menu_show_load_core, true, menu_show_load_core, false);
|
2017-10-05 07:26:25 +00:00
|
|
|
SETTING_BOOL("menu_show_load_content", &settings->bools.menu_show_load_content, true, menu_show_load_content, false);
|
2019-07-21 10:16:16 +00:00
|
|
|
#ifdef HAVE_CDROM
|
|
|
|
SETTING_BOOL("menu_show_load_disc", &settings->bools.menu_show_load_disc, true, menu_show_load_disc, false);
|
|
|
|
SETTING_BOOL("menu_show_dump_disc", &settings->bools.menu_show_dump_disc, true, menu_show_dump_disc, false);
|
|
|
|
#endif
|
2017-10-05 12:30:15 +00:00
|
|
|
SETTING_BOOL("menu_show_information", &settings->bools.menu_show_information, true, menu_show_information, false);
|
2017-10-06 06:18:39 +00:00
|
|
|
SETTING_BOOL("menu_show_configurations", &settings->bools.menu_show_configurations, true, menu_show_configurations, false);
|
2018-04-24 15:46:49 +00:00
|
|
|
SETTING_BOOL("menu_show_latency", &settings->bools.menu_show_latency, true, true, false);
|
|
|
|
SETTING_BOOL("menu_show_rewind", &settings->bools.menu_show_rewind, true, true, false);
|
|
|
|
SETTING_BOOL("menu_show_overlays", &settings->bools.menu_show_overlays, true, true, false);
|
2019-04-16 16:41:06 +00:00
|
|
|
#ifdef HAVE_VIDEO_LAYOUT
|
|
|
|
SETTING_BOOL("menu_show_video_layout", &settings->bools.menu_show_video_layout, true, true, false);
|
|
|
|
#endif
|
2017-10-06 06:28:45 +00:00
|
|
|
SETTING_BOOL("menu_show_help", &settings->bools.menu_show_help, true, menu_show_help, false);
|
2017-10-06 07:27:42 +00:00
|
|
|
SETTING_BOOL("menu_show_quit_retroarch", &settings->bools.menu_show_quit_retroarch, true, menu_show_quit_retroarch, false);
|
2019-05-30 12:52:24 +00:00
|
|
|
SETTING_BOOL("menu_show_restart_retroarch", &settings->bools.menu_show_restart_retroarch, true, menu_show_restart_retroarch, false);
|
2017-10-06 07:40:41 +00:00
|
|
|
SETTING_BOOL("menu_show_reboot", &settings->bools.menu_show_reboot, true, menu_show_reboot, false);
|
2018-06-23 05:01:13 +00:00
|
|
|
SETTING_BOOL("menu_show_shutdown", &settings->bools.menu_show_shutdown, true, menu_show_shutdown, false);
|
2017-06-19 23:42:28 +00:00
|
|
|
SETTING_BOOL("menu_show_online_updater", &settings->bools.menu_show_online_updater, true, menu_show_online_updater, false);
|
2017-06-20 00:22:07 +00:00
|
|
|
SETTING_BOOL("menu_show_core_updater", &settings->bools.menu_show_core_updater, true, menu_show_core_updater, false);
|
2019-05-24 13:39:53 +00:00
|
|
|
SETTING_BOOL("menu_show_legacy_thumbnail_updater", &settings->bools.menu_show_legacy_thumbnail_updater, true, menu_show_legacy_thumbnail_updater, false);
|
2017-05-31 22:25:13 +00:00
|
|
|
SETTING_BOOL("filter_by_current_core", &settings->bools.filter_by_current_core, false, false /* TODO */, false);
|
2017-04-28 11:43:47 +00:00
|
|
|
SETTING_BOOL("rgui_show_start_screen", &settings->bools.menu_show_start_screen, false, false /* TODO */, false);
|
|
|
|
SETTING_BOOL("menu_navigation_wraparound_enable", &settings->bools.menu_navigation_wraparound_enable, true, true, false);
|
2017-07-14 19:11:27 +00:00
|
|
|
SETTING_BOOL("menu_navigation_browser_filter_supported_extensions_enable",
|
2017-04-28 11:43:47 +00:00
|
|
|
&settings->bools.menu_navigation_browser_filter_supported_extensions_enable, true, true, false);
|
2019-06-14 09:13:02 +00:00
|
|
|
SETTING_BOOL("menu_show_advanced_settings", &settings->bools.menu_show_advanced_settings, true, DEFAULT_SHOW_ADVANCED_SETTINGS, false);
|
2018-01-01 18:38:16 +00:00
|
|
|
#ifdef HAVE_MATERIALUI
|
2019-06-02 15:18:52 +00:00
|
|
|
SETTING_BOOL("materialui_icons_enable", &settings->bools.menu_materialui_icons_enable, true, DEFAULT_MATERIALUI_ICONS_ENABLE, false);
|
2018-01-01 18:38:16 +00:00
|
|
|
#endif
|
2018-04-24 14:01:51 +00:00
|
|
|
#ifdef HAVE_RGUI
|
2019-02-25 12:24:59 +00:00
|
|
|
SETTING_BOOL("rgui_background_filler_thickness_enable", &settings->bools.menu_rgui_background_filler_thickness_enable, true, true, false);
|
2018-04-24 14:45:06 +00:00
|
|
|
SETTING_BOOL("rgui_border_filler_thickness_enable", &settings->bools.menu_rgui_border_filler_thickness_enable, true, true, false);
|
2019-02-25 12:24:59 +00:00
|
|
|
SETTING_BOOL("rgui_border_filler_enable", &settings->bools.menu_rgui_border_filler_enable, true, true, false);
|
2019-04-01 12:52:10 +00:00
|
|
|
SETTING_BOOL("menu_rgui_shadows", &settings->bools.menu_rgui_shadows, true, rgui_shadows, false);
|
2019-02-25 12:24:59 +00:00
|
|
|
SETTING_BOOL("menu_rgui_full_width_layout", &settings->bools.menu_rgui_full_width_layout, true, rgui_full_width_layout, false);
|
2019-03-27 16:29:23 +00:00
|
|
|
SETTING_BOOL("rgui_inline_thumbnails", &settings->bools.menu_rgui_inline_thumbnails, true, rgui_inline_thumbnails, false);
|
|
|
|
SETTING_BOOL("rgui_swap_thumbnails", &settings->bools.menu_rgui_swap_thumbnails, true, rgui_swap_thumbnails, false);
|
2019-04-11 13:29:31 +00:00
|
|
|
SETTING_BOOL("rgui_extended_ascii", &settings->bools.menu_rgui_extended_ascii, true, rgui_extended_ascii, false);
|
2018-04-24 14:01:51 +00:00
|
|
|
#endif
|
2018-01-01 18:38:16 +00:00
|
|
|
#ifdef HAVE_XMB
|
2019-06-14 09:13:02 +00:00
|
|
|
SETTING_BOOL("xmb_shadows_enable", &settings->bools.menu_xmb_shadows_enable, true, DEFAULT_XMB_SHADOWS_ENABLE, false);
|
2018-04-04 22:52:46 +00:00
|
|
|
SETTING_BOOL("xmb_vertical_thumbnails", &settings->bools.menu_xmb_vertical_thumbnails, true, xmb_vertical_thumbnails, false);
|
2018-01-01 18:38:16 +00:00
|
|
|
#endif
|
2016-08-29 17:10:00 +00:00
|
|
|
#endif
|
|
|
|
#ifdef HAVE_CHEEVOS
|
2019-06-02 15:18:52 +00:00
|
|
|
SETTING_BOOL("cheevos_enable", &settings->bools.cheevos_enable, true, DEFAULT_CHEEVOS_ENABLE, false);
|
2017-04-28 11:43:47 +00:00
|
|
|
SETTING_BOOL("cheevos_test_unofficial", &settings->bools.cheevos_test_unofficial, true, false, false);
|
|
|
|
SETTING_BOOL("cheevos_hardcore_mode_enable", &settings->bools.cheevos_hardcore_mode_enable, true, false, false);
|
2017-10-31 05:58:35 +00:00
|
|
|
SETTING_BOOL("cheevos_leaderboards_enable", &settings->bools.cheevos_leaderboards_enable, true, false, false);
|
2018-03-14 07:49:48 +00:00
|
|
|
SETTING_BOOL("cheevos_verbose_enable", &settings->bools.cheevos_verbose_enable, true, false, false);
|
|
|
|
SETTING_BOOL("cheevos_auto_screenshot", &settings->bools.cheevos_auto_screenshot, true, false, false);
|
2017-11-23 16:55:53 +00:00
|
|
|
#ifdef HAVE_XMB
|
|
|
|
SETTING_BOOL("cheevos_badges_enable", &settings->bools.cheevos_badges_enable, true, false, false);
|
|
|
|
#endif
|
2016-08-29 17:10:00 +00:00
|
|
|
#endif
|
|
|
|
#ifdef HAVE_OVERLAY
|
2017-04-28 11:43:47 +00:00
|
|
|
SETTING_BOOL("input_overlay_enable", &settings->bools.input_overlay_enable, true, config_overlay_enable_default(), false);
|
|
|
|
SETTING_BOOL("input_overlay_enable_autopreferred", &settings->bools.input_overlay_enable_autopreferred, true, true, false);
|
2017-08-08 11:50:39 +00:00
|
|
|
SETTING_BOOL("input_overlay_show_physical_inputs", &settings->bools.input_overlay_show_physical_inputs, true, false, false);
|
2019-06-02 19:02:59 +00:00
|
|
|
SETTING_BOOL("input_overlay_hide_in_menu", &settings->bools.input_overlay_hide_in_menu, true, DEFAULT_OVERLAY_HIDE_IN_MENU, false);
|
2019-06-02 21:48:01 +00:00
|
|
|
SETTING_BOOL("input_overlay_show_mouse_cursor", &settings->bools.input_overlay_show_mouse_cursor, true, DEFAULT_OVERLAY_SHOW_MOUSE_CURSOR, false);
|
2016-08-29 17:10:00 +00:00
|
|
|
#endif
|
2019-04-16 16:41:06 +00:00
|
|
|
#ifdef HAVE_VIDEO_LAYOUT
|
|
|
|
SETTING_BOOL("video_layout_enable", &settings->bools.video_layout_enable, true, true, false);
|
|
|
|
#endif
|
2016-08-29 17:10:00 +00:00
|
|
|
#ifdef HAVE_COMMAND
|
2017-04-28 11:43:47 +00:00
|
|
|
SETTING_BOOL("network_cmd_enable", &settings->bools.network_cmd_enable, true, network_cmd_enable, false);
|
|
|
|
SETTING_BOOL("stdin_cmd_enable", &settings->bools.stdin_cmd_enable, true, stdin_cmd_enable, false);
|
2016-08-29 17:10:00 +00:00
|
|
|
#endif
|
|
|
|
#ifdef HAVE_NETWORKGAMEPAD
|
2017-04-28 11:43:47 +00:00
|
|
|
SETTING_BOOL("network_remote_enable", &settings->bools.network_remote_enable, false, false /* TODO */, false);
|
2016-08-29 17:10:00 +00:00
|
|
|
#endif
|
2016-09-29 19:07:10 +00:00
|
|
|
#ifdef HAVE_NETWORKING
|
2017-04-28 11:43:47 +00:00
|
|
|
SETTING_BOOL("netplay_nat_traversal", &settings->bools.netplay_nat_traversal, true, true, false);
|
|
|
|
#endif
|
2019-06-02 19:02:59 +00:00
|
|
|
SETTING_BOOL("block_sram_overwrite", &settings->bools.block_sram_overwrite, true, DEFAULT_BLOCK_SRAM_OVERWRITE, false);
|
2017-04-28 11:43:47 +00:00
|
|
|
SETTING_BOOL("savestate_auto_index", &settings->bools.savestate_auto_index, true, savestate_auto_index, false);
|
|
|
|
SETTING_BOOL("savestate_auto_save", &settings->bools.savestate_auto_save, true, savestate_auto_save, false);
|
|
|
|
SETTING_BOOL("savestate_auto_load", &settings->bools.savestate_auto_load, true, savestate_auto_load, false);
|
|
|
|
SETTING_BOOL("savestate_thumbnail_enable", &settings->bools.savestate_thumbnail_enable, true, savestate_thumbnail_enable, false);
|
2019-06-14 09:13:02 +00:00
|
|
|
SETTING_BOOL("history_list_enable", &settings->bools.history_list_enable, true, DEFAULT_HISTORY_LIST_ENABLE, false);
|
|
|
|
SETTING_BOOL("playlist_entry_rename", &settings->bools.playlist_entry_rename, true, DEFAULT_PLAYLIST_ENTRY_RENAME, false);
|
2017-04-28 11:43:47 +00:00
|
|
|
SETTING_BOOL("game_specific_options", &settings->bools.game_specific_options, true, default_game_specific_options, false);
|
|
|
|
SETTING_BOOL("auto_overrides_enable", &settings->bools.auto_overrides_enable, true, default_auto_overrides_enable, false);
|
|
|
|
SETTING_BOOL("auto_remaps_enable", &settings->bools.auto_remaps_enable, true, default_auto_remaps_enable, false);
|
2019-08-02 14:44:51 +00:00
|
|
|
SETTING_BOOL("global_core_options", &settings->bools.global_core_options, true, default_global_core_options, false);
|
2017-04-28 11:43:47 +00:00
|
|
|
SETTING_BOOL("auto_shaders_enable", &settings->bools.auto_shaders_enable, true, default_auto_shaders_enable, false);
|
2019-05-06 22:58:17 +00:00
|
|
|
SETTING_BOOL("scan_without_core_match", &settings->bools.scan_without_core_match, true, scan_without_core_match, false);
|
2017-04-28 11:43:47 +00:00
|
|
|
SETTING_BOOL("sort_savefiles_enable", &settings->bools.sort_savefiles_enable, true, default_sort_savefiles_enable, false);
|
|
|
|
SETTING_BOOL("sort_savestates_enable", &settings->bools.sort_savestates_enable, true, default_sort_savestates_enable, false);
|
2019-06-02 19:02:59 +00:00
|
|
|
SETTING_BOOL("config_save_on_exit", &settings->bools.config_save_on_exit, true, DEFAULT_CONFIG_SAVE_ON_EXIT, false);
|
|
|
|
SETTING_BOOL("show_hidden_files", &settings->bools.show_hidden_files, true, DEFAULT_SHOW_HIDDEN_FILES, false);
|
2017-04-28 11:43:47 +00:00
|
|
|
SETTING_BOOL("input_autodetect_enable", &settings->bools.input_autodetect_enable, true, input_autodetect_enable, false);
|
2019-06-02 15:18:52 +00:00
|
|
|
SETTING_BOOL("audio_rate_control", &settings->bools.audio_rate_control, true, DEFAULT_RATE_CONTROL, false);
|
2017-04-13 08:16:19 +00:00
|
|
|
#ifdef HAVE_WASAPI
|
2017-04-29 02:40:24 +00:00
|
|
|
SETTING_BOOL("audio_wasapi_exclusive_mode", &settings->bools.audio_wasapi_exclusive_mode, true, wasapi_exclusive_mode, false);
|
|
|
|
SETTING_BOOL("audio_wasapi_float_format", &settings->bools.audio_wasapi_float_format, true, wasapi_float_format, false);
|
2017-04-13 08:16:19 +00:00
|
|
|
#endif
|
2016-08-29 17:10:00 +00:00
|
|
|
|
2017-08-05 17:31:58 +00:00
|
|
|
SETTING_BOOL("savestates_in_content_dir", &settings->bools.savestates_in_content_dir, true, default_savestates_in_content_dir, false);
|
|
|
|
SETTING_BOOL("savefiles_in_content_dir", &settings->bools.savefiles_in_content_dir, true, default_savefiles_in_content_dir, false);
|
|
|
|
SETTING_BOOL("systemfiles_in_content_dir", &settings->bools.systemfiles_in_content_dir, true, default_systemfiles_in_content_dir, false);
|
|
|
|
SETTING_BOOL("screenshots_in_content_dir", &settings->bools.screenshots_in_content_dir, true, default_screenshots_in_content_dir, false);
|
|
|
|
|
2017-10-10 18:53:32 +00:00
|
|
|
SETTING_BOOL("video_msg_bgcolor_enable", &settings->bools.video_msg_bgcolor_enable, true, message_bgcolor_enable, false);
|
2019-06-02 16:09:33 +00:00
|
|
|
SETTING_BOOL("video_window_show_decorations", &settings->bools.video_window_show_decorations, true, DEFAULT_WINDOW_DECORATIONS, false);
|
2018-11-25 08:02:32 +00:00
|
|
|
SETTING_BOOL("video_window_save_positions", &settings->bools.video_window_save_positions, true, false, false);
|
2017-10-10 18:53:32 +00:00
|
|
|
|
2018-06-19 06:50:33 +00:00
|
|
|
SETTING_BOOL("sustained_performance_mode", &settings->bools.sustained_performance_mode, true, sustained_performance_mode, false);
|
|
|
|
|
2018-11-14 16:38:52 +00:00
|
|
|
#ifdef _3DS
|
|
|
|
SETTING_BOOL("video_3ds_lcd_bottom", &settings->bools.video_3ds_lcd_bottom, true, video_3ds_lcd_bottom, false);
|
|
|
|
#endif
|
|
|
|
|
2019-01-09 22:13:13 +00:00
|
|
|
SETTING_BOOL("playlist_use_old_format", &settings->bools.playlist_use_old_format, true, playlist_use_old_format, false);
|
2019-08-23 15:10:56 +00:00
|
|
|
SETTING_BOOL("content_runtime_log", &settings->bools.content_runtime_log, true, DEFAULT_CONTENT_RUNTIME_LOG, false);
|
2019-03-07 12:28:21 +00:00
|
|
|
SETTING_BOOL("content_runtime_log_aggregate", &settings->bools.content_runtime_log_aggregate, true, content_runtime_log_aggregate, false);
|
2019-08-23 15:33:59 +00:00
|
|
|
SETTING_BOOL("playlist_show_sublabels", &settings->bools.playlist_show_sublabels, true, DEFAULT_PLAYLIST_SHOW_SUBLABELS, false);
|
2019-02-18 15:09:19 +00:00
|
|
|
SETTING_BOOL("playlist_sort_alphabetical", &settings->bools.playlist_sort_alphabetical, true, playlist_sort_alphabetical, false);
|
2019-05-02 08:56:04 +00:00
|
|
|
SETTING_BOOL("playlist_fuzzy_archive_match", &settings->bools.playlist_fuzzy_archive_match, true, playlist_fuzzy_archive_match, false);
|
2019-02-18 15:09:19 +00:00
|
|
|
|
2019-07-19 11:30:11 +00:00
|
|
|
SETTING_BOOL("quit_press_twice", &settings->bools.quit_press_twice, true, DEFAULT_QUIT_PRESS_TWICE, false);
|
2019-03-11 01:36:52 +00:00
|
|
|
SETTING_BOOL("vibrate_on_keypress", &settings->bools.vibrate_on_keypress, true, vibrate_on_keypress, false);
|
2019-03-12 17:07:16 +00:00
|
|
|
SETTING_BOOL("enable_device_vibration", &settings->bools.enable_device_vibration, true, enable_device_vibration, false);
|
2019-02-25 18:12:50 +00:00
|
|
|
|
2019-02-27 14:21:26 +00:00
|
|
|
#ifdef HAVE_OZONE
|
2019-06-14 09:13:02 +00:00
|
|
|
SETTING_BOOL("ozone_collapse_sidebar", &settings->bools.ozone_collapse_sidebar, true, DEFAULT_OZONE_COLLAPSE_SIDEBAR, false);
|
2019-08-09 16:01:47 +00:00
|
|
|
SETTING_BOOL("ozone_truncate_playlist_name", &settings->bools.ozone_truncate_playlist_name, true, DEFAULT_OZONE_TRUNCATE_PLAYLIST_NAME, false);
|
2019-09-23 14:33:20 +00:00
|
|
|
SETTING_BOOL("ozone_scroll_content_metadata",&settings->bools.ozone_scroll_content_metadata, true, DEFAULT_OZONE_SCROLL_CONTENT_METADATA, false);
|
2019-02-27 14:21:26 +00:00
|
|
|
#endif
|
2019-07-19 11:30:11 +00:00
|
|
|
SETTING_BOOL("log_to_file", &settings->bools.log_to_file, true, DEFAULT_LOG_TO_FILE, false);
|
2019-05-17 16:19:13 +00:00
|
|
|
SETTING_OVERRIDE(RARCH_OVERRIDE_SETTING_LOG_TO_FILE);
|
2019-07-19 11:30:11 +00:00
|
|
|
SETTING_BOOL("log_to_file_timestamp", &settings->bools.log_to_file_timestamp, true, DEFAULT_LOG_TO_FILE_TIMESTAMP, false);
|
2019-08-22 05:07:07 +00:00
|
|
|
SETTING_BOOL("ai_service_enable", &settings->bools.ai_service_enable, DEFAULT_AI_SERVICE_ENABLE, false, false);
|
2019-02-27 14:21:26 +00:00
|
|
|
|
2016-12-26 03:14:09 +00:00
|
|
|
*size = count;
|
|
|
|
|
|
|
|
return tmp;
|
2016-08-29 17:10:00 +00:00
|
|
|
}
|
|
|
|
|
2016-12-26 03:14:09 +00:00
|
|
|
static struct config_float_setting *populate_settings_float(settings_t *settings, int *size)
|
2016-08-29 17:10:00 +00:00
|
|
|
{
|
|
|
|
unsigned count = 0;
|
2018-08-18 14:15:55 +00:00
|
|
|
struct config_float_setting *tmp = (struct config_float_setting*)calloc(1, (*size + 1) * sizeof(struct config_float_setting));
|
2016-08-29 17:10:00 +00:00
|
|
|
|
2019-01-10 21:24:43 +00:00
|
|
|
if (!tmp)
|
|
|
|
return NULL;
|
|
|
|
|
2019-06-02 15:18:52 +00:00
|
|
|
SETTING_FLOAT("video_aspect_ratio", &settings->floats.video_aspect_ratio, true, DEFAULT_ASPECT_RATIO, false);
|
2017-04-28 12:57:55 +00:00
|
|
|
SETTING_FLOAT("video_scale", &settings->floats.video_scale, false, 0.0f, false);
|
2019-07-19 11:14:29 +00:00
|
|
|
SETTING_FLOAT("crt_video_refresh_rate", &settings->floats.crt_video_refresh_rate, true, DEFAULT_CRT_REFRESH_RATE, false);
|
|
|
|
SETTING_FLOAT("video_refresh_rate", &settings->floats.video_refresh_rate, true, DEFAULT_REFRESH_RATE, false);
|
2019-06-02 15:18:52 +00:00
|
|
|
SETTING_FLOAT("audio_rate_control_delta", audio_get_float_ptr(AUDIO_ACTION_RATE_CONTROL_DELTA), true, DEFAULT_RATE_CONTROL_DELTA, false);
|
|
|
|
SETTING_FLOAT("audio_max_timing_skew", &settings->floats.audio_max_timing_skew, true, DEFAULT_MAX_TIMING_SKEW, false);
|
|
|
|
SETTING_FLOAT("audio_volume", &settings->floats.audio_volume, true, DEFAULT_AUDIO_VOLUME, false);
|
2019-07-11 09:51:06 +00:00
|
|
|
#ifdef HAVE_AUDIOMIXER
|
2019-06-02 15:18:52 +00:00
|
|
|
SETTING_FLOAT("audio_mixer_volume", &settings->floats.audio_mixer_volume, true, DEFAULT_AUDIO_MIXER_VOLUME, false);
|
2019-07-11 09:51:06 +00:00
|
|
|
#endif
|
2016-08-29 17:10:00 +00:00
|
|
|
#ifdef HAVE_OVERLAY
|
2019-06-02 19:02:59 +00:00
|
|
|
SETTING_FLOAT("input_overlay_opacity", &settings->floats.input_overlay_opacity, true, DEFAULT_INPUT_OVERLAY_OPACITY, false);
|
2017-04-28 12:57:55 +00:00
|
|
|
SETTING_FLOAT("input_overlay_scale", &settings->floats.input_overlay_scale, true, 1.0f, false);
|
2016-08-29 17:10:00 +00:00
|
|
|
#endif
|
|
|
|
#ifdef HAVE_MENU
|
2017-04-28 12:57:55 +00:00
|
|
|
SETTING_FLOAT("menu_wallpaper_opacity", &settings->floats.menu_wallpaper_opacity, true, menu_wallpaper_opacity, false);
|
2017-09-29 23:41:09 +00:00
|
|
|
SETTING_FLOAT("menu_framebuffer_opacity", &settings->floats.menu_framebuffer_opacity, true, menu_framebuffer_opacity, false);
|
2017-04-28 12:57:55 +00:00
|
|
|
SETTING_FLOAT("menu_footer_opacity", &settings->floats.menu_footer_opacity, true, menu_footer_opacity, false);
|
|
|
|
SETTING_FLOAT("menu_header_opacity", &settings->floats.menu_header_opacity, true, menu_header_opacity, false);
|
2019-02-14 17:26:46 +00:00
|
|
|
SETTING_FLOAT("menu_ticker_speed", &settings->floats.menu_ticker_speed, true, menu_ticker_speed, false);
|
2019-08-23 11:22:30 +00:00
|
|
|
SETTING_FLOAT("rgui_particle_effect_speed", &settings->floats.menu_rgui_particle_effect_speed, true, DEFAULT_RGUI_PARTICLE_EFFECT_SPEED, false);
|
2016-08-29 17:10:00 +00:00
|
|
|
#endif
|
2017-04-28 12:57:55 +00:00
|
|
|
SETTING_FLOAT("video_message_pos_x", &settings->floats.video_msg_pos_x, true, message_pos_offset_x, false);
|
|
|
|
SETTING_FLOAT("video_message_pos_y", &settings->floats.video_msg_pos_y, true, message_pos_offset_y, false);
|
2019-06-02 15:18:52 +00:00
|
|
|
SETTING_FLOAT("video_font_size", &settings->floats.video_font_size, true, DEFAULT_FONT_SIZE, false);
|
|
|
|
SETTING_FLOAT("fastforward_ratio", &settings->floats.fastforward_ratio, true, DEFAULT_FASTFORWARD_RATIO, false);
|
|
|
|
SETTING_FLOAT("slowmotion_ratio", &settings->floats.slowmotion_ratio, true, DEFAULT_SLOWMOTION_RATIO, false);
|
2017-05-10 05:07:06 +00:00
|
|
|
SETTING_FLOAT("input_axis_threshold", input_driver_get_float(INPUT_ACTION_AXIS_THRESHOLD), true, axis_threshold, false);
|
2019-03-26 03:22:19 +00:00
|
|
|
SETTING_FLOAT("input_analog_deadzone", &settings->floats.input_analog_deadzone, true, analog_deadzone, false);
|
|
|
|
SETTING_FLOAT("input_analog_sensitivity", &settings->floats.input_analog_sensitivity, true, analog_sensitivity, false);
|
2017-10-10 18:53:32 +00:00
|
|
|
SETTING_FLOAT("video_msg_bgcolor_opacity", &settings->floats.video_msg_bgcolor_opacity, true, message_bgcolor_opacity, false);
|
2016-08-29 17:10:00 +00:00
|
|
|
|
2016-12-26 03:14:09 +00:00
|
|
|
*size = count;
|
|
|
|
|
|
|
|
return tmp;
|
2016-08-29 17:10:00 +00:00
|
|
|
}
|
|
|
|
|
2017-04-28 17:55:09 +00:00
|
|
|
static struct config_uint_setting *populate_settings_uint(settings_t *settings, int *size)
|
2016-08-29 17:10:00 +00:00
|
|
|
{
|
|
|
|
unsigned count = 0;
|
2019-02-06 20:25:22 +00:00
|
|
|
struct config_uint_setting *tmp = (struct config_uint_setting*)calloc(1, (*size + 1) * sizeof(struct config_uint_setting));
|
2017-04-28 17:55:09 +00:00
|
|
|
|
2019-01-10 21:24:43 +00:00
|
|
|
if (!tmp)
|
|
|
|
return NULL;
|
|
|
|
|
2018-09-26 22:58:51 +00:00
|
|
|
#ifdef HAVE_NETWORKING
|
2018-09-26 21:34:45 +00:00
|
|
|
SETTING_UINT("streaming_mode", &settings->uints.streaming_mode, true, STREAMING_MODE_TWITCH, false);
|
2018-09-26 22:58:51 +00:00
|
|
|
#endif
|
2019-06-14 09:13:02 +00:00
|
|
|
SETTING_UINT("crt_switch_resolution", &settings->uints.crt_switch_resolution, true, DEFAULT_CRT_SWITCH_RESOLUTION, false);
|
2017-04-28 19:03:04 +00:00
|
|
|
SETTING_UINT("input_bind_timeout", &settings->uints.input_bind_timeout, true, input_bind_timeout, false);
|
2018-04-04 08:33:59 +00:00
|
|
|
SETTING_UINT("input_bind_hold", &settings->uints.input_bind_hold, true, input_bind_hold, false);
|
2017-04-28 19:03:04 +00:00
|
|
|
SETTING_UINT("input_turbo_period", &settings->uints.input_turbo_period, true, turbo_period, false);
|
|
|
|
SETTING_UINT("input_duty_cycle", &settings->uints.input_turbo_duty_cycle, true, turbo_duty_cycle, false);
|
2017-05-11 05:36:21 +00:00
|
|
|
SETTING_UINT("input_max_users", input_driver_get_uint(INPUT_ACTION_MAX_USERS), true, input_max_users, false);
|
2019-08-20 01:05:52 +00:00
|
|
|
SETTING_UINT("fps_update_interval", &settings->uints.fps_update_interval, true, DEFAULT_FPS_UPDATE_INTERVAL, false);
|
2017-04-28 19:03:04 +00:00
|
|
|
SETTING_UINT("input_menu_toggle_gamepad_combo", &settings->uints.input_menu_toggle_gamepad_combo, true, menu_toggle_gamepad_combo, false);
|
2019-09-14 22:46:02 +00:00
|
|
|
#ifdef GEKKO
|
|
|
|
SETTING_UINT("input_mouse_scale", &settings->uints.input_mouse_scale, true, DEFAULT_MOUSE_SCALE, false);
|
|
|
|
#endif
|
2017-04-28 19:03:04 +00:00
|
|
|
SETTING_UINT("audio_latency", &settings->uints.audio_latency, false, 0 /* TODO */, false);
|
2017-12-31 20:25:07 +00:00
|
|
|
SETTING_UINT("audio_resampler_quality", &settings->uints.audio_resampler_quality, true, audio_resampler_quality_level, false);
|
2017-04-28 19:03:04 +00:00
|
|
|
SETTING_UINT("audio_block_frames", &settings->uints.audio_block_frames, true, 0, false);
|
2019-02-08 01:17:00 +00:00
|
|
|
#ifdef ANDROID
|
|
|
|
SETTING_UINT("input_block_timeout", &settings->uints.input_block_timeout, true, 1, false);
|
|
|
|
#endif
|
2019-06-02 15:18:52 +00:00
|
|
|
SETTING_UINT("rewind_granularity", &settings->uints.rewind_granularity, true, DEFAULT_REWIND_GRANULARITY, false);
|
|
|
|
SETTING_UINT("rewind_buffer_size_step", &settings->uints.rewind_buffer_size_step, true, DEFAULT_REWIND_BUFFER_SIZE_STEP, false);
|
|
|
|
SETTING_UINT("autosave_interval", &settings->uints.autosave_interval, true, DEFAULT_AUTOSAVE_INTERVAL, false);
|
2019-08-19 23:18:26 +00:00
|
|
|
SETTING_UINT("frontend_log_level", &settings->uints.frontend_log_level, true, DEFAULT_FRONTEND_LOG_LEVEL, false);
|
2019-07-19 11:20:13 +00:00
|
|
|
SETTING_UINT("libretro_log_level", &settings->uints.libretro_log_level, true, DEFAULT_LIBRETRO_LOG_LEVEL, false);
|
2017-04-28 19:03:04 +00:00
|
|
|
SETTING_UINT("keyboard_gamepad_mapping_type",&settings->uints.input_keyboard_gamepad_mapping_type, true, 1, false);
|
|
|
|
SETTING_UINT("input_poll_type_behavior", &settings->uints.input_poll_type_behavior, true, 2, false);
|
2019-06-02 15:18:52 +00:00
|
|
|
SETTING_UINT("video_monitor_index", &settings->uints.video_monitor_index, true, DEFAULT_MONITOR_INDEX, false);
|
|
|
|
SETTING_UINT("video_fullscreen_x", &settings->uints.video_fullscreen_x, true, DEFAULT_FULLSCREEN_X, false);
|
|
|
|
SETTING_UINT("video_fullscreen_y", &settings->uints.video_fullscreen_y, true, DEFAULT_FULLSCREEN_Y, false);
|
2019-06-02 16:09:33 +00:00
|
|
|
SETTING_UINT("video_window_opacity", &settings->uints.video_window_opacity, true, DEFAULT_WINDOW_OPACITY, false);
|
2019-04-16 16:41:06 +00:00
|
|
|
#ifdef HAVE_VIDEO_LAYOUT
|
|
|
|
SETTING_UINT("video_layout_selected_view", &settings->uints.video_layout_selected_view, true, 0, false);
|
|
|
|
#endif
|
2019-08-25 16:56:16 +00:00
|
|
|
SETTING_UINT("video_shader_delay", &settings->uints.video_shader_delay, true, DEFAULT_SHADER_DELAY, false);
|
2016-08-29 17:10:00 +00:00
|
|
|
#ifdef HAVE_COMMAND
|
2017-04-28 19:03:04 +00:00
|
|
|
SETTING_UINT("network_cmd_port", &settings->uints.network_cmd_port, true, network_cmd_port, false);
|
2016-08-29 17:10:00 +00:00
|
|
|
#endif
|
|
|
|
#ifdef HAVE_NETWORKGAMEPAD
|
2017-04-28 19:03:04 +00:00
|
|
|
SETTING_UINT("network_remote_base_port", &settings->uints.network_remote_base_port, true, network_remote_base_port, false);
|
2016-08-29 17:10:00 +00:00
|
|
|
#endif
|
2016-12-25 03:13:30 +00:00
|
|
|
#ifdef GEKKO
|
2019-06-04 14:50:47 +00:00
|
|
|
SETTING_UINT("video_viwidth", &settings->uints.video_viwidth, true, DEFAULT_VIDEO_VI_WIDTH, false);
|
|
|
|
SETTING_UINT("video_overscan_correction_top", &settings->uints.video_overscan_correction_top, true, DEFAULT_VIDEO_OVERSCAN_CORRECTION_TOP, false);
|
|
|
|
SETTING_UINT("video_overscan_correction_bottom", &settings->uints.video_overscan_correction_bottom, true, DEFAULT_VIDEO_OVERSCAN_CORRECTION_BOTTOM, false);
|
2016-08-29 17:10:00 +00:00
|
|
|
#endif
|
|
|
|
#ifdef HAVE_MENU
|
2019-07-19 11:20:13 +00:00
|
|
|
SETTING_UINT("dpi_override_value", &settings->uints.menu_dpi_override_value, true, DEFAULT_MENU_DPI_OVERRIDE_VALUE, false);
|
2017-04-28 19:03:04 +00:00
|
|
|
SETTING_UINT("menu_thumbnails", &settings->uints.menu_thumbnails, true, menu_thumbnails_default, false);
|
2019-06-10 09:53:45 +00:00
|
|
|
SETTING_UINT("menu_left_thumbnails", &settings->uints.menu_left_thumbnails, true, menu_left_thumbnails_default, false);
|
2019-06-05 16:04:23 +00:00
|
|
|
SETTING_UINT("menu_thumbnail_upscale_threshold", &settings->uints.menu_thumbnail_upscale_threshold, true, menu_thumbnail_upscale_threshold, false);
|
2018-09-30 17:01:43 +00:00
|
|
|
SETTING_UINT("menu_timedate_style", &settings->uints.menu_timedate_style, true, menu_timedate_style, false);
|
2019-02-14 15:10:07 +00:00
|
|
|
SETTING_UINT("menu_ticker_type", &settings->uints.menu_ticker_type, true, menu_ticker_type, false);
|
2019-02-04 16:20:34 +00:00
|
|
|
#ifdef HAVE_RGUI
|
2019-06-14 09:13:02 +00:00
|
|
|
SETTING_UINT("rgui_menu_color_theme", &settings->uints.menu_rgui_color_theme, true, DEFAULT_RGUI_COLOR_THEME, false);
|
2019-01-23 16:44:20 +00:00
|
|
|
SETTING_UINT("rgui_thumbnail_downscaler", &settings->uints.menu_rgui_thumbnail_downscaler, true, rgui_thumbnail_downscaler, false);
|
2019-04-12 14:50:27 +00:00
|
|
|
SETTING_UINT("rgui_thumbnail_delay", &settings->uints.menu_rgui_thumbnail_delay, true, rgui_thumbnail_delay, false);
|
2019-02-13 11:02:15 +00:00
|
|
|
SETTING_UINT("rgui_internal_upscale_level", &settings->uints.menu_rgui_internal_upscale_level, true, rgui_internal_upscale_level, false);
|
2019-03-19 11:48:22 +00:00
|
|
|
SETTING_UINT("rgui_aspect_ratio", &settings->uints.menu_rgui_aspect_ratio, true, rgui_aspect, false);
|
2019-03-20 13:40:04 +00:00
|
|
|
SETTING_UINT("rgui_aspect_ratio_lock", &settings->uints.menu_rgui_aspect_ratio_lock, true, rgui_aspect_lock, false);
|
2019-04-29 14:40:00 +00:00
|
|
|
SETTING_UINT("rgui_particle_effect", &settings->uints.menu_rgui_particle_effect, true, rgui_particle_effect, false);
|
2019-02-04 16:20:34 +00:00
|
|
|
#endif
|
2018-10-10 18:31:55 +00:00
|
|
|
#ifdef HAVE_LIBNX
|
2019-08-26 12:22:58 +00:00
|
|
|
SETTING_UINT("split_joycon_p1", &settings->uints.input_split_joycon[0], true, 0, false);
|
|
|
|
SETTING_UINT("split_joycon_p2", &settings->uints.input_split_joycon[1], true, 0, false);
|
|
|
|
SETTING_UINT("split_joycon_p3", &settings->uints.input_split_joycon[2], true, 0, false);
|
|
|
|
SETTING_UINT("split_joycon_p4", &settings->uints.input_split_joycon[3], true, 0, false);
|
|
|
|
SETTING_UINT("split_joycon_p5", &settings->uints.input_split_joycon[4], true, 0, false);
|
|
|
|
SETTING_UINT("split_joycon_p6", &settings->uints.input_split_joycon[5], true, 0, false);
|
|
|
|
SETTING_UINT("split_joycon_p7", &settings->uints.input_split_joycon[6], true, 0, false);
|
|
|
|
SETTING_UINT("split_joycon_p8", &settings->uints.input_split_joycon[7], true, 0, false);
|
2018-10-10 18:31:55 +00:00
|
|
|
#endif
|
2016-08-29 17:10:00 +00:00
|
|
|
#ifdef HAVE_XMB
|
2019-05-13 07:44:52 +00:00
|
|
|
SETTING_UINT("menu_xmb_animation_opening_main_menu", &settings->uints.menu_xmb_animation_opening_main_menu, true, 0 /* TODO/FIXME - implement */, false);
|
|
|
|
SETTING_UINT("menu_xmb_animation_horizontal_highlight", &settings->uints.menu_xmb_animation_horizontal_highlight, true, 0 /* TODO/FIXME - implement */, false);
|
|
|
|
SETTING_UINT("menu_xmb_animation_move_up_down", &settings->uints.menu_xmb_animation_move_up_down, true, 0 /* TODO/FIXME - implement */, false);
|
2017-04-28 19:03:04 +00:00
|
|
|
SETTING_UINT("xmb_alpha_factor", &settings->uints.menu_xmb_alpha_factor, true, xmb_alpha_factor, false);
|
|
|
|
SETTING_UINT("xmb_scale_factor", &settings->uints.menu_xmb_scale_factor, true, xmb_scale_factor, false);
|
2018-04-24 06:33:14 +00:00
|
|
|
SETTING_UINT("xmb_layout", &settings->uints.menu_xmb_layout, true, xmb_menu_layout, false);
|
2017-04-28 19:03:04 +00:00
|
|
|
SETTING_UINT("xmb_theme", &settings->uints.menu_xmb_theme, true, xmb_icon_theme, false);
|
|
|
|
SETTING_UINT("xmb_menu_color_theme", &settings->uints.menu_xmb_color_theme, true, xmb_theme, false);
|
2017-12-27 22:03:39 +00:00
|
|
|
SETTING_UINT("menu_font_color_red", &settings->uints.menu_font_color_red, true, menu_font_color_red, false);
|
|
|
|
SETTING_UINT("menu_font_color_green", &settings->uints.menu_font_color_green, true, menu_font_color_green, false);
|
|
|
|
SETTING_UINT("menu_font_color_blue", &settings->uints.menu_font_color_blue, true, menu_font_color_blue, false);
|
2019-06-07 15:38:17 +00:00
|
|
|
SETTING_UINT("menu_xmb_thumbnail_scale_factor", &settings->uints.menu_xmb_thumbnail_scale_factor, true, xmb_thumbnail_scale_factor, false);
|
2016-08-29 17:10:00 +00:00
|
|
|
#endif
|
2017-04-28 19:03:04 +00:00
|
|
|
SETTING_UINT("materialui_menu_color_theme", &settings->uints.menu_materialui_color_theme, true, MATERIALUI_THEME_BLUE, false);
|
2019-06-14 09:13:02 +00:00
|
|
|
SETTING_UINT("menu_shader_pipeline", &settings->uints.menu_xmb_shader_pipeline, true, DEFAULT_MENU_SHADER_PIPELINE, false);
|
2018-10-27 14:50:48 +00:00
|
|
|
#ifdef HAVE_OZONE
|
2019-02-01 15:16:06 +00:00
|
|
|
SETTING_UINT("ozone_menu_color_theme", &settings->uints.menu_ozone_color_theme, true, 1, false);
|
2018-10-27 14:50:48 +00:00
|
|
|
#endif
|
2017-04-28 17:55:09 +00:00
|
|
|
#endif
|
2019-06-02 15:18:52 +00:00
|
|
|
SETTING_UINT("audio_out_rate", &settings->uints.audio_out_rate, true, DEFAULT_OUTPUT_RATE, false);
|
2017-06-18 16:49:49 +00:00
|
|
|
SETTING_UINT("custom_viewport_width", &settings->video_viewport_custom.width, false, 0 /* TODO */, false);
|
2019-06-14 09:13:02 +00:00
|
|
|
SETTING_UINT("crt_switch_resolution_super", &settings->uints.crt_switch_resolution_super, true, DEFAULT_CRT_SWITCH_RESOLUTION_SUPER, false);
|
2017-06-18 16:49:49 +00:00
|
|
|
SETTING_UINT("custom_viewport_height", &settings->video_viewport_custom.height, false, 0 /* TODO */, false);
|
|
|
|
SETTING_UINT("custom_viewport_x", (unsigned*)&settings->video_viewport_custom.x, false, 0 /* TODO */, false);
|
|
|
|
SETTING_UINT("custom_viewport_y", (unsigned*)&settings->video_viewport_custom.y, false, 0 /* TODO */, false);
|
2017-04-28 19:03:04 +00:00
|
|
|
SETTING_UINT("content_history_size", &settings->uints.content_history_size, true, default_content_history_size, false);
|
2019-06-02 15:18:52 +00:00
|
|
|
SETTING_UINT("video_hard_sync_frames", &settings->uints.video_hard_sync_frames, true, DEFAULT_HARD_SYNC_FRAMES, false);
|
|
|
|
SETTING_UINT("video_frame_delay", &settings->uints.video_frame_delay, true, DEFAULT_FRAME_DELAY, false);
|
|
|
|
SETTING_UINT("video_max_swapchain_images", &settings->uints.video_max_swapchain_images, true, DEFAULT_MAX_SWAPCHAIN_IMAGES, false);
|
|
|
|
SETTING_UINT("video_swap_interval", &settings->uints.video_swap_interval, true, DEFAULT_SWAP_INTERVAL, false);
|
2017-04-28 19:03:04 +00:00
|
|
|
SETTING_UINT("video_rotation", &settings->uints.video_rotation, true, ORIENTATION_NORMAL, false);
|
2019-02-21 05:31:55 +00:00
|
|
|
SETTING_UINT("screen_orientation", &settings->uints.screen_orientation, true, ORIENTATION_NORMAL, false);
|
2019-06-02 15:18:52 +00:00
|
|
|
SETTING_UINT("aspect_ratio_index", &settings->uints.video_aspect_ratio_idx, true, DEFAULT_ASPECT_RATIO_IDX, false);
|
2016-09-29 19:07:10 +00:00
|
|
|
#ifdef HAVE_NETWORKING
|
2017-04-28 19:03:04 +00:00
|
|
|
SETTING_UINT("netplay_ip_port", &settings->uints.netplay_port, true, RARCH_DEFAULT_PORT, false);
|
2018-03-09 22:23:34 +00:00
|
|
|
SETTING_OVERRIDE(RARCH_OVERRIDE_SETTING_NETPLAY_IP_PORT);
|
2017-04-28 19:03:04 +00:00
|
|
|
SETTING_UINT("netplay_input_latency_frames_min",&settings->uints.netplay_input_latency_frames_min, true, 0, false);
|
|
|
|
SETTING_UINT("netplay_input_latency_frames_range",&settings->uints.netplay_input_latency_frames_range, true, 0, false);
|
2017-09-11 02:49:25 +00:00
|
|
|
SETTING_UINT("netplay_share_digital", &settings->uints.netplay_share_digital, true, netplay_share_digital, false);
|
|
|
|
SETTING_UINT("netplay_share_analog", &settings->uints.netplay_share_analog, true, netplay_share_analog, false);
|
2016-08-29 17:10:00 +00:00
|
|
|
#endif
|
|
|
|
#ifdef HAVE_LANGEXTRA
|
2019-10-01 17:46:49 +00:00
|
|
|
#ifdef VITA
|
|
|
|
SETTING_UINT("user_language", msg_hash_get_uint(MSG_HASH_USER_LANGUAGE), true, frontend_driver_get_user_language(), false);
|
|
|
|
#else
|
2019-06-14 09:13:02 +00:00
|
|
|
SETTING_UINT("user_language", msg_hash_get_uint(MSG_HASH_USER_LANGUAGE), true, DEFAULT_USER_LANGUAGE, false);
|
2019-10-01 17:46:49 +00:00
|
|
|
#endif
|
2016-08-29 17:10:00 +00:00
|
|
|
#endif
|
2017-04-28 19:03:04 +00:00
|
|
|
SETTING_UINT("bundle_assets_extract_version_current", &settings->uints.bundle_assets_extract_version_current, true, 0, false);
|
|
|
|
SETTING_UINT("bundle_assets_extract_last_version", &settings->uints.bundle_assets_extract_last_version, true, 0, false);
|
2017-08-08 14:56:27 +00:00
|
|
|
SETTING_UINT("input_overlay_show_physical_inputs_port", &settings->uints.input_overlay_show_physical_inputs_port, true, 0, false);
|
2017-10-10 18:53:32 +00:00
|
|
|
SETTING_UINT("video_msg_bgcolor_red", &settings->uints.video_msg_bgcolor_red, true, message_bgcolor_red, false);
|
|
|
|
SETTING_UINT("video_msg_bgcolor_green", &settings->uints.video_msg_bgcolor_green, true, message_bgcolor_green, false);
|
|
|
|
SETTING_UINT("video_msg_bgcolor_blue", &settings->uints.video_msg_bgcolor_blue, true, message_bgcolor_blue, false);
|
2017-12-27 21:21:56 +00:00
|
|
|
|
2018-03-28 19:22:07 +00:00
|
|
|
SETTING_UINT("run_ahead_frames", &settings->uints.run_ahead_frames, true, 1, false);
|
|
|
|
|
2018-06-04 05:48:08 +00:00
|
|
|
SETTING_UINT("midi_volume", &settings->uints.midi_volume, true, midi_volume, false);
|
|
|
|
|
2018-09-23 23:43:26 +00:00
|
|
|
SETTING_UINT("video_stream_port", &settings->uints.video_stream_port, true, RARCH_STREAM_DEFAULT_PORT, false);
|
|
|
|
SETTING_UINT("video_record_quality", &settings->uints.video_record_quality, true, RECORD_CONFIG_TYPE_RECORDING_LOSSLESS_QUALITY, false);
|
2018-09-24 00:02:12 +00:00
|
|
|
SETTING_UINT("video_stream_quality", &settings->uints.video_stream_quality, true, RECORD_CONFIG_TYPE_STREAMING_LOW_QUALITY, false);
|
2018-09-24 00:53:13 +00:00
|
|
|
SETTING_UINT("video_record_scale_factor", &settings->uints.video_record_scale_factor, true, 1, false);
|
|
|
|
SETTING_UINT("video_stream_scale_factor", &settings->uints.video_stream_scale_factor, true, 1, false);
|
2018-11-25 08:02:32 +00:00
|
|
|
SETTING_UINT("video_windowed_position_x", &settings->uints.window_position_x, true, 0, false);
|
|
|
|
SETTING_UINT("video_windowed_position_y", &settings->uints.window_position_y, true, 0, false);
|
2019-06-02 15:18:52 +00:00
|
|
|
SETTING_UINT("video_windowed_position_width", &settings->uints.window_position_width, true, DEFAULT_WINDOW_WIDTH, false);
|
|
|
|
SETTING_UINT("video_windowed_position_height", &settings->uints.window_position_height, true, DEFAULT_WINDOW_HEIGHT, false);
|
2019-08-22 05:07:07 +00:00
|
|
|
SETTING_UINT("ai_service_mode", &settings->uints.ai_service_mode, DEFAULT_AI_SERVICE_MODE, 0, false);
|
2019-08-22 17:39:00 +00:00
|
|
|
SETTING_UINT("ai_service_target_lang", &settings->uints.ai_service_target_lang, 0, 0, false);
|
|
|
|
SETTING_UINT("ai_service_source_lang", &settings->uints.ai_service_source_lang, 0, 0, false);
|
2018-09-23 23:43:26 +00:00
|
|
|
|
2019-06-02 15:18:52 +00:00
|
|
|
SETTING_UINT("video_record_threads", &settings->uints.video_record_threads, true, DEFAULT_VIDEO_RECORD_THREADS, false);
|
2018-11-25 20:41:26 +00:00
|
|
|
|
2018-11-29 17:42:44 +00:00
|
|
|
#ifdef HAVE_LIBNX
|
|
|
|
SETTING_UINT("libnx_overclock", &settings->uints.libnx_overclock, true, SWITCH_DEFAULT_CPU_PROFILE, false);
|
|
|
|
#endif
|
|
|
|
|
2019-04-15 16:05:55 +00:00
|
|
|
#ifdef _3DS
|
|
|
|
SETTING_UINT("video_3ds_display_mode", &settings->uints.video_3ds_display_mode, true, video_3ds_display_mode, false);
|
|
|
|
#endif
|
|
|
|
|
2019-03-27 01:37:34 +00:00
|
|
|
#ifdef HAVE_MENU
|
2019-06-04 10:27:37 +00:00
|
|
|
SETTING_UINT("playlist_entry_remove_enable", &settings->uints.playlist_entry_remove_enable, true, playlist_entry_remove_enable, false);
|
2019-03-08 12:52:23 +00:00
|
|
|
SETTING_UINT("playlist_show_inline_core_name", &settings->uints.playlist_show_inline_core_name, true, playlist_show_inline_core_name, false);
|
2019-03-07 12:28:21 +00:00
|
|
|
SETTING_UINT("playlist_sublabel_runtime_type", &settings->uints.playlist_sublabel_runtime_type, true, playlist_sublabel_runtime_type, false);
|
2019-09-10 15:13:25 +00:00
|
|
|
SETTING_UINT("playlist_sublabel_last_played_style", &settings->uints.playlist_sublabel_last_played_style, true, DEFAULT_PLAYLIST_SUBLABEL_LAST_PLAYED_STYLE, false);
|
2019-03-27 01:37:34 +00:00
|
|
|
#endif
|
2019-03-07 12:28:21 +00:00
|
|
|
|
2017-04-28 17:55:09 +00:00
|
|
|
*size = count;
|
|
|
|
|
|
|
|
return tmp;
|
|
|
|
}
|
|
|
|
|
2018-07-13 20:12:09 +00:00
|
|
|
static struct config_size_setting *populate_settings_size(settings_t *settings, int *size)
|
|
|
|
{
|
|
|
|
unsigned count = 0;
|
2018-08-06 04:59:50 +00:00
|
|
|
struct config_size_setting *tmp = (struct config_size_setting*)calloc((*size + 1), sizeof(struct config_size_setting));
|
2018-07-13 20:12:09 +00:00
|
|
|
|
2019-01-10 21:24:43 +00:00
|
|
|
if (!tmp)
|
|
|
|
return NULL;
|
|
|
|
|
2019-06-02 15:18:52 +00:00
|
|
|
SETTING_SIZE("rewind_buffer_size", &settings->sizes.rewind_buffer_size, true, DEFAULT_REWIND_BUFFER_SIZE, false);
|
2018-07-13 20:12:09 +00:00
|
|
|
|
2017-04-28 17:55:09 +00:00
|
|
|
*size = count;
|
|
|
|
|
|
|
|
return tmp;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct config_int_setting *populate_settings_int(settings_t *settings, int *size)
|
|
|
|
{
|
|
|
|
unsigned count = 0;
|
2018-03-09 22:23:34 +00:00
|
|
|
struct config_int_setting *tmp = (struct config_int_setting*)calloc((*size + 1), sizeof(struct config_int_setting));
|
2017-04-28 17:55:09 +00:00
|
|
|
|
2019-01-10 21:24:43 +00:00
|
|
|
if (!tmp)
|
|
|
|
return NULL;
|
|
|
|
|
2017-04-28 17:55:09 +00:00
|
|
|
SETTING_INT("state_slot", &settings->ints.state_slot, false, 0 /* TODO */, false);
|
|
|
|
#ifdef HAVE_NETWORKING
|
|
|
|
SETTING_INT("netplay_check_frames", &settings->ints.netplay_check_frames, true, netplay_check_frames, false);
|
2018-03-09 22:23:34 +00:00
|
|
|
SETTING_OVERRIDE(RARCH_OVERRIDE_SETTING_NETPLAY_CHECK_FRAMES);
|
2017-04-25 03:09:57 +00:00
|
|
|
#endif
|
2017-05-24 14:25:36 +00:00
|
|
|
#ifdef HAVE_WASAPI
|
|
|
|
SETTING_INT("audio_wasapi_sh_buffer_length", &settings->ints.audio_wasapi_sh_buffer_length, true, wasapi_sh_buffer_length, false);
|
|
|
|
#endif
|
2019-06-14 09:13:02 +00:00
|
|
|
SETTING_INT("crt_switch_center_adjust", &settings->ints.crt_switch_center_adjust, false, DEFAULT_CRT_SWITCH_CENTER_ADJUST, false);
|
2019-06-13 16:47:08 +00:00
|
|
|
#ifdef HAVE_VULKAN
|
2019-06-14 09:13:02 +00:00
|
|
|
SETTING_INT("vulkan_gpu_index", &settings->ints.vulkan_gpu_index, true, DEFAULT_VULKAN_GPU_INDEX, false);
|
2019-06-13 16:47:08 +00:00
|
|
|
#endif
|
2019-06-18 20:33:37 +00:00
|
|
|
#ifdef HAVE_D3D10
|
|
|
|
SETTING_INT("d3d10_gpu_index", &settings->ints.d3d10_gpu_index, true, DEFAULT_D3D10_GPU_INDEX, false);
|
|
|
|
#endif
|
|
|
|
#ifdef HAVE_D3D11
|
|
|
|
SETTING_INT("d3d11_gpu_index", &settings->ints.d3d11_gpu_index, true, DEFAULT_D3D11_GPU_INDEX, false);
|
|
|
|
#endif
|
|
|
|
#ifdef HAVE_D3D12
|
|
|
|
SETTING_INT("d3d12_gpu_index", &settings->ints.d3d12_gpu_index, true, DEFAULT_D3D12_GPU_INDEX, false);
|
|
|
|
#endif
|
2019-07-30 16:11:43 +00:00
|
|
|
SETTING_INT("content_favorites_size", &settings->ints.content_favorites_size, true, default_content_favorites_size, false);
|
2016-08-29 17:10:00 +00:00
|
|
|
|
2016-12-26 03:14:09 +00:00
|
|
|
*size = count;
|
|
|
|
|
|
|
|
return tmp;
|
2016-08-29 17:10:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* config_set_defaults:
|
|
|
|
*
|
|
|
|
* Set 'default' configuration values.
|
|
|
|
**/
|
2018-10-01 00:13:53 +00:00
|
|
|
void config_set_defaults(void)
|
2016-08-29 17:10:00 +00:00
|
|
|
{
|
|
|
|
unsigned i, j;
|
2017-04-27 22:00:43 +00:00
|
|
|
#ifdef HAVE_MENU
|
|
|
|
static bool first_initialized = true;
|
|
|
|
#endif
|
2016-08-29 17:10:00 +00:00
|
|
|
settings_t *settings = config_get_ptr();
|
2017-04-28 19:05:34 +00:00
|
|
|
int bool_settings_size = sizeof(settings->bools) / sizeof(settings->bools.placeholder);
|
|
|
|
int float_settings_size = sizeof(settings->floats) / sizeof(settings->floats.placeholder);
|
|
|
|
int int_settings_size = sizeof(settings->ints) / sizeof(settings->ints.placeholder);
|
|
|
|
int uint_settings_size = sizeof(settings->uints) / sizeof(settings->uints.placeholder);
|
2018-07-13 20:12:09 +00:00
|
|
|
int size_settings_size = sizeof(settings->sizes) / sizeof(settings->sizes.placeholder);
|
2016-08-29 17:10:00 +00:00
|
|
|
const char *def_video = config_get_default_video();
|
|
|
|
const char *def_audio = config_get_default_audio();
|
|
|
|
const char *def_audio_resampler = config_get_default_audio_resampler();
|
|
|
|
const char *def_input = config_get_default_input();
|
|
|
|
const char *def_joypad = config_get_default_joypad();
|
|
|
|
#ifdef HAVE_MENU
|
|
|
|
const char *def_menu = config_get_default_menu();
|
|
|
|
#endif
|
|
|
|
const char *def_camera = config_get_default_camera();
|
2016-09-21 16:51:40 +00:00
|
|
|
const char *def_wifi = config_get_default_wifi();
|
2017-12-27 16:05:12 +00:00
|
|
|
const char *def_led = config_get_default_led();
|
2016-08-29 17:10:00 +00:00
|
|
|
const char *def_location = config_get_default_location();
|
|
|
|
const char *def_record = config_get_default_record();
|
2018-06-04 05:48:08 +00:00
|
|
|
const char *def_midi = config_get_default_midi();
|
2018-02-02 20:37:02 +00:00
|
|
|
const char *def_mitm = netplay_mitm_server;
|
2017-04-27 22:01:47 +00:00
|
|
|
struct config_float_setting *float_settings = populate_settings_float (settings, &float_settings_size);
|
|
|
|
struct config_bool_setting *bool_settings = populate_settings_bool (settings, &bool_settings_size);
|
2017-04-28 18:08:12 +00:00
|
|
|
struct config_int_setting *int_settings = populate_settings_int (settings, &int_settings_size);
|
|
|
|
struct config_uint_setting *uint_settings = populate_settings_uint (settings, &uint_settings_size);
|
2018-07-13 20:12:09 +00:00
|
|
|
struct config_size_setting *size_settings = populate_settings_size (settings, &size_settings_size);
|
2016-08-29 17:26:08 +00:00
|
|
|
|
2016-12-26 02:16:27 +00:00
|
|
|
if (bool_settings && (bool_settings_size > 0))
|
2016-08-29 17:26:08 +00:00
|
|
|
{
|
2016-12-26 02:16:27 +00:00
|
|
|
for (i = 0; i < (unsigned)bool_settings_size; i++)
|
|
|
|
{
|
|
|
|
if (bool_settings[i].def_enable)
|
|
|
|
*bool_settings[i].ptr = bool_settings[i].def;
|
|
|
|
}
|
|
|
|
|
|
|
|
free(bool_settings);
|
2016-08-29 17:26:08 +00:00
|
|
|
}
|
2016-08-29 17:10:00 +00:00
|
|
|
|
2016-12-26 02:16:27 +00:00
|
|
|
if (int_settings && (int_settings_size > 0))
|
2016-08-30 01:20:55 +00:00
|
|
|
{
|
2016-12-26 02:16:27 +00:00
|
|
|
for (i = 0; i < (unsigned)int_settings_size; i++)
|
|
|
|
{
|
|
|
|
if (int_settings[i].def_enable)
|
|
|
|
*int_settings[i].ptr = int_settings[i].def;
|
|
|
|
}
|
|
|
|
|
|
|
|
free(int_settings);
|
2016-08-30 01:20:55 +00:00
|
|
|
}
|
|
|
|
|
2017-04-28 17:55:09 +00:00
|
|
|
if (uint_settings && (uint_settings_size > 0))
|
|
|
|
{
|
|
|
|
for (i = 0; i < (unsigned)uint_settings_size; i++)
|
|
|
|
{
|
|
|
|
if (uint_settings[i].def_enable)
|
|
|
|
*uint_settings[i].ptr = uint_settings[i].def;
|
|
|
|
}
|
|
|
|
|
|
|
|
free(uint_settings);
|
|
|
|
}
|
|
|
|
|
2018-07-13 20:12:09 +00:00
|
|
|
if (size_settings && (size_settings_size > 0))
|
|
|
|
{
|
|
|
|
for (i = 0; i < (unsigned)size_settings_size; i++)
|
|
|
|
{
|
|
|
|
if (size_settings[i].def_enable)
|
|
|
|
*size_settings[i].ptr = size_settings[i].def;
|
|
|
|
}
|
|
|
|
|
|
|
|
free(size_settings);
|
|
|
|
}
|
|
|
|
|
2016-12-26 02:16:27 +00:00
|
|
|
if (float_settings && (float_settings_size > 0))
|
2016-08-29 18:57:24 +00:00
|
|
|
{
|
2016-12-26 02:16:27 +00:00
|
|
|
for (i = 0; i < (unsigned)float_settings_size; i++)
|
|
|
|
{
|
|
|
|
if (float_settings[i].def_enable)
|
|
|
|
*float_settings[i].ptr = float_settings[i].def;
|
|
|
|
}
|
|
|
|
|
|
|
|
free(float_settings);
|
2016-08-29 18:57:24 +00:00
|
|
|
}
|
|
|
|
|
2016-08-29 17:10:00 +00:00
|
|
|
if (def_camera)
|
2017-04-28 20:59:13 +00:00
|
|
|
strlcpy(settings->arrays.camera_driver,
|
|
|
|
def_camera, sizeof(settings->arrays.camera_driver));
|
2016-09-21 16:51:40 +00:00
|
|
|
if (def_wifi)
|
2017-04-28 20:59:13 +00:00
|
|
|
strlcpy(settings->arrays.wifi_driver,
|
|
|
|
def_wifi, sizeof(settings->arrays.wifi_driver));
|
2017-12-27 16:05:12 +00:00
|
|
|
if (def_led)
|
|
|
|
strlcpy(settings->arrays.led_driver,
|
|
|
|
def_led, sizeof(settings->arrays.led_driver));
|
2016-08-29 17:10:00 +00:00
|
|
|
if (def_location)
|
2017-04-28 20:59:13 +00:00
|
|
|
strlcpy(settings->arrays.location_driver,
|
|
|
|
def_location, sizeof(settings->arrays.location_driver));
|
2016-08-29 17:10:00 +00:00
|
|
|
if (def_video)
|
2017-04-28 20:59:13 +00:00
|
|
|
strlcpy(settings->arrays.video_driver,
|
|
|
|
def_video, sizeof(settings->arrays.video_driver));
|
2016-08-29 17:10:00 +00:00
|
|
|
if (def_audio)
|
2017-04-28 20:59:13 +00:00
|
|
|
strlcpy(settings->arrays.audio_driver,
|
|
|
|
def_audio, sizeof(settings->arrays.audio_driver));
|
2016-08-29 17:10:00 +00:00
|
|
|
if (def_audio_resampler)
|
2017-04-28 20:59:13 +00:00
|
|
|
strlcpy(settings->arrays.audio_resampler,
|
|
|
|
def_audio_resampler, sizeof(settings->arrays.audio_resampler));
|
2016-08-29 17:10:00 +00:00
|
|
|
if (def_input)
|
2017-04-28 20:59:13 +00:00
|
|
|
strlcpy(settings->arrays.input_driver,
|
|
|
|
def_input, sizeof(settings->arrays.input_driver));
|
2016-08-29 17:10:00 +00:00
|
|
|
if (def_joypad)
|
2017-04-28 20:59:13 +00:00
|
|
|
strlcpy(settings->arrays.input_joypad_driver,
|
|
|
|
def_joypad, sizeof(settings->arrays.input_joypad_driver));
|
2016-08-29 17:10:00 +00:00
|
|
|
if (def_record)
|
2017-04-28 20:59:13 +00:00
|
|
|
strlcpy(settings->arrays.record_driver,
|
|
|
|
def_record, sizeof(settings->arrays.record_driver));
|
2018-06-04 05:48:08 +00:00
|
|
|
if (def_midi)
|
|
|
|
strlcpy(settings->arrays.midi_driver,
|
|
|
|
def_midi, sizeof(settings->arrays.midi_driver));
|
2018-02-02 20:37:02 +00:00
|
|
|
if (def_mitm)
|
|
|
|
strlcpy(settings->arrays.netplay_mitm_server,
|
|
|
|
def_mitm, sizeof(settings->arrays.netplay_mitm_server));
|
2016-08-29 17:10:00 +00:00
|
|
|
#ifdef HAVE_MENU
|
|
|
|
if (def_menu)
|
2017-04-28 20:59:13 +00:00
|
|
|
strlcpy(settings->arrays.menu_driver,
|
|
|
|
def_menu, sizeof(settings->arrays.menu_driver));
|
2016-08-29 17:10:00 +00:00
|
|
|
#ifdef HAVE_XMB
|
2017-04-28 22:39:29 +00:00
|
|
|
*settings->paths.path_menu_xmb_font = '\0';
|
2016-08-29 17:10:00 +00:00
|
|
|
#endif
|
|
|
|
|
2018-10-13 23:17:17 +00:00
|
|
|
strlcpy(settings->arrays.discord_app_id,
|
|
|
|
default_discord_app_id, sizeof(settings->arrays.discord_app_id));
|
|
|
|
|
2019-05-30 16:06:16 +00:00
|
|
|
strlcpy(settings->arrays.ai_service_url,
|
2019-08-22 05:07:07 +00:00
|
|
|
DEFAULT_AI_SERVICE_URL, sizeof(settings->arrays.ai_service_url));
|
2019-05-11 05:15:39 +00:00
|
|
|
|
|
|
|
|
2016-08-30 01:30:38 +00:00
|
|
|
#ifdef HAVE_MATERIALUI
|
2016-08-29 17:10:00 +00:00
|
|
|
if (g_defaults.menu.materialui.menu_color_theme_enable)
|
2017-04-28 19:03:04 +00:00
|
|
|
settings->uints.menu_materialui_color_theme = g_defaults.menu.materialui.menu_color_theme;
|
2016-08-29 17:10:00 +00:00
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
|
2018-06-20 02:50:58 +00:00
|
|
|
#if defined(HAVE_FFMPEG) || defined(HAVE_MPV)
|
2017-04-28 11:43:47 +00:00
|
|
|
configuration_set_bool(settings, settings->bools.multimedia_builtin_mediaplayer_enable, true);
|
2016-08-29 17:10:00 +00:00
|
|
|
#else
|
2017-04-28 11:43:47 +00:00
|
|
|
configuration_set_bool(settings, settings->bools.multimedia_builtin_mediaplayer_enable, false);
|
2016-08-29 17:10:00 +00:00
|
|
|
#endif
|
2019-06-02 15:18:52 +00:00
|
|
|
settings->floats.video_scale = DEFAULT_SCALE;
|
2016-08-29 17:10:00 +00:00
|
|
|
|
2019-07-10 10:21:18 +00:00
|
|
|
video_driver_set_threaded(DEFAULT_VIDEO_THREADED);
|
2016-08-29 17:10:00 +00:00
|
|
|
|
2017-04-28 12:57:55 +00:00
|
|
|
settings->floats.video_msg_color_r = ((message_color >> 16) & 0xff) / 255.0f;
|
|
|
|
settings->floats.video_msg_color_g = ((message_color >> 8) & 0xff) / 255.0f;
|
|
|
|
settings->floats.video_msg_color_b = ((message_color >> 0) & 0xff) / 255.0f;
|
2011-01-23 01:48:06 +00:00
|
|
|
|
2014-09-01 23:27:46 +00:00
|
|
|
if (g_defaults.settings.video_refresh_rate > 0.0 &&
|
2019-07-19 11:14:29 +00:00
|
|
|
g_defaults.settings.video_refresh_rate != DEFAULT_REFRESH_RATE)
|
2017-04-28 12:57:55 +00:00
|
|
|
settings->floats.video_refresh_rate = g_defaults.settings.video_refresh_rate;
|
2014-06-12 23:10:14 +00:00
|
|
|
|
2019-06-14 09:13:02 +00:00
|
|
|
if (DEFAULT_AUDIO_DEVICE)
|
2017-04-28 20:59:13 +00:00
|
|
|
strlcpy(settings->arrays.audio_device,
|
2019-06-14 09:13:02 +00:00
|
|
|
DEFAULT_AUDIO_DEVICE, sizeof(settings->arrays.audio_device));
|
2014-06-12 16:30:41 +00:00
|
|
|
|
|
|
|
if (!g_defaults.settings.out_latency)
|
2019-06-02 15:18:52 +00:00
|
|
|
g_defaults.settings.out_latency = DEFAULT_OUT_LATENCY;
|
2015-04-13 00:12:28 +00:00
|
|
|
|
2017-04-28 19:03:04 +00:00
|
|
|
settings->uints.audio_latency = g_defaults.settings.out_latency;
|
2015-05-19 19:18:07 +00:00
|
|
|
|
2017-06-08 20:24:51 +00:00
|
|
|
audio_set_float(AUDIO_ACTION_VOLUME_GAIN, settings->floats.audio_volume);
|
2019-07-11 09:51:06 +00:00
|
|
|
#ifdef HAVE_AUDIOMIXER
|
2017-06-08 20:58:43 +00:00
|
|
|
audio_set_float(AUDIO_ACTION_MIXER_VOLUME_GAIN, settings->floats.audio_mixer_volume);
|
2019-07-11 09:51:06 +00:00
|
|
|
#endif
|
2015-04-13 00:12:28 +00:00
|
|
|
|
2016-03-21 22:46:36 +00:00
|
|
|
#ifdef HAVE_LAKKA
|
2017-12-14 19:05:46 +00:00
|
|
|
settings->bools.ssh_enable = filestream_exists(LAKKA_SSH_PATH);
|
|
|
|
settings->bools.samba_enable = filestream_exists(LAKKA_SAMBA_PATH);
|
|
|
|
settings->bools.bluetooth_enable = filestream_exists(LAKKA_BLUETOOTH_PATH);
|
2016-03-21 22:46:36 +00:00
|
|
|
#endif
|
|
|
|
|
2014-02-10 19:26:48 +00:00
|
|
|
#ifdef HAVE_MENU
|
2016-01-11 21:52:17 +00:00
|
|
|
if (first_initialized)
|
2017-04-28 11:43:47 +00:00
|
|
|
settings->bools.menu_show_start_screen = default_menu_show_start_screen;
|
2014-02-10 19:26:48 +00:00
|
|
|
#endif
|
2013-10-05 09:11:43 +00:00
|
|
|
|
2015-10-16 16:14:29 +00:00
|
|
|
#ifdef HAVE_CHEEVOS
|
2017-04-28 20:59:13 +00:00
|
|
|
*settings->arrays.cheevos_username = '\0';
|
|
|
|
*settings->arrays.cheevos_password = '\0';
|
2018-04-25 02:31:07 +00:00
|
|
|
*settings->arrays.cheevos_token = '\0';
|
2015-10-16 16:14:29 +00:00
|
|
|
#endif
|
|
|
|
|
2017-04-25 14:49:54 +00:00
|
|
|
input_config_reset();
|
2017-09-12 03:49:39 +00:00
|
|
|
input_remapping_set_defaults(true);
|
2017-04-25 13:49:27 +00:00
|
|
|
input_autoconfigure_reset();
|
|
|
|
|
2014-09-01 23:27:46 +00:00
|
|
|
/* Verify that binds are in proper order. */
|
2015-01-05 00:58:00 +00:00
|
|
|
for (i = 0; i < MAX_USERS; i++)
|
2016-09-01 02:11:53 +00:00
|
|
|
{
|
2013-10-22 13:08:17 +00:00
|
|
|
for (j = 0; j < RARCH_BIND_LIST_END; j++)
|
2015-01-05 01:36:10 +00:00
|
|
|
{
|
2017-04-25 22:24:59 +00:00
|
|
|
const struct retro_keybind *keyval = &input_config_binds[i][j];
|
2017-04-25 16:12:13 +00:00
|
|
|
if (keyval->valid)
|
|
|
|
retro_assert(j == keyval->id);
|
2015-01-05 01:36:10 +00:00
|
|
|
}
|
2016-09-01 02:11:53 +00:00
|
|
|
}
|
2012-02-01 22:02:17 +00:00
|
|
|
|
2017-04-28 22:39:29 +00:00
|
|
|
strlcpy(settings->paths.network_buildbot_url, buildbot_server_url,
|
|
|
|
sizeof(settings->paths.network_buildbot_url));
|
|
|
|
strlcpy(settings->paths.network_buildbot_assets_url, buildbot_assets_server_url,
|
|
|
|
sizeof(settings->paths.network_buildbot_assets_url));
|
2015-01-19 03:09:28 +00:00
|
|
|
|
2017-04-28 20:59:13 +00:00
|
|
|
*settings->arrays.input_keyboard_layout = '\0';
|
2013-01-05 19:06:59 +00:00
|
|
|
|
2015-01-05 00:58:00 +00:00
|
|
|
for (i = 0; i < MAX_USERS; i++)
|
2013-09-22 09:08:09 +00:00
|
|
|
{
|
2017-04-28 19:03:04 +00:00
|
|
|
settings->uints.input_joypad_map[i] = i;
|
2018-12-16 14:38:56 +00:00
|
|
|
#ifdef SWITCH /* Switch prefered default dpad mode */
|
2018-09-29 15:52:35 +00:00
|
|
|
settings->uints.input_analog_dpad_mode[i] = ANALOG_DPAD_LSTICK;
|
|
|
|
#else
|
2017-04-28 19:03:04 +00:00
|
|
|
settings->uints.input_analog_dpad_mode[i] = ANALOG_DPAD_NONE;
|
2018-09-29 15:52:35 +00:00
|
|
|
#endif
|
2018-03-09 22:23:34 +00:00
|
|
|
input_config_set_device(i, RETRO_DEVICE_JOYPAD);
|
2017-06-08 14:13:45 +00:00
|
|
|
settings->uints.input_mouse_index[i] = 0;
|
2013-09-22 09:08:09 +00:00
|
|
|
}
|
2012-05-28 21:14:18 +00:00
|
|
|
|
2016-05-08 12:00:51 +00:00
|
|
|
video_driver_reset_custom_viewport();
|
2014-09-21 03:23:51 +00:00
|
|
|
|
2015-04-05 16:14:24 +00:00
|
|
|
/* Make sure settings from other configs carry over into defaults
|
2014-09-01 23:27:46 +00:00
|
|
|
* for another config. */
|
2018-03-09 22:33:41 +00:00
|
|
|
if (!retroarch_override_setting_is_set(RARCH_OVERRIDE_SETTING_SAVE_PATH, NULL))
|
|
|
|
dir_clear(RARCH_DIR_SAVEFILE);
|
|
|
|
if (!retroarch_override_setting_is_set(RARCH_OVERRIDE_SETTING_STATE_PATH, NULL))
|
|
|
|
dir_clear(RARCH_DIR_SAVESTATE);
|
2014-06-16 19:50:29 +00:00
|
|
|
|
2017-04-28 22:39:29 +00:00
|
|
|
*settings->paths.path_libretro_info = '\0';
|
2018-03-09 22:23:34 +00:00
|
|
|
*settings->paths.directory_libretro = '\0';
|
2017-04-28 22:39:29 +00:00
|
|
|
*settings->paths.directory_cursor = '\0';
|
|
|
|
*settings->paths.directory_resampler = '\0';
|
|
|
|
*settings->paths.directory_screenshot = '\0';
|
|
|
|
*settings->paths.directory_system = '\0';
|
|
|
|
*settings->paths.directory_cache = '\0';
|
|
|
|
*settings->paths.directory_input_remapping = '\0';
|
|
|
|
*settings->paths.directory_core_assets = '\0';
|
|
|
|
*settings->paths.directory_assets = '\0';
|
|
|
|
*settings->paths.directory_dynamic_wallpapers = '\0';
|
|
|
|
*settings->paths.directory_thumbnails = '\0';
|
|
|
|
*settings->paths.directory_playlist = '\0';
|
2019-03-11 12:50:46 +00:00
|
|
|
*settings->paths.directory_runtime_log = '\0';
|
2017-04-28 22:39:29 +00:00
|
|
|
*settings->paths.directory_autoconfig = '\0';
|
2016-04-28 17:26:02 +00:00
|
|
|
#ifdef HAVE_MENU
|
2017-04-28 22:39:29 +00:00
|
|
|
*settings->paths.directory_menu_content = '\0';
|
|
|
|
*settings->paths.directory_menu_config = '\0';
|
2016-04-28 17:26:02 +00:00
|
|
|
#endif
|
2017-04-28 22:39:29 +00:00
|
|
|
*settings->paths.directory_video_shader = '\0';
|
|
|
|
*settings->paths.directory_video_filter = '\0';
|
|
|
|
*settings->paths.directory_audio_filter = '\0';
|
2014-06-16 19:50:29 +00:00
|
|
|
|
2018-03-09 22:23:34 +00:00
|
|
|
rarch_ctl(RARCH_CTL_UNSET_UPS_PREF, NULL);
|
|
|
|
rarch_ctl(RARCH_CTL_UNSET_BPS_PREF, NULL);
|
|
|
|
rarch_ctl(RARCH_CTL_UNSET_IPS_PREF, NULL);
|
2015-01-13 02:21:36 +00:00
|
|
|
|
2016-10-01 06:24:02 +00:00
|
|
|
{
|
2016-12-26 02:16:27 +00:00
|
|
|
global_t *global = global_get_ptr();
|
|
|
|
|
|
|
|
if (global)
|
|
|
|
{
|
|
|
|
*global->record.output_dir = '\0';
|
|
|
|
*global->record.config_dir = '\0';
|
|
|
|
}
|
2016-10-01 06:24:02 +00:00
|
|
|
}
|
2015-04-14 19:13:54 +00:00
|
|
|
|
2017-04-28 22:39:29 +00:00
|
|
|
*settings->paths.path_core_options = '\0';
|
|
|
|
*settings->paths.path_content_history = '\0';
|
2017-08-12 15:10:14 +00:00
|
|
|
*settings->paths.path_content_favorites = '\0';
|
2017-04-28 22:39:29 +00:00
|
|
|
*settings->paths.path_content_music_history = '\0';
|
|
|
|
*settings->paths.path_content_image_history = '\0';
|
|
|
|
*settings->paths.path_content_video_history = '\0';
|
|
|
|
*settings->paths.path_cheat_settings = '\0';
|
2016-01-11 06:54:33 +00:00
|
|
|
#ifndef IOS
|
2017-04-28 20:59:13 +00:00
|
|
|
*settings->arrays.bundle_assets_src = '\0';
|
|
|
|
*settings->arrays.bundle_assets_dst = '\0';
|
|
|
|
*settings->arrays.bundle_assets_dst_subdir = '\0';
|
2016-01-11 06:54:33 +00:00
|
|
|
#endif
|
2017-04-28 22:39:29 +00:00
|
|
|
*settings->paths.path_cheat_database = '\0';
|
|
|
|
*settings->paths.path_menu_wallpaper = '\0';
|
2019-01-29 17:03:44 +00:00
|
|
|
*settings->paths.path_rgui_theme_preset = '\0';
|
2017-04-28 22:39:29 +00:00
|
|
|
*settings->paths.path_content_database = '\0';
|
|
|
|
*settings->paths.path_overlay = '\0';
|
2019-04-16 16:41:06 +00:00
|
|
|
#ifdef HAVE_VIDEO_LAYOUT
|
|
|
|
*settings->paths.path_video_layout = '\0';
|
|
|
|
#endif
|
2018-09-15 22:44:46 +00:00
|
|
|
*settings->paths.path_record_config = '\0';
|
|
|
|
*settings->paths.path_stream_config = '\0';
|
|
|
|
*settings->paths.path_stream_url = '\0';
|
2017-04-28 22:39:29 +00:00
|
|
|
*settings->paths.path_softfilter_plugin = '\0';
|
2016-04-28 17:52:25 +00:00
|
|
|
|
2017-04-28 22:39:29 +00:00
|
|
|
*settings->paths.directory_content_history = '\0';
|
|
|
|
*settings->paths.path_audio_dsp_plugin = '\0';
|
2015-05-07 23:06:14 +00:00
|
|
|
|
2019-03-21 16:56:24 +00:00
|
|
|
*settings->paths.log_dir = '\0';
|
|
|
|
|
2016-05-08 12:00:51 +00:00
|
|
|
video_driver_default_settings();
|
2015-11-21 08:54:55 +00:00
|
|
|
|
2017-05-23 17:43:58 +00:00
|
|
|
if (!string_is_empty(g_defaults.dirs[DEFAULT_DIR_WALLPAPERS]))
|
2017-04-28 22:39:29 +00:00
|
|
|
strlcpy(settings->paths.directory_dynamic_wallpapers,
|
2017-05-23 17:43:58 +00:00
|
|
|
g_defaults.dirs[DEFAULT_DIR_WALLPAPERS],
|
|
|
|
sizeof(settings->paths.directory_dynamic_wallpapers));
|
|
|
|
if (!string_is_empty(g_defaults.dirs[DEFAULT_DIR_THUMBNAILS]))
|
2017-04-28 22:39:29 +00:00
|
|
|
strlcpy(settings->paths.directory_thumbnails,
|
2017-05-23 17:43:58 +00:00
|
|
|
g_defaults.dirs[DEFAULT_DIR_THUMBNAILS],
|
|
|
|
sizeof(settings->paths.directory_thumbnails));
|
|
|
|
if (!string_is_empty(g_defaults.dirs[DEFAULT_DIR_REMAP]))
|
2017-04-28 22:39:29 +00:00
|
|
|
strlcpy(settings->paths.directory_input_remapping,
|
2017-05-23 17:43:58 +00:00
|
|
|
g_defaults.dirs[DEFAULT_DIR_REMAP],
|
|
|
|
sizeof(settings->paths.directory_input_remapping));
|
|
|
|
if (!string_is_empty(g_defaults.dirs[DEFAULT_DIR_CACHE]))
|
2017-04-28 22:39:29 +00:00
|
|
|
strlcpy(settings->paths.directory_cache,
|
2017-05-23 17:43:58 +00:00
|
|
|
g_defaults.dirs[DEFAULT_DIR_CACHE],
|
|
|
|
sizeof(settings->paths.directory_cache));
|
|
|
|
if (!string_is_empty(g_defaults.dirs[DEFAULT_DIR_ASSETS]))
|
2017-04-28 22:39:29 +00:00
|
|
|
strlcpy(settings->paths.directory_assets,
|
2017-05-23 17:43:58 +00:00
|
|
|
g_defaults.dirs[DEFAULT_DIR_ASSETS],
|
|
|
|
sizeof(settings->paths.directory_assets));
|
|
|
|
if (!string_is_empty(g_defaults.dirs[DEFAULT_DIR_CORE_ASSETS]))
|
2017-04-28 22:39:29 +00:00
|
|
|
strlcpy(settings->paths.directory_core_assets,
|
2017-05-23 17:43:58 +00:00
|
|
|
g_defaults.dirs[DEFAULT_DIR_CORE_ASSETS],
|
|
|
|
sizeof(settings->paths.directory_core_assets));
|
|
|
|
if (!string_is_empty(g_defaults.dirs[DEFAULT_DIR_PLAYLIST]))
|
2017-04-28 22:39:29 +00:00
|
|
|
strlcpy(settings->paths.directory_playlist,
|
2017-05-23 17:43:58 +00:00
|
|
|
g_defaults.dirs[DEFAULT_DIR_PLAYLIST],
|
|
|
|
sizeof(settings->paths.directory_playlist));
|
|
|
|
if (!string_is_empty(g_defaults.dirs[DEFAULT_DIR_CORE]))
|
2017-04-28 22:39:29 +00:00
|
|
|
fill_pathname_expand_special(settings->paths.directory_libretro,
|
2017-05-23 17:43:58 +00:00
|
|
|
g_defaults.dirs[DEFAULT_DIR_CORE],
|
|
|
|
sizeof(settings->paths.directory_libretro));
|
|
|
|
if (!string_is_empty(g_defaults.dirs[DEFAULT_DIR_AUDIO_FILTER]))
|
2017-04-28 22:39:29 +00:00
|
|
|
strlcpy(settings->paths.directory_audio_filter,
|
2017-05-23 17:43:58 +00:00
|
|
|
g_defaults.dirs[DEFAULT_DIR_AUDIO_FILTER],
|
|
|
|
sizeof(settings->paths.directory_audio_filter));
|
|
|
|
if (!string_is_empty(g_defaults.dirs[DEFAULT_DIR_VIDEO_FILTER]))
|
2017-04-28 22:39:29 +00:00
|
|
|
strlcpy(settings->paths.directory_video_filter,
|
2017-05-23 17:43:58 +00:00
|
|
|
g_defaults.dirs[DEFAULT_DIR_VIDEO_FILTER],
|
|
|
|
sizeof(settings->paths.directory_video_filter));
|
|
|
|
if (!string_is_empty(g_defaults.dirs[DEFAULT_DIR_SHADER]))
|
2017-04-28 22:39:29 +00:00
|
|
|
fill_pathname_expand_special(settings->paths.directory_video_shader,
|
2017-05-23 17:43:58 +00:00
|
|
|
g_defaults.dirs[DEFAULT_DIR_SHADER],
|
|
|
|
sizeof(settings->paths.directory_video_shader));
|
2016-04-28 17:26:02 +00:00
|
|
|
|
2016-06-25 00:30:54 +00:00
|
|
|
if (!string_is_empty(g_defaults.path.buildbot_server_url))
|
2017-04-28 22:39:29 +00:00
|
|
|
strlcpy(settings->paths.network_buildbot_url,
|
2017-05-23 17:43:58 +00:00
|
|
|
g_defaults.path.buildbot_server_url,
|
|
|
|
sizeof(settings->paths.network_buildbot_url));
|
2016-06-25 00:30:54 +00:00
|
|
|
if (!string_is_empty(g_defaults.path.core))
|
2019-04-21 04:03:02 +00:00
|
|
|
path_set(RARCH_PATH_CORE, g_defaults.path.core);
|
2017-05-23 17:43:58 +00:00
|
|
|
if (!string_is_empty(g_defaults.dirs[DEFAULT_DIR_DATABASE]))
|
|
|
|
strlcpy(settings->paths.path_content_database,
|
|
|
|
g_defaults.dirs[DEFAULT_DIR_DATABASE],
|
2017-04-28 22:39:29 +00:00
|
|
|
sizeof(settings->paths.path_content_database));
|
2017-05-23 17:43:58 +00:00
|
|
|
if (!string_is_empty(g_defaults.dirs[DEFAULT_DIR_CURSOR]))
|
|
|
|
strlcpy(settings->paths.directory_cursor,
|
|
|
|
g_defaults.dirs[DEFAULT_DIR_CURSOR],
|
2017-04-28 22:39:29 +00:00
|
|
|
sizeof(settings->paths.directory_cursor));
|
2017-05-23 17:43:58 +00:00
|
|
|
if (!string_is_empty(g_defaults.dirs[DEFAULT_DIR_CHEATS]))
|
|
|
|
strlcpy(settings->paths.path_cheat_database,
|
|
|
|
g_defaults.dirs[DEFAULT_DIR_CHEATS],
|
2017-04-28 22:39:29 +00:00
|
|
|
sizeof(settings->paths.path_cheat_database));
|
2017-05-23 17:43:58 +00:00
|
|
|
if (!string_is_empty(g_defaults.dirs[DEFAULT_DIR_CORE_INFO]))
|
2017-04-28 22:39:29 +00:00
|
|
|
fill_pathname_expand_special(settings->paths.path_libretro_info,
|
2017-05-23 17:43:58 +00:00
|
|
|
g_defaults.dirs[DEFAULT_DIR_CORE_INFO],
|
|
|
|
sizeof(settings->paths.path_libretro_info));
|
2014-06-03 23:44:38 +00:00
|
|
|
#ifdef HAVE_OVERLAY
|
2017-05-23 17:43:58 +00:00
|
|
|
if (!string_is_empty(g_defaults.dirs[DEFAULT_DIR_OVERLAY]))
|
2014-07-23 14:31:40 +00:00
|
|
|
{
|
2017-04-28 22:39:29 +00:00
|
|
|
fill_pathname_expand_special(settings->paths.directory_overlay,
|
2017-05-23 17:43:58 +00:00
|
|
|
g_defaults.dirs[DEFAULT_DIR_OVERLAY],
|
|
|
|
sizeof(settings->paths.directory_overlay));
|
2014-10-29 06:37:47 +00:00
|
|
|
#ifdef RARCH_MOBILE
|
2017-04-28 22:39:29 +00:00
|
|
|
if (string_is_empty(settings->paths.path_overlay))
|
|
|
|
fill_pathname_join(settings->paths.path_overlay,
|
|
|
|
settings->paths.directory_overlay,
|
2017-05-14 17:29:39 +00:00
|
|
|
"gamepads/flat/retropad.cfg",
|
2017-04-28 22:39:29 +00:00
|
|
|
sizeof(settings->paths.path_overlay));
|
2015-01-29 19:33:27 +00:00
|
|
|
#endif
|
|
|
|
}
|
2014-07-19 22:51:44 +00:00
|
|
|
#endif
|
2019-04-16 16:41:06 +00:00
|
|
|
#ifdef HAVE_VIDEO_LAYOUT
|
|
|
|
if (!string_is_empty(g_defaults.dirs[DEFAULT_DIR_VIDEO_LAYOUT]))
|
|
|
|
{
|
|
|
|
fill_pathname_expand_special(settings->paths.directory_video_layout,
|
|
|
|
g_defaults.dirs[DEFAULT_DIR_VIDEO_LAYOUT],
|
|
|
|
sizeof(settings->paths.directory_video_layout));
|
|
|
|
}
|
|
|
|
#endif
|
2016-11-27 01:46:09 +00:00
|
|
|
|
2014-07-19 22:51:44 +00:00
|
|
|
#ifdef HAVE_MENU
|
2017-05-23 17:43:58 +00:00
|
|
|
if (!string_is_empty(g_defaults.dirs[DEFAULT_DIR_MENU_CONFIG]))
|
2017-02-26 08:35:00 +00:00
|
|
|
{
|
2017-04-28 22:39:29 +00:00
|
|
|
strlcpy(settings->paths.directory_menu_config,
|
2017-05-23 17:43:58 +00:00
|
|
|
g_defaults.dirs[DEFAULT_DIR_MENU_CONFIG],
|
2017-04-28 22:39:29 +00:00
|
|
|
sizeof(settings->paths.directory_menu_config));
|
2017-02-26 21:24:07 +00:00
|
|
|
#if TARGET_OS_IPHONE
|
2018-03-25 10:17:05 +00:00
|
|
|
{
|
|
|
|
char *config_file_path = (char*)malloc(PATH_MAX_LENGTH * sizeof(char));
|
|
|
|
size_t config_file_path_size = PATH_MAX_LENGTH * sizeof(char);
|
|
|
|
|
|
|
|
fill_pathname_join(config_file_path, settings->paths.directory_menu_config, file_path_str(FILE_PATH_MAIN_CONFIG), config_file_path_size);
|
|
|
|
path_set(RARCH_PATH_CONFIG,
|
|
|
|
config_file_path);
|
2019-05-31 14:00:51 +00:00
|
|
|
free(config_file_path);
|
2018-03-25 10:17:05 +00:00
|
|
|
}
|
2017-02-26 21:24:07 +00:00
|
|
|
#endif
|
2017-02-26 08:35:00 +00:00
|
|
|
}
|
2017-02-26 21:24:07 +00:00
|
|
|
|
2017-05-23 17:43:58 +00:00
|
|
|
if (!string_is_empty(g_defaults.dirs[DEFAULT_DIR_MENU_CONTENT]))
|
2017-04-28 22:39:29 +00:00
|
|
|
strlcpy(settings->paths.directory_menu_content,
|
2017-05-23 17:43:58 +00:00
|
|
|
g_defaults.dirs[DEFAULT_DIR_MENU_CONTENT],
|
2017-04-28 22:39:29 +00:00
|
|
|
sizeof(settings->paths.directory_menu_content));
|
2014-06-03 23:44:38 +00:00
|
|
|
#endif
|
2017-05-23 17:43:58 +00:00
|
|
|
if (!string_is_empty(g_defaults.dirs[DEFAULT_DIR_AUTOCONFIG]))
|
2017-04-28 22:39:29 +00:00
|
|
|
strlcpy(settings->paths.directory_autoconfig,
|
2017-05-23 17:43:58 +00:00
|
|
|
g_defaults.dirs[DEFAULT_DIR_AUTOCONFIG],
|
2017-04-28 22:39:29 +00:00
|
|
|
sizeof(settings->paths.directory_autoconfig));
|
2014-07-23 14:31:40 +00:00
|
|
|
|
2018-03-09 22:23:34 +00:00
|
|
|
if (!string_is_empty(g_defaults.dirs[DEFAULT_DIR_SAVESTATE]))
|
2017-05-23 17:43:58 +00:00
|
|
|
dir_set(RARCH_DIR_SAVESTATE, g_defaults.dirs[DEFAULT_DIR_SAVESTATE]);
|
2016-09-17 12:49:35 +00:00
|
|
|
|
2018-03-09 22:23:34 +00:00
|
|
|
if (!string_is_empty(g_defaults.dirs[DEFAULT_DIR_SRAM]))
|
2017-05-23 17:43:58 +00:00
|
|
|
dir_set(RARCH_DIR_SAVEFILE, g_defaults.dirs[DEFAULT_DIR_SRAM]);
|
2016-09-17 12:49:35 +00:00
|
|
|
|
2017-05-23 17:43:58 +00:00
|
|
|
if (!string_is_empty(g_defaults.dirs[DEFAULT_DIR_SYSTEM]))
|
2017-04-28 22:39:29 +00:00
|
|
|
strlcpy(settings->paths.directory_system,
|
2017-05-23 17:43:58 +00:00
|
|
|
g_defaults.dirs[DEFAULT_DIR_SYSTEM],
|
|
|
|
sizeof(settings->paths.directory_system));
|
|
|
|
if (!string_is_empty(g_defaults.dirs[DEFAULT_DIR_SCREENSHOT]))
|
2017-04-28 22:39:29 +00:00
|
|
|
strlcpy(settings->paths.directory_screenshot,
|
2017-05-23 17:43:58 +00:00
|
|
|
g_defaults.dirs[DEFAULT_DIR_SCREENSHOT],
|
2017-04-28 22:39:29 +00:00
|
|
|
sizeof(settings->paths.directory_screenshot));
|
2017-05-23 17:43:58 +00:00
|
|
|
if (!string_is_empty(g_defaults.dirs[DEFAULT_DIR_RESAMPLER]))
|
2017-04-28 22:39:29 +00:00
|
|
|
strlcpy(settings->paths.directory_resampler,
|
2017-05-23 17:43:58 +00:00
|
|
|
g_defaults.dirs[DEFAULT_DIR_RESAMPLER],
|
2017-04-28 22:39:29 +00:00
|
|
|
sizeof(settings->paths.directory_resampler));
|
2017-05-23 17:43:58 +00:00
|
|
|
if (!string_is_empty(g_defaults.dirs[DEFAULT_DIR_CONTENT_HISTORY]))
|
2017-04-28 22:39:29 +00:00
|
|
|
strlcpy(settings->paths.directory_content_history,
|
2017-05-23 17:43:58 +00:00
|
|
|
g_defaults.dirs[DEFAULT_DIR_CONTENT_HISTORY],
|
2017-04-28 22:39:29 +00:00
|
|
|
sizeof(settings->paths.directory_content_history));
|
2014-06-12 16:06:29 +00:00
|
|
|
|
2019-03-05 22:34:05 +00:00
|
|
|
if (!string_is_empty(g_defaults.dirs[DEFAULT_DIR_LOGS]))
|
|
|
|
strlcpy(settings->paths.log_dir,
|
|
|
|
g_defaults.dirs[DEFAULT_DIR_LOGS],
|
|
|
|
sizeof(settings->paths.log_dir));
|
|
|
|
|
2016-06-28 09:02:51 +00:00
|
|
|
if (!string_is_empty(g_defaults.path.config))
|
2016-09-17 11:42:48 +00:00
|
|
|
{
|
2017-09-09 19:35:09 +00:00
|
|
|
char *temp_str = (char*)malloc(PATH_MAX_LENGTH * sizeof(char));
|
2016-10-09 07:05:41 +00:00
|
|
|
|
|
|
|
temp_str[0] = '\0';
|
|
|
|
|
2016-09-17 11:42:48 +00:00
|
|
|
fill_pathname_expand_special(temp_str,
|
2017-11-23 16:55:53 +00:00
|
|
|
g_defaults.path.config,
|
2017-09-09 19:35:09 +00:00
|
|
|
PATH_MAX_LENGTH * sizeof(char));
|
2016-09-29 05:46:21 +00:00
|
|
|
path_set(RARCH_PATH_CONFIG, temp_str);
|
2017-09-09 19:35:09 +00:00
|
|
|
free(temp_str);
|
2016-09-17 11:42:48 +00:00
|
|
|
}
|
2015-01-13 23:35:27 +00:00
|
|
|
|
2018-06-04 05:48:08 +00:00
|
|
|
if (midi_input)
|
|
|
|
strlcpy(settings->arrays.midi_input,
|
|
|
|
midi_input, sizeof(settings->arrays.midi_input));
|
|
|
|
if (midi_output)
|
|
|
|
strlcpy(settings->arrays.midi_output,
|
|
|
|
midi_output, sizeof(settings->arrays.midi_output));
|
|
|
|
|
2016-08-29 17:10:00 +00:00
|
|
|
/* Avoid reloading config on every content load */
|
2019-06-02 19:02:59 +00:00
|
|
|
if (DEFAULT_BLOCK_CONFIG_READ)
|
2016-08-29 17:10:00 +00:00
|
|
|
rarch_ctl(RARCH_CTL_SET_BLOCK_CONFIG_READ, NULL);
|
|
|
|
else
|
|
|
|
rarch_ctl(RARCH_CTL_UNSET_BLOCK_CONFIG_READ, NULL);
|
|
|
|
|
|
|
|
#ifdef HAVE_MENU
|
|
|
|
first_initialized = false;
|
|
|
|
#endif
|
2015-01-11 04:29:32 +00:00
|
|
|
}
|
|
|
|
|
2016-08-29 17:10:00 +00:00
|
|
|
/**
|
|
|
|
* open_default_config_file
|
|
|
|
*
|
|
|
|
* Open a default config file. Platform-specific.
|
|
|
|
*
|
|
|
|
* Returns: handle to config file if found, otherwise NULL.
|
|
|
|
**/
|
|
|
|
static config_file_t *open_default_config_file(void)
|
2015-01-11 04:29:32 +00:00
|
|
|
{
|
2018-01-04 15:55:28 +00:00
|
|
|
bool has_application_data = false;
|
2017-09-09 19:35:09 +00:00
|
|
|
size_t path_size = PATH_MAX_LENGTH * sizeof(char);
|
|
|
|
char *application_data = (char*)malloc(PATH_MAX_LENGTH * sizeof(char));
|
|
|
|
char *conf_path = (char*)malloc(PATH_MAX_LENGTH * sizeof(char));
|
|
|
|
char *app_path = (char*)malloc(PATH_MAX_LENGTH * sizeof(char));
|
2016-08-29 17:10:00 +00:00
|
|
|
config_file_t *conf = NULL;
|
2015-01-13 23:35:27 +00:00
|
|
|
|
2018-01-04 15:55:28 +00:00
|
|
|
(void)has_application_data;
|
2019-07-17 18:20:39 +00:00
|
|
|
(void)path_size;
|
2018-01-04 15:55:28 +00:00
|
|
|
|
2016-10-15 23:25:31 +00:00
|
|
|
application_data[0] = conf_path[0] = app_path[0] = '\0';
|
|
|
|
|
2018-12-28 11:41:38 +00:00
|
|
|
#if defined(_WIN32) && !defined(_XBOX)
|
2019-01-02 12:30:58 +00:00
|
|
|
#if defined(__WINRT__) || defined(WINAPI_FAMILY) && WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP
|
2018-12-28 11:41:38 +00:00
|
|
|
/* On UWP, the app install directory is not writable so use the writable LocalState dir instead */
|
|
|
|
fill_pathname_home_dir(app_path, path_size);
|
|
|
|
#else
|
|
|
|
fill_pathname_application_dir(app_path, path_size);
|
|
|
|
#endif
|
2016-08-29 17:10:00 +00:00
|
|
|
fill_pathname_resolve_relative(conf_path, app_path,
|
2017-09-09 19:35:09 +00:00
|
|
|
file_path_str(FILE_PATH_MAIN_CONFIG), path_size);
|
2015-01-11 04:29:32 +00:00
|
|
|
|
2019-07-18 14:15:02 +00:00
|
|
|
conf = config_file_new_from_path_to_string(conf_path);
|
2015-01-11 04:29:32 +00:00
|
|
|
|
2016-08-29 17:10:00 +00:00
|
|
|
if (!conf)
|
|
|
|
{
|
|
|
|
if (fill_pathname_application_data(application_data,
|
2017-09-09 19:35:09 +00:00
|
|
|
path_size))
|
2016-08-29 17:10:00 +00:00
|
|
|
{
|
|
|
|
fill_pathname_join(conf_path, application_data,
|
2017-09-09 19:35:09 +00:00
|
|
|
file_path_str(FILE_PATH_MAIN_CONFIG), path_size);
|
2019-07-18 14:15:02 +00:00
|
|
|
conf = config_file_new_from_path_to_string(conf_path);
|
2016-08-29 17:10:00 +00:00
|
|
|
}
|
2015-01-11 04:29:32 +00:00
|
|
|
}
|
|
|
|
|
2016-08-29 17:10:00 +00:00
|
|
|
if (!conf)
|
|
|
|
{
|
|
|
|
bool saved = false;
|
2015-01-13 23:35:27 +00:00
|
|
|
|
2016-08-29 17:10:00 +00:00
|
|
|
/* Try to create a new config file. */
|
2019-07-17 17:50:32 +00:00
|
|
|
conf = config_file_new_alloc();
|
2012-02-29 18:25:54 +00:00
|
|
|
|
2016-08-29 17:10:00 +00:00
|
|
|
if (conf)
|
|
|
|
{
|
|
|
|
/* Since this is a clean config file, we can
|
|
|
|
* safely use config_save_on_exit. */
|
|
|
|
fill_pathname_resolve_relative(conf_path, app_path,
|
2017-09-09 19:35:09 +00:00
|
|
|
file_path_str(FILE_PATH_MAIN_CONFIG), path_size);
|
2016-08-29 17:10:00 +00:00
|
|
|
config_set_bool(conf, "config_save_on_exit", true);
|
2019-01-03 17:34:00 +00:00
|
|
|
saved = config_file_write(conf, conf_path, true);
|
2016-08-29 17:10:00 +00:00
|
|
|
}
|
2014-10-22 01:22:08 +00:00
|
|
|
|
2016-08-29 17:10:00 +00:00
|
|
|
if (!saved)
|
|
|
|
{
|
|
|
|
/* WARN here to make sure user has a good chance of seeing it. */
|
|
|
|
RARCH_ERR("Failed to create new config file in: \"%s\".\n",
|
|
|
|
conf_path);
|
2017-09-09 19:35:09 +00:00
|
|
|
goto error;
|
2016-08-29 17:10:00 +00:00
|
|
|
}
|
2015-01-13 23:35:27 +00:00
|
|
|
|
2016-08-29 17:10:00 +00:00
|
|
|
RARCH_WARN("Created new config file in: \"%s\".\n", conf_path);
|
2014-10-22 01:22:08 +00:00
|
|
|
}
|
2016-08-29 17:10:00 +00:00
|
|
|
#elif defined(OSX)
|
|
|
|
if (!fill_pathname_application_data(application_data,
|
2017-09-09 19:35:09 +00:00
|
|
|
path_size))
|
|
|
|
goto error;
|
2015-11-21 17:08:37 +00:00
|
|
|
|
2016-12-19 22:17:36 +00:00
|
|
|
/* Group config file with menu configs, remaps, etc: */
|
2017-09-09 19:35:09 +00:00
|
|
|
strlcat(application_data, "/config", path_size);
|
2015-11-21 17:08:37 +00:00
|
|
|
|
2016-08-29 17:10:00 +00:00
|
|
|
path_mkdir(application_data);
|
2015-11-21 17:08:37 +00:00
|
|
|
|
2016-08-29 17:10:00 +00:00
|
|
|
fill_pathname_join(conf_path, application_data,
|
2017-09-09 19:35:09 +00:00
|
|
|
file_path_str(FILE_PATH_MAIN_CONFIG), path_size);
|
2019-07-18 14:15:02 +00:00
|
|
|
conf = config_file_new_from_path_to_string(conf_path);
|
2016-08-29 14:57:33 +00:00
|
|
|
|
2016-08-29 17:10:00 +00:00
|
|
|
if (!conf)
|
|
|
|
{
|
|
|
|
bool saved = false;
|
2019-07-17 17:50:32 +00:00
|
|
|
conf = config_file_new_alloc();
|
2016-08-29 17:10:00 +00:00
|
|
|
|
|
|
|
if (conf)
|
|
|
|
{
|
|
|
|
config_set_bool(conf, "config_save_on_exit", true);
|
2019-01-03 17:34:00 +00:00
|
|
|
saved = config_file_write(conf, conf_path, true);
|
2016-08-29 17:10:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!saved)
|
|
|
|
{
|
|
|
|
/* WARN here to make sure user has a good chance of seeing it. */
|
|
|
|
RARCH_ERR("Failed to create new config file in: \"%s\".\n",
|
|
|
|
conf_path);
|
2017-09-09 19:35:09 +00:00
|
|
|
goto error;
|
2016-08-29 17:10:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
RARCH_WARN("Created new config file in: \"%s\".\n", conf_path);
|
|
|
|
}
|
|
|
|
#elif !defined(RARCH_CONSOLE)
|
C89_BUILD: Fix some clang compiler errors.
Fixes these two compile errors with C89_BUILD=1
configuration.c:2028:9: error: ISO C90 forbids mixing declarations and code [-Werror,-Wdeclaration-after-statement]
bool has_application_data =
^
1 error generated.
make: *** [Makefile:164: obj-unix/configuration.o] Error 1
In file included from menu/widgets/menu_osk.c:42:
menu/widgets/menu_osk_utf8_pages.h:62:94: error: no newline at end of file [-Werror,-Wnewline-eof]
"ヤ","ユ","ヨ","ワ","ヲ","ァ","ィ","ゥ","ェ","ォ","⊕"};
^
1 error generated.
make: *** [Makefile:163: obj-unix/menu/widgets/menu_osk.o] Error 1
2018-01-03 11:22:25 +00:00
|
|
|
has_application_data =
|
2016-08-30 02:42:02 +00:00
|
|
|
fill_pathname_application_data(application_data,
|
2017-09-09 19:35:09 +00:00
|
|
|
path_size);
|
2016-08-29 17:10:00 +00:00
|
|
|
|
|
|
|
if (has_application_data)
|
|
|
|
{
|
|
|
|
fill_pathname_join(conf_path, application_data,
|
2017-09-09 19:35:09 +00:00
|
|
|
file_path_str(FILE_PATH_MAIN_CONFIG), path_size);
|
2016-08-29 17:10:00 +00:00
|
|
|
RARCH_LOG("Looking for config in: \"%s\".\n", conf_path);
|
2019-07-18 14:15:02 +00:00
|
|
|
conf = config_file_new_from_path_to_string(conf_path);
|
2016-08-29 17:10:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Fallback to $HOME/.retroarch.cfg. */
|
|
|
|
if (!conf && getenv("HOME"))
|
|
|
|
{
|
|
|
|
fill_pathname_join(conf_path, getenv("HOME"),
|
2017-09-09 19:35:09 +00:00
|
|
|
".retroarch.cfg", path_size);
|
2016-08-29 17:10:00 +00:00
|
|
|
RARCH_LOG("Looking for config in: \"%s\".\n", conf_path);
|
2019-07-18 14:15:02 +00:00
|
|
|
conf = config_file_new_from_path_to_string(conf_path);
|
2016-08-29 17:10:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!conf && has_application_data)
|
|
|
|
{
|
2019-07-17 18:20:39 +00:00
|
|
|
bool dir_created = false;
|
|
|
|
char *basedir = (char*)malloc(PATH_MAX_LENGTH * sizeof(char));
|
2016-10-15 23:25:31 +00:00
|
|
|
|
2019-07-17 18:20:39 +00:00
|
|
|
basedir[0] = '\0';
|
2016-08-29 17:10:00 +00:00
|
|
|
|
|
|
|
/* Try to create a new config file. */
|
|
|
|
|
2017-09-09 19:35:09 +00:00
|
|
|
strlcpy(conf_path, application_data, path_size);
|
2016-08-29 17:10:00 +00:00
|
|
|
|
2017-09-09 19:35:09 +00:00
|
|
|
fill_pathname_basedir(basedir, conf_path, path_size);
|
2016-08-29 17:10:00 +00:00
|
|
|
|
2016-08-30 02:42:02 +00:00
|
|
|
fill_pathname_join(conf_path, conf_path,
|
2017-09-09 19:35:09 +00:00
|
|
|
file_path_str(FILE_PATH_MAIN_CONFIG), path_size);
|
2016-08-29 17:10:00 +00:00
|
|
|
|
2019-07-17 18:20:39 +00:00
|
|
|
dir_created = path_mkdir(basedir);
|
|
|
|
free(basedir);
|
|
|
|
|
|
|
|
if (dir_created)
|
2016-08-29 17:10:00 +00:00
|
|
|
{
|
2017-09-09 19:35:09 +00:00
|
|
|
char *skeleton_conf = (char*)malloc(PATH_MAX_LENGTH * sizeof(char));
|
|
|
|
bool saved = false;
|
2016-10-15 23:25:31 +00:00
|
|
|
|
|
|
|
skeleton_conf[0] = '\0';
|
2016-08-29 17:10:00 +00:00
|
|
|
|
2019-07-17 18:20:39 +00:00
|
|
|
/* Build a retroarch.cfg path from the
|
|
|
|
* global config directory (/etc). */
|
2017-06-21 23:28:40 +00:00
|
|
|
fill_pathname_join(skeleton_conf, GLOBAL_CONFIG_DIR,
|
2017-09-09 19:35:09 +00:00
|
|
|
file_path_str(FILE_PATH_MAIN_CONFIG), path_size);
|
2017-06-21 23:28:40 +00:00
|
|
|
|
2019-07-18 14:15:02 +00:00
|
|
|
conf = config_file_new_from_path_to_string(skeleton_conf);
|
2016-08-29 17:10:00 +00:00
|
|
|
if (conf)
|
|
|
|
RARCH_WARN("Config: using skeleton config \"%s\" as base for a new config file.\n", skeleton_conf);
|
|
|
|
else
|
2019-07-17 17:50:32 +00:00
|
|
|
conf = config_file_new_alloc();
|
2016-08-29 17:10:00 +00:00
|
|
|
|
2017-09-09 19:35:09 +00:00
|
|
|
free(skeleton_conf);
|
|
|
|
|
2016-08-29 17:10:00 +00:00
|
|
|
if (conf)
|
|
|
|
{
|
2019-07-17 18:20:39 +00:00
|
|
|
/* Since this is a clean config file, we can
|
|
|
|
* safely use config_save_on_exit. */
|
2016-08-29 17:10:00 +00:00
|
|
|
config_set_bool(conf, "config_save_on_exit", true);
|
2019-01-03 17:34:00 +00:00
|
|
|
saved = config_file_write(conf, conf_path, true);
|
2016-08-29 17:10:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!saved)
|
|
|
|
{
|
|
|
|
/* WARN here to make sure user has a good chance of seeing it. */
|
|
|
|
RARCH_ERR("Failed to create new config file in: \"%s\".\n", conf_path);
|
2017-09-09 19:35:09 +00:00
|
|
|
goto error;
|
2016-08-29 17:10:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
RARCH_WARN("Config: Created new config file in: \"%s\".\n", conf_path);
|
|
|
|
}
|
|
|
|
}
|
2016-08-29 13:36:55 +00:00
|
|
|
#endif
|
2016-08-29 14:57:33 +00:00
|
|
|
|
2016-08-29 17:10:00 +00:00
|
|
|
(void)application_data;
|
|
|
|
(void)conf_path;
|
|
|
|
(void)app_path;
|
|
|
|
|
|
|
|
if (!conf)
|
2017-09-09 19:35:09 +00:00
|
|
|
goto error;
|
2016-08-29 17:10:00 +00:00
|
|
|
|
2016-09-29 05:46:21 +00:00
|
|
|
path_set(RARCH_PATH_CONFIG, conf_path);
|
2017-09-09 19:35:09 +00:00
|
|
|
free(application_data);
|
|
|
|
free(conf_path);
|
|
|
|
free(app_path);
|
2016-08-30 02:40:13 +00:00
|
|
|
|
2016-08-29 17:10:00 +00:00
|
|
|
return conf;
|
2017-09-09 19:35:09 +00:00
|
|
|
|
|
|
|
error:
|
|
|
|
if (conf)
|
|
|
|
config_file_free(conf);
|
|
|
|
free(application_data);
|
|
|
|
free(conf_path);
|
|
|
|
free(app_path);
|
|
|
|
return NULL;
|
2016-08-29 13:36:55 +00:00
|
|
|
}
|
|
|
|
|
2018-10-06 15:48:12 +00:00
|
|
|
#if defined(HAVE_MENU) && defined(HAVE_RGUI)
|
|
|
|
static bool check_menu_driver_compatibility(void)
|
|
|
|
{
|
2019-04-29 02:04:33 +00:00
|
|
|
settings_t *settings = config_get_ptr();
|
|
|
|
char *video_driver = settings->arrays.video_driver;
|
|
|
|
char *menu_driver = settings->arrays.menu_driver;
|
|
|
|
|
|
|
|
if (string_is_equal (menu_driver, "rgui") ||
|
|
|
|
string_is_equal(menu_driver, "null") ||
|
|
|
|
string_is_equal(video_driver, "null"))
|
2018-10-06 15:48:12 +00:00
|
|
|
return true;
|
|
|
|
|
2018-10-08 23:15:47 +00:00
|
|
|
/* TODO/FIXME - maintenance hazard */
|
2019-04-29 02:04:33 +00:00
|
|
|
if (string_is_equal(video_driver, "d3d9") ||
|
|
|
|
string_is_equal(video_driver, "d3d10") ||
|
|
|
|
string_is_equal(video_driver, "d3d11") ||
|
|
|
|
string_is_equal(video_driver, "d3d12") ||
|
2019-06-14 15:09:39 +00:00
|
|
|
string_is_equal(video_driver, "caca") ||
|
2019-04-29 02:04:33 +00:00
|
|
|
string_is_equal(video_driver, "gdi") ||
|
|
|
|
string_is_equal(video_driver, "gl") ||
|
|
|
|
string_is_equal(video_driver, "gl1") ||
|
|
|
|
string_is_equal(video_driver, "gx2") ||
|
|
|
|
string_is_equal(video_driver, "vulkan") ||
|
|
|
|
string_is_equal(video_driver, "glcore") ||
|
|
|
|
string_is_equal(video_driver, "metal") ||
|
|
|
|
string_is_equal(video_driver, "ctr") ||
|
|
|
|
string_is_equal(video_driver, "vita2d"))
|
2019-02-03 23:49:35 +00:00
|
|
|
return true;
|
2018-10-06 15:48:12 +00:00
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2015-01-08 18:11:05 +00:00
|
|
|
/**
|
|
|
|
* config_load:
|
|
|
|
* @path : path to be read from.
|
|
|
|
* @set_defaults : set default values first before
|
|
|
|
* reading the values from the config file
|
|
|
|
*
|
|
|
|
* Loads a config file and reads all the values into memory.
|
|
|
|
*
|
|
|
|
*/
|
2019-04-22 05:38:44 +00:00
|
|
|
static bool config_load_file(const char *path, settings_t *settings)
|
2011-01-19 11:54:19 +00:00
|
|
|
{
|
2013-10-22 13:08:17 +00:00
|
|
|
unsigned i;
|
2017-09-09 19:35:09 +00:00
|
|
|
size_t path_size = PATH_MAX_LENGTH * sizeof(char);
|
|
|
|
char *tmp_str = (char*)malloc(PATH_MAX_LENGTH * sizeof(char));
|
2016-09-20 14:32:33 +00:00
|
|
|
bool ret = false;
|
2019-08-19 23:34:40 +00:00
|
|
|
unsigned tmp_uint = 0;
|
2016-08-29 13:26:42 +00:00
|
|
|
bool tmp_bool = false;
|
|
|
|
unsigned msg_color = 0;
|
2019-04-22 05:38:44 +00:00
|
|
|
char *save = NULL;
|
2016-09-03 06:12:40 +00:00
|
|
|
char *override_username = NULL;
|
2017-11-24 05:45:21 +00:00
|
|
|
const char *path_core = NULL;
|
|
|
|
const char *path_config = NULL;
|
2017-04-28 22:43:20 +00:00
|
|
|
int bool_settings_size = sizeof(settings->bools) / sizeof(settings->bools.placeholder);
|
2017-04-28 13:01:11 +00:00
|
|
|
int float_settings_size = sizeof(settings->floats) / sizeof(settings->floats.placeholder);
|
2017-04-28 18:08:12 +00:00
|
|
|
int int_settings_size = sizeof(settings->ints) / sizeof(settings->ints.placeholder);
|
2017-04-28 22:43:20 +00:00
|
|
|
int uint_settings_size = sizeof(settings->uints) / sizeof(settings->uints.placeholder);
|
2018-07-13 20:12:09 +00:00
|
|
|
int size_settings_size = sizeof(settings->sizes) / sizeof(settings->sizes.placeholder);
|
2017-04-28 22:43:20 +00:00
|
|
|
int array_settings_size = sizeof(settings->arrays) / sizeof(settings->arrays.placeholder);
|
|
|
|
int path_settings_size = sizeof(settings->paths) / sizeof(settings->paths.placeholder);
|
2016-12-26 03:14:09 +00:00
|
|
|
struct config_bool_setting *bool_settings = populate_settings_bool (settings, &bool_settings_size);
|
|
|
|
struct config_float_setting *float_settings = populate_settings_float (settings, &float_settings_size);
|
|
|
|
struct config_int_setting *int_settings = populate_settings_int (settings, &int_settings_size);
|
2017-04-28 18:08:12 +00:00
|
|
|
struct config_uint_setting *uint_settings = populate_settings_uint (settings, &uint_settings_size);
|
2018-07-13 20:12:09 +00:00
|
|
|
struct config_size_setting *size_settings = populate_settings_size (settings, &size_settings_size);
|
2016-12-26 03:14:09 +00:00
|
|
|
struct config_array_setting *array_settings = populate_settings_array (settings, &array_settings_size);
|
|
|
|
struct config_path_setting *path_settings = populate_settings_path (settings, &path_settings_size);
|
2019-07-18 14:15:02 +00:00
|
|
|
config_file_t *conf = path ? config_file_new_from_path_to_string(path) : open_default_config_file();
|
2016-07-24 08:42:49 +00:00
|
|
|
|
2016-10-15 23:25:31 +00:00
|
|
|
tmp_str[0] = '\0';
|
|
|
|
|
2014-10-01 14:08:07 +00:00
|
|
|
if (!conf)
|
2016-09-20 14:32:33 +00:00
|
|
|
{
|
2019-04-22 05:38:44 +00:00
|
|
|
if (!path)
|
|
|
|
ret = true;
|
2016-09-20 14:10:27 +00:00
|
|
|
goto end;
|
2016-09-20 14:32:33 +00:00
|
|
|
}
|
2010-12-29 18:00:21 +00:00
|
|
|
|
2016-09-30 02:43:16 +00:00
|
|
|
if (!path_is_empty(RARCH_PATH_CONFIG_APPEND))
|
2012-09-10 22:10:44 +00:00
|
|
|
{
|
2016-09-17 12:14:58 +00:00
|
|
|
/* Don't destroy append_config_path, store in temporary
|
|
|
|
* variable. */
|
2017-09-09 19:35:09 +00:00
|
|
|
char *tmp_append_path = (char*)malloc(PATH_MAX_LENGTH * sizeof(char));
|
|
|
|
const char *extra_path = NULL;
|
2016-09-17 12:14:58 +00:00
|
|
|
|
2016-10-09 07:05:41 +00:00
|
|
|
tmp_append_path[0] = '\0';
|
|
|
|
|
2016-09-29 06:31:41 +00:00
|
|
|
strlcpy(tmp_append_path, path_get(RARCH_PATH_CONFIG_APPEND),
|
2017-09-09 19:35:09 +00:00
|
|
|
path_size);
|
2016-09-17 12:14:58 +00:00
|
|
|
extra_path = strtok_r(tmp_append_path, "|", &save);
|
2015-09-28 16:12:02 +00:00
|
|
|
|
2016-09-17 12:14:58 +00:00
|
|
|
while (extra_path)
|
|
|
|
{
|
2019-01-10 21:24:43 +00:00
|
|
|
bool result = config_append_file(conf, extra_path);
|
2015-09-28 16:12:02 +00:00
|
|
|
|
2016-09-17 12:14:58 +00:00
|
|
|
RARCH_LOG("Config: appending config \"%s\"\n", extra_path);
|
|
|
|
|
2019-01-10 21:24:43 +00:00
|
|
|
if (!result)
|
2016-09-17 12:14:58 +00:00
|
|
|
RARCH_ERR("Config: failed to append config \"%s\"\n", extra_path);
|
|
|
|
extra_path = strtok_r(NULL, "|", &save);
|
|
|
|
}
|
2017-09-09 23:03:26 +00:00
|
|
|
|
|
|
|
free(tmp_append_path);
|
2012-09-10 22:10:44 +00:00
|
|
|
}
|
2016-09-17 12:14:58 +00:00
|
|
|
|
2015-04-15 20:31:24 +00:00
|
|
|
#if 0
|
2016-05-31 02:42:04 +00:00
|
|
|
if (verbosity_is_enabled())
|
2011-10-17 17:11:31 +00:00
|
|
|
{
|
2012-10-16 11:57:35 +00:00
|
|
|
RARCH_LOG_OUTPUT("=== Config ===\n");
|
2014-06-11 12:19:34 +00:00
|
|
|
config_file_dump_all(conf);
|
2012-10-16 11:57:35 +00:00
|
|
|
RARCH_LOG_OUTPUT("=== Config end ===\n");
|
2011-10-17 17:11:31 +00:00
|
|
|
}
|
2015-04-15 20:31:24 +00:00
|
|
|
#endif
|
2010-12-29 18:00:21 +00:00
|
|
|
|
2016-09-03 06:12:40 +00:00
|
|
|
/* Overrides */
|
|
|
|
|
|
|
|
if (rarch_ctl(RARCH_CTL_HAS_SET_USERNAME, NULL))
|
2017-04-28 22:39:29 +00:00
|
|
|
override_username = strdup(settings->paths.username);
|
2016-09-03 06:12:40 +00:00
|
|
|
|
2016-08-29 13:26:42 +00:00
|
|
|
/* Boolean settings */
|
2016-07-25 06:01:47 +00:00
|
|
|
|
2016-09-05 16:45:48 +00:00
|
|
|
for (i = 0; i < (unsigned)bool_settings_size; i++)
|
2016-07-24 07:43:16 +00:00
|
|
|
{
|
|
|
|
bool tmp = false;
|
|
|
|
if (config_get_bool(conf, bool_settings[i].ident, &tmp))
|
2016-07-25 09:08:23 +00:00
|
|
|
*bool_settings[i].ptr = tmp;
|
2016-07-24 07:43:16 +00:00
|
|
|
}
|
2016-09-17 12:14:58 +00:00
|
|
|
|
2016-07-25 06:01:47 +00:00
|
|
|
#ifdef HAVE_NETWORKGAMEPAD
|
|
|
|
for (i = 0; i < MAX_USERS; i++)
|
|
|
|
{
|
2016-10-09 07:05:41 +00:00
|
|
|
char tmp[64];
|
|
|
|
|
|
|
|
tmp[0] = '\0';
|
2016-07-25 06:01:47 +00:00
|
|
|
|
|
|
|
snprintf(tmp, sizeof(tmp), "network_remote_enable_user_p%u", i + 1);
|
|
|
|
|
|
|
|
if (config_get_bool(conf, tmp, &tmp_bool))
|
2017-04-28 11:43:47 +00:00
|
|
|
settings->bools.network_remote_enable_user[i] = tmp_bool;
|
2016-07-25 06:01:47 +00:00
|
|
|
}
|
|
|
|
#endif
|
2018-03-09 22:23:34 +00:00
|
|
|
if (config_get_bool(conf, "log_verbosity", &tmp_bool))
|
2016-07-25 06:01:47 +00:00
|
|
|
{
|
2018-03-09 22:23:34 +00:00
|
|
|
if (tmp_bool)
|
|
|
|
verbosity_enable();
|
|
|
|
else
|
|
|
|
verbosity_disable();
|
2016-07-25 06:01:47 +00:00
|
|
|
}
|
2019-08-19 23:34:40 +00:00
|
|
|
if (config_get_uint(conf, "frontend_log_level", &tmp_uint))
|
2016-07-25 06:01:47 +00:00
|
|
|
{
|
2019-08-19 23:34:40 +00:00
|
|
|
verbosity_set_log_level(tmp_uint);
|
2016-07-25 06:01:47 +00:00
|
|
|
}
|
|
|
|
|
2016-08-29 13:26:42 +00:00
|
|
|
/* Integer settings */
|
2016-07-24 07:43:16 +00:00
|
|
|
|
2016-09-05 16:45:48 +00:00
|
|
|
for (i = 0; i < (unsigned)int_settings_size; i++)
|
2016-07-24 07:43:16 +00:00
|
|
|
{
|
|
|
|
int tmp = 0;
|
|
|
|
if (config_get_int(conf, int_settings[i].ident, &tmp))
|
2016-07-25 09:08:23 +00:00
|
|
|
*int_settings[i].ptr = tmp;
|
2016-07-24 07:43:16 +00:00
|
|
|
}
|
|
|
|
|
2017-04-28 17:55:09 +00:00
|
|
|
for (i = 0; i < (unsigned)uint_settings_size; i++)
|
|
|
|
{
|
|
|
|
int tmp = 0;
|
|
|
|
if (config_get_int(conf, uint_settings[i].ident, &tmp))
|
|
|
|
*uint_settings[i].ptr = tmp;
|
|
|
|
}
|
|
|
|
|
2018-07-13 20:12:09 +00:00
|
|
|
for (i = 0; i < (unsigned)size_settings_size; i++)
|
|
|
|
{
|
|
|
|
size_t tmp = 0;
|
|
|
|
if (config_get_size_t(conf, size_settings[i].ident, &tmp))
|
|
|
|
*size_settings[i].ptr = tmp ;
|
|
|
|
/* Special case for rewind_buffer_size - need to convert low values to what they were
|
|
|
|
* intended to be based on the default value in config.def.h
|
|
|
|
* If the value is less than 10000 then multiple by 1MB because if the retroarch.cfg
|
|
|
|
* file contains rewind_buffer_size = "100" then that ultimately gets interpreted as
|
|
|
|
* 100MB, so ensure the internal values represent that.*/
|
2018-08-06 04:59:50 +00:00
|
|
|
if (string_is_equal(size_settings[i].ident, "rewind_buffer_size"))
|
|
|
|
if (*size_settings[i].ptr < 10000)
|
|
|
|
*size_settings[i].ptr = *size_settings[i].ptr * 1024 * 1024;
|
2018-07-13 20:12:09 +00:00
|
|
|
}
|
|
|
|
|
2015-01-05 00:58:00 +00:00
|
|
|
for (i = 0; i < MAX_USERS; i++)
|
2012-02-02 20:02:36 +00:00
|
|
|
{
|
2016-10-09 07:05:41 +00:00
|
|
|
char buf[64];
|
|
|
|
|
|
|
|
buf[0] = '\0';
|
|
|
|
|
2012-02-18 11:09:20 +00:00
|
|
|
snprintf(buf, sizeof(buf), "input_player%u_joypad_index", i + 1);
|
2017-04-28 19:03:04 +00:00
|
|
|
CONFIG_GET_INT_BASE(conf, settings, uints.input_joypad_map[i], buf);
|
2013-09-22 09:08:09 +00:00
|
|
|
|
2014-01-08 16:31:14 +00:00
|
|
|
snprintf(buf, sizeof(buf), "input_player%u_analog_dpad_mode", i + 1);
|
2017-04-28 19:03:04 +00:00
|
|
|
CONFIG_GET_INT_BASE(conf, settings, uints.input_analog_dpad_mode[i], buf);
|
2014-01-08 16:31:14 +00:00
|
|
|
|
2017-06-08 14:13:45 +00:00
|
|
|
snprintf(buf, sizeof(buf), "input_player%u_mouse_index", i + 1);
|
|
|
|
CONFIG_GET_INT_BASE(conf, settings, uints.input_mouse_index[i], buf);
|
|
|
|
|
2018-03-09 22:23:34 +00:00
|
|
|
snprintf(buf, sizeof(buf), "input_libretro_device_p%u", i + 1);
|
|
|
|
CONFIG_GET_INT_BASE(conf, settings, uints.input_libretro_device[i], buf);
|
2012-02-02 20:02:36 +00:00
|
|
|
}
|
2017-12-27 16:05:12 +00:00
|
|
|
|
|
|
|
/* LED map for use by the led driver */
|
|
|
|
for (i = 0; i < MAX_LEDS; i++)
|
|
|
|
{
|
|
|
|
char buf[64];
|
|
|
|
|
|
|
|
buf[0] = '\0';
|
|
|
|
|
|
|
|
snprintf(buf, sizeof(buf), "led%u_map", i + 1);
|
2018-01-04 17:45:01 +00:00
|
|
|
settings->uints.led_map[i]=-1;
|
2017-12-27 16:05:12 +00:00
|
|
|
CONFIG_GET_INT_BASE(conf, settings, uints.led_map[i], buf);
|
|
|
|
}
|
2017-12-27 21:21:56 +00:00
|
|
|
|
2016-08-29 13:26:42 +00:00
|
|
|
/* Hexadecimal settings */
|
2016-07-24 06:52:03 +00:00
|
|
|
|
|
|
|
if (config_get_hex(conf, "video_message_color", &msg_color))
|
|
|
|
{
|
2017-04-28 12:57:55 +00:00
|
|
|
settings->floats.video_msg_color_r = ((msg_color >> 16) & 0xff) / 255.0f;
|
|
|
|
settings->floats.video_msg_color_g = ((msg_color >> 8) & 0xff) / 255.0f;
|
|
|
|
settings->floats.video_msg_color_b = ((msg_color >> 0) & 0xff) / 255.0f;
|
2016-07-24 06:52:03 +00:00
|
|
|
}
|
|
|
|
|
2016-08-29 13:26:42 +00:00
|
|
|
/* Float settings */
|
2016-09-05 16:45:48 +00:00
|
|
|
for (i = 0; i < (unsigned)float_settings_size; i++)
|
2016-07-24 08:42:49 +00:00
|
|
|
{
|
|
|
|
float tmp = 0.0f;
|
|
|
|
if (config_get_float(conf, float_settings[i].ident, &tmp))
|
2016-07-25 09:08:23 +00:00
|
|
|
*float_settings[i].ptr = tmp;
|
2016-07-24 08:42:49 +00:00
|
|
|
}
|
2015-01-13 02:13:19 +00:00
|
|
|
|
2016-08-29 13:26:42 +00:00
|
|
|
/* Array settings */
|
2016-09-05 16:45:48 +00:00
|
|
|
for (i = 0; i < (unsigned)array_settings_size; i++)
|
2016-09-01 00:40:05 +00:00
|
|
|
{
|
2016-09-01 02:40:02 +00:00
|
|
|
if (!array_settings[i].handle)
|
|
|
|
continue;
|
|
|
|
config_get_array(conf, array_settings[i].ident,
|
2016-09-01 03:52:38 +00:00
|
|
|
array_settings[i].ptr, PATH_MAX_LENGTH);
|
2016-09-01 00:40:05 +00:00
|
|
|
}
|
|
|
|
|
2016-08-29 13:26:42 +00:00
|
|
|
/* Path settings */
|
2016-09-05 16:45:48 +00:00
|
|
|
for (i = 0; i < (unsigned)path_settings_size; i++)
|
2016-09-01 02:37:22 +00:00
|
|
|
{
|
|
|
|
if (!path_settings[i].handle)
|
|
|
|
continue;
|
2017-09-09 19:35:09 +00:00
|
|
|
if (config_get_path(conf, path_settings[i].ident, tmp_str, path_size))
|
2016-09-01 03:24:47 +00:00
|
|
|
strlcpy(path_settings[i].ptr, tmp_str, PATH_MAX_LENGTH);
|
2016-09-01 02:37:22 +00:00
|
|
|
}
|
2016-06-25 05:12:37 +00:00
|
|
|
|
2018-03-09 22:23:34 +00:00
|
|
|
if (config_get_path(conf, "libretro_directory", tmp_str, path_size))
|
|
|
|
strlcpy(settings->paths.directory_libretro, tmp_str, sizeof(settings->paths.directory_libretro));
|
2016-08-01 19:51:23 +00:00
|
|
|
|
2016-07-24 06:52:03 +00:00
|
|
|
#ifndef HAVE_DYNAMIC
|
2017-09-09 19:35:09 +00:00
|
|
|
if (config_get_path(conf, "libretro_path", tmp_str, path_size))
|
2016-09-29 05:46:21 +00:00
|
|
|
path_set(RARCH_PATH_CORE, tmp_str);
|
2016-07-24 06:52:03 +00:00
|
|
|
#endif
|
2016-09-01 02:37:22 +00:00
|
|
|
|
2016-09-03 06:12:40 +00:00
|
|
|
#ifdef RARCH_CONSOLE
|
|
|
|
video_driver_load_settings(conf);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/* Post-settings load */
|
|
|
|
|
|
|
|
if (rarch_ctl(RARCH_CTL_HAS_SET_USERNAME, NULL) && override_username)
|
2016-07-24 06:52:03 +00:00
|
|
|
{
|
2017-04-28 22:39:29 +00:00
|
|
|
strlcpy(settings->paths.username,
|
|
|
|
override_username,
|
|
|
|
sizeof(settings->paths.username));
|
2016-09-03 06:12:40 +00:00
|
|
|
free(override_username);
|
2016-07-24 06:52:03 +00:00
|
|
|
}
|
2016-09-03 06:12:40 +00:00
|
|
|
|
2017-04-28 19:03:04 +00:00
|
|
|
if (settings->uints.video_hard_sync_frames > 3)
|
|
|
|
settings->uints.video_hard_sync_frames = 3;
|
2016-07-24 06:52:03 +00:00
|
|
|
|
2017-04-28 19:03:04 +00:00
|
|
|
if (settings->uints.video_frame_delay > 15)
|
|
|
|
settings->uints.video_frame_delay = 15;
|
2016-07-24 06:52:03 +00:00
|
|
|
|
2017-04-28 19:03:04 +00:00
|
|
|
settings->uints.video_swap_interval = MAX(settings->uints.video_swap_interval, 1);
|
|
|
|
settings->uints.video_swap_interval = MIN(settings->uints.video_swap_interval, 4);
|
2016-07-24 06:52:03 +00:00
|
|
|
|
2017-06-08 20:24:51 +00:00
|
|
|
audio_set_float(AUDIO_ACTION_VOLUME_GAIN, settings->floats.audio_volume);
|
2019-07-11 09:51:06 +00:00
|
|
|
#ifdef HAVE_AUDIOMIXER
|
2017-06-08 20:58:43 +00:00
|
|
|
audio_set_float(AUDIO_ACTION_MIXER_VOLUME_GAIN, settings->floats.audio_mixer_volume);
|
2019-07-11 09:51:06 +00:00
|
|
|
#endif
|
2016-07-24 06:52:03 +00:00
|
|
|
|
2017-11-24 05:45:21 +00:00
|
|
|
path_config = path_get(RARCH_PATH_CONFIG);
|
|
|
|
path_core = path_get(RARCH_PATH_CORE);
|
|
|
|
|
2017-04-28 22:39:29 +00:00
|
|
|
if (string_is_empty(settings->paths.path_content_history))
|
2016-04-28 18:49:13 +00:00
|
|
|
{
|
2017-04-28 22:39:29 +00:00
|
|
|
if (string_is_empty(settings->paths.directory_content_history))
|
2016-04-28 18:49:13 +00:00
|
|
|
fill_pathname_resolve_relative(
|
2017-04-28 22:39:29 +00:00
|
|
|
settings->paths.path_content_history,
|
2017-11-24 05:45:21 +00:00
|
|
|
path_config,
|
2016-06-20 03:11:01 +00:00
|
|
|
file_path_str(FILE_PATH_CONTENT_HISTORY),
|
2017-04-28 22:39:29 +00:00
|
|
|
sizeof(settings->paths.path_content_history));
|
2016-04-28 18:49:13 +00:00
|
|
|
else
|
2017-04-28 22:39:29 +00:00
|
|
|
fill_pathname_join(settings->paths.path_content_history,
|
|
|
|
settings->paths.directory_content_history,
|
2016-06-20 03:11:01 +00:00
|
|
|
file_path_str(FILE_PATH_CONTENT_HISTORY),
|
2017-04-28 22:39:29 +00:00
|
|
|
sizeof(settings->paths.path_content_history));
|
2016-04-28 18:49:13 +00:00
|
|
|
}
|
|
|
|
|
2017-08-12 15:10:14 +00:00
|
|
|
if (string_is_empty(settings->paths.path_content_favorites))
|
|
|
|
{
|
|
|
|
if (string_is_empty(settings->paths.directory_content_history))
|
|
|
|
fill_pathname_resolve_relative(
|
|
|
|
settings->paths.path_content_favorites,
|
2017-11-24 05:45:21 +00:00
|
|
|
path_config,
|
2017-08-12 15:10:14 +00:00
|
|
|
file_path_str(FILE_PATH_CONTENT_FAVORITES),
|
|
|
|
sizeof(settings->paths.path_content_favorites));
|
|
|
|
else
|
|
|
|
fill_pathname_join(settings->paths.path_content_favorites,
|
|
|
|
settings->paths.directory_content_history,
|
|
|
|
file_path_str(FILE_PATH_CONTENT_FAVORITES),
|
|
|
|
sizeof(settings->paths.path_content_favorites));
|
|
|
|
}
|
|
|
|
|
2017-04-28 22:39:29 +00:00
|
|
|
if (string_is_empty(settings->paths.path_content_music_history))
|
2016-07-30 20:32:52 +00:00
|
|
|
{
|
2017-04-28 22:39:29 +00:00
|
|
|
if (string_is_empty(settings->paths.directory_content_history))
|
2016-07-30 20:32:52 +00:00
|
|
|
fill_pathname_resolve_relative(
|
2017-04-28 22:39:29 +00:00
|
|
|
settings->paths.path_content_music_history,
|
2017-11-24 05:45:21 +00:00
|
|
|
path_config,
|
2016-07-30 20:32:52 +00:00
|
|
|
file_path_str(FILE_PATH_CONTENT_MUSIC_HISTORY),
|
2017-04-28 22:39:29 +00:00
|
|
|
sizeof(settings->paths.path_content_music_history));
|
2016-07-30 20:32:52 +00:00
|
|
|
else
|
2017-04-28 22:39:29 +00:00
|
|
|
fill_pathname_join(settings->paths.path_content_music_history,
|
|
|
|
settings->paths.directory_content_history,
|
2016-07-30 20:32:52 +00:00
|
|
|
file_path_str(FILE_PATH_CONTENT_MUSIC_HISTORY),
|
2017-04-28 22:39:29 +00:00
|
|
|
sizeof(settings->paths.path_content_music_history));
|
2016-07-30 20:32:52 +00:00
|
|
|
}
|
2016-04-28 18:49:13 +00:00
|
|
|
|
2017-04-28 22:39:29 +00:00
|
|
|
if (string_is_empty(settings->paths.path_content_video_history))
|
2016-07-30 20:32:52 +00:00
|
|
|
{
|
2017-04-28 22:39:29 +00:00
|
|
|
if (string_is_empty(settings->paths.directory_content_history))
|
2016-07-30 20:32:52 +00:00
|
|
|
fill_pathname_resolve_relative(
|
2017-04-28 22:39:29 +00:00
|
|
|
settings->paths.path_content_video_history,
|
2017-11-24 05:45:21 +00:00
|
|
|
path_config,
|
2016-07-30 20:32:52 +00:00
|
|
|
file_path_str(FILE_PATH_CONTENT_VIDEO_HISTORY),
|
2017-04-28 22:39:29 +00:00
|
|
|
sizeof(settings->paths.path_content_video_history));
|
2016-07-30 20:32:52 +00:00
|
|
|
else
|
2017-04-28 22:39:29 +00:00
|
|
|
fill_pathname_join(settings->paths.path_content_video_history,
|
|
|
|
settings->paths.directory_content_history,
|
2016-07-30 20:32:52 +00:00
|
|
|
file_path_str(FILE_PATH_CONTENT_VIDEO_HISTORY),
|
2017-04-28 22:39:29 +00:00
|
|
|
sizeof(settings->paths.path_content_video_history));
|
2016-07-30 20:32:52 +00:00
|
|
|
}
|
|
|
|
|
2017-04-28 22:39:29 +00:00
|
|
|
if (string_is_empty(settings->paths.path_content_image_history))
|
2016-07-30 20:32:52 +00:00
|
|
|
{
|
2017-04-28 22:39:29 +00:00
|
|
|
if (string_is_empty(settings->paths.directory_content_history))
|
2016-07-30 20:32:52 +00:00
|
|
|
fill_pathname_resolve_relative(
|
2017-04-28 22:39:29 +00:00
|
|
|
settings->paths.path_content_image_history,
|
2017-11-24 05:45:21 +00:00
|
|
|
path_config,
|
2016-07-30 20:32:52 +00:00
|
|
|
file_path_str(FILE_PATH_CONTENT_IMAGE_HISTORY),
|
2017-04-28 22:39:29 +00:00
|
|
|
sizeof(settings->paths.path_content_image_history));
|
2016-07-30 20:32:52 +00:00
|
|
|
else
|
2017-04-28 22:39:29 +00:00
|
|
|
fill_pathname_join(settings->paths.path_content_image_history,
|
|
|
|
settings->paths.directory_content_history,
|
2016-07-30 20:32:52 +00:00
|
|
|
file_path_str(FILE_PATH_CONTENT_IMAGE_HISTORY),
|
2017-04-28 22:39:29 +00:00
|
|
|
sizeof(settings->paths.path_content_image_history));
|
2016-07-30 20:32:52 +00:00
|
|
|
}
|
2016-07-24 06:54:38 +00:00
|
|
|
|
2017-04-28 22:39:29 +00:00
|
|
|
if (!string_is_empty(settings->paths.directory_screenshot))
|
2011-08-24 13:47:39 +00:00
|
|
|
{
|
2018-01-16 21:53:38 +00:00
|
|
|
if (string_is_equal(settings->paths.directory_screenshot, "default"))
|
2017-04-28 22:39:29 +00:00
|
|
|
*settings->paths.directory_screenshot = '\0';
|
|
|
|
else if (!path_is_directory(settings->paths.directory_screenshot))
|
2013-09-16 21:30:42 +00:00
|
|
|
{
|
|
|
|
RARCH_WARN("screenshot_directory is not an existing directory, ignoring ...\n");
|
2017-04-28 22:39:29 +00:00
|
|
|
*settings->paths.directory_screenshot = '\0';
|
2013-09-16 21:30:42 +00:00
|
|
|
}
|
2011-08-24 13:47:39 +00:00
|
|
|
}
|
2016-04-28 18:49:13 +00:00
|
|
|
|
2017-10-01 05:17:45 +00:00
|
|
|
#ifdef RARCH_CONSOLE
|
2017-11-24 05:45:21 +00:00
|
|
|
if (!string_is_empty(path_core))
|
2016-04-28 18:49:13 +00:00
|
|
|
{
|
2017-10-01 05:17:45 +00:00
|
|
|
#endif
|
|
|
|
/* Safe-guard against older behavior. */
|
2017-11-24 05:45:21 +00:00
|
|
|
if (path_is_directory(path_core))
|
2017-10-01 05:17:45 +00:00
|
|
|
{
|
|
|
|
RARCH_WARN("\"libretro_path\" is a directory, using this for \"libretro_directory\" instead.\n");
|
2017-11-24 05:45:21 +00:00
|
|
|
strlcpy(settings->paths.directory_libretro, path_core,
|
2017-10-01 05:17:45 +00:00
|
|
|
sizeof(settings->paths.directory_libretro));
|
|
|
|
path_clear(RARCH_PATH_CORE);
|
|
|
|
}
|
|
|
|
#ifdef RARCH_CONSOLE
|
2016-04-28 18:49:13 +00:00
|
|
|
}
|
2017-10-01 05:17:45 +00:00
|
|
|
#endif
|
2011-01-31 17:06:57 +00:00
|
|
|
|
2018-01-16 21:53:38 +00:00
|
|
|
if (string_is_equal(settings->paths.path_menu_wallpaper, "default"))
|
2017-04-28 22:39:29 +00:00
|
|
|
*settings->paths.path_menu_wallpaper = '\0';
|
2019-01-29 17:03:44 +00:00
|
|
|
if (string_is_equal(settings->paths.path_rgui_theme_preset, "default"))
|
|
|
|
*settings->paths.path_rgui_theme_preset = '\0';
|
2018-01-16 21:53:38 +00:00
|
|
|
if (string_is_equal(settings->paths.directory_video_shader, "default"))
|
2017-04-28 22:39:29 +00:00
|
|
|
*settings->paths.directory_video_shader = '\0';
|
2018-01-16 21:53:38 +00:00
|
|
|
if (string_is_equal(settings->paths.directory_video_filter, "default"))
|
2017-04-28 22:39:29 +00:00
|
|
|
*settings->paths.directory_video_filter = '\0';
|
2018-01-16 21:53:38 +00:00
|
|
|
if (string_is_equal(settings->paths.directory_audio_filter, "default"))
|
2017-04-28 22:39:29 +00:00
|
|
|
*settings->paths.directory_audio_filter = '\0';
|
2018-01-16 21:53:38 +00:00
|
|
|
if (string_is_equal(settings->paths.directory_core_assets, "default"))
|
2017-04-28 22:39:29 +00:00
|
|
|
*settings->paths.directory_core_assets = '\0';
|
2018-01-16 21:53:38 +00:00
|
|
|
if (string_is_equal(settings->paths.directory_assets, "default"))
|
2017-04-28 22:39:29 +00:00
|
|
|
*settings->paths.directory_assets = '\0';
|
2018-01-16 21:53:38 +00:00
|
|
|
if (string_is_equal(settings->paths.directory_dynamic_wallpapers, "default"))
|
2017-04-28 22:39:29 +00:00
|
|
|
*settings->paths.directory_dynamic_wallpapers = '\0';
|
2018-01-16 21:53:38 +00:00
|
|
|
if (string_is_equal(settings->paths.directory_thumbnails, "default"))
|
2017-04-28 22:39:29 +00:00
|
|
|
*settings->paths.directory_thumbnails = '\0';
|
2018-01-16 21:53:38 +00:00
|
|
|
if (string_is_equal(settings->paths.directory_playlist, "default"))
|
2017-04-28 22:39:29 +00:00
|
|
|
*settings->paths.directory_playlist = '\0';
|
2019-03-11 12:50:46 +00:00
|
|
|
if (string_is_equal(settings->paths.directory_runtime_log, "default"))
|
|
|
|
*settings->paths.directory_runtime_log = '\0';
|
2013-11-08 03:36:16 +00:00
|
|
|
#ifdef HAVE_MENU
|
2018-01-16 21:53:38 +00:00
|
|
|
if (string_is_equal(settings->paths.directory_menu_content, "default"))
|
2017-04-28 22:39:29 +00:00
|
|
|
*settings->paths.directory_menu_content = '\0';
|
2018-01-16 21:53:38 +00:00
|
|
|
if (string_is_equal(settings->paths.directory_menu_config, "default"))
|
2017-04-28 22:39:29 +00:00
|
|
|
*settings->paths.directory_menu_config = '\0';
|
2013-03-17 20:37:41 +00:00
|
|
|
#endif
|
2013-05-22 20:31:16 +00:00
|
|
|
#ifdef HAVE_OVERLAY
|
2018-01-16 21:53:38 +00:00
|
|
|
if (string_is_equal(settings->paths.directory_overlay, "default"))
|
2017-04-28 22:39:29 +00:00
|
|
|
*settings->paths.directory_overlay = '\0';
|
2019-04-16 16:41:06 +00:00
|
|
|
#endif
|
|
|
|
#ifdef HAVE_VIDEO_LAYOUT
|
|
|
|
if (string_is_equal(settings->paths.directory_video_layout, "default"))
|
|
|
|
*settings->paths.directory_video_layout = '\0';
|
2013-05-22 20:31:16 +00:00
|
|
|
#endif
|
2018-01-16 21:53:38 +00:00
|
|
|
if (string_is_equal(settings->paths.directory_system, "default"))
|
2017-04-28 22:39:29 +00:00
|
|
|
*settings->paths.directory_system = '\0';
|
2011-02-05 10:31:35 +00:00
|
|
|
|
2019-03-21 16:56:24 +00:00
|
|
|
/* Log directory is a special case, since it must contain
|
|
|
|
* a valid path as soon as possible - if config file
|
|
|
|
* value is 'default' must copy g_defaults.dirs[DEFAULT_DIR_LOGS]
|
|
|
|
* directly... */
|
|
|
|
if (string_is_equal(settings->paths.log_dir, "default"))
|
|
|
|
{
|
|
|
|
if (!string_is_empty(g_defaults.dirs[DEFAULT_DIR_LOGS]))
|
|
|
|
strlcpy(settings->paths.log_dir,
|
|
|
|
g_defaults.dirs[DEFAULT_DIR_LOGS],
|
|
|
|
sizeof(settings->paths.log_dir));
|
|
|
|
else
|
|
|
|
*settings->paths.log_dir = '\0';
|
|
|
|
}
|
|
|
|
|
2017-04-28 12:57:55 +00:00
|
|
|
if (settings->floats.slowmotion_ratio < 1.0f)
|
2017-12-03 02:37:06 +00:00
|
|
|
configuration_set_float(settings, settings->floats.slowmotion_ratio, 1.0f);
|
2011-01-31 17:06:57 +00:00
|
|
|
|
2014-10-03 17:07:40 +00:00
|
|
|
/* Sanitize fastforward_ratio value - previously range was -1
|
|
|
|
* and up (with 0 being skipped) */
|
2017-04-28 12:57:55 +00:00
|
|
|
if (settings->floats.fastforward_ratio < 0.0f)
|
|
|
|
configuration_set_float(settings, settings->floats.fastforward_ratio, 0.0f);
|
2013-08-07 20:24:12 +00:00
|
|
|
|
2016-03-21 22:46:36 +00:00
|
|
|
#ifdef HAVE_LAKKA
|
2017-12-14 19:05:46 +00:00
|
|
|
settings->bools.ssh_enable = filestream_exists(LAKKA_SSH_PATH);
|
|
|
|
settings->bools.samba_enable = filestream_exists(LAKKA_SAMBA_PATH);
|
|
|
|
settings->bools.bluetooth_enable = filestream_exists(LAKKA_BLUETOOTH_PATH);
|
2016-03-21 22:46:36 +00:00
|
|
|
#endif
|
|
|
|
|
2016-10-01 04:05:08 +00:00
|
|
|
if (!retroarch_override_setting_is_set(RARCH_OVERRIDE_SETTING_SAVE_PATH, NULL) &&
|
2017-09-09 19:35:09 +00:00
|
|
|
config_get_path(conf, "savefile_directory", tmp_str, path_size))
|
2011-08-24 13:47:39 +00:00
|
|
|
{
|
2018-01-16 21:53:38 +00:00
|
|
|
if (string_is_equal(tmp_str, "default"))
|
2017-05-23 17:43:58 +00:00
|
|
|
dir_set(RARCH_DIR_SAVEFILE, g_defaults.dirs[DEFAULT_DIR_SRAM]);
|
2016-09-17 12:49:35 +00:00
|
|
|
|
2013-05-21 02:18:34 +00:00
|
|
|
else if (path_is_directory(tmp_str))
|
2011-08-24 13:47:39 +00:00
|
|
|
{
|
2016-12-26 02:16:27 +00:00
|
|
|
global_t *global = global_get_ptr();
|
|
|
|
|
2016-10-03 06:20:33 +00:00
|
|
|
dir_set(RARCH_DIR_SAVEFILE, tmp_str);
|
2016-09-17 12:49:35 +00:00
|
|
|
|
2016-12-26 02:16:27 +00:00
|
|
|
if (global)
|
|
|
|
{
|
|
|
|
strlcpy(global->name.savefile, tmp_str,
|
|
|
|
sizeof(global->name.savefile));
|
|
|
|
fill_pathname_dir(global->name.savefile,
|
|
|
|
path_get(RARCH_PATH_BASENAME),
|
2019-09-18 16:12:57 +00:00
|
|
|
".srm",
|
2016-12-26 02:16:27 +00:00
|
|
|
sizeof(global->name.savefile));
|
|
|
|
}
|
2011-08-24 13:47:39 +00:00
|
|
|
}
|
|
|
|
else
|
2013-05-01 10:50:40 +00:00
|
|
|
RARCH_WARN("savefile_directory is not a directory, ignoring ...\n");
|
2011-08-24 13:47:39 +00:00
|
|
|
}
|
2012-06-11 22:28:34 +00:00
|
|
|
|
2016-10-01 04:05:08 +00:00
|
|
|
if (!retroarch_override_setting_is_set(RARCH_OVERRIDE_SETTING_STATE_PATH, NULL) &&
|
2017-09-09 19:35:09 +00:00
|
|
|
config_get_path(conf, "savestate_directory", tmp_str, path_size))
|
2011-08-24 13:47:39 +00:00
|
|
|
{
|
2018-01-16 21:53:38 +00:00
|
|
|
if (string_is_equal(tmp_str, "default"))
|
2017-05-23 17:43:58 +00:00
|
|
|
dir_set(RARCH_DIR_SAVESTATE, g_defaults.dirs[DEFAULT_DIR_SAVESTATE]);
|
2013-05-21 02:18:34 +00:00
|
|
|
else if (path_is_directory(tmp_str))
|
2011-08-24 13:47:39 +00:00
|
|
|
{
|
2016-12-26 02:16:27 +00:00
|
|
|
global_t *global = global_get_ptr();
|
|
|
|
|
2016-10-03 06:20:33 +00:00
|
|
|
dir_set(RARCH_DIR_SAVESTATE, tmp_str);
|
2016-09-17 12:49:35 +00:00
|
|
|
|
2016-12-26 02:16:27 +00:00
|
|
|
if (global)
|
|
|
|
{
|
|
|
|
strlcpy(global->name.savestate, tmp_str,
|
|
|
|
sizeof(global->name.savestate));
|
|
|
|
fill_pathname_dir(global->name.savestate,
|
|
|
|
path_get(RARCH_PATH_BASENAME),
|
2019-09-18 16:12:57 +00:00
|
|
|
".state",
|
2016-12-26 02:16:27 +00:00
|
|
|
sizeof(global->name.savestate));
|
|
|
|
}
|
2011-08-24 13:47:39 +00:00
|
|
|
}
|
|
|
|
else
|
2012-04-21 21:25:32 +00:00
|
|
|
RARCH_WARN("savestate_directory is not a directory, ignoring ...\n");
|
2011-08-24 13:47:39 +00:00
|
|
|
}
|
|
|
|
|
2012-02-29 18:25:54 +00:00
|
|
|
config_read_keybinds_conf(conf);
|
2010-12-29 20:12:56 +00:00
|
|
|
|
2018-10-06 15:48:12 +00:00
|
|
|
#if defined(HAVE_MENU) && defined(HAVE_RGUI)
|
|
|
|
if (!check_menu_driver_compatibility())
|
|
|
|
strlcpy(settings->arrays.menu_driver, "rgui", sizeof(settings->arrays.menu_driver));
|
|
|
|
#endif
|
|
|
|
|
2018-11-29 17:42:44 +00:00
|
|
|
#ifdef HAVE_LIBNX
|
2019-04-22 07:27:59 +00:00
|
|
|
/* Apply initial clocks */
|
2018-11-29 17:42:44 +00:00
|
|
|
extern void libnx_apply_overclock();
|
|
|
|
libnx_apply_overclock();
|
|
|
|
#endif
|
|
|
|
|
2018-06-19 06:50:33 +00:00
|
|
|
frontend_driver_set_sustained_performance_mode(settings->bools.sustained_performance_mode);
|
2018-09-27 02:40:57 +00:00
|
|
|
recording_driver_update_streaming_url();
|
2018-01-30 03:11:08 +00:00
|
|
|
|
2019-04-16 03:14:49 +00:00
|
|
|
if (!config_entry_exists(conf, "user_language"))
|
|
|
|
msg_hash_set_uint(MSG_HASH_USER_LANGUAGE, frontend_driver_get_user_language());
|
2015-05-07 01:55:15 +00:00
|
|
|
|
2019-07-30 16:11:43 +00:00
|
|
|
/* If this is the first run of an existing installation
|
|
|
|
* after the independent favourites playlist size limit was
|
|
|
|
* added, set the favourites limit according to the current
|
|
|
|
* history playlist size limit. (Have to do this, otherwise
|
|
|
|
* users with large custom history size limits may lose
|
|
|
|
* favourites entries when updating RetroArch...) */
|
|
|
|
if ( config_entry_exists(conf, "content_history_size") &&
|
|
|
|
!config_entry_exists(conf, "content_favorites_size"))
|
|
|
|
{
|
|
|
|
if (settings->uints.content_history_size > 999)
|
|
|
|
settings->ints.content_favorites_size = -1;
|
|
|
|
else
|
|
|
|
settings->ints.content_favorites_size = (int)settings->uints.content_history_size;
|
|
|
|
}
|
|
|
|
|
2018-01-30 03:11:08 +00:00
|
|
|
ret = true;
|
2016-09-20 14:10:27 +00:00
|
|
|
end:
|
|
|
|
if (conf)
|
|
|
|
config_file_free(conf);
|
2016-08-29 17:26:08 +00:00
|
|
|
if (bool_settings)
|
|
|
|
free(bool_settings);
|
|
|
|
if (int_settings)
|
|
|
|
free(int_settings);
|
2017-04-28 17:55:09 +00:00
|
|
|
if (uint_settings)
|
|
|
|
free(uint_settings);
|
2016-08-29 17:26:08 +00:00
|
|
|
if (float_settings)
|
|
|
|
free(float_settings);
|
2016-09-01 00:53:04 +00:00
|
|
|
if (array_settings)
|
|
|
|
free(array_settings);
|
2016-09-01 02:37:22 +00:00
|
|
|
if (path_settings)
|
|
|
|
free(path_settings);
|
2018-08-18 04:56:10 +00:00
|
|
|
if (size_settings)
|
|
|
|
free(size_settings);
|
2017-09-09 19:35:09 +00:00
|
|
|
free(tmp_str);
|
2016-09-20 14:32:33 +00:00
|
|
|
return ret;
|
2010-12-29 18:00:21 +00:00
|
|
|
}
|
2010-12-30 03:51:08 +00:00
|
|
|
|
2015-04-05 16:14:24 +00:00
|
|
|
/**
|
2015-04-05 18:52:43 +00:00
|
|
|
* config_load_override:
|
2015-04-05 16:14:24 +00:00
|
|
|
*
|
|
|
|
* Tries to append game-specific and core-specific configuration.
|
|
|
|
* These settings will always have precedence, thus this feature
|
|
|
|
* can be used to enforce overrides.
|
|
|
|
*
|
|
|
|
* This function only has an effect if a game-specific or core-specific
|
|
|
|
* configuration file exists at respective locations.
|
|
|
|
*
|
2017-07-14 19:11:27 +00:00
|
|
|
* core-specific: $CONFIG_DIR/$CORE_NAME/$CORE_NAME.cfg
|
2016-08-30 02:37:49 +00:00
|
|
|
* fallback: $CURRENT_CFG_LOCATION/$CORE_NAME/$CORE_NAME.cfg
|
|
|
|
*
|
2017-07-14 19:11:27 +00:00
|
|
|
* game-specific: $CONFIG_DIR/$CORE_NAME/$ROM_NAME.cfg
|
2016-08-30 02:37:49 +00:00
|
|
|
* fallback: $CURRENT_CFG_LOCATION/$CORE_NAME/$GAME_NAME.cfg
|
2015-04-05 16:14:24 +00:00
|
|
|
*
|
2015-04-07 01:16:00 +00:00
|
|
|
* Returns: false if there was an error or no action was performed.
|
2015-04-05 16:14:24 +00:00
|
|
|
*
|
|
|
|
*/
|
2015-04-05 18:52:43 +00:00
|
|
|
bool config_load_override(void)
|
2015-04-05 16:14:24 +00:00
|
|
|
{
|
2017-09-09 19:35:09 +00:00
|
|
|
size_t path_size = PATH_MAX_LENGTH * sizeof(char);
|
2018-02-04 22:02:52 +00:00
|
|
|
char *buf = NULL;
|
|
|
|
char *core_path = NULL;
|
|
|
|
char *game_path = NULL;
|
2018-05-13 20:24:10 +00:00
|
|
|
char *content_path = NULL;
|
2018-02-04 22:02:52 +00:00
|
|
|
char *config_directory = NULL;
|
2016-10-03 02:34:08 +00:00
|
|
|
bool should_append = false;
|
2017-04-23 14:41:26 +00:00
|
|
|
rarch_system_info_t *system = runloop_get_system_info();
|
2018-03-25 15:27:17 +00:00
|
|
|
const char *core_name = system ?
|
2018-02-17 10:55:39 +00:00
|
|
|
system->info.library_name : NULL;
|
2019-04-21 04:20:25 +00:00
|
|
|
const char *rarch_path_basename = path_get(RARCH_PATH_BASENAME);
|
|
|
|
const char *game_name = path_basename(rarch_path_basename);
|
2018-05-13 20:24:10 +00:00
|
|
|
char content_dir_name[PATH_MAX_LENGTH];
|
2015-11-17 23:30:11 +00:00
|
|
|
|
2019-04-21 04:20:25 +00:00
|
|
|
if (!string_is_empty(rarch_path_basename))
|
|
|
|
fill_pathname_parent_dir_name(content_dir_name,
|
|
|
|
rarch_path_basename, sizeof(content_dir_name));
|
2015-11-17 23:30:11 +00:00
|
|
|
|
2015-12-26 06:19:04 +00:00
|
|
|
if (string_is_empty(core_name) || string_is_empty(game_name))
|
2018-02-04 22:02:52 +00:00
|
|
|
return false;
|
2015-11-17 23:30:11 +00:00
|
|
|
|
2018-02-17 10:55:39 +00:00
|
|
|
game_path = (char*)
|
|
|
|
malloc(PATH_MAX_LENGTH * sizeof(char));
|
|
|
|
core_path = (char*)
|
|
|
|
malloc(PATH_MAX_LENGTH * sizeof(char));
|
2018-05-13 20:24:10 +00:00
|
|
|
content_path = (char*)
|
2018-05-09 13:40:25 +00:00
|
|
|
malloc(PATH_MAX_LENGTH * sizeof(char));
|
2018-02-17 10:55:39 +00:00
|
|
|
buf = (char*)
|
|
|
|
malloc(PATH_MAX_LENGTH * sizeof(char));
|
|
|
|
config_directory = (char*)
|
|
|
|
malloc(PATH_MAX_LENGTH * sizeof(char));
|
2016-10-20 16:36:01 +00:00
|
|
|
config_directory[0] = core_path[0] = game_path[0] = '\0';
|
|
|
|
|
2017-09-09 19:35:09 +00:00
|
|
|
fill_pathname_application_special(config_directory, path_size,
|
2016-06-11 20:00:29 +00:00
|
|
|
APPLICATION_SPECIAL_DIRECTORY_CONFIG);
|
2015-04-05 16:14:24 +00:00
|
|
|
|
2018-05-13 20:24:10 +00:00
|
|
|
/* Concatenate strings into full paths for core_path, game_path, content_path */
|
2016-06-30 03:02:45 +00:00
|
|
|
fill_pathname_join_special_ext(game_path,
|
|
|
|
config_directory, core_name,
|
|
|
|
game_name,
|
2019-09-18 16:12:57 +00:00
|
|
|
".cfg",
|
2017-09-09 19:35:09 +00:00
|
|
|
path_size);
|
2015-04-05 16:14:24 +00:00
|
|
|
|
2018-05-13 20:24:10 +00:00
|
|
|
fill_pathname_join_special_ext(content_path,
|
2018-05-09 13:40:25 +00:00
|
|
|
config_directory, core_name,
|
2018-05-13 20:24:10 +00:00
|
|
|
content_dir_name,
|
2019-09-18 16:12:57 +00:00
|
|
|
".cfg",
|
2018-05-09 13:40:25 +00:00
|
|
|
path_size);
|
|
|
|
|
2016-06-30 03:02:45 +00:00
|
|
|
fill_pathname_join_special_ext(core_path,
|
|
|
|
config_directory, core_name,
|
|
|
|
core_name,
|
2019-09-18 16:12:57 +00:00
|
|
|
".cfg",
|
2017-09-09 19:35:09 +00:00
|
|
|
path_size);
|
2015-04-05 16:14:24 +00:00
|
|
|
|
2019-04-27 12:01:50 +00:00
|
|
|
free(config_directory);
|
|
|
|
|
2018-05-13 20:24:10 +00:00
|
|
|
/* per-core overrides */
|
2015-05-08 07:12:49 +00:00
|
|
|
/* Create a new config file from core_path */
|
2019-04-28 01:21:30 +00:00
|
|
|
if (config_file_exists(core_path))
|
2015-04-05 16:14:24 +00:00
|
|
|
{
|
2019-04-22 06:29:29 +00:00
|
|
|
RARCH_LOG("[Overrides] core-specific overrides found at %s.\n",
|
2018-02-17 10:55:39 +00:00
|
|
|
core_path);
|
2016-09-17 12:14:58 +00:00
|
|
|
|
2016-09-29 05:49:54 +00:00
|
|
|
path_set(RARCH_PATH_CONFIG_APPEND, core_path);
|
2015-11-15 21:02:24 +00:00
|
|
|
|
2015-04-05 16:14:24 +00:00
|
|
|
should_append = true;
|
|
|
|
}
|
|
|
|
else
|
2019-04-22 06:29:29 +00:00
|
|
|
RARCH_LOG("[Overrides] no core-specific overrides found at %s.\n",
|
2018-02-17 10:55:39 +00:00
|
|
|
core_path);
|
2015-04-05 16:14:24 +00:00
|
|
|
|
2018-05-13 20:24:10 +00:00
|
|
|
/* per-content-dir overrides */
|
|
|
|
/* Create a new config file from content_path */
|
2019-04-28 01:21:30 +00:00
|
|
|
if (config_file_exists(content_path))
|
2018-05-09 13:40:25 +00:00
|
|
|
{
|
2018-05-13 20:24:10 +00:00
|
|
|
char *temp_path = (char*)malloc(PATH_MAX_LENGTH * sizeof(char));
|
|
|
|
|
|
|
|
temp_path[0] = '\0';
|
2018-05-09 13:40:25 +00:00
|
|
|
|
2019-04-22 06:29:29 +00:00
|
|
|
RARCH_LOG("[Overrides] content-dir-specific overrides found at %s.\n",
|
2018-05-13 20:24:10 +00:00
|
|
|
game_path);
|
|
|
|
|
|
|
|
if (should_append)
|
|
|
|
{
|
2019-04-22 06:29:29 +00:00
|
|
|
RARCH_LOG("[Overrides] content-dir-specific overrides stacking on top of previous overrides.\n");
|
2018-05-13 20:24:10 +00:00
|
|
|
strlcpy(temp_path, path_get(RARCH_PATH_CONFIG_APPEND), path_size);
|
|
|
|
strlcat(temp_path, "|", path_size);
|
|
|
|
strlcat(temp_path, content_path, path_size);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
strlcpy(temp_path, content_path, path_size);
|
|
|
|
|
|
|
|
path_set(RARCH_PATH_CONFIG_APPEND, temp_path);
|
|
|
|
|
|
|
|
free(temp_path);
|
2018-05-09 13:40:25 +00:00
|
|
|
|
|
|
|
should_append = true;
|
|
|
|
}
|
|
|
|
else
|
2019-04-22 06:29:29 +00:00
|
|
|
RARCH_LOG("[Overrides] no content-dir-specific overrides found at %s.\n",
|
2018-05-13 20:24:10 +00:00
|
|
|
content_path);
|
2018-05-09 13:40:25 +00:00
|
|
|
|
2018-05-13 20:24:10 +00:00
|
|
|
/* per-game overrides */
|
2015-06-26 15:46:13 +00:00
|
|
|
/* Create a new config file from game_path */
|
2019-04-28 01:21:30 +00:00
|
|
|
if (config_file_exists(game_path))
|
2015-04-05 16:14:24 +00:00
|
|
|
{
|
2017-09-09 19:35:09 +00:00
|
|
|
char *temp_path = (char*)malloc(PATH_MAX_LENGTH * sizeof(char));
|
2016-10-27 07:44:20 +00:00
|
|
|
|
2017-09-09 19:35:09 +00:00
|
|
|
temp_path[0] = '\0';
|
2016-09-17 12:14:58 +00:00
|
|
|
|
2019-04-22 06:29:29 +00:00
|
|
|
RARCH_LOG("[Overrides] game-specific overrides found at %s.\n",
|
2018-02-17 10:55:39 +00:00
|
|
|
game_path);
|
2016-09-17 12:14:58 +00:00
|
|
|
|
2015-04-08 03:20:09 +00:00
|
|
|
if (should_append)
|
2015-04-05 16:14:24 +00:00
|
|
|
{
|
2019-04-22 06:29:29 +00:00
|
|
|
RARCH_LOG("[Overrides] game-specific overrides stacking on top of previous overrides\n");
|
2017-09-09 19:35:09 +00:00
|
|
|
strlcpy(temp_path, path_get(RARCH_PATH_CONFIG_APPEND), path_size);
|
|
|
|
strlcat(temp_path, "|", path_size);
|
|
|
|
strlcat(temp_path, game_path, path_size);
|
2015-04-05 16:14:24 +00:00
|
|
|
}
|
|
|
|
else
|
2017-09-09 19:35:09 +00:00
|
|
|
strlcpy(temp_path, game_path, path_size);
|
2016-09-17 12:14:58 +00:00
|
|
|
|
2016-09-29 05:49:54 +00:00
|
|
|
path_set(RARCH_PATH_CONFIG_APPEND, temp_path);
|
2015-04-07 00:58:57 +00:00
|
|
|
|
2017-09-09 19:35:09 +00:00
|
|
|
free(temp_path);
|
|
|
|
|
2015-04-05 16:14:24 +00:00
|
|
|
should_append = true;
|
|
|
|
}
|
|
|
|
else
|
2019-04-22 06:29:29 +00:00
|
|
|
RARCH_LOG("[Overrides] no game-specific overrides found at %s.\n",
|
2018-02-17 10:55:39 +00:00
|
|
|
game_path);
|
2015-04-05 16:14:24 +00:00
|
|
|
|
2015-11-21 17:21:53 +00:00
|
|
|
if (!should_append)
|
2017-09-09 19:35:09 +00:00
|
|
|
goto error;
|
2015-11-21 17:21:53 +00:00
|
|
|
|
2018-03-25 15:27:17 +00:00
|
|
|
/* Re-load the configuration with any overrides
|
2018-02-17 10:55:39 +00:00
|
|
|
* that might have been found */
|
2016-10-20 16:36:01 +00:00
|
|
|
buf[0] = '\0';
|
2015-04-11 21:03:30 +00:00
|
|
|
|
2017-07-14 19:11:27 +00:00
|
|
|
/* Store the libretro_path we're using since it will be
|
2016-07-01 06:53:27 +00:00
|
|
|
* overwritten by the override when reloading. */
|
2017-09-09 19:35:09 +00:00
|
|
|
strlcpy(buf, path_get(RARCH_PATH_CORE), path_size);
|
2015-05-07 05:36:29 +00:00
|
|
|
|
2015-11-21 17:21:53 +00:00
|
|
|
/* Toggle has_save_path to false so it resets */
|
2016-10-01 04:14:30 +00:00
|
|
|
retroarch_override_setting_unset(RARCH_OVERRIDE_SETTING_STATE_PATH, NULL);
|
|
|
|
retroarch_override_setting_unset(RARCH_OVERRIDE_SETTING_SAVE_PATH, NULL);
|
2015-05-07 05:36:29 +00:00
|
|
|
|
2019-04-22 05:38:44 +00:00
|
|
|
if (!config_load_file(path_get(RARCH_PATH_CONFIG), config_get_ptr()))
|
2017-09-09 19:35:09 +00:00
|
|
|
goto error;
|
2015-11-21 17:21:53 +00:00
|
|
|
|
|
|
|
/* Restore the libretro_path we're using
|
|
|
|
* since it will be overwritten by the override when reloading. */
|
2016-09-29 05:46:21 +00:00
|
|
|
path_set(RARCH_PATH_CORE, buf);
|
2018-02-17 10:55:39 +00:00
|
|
|
runloop_msg_queue_push(msg_hash_to_str(MSG_CONFIG_OVERRIDE_LOADED),
|
2018-11-22 14:45:52 +00:00
|
|
|
1, 100, true,
|
|
|
|
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
|
2015-04-05 16:14:24 +00:00
|
|
|
|
2016-07-01 06:53:27 +00:00
|
|
|
/* Reset save paths. */
|
2016-10-01 03:51:03 +00:00
|
|
|
retroarch_override_setting_set(RARCH_OVERRIDE_SETTING_STATE_PATH, NULL);
|
|
|
|
retroarch_override_setting_set(RARCH_OVERRIDE_SETTING_SAVE_PATH, NULL);
|
2016-09-17 12:14:58 +00:00
|
|
|
|
2016-09-30 02:31:19 +00:00
|
|
|
path_clear(RARCH_PATH_CONFIG_APPEND);
|
2016-09-17 12:14:58 +00:00
|
|
|
|
2017-09-09 19:35:09 +00:00
|
|
|
free(buf);
|
|
|
|
free(core_path);
|
2018-05-13 20:24:10 +00:00
|
|
|
free(content_path);
|
2017-09-09 19:35:09 +00:00
|
|
|
free(game_path);
|
2015-11-21 17:21:53 +00:00
|
|
|
return true;
|
2017-09-09 19:35:09 +00:00
|
|
|
|
|
|
|
error:
|
|
|
|
free(buf);
|
|
|
|
free(core_path);
|
2018-05-13 20:24:10 +00:00
|
|
|
free(content_path);
|
2017-09-09 19:35:09 +00:00
|
|
|
free(game_path);
|
|
|
|
return false;
|
2015-04-07 00:54:58 +00:00
|
|
|
}
|
|
|
|
|
2015-04-07 01:07:44 +00:00
|
|
|
/**
|
|
|
|
* config_unload_override:
|
|
|
|
*
|
|
|
|
* Unloads configuration overrides if overrides are active.
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* Returns: false if there was an error.
|
|
|
|
*/
|
2016-05-27 03:13:05 +00:00
|
|
|
bool config_unload_override(void)
|
2015-04-07 00:54:58 +00:00
|
|
|
{
|
2016-09-30 02:31:19 +00:00
|
|
|
path_clear(RARCH_PATH_CONFIG_APPEND);
|
2015-05-07 23:06:14 +00:00
|
|
|
|
2015-05-08 07:12:49 +00:00
|
|
|
/* Toggle has_save_path to false so it resets */
|
2016-10-01 04:14:30 +00:00
|
|
|
retroarch_override_setting_unset(RARCH_OVERRIDE_SETTING_STATE_PATH, NULL);
|
|
|
|
retroarch_override_setting_unset(RARCH_OVERRIDE_SETTING_SAVE_PATH, NULL);
|
2015-05-07 23:06:14 +00:00
|
|
|
|
2019-04-22 05:38:44 +00:00
|
|
|
if (!config_load_file(path_get(RARCH_PATH_CONFIG), config_get_ptr()))
|
2016-12-15 11:07:02 +00:00
|
|
|
return false;
|
2015-05-07 23:06:14 +00:00
|
|
|
|
2019-04-22 06:29:29 +00:00
|
|
|
RARCH_LOG("[Overrides] configuration overrides unloaded, original configuration restored.\n");
|
2015-05-07 05:36:29 +00:00
|
|
|
|
2016-12-15 11:07:02 +00:00
|
|
|
/* Reset save paths */
|
|
|
|
retroarch_override_setting_set(RARCH_OVERRIDE_SETTING_STATE_PATH, NULL);
|
|
|
|
retroarch_override_setting_set(RARCH_OVERRIDE_SETTING_SAVE_PATH, NULL);
|
2015-05-08 07:12:49 +00:00
|
|
|
|
2016-12-15 11:07:02 +00:00
|
|
|
return true;
|
2015-04-05 16:14:24 +00:00
|
|
|
}
|
|
|
|
|
2015-04-05 19:06:23 +00:00
|
|
|
/**
|
|
|
|
* config_load_remap:
|
|
|
|
*
|
|
|
|
* Tries to append game-specific and core-specific remap files.
|
|
|
|
*
|
|
|
|
* This function only has an effect if a game-specific or core-specific
|
|
|
|
* configuration file exists at respective locations.
|
|
|
|
*
|
|
|
|
* core-specific: $REMAP_DIR/$CORE_NAME/$CORE_NAME.cfg
|
|
|
|
* game-specific: $REMAP_DIR/$CORE_NAME/$GAME_NAME.cfg
|
|
|
|
*
|
2015-04-07 01:16:00 +00:00
|
|
|
* Returns: false if there was an error or no action was performed.
|
2015-04-05 19:06:23 +00:00
|
|
|
*/
|
2019-07-30 01:04:56 +00:00
|
|
|
bool config_load_remap(const char *directory_input_remapping)
|
2015-04-05 20:41:24 +00:00
|
|
|
{
|
2017-09-09 19:35:09 +00:00
|
|
|
size_t path_size = PATH_MAX_LENGTH * sizeof(char);
|
2019-04-28 01:21:30 +00:00
|
|
|
config_file_t *new_conf = NULL;
|
2018-03-25 15:27:17 +00:00
|
|
|
char *remap_directory = NULL;
|
2018-02-04 22:02:52 +00:00
|
|
|
char *core_path = NULL;
|
|
|
|
char *game_path = NULL;
|
2018-05-13 21:20:51 +00:00
|
|
|
char *content_path = NULL;
|
2017-04-23 14:41:26 +00:00
|
|
|
rarch_system_info_t *system = runloop_get_system_info();
|
2018-02-04 22:02:52 +00:00
|
|
|
const char *core_name = system ? system->info.library_name : NULL;
|
2019-04-21 04:20:25 +00:00
|
|
|
const char *rarch_path_basename = path_get(RARCH_PATH_BASENAME);
|
|
|
|
const char *game_name = path_basename(rarch_path_basename);
|
2018-05-13 21:20:51 +00:00
|
|
|
char content_dir_name[PATH_MAX_LENGTH];
|
|
|
|
|
2015-12-26 06:19:04 +00:00
|
|
|
if (string_is_empty(core_name) || string_is_empty(game_name))
|
2018-02-04 22:02:52 +00:00
|
|
|
return false;
|
2015-11-17 23:30:11 +00:00
|
|
|
|
2015-05-08 07:12:49 +00:00
|
|
|
/* Remap directory: remap_directory.
|
|
|
|
* Try remap directory setting, no fallbacks defined */
|
2019-07-30 01:04:56 +00:00
|
|
|
if (string_is_empty(directory_input_remapping))
|
2018-02-04 22:02:52 +00:00
|
|
|
return false;
|
2015-12-26 06:19:04 +00:00
|
|
|
|
2019-04-28 01:21:30 +00:00
|
|
|
if (!string_is_empty(rarch_path_basename))
|
|
|
|
fill_pathname_parent_dir_name(content_dir_name,
|
|
|
|
rarch_path_basename, sizeof(content_dir_name));
|
|
|
|
|
2018-02-04 22:02:52 +00:00
|
|
|
/* path to the directory containing retroarch.cfg (prefix) */
|
2018-02-17 10:55:39 +00:00
|
|
|
remap_directory = (char*)
|
|
|
|
malloc(PATH_MAX_LENGTH * sizeof(char));
|
2018-03-25 15:27:17 +00:00
|
|
|
/* final path for core-specific configuration (prefix+suffix) */
|
2018-02-17 10:55:39 +00:00
|
|
|
core_path = (char*)
|
|
|
|
malloc(PATH_MAX_LENGTH * sizeof(char));
|
2018-02-04 22:02:52 +00:00
|
|
|
/* final path for game-specific configuration (prefix+suffix) */
|
2018-02-17 10:55:39 +00:00
|
|
|
game_path = (char*)
|
2018-03-25 15:27:17 +00:00
|
|
|
malloc(PATH_MAX_LENGTH * sizeof(char));
|
2018-05-13 21:20:51 +00:00
|
|
|
/* final path for content-dir-specific configuration (prefix+suffix) */
|
|
|
|
content_path = (char*)
|
|
|
|
malloc(PATH_MAX_LENGTH * sizeof(char));
|
2016-10-20 16:33:25 +00:00
|
|
|
remap_directory[0] = core_path[0] = game_path[0] = '\0';
|
|
|
|
|
2019-07-30 01:04:56 +00:00
|
|
|
strlcpy(remap_directory, directory_input_remapping, path_size);
|
2019-04-28 03:48:09 +00:00
|
|
|
RARCH_LOG("[Remaps]: remap directory: %s\n", remap_directory);
|
2015-04-05 20:41:24 +00:00
|
|
|
|
2015-05-08 07:12:49 +00:00
|
|
|
/* Concatenate strings into full paths for core_path, game_path */
|
2016-06-30 03:02:45 +00:00
|
|
|
fill_pathname_join_special_ext(core_path,
|
|
|
|
remap_directory, core_name,
|
|
|
|
core_name,
|
2019-09-18 16:12:57 +00:00
|
|
|
".rmp",
|
2017-09-09 19:35:09 +00:00
|
|
|
path_size);
|
2015-04-05 20:41:24 +00:00
|
|
|
|
2018-05-13 21:20:51 +00:00
|
|
|
fill_pathname_join_special_ext(content_path,
|
|
|
|
remap_directory, core_name,
|
|
|
|
content_dir_name,
|
2019-09-18 16:12:57 +00:00
|
|
|
".rmp",
|
2018-05-13 21:20:51 +00:00
|
|
|
path_size);
|
|
|
|
|
2016-06-30 03:02:45 +00:00
|
|
|
fill_pathname_join_special_ext(game_path,
|
|
|
|
remap_directory, core_name,
|
|
|
|
game_name,
|
2019-09-18 16:12:57 +00:00
|
|
|
".rmp",
|
2017-09-09 19:35:09 +00:00
|
|
|
path_size);
|
2015-04-05 20:41:24 +00:00
|
|
|
|
2019-07-30 00:44:33 +00:00
|
|
|
input_remapping_set_defaults(false);
|
2015-04-05 20:41:24 +00:00
|
|
|
|
2015-05-08 07:12:49 +00:00
|
|
|
/* If a game remap file exists, load it. */
|
2019-07-30 00:44:33 +00:00
|
|
|
if ((new_conf = config_file_new_from_path_to_string(game_path)))
|
2015-04-05 20:41:24 +00:00
|
|
|
{
|
2019-04-28 03:48:09 +00:00
|
|
|
RARCH_LOG("[Remaps]: game-specific remap found at %s.\n", game_path);
|
2015-11-15 21:02:24 +00:00
|
|
|
if (input_remapping_load_file(new_conf, game_path))
|
2015-05-08 07:12:49 +00:00
|
|
|
{
|
2017-08-05 05:37:26 +00:00
|
|
|
rarch_ctl(RARCH_CTL_SET_REMAPS_GAME_ACTIVE, NULL);
|
2017-09-09 19:35:09 +00:00
|
|
|
goto success;
|
2015-05-08 07:12:49 +00:00
|
|
|
}
|
2015-04-05 20:41:24 +00:00
|
|
|
}
|
2018-05-13 21:20:51 +00:00
|
|
|
|
|
|
|
/* If a content-dir remap file exists, load it. */
|
2019-07-30 00:44:33 +00:00
|
|
|
if ((new_conf = config_file_new_from_path_to_string(content_path)))
|
2018-05-13 21:20:51 +00:00
|
|
|
{
|
2019-04-28 03:48:09 +00:00
|
|
|
RARCH_LOG("[Remaps]: content-dir-specific remap found at %s.\n", content_path);
|
2018-05-13 21:20:51 +00:00
|
|
|
if (input_remapping_load_file(new_conf, content_path))
|
|
|
|
{
|
2018-05-14 04:17:44 +00:00
|
|
|
rarch_ctl(RARCH_CTL_SET_REMAPS_CONTENT_DIR_ACTIVE, NULL);
|
2018-05-13 21:20:51 +00:00
|
|
|
goto success;
|
|
|
|
}
|
|
|
|
}
|
2015-04-05 20:41:24 +00:00
|
|
|
|
2015-05-08 07:12:49 +00:00
|
|
|
/* If a core remap file exists, load it. */
|
2019-07-30 00:44:33 +00:00
|
|
|
if ((new_conf = config_file_new_from_path_to_string(core_path)))
|
2015-04-05 20:41:24 +00:00
|
|
|
{
|
2019-04-28 03:48:09 +00:00
|
|
|
RARCH_LOG("[Remaps]: core-specific remap found at %s.\n", core_path);
|
2015-11-15 21:02:24 +00:00
|
|
|
if (input_remapping_load_file(new_conf, core_path))
|
2015-05-08 07:12:49 +00:00
|
|
|
{
|
2017-08-05 05:37:26 +00:00
|
|
|
rarch_ctl(RARCH_CTL_SET_REMAPS_CORE_ACTIVE, NULL);
|
2017-09-09 19:35:09 +00:00
|
|
|
goto success;
|
2015-05-08 07:12:49 +00:00
|
|
|
}
|
2015-04-05 20:41:24 +00:00
|
|
|
}
|
2015-04-07 01:30:47 +00:00
|
|
|
|
|
|
|
new_conf = NULL;
|
2015-04-05 20:41:24 +00:00
|
|
|
|
2018-08-06 04:54:52 +00:00
|
|
|
free(content_path);
|
2017-09-09 19:35:09 +00:00
|
|
|
free(remap_directory);
|
|
|
|
free(core_path);
|
|
|
|
free(game_path);
|
2015-04-07 01:16:00 +00:00
|
|
|
return false;
|
2017-09-09 19:35:09 +00:00
|
|
|
|
|
|
|
success:
|
2019-07-30 00:44:33 +00:00
|
|
|
runloop_msg_queue_push(msg_hash_to_str(
|
|
|
|
MSG_GAME_REMAP_FILE_LOADED), 1, 100, true,
|
|
|
|
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
|
2018-08-06 04:54:52 +00:00
|
|
|
free(content_path);
|
2017-09-09 19:35:09 +00:00
|
|
|
free(remap_directory);
|
|
|
|
free(core_path);
|
|
|
|
free(game_path);
|
|
|
|
return true;
|
2015-04-05 20:41:24 +00:00
|
|
|
}
|
2015-04-05 19:06:23 +00:00
|
|
|
|
2019-07-04 15:29:29 +00:00
|
|
|
/**
|
|
|
|
* config_parse_file:
|
|
|
|
*
|
|
|
|
* Loads a config file and reads all the values into memory.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
void config_parse_file(void)
|
2014-10-02 23:07:35 +00:00
|
|
|
{
|
2017-05-23 19:14:53 +00:00
|
|
|
if (path_is_empty(RARCH_PATH_CONFIG))
|
2014-10-02 23:07:35 +00:00
|
|
|
{
|
2019-02-21 18:57:06 +00:00
|
|
|
RARCH_LOG("[config] Loading default config.\n");
|
2014-10-02 23:07:35 +00:00
|
|
|
}
|
|
|
|
|
2019-07-04 15:29:29 +00:00
|
|
|
{
|
|
|
|
const char *config_path = path_get(RARCH_PATH_CONFIG);
|
|
|
|
RARCH_LOG("[config] loading config from: %s.\n", config_path);
|
2015-01-24 22:42:31 +00:00
|
|
|
|
2019-07-04 15:29:29 +00:00
|
|
|
if (!config_load_file(config_path, config_get_ptr()))
|
|
|
|
{
|
|
|
|
RARCH_ERR("[config] couldn't find config at path: \"%s\"\n",
|
|
|
|
config_path);
|
|
|
|
}
|
|
|
|
}
|
2012-02-20 19:36:21 +00:00
|
|
|
}
|
|
|
|
|
2015-01-08 17:01:13 +00:00
|
|
|
/**
|
|
|
|
* config_load:
|
|
|
|
*
|
|
|
|
* Loads a config file and reads all the values into memory.
|
|
|
|
*
|
|
|
|
*/
|
2014-10-03 11:39:19 +00:00
|
|
|
void config_load(void)
|
|
|
|
{
|
2016-09-03 06:15:41 +00:00
|
|
|
config_set_defaults();
|
2019-07-04 15:29:29 +00:00
|
|
|
config_parse_file();
|
2014-10-03 11:39:19 +00:00
|
|
|
}
|
|
|
|
|
2015-07-11 01:14:36 +00:00
|
|
|
/**
|
|
|
|
* config_save_autoconf_profile:
|
|
|
|
* @path : Path that shall be written to.
|
|
|
|
* @user : Controller number to save
|
|
|
|
* Writes a controller autoconf file to disk.
|
|
|
|
**/
|
2015-07-11 02:20:19 +00:00
|
|
|
bool config_save_autoconf_profile(const char *path, unsigned user)
|
2015-07-11 01:14:36 +00:00
|
|
|
{
|
2015-07-11 01:40:15 +00:00
|
|
|
unsigned i;
|
2018-02-04 22:02:52 +00:00
|
|
|
config_file_t *conf = NULL;
|
2017-09-09 19:35:09 +00:00
|
|
|
size_t path_size = PATH_MAX_LENGTH * sizeof(char);
|
2017-04-25 14:49:54 +00:00
|
|
|
int32_t pid_user = 0;
|
|
|
|
int32_t vid_user = 0;
|
2016-05-27 03:13:05 +00:00
|
|
|
bool ret = false;
|
2015-07-11 01:40:15 +00:00
|
|
|
settings_t *settings = config_get_ptr();
|
2017-04-28 22:39:29 +00:00
|
|
|
const char *autoconf_dir = settings->paths.directory_autoconfig;
|
2017-04-28 20:59:13 +00:00
|
|
|
const char *joypad_ident = settings->arrays.input_joypad_driver;
|
2019-04-22 06:13:26 +00:00
|
|
|
char *buf = (char*)
|
2018-02-17 10:55:39 +00:00
|
|
|
malloc(PATH_MAX_LENGTH * sizeof(char));
|
2019-04-22 06:13:26 +00:00
|
|
|
char *autoconf_file = (char*)
|
2018-02-17 10:55:39 +00:00
|
|
|
malloc(PATH_MAX_LENGTH * sizeof(char));
|
2019-04-22 06:13:26 +00:00
|
|
|
char *path_new = strdup(path);
|
2018-02-04 22:02:52 +00:00
|
|
|
buf[0] = autoconf_file[0] = '\0';
|
2017-11-13 21:59:23 +00:00
|
|
|
|
|
|
|
for (i = 0; invalid_filename_chars[i]; i++)
|
|
|
|
{
|
|
|
|
while (1)
|
|
|
|
{
|
|
|
|
char *tmp = strstr(path_new, invalid_filename_chars[i]);
|
|
|
|
|
|
|
|
if (tmp)
|
|
|
|
*tmp = '_';
|
|
|
|
else
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
path = path_new;
|
|
|
|
|
2017-09-09 19:35:09 +00:00
|
|
|
fill_pathname_join(buf, autoconf_dir, joypad_ident, path_size);
|
2015-07-11 04:07:44 +00:00
|
|
|
|
2018-02-17 10:55:39 +00:00
|
|
|
if (path_is_directory(buf))
|
2015-07-11 04:07:44 +00:00
|
|
|
{
|
2017-09-09 19:35:09 +00:00
|
|
|
char *buf_new = (char*)malloc(PATH_MAX_LENGTH * sizeof(char));
|
2016-10-09 07:05:41 +00:00
|
|
|
|
2019-04-22 06:21:57 +00:00
|
|
|
buf_new[0] = '\0';
|
2016-08-29 02:02:58 +00:00
|
|
|
|
|
|
|
fill_pathname_join(buf_new, buf,
|
2017-09-09 19:35:09 +00:00
|
|
|
path, path_size);
|
2016-08-29 02:02:58 +00:00
|
|
|
fill_pathname_noext(autoconf_file, buf_new,
|
2019-09-18 16:12:57 +00:00
|
|
|
".cfg",
|
2017-09-09 19:35:09 +00:00
|
|
|
path_size);
|
|
|
|
|
|
|
|
free(buf_new);
|
2015-07-11 04:07:44 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2017-04-25 14:38:47 +00:00
|
|
|
fill_pathname_join(buf, autoconf_dir,
|
2017-09-09 19:35:09 +00:00
|
|
|
path, path_size);
|
2016-06-29 16:40:36 +00:00
|
|
|
fill_pathname_noext(autoconf_file, buf,
|
2019-09-18 16:12:57 +00:00
|
|
|
".cfg",
|
2017-09-09 19:35:09 +00:00
|
|
|
path_size);
|
2015-07-11 04:07:44 +00:00
|
|
|
}
|
2015-07-11 01:14:36 +00:00
|
|
|
|
2019-04-22 06:21:57 +00:00
|
|
|
free(buf);
|
|
|
|
free(path_new);
|
|
|
|
|
2019-07-18 14:15:02 +00:00
|
|
|
conf = config_file_new_from_path_to_string(autoconf_file);
|
2015-07-11 01:40:15 +00:00
|
|
|
|
2015-07-11 01:14:36 +00:00
|
|
|
if (!conf)
|
|
|
|
{
|
2019-07-17 17:50:32 +00:00
|
|
|
conf = config_file_new_alloc();
|
2015-07-11 01:40:15 +00:00
|
|
|
if (!conf)
|
2019-04-22 06:21:57 +00:00
|
|
|
{
|
|
|
|
free(autoconf_file);
|
|
|
|
return false;
|
|
|
|
}
|
2015-07-11 01:14:36 +00:00
|
|
|
}
|
2015-07-11 01:40:15 +00:00
|
|
|
|
2017-09-09 19:35:09 +00:00
|
|
|
config_set_string(conf, "input_driver",
|
|
|
|
joypad_ident);
|
2016-07-01 06:53:27 +00:00
|
|
|
config_set_string(conf, "input_device",
|
2017-04-25 14:07:17 +00:00
|
|
|
input_config_get_device_name(user));
|
2015-07-11 01:14:36 +00:00
|
|
|
|
2017-04-25 14:49:54 +00:00
|
|
|
pid_user = input_config_get_pid(user);
|
|
|
|
vid_user = input_config_get_vid(user);
|
|
|
|
|
2018-02-17 10:55:39 +00:00
|
|
|
if (pid_user && vid_user)
|
2015-07-11 01:14:36 +00:00
|
|
|
{
|
2016-07-01 06:53:27 +00:00
|
|
|
config_set_int(conf, "input_vendor_id",
|
2017-04-25 14:49:54 +00:00
|
|
|
vid_user);
|
2016-07-01 06:53:27 +00:00
|
|
|
config_set_int(conf, "input_product_id",
|
2017-04-25 14:49:54 +00:00
|
|
|
pid_user);
|
2015-07-11 01:14:36 +00:00
|
|
|
}
|
|
|
|
|
2015-07-11 01:40:15 +00:00
|
|
|
for (i = 0; i < RARCH_FIRST_META_KEY; i++)
|
2015-07-11 01:14:36 +00:00
|
|
|
{
|
2019-04-21 04:20:25 +00:00
|
|
|
const struct retro_keybind *bind = &input_config_binds[user][i];
|
|
|
|
if (bind->valid)
|
2019-04-21 05:30:14 +00:00
|
|
|
input_config_save_keybind(
|
|
|
|
conf, "input", input_config_bind_map_get_base(i),
|
2019-04-21 04:20:25 +00:00
|
|
|
bind, false);
|
2015-07-11 01:14:36 +00:00
|
|
|
}
|
2016-05-27 03:13:05 +00:00
|
|
|
|
2019-01-03 17:34:00 +00:00
|
|
|
ret = config_file_write(conf, autoconf_file, false);
|
2016-05-27 03:13:05 +00:00
|
|
|
|
2015-07-11 01:14:36 +00:00
|
|
|
config_file_free(conf);
|
2017-09-09 19:35:09 +00:00
|
|
|
free(autoconf_file);
|
2015-07-11 02:20:19 +00:00
|
|
|
return ret;
|
2015-07-11 01:14:36 +00:00
|
|
|
}
|
|
|
|
|
2016-08-26 01:10:01 +00:00
|
|
|
/**
|
|
|
|
* config_save_file:
|
|
|
|
* @path : Path that shall be written to.
|
|
|
|
*
|
|
|
|
* Writes a config file to disk.
|
|
|
|
*
|
|
|
|
* Returns: true (1) on success, otherwise returns false (0).
|
|
|
|
**/
|
|
|
|
bool config_save_file(const char *path)
|
|
|
|
{
|
|
|
|
float msg_color;
|
2016-09-05 15:16:37 +00:00
|
|
|
unsigned i = 0;
|
|
|
|
bool ret = false;
|
|
|
|
struct config_bool_setting *bool_settings = NULL;
|
|
|
|
struct config_int_setting *int_settings = NULL;
|
2017-04-28 17:55:09 +00:00
|
|
|
struct config_uint_setting *uint_settings = NULL;
|
2018-07-13 20:12:09 +00:00
|
|
|
struct config_size_setting *size_settings = NULL;
|
2016-09-05 15:16:37 +00:00
|
|
|
struct config_float_setting *float_settings = NULL;
|
|
|
|
struct config_array_setting *array_settings = NULL;
|
|
|
|
struct config_path_setting *path_settings = NULL;
|
2019-07-18 14:15:02 +00:00
|
|
|
config_file_t *conf = config_file_new_from_path_to_string(path);
|
2016-09-05 15:16:37 +00:00
|
|
|
settings_t *settings = config_get_ptr();
|
2017-04-28 19:05:34 +00:00
|
|
|
int bool_settings_size = sizeof(settings->bools) / sizeof(settings->bools.placeholder);
|
|
|
|
int float_settings_size = sizeof(settings->floats)/ sizeof(settings->floats.placeholder);
|
|
|
|
int int_settings_size = sizeof(settings->ints) / sizeof(settings->ints.placeholder);
|
|
|
|
int uint_settings_size = sizeof(settings->uints) / sizeof(settings->uints.placeholder);
|
2018-07-13 20:12:09 +00:00
|
|
|
int size_settings_size = sizeof(settings->sizes) / sizeof(settings->sizes.placeholder);
|
2017-04-28 22:43:20 +00:00
|
|
|
int array_settings_size = sizeof(settings->arrays)/ sizeof(settings->arrays.placeholder);
|
|
|
|
int path_settings_size = sizeof(settings->paths) / sizeof(settings->paths.placeholder);
|
2016-08-26 16:26:24 +00:00
|
|
|
|
|
|
|
if (!conf)
|
2019-07-17 17:50:32 +00:00
|
|
|
conf = config_file_new_alloc();
|
2016-08-26 16:26:24 +00:00
|
|
|
|
2017-05-15 03:06:23 +00:00
|
|
|
if (!conf || rarch_ctl(RARCH_CTL_IS_OVERRIDES_ACTIVE, NULL))
|
2016-08-26 16:26:24 +00:00
|
|
|
{
|
|
|
|
if (conf)
|
|
|
|
config_file_free(conf);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2016-12-26 03:14:09 +00:00
|
|
|
bool_settings = populate_settings_bool (settings, &bool_settings_size);
|
|
|
|
int_settings = populate_settings_int (settings, &int_settings_size);
|
2017-04-28 17:55:09 +00:00
|
|
|
uint_settings = populate_settings_uint (settings, &uint_settings_size);
|
2018-07-13 20:12:09 +00:00
|
|
|
size_settings = populate_settings_size (settings, &size_settings_size);
|
2016-12-26 03:14:09 +00:00
|
|
|
float_settings = populate_settings_float (settings, &float_settings_size);
|
|
|
|
array_settings = populate_settings_array (settings, &array_settings_size);
|
|
|
|
path_settings = populate_settings_path (settings, &path_settings_size);
|
2016-08-26 01:10:01 +00:00
|
|
|
|
2016-08-29 18:18:20 +00:00
|
|
|
/* Path settings */
|
2016-12-26 02:01:29 +00:00
|
|
|
if (path_settings && (path_settings_size > 0))
|
2016-07-24 05:14:24 +00:00
|
|
|
{
|
2016-12-26 02:01:29 +00:00
|
|
|
for (i = 0; i < (unsigned)path_settings_size; i++)
|
|
|
|
{
|
|
|
|
const char *value = path_settings[i].ptr;
|
2016-08-30 02:20:28 +00:00
|
|
|
|
2016-12-26 02:01:29 +00:00
|
|
|
if (path_settings[i].def_enable && string_is_empty(path_settings[i].ptr))
|
|
|
|
value = "default";
|
2016-08-30 02:20:28 +00:00
|
|
|
|
2016-12-26 02:01:29 +00:00
|
|
|
config_set_path(conf, path_settings[i].ident, value);
|
|
|
|
}
|
|
|
|
|
|
|
|
free(path_settings);
|
2016-07-24 05:14:24 +00:00
|
|
|
}
|
2013-01-10 06:11:37 +00:00
|
|
|
|
2016-07-25 06:06:04 +00:00
|
|
|
#ifdef HAVE_MENU
|
|
|
|
config_set_path(conf, "xmb_font",
|
2017-07-14 19:11:27 +00:00
|
|
|
!string_is_empty(settings->paths.path_menu_xmb_font)
|
2017-04-28 22:39:29 +00:00
|
|
|
? settings->paths.path_menu_xmb_font : "");
|
2016-07-25 06:06:04 +00:00
|
|
|
#endif
|
|
|
|
|
2016-08-29 18:18:20 +00:00
|
|
|
/* String settings */
|
2016-12-26 02:01:29 +00:00
|
|
|
if (array_settings && (array_settings_size > 0))
|
|
|
|
{
|
|
|
|
for (i = 0; i < (unsigned)array_settings_size; i++)
|
2018-03-09 22:23:34 +00:00
|
|
|
if (!array_settings[i].override ||
|
|
|
|
!retroarch_override_setting_is_set(array_settings[i].override, NULL))
|
|
|
|
config_set_string(conf,
|
|
|
|
array_settings[i].ident,
|
|
|
|
array_settings[i].ptr);
|
2016-12-26 02:01:29 +00:00
|
|
|
|
|
|
|
free(array_settings);
|
|
|
|
}
|
2016-07-24 04:07:24 +00:00
|
|
|
|
2016-08-29 18:18:20 +00:00
|
|
|
/* Float settings */
|
2016-12-26 02:01:29 +00:00
|
|
|
if (float_settings && (float_settings_size > 0))
|
|
|
|
{
|
|
|
|
for (i = 0; i < (unsigned)float_settings_size; i++)
|
2018-03-09 22:23:34 +00:00
|
|
|
if (!float_settings[i].override ||
|
|
|
|
!retroarch_override_setting_is_set(float_settings[i].override, NULL))
|
|
|
|
config_set_float(conf,
|
|
|
|
float_settings[i].ident,
|
|
|
|
*float_settings[i].ptr);
|
2016-12-26 02:01:29 +00:00
|
|
|
|
|
|
|
free(float_settings);
|
|
|
|
}
|
2016-07-23 12:59:07 +00:00
|
|
|
|
2016-08-29 18:18:20 +00:00
|
|
|
/* Integer settings */
|
2016-12-26 02:01:29 +00:00
|
|
|
if (int_settings && (int_settings_size > 0))
|
|
|
|
{
|
|
|
|
for (i = 0; i < (unsigned)int_settings_size; i++)
|
2018-03-09 22:23:34 +00:00
|
|
|
if (!int_settings[i].override ||
|
|
|
|
!retroarch_override_setting_is_set(int_settings[i].override, NULL))
|
|
|
|
config_set_int(conf,
|
|
|
|
int_settings[i].ident,
|
|
|
|
*int_settings[i].ptr);
|
2016-12-26 02:01:29 +00:00
|
|
|
|
|
|
|
free(int_settings);
|
|
|
|
}
|
2016-07-24 03:01:11 +00:00
|
|
|
|
2017-04-28 17:55:09 +00:00
|
|
|
if (uint_settings && (uint_settings_size > 0))
|
|
|
|
{
|
|
|
|
for (i = 0; i < (unsigned)uint_settings_size; i++)
|
2018-03-09 22:23:34 +00:00
|
|
|
if (!uint_settings[i].override ||
|
|
|
|
!retroarch_override_setting_is_set(uint_settings[i].override, NULL))
|
|
|
|
config_set_int(conf,
|
|
|
|
uint_settings[i].ident,
|
|
|
|
*uint_settings[i].ptr);
|
2017-04-28 17:55:09 +00:00
|
|
|
|
|
|
|
free(uint_settings);
|
|
|
|
}
|
|
|
|
|
2018-07-13 20:12:09 +00:00
|
|
|
if (size_settings && (size_settings_size > 0))
|
|
|
|
{
|
|
|
|
for (i = 0; i < (unsigned)size_settings_size; i++)
|
|
|
|
if (!size_settings[i].override ||
|
|
|
|
!retroarch_override_setting_is_set(size_settings[i].override, NULL))
|
|
|
|
config_set_int(conf,
|
|
|
|
size_settings[i].ident,
|
2018-08-04 18:02:33 +00:00
|
|
|
(int)*size_settings[i].ptr);
|
2018-07-13 20:12:09 +00:00
|
|
|
|
|
|
|
free(size_settings);
|
|
|
|
}
|
|
|
|
|
2016-07-24 03:57:20 +00:00
|
|
|
for (i = 0; i < MAX_USERS; i++)
|
|
|
|
{
|
2016-10-09 07:05:41 +00:00
|
|
|
char cfg[64];
|
|
|
|
|
|
|
|
cfg[0] = '\0';
|
2016-07-24 03:57:20 +00:00
|
|
|
|
|
|
|
snprintf(cfg, sizeof(cfg), "input_device_p%u", i + 1);
|
2017-04-28 19:03:04 +00:00
|
|
|
config_set_int(conf, cfg, settings->uints.input_device[i]);
|
2016-07-24 03:57:20 +00:00
|
|
|
snprintf(cfg, sizeof(cfg), "input_player%u_joypad_index", i + 1);
|
2017-04-28 19:03:04 +00:00
|
|
|
config_set_int(conf, cfg, settings->uints.input_joypad_map[i]);
|
2016-07-24 03:57:20 +00:00
|
|
|
snprintf(cfg, sizeof(cfg), "input_libretro_device_p%u", i + 1);
|
2017-04-25 15:14:46 +00:00
|
|
|
config_set_int(conf, cfg, input_config_get_device(i));
|
2016-07-24 03:57:20 +00:00
|
|
|
snprintf(cfg, sizeof(cfg), "input_player%u_analog_dpad_mode", i + 1);
|
2017-04-28 19:03:04 +00:00
|
|
|
config_set_int(conf, cfg, settings->uints.input_analog_dpad_mode[i]);
|
2017-06-08 14:13:45 +00:00
|
|
|
snprintf(cfg, sizeof(cfg), "input_player%u_mouse_index", i + 1);
|
|
|
|
config_set_int(conf, cfg, settings->uints.input_mouse_index[i]);
|
2016-07-24 03:57:20 +00:00
|
|
|
}
|
|
|
|
|
2016-08-29 18:18:20 +00:00
|
|
|
/* Boolean settings */
|
2016-12-26 02:01:29 +00:00
|
|
|
if (bool_settings && (bool_settings_size > 0))
|
|
|
|
{
|
|
|
|
for (i = 0; i < (unsigned)bool_settings_size; i++)
|
2018-03-09 22:23:34 +00:00
|
|
|
if (!bool_settings[i].override ||
|
|
|
|
!retroarch_override_setting_is_set(bool_settings[i].override, NULL))
|
|
|
|
config_set_bool(conf, bool_settings[i].ident,
|
|
|
|
*bool_settings[i].ptr);
|
2016-12-26 02:01:29 +00:00
|
|
|
|
|
|
|
free(bool_settings);
|
|
|
|
}
|
2016-08-30 02:20:28 +00:00
|
|
|
|
2016-07-24 02:37:46 +00:00
|
|
|
#ifdef HAVE_NETWORKGAMEPAD
|
|
|
|
for (i = 0; i < MAX_USERS; i++)
|
|
|
|
{
|
2016-10-09 07:05:41 +00:00
|
|
|
char tmp[64];
|
|
|
|
|
|
|
|
tmp[0] = '\0';
|
|
|
|
|
2016-07-24 02:37:46 +00:00
|
|
|
snprintf(tmp, sizeof(tmp), "network_remote_enable_user_p%u", i + 1);
|
2017-04-28 11:43:47 +00:00
|
|
|
config_set_bool(conf, tmp, settings->bools.network_remote_enable_user[i]);
|
2016-07-24 02:37:46 +00:00
|
|
|
}
|
|
|
|
#endif
|
2016-08-30 02:20:28 +00:00
|
|
|
|
2018-03-09 22:23:34 +00:00
|
|
|
/* Verbosity isn't in bool_settings since it needs to be loaded differently */
|
2017-08-31 02:42:29 +00:00
|
|
|
if (!retroarch_override_setting_is_set(RARCH_OVERRIDE_SETTING_VERBOSITY, NULL))
|
|
|
|
config_set_bool(conf, "log_verbosity",
|
|
|
|
verbosity_is_enabled());
|
2016-07-24 02:37:46 +00:00
|
|
|
config_set_bool(conf, "perfcnt_enable",
|
2017-05-15 03:06:23 +00:00
|
|
|
rarch_ctl(RARCH_CTL_IS_PERFCNT_ENABLE, NULL));
|
2016-07-24 02:37:46 +00:00
|
|
|
|
2017-04-28 12:57:55 +00:00
|
|
|
msg_color = (((int)(settings->floats.video_msg_color_r * 255.0f) & 0xff) << 16) +
|
|
|
|
(((int)(settings->floats.video_msg_color_g * 255.0f) & 0xff) << 8) +
|
|
|
|
(((int)(settings->floats.video_msg_color_b * 255.0f) & 0xff));
|
2016-07-25 06:06:04 +00:00
|
|
|
|
2016-08-29 18:18:20 +00:00
|
|
|
/* Hexadecimal settings */
|
2016-07-24 03:57:20 +00:00
|
|
|
config_set_hex(conf, "video_message_color", msg_color);
|
|
|
|
|
2016-05-08 12:00:51 +00:00
|
|
|
video_driver_save_settings(conf);
|
2015-05-20 21:13:39 +00:00
|
|
|
|
2016-03-21 22:46:36 +00:00
|
|
|
#ifdef HAVE_LAKKA
|
2017-05-03 15:01:37 +00:00
|
|
|
if (settings->bools.ssh_enable)
|
2017-12-10 21:25:38 +00:00
|
|
|
filestream_close(filestream_open(LAKKA_SSH_PATH,
|
2017-12-11 11:53:47 +00:00
|
|
|
RETRO_VFS_FILE_ACCESS_WRITE,
|
|
|
|
RETRO_VFS_FILE_ACCESS_HINT_NONE));
|
2016-03-21 22:46:36 +00:00
|
|
|
else
|
2017-12-14 18:29:36 +00:00
|
|
|
filestream_delete(LAKKA_SSH_PATH);
|
2017-05-03 15:01:37 +00:00
|
|
|
if (settings->bools.samba_enable)
|
2017-12-10 21:25:38 +00:00
|
|
|
filestream_close(filestream_open(LAKKA_SAMBA_PATH,
|
2017-12-11 11:53:47 +00:00
|
|
|
RETRO_VFS_FILE_ACCESS_WRITE,
|
|
|
|
RETRO_VFS_FILE_ACCESS_HINT_NONE));
|
2016-03-23 12:58:01 +00:00
|
|
|
else
|
2017-12-14 18:29:36 +00:00
|
|
|
filestream_delete(LAKKA_SAMBA_PATH);
|
2017-05-03 15:01:37 +00:00
|
|
|
if (settings->bools.bluetooth_enable)
|
2017-12-10 21:25:38 +00:00
|
|
|
filestream_close(filestream_open(LAKKA_BLUETOOTH_PATH,
|
2017-12-11 11:53:47 +00:00
|
|
|
RETRO_VFS_FILE_ACCESS_WRITE,
|
|
|
|
RETRO_VFS_FILE_ACCESS_HINT_NONE));
|
2016-03-23 13:06:53 +00:00
|
|
|
else
|
2017-12-14 18:29:36 +00:00
|
|
|
filestream_delete(LAKKA_BLUETOOTH_PATH);
|
2016-03-21 22:46:36 +00:00
|
|
|
#endif
|
|
|
|
|
2015-01-05 00:58:00 +00:00
|
|
|
for (i = 0; i < MAX_USERS; i++)
|
2019-04-21 05:30:14 +00:00
|
|
|
input_config_save_keybinds_user(conf, i);
|
2013-09-29 17:37:48 +00:00
|
|
|
|
2019-01-03 17:34:00 +00:00
|
|
|
ret = config_file_write(conf, path, true);
|
2013-01-05 21:18:59 +00:00
|
|
|
config_file_free(conf);
|
2016-08-26 00:00:06 +00:00
|
|
|
|
2013-09-22 10:48:33 +00:00
|
|
|
return ret;
|
2013-01-05 21:18:59 +00:00
|
|
|
}
|
2016-05-27 14:42:20 +00:00
|
|
|
|
2016-08-25 06:34:51 +00:00
|
|
|
/**
|
2016-08-26 14:43:29 +00:00
|
|
|
* config_save_overrides:
|
2016-08-25 06:34:51 +00:00
|
|
|
* @path : Path that shall be written to.
|
|
|
|
*
|
2016-08-26 14:43:29 +00:00
|
|
|
* Writes a config file override to disk.
|
2016-08-25 06:34:51 +00:00
|
|
|
*
|
|
|
|
* Returns: true (1) on success, otherwise returns false (0).
|
|
|
|
**/
|
2016-08-26 14:43:29 +00:00
|
|
|
bool config_save_overrides(int override_type)
|
2016-08-25 06:34:51 +00:00
|
|
|
{
|
2017-09-09 19:35:09 +00:00
|
|
|
size_t path_size = PATH_MAX_LENGTH * sizeof(char);
|
2016-12-26 03:14:09 +00:00
|
|
|
int tmp_i = 0;
|
2016-09-05 15:17:28 +00:00
|
|
|
unsigned i = 0;
|
2016-08-27 00:35:21 +00:00
|
|
|
bool ret = false;
|
|
|
|
config_file_t *conf = NULL;
|
|
|
|
settings_t *settings = NULL;
|
2016-09-05 15:16:37 +00:00
|
|
|
struct config_bool_setting *bool_settings = NULL;
|
|
|
|
struct config_bool_setting *bool_overrides = NULL;
|
|
|
|
struct config_int_setting *int_settings = NULL;
|
2017-04-28 17:55:09 +00:00
|
|
|
struct config_uint_setting *uint_settings = NULL;
|
2018-07-13 20:12:09 +00:00
|
|
|
struct config_size_setting *size_settings = NULL;
|
2016-09-05 15:16:37 +00:00
|
|
|
struct config_int_setting *int_overrides = NULL;
|
2017-04-28 17:55:09 +00:00
|
|
|
struct config_uint_setting *uint_overrides = NULL;
|
2018-07-13 20:12:09 +00:00
|
|
|
struct config_size_setting *size_overrides = NULL;
|
2016-09-05 15:16:37 +00:00
|
|
|
struct config_float_setting *float_settings = NULL;
|
|
|
|
struct config_float_setting *float_overrides= NULL;
|
|
|
|
struct config_array_setting *array_settings = NULL;
|
|
|
|
struct config_array_setting *array_overrides= NULL;
|
|
|
|
struct config_path_setting *path_settings = NULL;
|
|
|
|
struct config_path_setting *path_overrides = NULL;
|
2018-02-04 22:02:52 +00:00
|
|
|
char *config_directory = NULL;
|
|
|
|
char *override_directory = NULL;
|
|
|
|
char *core_path = NULL;
|
|
|
|
char *game_path = NULL;
|
2018-05-13 21:20:51 +00:00
|
|
|
char *content_path = NULL;
|
2017-04-23 14:41:26 +00:00
|
|
|
settings_t *overrides = config_get_ptr();
|
2017-04-28 22:43:20 +00:00
|
|
|
int bool_settings_size = sizeof(settings->bools) / sizeof(settings->bools.placeholder);
|
2017-04-28 13:01:11 +00:00
|
|
|
int float_settings_size = sizeof(settings->floats) / sizeof(settings->floats.placeholder);
|
2017-04-28 18:08:12 +00:00
|
|
|
int int_settings_size = sizeof(settings->ints) / sizeof(settings->ints.placeholder);
|
2017-04-28 22:43:20 +00:00
|
|
|
int uint_settings_size = sizeof(settings->uints) / sizeof(settings->uints.placeholder);
|
2018-07-13 20:12:09 +00:00
|
|
|
int size_settings_size = sizeof(settings->sizes) / sizeof(settings->sizes.placeholder);
|
2017-04-28 22:43:20 +00:00
|
|
|
int array_settings_size = sizeof(settings->arrays) / sizeof(settings->arrays.placeholder);
|
|
|
|
int path_settings_size = sizeof(settings->paths) / sizeof(settings->paths.placeholder);
|
2017-04-23 14:41:26 +00:00
|
|
|
rarch_system_info_t *system = runloop_get_system_info();
|
2018-02-04 22:02:52 +00:00
|
|
|
const char *core_name = system ? system->info.library_name : NULL;
|
2019-04-21 04:20:25 +00:00
|
|
|
const char *rarch_path_basename = path_get(RARCH_PATH_BASENAME);
|
|
|
|
const char *game_name = path_basename(rarch_path_basename);
|
2018-05-13 21:20:51 +00:00
|
|
|
char content_dir_name[PATH_MAX_LENGTH];
|
|
|
|
|
2019-04-21 04:20:25 +00:00
|
|
|
if (!string_is_empty(rarch_path_basename))
|
|
|
|
fill_pathname_parent_dir_name(content_dir_name, rarch_path_basename, sizeof(content_dir_name));
|
2016-08-26 16:26:24 +00:00
|
|
|
|
|
|
|
if (string_is_empty(core_name) || string_is_empty(game_name))
|
2018-02-04 22:02:52 +00:00
|
|
|
return false;
|
2016-08-26 16:26:24 +00:00
|
|
|
|
2019-06-17 12:10:55 +00:00
|
|
|
settings = (settings_t*)calloc(1, sizeof(settings_t));
|
|
|
|
config_directory = (char*)malloc(PATH_MAX_LENGTH);
|
|
|
|
override_directory = (char*)malloc(PATH_MAX_LENGTH);
|
|
|
|
core_path = (char*)malloc(PATH_MAX_LENGTH);
|
|
|
|
game_path = (char*)malloc(PATH_MAX_LENGTH);
|
|
|
|
content_path = (char*)malloc(PATH_MAX_LENGTH);
|
2016-08-26 16:26:24 +00:00
|
|
|
|
2016-10-20 16:36:01 +00:00
|
|
|
config_directory[0] = override_directory[0] = core_path[0] = game_path[0] = '\0';
|
|
|
|
|
2017-09-09 19:35:09 +00:00
|
|
|
fill_pathname_application_special(config_directory, path_size,
|
2016-08-26 05:44:05 +00:00
|
|
|
APPLICATION_SPECIAL_DIRECTORY_CONFIG);
|
|
|
|
|
2017-07-14 19:11:27 +00:00
|
|
|
fill_pathname_join(override_directory, config_directory, core_name,
|
2017-09-09 19:35:09 +00:00
|
|
|
path_size);
|
2016-08-26 14:43:29 +00:00
|
|
|
|
2019-04-22 00:43:09 +00:00
|
|
|
if (!path_is_directory(override_directory))
|
2016-08-26 14:43:29 +00:00
|
|
|
path_mkdir(override_directory);
|
|
|
|
|
2016-08-26 05:44:05 +00:00
|
|
|
/* Concatenate strings into full paths for core_path, game_path */
|
|
|
|
fill_pathname_join_special_ext(game_path,
|
|
|
|
config_directory, core_name,
|
|
|
|
game_name,
|
2019-09-18 16:12:57 +00:00
|
|
|
".cfg",
|
2017-09-09 19:35:09 +00:00
|
|
|
path_size);
|
2016-08-26 05:44:05 +00:00
|
|
|
|
2018-05-13 21:20:51 +00:00
|
|
|
fill_pathname_join_special_ext(content_path,
|
|
|
|
config_directory, core_name,
|
|
|
|
content_dir_name,
|
2019-09-18 16:12:57 +00:00
|
|
|
".cfg",
|
2018-05-13 21:20:51 +00:00
|
|
|
path_size);
|
|
|
|
|
2016-08-26 05:44:05 +00:00
|
|
|
fill_pathname_join_special_ext(core_path,
|
|
|
|
config_directory, core_name,
|
|
|
|
core_name,
|
2019-09-18 16:12:57 +00:00
|
|
|
".cfg",
|
2017-09-09 19:35:09 +00:00
|
|
|
path_size);
|
2016-08-26 05:44:05 +00:00
|
|
|
|
2016-08-26 14:43:29 +00:00
|
|
|
if (!conf)
|
2019-07-17 17:50:32 +00:00
|
|
|
conf = config_file_new_alloc();
|
2016-08-26 05:44:05 +00:00
|
|
|
|
2016-08-26 00:00:06 +00:00
|
|
|
/* Load the original config file in memory */
|
2019-04-22 05:38:44 +00:00
|
|
|
config_load_file(path_get(RARCH_PATH_CONFIG), settings);
|
2016-08-25 15:30:30 +00:00
|
|
|
|
2016-12-26 03:14:09 +00:00
|
|
|
bool_settings = populate_settings_bool(settings, &bool_settings_size);
|
2017-04-28 12:33:18 +00:00
|
|
|
tmp_i = sizeof(settings->bools) / sizeof(settings->bools.placeholder);
|
|
|
|
bool_overrides = populate_settings_bool(overrides, &tmp_i);
|
2016-12-26 03:14:09 +00:00
|
|
|
|
|
|
|
int_settings = populate_settings_int(settings, &int_settings_size);
|
2017-04-28 18:08:12 +00:00
|
|
|
tmp_i = sizeof(settings->ints) / sizeof(settings->ints.placeholder);
|
2016-12-26 03:14:09 +00:00
|
|
|
int_overrides = populate_settings_int (overrides, &tmp_i);
|
|
|
|
|
2017-04-28 17:55:09 +00:00
|
|
|
uint_settings = populate_settings_uint(settings, &uint_settings_size);
|
2017-04-28 19:05:34 +00:00
|
|
|
tmp_i = sizeof(settings->uints) / sizeof(settings->uints.placeholder);
|
2017-04-28 17:55:09 +00:00
|
|
|
uint_overrides = populate_settings_uint (overrides, &tmp_i);
|
|
|
|
|
2018-07-13 20:12:09 +00:00
|
|
|
size_settings = populate_settings_size(settings, &size_settings_size);
|
|
|
|
tmp_i = sizeof(settings->sizes) / sizeof(settings->sizes.placeholder);
|
|
|
|
size_overrides = populate_settings_size (overrides, &tmp_i);
|
|
|
|
|
2016-12-26 03:14:09 +00:00
|
|
|
float_settings = populate_settings_float(settings, &float_settings_size);
|
2017-04-28 13:01:11 +00:00
|
|
|
tmp_i = sizeof(settings->floats) / sizeof(settings->floats.placeholder);
|
2016-12-26 03:14:09 +00:00
|
|
|
float_overrides = populate_settings_float(overrides, &tmp_i);
|
|
|
|
|
|
|
|
array_settings = populate_settings_array(settings, &array_settings_size);
|
2017-04-28 21:02:22 +00:00
|
|
|
tmp_i = sizeof(settings->arrays) / sizeof(settings->arrays.placeholder);
|
2016-12-26 03:14:09 +00:00
|
|
|
array_overrides = populate_settings_array (overrides, &tmp_i);
|
|
|
|
|
|
|
|
path_settings = populate_settings_path(settings, &path_settings_size);
|
2017-04-28 22:43:20 +00:00
|
|
|
tmp_i = sizeof(settings->paths) / sizeof(settings->paths.placeholder);
|
2016-12-26 03:14:09 +00:00
|
|
|
path_overrides = populate_settings_path (overrides, &tmp_i);
|
2016-08-26 01:10:01 +00:00
|
|
|
|
2019-04-22 06:29:29 +00:00
|
|
|
RARCH_LOG("[Overrides] looking for changed settings... \n");
|
2016-08-29 13:36:55 +00:00
|
|
|
|
2016-09-23 14:03:37 +00:00
|
|
|
if (conf)
|
2016-08-25 15:30:30 +00:00
|
|
|
{
|
2016-09-23 14:03:37 +00:00
|
|
|
for (i = 0; i < (unsigned)bool_settings_size; i++)
|
2016-08-26 00:00:06 +00:00
|
|
|
{
|
2016-09-23 14:03:37 +00:00
|
|
|
if ((*bool_settings[i].ptr) != (*bool_overrides[i].ptr))
|
|
|
|
config_set_bool(conf, bool_overrides[i].ident,
|
|
|
|
(*bool_overrides[i].ptr));
|
2016-08-26 00:00:06 +00:00
|
|
|
}
|
2016-09-23 14:03:37 +00:00
|
|
|
for (i = 0; i < (unsigned)int_settings_size; i++)
|
2016-08-26 00:14:10 +00:00
|
|
|
{
|
2016-09-23 14:03:37 +00:00
|
|
|
if ((*int_settings[i].ptr) != (*int_overrides[i].ptr))
|
|
|
|
config_set_int(conf, int_overrides[i].ident,
|
|
|
|
(*int_overrides[i].ptr));
|
2016-08-26 00:14:10 +00:00
|
|
|
}
|
2017-04-28 17:55:09 +00:00
|
|
|
for (i = 0; i < (unsigned)uint_settings_size; i++)
|
|
|
|
{
|
|
|
|
if ((*uint_settings[i].ptr) != (*uint_overrides[i].ptr))
|
|
|
|
config_set_int(conf, uint_overrides[i].ident,
|
|
|
|
(*uint_overrides[i].ptr));
|
|
|
|
}
|
2018-07-13 20:12:09 +00:00
|
|
|
for (i = 0; i < (unsigned)size_settings_size; i++)
|
|
|
|
{
|
|
|
|
if ((*size_settings[i].ptr) != (*size_overrides[i].ptr))
|
|
|
|
config_set_int(conf, size_overrides[i].ident,
|
2018-08-04 18:02:33 +00:00
|
|
|
(int)(*size_overrides[i].ptr));
|
2018-07-13 20:12:09 +00:00
|
|
|
}
|
2016-09-23 14:03:37 +00:00
|
|
|
for (i = 0; i < (unsigned)float_settings_size; i++)
|
2016-08-26 00:30:10 +00:00
|
|
|
{
|
2016-09-23 14:03:37 +00:00
|
|
|
if ((*float_settings[i].ptr) != (*float_overrides[i].ptr))
|
|
|
|
config_set_float(conf, float_overrides[i].ident,
|
|
|
|
*float_overrides[i].ptr);
|
2016-08-26 00:30:10 +00:00
|
|
|
}
|
2016-09-23 14:03:37 +00:00
|
|
|
|
|
|
|
for (i = 0; i < (unsigned)array_settings_size; i++)
|
2016-08-26 00:49:31 +00:00
|
|
|
{
|
2016-09-23 14:03:37 +00:00
|
|
|
if (!string_is_equal(array_settings[i].ptr, array_overrides[i].ptr))
|
|
|
|
config_set_string(conf, array_overrides[i].ident,
|
|
|
|
array_overrides[i].ptr);
|
2016-08-26 00:49:31 +00:00
|
|
|
}
|
2016-09-23 14:03:37 +00:00
|
|
|
|
|
|
|
for (i = 0; i < (unsigned)path_settings_size; i++)
|
2016-08-26 01:10:01 +00:00
|
|
|
{
|
2016-09-23 14:03:37 +00:00
|
|
|
if (!string_is_equal(path_settings[i].ptr, path_overrides[i].ptr))
|
|
|
|
config_set_path(conf, path_overrides[i].ident,
|
|
|
|
path_overrides[i].ptr);
|
2016-08-26 01:10:01 +00:00
|
|
|
}
|
2016-08-25 15:30:30 +00:00
|
|
|
|
2016-11-20 16:47:50 +00:00
|
|
|
for (i = 0; i < MAX_USERS; i++)
|
|
|
|
{
|
|
|
|
char cfg[64];
|
|
|
|
|
|
|
|
cfg[0] = '\0';
|
2018-03-25 15:27:17 +00:00
|
|
|
if (settings->uints.input_device[i]
|
2018-02-17 10:55:39 +00:00
|
|
|
!= overrides->uints.input_device[i])
|
2016-11-20 16:47:50 +00:00
|
|
|
{
|
|
|
|
snprintf(cfg, sizeof(cfg), "input_device_p%u", i + 1);
|
2017-04-28 19:03:04 +00:00
|
|
|
config_set_int(conf, cfg, overrides->uints.input_device[i]);
|
2016-11-20 16:47:50 +00:00
|
|
|
}
|
2018-02-17 10:55:39 +00:00
|
|
|
|
2018-03-25 15:27:17 +00:00
|
|
|
if (settings->uints.input_joypad_map[i]
|
2018-02-17 10:55:39 +00:00
|
|
|
!= overrides->uints.input_joypad_map[i])
|
2016-11-20 16:47:50 +00:00
|
|
|
{
|
|
|
|
snprintf(cfg, sizeof(cfg), "input_player%u_joypad_index", i + 1);
|
2017-04-28 19:03:04 +00:00
|
|
|
config_set_int(conf, cfg, overrides->uints.input_joypad_map[i]);
|
2016-11-20 16:47:50 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-09-24 15:00:41 +00:00
|
|
|
ret = false;
|
2016-09-21 22:58:19 +00:00
|
|
|
|
2016-09-24 15:00:41 +00:00
|
|
|
switch (override_type)
|
|
|
|
{
|
|
|
|
case OVERRIDE_CORE:
|
|
|
|
/* Create a new config file from core_path */
|
2019-04-22 06:29:29 +00:00
|
|
|
RARCH_LOG ("[Overrides] path %s\n", core_path);
|
2019-01-03 17:34:00 +00:00
|
|
|
ret = config_file_write(conf, core_path, true);
|
2016-09-24 15:00:41 +00:00
|
|
|
break;
|
|
|
|
case OVERRIDE_GAME:
|
|
|
|
/* Create a new config file from core_path */
|
2019-04-22 06:29:29 +00:00
|
|
|
RARCH_LOG ("[Overrides] path %s\n", game_path);
|
2019-01-03 17:34:00 +00:00
|
|
|
ret = config_file_write(conf, game_path, true);
|
2016-09-24 15:00:41 +00:00
|
|
|
break;
|
2018-05-13 21:20:51 +00:00
|
|
|
case OVERRIDE_CONTENT_DIR:
|
|
|
|
/* Create a new config file from content_path */
|
2019-04-22 06:29:29 +00:00
|
|
|
RARCH_LOG ("[Overrides] path %s\n", content_path);
|
2019-01-03 17:34:00 +00:00
|
|
|
ret = config_file_write(conf, content_path, true);
|
2018-05-13 21:20:51 +00:00
|
|
|
break;
|
2016-09-24 15:00:41 +00:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
2016-09-21 22:58:19 +00:00
|
|
|
|
2016-09-24 15:00:41 +00:00
|
|
|
config_file_free(conf);
|
|
|
|
}
|
2016-08-26 06:06:15 +00:00
|
|
|
|
2016-08-29 17:26:08 +00:00
|
|
|
if (bool_settings)
|
|
|
|
free(bool_settings);
|
|
|
|
if (bool_overrides)
|
|
|
|
free(bool_overrides);
|
|
|
|
if (int_settings)
|
|
|
|
free(int_settings);
|
2017-04-28 17:55:09 +00:00
|
|
|
if (uint_settings)
|
|
|
|
free(uint_settings);
|
2018-07-13 20:12:09 +00:00
|
|
|
if (size_settings)
|
|
|
|
free(size_settings);
|
2016-08-29 17:26:08 +00:00
|
|
|
if (int_overrides)
|
|
|
|
free(int_overrides);
|
2017-04-28 19:47:26 +00:00
|
|
|
if (uint_overrides)
|
|
|
|
free(uint_overrides);
|
2016-08-29 17:26:08 +00:00
|
|
|
if (float_settings)
|
|
|
|
free(float_settings);
|
|
|
|
if (float_overrides)
|
|
|
|
free(float_overrides);
|
2016-09-01 00:53:04 +00:00
|
|
|
if (array_settings)
|
|
|
|
free(array_settings);
|
|
|
|
if (array_overrides)
|
|
|
|
free(array_overrides);
|
2016-08-29 17:26:08 +00:00
|
|
|
if (path_settings)
|
|
|
|
free(path_settings);
|
|
|
|
if (path_overrides)
|
|
|
|
free(path_overrides);
|
2018-08-18 04:56:10 +00:00
|
|
|
if (size_overrides)
|
|
|
|
free(size_overrides);
|
2016-08-26 05:44:05 +00:00
|
|
|
free(settings);
|
2017-09-09 19:35:09 +00:00
|
|
|
free(config_directory);
|
|
|
|
free(override_directory);
|
|
|
|
free(core_path);
|
|
|
|
free(game_path);
|
2016-08-26 06:06:15 +00:00
|
|
|
|
|
|
|
return ret;
|
2016-08-25 06:34:51 +00:00
|
|
|
}
|
|
|
|
|
2016-05-27 14:42:20 +00:00
|
|
|
/* Replaces currently loaded configuration file with
|
|
|
|
* another one. Will load a dummy core to flush state
|
|
|
|
* properly. */
|
2019-01-10 21:49:23 +00:00
|
|
|
bool config_replace(bool config_replace_save_on_exit, char *path)
|
2016-05-27 14:42:20 +00:00
|
|
|
{
|
|
|
|
content_ctx_info_t content_info = {0};
|
2019-04-21 04:20:25 +00:00
|
|
|
const char *rarch_path_config = path_get(RARCH_PATH_CONFIG);
|
2016-05-27 14:42:20 +00:00
|
|
|
|
|
|
|
/* If config file to be replaced is the same as the
|
|
|
|
* current config file, exit. */
|
2019-04-21 04:20:25 +00:00
|
|
|
if (string_is_equal(path, rarch_path_config))
|
2016-05-27 14:42:20 +00:00
|
|
|
return false;
|
|
|
|
|
2019-01-10 21:49:23 +00:00
|
|
|
if (config_replace_save_on_exit && !path_is_empty(RARCH_PATH_CONFIG))
|
2019-04-21 04:20:25 +00:00
|
|
|
config_save_file(rarch_path_config);
|
2016-05-27 14:42:20 +00:00
|
|
|
|
2016-09-29 05:46:21 +00:00
|
|
|
path_set(RARCH_PATH_CONFIG, path);
|
2016-05-27 14:42:20 +00:00
|
|
|
|
|
|
|
rarch_ctl(RARCH_CTL_UNSET_BLOCK_CONFIG_READ, NULL);
|
|
|
|
|
2016-07-25 04:47:15 +00:00
|
|
|
/* Load core in new config. */
|
2016-09-30 02:31:19 +00:00
|
|
|
path_clear(RARCH_PATH_CORE);
|
2016-05-27 14:42:20 +00:00
|
|
|
|
2019-06-04 19:52:58 +00:00
|
|
|
return task_push_start_dummy_core(&content_info);
|
2016-05-27 14:42:20 +00:00
|
|
|
}
|