RetroArch/driver.c

529 lines
15 KiB
C
Raw Normal View History

2012-04-21 21:13:50 +00:00
/* RetroArch - A frontend for libretro.
2014-01-01 00:50:59 +00:00
* Copyright (C) 2010-2014 - Hans-Kristian Arntzen
2016-01-10 03:06:50 +00:00
* Copyright (C) 2011-2016 - Daniel De Matteis
2010-12-24 00:33:40 +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-24 00:33:40 +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-24 00:33:40 +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-24 00:33:40 +00:00
* If not, see <http://www.gnu.org/licenses/>.
*/
2015-09-04 19:11:00 +00:00
#include <compat/posix_string.h>
2015-12-26 06:07:01 +00:00
#include <string/stdstring.h>
2015-09-04 19:11:00 +00:00
#include "command.h"
#include "general.h"
2015-07-02 03:26:10 +00:00
#include "msg_hash.h"
#include "system.h"
2011-01-07 16:59:53 +00:00
2015-11-23 18:40:09 +00:00
#include "audio/audio_driver.h"
2015-11-23 20:58:39 +00:00
#include "audio/audio_resampler_driver.h"
#include "camera/camera_driver.h"
#include "record/record_driver.h"
#include "location/location_driver.h"
2016-05-08 03:29:10 +00:00
#include "core.h"
2015-07-01 00:08:44 +00:00
#ifdef HAVE_MENU
2015-12-06 16:55:27 +00:00
#include "menu/menu_driver.h"
#endif
2011-01-07 16:59:53 +00:00
#ifdef HAVE_CONFIG_H
2010-12-30 02:02:30 +00:00
#include "config.h"
2011-01-07 16:59:53 +00:00
#endif
#define HASH_LOCATION_DRIVER 0x09189689U
#define HASH_CAMERA_DRIVER 0xf25db959U
#define HASH_MENU_DRIVER 0xd607fb05U
#define HASH_INPUT_DRIVER 0x4c087840U
#define HASH_INPUT_JOYPAD_DRIVER 0xab124146U
#define HASH_VIDEO_DRIVER 0x1805a5e7U
#define HASH_AUDIO_DRIVER 0x26594002U
#define HASH_AUDIO_RESAMPLER_DRIVER 0xedcba9ecU
#define HASH_RECORD_DRIVER 0x144cd2cfU
2015-12-05 20:14:44 +00:00
2015-01-08 02:40:43 +00:00
/**
* find_driver_nonempty:
* @label : string of driver type to be found.
* @i : index of driver.
* @str : identifier name of the found driver
* gets written to this string.
2015-06-02 16:28:51 +00:00
* @len : size of @str.
2015-01-08 02:40:43 +00:00
*
* Find driver based on @label.
*
* Returns: NULL if no driver based on @label found, otherwise
* pointer to driver.
**/
2014-08-31 17:06:32 +00:00
static const void *find_driver_nonempty(const char *label, int i,
2015-06-02 16:28:51 +00:00
char *s, size_t len)
2014-08-13 06:55:29 +00:00
{
const void *drv = NULL;
2015-07-02 03:26:10 +00:00
uint32_t hash = msg_hash_calculate(label);
2014-08-26 18:32:48 +00:00
switch (hash)
2014-08-31 17:06:32 +00:00
{
case HASH_CAMERA_DRIVER:
drv = camera_driver_find_handle(i);
if (drv)
strlcpy(s, camera_driver_find_ident(i), len);
break;
case HASH_LOCATION_DRIVER:
drv = location_driver_find_handle(i);
if (drv)
strlcpy(s, location_driver_find_ident(i), len);
break;
case HASH_MENU_DRIVER:
2014-08-26 18:32:48 +00:00
#ifdef HAVE_MENU
drv = menu_driver_find_handle(i);
if (drv)
strlcpy(s, menu_driver_find_ident(i), len);
2014-08-26 18:32:48 +00:00
#endif
break;
case HASH_INPUT_DRIVER:
drv = input_driver_find_handle(i);
if (drv)
strlcpy(s, input_driver_find_ident(i), len);
break;
case HASH_INPUT_JOYPAD_DRIVER:
drv = joypad_driver_find_handle(i);
if (drv)
strlcpy(s, joypad_driver_find_ident(i), len);
break;
case HASH_VIDEO_DRIVER:
drv = video_driver_find_handle(i);
if (drv)
strlcpy(s, video_driver_find_ident(i), len);
break;
case HASH_AUDIO_DRIVER:
drv = audio_driver_find_handle(i);
if (drv)
strlcpy(s, audio_driver_find_ident(i), len);
break;
case HASH_RECORD_DRIVER:
drv = record_driver_find_handle(i);
if (drv)
strlcpy(s, record_driver_find_ident(i), len);
break;
case HASH_AUDIO_RESAMPLER_DRIVER:
drv = audio_resampler_driver_find_handle(i);
if (drv)
strlcpy(s, audio_resampler_driver_find_ident(i), len);
break;
}
2014-08-26 19:13:14 +00:00
return drv;
2014-08-26 18:55:24 +00:00
}
2015-01-08 02:40:43 +00:00
/**
2016-02-01 12:15:53 +00:00
* driver_find_index:
2015-01-08 02:40:43 +00:00
* @label : string of driver type to be found.
* @drv : identifier of driver to be found.
*
* Find index of the driver, based on @label.
*
* Returns: -1 if no driver based on @label and @drv found, otherwise
* index number of the driver found in the array.
**/
2016-02-01 12:15:53 +00:00
static int driver_find_index(const char * label, const char *drv)
2014-08-26 18:55:24 +00:00
{
unsigned i;
2016-06-03 02:37:10 +00:00
char str[256] = {0};
2014-08-31 17:06:32 +00:00
2016-05-26 04:41:28 +00:00
for (i = 0;
find_driver_nonempty(label, i, str, sizeof(str)) != NULL; i++)
2014-08-26 18:55:24 +00:00
{
2015-12-26 06:07:01 +00:00
if (string_is_empty(str))
2014-08-26 18:32:48 +00:00
break;
if (string_is_equal_noncase(drv, str))
2014-08-31 17:06:32 +00:00
return i;
2014-08-26 18:32:48 +00:00
}
2014-08-13 06:55:29 +00:00
return -1;
}
2016-02-01 11:56:17 +00:00
static bool driver_find_first(const char *label, char *s, size_t len)
{
2015-06-02 16:28:51 +00:00
find_driver_nonempty(label, 0, s, len);
return true;
}
2015-01-08 02:40:43 +00:00
/**
2016-02-01 11:56:17 +00:00
* driver_find_prev:
2015-01-08 02:40:43 +00:00
* @label : string of driver type to be found.
2015-06-02 16:28:51 +00:00
* @s : identifier of driver to be found.
* @len : size of @s.
2015-01-08 02:40:43 +00:00
*
* Find previous driver in driver array.
**/
2016-02-01 11:56:17 +00:00
static bool driver_find_prev(const char *label, char *s, size_t len)
{
2016-02-01 12:15:53 +00:00
int i = driver_find_index(label, s);
if (i > 0)
2015-06-02 16:28:51 +00:00
find_driver_nonempty(label, i - 1, s, len);
else
{
2014-10-01 11:32:41 +00:00
RARCH_WARN(
2015-06-02 16:28:51 +00:00
"Couldn't find any previous driver (current one: \"%s\").\n", s);
return false;
}
return true;
}
2015-01-08 02:40:43 +00:00
/**
2016-02-01 11:56:17 +00:00
* driver_find_next:
2015-01-08 02:40:43 +00:00
* @label : string of driver type to be found.
2015-06-02 16:28:51 +00:00
* @s : identifier of driver to be found.
* @len : size of @s.
2015-01-08 02:40:43 +00:00
*
* Find next driver in driver array.
**/
2016-02-01 11:56:17 +00:00
bool driver_find_next(const char *label, char *s, size_t len)
{
2016-02-01 12:15:53 +00:00
int i = driver_find_index(label, s);
2016-01-20 03:07:24 +00:00
if (i >= 0 && !string_is_equal(s, "null"))
2015-06-02 16:28:51 +00:00
find_driver_nonempty(label, i + 1, s, len);
else
{
2016-06-20 02:07:49 +00:00
RARCH_WARN("%s (current one: \"%s\").\n",
msg_hash_to_str(MSG_COULD_NOT_FIND_ANY_NEXT_DRIVER),
s);
return false;
}
return true;
}
static void driver_adjust_system_rates(void)
{
2016-05-08 15:26:17 +00:00
audio_driver_monitor_adjust_system_rates();
2016-05-08 12:00:51 +00:00
video_driver_monitor_adjust_system_rates();
2015-01-18 18:01:13 +00:00
if (!video_driver_get_ptr(false))
2015-01-18 18:01:13 +00:00
return;
if (runloop_ctl(RUNLOOP_CTL_IS_NONBLOCK_FORCED, NULL))
2016-05-09 18:51:53 +00:00
command_event(CMD_EVENT_VIDEO_SET_NONBLOCKING_STATE, NULL);
2015-01-18 18:01:13 +00:00
else
driver_ctl(RARCH_DRIVER_CTL_SET_NONBLOCK_STATE, NULL);
2015-01-18 18:01:13 +00:00
}
2015-01-12 04:37:52 +00:00
/**
* driver_set_nonblock_state:
*
2015-11-29 16:45:07 +00:00
* Sets audio and video drivers to nonblock state (if enabled).
2015-01-12 04:37:52 +00:00
*
2015-11-29 16:45:07 +00:00
* If nonblock state is false, sets
* blocking state for both audio and video drivers instead.
2015-01-12 04:37:52 +00:00
**/
static void driver_set_nonblock_state(void)
{
2015-12-06 14:29:41 +00:00
settings_t *settings = config_get_ptr();
2016-05-08 21:12:04 +00:00
bool enable = input_driver_is_nonblock_state();
2015-12-10 21:30:25 +00:00
/* Only apply non-block-state for video if we're using vsync. */
2016-05-08 12:00:51 +00:00
if (video_driver_is_active() && video_driver_get_ptr(false))
{
2015-01-12 04:37:52 +00:00
bool video_nonblock = enable;
if ( !settings->video.vsync
|| runloop_ctl(RUNLOOP_CTL_IS_NONBLOCK_FORCED, NULL))
2014-10-01 11:04:58 +00:00
video_nonblock = true;
2016-05-08 12:00:51 +00:00
video_driver_set_nonblock_state(video_nonblock);
}
audio_driver_set_nonblocking_state(enable);
}
2015-01-09 20:07:32 +00:00
/**
* driver_update_system_av_info:
2015-12-05 19:05:32 +00:00
* @data : pointer to new A/V info
2015-01-09 20:07:32 +00:00
*
* Update the system Audio/Video information.
* Will reinitialize audio/video drivers.
* Used by RETRO_ENVIRONMENT_SET_SYSTEM_AV_INFO.
*
* Returns: true (1) if successful, otherwise false (0).
**/
static bool driver_update_system_av_info(const struct retro_system_av_info *info)
{
2015-12-05 19:05:32 +00:00
struct retro_system_av_info *av_info = video_viewport_get_system_av_info();
2015-03-21 03:43:18 +00:00
memcpy(av_info, info, sizeof(*av_info));
2016-05-09 18:51:53 +00:00
command_event(CMD_EVENT_REINIT, NULL);
/* Cannot continue recording with different parameters.
* Take the easiest route out and just restart the recording. */
if (recording_driver_get_data_ptr())
{
runloop_msg_queue_push(
msg_hash_to_str(MSG_RESTARTING_RECORDING_DUE_TO_DRIVER_REINIT),
2, 180, false);
2016-05-09 18:51:53 +00:00
command_event(CMD_EVENT_RECORD_DEINIT, NULL);
command_event(CMD_EVENT_RECORD_INIT, NULL);
}
return true;
}
2015-10-27 23:55:11 +00:00
#ifdef HAVE_MENU
/**
* menu_update_libretro_info:
*
* Update menu state which depends on config.
**/
static void menu_update_libretro_info(void)
{
2015-12-10 22:08:34 +00:00
struct retro_system_info *info = NULL;
menu_driver_ctl(RARCH_MENU_CTL_SYSTEM_INFO_GET,
&info);
2015-10-27 23:55:11 +00:00
if (!info)
return;
2016-05-09 18:51:53 +00:00
command_event(CMD_EVENT_CORE_INFO_INIT, NULL);
command_event(CMD_EVENT_LOAD_CORE_PERSIST, NULL);
}
2015-10-27 23:55:11 +00:00
#endif
2015-01-12 04:37:52 +00:00
/**
* init_drivers:
* @flags : Bitmask of drivers to initialize.
*
* Initializes drivers.
* @flags determines which drivers get initialized.
**/
2015-12-11 10:21:17 +00:00
static void init_drivers(int flags)
{
if (flags & DRIVER_VIDEO)
2016-05-08 12:00:51 +00:00
video_driver_unset_own_driver();
if (flags & DRIVER_AUDIO)
2016-05-08 16:24:25 +00:00
audio_driver_unset_own_driver();
if (flags & DRIVER_INPUT)
2016-05-08 21:12:04 +00:00
input_driver_unset_own_driver();
if (flags & DRIVER_CAMERA)
2015-12-05 13:39:52 +00:00
camera_driver_ctl(RARCH_CAMERA_CTL_UNSET_OWN_DRIVER, NULL);
if (flags & DRIVER_LOCATION)
2015-12-05 14:40:29 +00:00
location_driver_ctl(RARCH_LOCATION_CTL_UNSET_OWN_DRIVER, NULL);
#ifdef HAVE_MENU
/* By default, we want the menu to persist through driver reinits. */
2015-12-05 12:00:45 +00:00
menu_driver_ctl(RARCH_MENU_CTL_SET_OWN_DRIVER, NULL);
#endif
if (flags & (DRIVER_VIDEO | DRIVER_AUDIO))
driver_adjust_system_rates();
if (flags & DRIVER_VIDEO)
{
2016-05-08 12:00:51 +00:00
struct retro_hw_render_callback *hwr =
video_driver_get_hw_context();
2016-05-08 12:00:51 +00:00
video_driver_monitor_reset();
video_driver_init();
2016-05-08 12:00:51 +00:00
if (!video_driver_is_video_cache_context_ack()
&& hwr->context_reset)
hwr->context_reset();
2016-05-08 12:00:51 +00:00
video_driver_unset_video_cache_context_ack();
runloop_ctl(RUNLOOP_CTL_SET_FRAME_TIME_LAST, NULL);
}
if (flags & DRIVER_AUDIO)
{
2016-05-08 14:02:46 +00:00
audio_driver_init();
2016-05-08 13:53:12 +00:00
audio_driver_new_devices_list();
}
/* Only initialize camera driver if we're ever going to use it. */
2015-12-05 13:39:52 +00:00
if ((flags & DRIVER_CAMERA) && camera_driver_ctl(RARCH_CAMERA_CTL_IS_ACTIVE, NULL))
2016-03-04 17:16:07 +00:00
camera_driver_ctl(RARCH_CAMERA_CTL_INIT, NULL);
/* Only initialize location driver if we're ever going to use it. */
2015-12-05 14:40:29 +00:00
if ((flags & DRIVER_LOCATION) && location_driver_ctl(RARCH_LOCATION_CTL_IS_ACTIVE, NULL))
init_location();
#ifdef HAVE_MENU
2015-04-27 02:03:44 +00:00
menu_update_libretro_info();
if (flags & DRIVER_MENU)
2015-03-22 05:29:51 +00:00
{
2016-02-09 15:45:28 +00:00
menu_driver_ctl(RARCH_MENU_CTL_INIT, NULL);
2015-12-12 22:34:49 +00:00
menu_driver_ctl(RARCH_MENU_CTL_CONTEXT_RESET, NULL);
2015-03-22 05:29:51 +00:00
}
#endif
if (flags & (DRIVER_VIDEO | DRIVER_AUDIO))
{
/* Keep non-throttled state as good as possible. */
2016-05-08 21:12:04 +00:00
if (input_driver_is_nonblock_state())
driver_ctl(RARCH_DRIVER_CTL_SET_NONBLOCK_STATE, NULL);
}
}
2015-01-12 04:37:52 +00:00
/**
* uninit_drivers:
* @flags : Bitmask of drivers to deinitialize.
*
* Deinitializes drivers.
2016-02-11 01:29:49 +00:00
*
*
2015-01-12 04:37:52 +00:00
* @flags determines which drivers get deinitialized.
**/
2016-02-11 01:29:49 +00:00
/**
* Driver ownership - set this to true if the platform in question needs to 'own'
* the respective handle and therefore skip regular RetroArch
* driver teardown/reiniting procedure.
*
* If to true, the 'free' function will get skipped. It is
* then up to the driver implementation to properly handle
* 'reiniting' inside the 'init' function and make sure it
* returns the existing handle instead of allocating and
* returning a pointer to a new handle.
*
* Typically, if a driver intends to make use of this, it should
* set this to true at the end of its 'init' function.
**/
2015-12-11 10:23:32 +00:00
static void uninit_drivers(int flags)
{
#ifdef HAVE_MENU
if (flags & DRIVER_MENU)
menu_driver_ctl(RARCH_MENU_CTL_DEINIT, NULL);
#endif
2015-12-05 14:40:29 +00:00
if ((flags & DRIVER_LOCATION) && !location_driver_ctl(RARCH_LOCATION_CTL_OWNS_DRIVER, NULL))
2015-12-05 22:03:05 +00:00
location_driver_ctl(RARCH_LOCATION_CTL_DEINIT, NULL);
2015-12-05 13:39:52 +00:00
if ((flags & DRIVER_CAMERA) && !camera_driver_ctl(RARCH_CAMERA_CTL_OWNS_DRIVER, NULL))
2015-12-05 22:03:05 +00:00
camera_driver_ctl(RARCH_CAMERA_CTL_DEINIT, NULL);
if (flags & DRIVER_AUDIO)
2016-05-08 15:54:30 +00:00
audio_driver_deinit();
if (flags & DRIVERS_VIDEO_INPUT)
2016-05-08 12:00:51 +00:00
video_driver_deinit();
2016-05-08 12:00:51 +00:00
if ((flags & DRIVER_VIDEO) && !video_driver_owns_driver())
video_driver_destroy_data();
2016-05-08 21:12:04 +00:00
if ((flags & DRIVER_INPUT) && !input_driver_owns_driver())
input_driver_destroy_data();
2016-05-08 16:24:25 +00:00
if ((flags & DRIVER_AUDIO) && !audio_driver_owns_driver())
audio_driver_destroy_data();
}
2015-12-11 09:43:53 +00:00
bool driver_ctl(enum driver_ctl_state state, void *data)
{
switch (state)
{
case RARCH_DRIVER_CTL_DEINIT:
2016-05-08 12:00:51 +00:00
video_driver_destroy();
2016-05-08 16:24:25 +00:00
audio_driver_destroy();
2016-05-08 21:12:04 +00:00
input_driver_destroy();
2015-12-11 09:43:53 +00:00
#ifdef HAVE_MENU
menu_driver_ctl(RARCH_MENU_CTL_DESTROY, NULL);
#endif
location_driver_ctl(RARCH_LOCATION_CTL_DESTROY, NULL);
camera_driver_ctl(RARCH_CAMERA_CTL_DESTROY, NULL);
2016-05-07 23:33:57 +00:00
core_uninit_libretro_callbacks();
2015-12-11 09:43:53 +00:00
break;
2015-12-11 10:23:32 +00:00
case RARCH_DRIVER_CTL_UNINIT:
{
int *flags = (int*)data;
if (!flags)
return false;
uninit_drivers(*flags);
}
break;
2016-04-10 14:40:36 +00:00
case RARCH_DRIVER_CTL_UNINIT_ALL:
{
int flags = DRIVERS_CMD_ALL;
return driver_ctl(RARCH_DRIVER_CTL_UNINIT, &flags);
}
2015-12-11 10:21:17 +00:00
case RARCH_DRIVER_CTL_INIT:
{
int *flags = (int*)data;
if (!flags)
return false;
init_drivers(*flags);
}
break;
2016-04-10 14:40:36 +00:00
case RARCH_DRIVER_CTL_INIT_ALL:
{
int flags = DRIVERS_CMD_ALL;
return driver_ctl(RARCH_DRIVER_CTL_INIT, &flags);
}
case RARCH_DRIVER_CTL_INIT_PRE:
2016-05-08 14:50:23 +00:00
audio_driver_find_driver();
2016-05-08 12:00:51 +00:00
video_driver_find_driver();
2016-05-08 21:12:04 +00:00
input_driver_find_driver();
2016-03-04 17:16:07 +00:00
camera_driver_ctl(RARCH_CAMERA_CTL_FIND_DRIVER, NULL);
find_location_driver();
#ifdef HAVE_MENU
2016-02-09 15:49:23 +00:00
menu_driver_ctl(RARCH_MENU_CTL_FIND_DRIVER, NULL);
#endif
break;
case RARCH_DRIVER_CTL_SET_REFRESH_RATE:
{
float *hz = (float*)data;
video_monitor_set_refresh_rate(*hz);
2016-05-08 14:54:15 +00:00
audio_driver_monitor_set_rate();
driver_adjust_system_rates();
}
break;
case RARCH_DRIVER_CTL_SET_NONBLOCK_STATE:
driver_set_nonblock_state();
break;
case RARCH_DRIVER_CTL_UPDATE_SYSTEM_AV_INFO:
{
const struct retro_system_av_info **info = (const struct retro_system_av_info**)data;
2015-12-26 08:49:58 +00:00
if (info)
return driver_update_system_av_info(*info);
}
2015-12-26 08:49:58 +00:00
return false;
2016-02-01 11:56:17 +00:00
case RARCH_DRIVER_CTL_FIND_FIRST:
{
driver_ctx_info_t *drv = (driver_ctx_info_t*)data;
if (!drv)
return false;
return driver_find_first(drv->label, drv->s, drv->len);
}
case RARCH_DRIVER_CTL_FIND_PREV:
{
driver_ctx_info_t *drv = (driver_ctx_info_t*)data;
if (!drv)
return false;
return driver_find_prev(drv->label, drv->s, drv->len);
}
case RARCH_DRIVER_CTL_FIND_NEXT:
{
driver_ctx_info_t *drv = (driver_ctx_info_t*)data;
if (!drv)
return false;
return driver_find_next(drv->label, drv->s, drv->len);
}
2016-02-01 12:15:53 +00:00
case RARCH_DRIVER_CTL_FIND_INDEX:
{
driver_ctx_info_t *drv = (driver_ctx_info_t*)data;
if (!drv)
return false;
drv->len = driver_find_index(drv->label, drv->s);
}
break;
2015-12-11 09:43:53 +00:00
case RARCH_DRIVER_CTL_NONE:
default:
break;
}
return true;
2015-12-11 09:43:53 +00:00
}