RetroArch/driver.c

465 lines
12 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
2015-01-07 16:46:50 +00:00
* Copyright (C) 2011-2015 - 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/>.
*/
#include "driver.h"
#include "general.h"
2015-01-09 16:40:47 +00:00
#include "retroarch.h"
#include "runloop.h"
2012-03-16 22:26:57 +00:00
#include "compat/posix_string.h"
#include "gfx/video_monitor.h"
2015-01-18 17:47:53 +00:00
#include "audio/audio_monitor.h"
2011-01-07 16:59:53 +00:00
#ifdef HAVE_MENU
2015-01-10 03:53:37 +00:00
#include "menu/menu.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
static driver_t *g_driver;
void driver_free(void)
{
driver_t *driver = driver_get_ptr();
2015-03-24 08:04:06 +00:00
if (driver)
free(driver);
}
2015-03-22 02:41:20 +00:00
static driver_t *driver_new(void)
{
driver_t *driver = (driver_t*)calloc(1, sizeof(driver_t));
if (!driver)
return NULL;
return driver;
}
void driver_clear_state(void)
{
driver_free();
2015-03-22 02:41:20 +00:00
g_driver = driver_new();
}
driver_t *driver_get_ptr(void)
{
return g_driver;
}
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.
* @sizeof_str : size of @str.
*
* 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,
2014-08-26 19:13:14 +00:00
char *str, size_t sizeof_str)
2014-08-13 06:55:29 +00:00
{
const void *drv = NULL;
2014-08-26 18:32:48 +00:00
2014-08-31 17:06:32 +00:00
if (!strcmp(label, "camera_driver"))
2014-08-26 18:32:48 +00:00
{
drv = camera_driver_find_handle(i);
if (drv)
strlcpy(str, camera_driver_find_ident(i), sizeof_str);
2014-08-31 17:06:32 +00:00
}
else if (!strcmp(label, "location_driver"))
{
drv = location_driver_find_handle(i);
if (drv)
strlcpy(str, location_driver_find_ident(i), sizeof_str);
2014-08-31 17:06:32 +00:00
}
2014-08-26 18:32:48 +00:00
#ifdef HAVE_MENU
2014-08-31 17:06:32 +00:00
else if (!strcmp(label, "menu_driver"))
{
drv = menu_driver_find_handle(i);
if (drv)
strlcpy(str, menu_driver_find_ident(i), sizeof_str);
2014-08-31 17:06:32 +00:00
}
2014-08-26 18:32:48 +00:00
#endif
2014-08-31 17:06:32 +00:00
else if (!strcmp(label, "input_driver"))
{
drv = input_driver_find_handle(i);
if (drv)
strlcpy(str, input_driver_find_ident(i), sizeof_str);
2014-08-31 17:06:32 +00:00
}
else if (!strcmp(label, "input_joypad_driver"))
{
drv = joypad_driver_find_handle(i);
if (drv)
strlcpy(str, joypad_driver_find_ident(i), sizeof_str);
}
2014-08-31 17:06:32 +00:00
else if (!strcmp(label, "video_driver"))
{
drv = video_driver_find_handle(i);
if (drv)
strlcpy(str, video_driver_find_ident(i), sizeof_str);
2014-08-31 17:06:32 +00:00
}
else if (!strcmp(label, "audio_driver"))
{
drv = audio_driver_find_handle(i);
if (drv)
strlcpy(str, audio_driver_find_ident(i), sizeof_str);
2014-08-26 18:55:24 +00:00
}
else if (!strcmp(label, "audio_resampler_driver"))
{
drv = audio_resampler_driver_find_handle(i);
if (drv)
strlcpy(str, audio_resampler_driver_find_ident(i), sizeof_str);
}
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
/**
* 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.
**/
int find_driver_index(const char * label, const char *drv)
2014-08-26 18:55:24 +00:00
{
unsigned i;
2015-01-09 17:04:29 +00:00
char str[PATH_MAX_LENGTH];
2014-10-01 11:04:58 +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;
if (str[0] == '\0')
2014-08-26 18:32:48 +00:00
break;
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;
}
bool find_first_driver(const char *label, char *str, size_t sizeof_str)
{
find_driver_nonempty(label, 0, str, sizeof_str);
return true;
}
2015-01-08 02:40:43 +00:00
/**
* find_prev_driver:
* @label : string of driver type to be found.
* @str : identifier of driver to be found.
* @sizeof_str : size of @str.
*
* Find previous driver in driver array.
**/
bool find_prev_driver(const char *label, char *str, size_t sizeof_str)
{
2014-08-31 17:06:32 +00:00
int i = find_driver_index(label, str);
if (i > 0)
2014-08-31 17:06:32 +00:00
find_driver_nonempty(label, i - 1, str, sizeof_str);
else
{
2014-10-01 11:32:41 +00:00
RARCH_WARN(
"Couldn't find any previous driver (current one: \"%s\").\n", str);
return false;
}
return true;
}
2015-01-08 02:40:43 +00:00
/**
* find_next_driver:
* @label : string of driver type to be found.
* @str : identifier of driver to be found.
* @sizeof_str : size of @str.
*
* Find next driver in driver array.
**/
bool find_next_driver(const char *label, char *str, size_t sizeof_str)
{
2014-08-31 17:06:32 +00:00
int i = find_driver_index(label, str);
if (i >= 0 && (strcmp(str, "null") != 0))
2014-08-31 17:06:32 +00:00
find_driver_nonempty(label, i + 1, str, sizeof_str);
else
{
RARCH_WARN("Couldn't find any next driver (current one: \"%s\").\n", str);
return false;
}
return true;
}
2015-01-12 04:37:52 +00:00
/**
* init_drivers_pre:
*
* Attempts to find a default driver for
* all driver types.
*
* Should be run before init_drivers().
**/
void init_drivers_pre(void)
{
find_audio_driver();
find_video_driver();
find_input_driver();
find_camera_driver();
find_location_driver();
#ifdef HAVE_MENU
find_menu_driver();
#endif
}
static void driver_adjust_system_rates(void)
{
2015-03-21 03:43:18 +00:00
global_t *global = global_get_ptr();
2015-03-21 21:04:34 +00:00
driver_t *driver = driver_get_ptr();
2015-03-21 03:43:18 +00:00
2015-01-18 17:47:53 +00:00
audio_monitor_adjust_system_rates();
video_monitor_adjust_system_rates();
2015-01-18 18:01:13 +00:00
2015-03-21 21:04:34 +00:00
if (!driver->video_data)
2015-01-18 18:01:13 +00:00
return;
2015-03-21 03:43:18 +00:00
if (global->system.force_nonblock)
event_command(EVENT_CMD_VIDEO_SET_NONBLOCKING_STATE);
2015-01-18 18:01:13 +00:00
else
2015-03-21 21:04:34 +00:00
driver_set_nonblock_state(driver->nonblock_state);
2015-01-18 18:01:13 +00:00
}
/**
* driver_set_refresh_rate:
* @hz : New refresh rate for monitor.
*
* Sets monitor refresh rate to new value by calling
* video_monitor_set_refresh_rate(). Subsequently
* calls audio_monitor_set_refresh_rate().
**/
void driver_set_refresh_rate(float hz)
{
video_monitor_set_refresh_rate(hz);
audio_monitor_set_refresh_rate();
2015-01-18 18:08:07 +00:00
driver_adjust_system_rates();
}
2015-01-12 04:37:52 +00:00
/**
* driver_set_nonblock_state:
* @enable : Enable nonblock state?
*
* Sets audio and video drivers to nonblock state.
*
* If @enable is false, sets blocking state for both
* audio and video drivers instead.
**/
void driver_set_nonblock_state(bool enable)
{
2015-03-20 19:43:22 +00:00
settings_t *settings = config_get_ptr();
2015-03-21 03:43:18 +00:00
global_t *global = global_get_ptr();
2015-03-21 21:04:34 +00:00
driver_t *driver = driver_get_ptr();
2015-03-20 19:43:22 +00:00
/* Only apply non-block-state for video if we're using vsync. */
2015-03-21 21:04:34 +00:00
if (driver->video_active && driver->video_data)
{
2015-01-12 04:37:52 +00:00
bool video_nonblock = enable;
2015-03-21 03:43:18 +00:00
if (!settings->video.vsync || global->system.force_nonblock)
2014-10-01 11:04:58 +00:00
video_nonblock = true;
2015-03-22 09:29:13 +00:00
video_driver_set_nonblock_state(video_nonblock);
}
2015-03-21 21:04:34 +00:00
if (driver->audio_active && driver->audio_data)
2015-03-23 01:44:49 +00:00
audio_driver_set_nonblock_state(settings->audio.sync ? enable : true);
2015-03-21 03:43:18 +00:00
global->audio_data.chunk_size = enable ?
global->audio_data.nonblock_chunk_size :
global->audio_data.block_chunk_size;
}
2015-01-09 20:07:32 +00:00
/**
* driver_update_system_av_info:
* @info : pointer to new A/V info
*
* 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).
**/
bool driver_update_system_av_info(const struct retro_system_av_info *info)
{
2015-03-21 03:43:18 +00:00
global_t *global = global_get_ptr();
2015-03-21 21:04:34 +00:00
driver_t *driver = driver_get_ptr();
2015-03-21 03:43:18 +00:00
global->system.av_info = *info;
event_command(EVENT_CMD_REINIT);
/* Cannot continue recording with different parameters.
* Take the easiest route out and just restart the recording. */
2015-03-21 21:04:34 +00:00
if (driver->recording_data)
{
static const char *msg = "Restarting recording due to driver reinit.";
rarch_main_msg_queue_push(msg, 2, 180, false);
RARCH_WARN("%s\n", msg);
event_command(EVENT_CMD_RECORD_DEINIT);
event_command(EVENT_CMD_RECORD_INIT);
}
return true;
}
2015-01-12 04:37:52 +00:00
/**
* init_drivers:
* @flags : Bitmask of drivers to initialize.
*
* Initializes drivers.
* @flags determines which drivers get initialized.
**/
void init_drivers(int flags)
{
2015-03-21 21:04:34 +00:00
driver_t *driver = driver_get_ptr();
global_t *global = global_get_ptr();
2015-03-21 21:04:34 +00:00
if (flags & DRIVER_VIDEO)
2015-03-21 21:04:34 +00:00
driver->video_data_own = false;
if (flags & DRIVER_AUDIO)
2015-03-21 21:04:34 +00:00
driver->audio_data_own = false;
if (flags & DRIVER_INPUT)
2015-03-21 21:04:34 +00:00
driver->input_data_own = false;
if (flags & DRIVER_CAMERA)
2015-03-21 21:04:34 +00:00
driver->camera_data_own = false;
if (flags & DRIVER_LOCATION)
2015-03-21 21:04:34 +00:00
driver->location_data_own = false;
#ifdef HAVE_MENU
/* By default, we want the menu to persist through driver reinits. */
2015-03-21 21:04:34 +00:00
driver->menu_data_own = true;
#endif
if (flags & (DRIVER_VIDEO | DRIVER_AUDIO))
driver_adjust_system_rates();
if (flags & DRIVER_VIDEO)
{
2015-01-18 21:48:34 +00:00
init_video();
2015-03-21 21:04:34 +00:00
if (!driver->video_cache_context_ack
2015-03-21 03:43:18 +00:00
&& global->system.hw_render_callback.context_reset)
global->system.hw_render_callback.context_reset();
2015-03-21 21:04:34 +00:00
driver->video_cache_context_ack = false;
2015-03-21 03:43:18 +00:00
global->system.frame_time_last = 0;
}
if (flags & DRIVER_AUDIO)
init_audio();
/* Only initialize camera driver if we're ever going to use it. */
2015-03-21 21:04:34 +00:00
if ((flags & DRIVER_CAMERA) && driver->camera_active)
init_camera();
/* Only initialize location driver if we're ever going to use it. */
2015-03-21 21:04:34 +00:00
if ((flags & DRIVER_LOCATION) && driver->location_active)
init_location();
#ifdef HAVE_MENU
if (flags & DRIVER_MENU)
2015-03-22 05:29:51 +00:00
{
init_menu();
menu_update_libretro_info(&global->menu.info);
2015-03-22 05:29:51 +00:00
}
#endif
if (flags & (DRIVER_VIDEO | DRIVER_AUDIO))
{
/* Keep non-throttled state as good as possible. */
2015-03-21 21:04:34 +00:00
if (driver->nonblock_state)
driver_set_nonblock_state(driver->nonblock_state);
}
}
2015-01-12 04:37:52 +00:00
/**
* uninit_drivers:
* @flags : Bitmask of drivers to deinitialize.
*
* Deinitializes drivers.
* @flags determines which drivers get deinitialized.
**/
void uninit_drivers(int flags)
{
2015-03-21 21:04:34 +00:00
driver_t *driver = driver_get_ptr();
if (flags & DRIVER_AUDIO)
uninit_audio();
if (flags & DRIVER_VIDEO)
{
2015-03-21 03:43:18 +00:00
global_t *global = global_get_ptr();
if (global->system.hw_render_callback.context_destroy &&
2015-03-21 21:04:34 +00:00
!driver->video_cache_context)
2015-03-21 03:43:18 +00:00
global->system.hw_render_callback.context_destroy();
}
#ifdef HAVE_MENU
if (flags & DRIVER_MENU)
{
menu_driver_context_destroy();
if (!driver->menu_data_own)
{
menu_free_list(driver->menu);
menu_free(driver->menu);
driver->menu = NULL;
}
}
#endif
if (flags & DRIVERS_VIDEO_INPUT)
uninit_video_input();
2015-03-21 21:04:34 +00:00
if ((flags & DRIVER_VIDEO) && !driver->video_data_own)
driver->video_data = NULL;
2015-03-21 21:04:34 +00:00
if ((flags & DRIVER_CAMERA) && !driver->camera_data_own)
{
uninit_camera();
2015-03-21 21:04:34 +00:00
driver->camera_data = NULL;
}
2015-03-21 21:04:34 +00:00
if ((flags & DRIVER_LOCATION) && !driver->location_data_own)
{
uninit_location();
2015-03-21 21:04:34 +00:00
driver->location_data = NULL;
}
2015-03-21 21:04:34 +00:00
if ((flags & DRIVER_INPUT) && !driver->input_data_own)
driver->input_data = NULL;
2015-03-21 21:04:34 +00:00
if ((flags & DRIVER_AUDIO) && !driver->audio_data_own)
driver->audio_data = NULL;
}