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
|
|
|
|
2010-12-24 00:26:36 +00:00
|
|
|
#include "general.h"
|
2015-07-02 03:26:10 +00:00
|
|
|
#include "msg_hash.h"
|
2015-12-06 18:31:47 +00:00
|
|
|
#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"
|
2015-12-05 14:55:26 +00:00
|
|
|
#include "camera/camera_driver.h"
|
2015-12-05 15:12:29 +00:00
|
|
|
#include "record/record_driver.h"
|
2015-12-05 14:47:33 +00:00
|
|
|
#include "location/location_driver.h"
|
2015-12-05 15:54:03 +00:00
|
|
|
#include "libretro_version_1.h"
|
2015-07-01 00:08:44 +00:00
|
|
|
|
2014-05-30 15:49:04 +00:00
|
|
|
#ifdef HAVE_MENU
|
2015-12-06 16:55:27 +00:00
|
|
|
#include "menu/menu_driver.h"
|
2014-05-30 15:49:04 +00:00
|
|
|
#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
|
2010-12-24 00:26:36 +00:00
|
|
|
|
2015-06-04 20:37:00 +00:00
|
|
|
#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
|
|
|
{
|
2014-10-14 16:42:47 +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
|
|
|
|
2015-06-04 20:37:00 +00:00
|
|
|
switch (hash)
|
2014-08-31 17:06:32 +00:00
|
|
|
{
|
2015-06-04 20:37:00 +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
|
2015-06-04 20:37:00 +00:00
|
|
|
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
|
2015-06-04 20:37:00 +00:00
|
|
|
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;
|
2015-01-12 20:12:48 +00:00
|
|
|
}
|
2014-08-26 19:13:14 +00:00
|
|
|
|
2014-10-14 16:42:47 +00:00
|
|
|
return drv;
|
2014-08-26 18:55:24 +00:00
|
|
|
}
|
|
|
|
|
2015-01-08 02:40:43 +00:00
|
|
|
/**
|
|
|
|
* find_driver_index:
|
|
|
|
* @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.
|
|
|
|
**/
|
2015-01-12 17:06:38 +00:00
|
|
|
int find_driver_index(const char * label, const char *drv)
|
2014-08-26 18:55:24 +00:00
|
|
|
{
|
|
|
|
unsigned i;
|
2015-12-06 12:28:20 +00:00
|
|
|
char str[256];
|
2015-06-12 21:24:24 +00:00
|
|
|
const void *obj = NULL;
|
2014-08-31 17:06:32 +00:00
|
|
|
|
2014-10-01 11:32:41 +00:00
|
|
|
for (i = 0; (obj = (const void*)
|
|
|
|
find_driver_nonempty(label, i, str, sizeof(str))) != NULL; i++)
|
2014-08-26 18:55:24 +00:00
|
|
|
{
|
2014-08-31 17:06:32 +00:00
|
|
|
if (!obj)
|
|
|
|
return -1;
|
2015-12-26 06:07:01 +00:00
|
|
|
if (string_is_empty(str))
|
2014-08-26 18:32:48 +00:00
|
|
|
break;
|
2014-10-14 16:42:47 +00:00
|
|
|
if (!strcasecmp(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;
|
|
|
|
}
|
|
|
|
|
2015-06-02 16:28:51 +00:00
|
|
|
bool find_first_driver(const char *label, char *s, size_t len)
|
2015-03-09 13:32:58 +00:00
|
|
|
{
|
2015-06-02 16:28:51 +00:00
|
|
|
find_driver_nonempty(label, 0, s, len);
|
2015-03-09 13:32:58 +00:00
|
|
|
return true;
|
|
|
|
}
|
2015-01-12 15:49:37 +00:00
|
|
|
|
2015-01-08 02:40:43 +00:00
|
|
|
/**
|
|
|
|
* find_prev_driver:
|
|
|
|
* @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.
|
|
|
|
**/
|
2015-06-02 16:28:51 +00:00
|
|
|
bool find_prev_driver(const char *label, char *s, size_t len)
|
2014-08-26 20:26:23 +00:00
|
|
|
{
|
2015-06-02 16:28:51 +00:00
|
|
|
int i = find_driver_index(label, s);
|
2014-08-26 20:26:23 +00:00
|
|
|
if (i > 0)
|
2015-06-02 16:28:51 +00:00
|
|
|
find_driver_nonempty(label, i - 1, s, len);
|
2014-08-26 20:26:23 +00:00
|
|
|
else
|
2015-03-09 03:22:41 +00:00
|
|
|
{
|
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);
|
2015-03-09 03:22:41 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return true;
|
2014-08-26 20:26:23 +00:00
|
|
|
}
|
|
|
|
|
2015-01-08 02:40:43 +00:00
|
|
|
/**
|
|
|
|
* find_next_driver:
|
|
|
|
* @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.
|
|
|
|
**/
|
2015-06-02 16:28:51 +00:00
|
|
|
bool find_next_driver(const char *label, char *s, size_t len)
|
2014-08-26 20:26:23 +00:00
|
|
|
{
|
2015-06-02 16:28:51 +00:00
|
|
|
int i = find_driver_index(label, s);
|
|
|
|
if (i >= 0 && (strcmp(s, "null") != 0))
|
|
|
|
find_driver_nonempty(label, i + 1, s, len);
|
2014-08-26 20:26:23 +00:00
|
|
|
else
|
2015-03-09 03:22:41 +00:00
|
|
|
{
|
2015-06-02 16:28:51 +00:00
|
|
|
RARCH_WARN("Couldn't find any next driver (current one: \"%s\").\n", s);
|
2015-03-09 03:22:41 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return true;
|
2014-08-26 20:26:23 +00:00
|
|
|
}
|
|
|
|
|
2015-01-18 18:32:40 +00:00
|
|
|
static void driver_adjust_system_rates(void)
|
2012-08-11 22:40:21 +00:00
|
|
|
{
|
2015-12-10 21:30:25 +00:00
|
|
|
rarch_system_info_t *system = NULL;
|
|
|
|
|
|
|
|
runloop_ctl(RUNLOOP_CTL_SYSTEM_INFO_GET, &system);
|
2015-11-22 14:07:11 +00:00
|
|
|
audio_driver_ctl(RARCH_AUDIO_CTL_MONITOR_ADJUST_SYSTEM_RATES, NULL);
|
2015-11-20 19:47:47 +00:00
|
|
|
video_driver_ctl(RARCH_DISPLAY_CTL_MONITOR_ADJUST_SYSTEM_RATES, NULL);
|
2015-01-18 18:01:13 +00:00
|
|
|
|
2015-11-23 17:50:49 +00:00
|
|
|
if (!video_driver_get_ptr(false))
|
2015-01-18 18:01:13 +00:00
|
|
|
return;
|
|
|
|
|
2015-06-25 11:33:27 +00:00
|
|
|
if (system->force_nonblock)
|
2015-04-13 09:26:02 +00:00
|
|
|
event_command(EVENT_CMD_VIDEO_SET_NONBLOCKING_STATE);
|
2015-01-18 18:01:13 +00:00
|
|
|
else
|
2015-12-11 10:04:16 +00:00
|
|
|
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
|
|
|
**/
|
2015-12-11 10:04:16 +00:00
|
|
|
static void driver_set_nonblock_state(void)
|
2013-04-13 22:53:05 +00:00
|
|
|
{
|
2015-12-11 10:04:16 +00:00
|
|
|
rarch_system_info_t *system = NULL;
|
2015-12-06 14:29:41 +00:00
|
|
|
settings_t *settings = config_get_ptr();
|
|
|
|
bool enable = input_driver_ctl(
|
|
|
|
RARCH_INPUT_CTL_IS_NONBLOCK_STATE, NULL);
|
2015-12-10 21:30:25 +00:00
|
|
|
|
|
|
|
runloop_ctl(RUNLOOP_CTL_SYSTEM_INFO_GET, &system);
|
2015-03-20 19:43:22 +00:00
|
|
|
|
2014-09-02 02:43:31 +00:00
|
|
|
/* Only apply non-block-state for video if we're using vsync. */
|
2015-12-06 14:29:41 +00:00
|
|
|
if (video_driver_ctl(RARCH_DISPLAY_CTL_IS_ACTIVE, NULL)
|
|
|
|
&& video_driver_get_ptr(false))
|
2013-04-13 22:53:05 +00:00
|
|
|
{
|
2015-01-12 04:37:52 +00:00
|
|
|
bool video_nonblock = enable;
|
|
|
|
|
2015-06-25 11:33:27 +00:00
|
|
|
if (!settings->video.vsync || system->force_nonblock)
|
2014-10-01 11:04:58 +00:00
|
|
|
video_nonblock = true;
|
2015-11-20 16:22:19 +00:00
|
|
|
video_driver_ctl(RARCH_DISPLAY_CTL_SET_NONBLOCK_STATE, &video_nonblock);
|
2013-04-13 22:53:05 +00:00
|
|
|
}
|
|
|
|
|
2015-05-19 19:18:07 +00:00
|
|
|
audio_driver_set_nonblocking_state(enable);
|
2012-08-11 22:40:21 +00:00
|
|
|
}
|
|
|
|
|
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).
|
|
|
|
**/
|
2015-12-11 10:12:20 +00:00
|
|
|
static bool driver_update_system_av_info(const struct retro_system_av_info *info)
|
2014-02-20 21:48:31 +00:00
|
|
|
{
|
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
|
|
|
|
2015-05-20 16:57:17 +00:00
|
|
|
memcpy(av_info, info, sizeof(*av_info));
|
2015-04-13 09:26:02 +00:00
|
|
|
event_command(EVENT_CMD_REINIT);
|
2014-08-02 01:56:19 +00:00
|
|
|
|
2014-09-02 02:43:31 +00:00
|
|
|
/* Cannot continue recording with different parameters.
|
|
|
|
* Take the easiest route out and just restart the recording. */
|
2015-12-05 15:05:35 +00:00
|
|
|
if (recording_driver_get_data_ptr())
|
2014-02-20 21:48:31 +00:00
|
|
|
{
|
2015-12-07 14:32:14 +00:00
|
|
|
runloop_msg_queue_push_new(
|
2015-07-01 00:08:44 +00:00
|
|
|
MSG_RESTARTING_RECORDING_DUE_TO_DRIVER_REINIT, 2, 180, false);
|
2015-04-13 09:26:02 +00:00
|
|
|
event_command(EVENT_CMD_RECORD_DEINIT);
|
|
|
|
event_command(EVENT_CMD_RECORD_INIT);
|
2014-02-20 21:48:31 +00:00
|
|
|
}
|
2014-08-12 03:28:43 +00:00
|
|
|
|
2014-02-20 21:48:31 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2015-10-27 23:55:11 +00:00
|
|
|
#ifdef HAVE_MENU
|
2015-04-27 03:38:27 +00:00
|
|
|
/**
|
|
|
|
* 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
|
|
|
|
2015-12-06 18:31:47 +00:00
|
|
|
if (!info)
|
2015-04-27 03:38:27 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
#ifndef HAVE_DYNAMIC
|
|
|
|
retro_get_system_info(info);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
event_command(EVENT_CMD_CORE_INFO_INIT);
|
|
|
|
event_command(EVENT_CMD_LOAD_CORE_PERSIST);
|
|
|
|
}
|
2015-10-27 23:55:11 +00:00
|
|
|
#endif
|
2015-04-27 03:38:27 +00:00
|
|
|
|
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)
|
2014-10-03 10:51:02 +00:00
|
|
|
{
|
2014-10-08 04:49:04 +00:00
|
|
|
if (flags & DRIVER_VIDEO)
|
2015-11-29 19:23:16 +00:00
|
|
|
video_driver_ctl(RARCH_DISPLAY_CTL_UNSET_OWN_DRIVER, NULL);
|
2014-10-08 04:49:04 +00:00
|
|
|
if (flags & DRIVER_AUDIO)
|
2015-11-29 19:26:30 +00:00
|
|
|
audio_driver_ctl(RARCH_AUDIO_CTL_UNSET_OWN_DRIVER, NULL);
|
2014-10-08 04:49:04 +00:00
|
|
|
if (flags & DRIVER_INPUT)
|
2015-11-29 19:34:35 +00:00
|
|
|
input_driver_ctl(RARCH_INPUT_CTL_UNSET_OWN_DRIVER, NULL);
|
2014-10-08 04:49:04 +00:00
|
|
|
if (flags & DRIVER_CAMERA)
|
2015-12-05 13:39:52 +00:00
|
|
|
camera_driver_ctl(RARCH_CAMERA_CTL_UNSET_OWN_DRIVER, NULL);
|
2014-10-08 04:49:04 +00:00
|
|
|
if (flags & DRIVER_LOCATION)
|
2015-12-05 14:40:29 +00:00
|
|
|
location_driver_ctl(RARCH_LOCATION_CTL_UNSET_OWN_DRIVER, NULL);
|
2014-10-08 04:49:04 +00:00
|
|
|
|
2014-10-03 10:51:02 +00:00
|
|
|
#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);
|
2014-10-03 10:51:02 +00:00
|
|
|
#endif
|
|
|
|
|
2014-10-08 04:49:04 +00:00
|
|
|
if (flags & (DRIVER_VIDEO | DRIVER_AUDIO))
|
2015-01-18 17:28:14 +00:00
|
|
|
driver_adjust_system_rates();
|
2014-10-03 10:51:02 +00:00
|
|
|
|
2014-10-08 04:49:04 +00:00
|
|
|
if (flags & DRIVER_VIDEO)
|
|
|
|
{
|
2015-05-20 17:56:12 +00:00
|
|
|
const struct retro_hw_render_callback *hw_render =
|
|
|
|
(const struct retro_hw_render_callback*)video_driver_callback();
|
|
|
|
|
2015-11-20 18:04:00 +00:00
|
|
|
video_driver_ctl(RARCH_DISPLAY_CTL_MONITOR_RESET, NULL);
|
2015-11-20 18:01:13 +00:00
|
|
|
video_driver_ctl(RARCH_DISPLAY_CTL_INIT, NULL);
|
2014-10-03 10:51:02 +00:00
|
|
|
|
2015-11-29 19:44:51 +00:00
|
|
|
if (!video_driver_ctl(RARCH_DISPLAY_CTL_IS_VIDEO_CACHE_CONTEXT_ACK, NULL)
|
2015-05-20 17:56:12 +00:00
|
|
|
&& hw_render->context_reset)
|
|
|
|
hw_render->context_reset();
|
2015-11-29 19:44:51 +00:00
|
|
|
video_driver_ctl(RARCH_DISPLAY_CTL_UNSET_VIDEO_CACHE_CONTEXT_ACK, NULL);
|
2014-10-03 10:51:02 +00:00
|
|
|
|
2015-12-04 11:26:39 +00:00
|
|
|
runloop_ctl(RUNLOOP_CTL_SET_FRAME_TIME_LAST, NULL);
|
2014-10-08 04:49:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (flags & DRIVER_AUDIO)
|
2015-11-22 13:28:00 +00:00
|
|
|
audio_driver_ctl(RARCH_AUDIO_CTL_INIT, NULL);
|
2014-10-03 10:51:02 +00:00
|
|
|
|
|
|
|
/* 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))
|
2014-10-03 10:51:02 +00:00
|
|
|
init_camera();
|
|
|
|
|
|
|
|
/* 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))
|
2014-10-03 10:51:02 +00:00
|
|
|
init_location();
|
|
|
|
|
|
|
|
#ifdef HAVE_MENU
|
2015-04-27 02:03:44 +00:00
|
|
|
menu_update_libretro_info();
|
|
|
|
|
2014-10-08 04:49:04 +00:00
|
|
|
if (flags & DRIVER_MENU)
|
2015-03-22 05:29:51 +00:00
|
|
|
{
|
2014-10-08 04:49:04 +00:00
|
|
|
init_menu();
|
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
|
|
|
}
|
2014-10-03 10:51:02 +00:00
|
|
|
#endif
|
|
|
|
|
2014-10-08 04:49:04 +00:00
|
|
|
if (flags & (DRIVER_VIDEO | DRIVER_AUDIO))
|
|
|
|
{
|
|
|
|
/* Keep non-throttled state as good as possible. */
|
2015-11-29 16:53:11 +00:00
|
|
|
if (input_driver_ctl(RARCH_INPUT_CTL_IS_NONBLOCK_STATE, NULL))
|
2015-12-11 10:04:16 +00:00
|
|
|
driver_ctl(RARCH_DRIVER_CTL_SET_NONBLOCK_STATE, NULL);
|
2014-10-08 04:49:04 +00:00
|
|
|
}
|
2014-10-03 10:51:02 +00:00
|
|
|
}
|
|
|
|
|
2014-09-12 20:18:44 +00:00
|
|
|
|
2015-01-12 04:37:52 +00:00
|
|
|
/**
|
|
|
|
* uninit_drivers:
|
|
|
|
* @flags : Bitmask of drivers to deinitialize.
|
|
|
|
*
|
|
|
|
* Deinitializes drivers.
|
|
|
|
* @flags determines which drivers get deinitialized.
|
|
|
|
**/
|
2015-12-11 10:23:32 +00:00
|
|
|
static void uninit_drivers(int flags)
|
2014-10-03 10:51:02 +00:00
|
|
|
{
|
|
|
|
#ifdef HAVE_MENU
|
2014-10-08 04:49:04 +00:00
|
|
|
if (flags & DRIVER_MENU)
|
2014-10-03 10:51:02 +00:00
|
|
|
{
|
2015-12-12 22:36:43 +00:00
|
|
|
menu_driver_ctl(RARCH_MENU_CTL_CONTEXT_DESTROY, NULL);
|
2015-12-05 12:00:45 +00:00
|
|
|
if (!menu_driver_ctl(RARCH_MENU_CTL_OWNS_DRIVER, NULL))
|
2015-12-05 12:04:21 +00:00
|
|
|
menu_driver_ctl(RARCH_MENU_CTL_DEINIT, NULL);
|
2014-10-03 10:51:02 +00:00
|
|
|
}
|
|
|
|
#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);
|
2014-10-03 10:51:02 +00:00
|
|
|
|
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);
|
2014-10-03 10:51:02 +00:00
|
|
|
|
2015-05-10 21:46:24 +00:00
|
|
|
if (flags & DRIVER_AUDIO)
|
2015-11-22 13:28:00 +00:00
|
|
|
audio_driver_ctl(RARCH_AUDIO_CTL_DEINIT, NULL);
|
2015-05-10 21:46:24 +00:00
|
|
|
|
|
|
|
if (flags & DRIVERS_VIDEO_INPUT)
|
2015-11-20 18:01:13 +00:00
|
|
|
video_driver_ctl(RARCH_DISPLAY_CTL_DEINIT, NULL);
|
2015-05-10 21:46:24 +00:00
|
|
|
|
2015-12-04 13:30:59 +00:00
|
|
|
if ((flags & DRIVER_VIDEO) && !video_driver_ctl(RARCH_DISPLAY_CTL_OWNS_DRIVER, NULL))
|
|
|
|
video_driver_ctl(RARCH_DISPLAY_CTL_DESTROY_DATA, NULL);
|
|
|
|
|
2015-11-29 19:34:35 +00:00
|
|
|
if ((flags & DRIVER_INPUT) && !input_driver_ctl(RARCH_INPUT_CTL_OWNS_DRIVER, NULL))
|
2015-12-04 13:30:59 +00:00
|
|
|
input_driver_ctl(RARCH_INPUT_CTL_DESTROY_DATA, NULL);
|
|
|
|
|
|
|
|
if ((flags & DRIVER_AUDIO) && !audio_driver_ctl(RARCH_AUDIO_CTL_OWNS_DRIVER, NULL))
|
|
|
|
audio_driver_ctl(RARCH_AUDIO_CTL_DESTROY_DATA, NULL);
|
2014-10-03 10:51:02 +00:00
|
|
|
}
|
2015-03-18 18:40:00 +00:00
|
|
|
|
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:
|
|
|
|
video_driver_ctl(RARCH_DISPLAY_CTL_DESTROY, NULL);
|
|
|
|
audio_driver_ctl(RARCH_AUDIO_CTL_DESTROY, NULL);
|
|
|
|
input_driver_ctl(RARCH_INPUT_CTL_DESTROY, NULL);
|
|
|
|
#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);
|
|
|
|
retro_uninit_libretro_cbs();
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
return true;
|
2015-12-11 10:21:17 +00:00
|
|
|
case RARCH_DRIVER_CTL_INIT:
|
|
|
|
{
|
|
|
|
int *flags = (int*)data;
|
|
|
|
if (!flags)
|
|
|
|
return false;
|
|
|
|
init_drivers(*flags);
|
|
|
|
}
|
|
|
|
return true;
|
2015-12-11 10:00:12 +00:00
|
|
|
case RARCH_DRIVER_CTL_INIT_PRE:
|
|
|
|
audio_driver_ctl(RARCH_AUDIO_CTL_FIND_DRIVER, NULL);
|
|
|
|
video_driver_ctl(RARCH_DISPLAY_CTL_FIND_DRIVER, NULL);
|
|
|
|
input_driver_ctl(RARCH_INPUT_CTL_FIND_DRIVER, NULL);
|
|
|
|
find_camera_driver();
|
|
|
|
find_location_driver();
|
|
|
|
#ifdef HAVE_MENU
|
|
|
|
find_menu_driver();
|
|
|
|
#endif
|
|
|
|
break;
|
|
|
|
case RARCH_DRIVER_CTL_SET_REFRESH_RATE:
|
|
|
|
{
|
|
|
|
float *hz = (float*)data;
|
|
|
|
video_monitor_set_refresh_rate(*hz);
|
|
|
|
audio_driver_ctl(RARCH_AUDIO_CTL_MONITOR_SET_REFRESH_RATE, NULL);
|
|
|
|
driver_adjust_system_rates();
|
|
|
|
}
|
|
|
|
break;
|
2015-12-11 10:04:16 +00:00
|
|
|
case RARCH_DRIVER_CTL_SET_NONBLOCK_STATE:
|
|
|
|
driver_set_nonblock_state();
|
|
|
|
break;
|
2015-12-11 10:12:20 +00:00
|
|
|
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-11 10:12:20 +00:00
|
|
|
}
|
2015-12-26 08:49:58 +00:00
|
|
|
return false;
|
2015-12-11 09:43:53 +00:00
|
|
|
case RARCH_DRIVER_CTL_NONE:
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|