mirror of
https://github.com/libretro/RetroArch.git
synced 2026-11-21 12:29:43 -10:00
A firmware download was titled with MSG_FIRMWARE, "One or more firmware files are missing", so while the file came down - which it did, and was unpacked fine - the progress notification said it was missing. It is now "Downloading: <file>", as the core and asset downloads are. Reported by Craig Carnell (cscd98).
4745 lines
155 KiB
C
4745 lines
155 KiB
C
/* RetroArch - A frontend for libretro.
|
|
* Copyright (C) 2011-2017 - Daniel De Matteis
|
|
* Copyright (C) 2016-2019 - Brad Parker
|
|
* Copyright (C) 2016-2019 - Andrés Suárez
|
|
*
|
|
* RetroArch is free software: you can redistribute it and/or modify it under the terms
|
|
* 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.
|
|
*
|
|
* RetroArch is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
|
|
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
|
|
* PURPOSE. See the GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License along with RetroArch.
|
|
* If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <stdint.h>
|
|
#include <stdlib.h>
|
|
#include <sys/types.h>
|
|
#include <string.h>
|
|
#include <time.h>
|
|
|
|
#ifdef __APPLE__
|
|
#include <TargetConditionals.h>
|
|
#endif
|
|
|
|
#ifdef _WIN32
|
|
#ifdef _XBOX
|
|
#include <xtl.h>
|
|
#define setmode _setmode
|
|
#define INVALID_FILE_ATTRIBUTES -1
|
|
#else
|
|
#include <io.h>
|
|
#include <fcntl.h>
|
|
#define WIN32_LEAN_AND_MEAN
|
|
#include <windows.h>
|
|
#endif
|
|
#endif
|
|
|
|
#ifdef __WINRT__
|
|
#include <Fileapifromapp.h>
|
|
#include "../os/uwp/uwp_func.h"
|
|
#endif
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
#include "../config.h"
|
|
#endif
|
|
|
|
#include <boolean.h>
|
|
|
|
#include <encodings/crc32.h>
|
|
#include <compat/strl.h>
|
|
#include <compat/posix_string.h>
|
|
#include <file/file_path.h>
|
|
#include <file/archive_file.h>
|
|
#include <formats/data_transfer.h>
|
|
#include <streams/file_stream.h>
|
|
#include <string/stdstring.h>
|
|
#include <lists/string_list.h>
|
|
#include <lists/dir_list.h>
|
|
#include <vfs/vfs_implementation.h>
|
|
#include <array/rbuf.h>
|
|
#include "../msg_hash_lbl_str.h"
|
|
|
|
#include <retro_miscellaneous.h>
|
|
|
|
#ifdef HAVE_MENU
|
|
#include "../menu/menu_driver.h"
|
|
#endif
|
|
|
|
#ifdef HAVE_GFX_WIDGETS
|
|
#include "../gfx/gfx_widgets.h"
|
|
#endif
|
|
|
|
#ifdef HAVE_WAYLAND
|
|
/* gfx/common/wayland_common.c */
|
|
void gfx_ctx_wl_release_kept(void);
|
|
#endif
|
|
/* Desktop Windows: __WINRT__ is what says a build is not
|
|
* (retro_environment.h). WINAPI_FAMILY says nothing - <windows.h>
|
|
* defines it in every build - and asking that it not be defined
|
|
* compiled this out on the desktop too. */
|
|
#include <retro_environment.h>
|
|
#if defined(_WIN32) && !defined(_XBOX) && !defined(__WINRT__)
|
|
/* gfx/common/win32_common.c */
|
|
void win32_window_release_kept(void);
|
|
#endif
|
|
|
|
#if defined(HAVE_CG) || defined(HAVE_GLSL) || defined(HAVE_SLANG) || defined(HAVE_HLSL)
|
|
#include "../menu/menu_shader.h"
|
|
#endif
|
|
|
|
#ifdef HAVE_CHEEVOS
|
|
#include "../cheevos/cheevos.h"
|
|
#endif
|
|
|
|
#if defined(ANDROID) && defined(HAVE_SAF)
|
|
#include <vfs/vfs_implementation_saf.h>
|
|
#endif
|
|
|
|
#include "task_content.h"
|
|
#ifdef HAVE_NFSCLIENT
|
|
#include "../libretro-common/vfs/vfs_implementation_nfs.h"
|
|
#endif
|
|
#include "patch_stream.h"
|
|
#include "tasks_internal.h"
|
|
#include "task_content_prefetch.h"
|
|
#include "task_file_transfer.h"
|
|
|
|
#include "../command.h"
|
|
#include "../core_info.h"
|
|
#ifdef HAVE_CORE_LOAD_CHECK
|
|
#include "../core_load_check.h"
|
|
#include "../core_trust_runtime.h"
|
|
#endif
|
|
#include "../content.h"
|
|
#include "../core.h"
|
|
#include "../configuration.h"
|
|
#include "../config.def.h"
|
|
#include "../defaults.h"
|
|
#include "../dynamic.h"
|
|
#include "../file_path_special.h"
|
|
#include "../frontend/frontend.h"
|
|
#include "../msg_hash.h"
|
|
#include "../playlist.h"
|
|
#include "../paths.h"
|
|
#include "../retroarch.h"
|
|
#include "../runloop.h"
|
|
#include "../verbosity.h"
|
|
|
|
#ifdef HAVE_PRESENCE
|
|
#include "../network/presence.h"
|
|
#endif
|
|
|
|
#define MAX_ARGS 32
|
|
|
|
typedef struct content_stream content_stream_t;
|
|
typedef struct content_information_ctx content_information_ctx_t;
|
|
|
|
struct content_stream
|
|
{
|
|
const uint8_t *b;
|
|
size_t c;
|
|
uint32_t a;
|
|
uint32_t crc;
|
|
};
|
|
|
|
enum content_information_flags
|
|
{
|
|
CONTENT_INFO_FLAG_BLOCK_EXTRACT = (1 << 0),
|
|
CONTENT_INFO_FLAG_NEED_FULLPATH = (1 << 1),
|
|
CONTENT_INFO_FLAG_SET_SUPPORTS_NO_GAME_ENABLE = (1 << 2),
|
|
CONTENT_INFO_FLAG_PATCH_IS_BLOCKED = (1 << 3),
|
|
CONTENT_INFO_FLAG_IS_IPS_PREF = (1 << 4),
|
|
CONTENT_INFO_FLAG_IS_BPS_PREF = (1 << 5),
|
|
CONTENT_INFO_FLAG_IS_UPS_PREF = (1 << 6),
|
|
CONTENT_INFO_FLAG_IS_XDELTA_PREF = (1 << 7)
|
|
};
|
|
|
|
struct content_information_ctx
|
|
{
|
|
char *name_ips;
|
|
char *name_bps;
|
|
char *name_ups;
|
|
char *name_xdelta;
|
|
|
|
char *valid_extensions;
|
|
char *directory_cache;
|
|
char *directory_system;
|
|
|
|
struct
|
|
{
|
|
struct retro_subsystem_info *data;
|
|
unsigned size;
|
|
} subsystem;
|
|
|
|
uint16_t flags;
|
|
};
|
|
|
|
#if defined(HAVE_GFX_WIDGETS)
|
|
/* True while the deferred load path has a launch notification on
|
|
* screen that it started BEFORE the read, so it could carry the read
|
|
* percentage. Only one deferral runs at a time
|
|
* (CONTENT_ST_FLAG_DEFERRED_LOAD_PENDING), so one flag covers it.
|
|
* Consumed by content_load(), which must not restart the card the
|
|
* user has been watching. */
|
|
static bool content_load_animation_showing = false;
|
|
#endif
|
|
|
|
/*************************************/
|
|
/* Content file info functions START */
|
|
/*************************************/
|
|
|
|
static void content_file_override_free(
|
|
content_state_t *p_content)
|
|
{
|
|
size_t i;
|
|
|
|
if (!p_content->content_override_list)
|
|
return;
|
|
|
|
for (i = 0; i < RBUF_LEN(p_content->content_override_list); i++)
|
|
{
|
|
content_file_override_t *override =
|
|
&p_content->content_override_list[i];
|
|
if (override && override->ext)
|
|
free(override->ext);
|
|
}
|
|
|
|
RBUF_FREE(p_content->content_override_list);
|
|
}
|
|
|
|
/* Returns true if an override for content files
|
|
* of extension 'ext' has been set */
|
|
static bool content_file_override_get_ext(
|
|
content_state_t *p_content,
|
|
const char *ext,
|
|
const content_file_override_t **override)
|
|
{
|
|
size_t num_overrides;
|
|
size_t i;
|
|
|
|
if (p_content && (ext && *ext))
|
|
{
|
|
if ((num_overrides = RBUF_LEN(p_content->content_override_list)) >= 1)
|
|
{
|
|
for (i = 0; i < num_overrides; i++)
|
|
{
|
|
content_file_override_t *content_override =
|
|
&p_content->content_override_list[i];
|
|
|
|
if ( !content_override
|
|
|| !content_override->ext)
|
|
continue;
|
|
|
|
if (string_is_equal_noncase(
|
|
content_override->ext, ext))
|
|
{
|
|
if (override)
|
|
*override = content_override;
|
|
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool content_file_override_set(
|
|
const struct retro_system_content_info_override *overrides)
|
|
{
|
|
size_t i;
|
|
content_state_t *p_content = content_state_get_ptr();
|
|
if (!p_content || !overrides)
|
|
return false;
|
|
/* Free any existing override list */
|
|
content_file_override_free(p_content);
|
|
for (i = 0; overrides[i].extensions; i++)
|
|
{
|
|
const char *ptr = overrides[i].extensions;
|
|
while (*ptr)
|
|
{
|
|
char ext[32];
|
|
size_t num_entries, _len;
|
|
content_file_override_t *override = NULL;
|
|
/* Find next '|' delimiter or end of string */
|
|
const char *delim = ptr;
|
|
while (*delim && *delim != '|')
|
|
delim++;
|
|
_len = (size_t)(delim - ptr);
|
|
|
|
/* Extract extension token */
|
|
if (_len > 0 && _len < sizeof(ext))
|
|
{
|
|
memcpy(ext, ptr, _len);
|
|
ext[_len] = '\0';
|
|
|
|
/* Check whether extension has already been
|
|
* registered */
|
|
if (!content_file_override_get_ext(p_content, ext, NULL))
|
|
{
|
|
/* Add current override to the list */
|
|
num_entries = RBUF_LEN(p_content->content_override_list);
|
|
if (!RBUF_TRYFIT(p_content->content_override_list,
|
|
num_entries + 1))
|
|
return false;
|
|
|
|
RBUF_RESIZE(p_content->content_override_list,
|
|
num_entries + 1);
|
|
|
|
RARCH_LOG("[Content Override] File Extension: '%3s' - need_fullpath: %s, persistent_data: %s\n",
|
|
ext, overrides[i].need_fullpath ? "TRUE" : "FALSE",
|
|
overrides[i].persistent_data ? "TRUE" : "FALSE");
|
|
|
|
override = &p_content->content_override_list[num_entries];
|
|
override->ext = strdup(ext);
|
|
override->need_fullpath = overrides[i].need_fullpath;
|
|
override->persistent_data = overrides[i].persistent_data;
|
|
}
|
|
}
|
|
|
|
/* Advance past token and delimiter */
|
|
ptr += _len;
|
|
if (*ptr == '|')
|
|
ptr++;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/* Frees any content data that is not flagged
|
|
* as 'persistent'. Should be called after
|
|
* content_file_load() */
|
|
static void content_file_list_free_transient_data(
|
|
content_file_list_t *file_list)
|
|
{
|
|
size_t i;
|
|
|
|
if (!file_list)
|
|
return;
|
|
|
|
for (i = 0; i < file_list->size; i++)
|
|
{
|
|
content_file_info_t *file_info = &file_list->entries[i];
|
|
|
|
if (file_info->data &&
|
|
!file_info->persistent_data)
|
|
{
|
|
free((void*)file_info->data);
|
|
|
|
file_info->data = NULL;
|
|
file_info->data_size = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
static void content_file_list_free_entry(
|
|
content_file_info_t *file_info)
|
|
{
|
|
if (!file_info)
|
|
return;
|
|
|
|
if (file_info->full_path)
|
|
{
|
|
free(file_info->full_path);
|
|
file_info->full_path = NULL;
|
|
}
|
|
|
|
if (file_info->archive_path)
|
|
{
|
|
free(file_info->archive_path);
|
|
file_info->archive_path = NULL;
|
|
}
|
|
|
|
if (file_info->archive_file)
|
|
{
|
|
free(file_info->archive_file);
|
|
file_info->archive_file = NULL;
|
|
}
|
|
|
|
if (file_info->dir)
|
|
{
|
|
free(file_info->dir);
|
|
file_info->dir = NULL;
|
|
}
|
|
|
|
if (file_info->name)
|
|
{
|
|
free(file_info->name);
|
|
file_info->name = NULL;
|
|
}
|
|
|
|
if (file_info->ext)
|
|
{
|
|
free(file_info->ext);
|
|
file_info->ext = NULL;
|
|
}
|
|
|
|
if (file_info->meta)
|
|
{
|
|
free(file_info->meta);
|
|
file_info->meta = NULL;
|
|
}
|
|
|
|
if (file_info->data)
|
|
{
|
|
free((void*)file_info->data);
|
|
file_info->data = NULL;
|
|
}
|
|
file_info->data_size = 0;
|
|
|
|
file_info->file_in_archive = false;
|
|
file_info->persistent_data = false;
|
|
}
|
|
|
|
static void content_file_list_free(
|
|
content_file_list_t *file_list)
|
|
{
|
|
if (!file_list)
|
|
return;
|
|
|
|
if (file_list->entries)
|
|
{
|
|
size_t i;
|
|
|
|
for (i = 0; i < file_list->size; i++)
|
|
{
|
|
content_file_info_t *file_info = &file_list->entries[i];
|
|
content_file_list_free_entry(file_info);
|
|
}
|
|
|
|
free(file_list->entries);
|
|
}
|
|
|
|
if (file_list->temporary_files)
|
|
{
|
|
size_t i;
|
|
|
|
/* Remove any temporary content files from
|
|
* the file system */
|
|
for (i = 0; i < file_list->temporary_files->size; i++)
|
|
{
|
|
const char *path = file_list->temporary_files->elems[i].data;
|
|
|
|
if (!path || !*path)
|
|
continue;
|
|
|
|
RARCH_LOG("[Content] %s: \"%s\".\n",
|
|
msg_hash_to_str(MSG_REMOVING_TEMPORARY_CONTENT_FILE),
|
|
path);
|
|
|
|
/* a private staging directory (attr 1) is listed after the
|
|
* file it held, so it is empty by now and the same remove
|
|
* takes it through the VFS */
|
|
if (filestream_delete(path) != 0)
|
|
RARCH_ERR("[Content] %s: \"%s\".\n",
|
|
msg_hash_to_str(MSG_FAILED_TO_REMOVE_TEMPORARY_FILE),
|
|
path);
|
|
}
|
|
|
|
string_list_free(file_list->temporary_files);
|
|
}
|
|
|
|
if (file_list->game_info)
|
|
free(file_list->game_info);
|
|
|
|
if (file_list->game_info_ext)
|
|
free(file_list->game_info_ext);
|
|
|
|
free(file_list);
|
|
}
|
|
|
|
static content_file_list_t *content_file_list_init(size_t len)
|
|
{
|
|
content_file_list_t *file_list = NULL;
|
|
|
|
if ((file_list = (content_file_list_t *)malloc(sizeof(*file_list))))
|
|
{
|
|
/* Set initial 'values' */
|
|
file_list->entries = NULL;
|
|
file_list->size = 0;
|
|
file_list->game_info = NULL;
|
|
file_list->game_info_ext = NULL;
|
|
file_list->temporary_files = string_list_new();
|
|
|
|
if (file_list->temporary_files)
|
|
{
|
|
/* Create entries list */
|
|
if ((file_list->entries = (content_file_info_t *)
|
|
calloc(len, sizeof(content_file_info_t))))
|
|
{
|
|
file_list->size = len;
|
|
/* Create retro_game_info object */
|
|
if ((file_list->game_info = (struct retro_game_info *)
|
|
calloc(len, sizeof(struct retro_game_info))))
|
|
{
|
|
/* Create retro_game_info_ext object */
|
|
if ((file_list->game_info_ext =
|
|
(struct retro_game_info_ext *)
|
|
calloc(len, sizeof(struct retro_game_info_ext))))
|
|
return file_list;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
content_file_list_free(file_list);
|
|
return NULL;
|
|
}
|
|
|
|
/* Convenience function: Adds an entry to the
|
|
* temporary (i.e. extracted) content file list.
|
|
* Returns pointer to allocated char array. */
|
|
static const char *content_file_list_append_temporary_kind(
|
|
content_file_list_t *file_list, const char *path, int kind)
|
|
{
|
|
if (file_list && (path && *path))
|
|
{
|
|
union string_list_elem_attr attr;
|
|
attr.i = kind;
|
|
if (string_list_append(file_list->temporary_files,
|
|
path, attr))
|
|
return file_list->temporary_files->elems[
|
|
file_list->temporary_files->size - 1].data;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
static const char *content_file_list_append_temporary(
|
|
content_file_list_t *file_list, const char *path)
|
|
{
|
|
return content_file_list_append_temporary_kind(file_list, path, 0);
|
|
}
|
|
|
|
/* NOTE: Takes ownership of supplied 'data' buffer */
|
|
static bool content_file_list_set_info(
|
|
content_file_list_t *file_list,
|
|
const char *path,
|
|
void *data,
|
|
size_t data_size,
|
|
bool persistent_data,
|
|
size_t idx)
|
|
{
|
|
content_file_info_t *file_info = NULL;
|
|
struct retro_game_info *game_info = NULL;
|
|
struct retro_game_info_ext *game_info_ext = NULL;
|
|
|
|
if ( !file_list
|
|
|| (idx >= file_list->size))
|
|
return false;
|
|
|
|
file_info = &file_list->entries[idx];
|
|
game_info = &file_list->game_info[idx];
|
|
game_info_ext = &file_list->game_info_ext[idx];
|
|
|
|
/* Clear any existing info */
|
|
content_file_list_free_entry(file_info);
|
|
|
|
game_info->path = NULL;
|
|
game_info->data = NULL;
|
|
game_info->size = 0;
|
|
game_info->meta = NULL;
|
|
|
|
game_info_ext->full_path = NULL;
|
|
game_info_ext->archive_path = NULL;
|
|
game_info_ext->archive_file = NULL;
|
|
game_info_ext->dir = NULL;
|
|
game_info_ext->name = NULL;
|
|
game_info_ext->ext = NULL;
|
|
game_info_ext->meta = NULL;
|
|
game_info_ext->data = NULL;
|
|
game_info_ext->size = 0;
|
|
game_info_ext->file_in_archive = false;
|
|
game_info_ext->persistent_data = false;
|
|
|
|
/* Assign data */
|
|
if ( ( data && !data_size)
|
|
|| (!data && data_size))
|
|
return false;
|
|
|
|
file_info->data = data;
|
|
file_info->data_size = data_size;
|
|
file_info->persistent_data = persistent_data;
|
|
|
|
/* Assign paths
|
|
* > There is some degree of redundant data
|
|
* here, but we need it in this format
|
|
* (persistent copies of each parameter)
|
|
* to minimise complications when passing
|
|
* extended path info to cores */
|
|
if (path && *path)
|
|
{
|
|
char dir [DIR_MAX_LENGTH];
|
|
char name[NAME_MAX_LENGTH];
|
|
const char *archive_delim = NULL;
|
|
const char *ext = NULL;
|
|
|
|
/* 'Full' path - may point to a file
|
|
* inside an archive */
|
|
file_info->full_path = strdup(path);
|
|
|
|
/* File extension - may be used core-side
|
|
* to differentiate content types */
|
|
if ((ext = path_get_extension(path)))
|
|
{
|
|
file_info->ext = strdup(ext);
|
|
/* File extension is always presented
|
|
* core-side in lowercase format */
|
|
string_to_lower(file_info->ext);
|
|
}
|
|
|
|
/* Check whether path corresponds to a file
|
|
* inside an archive */
|
|
if ((archive_delim = path_get_archive_delim(path)))
|
|
{
|
|
char archive_path[PATH_MAX_LENGTH];
|
|
size_t _len = 0;
|
|
|
|
file_info->file_in_archive = true;
|
|
|
|
/* Extract path of parent archive */
|
|
if ((_len = (size_t)(1 + archive_delim - path))
|
|
>= PATH_MAX_LENGTH)
|
|
_len = PATH_MAX_LENGTH;
|
|
|
|
strlcpy(archive_path, path, _len * sizeof(char));
|
|
if (*archive_path)
|
|
file_info->archive_path = strdup(archive_path);
|
|
|
|
/* Extract name of file in archive */
|
|
archive_delim++;
|
|
if (archive_delim && *archive_delim)
|
|
file_info->archive_file = strdup(archive_delim);
|
|
|
|
/* Extract parent directory - may be used
|
|
* core-side as a reference point for searching
|
|
* related content (e.g. same file name, different
|
|
* extension) */
|
|
fill_pathname_parent_dir(dir, archive_path, sizeof(dir));
|
|
|
|
/* Extract 'canonical' name/id of content file -
|
|
* may be used core-side as a reference point for
|
|
* searching related content. For archived content,
|
|
* this is the basename of the archive file without
|
|
* extension */
|
|
fill_pathname_base(name, archive_path, sizeof(name));
|
|
}
|
|
else
|
|
{
|
|
/* If path corresponds to a 'normal' file,
|
|
* just extract parent directory */
|
|
fill_pathname_parent_dir(dir, path, sizeof(dir));
|
|
|
|
/* For uncompressed content, 'canonical' name/id
|
|
* is the basename of the content file, without
|
|
* extension */
|
|
fill_pathname_base(name, path, sizeof(name));
|
|
}
|
|
path_remove_extension(name);
|
|
|
|
if (*dir)
|
|
{
|
|
/* Remove any trailing slash */
|
|
char *last_slash = find_last_slash(dir);
|
|
if (last_slash && (last_slash[1] == '\0'))
|
|
*last_slash = '\0';
|
|
|
|
if (*dir)
|
|
file_info->dir = strdup(dir);
|
|
}
|
|
|
|
if (*name)
|
|
file_info->name = strdup(name);
|
|
}
|
|
|
|
/* Assign retro_game_info pointers */
|
|
game_info->path = file_info->full_path;
|
|
game_info->data = file_info->data;
|
|
game_info->size = file_info->data_size;
|
|
game_info->meta = file_info->meta;
|
|
|
|
/* Assign retro_game_info_ext pointers */
|
|
game_info_ext->full_path = file_info->full_path;
|
|
game_info_ext->archive_path = file_info->archive_path;
|
|
game_info_ext->archive_file = file_info->archive_file;
|
|
game_info_ext->dir = file_info->dir;
|
|
game_info_ext->name = file_info->name;
|
|
game_info_ext->ext = file_info->ext;
|
|
game_info_ext->meta = file_info->meta;
|
|
game_info_ext->data = file_info->data;
|
|
game_info_ext->size = file_info->data_size;
|
|
game_info_ext->file_in_archive = file_info->file_in_archive;
|
|
game_info_ext->persistent_data = file_info->persistent_data;
|
|
|
|
return true;
|
|
}
|
|
|
|
/***********************************/
|
|
/* Content file info functions END */
|
|
/***********************************/
|
|
|
|
/*****************************************************/
|
|
/* Content information context helper functions START */
|
|
/*****************************************************/
|
|
|
|
/**
|
|
* content_information_ctx_init:
|
|
*
|
|
* Initialises a content_information_ctx_t, reading
|
|
* current settings and runloop state. Caller must
|
|
* call content_information_ctx_free() when done.
|
|
*
|
|
* @param content_ctx : context to initialise.
|
|
* @param settings : current settings (may be NULL).
|
|
* @param runloop_st : current runloop state (may be NULL).
|
|
* @param include_sys_info : if true, also populate fields from
|
|
* the system info (valid_extensions,
|
|
* block_extract, need_fullpath, subsystem,
|
|
* directory_cache, set_supports_no_game).
|
|
**/
|
|
static void content_information_ctx_init(
|
|
content_information_ctx_t *content_ctx,
|
|
settings_t *settings,
|
|
runloop_state_t *runloop_st,
|
|
bool include_sys_info)
|
|
{
|
|
content_ctx->flags = 0;
|
|
content_ctx->directory_system = NULL;
|
|
content_ctx->directory_cache = NULL;
|
|
content_ctx->name_ips = NULL;
|
|
content_ctx->name_bps = NULL;
|
|
content_ctx->name_ups = NULL;
|
|
content_ctx->name_xdelta = NULL;
|
|
content_ctx->valid_extensions = NULL;
|
|
content_ctx->subsystem.data = NULL;
|
|
content_ctx->subsystem.size = 0;
|
|
|
|
#ifdef HAVE_PATCH
|
|
{
|
|
uint32_t rarch_flags = retroarch_get_flags();
|
|
if (rarch_flags & RARCH_FLAGS_IPS_PREF)
|
|
content_ctx->flags |= CONTENT_INFO_FLAG_IS_IPS_PREF;
|
|
if (rarch_flags & RARCH_FLAGS_BPS_PREF)
|
|
content_ctx->flags |= CONTENT_INFO_FLAG_IS_BPS_PREF;
|
|
if (rarch_flags & RARCH_FLAGS_UPS_PREF)
|
|
content_ctx->flags |= CONTENT_INFO_FLAG_IS_UPS_PREF;
|
|
#ifdef HAVE_XDELTA
|
|
if (rarch_flags & RARCH_FLAGS_XDELTA_PREF)
|
|
content_ctx->flags |= CONTENT_INFO_FLAG_IS_XDELTA_PREF;
|
|
#endif /* HAVE_XDELTA */
|
|
if (runloop_st && (runloop_st->flags & RUNLOOP_FLAG_PATCH_BLOCKED))
|
|
content_ctx->flags |= CONTENT_INFO_FLAG_PATCH_IS_BLOCKED;
|
|
}
|
|
#endif /* HAVE_PATCH */
|
|
|
|
if (runloop_st)
|
|
{
|
|
if (*runloop_st->name.ips)
|
|
content_ctx->name_ips = strdup(runloop_st->name.ips);
|
|
if (*runloop_st->name.bps)
|
|
content_ctx->name_bps = strdup(runloop_st->name.bps);
|
|
if (*runloop_st->name.ups)
|
|
content_ctx->name_ups = strdup(runloop_st->name.ups);
|
|
if (*runloop_st->name.xdelta)
|
|
content_ctx->name_xdelta = strdup(runloop_st->name.xdelta);
|
|
}
|
|
|
|
if (settings)
|
|
{
|
|
const char *path_dir_system = settings->paths.directory_system;
|
|
if (path_dir_system && *path_dir_system)
|
|
content_ctx->directory_system = strdup(path_dir_system);
|
|
}
|
|
|
|
if (include_sys_info && runloop_st)
|
|
{
|
|
rarch_system_info_t *sys_info = &runloop_st->system;
|
|
struct retro_system_info *sysinfo = &sys_info->info;
|
|
|
|
if (settings && settings->bools.set_supports_no_game_enable)
|
|
content_ctx->flags |= CONTENT_INFO_FLAG_SET_SUPPORTS_NO_GAME_ENABLE;
|
|
|
|
if (settings)
|
|
{
|
|
const char *path_dir_cache = settings->paths.directory_cache;
|
|
if (path_dir_cache && *path_dir_cache)
|
|
{
|
|
content_ctx->directory_cache = strdup(path_dir_cache);
|
|
|
|
if (!path_is_directory(path_dir_cache))
|
|
path_mkdir(path_dir_cache);
|
|
}
|
|
}
|
|
|
|
if (sysinfo->valid_extensions && *sysinfo->valid_extensions)
|
|
content_ctx->valid_extensions = strdup(sysinfo->valid_extensions);
|
|
|
|
if (sysinfo->block_extract)
|
|
content_ctx->flags |= CONTENT_INFO_FLAG_BLOCK_EXTRACT;
|
|
if (sysinfo->need_fullpath)
|
|
content_ctx->flags |= CONTENT_INFO_FLAG_NEED_FULLPATH;
|
|
|
|
content_ctx->subsystem.data = sys_info->subsystem.data;
|
|
content_ctx->subsystem.size = sys_info->subsystem.size;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* content_information_ctx_free:
|
|
*
|
|
* Frees all heap-allocated members of a content_information_ctx_t.
|
|
**/
|
|
static void content_information_ctx_free(
|
|
content_information_ctx_t *content_ctx)
|
|
{
|
|
if (content_ctx->name_ips)
|
|
free(content_ctx->name_ips);
|
|
if (content_ctx->name_bps)
|
|
free(content_ctx->name_bps);
|
|
if (content_ctx->name_ups)
|
|
free(content_ctx->name_ups);
|
|
if (content_ctx->name_xdelta)
|
|
free(content_ctx->name_xdelta);
|
|
if (content_ctx->directory_system)
|
|
free(content_ctx->directory_system);
|
|
if (content_ctx->directory_cache)
|
|
free(content_ctx->directory_cache);
|
|
if (content_ctx->valid_extensions)
|
|
free(content_ctx->valid_extensions);
|
|
}
|
|
|
|
/***************************************************/
|
|
/* Content information context helper functions END */
|
|
/***************************************************/
|
|
|
|
/********************************/
|
|
/* Content file functions START */
|
|
/********************************/
|
|
|
|
#define BLCK_BLOCK_EXTRACT 1
|
|
#define BLCK_NEED_FULLPATH 2
|
|
#define BLCK_REQUIRED 4
|
|
#define BLCK_PERSISTENT 8
|
|
|
|
#ifdef HAVE_COMPRESSION
|
|
/* data_transfer source bridge for archive entries */
|
|
static int64_t content_file_entry_source_read(void *ud, uint8_t *dst,
|
|
size_t n)
|
|
{
|
|
return file_archive_entry_source_read(
|
|
(file_archive_entry_source_t*)ud, dst, (int64_t)n);
|
|
}
|
|
#endif
|
|
|
|
/* data_transfer source bridge for a plain file */
|
|
static int64_t content_file_plain_source_read(void *ud, uint8_t *dst,
|
|
size_t n)
|
|
{
|
|
return filestream_read((RFILE*)ud, dst, (int64_t)n);
|
|
}
|
|
|
|
#ifdef HAVE_PATCH
|
|
/* Open a streaming applier for whatever patch this load would apply, or
|
|
* NULL to leave the load on the existing whole-buffer patch pass. */
|
|
static patch_stream_t *content_file_patch_stream_open(
|
|
content_information_ctx_t *content_ctx,
|
|
size_t idx,
|
|
enum rarch_content_type first_content_type,
|
|
size_t src_len,
|
|
void **patch_data,
|
|
const char **patch_path)
|
|
{
|
|
if ( idx != 0
|
|
|| first_content_type != RARCH_CONTENT_NONE
|
|
|| (content_ctx->flags & CONTENT_INFO_FLAG_PATCH_IS_BLOCKED))
|
|
{
|
|
*patch_data = NULL;
|
|
*patch_path = NULL;
|
|
return NULL;
|
|
}
|
|
|
|
return patch_content_stream_open(
|
|
content_ctx->flags & CONTENT_INFO_FLAG_IS_IPS_PREF,
|
|
content_ctx->flags & CONTENT_INFO_FLAG_IS_BPS_PREF,
|
|
content_ctx->flags & CONTENT_INFO_FLAG_IS_UPS_PREF,
|
|
content_ctx->flags & CONTENT_INFO_FLAG_IS_XDELTA_PREF,
|
|
content_ctx->name_ips,
|
|
content_ctx->name_bps,
|
|
content_ctx->name_ups,
|
|
content_ctx->name_xdelta,
|
|
src_len, patch_data, patch_path);
|
|
}
|
|
#endif
|
|
|
|
#ifdef HAVE_PATCH
|
|
/* Abandon a streaming patch whose source never fully arrived.
|
|
*
|
|
* A stream that has seen only part of its source must never be
|
|
* finished: the appliers treat a short source as a legitimately short
|
|
* one and zero-fill the rest, so finishing here would silently replace
|
|
* the content with a patch applied to a truncated ROM. Dropping the
|
|
* stream instead leaves the load to its fallback read, after which the
|
|
* ordinary whole-buffer pass patches the complete buffer. */
|
|
static void content_file_patch_stream_drop(void **ps, void **patch_data)
|
|
{
|
|
if (*ps)
|
|
{
|
|
patch_stream_free((patch_stream_t*)*ps);
|
|
*ps = NULL;
|
|
}
|
|
free(*patch_data);
|
|
*patch_data = NULL;
|
|
}
|
|
#endif
|
|
|
|
/* Drive a source-mode transfer to completion, advancing a streaming
|
|
* patch (if any) over each span as it arrives, and detach the filled
|
|
* buffer. Shared by the archive-entry and plain-file loads so both get
|
|
* the same interleaving and the same ownership handoff.
|
|
*
|
|
* Returns the detached buffer (caller frees) or NULL, in which case the
|
|
* transfer has already been released. */
|
|
static uint8_t *content_file_pump_source(data_transfer_t *dt,
|
|
void *patch_stream, size_t *out_len)
|
|
{
|
|
uint8_t *out = NULL;
|
|
size_t avail = 0;
|
|
#ifdef HAVE_PATCH
|
|
patch_stream_t *ps = (patch_stream_t*)patch_stream;
|
|
const uint8_t *base = NULL;
|
|
size_t fed = 0;
|
|
size_t total = 0;
|
|
|
|
if (ps)
|
|
{
|
|
/* The transfer's buffer is one allocation that never moves, and
|
|
* stays alive, detached as the content, until the patch is
|
|
* finished: the patch reads the source there, not from a copy */
|
|
base = data_transfer_ptr(dt, &total);
|
|
patch_stream_set_source(ps, base);
|
|
}
|
|
#else
|
|
(void)patch_stream;
|
|
#endif
|
|
|
|
while ( !data_transfer_complete(dt)
|
|
&& !data_transfer_failed(dt))
|
|
{
|
|
avail = data_transfer_iterate(dt, 0);
|
|
#ifdef HAVE_PATCH
|
|
if (ps && avail > fed)
|
|
{
|
|
patch_stream_feed(ps, base + fed, avail - fed);
|
|
fed = avail;
|
|
/* Once the stream is dead its finish will fail anyway, so
|
|
* stop pushing the rest of the content through it - the load
|
|
* itself still has to complete. */
|
|
if (patch_stream_failed(ps))
|
|
ps = NULL;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
#ifdef HAVE_PATCH
|
|
if (ps)
|
|
{
|
|
avail = data_transfer_avail(dt);
|
|
if (avail > fed)
|
|
patch_stream_feed(ps, base + fed, avail - fed);
|
|
}
|
|
#endif
|
|
|
|
if (!(out = (uint8_t*)data_transfer_source_detach(dt, out_len)))
|
|
data_transfer_free(dt);
|
|
return out;
|
|
}
|
|
|
|
/* ---- prefetch cache: bytes read ahead of the load ---- */
|
|
|
|
/* Take (transfer ownership of) a prefetched buffer for this exact
|
|
* path, if the prefetch task deposited one. */
|
|
static uint8_t *content_file_prefetch_take(content_state_t *p_content,
|
|
const char *path, size_t *size)
|
|
{
|
|
size_t i;
|
|
for (i = 0; i < p_content->prefetch_count; i++)
|
|
{
|
|
if ( p_content->prefetch[i].path
|
|
&& string_is_equal(p_content->prefetch[i].path, path))
|
|
{
|
|
uint8_t *data = p_content->prefetch[i].data;
|
|
*size = p_content->prefetch[i].size;
|
|
free(p_content->prefetch[i].path);
|
|
p_content->prefetch[i].path = NULL;
|
|
p_content->prefetch[i].data = NULL;
|
|
p_content->prefetch[i].size = 0;
|
|
return data;
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
/**
|
|
* content_file_load_into_memory:
|
|
* @content_path : path of the content file.
|
|
* @data : buffer into which the content file will be read.
|
|
* @data_size : size of the resultant content buffer.
|
|
*
|
|
* Reads the content file into memory. Also performs soft patching
|
|
* (see patch_content function) if soft patching has not been
|
|
* blocked by the user.
|
|
*
|
|
* Returns: non-0 if successful, 0 on error.
|
|
**/
|
|
static size_t content_file_load_into_memory(
|
|
content_information_ctx_t *content_ctx,
|
|
content_state_t *p_content,
|
|
const char *content_path,
|
|
bool content_compressed,
|
|
size_t idx,
|
|
enum rarch_content_type first_content_type,
|
|
uint8_t **data)
|
|
{
|
|
uint8_t *content_data = NULL;
|
|
int64_t content_size = 0;
|
|
#ifdef HAVE_PATCH
|
|
/* Soft patching normally runs as a separate pass once the whole file
|
|
* is resident. When the patch can be resolved ahead of the load - it
|
|
* depends only on the preference flags and which patch files exist,
|
|
* never on the content - the applier is opened here and advanced over
|
|
* each span as it arrives, so the patch keeps pace with the load
|
|
* instead of following it. NULL means there is nothing streamable
|
|
* and the existing patch_content pass below runs unchanged. */
|
|
void *patch_data = NULL;
|
|
const char *patch_src = NULL;
|
|
bool streamed = false;
|
|
#endif
|
|
/* Streaming patch handle, kept opaque and declared unconditionally so
|
|
* the load paths can hand it to the pump without a HAVE_PATCH branch
|
|
* of their own. Always NULL when patching is compiled out. */
|
|
void *patch_ps = NULL;
|
|
|
|
RARCH_LOG("[Content] %s: \"%s\".\n",
|
|
msg_hash_to_str(MSG_LOADING_CONTENT_FILE), content_path);
|
|
|
|
/* A prefetched buffer for this exact path short-circuits the
|
|
* read entirely: the bytes streamed in ahead of the load, a
|
|
* budgeted slice per task tick, while the frontend kept
|
|
* running. */
|
|
{
|
|
size_t pre_size = 0;
|
|
if ((content_data = content_file_prefetch_take(p_content,
|
|
content_path, &pre_size)))
|
|
content_size = (int64_t)pre_size;
|
|
}
|
|
/* Read content from file into memory buffer */
|
|
#ifdef HAVE_COMPRESSION
|
|
if (content_data)
|
|
{
|
|
/* prefetched above */
|
|
}
|
|
else if (content_compressed)
|
|
{
|
|
/* Prefer the incremental entry source on the data_transfer
|
|
* spine: the entry inflates chunk by chunk directly into the
|
|
* exact-size destination as it is read - decompression and
|
|
* loading interleave instead of running as one opaque gulp -
|
|
* and the pump takes a byte budget, so this read is ready to
|
|
* be sliced across task ticks once the surrounding load flow
|
|
* is. (Today it is still pumped to completion in place:
|
|
* behaviour and bytes are identical to the classic path.)
|
|
* Backends without independently decodable entries (7z solid
|
|
* blocks) and anything unexpected fall back to the classic
|
|
* whole-entry read below. */
|
|
int64_t src_usize = 0;
|
|
file_archive_entry_source_t *src =
|
|
file_archive_entry_source_open(content_path, &src_usize);
|
|
if (src)
|
|
{
|
|
if (src_usize > 0)
|
|
{
|
|
data_transfer_t *dt = data_transfer_open_source(
|
|
(size_t)src_usize, content_file_entry_source_read,
|
|
src);
|
|
if (dt)
|
|
{
|
|
size_t out_len = 0;
|
|
#ifdef HAVE_PATCH
|
|
patch_ps = content_file_patch_stream_open(content_ctx,
|
|
idx, first_content_type, (size_t)src_usize,
|
|
&patch_data, &patch_src);
|
|
#endif
|
|
if ((content_data = content_file_pump_source(dt,
|
|
patch_ps, &out_len)))
|
|
content_size = (int64_t)out_len;
|
|
#ifdef HAVE_PATCH
|
|
else
|
|
content_file_patch_stream_drop(&patch_ps, &patch_data);
|
|
#endif
|
|
}
|
|
}
|
|
file_archive_entry_source_close(src);
|
|
}
|
|
if (!content_data)
|
|
{
|
|
if (!file_archive_compressed_read(content_path,
|
|
(void**)&content_data, NULL, &content_size))
|
|
return 0;
|
|
}
|
|
}
|
|
else
|
|
#endif
|
|
if (!content_data)
|
|
{
|
|
/* Plain file: pump it through the same source-mode transfer the
|
|
* archive path uses, rather than one blocking whole-file read.
|
|
* That puts uncompressed content - the common case - on the
|
|
* sliceable spine too, and lets a patch advance alongside the
|
|
* read instead of running as a pass afterwards.
|
|
*
|
|
* Falls back to filestream_read_file if the file cannot be
|
|
* opened, sized, or transferred, so nothing that loaded before
|
|
* stops loading now. */
|
|
RFILE *fp = filestream_open(content_path,
|
|
RETRO_VFS_FILE_ACCESS_READ, RETRO_VFS_FILE_ACCESS_HINT_NONE);
|
|
|
|
if (fp)
|
|
{
|
|
int64_t fsize = filestream_get_size(fp);
|
|
|
|
if (fsize > 0)
|
|
{
|
|
data_transfer_t *dt = data_transfer_open_source((size_t)fsize,
|
|
content_file_plain_source_read, fp);
|
|
|
|
if (dt)
|
|
{
|
|
size_t out_len = 0;
|
|
#ifdef HAVE_PATCH
|
|
patch_ps = content_file_patch_stream_open(content_ctx,
|
|
idx, first_content_type, (size_t)fsize,
|
|
&patch_data, &patch_src);
|
|
#endif
|
|
if ((content_data = content_file_pump_source(dt,
|
|
patch_ps, &out_len)))
|
|
content_size = (int64_t)out_len;
|
|
#ifdef HAVE_PATCH
|
|
else
|
|
content_file_patch_stream_drop(&patch_ps, &patch_data);
|
|
#endif
|
|
}
|
|
}
|
|
filestream_close(fp);
|
|
}
|
|
|
|
if (!content_data)
|
|
{
|
|
if (!filestream_read_file(content_path,
|
|
(void**)&content_data, &content_size))
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
if (content_size < 0)
|
|
{
|
|
/* Nothing downstream can use this, and the patch stream must not
|
|
* outlive the function that owns it. */
|
|
#ifdef HAVE_PATCH
|
|
content_file_patch_stream_drop(&patch_ps, &patch_data);
|
|
#endif
|
|
free(content_data);
|
|
return 0;
|
|
}
|
|
|
|
#ifdef HAVE_PATCH
|
|
/* Complete a streamed patch. The source is still fully resident here
|
|
* (the transfer buffer we just detached), so a patch that turns out to
|
|
* be malformed costs nothing: keep the unpatched buffer and let the
|
|
* normal pass below try again, which is exactly what happens today
|
|
* when an applier rejects a patch. */
|
|
if (patch_ps)
|
|
{
|
|
size_t patched_len = (size_t)content_size;
|
|
|
|
/* The source was fed from content_data itself: an IPS patch goes
|
|
* on it where it lies, any other replaces it */
|
|
if ( content_data
|
|
&& patch_stream_finish_into((patch_stream_t*)patch_ps,
|
|
&content_data, &patched_len))
|
|
{
|
|
content_size = (int64_t)patched_len;
|
|
streamed = true;
|
|
|
|
if (config_get_ptr()->bools.notification_show_patch_applied)
|
|
{
|
|
/* Same wording as the whole-buffer path: the patch's
|
|
* file name, not the format it happens to be. */
|
|
char msg[128];
|
|
const char *patch_filename = patch_src
|
|
? path_basename_nocompression(patch_src) : NULL;
|
|
size_t _len = snprintf(msg, sizeof(msg),
|
|
msg_hash_to_str(MSG_APPLYING_PATCH),
|
|
patch_filename ? patch_filename :
|
|
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_UNKNOWN));
|
|
runloop_msg_queue_push(msg, _len, 1, 180, false, NULL,
|
|
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
|
|
}
|
|
}
|
|
patch_stream_free((patch_stream_t*)patch_ps);
|
|
patch_ps = NULL;
|
|
free(patch_data);
|
|
patch_data = NULL;
|
|
}
|
|
#endif
|
|
|
|
/* First content file is significant: attempt to do
|
|
* soft patching, CRC checking, etc. */
|
|
if (idx == 0)
|
|
{
|
|
/* If we have a media type, ignore patches. */
|
|
if (first_content_type == RARCH_CONTENT_NONE)
|
|
{
|
|
#ifdef HAVE_PATCH
|
|
/* Attempt to apply a patch, unless one was already streamed
|
|
* alongside the load above. */
|
|
if ( !streamed
|
|
&& !(content_ctx->flags & CONTENT_INFO_FLAG_PATCH_IS_BLOCKED))
|
|
patch_content(
|
|
content_ctx->flags & CONTENT_INFO_FLAG_IS_IPS_PREF,
|
|
content_ctx->flags & CONTENT_INFO_FLAG_IS_BPS_PREF,
|
|
content_ctx->flags & CONTENT_INFO_FLAG_IS_UPS_PREF,
|
|
content_ctx->flags & CONTENT_INFO_FLAG_IS_XDELTA_PREF,
|
|
content_ctx->name_ips,
|
|
content_ctx->name_bps,
|
|
content_ctx->name_ups,
|
|
content_ctx->name_xdelta,
|
|
(uint8_t**)&content_data,
|
|
(void*)&content_size);
|
|
#endif
|
|
}
|
|
}
|
|
|
|
*data = content_data;
|
|
|
|
return (size_t)content_size;
|
|
}
|
|
|
|
#ifdef HAVE_COMPRESSION
|
|
static bool content_file_extract_from_archive(
|
|
content_information_ctx_t *content_ctx,
|
|
content_state_t *p_content,
|
|
const char *valid_exts,
|
|
const char **content_path,
|
|
char **err_string)
|
|
{
|
|
const char *tmp_path_ptr = NULL;
|
|
size_t _len;
|
|
unsigned i;
|
|
char tmp_path[PATH_MAX_LENGTH];
|
|
char tmp_dir[DIR_MAX_LENGTH];
|
|
|
|
tmp_path[0] = '\0';
|
|
|
|
/* TODO/FIXME - localize */
|
|
RARCH_LOG("[Content] Core requires uncompressed content - "
|
|
"extracting archive to temporary directory...\n");
|
|
|
|
/* The member is written under a directory of our own rather than
|
|
* straight into the cache or content directory. Extraction keeps
|
|
* the member's own basename - savefile and savestate paths are
|
|
* derived from it, so a uniquified file name would silently move
|
|
* a user's saves - and a name that is already taken beside the
|
|
* archive would otherwise be overwritten here and deleted again
|
|
* on teardown, taking an unrelated file with it. A directory of
|
|
* our own makes the collision impossible instead of detecting it.
|
|
*
|
|
* The cache directory is the parent when one is configured;
|
|
* otherwise the archive's own directory is, which is the only
|
|
* location known to exist and be writable at this point. */
|
|
if (content_ctx->directory_cache && *content_ctx->directory_cache)
|
|
{
|
|
strlcpy(tmp_dir, content_ctx->directory_cache, sizeof(tmp_dir));
|
|
fill_pathname_slash(tmp_dir, sizeof(tmp_dir));
|
|
}
|
|
else
|
|
fill_pathname_basedir(tmp_dir, *content_path, sizeof(tmp_dir));
|
|
|
|
_len = strlen(tmp_dir);
|
|
|
|
/* First name not already on disk wins. A stale directory from a
|
|
* previous run - a crash between extraction and teardown - is
|
|
* therefore stepped over rather than reused, so its contents can
|
|
* never be mistaken for this load's content. */
|
|
for (i = 0; i < 1024; i++)
|
|
{
|
|
snprintf(tmp_dir + _len, sizeof(tmp_dir) - _len,
|
|
".extract-%u", i);
|
|
if (!path_is_valid(tmp_dir))
|
|
break;
|
|
}
|
|
|
|
if (i == 1024 || !path_mkdir(tmp_dir))
|
|
goto error;
|
|
|
|
/* Attempt to extract file */
|
|
if (!file_archive_extract_file(
|
|
*content_path, valid_exts, tmp_dir,
|
|
tmp_path, sizeof(tmp_path)))
|
|
{
|
|
/* Only ever removes the directory created just above, and it
|
|
* is empty on this path, so nothing else can be caught by it. */
|
|
filestream_delete(tmp_dir);
|
|
goto error;
|
|
}
|
|
|
|
/* Add path of extracted file to temporary content
|
|
* list (so it can be deleted when deinitialising
|
|
* the core) */
|
|
if (!(tmp_path_ptr = content_file_list_append_temporary(
|
|
p_content->content_list, tmp_path)))
|
|
return false;
|
|
|
|
/* The directory follows its own file in the list, so teardown
|
|
* empties it before removing it. */
|
|
content_file_list_append_temporary(p_content->content_list, tmp_dir);
|
|
|
|
/* Update content path pointer */
|
|
*content_path = tmp_path_ptr;
|
|
|
|
/* TODO/FIXME - localize */
|
|
RARCH_LOG("[Content] Content successfully extracted to: \"%s\".\n",
|
|
tmp_path);
|
|
|
|
return true;
|
|
|
|
error:
|
|
/* tmp_path is spent on this path - whatever the extraction left in
|
|
* it is unused - so it carries the message rather than a second
|
|
* buffer of its size sitting in the frame for the error case. */
|
|
snprintf(tmp_path, sizeof(tmp_path), "%s: \"%s\".\n",
|
|
msg_hash_to_str(MSG_FAILED_TO_EXTRACT_CONTENT_FROM_COMPRESSED_FILE),
|
|
*content_path);
|
|
*err_string = strdup(tmp_path);
|
|
return false;
|
|
}
|
|
#endif
|
|
|
|
static void content_file_get_path(
|
|
struct string_list *content,
|
|
size_t idx,
|
|
const char *valid_exts,
|
|
const char **path,
|
|
bool *path_is_compressed)
|
|
{
|
|
bool path_is_archive;
|
|
bool path_is_inside_archive;
|
|
const char *content_path = content->elems[idx].data;
|
|
|
|
if (!content_path || !*content_path)
|
|
return;
|
|
|
|
#if defined(ANDROID) && defined(HAVE_SAF)
|
|
/* Convert content:// URIs to the path format used by the VFS */
|
|
if (strncmp(content_path, "content://", sizeof "content://" - 1) == 0)
|
|
{
|
|
struct libretro_vfs_implementation_saf_path_split_result result;
|
|
if (retro_vfs_path_split_content_saf(&result, content_path))
|
|
{
|
|
char *serialized_path = retro_vfs_path_join_saf(result.tree, result.path);
|
|
free(result.path);
|
|
free(result.tree);
|
|
if (serialized_path != NULL)
|
|
{
|
|
/* Store the serialized path in the content list entry
|
|
* itself, so it is freed when the list is freed and we
|
|
* avoid a static buffer leak. */
|
|
free(content->elems[idx].data);
|
|
content->elems[idx].data = serialized_path;
|
|
content_path = serialized_path;
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
#ifdef HAVE_COMPRESSION
|
|
/* Check whether we are dealing with a
|
|
* compressed file */
|
|
path_is_archive = path_is_compressed_file(content_path);
|
|
path_is_inside_archive = path_contains_compressed_file(content_path);
|
|
*path_is_compressed = path_is_archive || path_is_inside_archive;
|
|
|
|
/* If extraction is permitted and content is a
|
|
* 'parent' archive file, must determine which
|
|
* internal file to load
|
|
* > file_archive_compressed_read() requires
|
|
* a 'complete' file path:
|
|
* <parent_archive>#<internal_file> */
|
|
if (!((content->elems[idx].attr.i & BLCK_BLOCK_EXTRACT) != 0)
|
|
&& path_is_archive
|
|
&& !path_is_inside_archive)
|
|
{
|
|
/* Get internal archive file list */
|
|
struct string_list *archive_list =
|
|
file_archive_get_file_list(content_path, valid_exts);
|
|
|
|
if ( archive_list
|
|
&& (archive_list->size > 0))
|
|
{
|
|
const char *archive_file = NULL;
|
|
|
|
/* Ensure that list is sorted alphabetically */
|
|
if (archive_list->size > 1)
|
|
dir_list_sort(archive_list, true);
|
|
|
|
archive_file = archive_list->elems[0].data;
|
|
|
|
if (archive_file && *archive_file)
|
|
{
|
|
char info_path[PATH_MAX_LENGTH];
|
|
/* Build 'complete' archive file path */
|
|
size_t _len = strlcpy(info_path,
|
|
content_path, sizeof(info_path) - 2);
|
|
info_path[_len ] = '#';
|
|
info_path[_len+1] = '\0';
|
|
_len += 1;
|
|
strlcpy(info_path + _len, archive_file, sizeof(info_path) - _len);
|
|
|
|
/* Update 'content' string_list */
|
|
free(content->elems[idx].data);
|
|
content->elems[idx].data = strdup(info_path);
|
|
content_path = content->elems[idx].data;
|
|
|
|
string_list_free(archive_list);
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
*path = content_path;
|
|
}
|
|
|
|
static void content_file_apply_overrides(
|
|
content_state_t *p_content,
|
|
struct string_list *content,
|
|
size_t idx,
|
|
const char *path)
|
|
{
|
|
const content_file_override_t *override = NULL;
|
|
|
|
/* Check whether an override has been set
|
|
* for files of this type */
|
|
if (content_file_override_get_ext(p_content,
|
|
path_get_extension(path), &override))
|
|
{
|
|
/* Get existing attributes */
|
|
bool block_extract = ((content->elems[idx].attr.i & BLCK_BLOCK_EXTRACT) != 0);
|
|
bool required = ((content->elems[idx].attr.i & BLCK_REQUIRED) != 0);
|
|
bool persistent = ((content->elems[idx].attr.i & BLCK_PERSISTENT) != 0);
|
|
|
|
content->elems[idx].attr.i = 0;
|
|
|
|
/* Apply updates
|
|
* > Note that 'persistent' attribute must not
|
|
* be set false by an override if it is already
|
|
* true (frontend may require persistence for
|
|
* other purposes, e.g. runahead) */
|
|
if (block_extract)
|
|
content->elems[idx].attr.i |= BLCK_BLOCK_EXTRACT;
|
|
if (override->need_fullpath)
|
|
content->elems[idx].attr.i |= BLCK_NEED_FULLPATH;
|
|
if (required)
|
|
content->elems[idx].attr.i |= BLCK_REQUIRED;
|
|
if (persistent || override->persistent_data)
|
|
content->elems[idx].attr.i |= BLCK_PERSISTENT;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* content_file_load:
|
|
* @special : subsystem of content to be loaded. Can be NULL.
|
|
*
|
|
* Load content file (for libretro core).
|
|
*
|
|
* Returns : true if successful, otherwise false.
|
|
**/
|
|
#if defined(HAVE_SMBCLIENT) || defined(HAVE_NFSCLIENT)
|
|
/* smb:// or nfs://: a path only the VFS can open. */
|
|
static bool content_path_is_network(const char *path)
|
|
{
|
|
return path && (string_starts_with(path, "smb://") || string_starts_with(path, "nfs://"));
|
|
}
|
|
#endif
|
|
|
|
static bool content_file_load(
|
|
content_state_t *p_content,
|
|
struct string_list *content,
|
|
content_information_ctx_t *content_ctx,
|
|
enum msg_hash_enums *error_enum,
|
|
char **err_string,
|
|
const struct retro_subsystem_info *special)
|
|
{
|
|
size_t i;
|
|
retro_ctx_load_content_info_t load_info;
|
|
bool used_vfs_fallback_copy = false;
|
|
#if defined(__WINRT__) || defined(HAVE_SMBCLIENT) || defined(HAVE_NFSCLIENT)
|
|
rarch_system_info_t *sys_info = &runloop_state_get_ptr()->system;
|
|
#endif
|
|
enum rarch_content_type first_content_type = RARCH_CONTENT_NONE;
|
|
|
|
for (i = 0; i < content->size; i++)
|
|
{
|
|
const char *content_path = NULL;
|
|
uint8_t *content_data = NULL;
|
|
size_t content_size = 0;
|
|
const char *valid_exts = special
|
|
? special->roms[i].valid_extensions
|
|
: content_ctx->valid_extensions;
|
|
bool content_compressed = false;
|
|
|
|
/* Get content path */
|
|
content_file_get_path(content, i, valid_exts,
|
|
&content_path, &content_compressed);
|
|
|
|
/* If content is missing and core requires content,
|
|
* return an error */
|
|
if (!content_path || !*content_path)
|
|
{
|
|
if ((content->elems[i].attr.i & BLCK_REQUIRED) != 0)
|
|
{
|
|
*error_enum = MSG_ERROR_LIBRETRO_CORE_REQUIRES_CONTENT;
|
|
return false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* If this is the first item of content,
|
|
* get content type */
|
|
if (i == 0)
|
|
first_content_type = path_is_media_type(content_path);
|
|
|
|
/* Apply any file-type-specific content
|
|
* handling overrides */
|
|
if (p_content->content_override_list)
|
|
content_file_apply_overrides(p_content, content, i, content_path);
|
|
|
|
/* If core does not require 'fullpath', load
|
|
* the content into memory */
|
|
|
|
/* Doesn't need fullpath? */
|
|
if (!((content->elems[i].attr.i & BLCK_NEED_FULLPATH) != 0))
|
|
{
|
|
content_data = NULL;
|
|
if ((content_size = content_file_load_into_memory(
|
|
content_ctx, p_content, content_path,
|
|
content_compressed, i, first_content_type,
|
|
&content_data)) == 0)
|
|
{
|
|
char msg[PATH_MAX_LENGTH];
|
|
snprintf(msg, sizeof(msg), "%s: \"%s\".\n",
|
|
msg_hash_to_str(MSG_COULD_NOT_READ_CONTENT_FILE),
|
|
content_path);
|
|
*err_string = strdup(msg);
|
|
return false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
#ifdef HAVE_COMPRESSION
|
|
/* If this is compressed content and need_fullpath
|
|
* is true, extract it to a temporary file */
|
|
if ( content_compressed
|
|
&& !((content->elems[i].attr.i & BLCK_BLOCK_EXTRACT) != 0)
|
|
&& !content_file_extract_from_archive(content_ctx, p_content,
|
|
valid_exts, &content_path, err_string))
|
|
return false;
|
|
#endif
|
|
#if defined(HAVE_SMBCLIENT) || defined(HAVE_NFSCLIENT)
|
|
/* Network content for a core that reads paths itself: an
|
|
* smb:// or nfs:// path means nothing to its fopen(), so
|
|
* the file is staged into the cache directory and the
|
|
* copy handed over (and removed when the content is
|
|
* unloaded). A core that goes through the VFS streams the
|
|
* original, which is what keeps large disc images usable.
|
|
* Compressed content was extracted through the VFS above
|
|
* and is already local by the time it gets here. */
|
|
if ( !sys_info->supports_vfs
|
|
&& !content_compressed
|
|
&& content_path_is_network(content_path))
|
|
{
|
|
char new_path[PATH_MAX_LENGTH];
|
|
|
|
if (!content_ctx->directory_cache || !*content_ctx->directory_cache
|
|
|| !path_is_directory(content_ctx->directory_cache))
|
|
{
|
|
char msg[PATH_MAX_LENGTH];
|
|
/* TODO/FIXME - localize */
|
|
snprintf(msg, sizeof(msg),
|
|
"%s: \"%s\". (this core needs a local file; set a Cache Directory)\n",
|
|
msg_hash_to_str(MSG_COULD_NOT_READ_CONTENT_FILE),
|
|
content_path);
|
|
*err_string = strdup(msg);
|
|
return false;
|
|
}
|
|
/* A private directory of its own, so the copy can never
|
|
* land on (and later remove) an unrelated cache file, and
|
|
* two remote files sharing a name cannot collide; the
|
|
* basename is kept inside it for the save paths. The
|
|
* copy is written under a part name and renamed into
|
|
* place only once complete. */
|
|
{
|
|
char stage_dir[PATH_MAX_LENGTH];
|
|
char part_path[PATH_MAX_LENGTH];
|
|
static unsigned stage_seq = 0;
|
|
unsigned attempt;
|
|
bool made = false;
|
|
|
|
for (attempt = 0; attempt < 64 && !made; attempt++)
|
|
{
|
|
snprintf(new_path, sizeof(new_path), "retroarch-stage-%u-%u",
|
|
(unsigned)cpu_features_get_time_usec(), ++stage_seq);
|
|
fill_pathname_join_special(stage_dir, content_ctx->directory_cache,
|
|
new_path, sizeof(stage_dir));
|
|
if (!path_is_directory(stage_dir) && !path_is_valid(stage_dir))
|
|
made = path_mkdir(stage_dir);
|
|
}
|
|
if (!made)
|
|
{
|
|
char msg[PATH_MAX_LENGTH];
|
|
snprintf(msg, sizeof(msg), "%s: \"%s\". (no staging directory in the cache)\n",
|
|
msg_hash_to_str(MSG_COULD_NOT_READ_CONTENT_FILE),
|
|
content_path);
|
|
*err_string = strdup(msg);
|
|
return false;
|
|
}
|
|
fill_pathname_join_special(new_path, stage_dir,
|
|
path_basename(content_path), sizeof(new_path));
|
|
strlcpy(part_path, new_path, sizeof(part_path));
|
|
strlcat(part_path, ".part", sizeof(part_path));
|
|
RARCH_LOG("[Content] Core does not support VFS - staging network content to \"%s\".\n",
|
|
new_path);
|
|
if (filestream_copy(content_path, part_path) != 0
|
|
|| filestream_rename(part_path, new_path) != 0)
|
|
{
|
|
char msg[PATH_MAX_LENGTH];
|
|
#ifdef HAVE_NFSCLIENT
|
|
if (content_path[0] == 'n')
|
|
RARCH_ERR("[Content] NFS: %s\n", nfs_get_last_error());
|
|
#endif
|
|
filestream_delete(part_path);
|
|
filestream_delete(stage_dir);
|
|
snprintf(msg, sizeof(msg), "%s: \"%s\". (during copy read or write)\n",
|
|
msg_hash_to_str(MSG_COULD_NOT_READ_CONTENT_FILE),
|
|
content_path);
|
|
*err_string = strdup(msg);
|
|
return false;
|
|
}
|
|
/* file first, then the directory that held it */
|
|
content_path = content_file_list_append_temporary(
|
|
p_content->content_list, new_path);
|
|
content_file_list_append_temporary_kind(
|
|
p_content->content_list, stage_dir, 1);
|
|
used_vfs_fallback_copy = true;
|
|
}
|
|
}
|
|
#endif
|
|
#ifdef __WINRT__
|
|
/* TODO: When support for the 'actual' VFS is added,
|
|
* there will need to be some more logic here */
|
|
if ( !sys_info->supports_vfs
|
|
&& !is_path_accessible_using_standard_io(content_path))
|
|
{
|
|
/* Try to copy ACL to file first. If successful, this should mean that cores using standard I/O can still access them
|
|
* It would be better to set the ACL to allow full access for all application packages. However,
|
|
* this is substantially easier than writing out new functions to do this
|
|
* Copy ACL from localstate
|
|
* I am genuinely really proud of these work arounds
|
|
*/
|
|
wchar_t wcontent_path[MAX_PATH];
|
|
mbstowcs(wcontent_path, content_path, MAX_PATH);
|
|
uwp_set_acl(wcontent_path, L"S-1-15-2-1");
|
|
if (!is_path_accessible_using_standard_io(content_path))
|
|
{
|
|
/* Fallback to a file copy into an accessible directory */
|
|
char new_basedir[DIR_MAX_LENGTH];
|
|
char new_path[PATH_MAX_LENGTH];
|
|
|
|
RARCH_LOG("[Content] Core does not support VFS"
|
|
" - copying to cache directory...\n");
|
|
|
|
if (content_ctx->directory_cache && *content_ctx->directory_cache)
|
|
strlcpy(new_basedir, content_ctx->directory_cache,
|
|
sizeof(new_basedir));
|
|
else
|
|
new_basedir[0] = '\0';
|
|
|
|
if ( (!new_basedir || !*new_basedir)
|
|
|| !path_is_directory(new_basedir)
|
|
|| !is_path_accessible_using_standard_io(new_basedir))
|
|
{
|
|
size_t _len;
|
|
DWORD basedir_attribs;
|
|
RARCH_WARN("[Content] Tried copying to cache directory, "
|
|
"but cache directory was not set or found. "
|
|
"Setting cache directory to root of writable app directory...\n");
|
|
_len = strlcpy(new_basedir, uwp_dir_data, sizeof(new_basedir));
|
|
strlcpy_lit(new_basedir + _len,
|
|
"VFSCACHE\\",
|
|
sizeof(new_basedir) - _len);
|
|
basedir_attribs = GetFileAttributes(new_basedir);
|
|
if ( (basedir_attribs == INVALID_FILE_ATTRIBUTES)
|
|
|| (!(basedir_attribs & FILE_ATTRIBUTE_DIRECTORY)))
|
|
{
|
|
if (!CreateDirectoryA(new_basedir, NULL))
|
|
strlcpy(new_basedir, uwp_dir_data, sizeof(new_basedir));
|
|
}
|
|
}
|
|
fill_pathname_join_special(new_path, new_basedir,
|
|
path_basename(content_path), sizeof(new_path));
|
|
|
|
/* filestream_copy() goes through the VFS copy, and
|
|
* the destination directory is created for us. */
|
|
if (filestream_copy(content_path, new_path) != 0)
|
|
{
|
|
char msg[PATH_MAX_LENGTH];
|
|
/* TODO/FIXME - localize */
|
|
snprintf(msg, sizeof(msg), "%s: \"%s\". (during copy read or write)\n",
|
|
msg_hash_to_str(MSG_COULD_NOT_READ_CONTENT_FILE),
|
|
content_path);
|
|
*err_string = strdup(msg);
|
|
return false;
|
|
}
|
|
|
|
content_path = content_file_list_append_temporary(
|
|
p_content->content_list, new_path);
|
|
|
|
used_vfs_fallback_copy = true;
|
|
}
|
|
}
|
|
#endif
|
|
RARCH_LOG("[Content] %s\n", msg_hash_to_str(
|
|
MSG_CONTENT_LOADING_SKIPPED_IMPLEMENTATION_WILL_DO_IT));
|
|
|
|
/* First content file is significant: need to
|
|
* perform CRC calculation, but defer this
|
|
* until value is used */
|
|
if (i == 0)
|
|
{
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Add current entry to content file list */
|
|
if (!content_file_list_set_info(
|
|
p_content->content_list,
|
|
content_path, content_data, content_size,
|
|
((content->elems[i].attr.i & BLCK_PERSISTENT) != 0), i))
|
|
{
|
|
RARCH_LOG("[Content] Failed to process content file: \"%s\".\n", content_path);
|
|
if (content_data)
|
|
free((void*)content_data);
|
|
*error_enum = MSG_FAILED_TO_LOAD_CONTENT;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/* Load content into core */
|
|
load_info.content = content;
|
|
load_info.special = special;
|
|
load_info.info = p_content->content_list->game_info;
|
|
|
|
if (!core_load_game(&load_info))
|
|
{
|
|
/* This is probably going to fail on multifile ROMs etc.
|
|
* so give a visible explanation of what is likely wrong */
|
|
if (used_vfs_fallback_copy)
|
|
*error_enum = MSG_ERROR_LIBRETRO_CORE_REQUIRES_VFS;
|
|
else
|
|
*error_enum = MSG_FAILED_TO_LOAD_CONTENT;
|
|
|
|
return false;
|
|
}
|
|
|
|
#ifdef HAVE_CHEEVOS
|
|
if (!special)
|
|
{
|
|
const char *first_content_path =
|
|
p_content->content_list->entries[0].full_path;
|
|
if (first_content_path && *first_content_path)
|
|
{
|
|
if (first_content_type == RARCH_CONTENT_NONE)
|
|
{
|
|
rcheevos_load(p_content->content_list->game_info);
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
rcheevos_pause_hardcore();
|
|
#endif
|
|
|
|
return true;
|
|
}
|
|
|
|
static const struct retro_subsystem_info *content_file_init_subsystem(
|
|
const struct retro_subsystem_info *subsystem_data,
|
|
size_t subsystem_current_count,
|
|
enum msg_hash_enums *error_enum,
|
|
char **err_string,
|
|
bool *ret)
|
|
{
|
|
struct string_list *subsystem = path_get_subsystem_list();
|
|
const struct retro_subsystem_info *special = libretro_find_subsystem_info(
|
|
subsystem_data, (unsigned)subsystem_current_count,
|
|
path_get(RARCH_PATH_SUBSYSTEM));
|
|
|
|
if (!special)
|
|
{
|
|
char msg[128];
|
|
/* TODO/FIXME - localize */
|
|
snprintf(msg, sizeof(msg),
|
|
"Failed to find subsystem \"%s\" in libretro implementation.\n",
|
|
path_get(RARCH_PATH_SUBSYSTEM));
|
|
*err_string = strdup(msg);
|
|
*ret = false;
|
|
return NULL;
|
|
}
|
|
|
|
if (special->num_roms)
|
|
{
|
|
if (!subsystem)
|
|
{
|
|
*error_enum = MSG_ERROR_LIBRETRO_CORE_REQUIRES_SPECIAL_CONTENT;
|
|
*ret = false;
|
|
return NULL;
|
|
}
|
|
|
|
if (special->num_roms != subsystem->size)
|
|
{
|
|
char msg[128];
|
|
/* TODO/FIXME - localize */
|
|
snprintf(msg, sizeof(msg),
|
|
"Libretro core requires %u content files for "
|
|
"subsystem \"%s\", but %u content files were provided.\n",
|
|
special->num_roms, special->desc,
|
|
(unsigned)subsystem->size);
|
|
*err_string = strdup(msg);
|
|
*ret = false;
|
|
return NULL;
|
|
}
|
|
}
|
|
else if (subsystem && subsystem->size)
|
|
{
|
|
char msg[128];
|
|
/* TODO/FIXME - localize */
|
|
snprintf(msg, sizeof(msg),
|
|
"Libretro core takes no content for subsystem \"%s\", "
|
|
"but %u content files were provided.\n",
|
|
special->desc,
|
|
(unsigned)subsystem->size);
|
|
*err_string = strdup(msg);
|
|
*ret = false;
|
|
return NULL;
|
|
}
|
|
|
|
*ret = true;
|
|
return special;
|
|
}
|
|
|
|
static void content_file_set_attributes(
|
|
struct string_list *content,
|
|
const struct retro_subsystem_info *special,
|
|
content_information_ctx_t *content_ctx)
|
|
{
|
|
struct string_list *subsystem = path_get_subsystem_list();
|
|
|
|
if (!path_is_empty(RARCH_PATH_SUBSYSTEM) && special)
|
|
{
|
|
size_t i;
|
|
|
|
for (i = 0; i < subsystem->size; i++)
|
|
{
|
|
union string_list_elem_attr attr;
|
|
|
|
attr.i = 0;
|
|
if (special->roms[i].block_extract)
|
|
attr.i |= BLCK_BLOCK_EXTRACT;
|
|
if (special->roms[i].need_fullpath)
|
|
attr.i |= BLCK_NEED_FULLPATH;
|
|
if (special->roms[i].required)
|
|
attr.i |= BLCK_REQUIRED;
|
|
|
|
string_list_append(content, subsystem->elems[i].data, attr);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
union string_list_elem_attr attr;
|
|
const char *content_path = path_get(RARCH_PATH_CONTENT);
|
|
uint8_t flags = content_get_flags();
|
|
|
|
attr.i = 0;
|
|
if (content_ctx->flags & CONTENT_INFO_FLAG_BLOCK_EXTRACT)
|
|
attr.i |= BLCK_BLOCK_EXTRACT;
|
|
if (content_ctx->flags & CONTENT_INFO_FLAG_NEED_FULLPATH)
|
|
attr.i |= BLCK_NEED_FULLPATH;
|
|
if (!(flags
|
|
& CONTENT_ST_FLAG_CORE_DOES_NOT_NEED_CONTENT))
|
|
attr.i |= BLCK_REQUIRED;
|
|
|
|
/* If runahead is supported and we are not using
|
|
* subsystems, content data buffer must *always*
|
|
* be persistent, since user may toggle second
|
|
* instance runahead at any time (and secondary
|
|
* core initialisation requires valid data) */
|
|
#if defined(HAVE_RUNAHEAD)
|
|
attr.i |= BLCK_PERSISTENT;
|
|
#endif
|
|
|
|
if (!content_path || !*content_path)
|
|
{
|
|
if ( (flags & CONTENT_ST_FLAG_CORE_DOES_NOT_NEED_CONTENT)
|
|
&& content_ctx->flags
|
|
& CONTENT_INFO_FLAG_SET_SUPPORTS_NO_GAME_ENABLE)
|
|
string_list_append_n(content, "", STRLEN_CONST(""), attr);
|
|
}
|
|
else
|
|
string_list_append(content, content_path, attr);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* content_init_file:
|
|
*
|
|
* Initializes and loads a content file for the currently
|
|
* selected libretro core.
|
|
*
|
|
* Returns : true if successful, otherwise false.
|
|
**/
|
|
static bool content_file_init(
|
|
content_information_ctx_t *content_ctx,
|
|
content_state_t *p_content,
|
|
struct string_list *content,
|
|
enum msg_hash_enums *error_enum,
|
|
char **err_string)
|
|
{
|
|
bool subsystem_path_is_empty = path_is_empty(RARCH_PATH_SUBSYSTEM);
|
|
bool ret = subsystem_path_is_empty;
|
|
const struct retro_subsystem_info *special = subsystem_path_is_empty ?
|
|
NULL : content_file_init_subsystem(content_ctx->subsystem.data,
|
|
content_ctx->subsystem.size, error_enum, err_string, &ret);
|
|
|
|
if (!ret)
|
|
return false;
|
|
|
|
content_file_set_attributes(content, special, content_ctx);
|
|
|
|
if (content->size > 0)
|
|
{
|
|
content_file_list_t *file_list = content_file_list_init(content->size);
|
|
if (file_list)
|
|
{
|
|
p_content->content_list = file_list;
|
|
ret = content_file_load(p_content, content, content_ctx,
|
|
error_enum, err_string, special);
|
|
|
|
content_file_list_free_transient_data(p_content->content_list);
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
if (!special)
|
|
{
|
|
*error_enum = MSG_ERROR_LIBRETRO_CORE_REQUIRES_CONTENT;
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/******************************/
|
|
/* Content file functions END */
|
|
/******************************/
|
|
|
|
/**
|
|
* content_load_init_wrap:
|
|
* @args : Input arguments.
|
|
* @argc : Count of arguments.
|
|
* @argv : Arguments.
|
|
*
|
|
* Generates an @argc and @argv pair based on @args
|
|
* of type rarch_main_wrap.
|
|
**/
|
|
static void content_load_init_wrap(
|
|
const struct rarch_main_wrap *args,
|
|
int *argc, char **argv)
|
|
{
|
|
*argc = 0;
|
|
argv[(*argc)++] = strldup("retroarch", sizeof("retroarch"));
|
|
|
|
if (args->content_path)
|
|
{
|
|
RARCH_LOG("[Core] Using content: \"%s\".\n", args->content_path);
|
|
argv[(*argc)++] = strdup(args->content_path);
|
|
}
|
|
#ifdef HAVE_MENU
|
|
else
|
|
{
|
|
RARCH_LOG("[Core] %s\n",
|
|
msg_hash_to_str(MSG_NO_CONTENT_STARTING_DUMMY_CORE));
|
|
argv[(*argc)++] = strldup("--menu", sizeof("--menu"));
|
|
}
|
|
#endif
|
|
|
|
if (args->sram_path)
|
|
{
|
|
argv[(*argc)++] = strldup("-s", sizeof("-s"));
|
|
argv[(*argc)++] = strdup(args->sram_path);
|
|
}
|
|
|
|
if (args->state_path)
|
|
{
|
|
argv[(*argc)++] = strldup("-S", sizeof("-S"));
|
|
argv[(*argc)++] = strdup(args->state_path);
|
|
}
|
|
|
|
if (args->config_path)
|
|
{
|
|
argv[(*argc)++] = strldup("-c", sizeof("-c"));
|
|
argv[(*argc)++] = strdup(args->config_path);
|
|
}
|
|
|
|
#ifdef HAVE_DYNAMIC
|
|
if (args->libretro_path)
|
|
{
|
|
argv[(*argc)++] = strldup("-L", sizeof("-L"));
|
|
argv[(*argc)++] = strdup(args->libretro_path);
|
|
}
|
|
#endif
|
|
|
|
if (args->flags & RARCH_MAIN_WRAP_FLAG_VERBOSE)
|
|
argv[(*argc)++] = strldup("-v", sizeof("-v"));
|
|
}
|
|
|
|
/* ---- the content load: a job the frame loop advances in stages ---- */
|
|
|
|
enum content_load_stage
|
|
{
|
|
CONTENT_LOAD_STAGE_NONE = 0,
|
|
/* The old session closes: SRAM written, core unloaded; the drivers
|
|
* stay up when staged. */
|
|
CONTENT_LOAD_STAGE_DEINIT,
|
|
/* A save or load state task is still inside the old core: the
|
|
* close waits for it, presenting, and finishes when it is out. */
|
|
CONTENT_LOAD_STAGE_CLOSE_WAIT,
|
|
/* The new core's library is opened on the task worker, presenting,
|
|
* now that the old one is closed. */
|
|
CONTENT_LOAD_STAGE_CORE_PRELOAD,
|
|
/* The new core comes up behind those drivers: configuration,
|
|
* task queue, dlopen, retro_init, the content read, retro_load_game. */
|
|
CONTENT_LOAD_STAGE_CORE,
|
|
/* One driver reinit against the new core, then the session tail
|
|
* and whatever the entry point asked for after the load. */
|
|
CONTENT_LOAD_STAGE_DRIVERS,
|
|
CONTENT_LOAD_STAGE_FIRMWARE
|
|
};
|
|
|
|
/* What an entry point wants done once the load is through. */
|
|
enum content_load_after
|
|
{
|
|
CONTENT_LOAD_AFTER_HISTORY = 1 << 0,
|
|
CONTENT_LOAD_AFTER_HISTORY_MENU = 1 << 1, /* launched from menu */
|
|
CONTENT_LOAD_AFTER_HISTORY_CLI = 1 << 2,
|
|
CONTENT_LOAD_AFTER_HISTORY_UI = 1 << 3, /* companion UI */
|
|
CONTENT_LOAD_AFTER_QUICK_MENU = 1 << 4,
|
|
CONTENT_LOAD_AFTER_QUICK_MENU_KEEP = 1 << 5, /* without a menu flush */
|
|
CONTENT_LOAD_AFTER_MENU_ON_FAIL = 1 << 6, /* retroarch_menu_running */
|
|
CONTENT_LOAD_AFTER_DUMMY_IS_FAIL = 1 << 7, /* the dummy core counts as failure */
|
|
CONTENT_LOAD_AFTER_QUIT_ON_FAIL = 1 << 8 /* retroarch_main_quit_failure */
|
|
};
|
|
|
|
#ifdef HAVE_CORE_LOAD_CHECK
|
|
struct content_load_parked;
|
|
#endif
|
|
|
|
#ifdef HAVE_MENU
|
|
struct content_firmware
|
|
{
|
|
size_t index;
|
|
unsigned missing_count;
|
|
char system_dir[DIR_MAX_LENGTH];
|
|
char target[PATH_MAX_LENGTH];
|
|
char download[PATH_MAX_LENGTH];
|
|
#ifdef HAVE_NETWORKING
|
|
char url[PATH_MAX_LENGTH];
|
|
#endif
|
|
char message[1024];
|
|
bool shown;
|
|
bool downloading;
|
|
bool failed;
|
|
bool archive;
|
|
bool confirmed;
|
|
bool cancelled;
|
|
bool has_download;
|
|
bool download_requested;
|
|
};
|
|
|
|
#if defined(HAVE_NETWORKING)
|
|
static bool content_firmware_path_valid(const char *path)
|
|
{
|
|
const char *part = path;
|
|
const char *end;
|
|
if (string_is_empty(path) || *path == '/' || *path == '\\')
|
|
return false;
|
|
|
|
do
|
|
{
|
|
end = part + strcspn(part, "/\\");
|
|
if (end == part || (end - part == 2 && !memcmp(part, "..", 2))
|
|
|| memchr(part, ':', end - part))
|
|
return false;
|
|
part = end + 1;
|
|
} while (*end);
|
|
|
|
return true;
|
|
}
|
|
|
|
static void content_firmware_download_finish(struct content_firmware *firmware,
|
|
bool success)
|
|
{
|
|
filestream_delete(firmware->download);
|
|
firmware->downloading = false;
|
|
|
|
if (!success || !path_is_valid(firmware->target))
|
|
firmware->failed = true;
|
|
}
|
|
|
|
#ifdef HAVE_COMPRESSION
|
|
static void content_firmware_extracted(retro_task_t *task,
|
|
void *task_data, void *user_data, const char *err)
|
|
{
|
|
decompress_task_data_t *data = (decompress_task_data_t*)task_data;
|
|
struct content_firmware *firmware = (struct content_firmware*)user_data;
|
|
content_firmware_download_finish(firmware, !err);
|
|
if (data)
|
|
{
|
|
free(data->source_file);
|
|
free(data);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
static void content_firmware_downloaded(retro_task_t *task,
|
|
void *task_data, void *user_data, const char *err)
|
|
{
|
|
http_transfer_data_t *data = (http_transfer_data_t*)task_data;
|
|
struct content_firmware *firmware = (struct content_firmware*)user_data;
|
|
bool success = !err && data && data->status >= 200 && data->status < 300;
|
|
#ifdef HAVE_COMPRESSION
|
|
if (success && firmware->archive)
|
|
{
|
|
if (task_push_decompress(firmware->download, firmware->system_dir,
|
|
NULL, NULL, NULL, content_firmware_extracted, firmware,
|
|
NULL, false))
|
|
return;
|
|
|
|
success = false;
|
|
}
|
|
else
|
|
#endif
|
|
if (success)
|
|
success = filestream_rename(firmware->download, firmware->target) == 0;
|
|
|
|
content_firmware_download_finish(firmware, success);
|
|
}
|
|
#endif
|
|
#endif
|
|
|
|
struct content_load_job
|
|
{
|
|
#ifdef HAVE_MENU
|
|
struct content_firmware *firmware;
|
|
#endif
|
|
struct rarch_main_wrap *wrap_args;
|
|
char **argv_ptr;
|
|
int *argc_ptr;
|
|
char *rarch_argv[MAX_ARGS];
|
|
char *argv_copy [MAX_ARGS];
|
|
content_ctx_info_t info;
|
|
int rarch_argc;
|
|
unsigned after;
|
|
enum content_load_stage stage;
|
|
bool staged; /* advanced from the frame loop; else run in one go */
|
|
bool verbosity;
|
|
bool ok;
|
|
bool fell_back; /* the core failed; the dummy core took its place */
|
|
#ifdef HAVE_CORE_LOAD_CHECK
|
|
struct content_load_parked *parked; /* to re-run if the core is refused */
|
|
bool (*refused)(const char *core_path); /* or takes the refusal */
|
|
#endif
|
|
};
|
|
|
|
/* One load at a time: an entry point called while a job is in flight
|
|
* is refused, as the prefetch deferral refuses a second deferral. */
|
|
static struct content_load_job content_load_job;
|
|
/* How the last job ended, for the unstaged caller's return value. */
|
|
static bool content_load_job_result;
|
|
|
|
#ifdef HAVE_CORE_LOAD_CHECK
|
|
static void content_load_parked_free(void *ud);
|
|
#endif
|
|
|
|
#ifdef HAVE_MENU
|
|
void task_content_firmware_download(void)
|
|
{
|
|
struct content_firmware *firmware = content_load_job.firmware;
|
|
if (firmware)
|
|
{
|
|
firmware->confirmed = true;
|
|
firmware->download_requested = firmware->has_download;
|
|
}
|
|
}
|
|
|
|
#if defined(HAVE_NETWORKING)
|
|
static void content_firmware_download_start(struct content_firmware *firmware,
|
|
const char *url)
|
|
{
|
|
char parent[PATH_MAX_LENGTH];
|
|
char title[NAME_MAX_LENGTH];
|
|
size_t _len;
|
|
strlcpy(parent, firmware->download, sizeof(parent));
|
|
path_basedir_wrapper(parent);
|
|
|
|
if (!path_mkdir(parent))
|
|
{
|
|
firmware->failed = true;
|
|
return;
|
|
}
|
|
/* Left by a download that was cut off: the name is ours */
|
|
filestream_delete(firmware->download);
|
|
|
|
firmware->downloading = true;
|
|
|
|
/* Named as every other download is: "Downloading: <file>" */
|
|
_len = 0;
|
|
strlcpy_append(title, sizeof(title), &_len,
|
|
msg_hash_to_str(MSG_DOWNLOADING));
|
|
strlcpy_append(title, sizeof(title), &_len, ": ");
|
|
strlcpy_append(title, sizeof(title), &_len,
|
|
path_basename(firmware->target));
|
|
|
|
/* The HTTP task copies the borrowed URL and title on submission. */
|
|
if (!task_push_http_download_file(url, firmware->download,
|
|
false, title, content_firmware_downloaded, firmware))
|
|
content_firmware_download_finish(firmware, false);
|
|
}
|
|
#endif
|
|
|
|
static bool content_load_firmware(struct content_load_job *job)
|
|
{
|
|
struct menu_state *menu_st = menu_state_get_ptr();
|
|
settings_t *settings = config_get_ptr();
|
|
struct content_firmware *firmware = job->firmware;
|
|
core_info_t *core = NULL;
|
|
core_info_firmware_t *entry;
|
|
bool download_available = false;
|
|
const char *content = path_get(RARCH_PATH_CONTENT);
|
|
#if defined(HAVE_NETWORKING)
|
|
const char *url = NULL;
|
|
const char *download_url;
|
|
#endif
|
|
|
|
if (firmware && firmware->downloading)
|
|
return false;
|
|
|
|
if (!settings->bools.core_firmware_notification_enable
|
|
|| !menu_st->driver_data
|
|
|| (string_is_empty(content)
|
|
&& !runloop_state_get_ptr()->system.load_no_content)
|
|
|| !core_info_find(path_get(RARCH_PATH_CORE), &core)
|
|
|| !core || !core->firmware_count)
|
|
return true;
|
|
|
|
if (menu_st->dialog_st.confirm_cmd || menu_st->dialog_st.pending_cmd)
|
|
return false;
|
|
|
|
if (!firmware)
|
|
{
|
|
firmware = (struct content_firmware*)calloc(1, sizeof(*firmware));
|
|
if (!firmware)
|
|
return true;
|
|
|
|
job->firmware = firmware;
|
|
|
|
if ((settings->bools.systemfiles_in_content_dir
|
|
|| string_is_empty(settings->paths.directory_system))
|
|
&& !string_is_empty(content))
|
|
fill_pathname_basedir(firmware->system_dir, content,
|
|
sizeof(firmware->system_dir));
|
|
else
|
|
strlcpy(firmware->system_dir, settings->paths.directory_system,
|
|
sizeof(firmware->system_dir));
|
|
}
|
|
|
|
if (firmware->shown && !firmware->download_requested)
|
|
{
|
|
firmware->cancelled = !firmware->has_download && !firmware->confirmed;
|
|
return true;
|
|
}
|
|
|
|
if (firmware->index >= core->firmware_count)
|
|
{
|
|
if (firmware->shown)
|
|
{
|
|
if (firmware->failed)
|
|
{
|
|
const char *msg = msg_hash_to_str(MSG_CORE_FIRMWARE_DOWNLOAD_FAILED);
|
|
runloop_msg_queue_push(msg, strlen(msg), 1, 180, true, NULL,
|
|
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_ERROR);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
if (!firmware->missing_count)
|
|
return true;
|
|
|
|
strlcat(firmware->message, "\n\n", sizeof(firmware->message));
|
|
strlcat(firmware->message, msg_hash_to_str(firmware->has_download
|
|
? MSG_CORE_FIRMWARE_DOWNLOAD_PROMPT
|
|
: MSG_CORE_FIRMWARE_CONTINUE_PROMPT), sizeof(firmware->message));
|
|
firmware->shown = true;
|
|
firmware->index = 0;
|
|
|
|
menu_dialog_confirm_set(menu_st, MSG_CORE_FIRMWARE_MISSING,
|
|
CMD_EVENT_CORE_FIRMWARE_DOWNLOAD);
|
|
menu_st->dialog_st.confirm_text = firmware->message;
|
|
retroarch_menu_running();
|
|
|
|
return false;
|
|
}
|
|
|
|
entry = &core->firmware[firmware->index++];
|
|
if (entry->optional || string_is_empty(entry->path))
|
|
return false;
|
|
|
|
fill_pathname_join(firmware->target, firmware->system_dir,
|
|
entry->path, sizeof(firmware->target));
|
|
|
|
if (path_is_valid(firmware->target))
|
|
return false;
|
|
|
|
#if defined(HAVE_NETWORKING)
|
|
download_url = entry->url;
|
|
if (!string_is_empty(download_url)
|
|
&& !strchr(download_url, ':')
|
|
&& content_firmware_path_valid(download_url))
|
|
{
|
|
int written = snprintf(firmware->url, sizeof(firmware->url),
|
|
"%ssystem/%s", DEFAULT_BUILDBOT_ASSETS_SERVER_URL, download_url);
|
|
download_url = written >= 0
|
|
&& (size_t)written < sizeof(firmware->url)
|
|
? firmware->url : NULL;
|
|
}
|
|
|
|
if (!string_is_empty(firmware->system_dir)
|
|
&& content_firmware_path_valid(entry->path)
|
|
&& !string_is_empty(download_url)
|
|
&& (string_starts_with_size(download_url, "https://", 8)
|
|
|| string_starts_with_size(download_url, "http://", 7)))
|
|
{
|
|
char url_path[PATH_MAX_LENGTH];
|
|
strlcpy(url_path, download_url, sizeof(url_path));
|
|
url_path[strcspn(url_path, "?#")] = '\0';
|
|
firmware->archive = path_is_compressed_file(url_path);
|
|
#ifndef HAVE_COMPRESSION
|
|
if (!firmware->archive)
|
|
#endif
|
|
{
|
|
if (firmware->archive)
|
|
{
|
|
char name[64];
|
|
snprintf(name, sizeof(name), ".retroarch-firmware.%s",
|
|
path_get_extension(url_path));
|
|
fill_pathname_join(firmware->download, firmware->system_dir,
|
|
name, sizeof(firmware->download));
|
|
}
|
|
else
|
|
{
|
|
size_t len = strlcpy(firmware->download, firmware->target,
|
|
sizeof(firmware->download));
|
|
if (len + sizeof(".download") > sizeof(firmware->download))
|
|
return false;
|
|
strlcpy_lit(firmware->download + len, ".download",
|
|
sizeof(firmware->download) - len);
|
|
}
|
|
|
|
download_available = true;
|
|
|
|
if (firmware->shown)
|
|
url = download_url;
|
|
else
|
|
firmware->has_download = true;
|
|
}
|
|
}
|
|
#endif
|
|
if (firmware->shown)
|
|
{
|
|
#if defined(HAVE_NETWORKING)
|
|
if (url)
|
|
content_firmware_download_start(firmware, url);
|
|
#endif
|
|
return false;
|
|
}
|
|
|
|
if (!firmware->missing_count)
|
|
strlcpy(firmware->message, msg_hash_to_str(MSG_CORE_FIRMWARE_MISSING),
|
|
sizeof(firmware->message));
|
|
|
|
strlcat(firmware->message, "\n\n", sizeof(firmware->message));
|
|
{
|
|
char number[32];
|
|
snprintf(number, sizeof(number), "%u. ", ++firmware->missing_count);
|
|
strlcat(firmware->message, number, sizeof(firmware->message));
|
|
}
|
|
|
|
strlcat(firmware->message, entry->path, sizeof(firmware->message));
|
|
strlcat(firmware->message, "\n[", sizeof(firmware->message));
|
|
strlcat(firmware->message, msg_hash_to_str(download_available
|
|
? MSG_CORE_FIRMWARE_DOWNLOAD_AVAILABLE
|
|
: MSG_CORE_FIRMWARE_SUPPLY_MANUALLY), sizeof(firmware->message));
|
|
strlcat(firmware->message, "]", sizeof(firmware->message));
|
|
|
|
if (!string_is_empty(entry->desc))
|
|
{
|
|
strlcat(firmware->message, "\n", sizeof(firmware->message));
|
|
strlcat(firmware->message, entry->desc, sizeof(firmware->message));
|
|
}
|
|
|
|
return false;
|
|
}
|
|
#endif
|
|
|
|
static void content_load_job_free(struct content_load_job *job)
|
|
{
|
|
size_t i;
|
|
for (i = 0; i < ARRAY_SIZE(job->argv_copy); i++)
|
|
{
|
|
free(job->argv_copy[i]);
|
|
job->argv_copy[i] = NULL;
|
|
}
|
|
#ifdef HAVE_MENU
|
|
if (job->firmware)
|
|
{
|
|
struct menu_state *menu_st = menu_state_get_ptr();
|
|
/* The dialog borrows the message: it goes with it */
|
|
if (menu_st->dialog_st.confirm_text == job->firmware->message)
|
|
menu_dialog_confirm_clear(menu_st);
|
|
free(job->firmware);
|
|
job->firmware = NULL;
|
|
}
|
|
#endif
|
|
free(job->wrap_args);
|
|
job->wrap_args = NULL;
|
|
#ifdef HAVE_CORE_LOAD_CHECK
|
|
content_load_parked_free(job->parked);
|
|
job->parked = NULL;
|
|
#endif
|
|
job->stage = CONTENT_LOAD_STAGE_NONE;
|
|
}
|
|
|
|
/* The arguments the core stage parses, from the job's content info. */
|
|
static void content_load_job_args(struct content_load_job *job)
|
|
{
|
|
struct rarch_main_wrap *wrap_args = job->wrap_args;
|
|
|
|
/* The following snippet breaks command-line arguments on Haiku which in turn
|
|
prevents from using RA without a menu or to start it from a front-end like ES-DE.
|
|
All things considered, the risk/reward is favorable to just skipping this. */
|
|
#ifndef __HAIKU__
|
|
if (job->info.environ_get)
|
|
job->info.environ_get(job->argc_ptr,
|
|
job->argv_ptr, job->info.args, wrap_args);
|
|
#endif
|
|
if (wrap_args->flags & RARCH_MAIN_WRAP_FLAG_TOUCHED)
|
|
{
|
|
content_load_init_wrap(wrap_args, &job->rarch_argc, job->rarch_argv);
|
|
memcpy(job->argv_copy, job->rarch_argv, sizeof(job->rarch_argv));
|
|
job->argv_ptr = job->rarch_argv;
|
|
job->argc_ptr = &job->rarch_argc;
|
|
}
|
|
|
|
wrap_args->argc = *job->argc_ptr;
|
|
wrap_args->argv = job->argv_ptr;
|
|
}
|
|
|
|
void menu_content_environment_get(int *argc, char *argv[],
|
|
void *args, void *params_data);
|
|
|
|
/* The core stage failed after the old session was closed - a library
|
|
* that opened and then turned out not to be a core, say. The load
|
|
* lands on the dummy core instead, as every caller already allows for:
|
|
* the drivers come back and the menu has something to run against. */
|
|
static void content_load_job_fall_back(struct content_load_job *job)
|
|
{
|
|
struct rarch_main_wrap *wrap_args = job->wrap_args;
|
|
size_t i;
|
|
|
|
for (i = 0; i < ARRAY_SIZE(job->argv_copy); i++)
|
|
{
|
|
free(job->argv_copy[i]);
|
|
job->argv_copy[i] = NULL;
|
|
}
|
|
memset(job->rarch_argv, 0, sizeof(job->rarch_argv));
|
|
job->rarch_argc = 0;
|
|
wrap_args->argv = NULL;
|
|
wrap_args->content_path = NULL;
|
|
wrap_args->sram_path = NULL;
|
|
wrap_args->state_path = NULL;
|
|
wrap_args->config_path = NULL;
|
|
wrap_args->libretro_path = NULL;
|
|
wrap_args->flags = 0;
|
|
wrap_args->argc = 0;
|
|
|
|
job->info.argc = 0;
|
|
job->info.argv = NULL;
|
|
job->info.args = NULL;
|
|
job->info.environ_get = menu_content_environment_get;
|
|
job->argv_ptr = NULL;
|
|
job->argc_ptr = &job->info.argc;
|
|
job->fell_back = true;
|
|
|
|
path_clear(RARCH_PATH_CONTENT);
|
|
runloop_set_current_core_type(CORE_TYPE_DUMMY, true);
|
|
content_load_job_args(job);
|
|
/* An opened library the failed core stage did not take */
|
|
runloop_core_preload_cancel();
|
|
}
|
|
|
|
/* The close of the old session. Staged, the drivers stay up
|
|
* (runloop_event_deinit_core keys off content_switching) and keep
|
|
* presenting until the driver stage. */
|
|
static bool content_load_stage_deinit(struct content_load_job *job)
|
|
{
|
|
content_load_job_args(job);
|
|
|
|
/* Staged, a save or load state task still inside the core is
|
|
* waited out from the frame loop, one check per frame; in one go,
|
|
* here. */
|
|
if (!job->staged)
|
|
{
|
|
retroarch_ctl(RARCH_CTL_MAIN_DEINIT, NULL);
|
|
return false;
|
|
}
|
|
return retroarch_main_deinit_begin();
|
|
}
|
|
|
|
static bool content_load_stage_core(struct content_load_job *job)
|
|
{
|
|
/* Staged, the previous session's drivers are still up: they are
|
|
* found once freed, in the driver stage. */
|
|
return retroarch_main_init_core(job->wrap_args->argc,
|
|
job->wrap_args->argv, !job->staged, &job->verbosity);
|
|
}
|
|
|
|
static bool content_load_stage_drivers(struct content_load_job *job)
|
|
{
|
|
return retroarch_main_init_drivers(job->staged, job->verbosity);
|
|
}
|
|
|
|
/* Everything content_load() did once retroarch_main_init() had
|
|
* returned true. */
|
|
static void content_load_tail(struct content_load_job *job,
|
|
content_state_t *p_content)
|
|
{
|
|
if (p_content->flags & CONTENT_ST_FLAG_PENDING_SUBSYSTEM_INIT)
|
|
content_clear_subsystem();
|
|
|
|
#ifdef HAVE_GFX_WIDGETS
|
|
#ifdef HAVE_CONFIGFILE
|
|
/* The load went through, so a load content animation is safe to
|
|
* trigger.
|
|
*
|
|
* Unless the deferred path already started one before the read,
|
|
* so it could carry the read percentage: restarting it here would
|
|
* replay the card the user has been watching. Clear the
|
|
* percentage instead - the read is over - and leave it be. */
|
|
if (gfx_widgets_ready())
|
|
{
|
|
if (content_load_animation_showing)
|
|
{
|
|
gfx_widget_set_load_content_progress(-1);
|
|
content_load_animation_showing = false;
|
|
}
|
|
else
|
|
{
|
|
/* Note: Have to read settings value here
|
|
* (It will be invalid if we try to read
|
|
* it earlier...) */
|
|
settings_t *settings = config_get_ptr();
|
|
bool show_load_content_animation = settings && settings->bools.menu_show_load_content_animation;
|
|
if (show_load_content_animation)
|
|
gfx_widget_start_load_content_animation();
|
|
}
|
|
}
|
|
#endif
|
|
#endif
|
|
|
|
#ifdef HAVE_MENU
|
|
#if defined(HAVE_CG) || defined(HAVE_GLSL) || defined(HAVE_SLANG) || defined(HAVE_HLSL)
|
|
menu_shader_manager_init();
|
|
#endif
|
|
#endif
|
|
|
|
#ifdef HAVE_MENU
|
|
retroarch_favorites_init();
|
|
command_event(CMD_EVENT_HISTORY_INIT, NULL);
|
|
#endif
|
|
|
|
command_event(CMD_EVENT_RESUME, NULL);
|
|
command_event(CMD_EVENT_VIDEO_SET_ASPECT_RATIO, NULL);
|
|
|
|
frontend_driver_process_args(job->argc_ptr, job->argv_ptr);
|
|
frontend_driver_content_loaded();
|
|
}
|
|
|
|
#if defined(HAVE_DYNAMIC) && defined(HAVE_MENU)
|
|
static void content_file_prefetch_free(content_state_t *p_content);
|
|
#endif
|
|
static void task_push_to_history_list(content_state_t *p_content,
|
|
bool launched_from_menu, bool launched_from_cli,
|
|
bool launched_from_companion_ui);
|
|
|
|
void task_content_load_notify_finish(const char *error)
|
|
{
|
|
const char *path = path_get(RARCH_PATH_CONTENT);
|
|
task_notify_fire(&content_state_get_ptr()->load_notify,
|
|
(path && *path) ? (void*)path : NULL, error);
|
|
}
|
|
|
|
bool task_content_load_pending(void)
|
|
{
|
|
return content_load_job.stage != CONTENT_LOAD_STAGE_NONE;
|
|
}
|
|
|
|
/* The entry point's after-load work, and the job's end. */
|
|
static void content_load_finish(struct content_load_job *job,
|
|
content_state_t *p_content)
|
|
{
|
|
runloop_state_t *runloop_st = runloop_state_get_ptr();
|
|
unsigned after = job->after;
|
|
bool ok = job->ok;
|
|
|
|
runloop_st->content_switching = false;
|
|
/* A library opened for a core stage that never took it */
|
|
runloop_core_preload_cancel();
|
|
#ifdef HAVE_MENU
|
|
/* A Load State slot asked for with this load, left over when the
|
|
* load failed before the content came up */
|
|
{
|
|
menu_handle_t *menu = menu_state_get_ptr()->driver_data;
|
|
if (menu)
|
|
menu->state_slot_run_pending = false;
|
|
}
|
|
#endif
|
|
|
|
if (ok)
|
|
content_load_tail(job, p_content);
|
|
|
|
/* The core asked for failed and the dummy core took its place: the
|
|
* load failed, said now that there are drivers to say it on. */
|
|
if (job->fell_back)
|
|
{
|
|
if (ok)
|
|
{
|
|
const char *_msg = msg_hash_to_str(MSG_FAILED_TO_LOAD_CONTENT);
|
|
runloop_msg_queue_push(_msg, strlen(_msg), 2, 180, true, NULL,
|
|
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_ERROR);
|
|
}
|
|
ok = false;
|
|
}
|
|
|
|
/* A load that fell back to the dummy core did not start the core
|
|
* the caller asked for. */
|
|
if ( ok
|
|
&& (after & CONTENT_LOAD_AFTER_DUMMY_IS_FAIL)
|
|
&& runloop_st->current_core_type == CORE_TYPE_DUMMY)
|
|
ok = false;
|
|
|
|
if (!ok && (after & CONTENT_LOAD_AFTER_QUIT_ON_FAIL))
|
|
retroarch_main_quit_failure();
|
|
|
|
if (ok)
|
|
{
|
|
if (after & CONTENT_LOAD_AFTER_HISTORY)
|
|
task_push_to_history_list(p_content,
|
|
(after & CONTENT_LOAD_AFTER_HISTORY_MENU) != 0,
|
|
(after & CONTENT_LOAD_AFTER_HISTORY_CLI) != 0,
|
|
(after & CONTENT_LOAD_AFTER_HISTORY_UI) != 0);
|
|
#ifdef HAVE_MENU
|
|
if (after & CONTENT_LOAD_AFTER_QUICK_MENU)
|
|
{
|
|
bool flush_menu = !(after & CONTENT_LOAD_AFTER_QUICK_MENU_KEEP);
|
|
menu_driver_ctl(RARCH_MENU_CTL_SET_PENDING_QUICK_MENU,
|
|
flush_menu ? NULL : &flush_menu);
|
|
}
|
|
#endif
|
|
}
|
|
#ifdef HAVE_MENU
|
|
else if (after & CONTENT_LOAD_AFTER_MENU_ON_FAIL)
|
|
retroarch_menu_running();
|
|
#endif
|
|
|
|
#if defined(HAVE_DYNAMIC) && defined(HAVE_MENU)
|
|
content_file_prefetch_free(p_content); /* leftovers, if any */
|
|
#endif
|
|
content_load_job_result = ok;
|
|
content_load_job_free(job);
|
|
task_content_load_notify_finish(ok ? NULL
|
|
: msg_hash_to_str(MSG_FAILED_TO_LOAD_CONTENT));
|
|
}
|
|
|
|
#ifdef HAVE_CORE_LOAD_CHECK
|
|
static bool content_load(content_ctx_info_t *info,
|
|
content_state_t *p_content, unsigned after, bool staged);
|
|
|
|
/* A staged load the check refused, kept to run again as it was asked */
|
|
struct content_load_parked
|
|
{
|
|
content_ctx_info_t info;
|
|
char *core_path;
|
|
char *content_path;
|
|
char *label;
|
|
char *db_name;
|
|
char *crc32;
|
|
char *subsystem_ident;
|
|
char *subsystem_roms[RARCH_MAX_SUBSYSTEM_ROMS];
|
|
unsigned after;
|
|
unsigned subsystem_rom_id;
|
|
int subsystem_id;
|
|
int subsystem_rom_num;
|
|
bool subsystem_init;
|
|
};
|
|
|
|
static void content_load_parked_free(void *ud)
|
|
{
|
|
struct content_load_parked *d = (struct content_load_parked*)ud;
|
|
int i;
|
|
if (!d)
|
|
return;
|
|
free(d->core_path);
|
|
free(d->content_path);
|
|
free(d->label);
|
|
free(d->db_name);
|
|
free(d->crc32);
|
|
free(d->subsystem_ident);
|
|
for (i = 0; i < RARCH_MAX_SUBSYSTEM_ROMS; i++)
|
|
free(d->subsystem_roms[i]);
|
|
free(d);
|
|
}
|
|
|
|
static void content_load_parked_run(void *ud)
|
|
{
|
|
struct content_load_parked *d = (struct content_load_parked*)ud;
|
|
runloop_state_t *runloop_st = runloop_state_get_ptr();
|
|
content_state_t *p_content = content_state_get_ptr();
|
|
int i;
|
|
path_set(RARCH_PATH_CORE, d->core_path);
|
|
if (d->content_path)
|
|
path_set(RARCH_PATH_CONTENT, d->content_path);
|
|
else
|
|
path_clear(RARCH_PATH_CONTENT);
|
|
strlcpy(runloop_st->name.label, d->label ? d->label : "",
|
|
sizeof(runloop_st->name.label));
|
|
strlcpy(p_content->companion_ui_db_name, d->db_name ? d->db_name : "",
|
|
sizeof(p_content->companion_ui_db_name));
|
|
strlcpy(p_content->companion_ui_crc32, d->crc32 ? d->crc32 : "",
|
|
sizeof(p_content->companion_ui_crc32));
|
|
content_clear_subsystem();
|
|
/* As it was: content_set_subsystem() would read the current core's
|
|
* subsystems, the dummy core's by now */
|
|
if (d->subsystem_init)
|
|
{
|
|
strlcpy(p_content->pending_subsystem_ident,
|
|
d->subsystem_ident ? d->subsystem_ident : "",
|
|
sizeof(p_content->pending_subsystem_ident));
|
|
p_content->pending_subsystem_id = d->subsystem_id;
|
|
p_content->pending_subsystem_rom_num = d->subsystem_rom_num;
|
|
p_content->pending_subsystem_rom_id = d->subsystem_rom_id;
|
|
for (i = 0; i < RARCH_MAX_SUBSYSTEM_ROMS; i++)
|
|
{
|
|
p_content->pending_subsystem_roms[i] = d->subsystem_roms[i];
|
|
d->subsystem_roms[i] = NULL;
|
|
}
|
|
p_content->flags |= CONTENT_ST_FLAG_PENDING_SUBSYSTEM_INIT;
|
|
}
|
|
runloop_set_current_core_type(CORE_TYPE_PLAIN, true);
|
|
if (!content_load(&d->info, p_content, d->after, true))
|
|
{
|
|
if (d->after & CONTENT_LOAD_AFTER_QUIT_ON_FAIL)
|
|
retroarch_main_quit_failure();
|
|
#ifdef HAVE_MENU
|
|
else
|
|
retroarch_menu_running();
|
|
#endif
|
|
}
|
|
}
|
|
|
|
/* What the re-run needs, taken before the core stage's dummy fallback
|
|
* changes it */
|
|
static struct content_load_parked *content_load_parked_new(
|
|
struct content_load_job *job)
|
|
{
|
|
struct content_load_parked *d = NULL;
|
|
runloop_state_t *runloop_st = runloop_state_get_ptr();
|
|
content_state_t *p_content = content_state_get_ptr();
|
|
const char *core_path = path_get(RARCH_PATH_CORE);
|
|
const char *content_path = path_get(RARCH_PATH_CONTENT);
|
|
int i;
|
|
if (!(d = (struct content_load_parked*)calloc(1, sizeof(*d))))
|
|
return NULL;
|
|
/* A menu load again: no startup argv */
|
|
d->info.environ_get = job->info.environ_get;
|
|
d->after = job->after;
|
|
d->core_path = strdup(core_path ? core_path : "");
|
|
d->content_path = (content_path && *content_path)
|
|
? strdup(content_path) : NULL;
|
|
/* Else the re-run would start the core without its content */
|
|
if (content_path && *content_path && !d->content_path)
|
|
{
|
|
content_load_parked_free(d);
|
|
return NULL;
|
|
}
|
|
d->label = strdup(runloop_st->name.label);
|
|
d->db_name = strdup(p_content->companion_ui_db_name);
|
|
d->crc32 = strdup(p_content->companion_ui_crc32);
|
|
d->subsystem_init = (p_content->flags
|
|
& CONTENT_ST_FLAG_PENDING_SUBSYSTEM_INIT) ? true : false;
|
|
d->subsystem_ident = strdup(p_content->pending_subsystem_ident);
|
|
d->subsystem_id = p_content->pending_subsystem_id;
|
|
d->subsystem_rom_num = p_content->pending_subsystem_rom_num;
|
|
d->subsystem_rom_id = p_content->pending_subsystem_rom_id;
|
|
for (i = 0; i < RARCH_MAX_SUBSYSTEM_ROMS; i++)
|
|
if (p_content->pending_subsystem_roms[i])
|
|
d->subsystem_roms[i] = strdup(p_content->pending_subsystem_roms[i]);
|
|
return d;
|
|
}
|
|
|
|
/* After the core stage: parks the snapshot if that stage's open of the
|
|
* core was refused, else drops it */
|
|
static void content_load_park(struct content_load_job *job)
|
|
{
|
|
struct content_load_parked *d = job->parked;
|
|
job->parked = NULL;
|
|
if (!d)
|
|
return;
|
|
if ( !core_load_check_refused(d->core_path)
|
|
|| !core_load_check_park(d->core_path, content_load_parked_run,
|
|
content_load_parked_free, d))
|
|
content_load_parked_free(d);
|
|
}
|
|
|
|
static bool content_load_park_core(const char *core_path,
|
|
core_load_rerun_t rerun);
|
|
|
|
/* A parked Load Core run again: refused again (its core changed since
|
|
* the check), it parks again with the same rerun; else a failed open
|
|
* the check did not refuse is said, as the runloop's is */
|
|
static void content_load_core_open(const char *core_path,
|
|
core_load_rerun_t rerun)
|
|
{
|
|
content_ctx_info_t content_info = {0};
|
|
if ( !task_push_load_new_core(core_path, NULL, &content_info,
|
|
CORE_TYPE_PLAIN, NULL, NULL)
|
|
&& !content_load_park_core(core_path, rerun)
|
|
&& !core_load_check_refused(core_path))
|
|
{
|
|
const char *_msg = msg_hash_to_str(MSG_FAILED_TO_OPEN_LIBRETRO_CORE);
|
|
runloop_msg_queue_push(_msg, strlen(_msg), 1, 180, true, NULL,
|
|
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
|
|
}
|
|
#ifdef HAVE_MENU
|
|
menu_state_get_ptr()->flags |= MENU_ST_FLAG_ENTRIES_NEED_REFRESH
|
|
| MENU_ST_FLAG_PREVENT_POPULATE;
|
|
#endif
|
|
}
|
|
|
|
static void content_load_core_rerun(void *ud)
|
|
{
|
|
content_load_core_open((const char*)ud, content_load_core_rerun);
|
|
}
|
|
|
|
/* The companion UI's Load Core starts a core that runs without content */
|
|
static void content_load_core_start_no_content(void)
|
|
{
|
|
content_ctx_info_t content_info = {0};
|
|
if ( runloop_state_get_ptr()->system.load_no_content
|
|
&& config_get_ptr()->bools.set_supports_no_game_enable)
|
|
{
|
|
path_clear(RARCH_PATH_CONTENT);
|
|
task_push_load_content_with_current_core_from_companion_ui(NULL,
|
|
&content_info, CORE_TYPE_PLAIN, NULL, NULL);
|
|
}
|
|
}
|
|
|
|
/* As content_load_core_rerun(), then started if it runs without
|
|
* content, as the companion UI's Load Core starts it after a probe */
|
|
static void content_load_core_start_rerun(void *ud)
|
|
{
|
|
/* Set by the probe only when it succeeds */
|
|
runloop_state_get_ptr()->system.load_no_content = false;
|
|
content_load_core_open((const char*)ud, content_load_core_start_rerun);
|
|
content_load_core_start_no_content();
|
|
}
|
|
|
|
static bool content_load_park_core(const char *core_path,
|
|
core_load_rerun_t rerun)
|
|
{
|
|
char *d = NULL;
|
|
if ( !core_path
|
|
|| !core_load_check_refused(core_path)
|
|
|| !(d = strdup(core_path)))
|
|
return false;
|
|
if (core_load_check_park(d, rerun, free, d))
|
|
return true;
|
|
free(d);
|
|
return false;
|
|
}
|
|
|
|
bool task_content_park_core_load(const char *core_path)
|
|
{
|
|
return content_load_park_core(core_path, content_load_core_rerun);
|
|
}
|
|
|
|
bool task_content_park_core_start(const char *core_path)
|
|
{
|
|
return content_load_park_core(core_path, content_load_core_start_rerun);
|
|
}
|
|
|
|
void task_content_load_core_start(const char *core_path)
|
|
{
|
|
runloop_state_t *runloop_st = runloop_state_get_ptr();
|
|
bool no_content = runloop_st->system.load_no_content;
|
|
path_set(RARCH_PATH_CORE, core_path);
|
|
/* Set by the open only when it succeeds */
|
|
runloop_st->system.load_no_content = false;
|
|
/* Before the park: only the open's refusal parks */
|
|
command_event(CMD_EVENT_LOAD_CORE, NULL);
|
|
/* The running core's open read back the flag just cleared */
|
|
if (runloop_core_probe_live())
|
|
runloop_st->system.load_no_content = no_content;
|
|
if (!task_content_park_core_start(core_path))
|
|
content_load_core_start_no_content();
|
|
}
|
|
|
|
bool task_content_core_refused_notify(const char *core_path)
|
|
{
|
|
char msg[NAME_MAX_LENGTH + 128];
|
|
if (!core_path || !core_load_check_refused(core_path))
|
|
return false;
|
|
if (core_load_check_refused_seed(core_path))
|
|
strlcpy(msg, msg_hash_to_str(MSG_CORE_LOAD_REFUSED_SEED_PENDING),
|
|
sizeof(msg));
|
|
else
|
|
{
|
|
RARCH_WARN("[Core] Not loading \"%s\": not trusted. Load it from Load Core and choose Always Trust to approve it.\n",
|
|
core_path);
|
|
snprintf(msg, sizeof(msg),
|
|
msg_hash_to_str(MSG_CORE_LOAD_REFUSED_LOAD_CORE),
|
|
path_basename_nocompression(core_path));
|
|
}
|
|
runloop_msg_queue_push(msg, strlen(msg), 2, 360, false, NULL,
|
|
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_WARNING);
|
|
return true;
|
|
}
|
|
|
|
void task_content_load_no_park(bool (*refused)(const char *core_path))
|
|
{
|
|
struct content_load_job *job = &content_load_job;
|
|
if (job->stage == CONTENT_LOAD_STAGE_NONE)
|
|
return;
|
|
job->refused = refused;
|
|
/* Past its preload stage, a load has kept its snapshot already */
|
|
content_load_parked_free(job->parked);
|
|
job->parked = NULL;
|
|
}
|
|
|
|
void task_content_load_refused(const char *core_path)
|
|
{
|
|
struct content_load_job *job = &content_load_job;
|
|
if (job->stage != CONTENT_LOAD_STAGE_NONE && job->refused)
|
|
job->refused(core_path);
|
|
}
|
|
|
|
#ifdef HAVE_MENU
|
|
/* The startup load again, as a menu load: its startup-only options
|
|
* (-H, --record, --entryslot, subsystems) aren't replayed */
|
|
static void content_load_startup_rerun(void *ud)
|
|
{
|
|
struct content_load_parked *d = (struct content_load_parked*)ud;
|
|
content_ctx_info_t content_info = {0};
|
|
rarch_system_info_t *sys_info = &runloop_state_get_ptr()->system;
|
|
if (d->content_path)
|
|
task_push_load_content_with_new_core_from_menu(d->core_path,
|
|
d->content_path, &content_info, CORE_TYPE_PLAIN, NULL, NULL);
|
|
/* With no content, started only by a core that runs without it, as
|
|
* at startup; else loaded, waiting for content. On the probe's word
|
|
* alone (it sets the flag only when it succeeds): a core outside
|
|
* the core info list starts at startup too. */
|
|
else
|
|
{
|
|
sys_info->load_no_content = false;
|
|
/* Refused again (its core changed since the check): asks again */
|
|
if ( !task_push_load_new_core(d->core_path, NULL, &content_info,
|
|
CORE_TYPE_PLAIN, NULL, NULL)
|
|
&& task_content_park_startup(d->core_path, NULL))
|
|
return;
|
|
if ( sys_info->load_no_content
|
|
&& config_get_ptr()->bools.set_supports_no_game_enable)
|
|
task_push_load_contentless_core_from_menu(d->core_path);
|
|
else
|
|
menu_state_get_ptr()->flags |= MENU_ST_FLAG_ENTRIES_NEED_REFRESH
|
|
| MENU_ST_FLAG_PREVENT_POPULATE;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
bool task_content_park_startup(const char *core_path,
|
|
const char *content_path)
|
|
{
|
|
struct content_load_parked *d = NULL;
|
|
core_load_rerun_t rerun = content_load_parked_run;
|
|
if ( !core_path || !*core_path
|
|
|| !core_load_check_refused(core_path)
|
|
|| !(d = (struct content_load_parked*)calloc(1, sizeof(*d))))
|
|
return false;
|
|
d->core_path = strdup(core_path);
|
|
d->content_path = (content_path && *content_path)
|
|
? strdup(content_path) : NULL;
|
|
if (content_path && *content_path && !d->content_path)
|
|
{
|
|
content_load_parked_free(d);
|
|
return false;
|
|
}
|
|
#ifdef HAVE_MENU
|
|
if (menu_core_warning_can_open())
|
|
rerun = content_load_startup_rerun;
|
|
else
|
|
#endif
|
|
{
|
|
/* No menu: a staged load, as the menu's are; failing, it ends
|
|
* RetroArch, as the startup load would have */
|
|
d->info.environ_get = menu_content_environment_get;
|
|
d->after = CONTENT_LOAD_AFTER_HISTORY
|
|
| CONTENT_LOAD_AFTER_HISTORY_MENU
|
|
| CONTENT_LOAD_AFTER_HISTORY_CLI
|
|
| CONTENT_LOAD_AFTER_DUMMY_IS_FAIL
|
|
| CONTENT_LOAD_AFTER_QUIT_ON_FAIL;
|
|
}
|
|
if (core_load_check_park(d->core_path, rerun,
|
|
content_load_parked_free, d))
|
|
return true;
|
|
content_load_parked_free(d);
|
|
return false;
|
|
}
|
|
#endif
|
|
|
|
/* Runs the job's current stage and moves it on. */
|
|
static void content_load_step(struct content_load_job *job,
|
|
content_state_t *p_content)
|
|
{
|
|
switch (job->stage)
|
|
{
|
|
case CONTENT_LOAD_STAGE_FIRMWARE:
|
|
#ifdef HAVE_MENU
|
|
if (!content_load_firmware(job))
|
|
break;
|
|
if (job->firmware && job->firmware->cancelled)
|
|
{
|
|
job->after |= CONTENT_LOAD_AFTER_MENU_ON_FAIL;
|
|
content_load_finish(job, p_content);
|
|
break;
|
|
}
|
|
#endif
|
|
job->stage = CONTENT_LOAD_STAGE_DEINIT;
|
|
break;
|
|
case CONTENT_LOAD_STAGE_DEINIT:
|
|
if (!content_load_stage_deinit(job))
|
|
{
|
|
job->stage = (job->staged && runloop_core_preload_begin())
|
|
? CONTENT_LOAD_STAGE_CORE_PRELOAD
|
|
: CONTENT_LOAD_STAGE_CORE;
|
|
break;
|
|
}
|
|
job->stage = CONTENT_LOAD_STAGE_CLOSE_WAIT;
|
|
/* fall through */
|
|
case CONTENT_LOAD_STAGE_CLOSE_WAIT:
|
|
if (retroarch_main_deinit_pending())
|
|
break;
|
|
retroarch_main_deinit_finish();
|
|
/* The old core is closed now: its library open may start */
|
|
job->stage = (job->staged && runloop_core_preload_begin())
|
|
? CONTENT_LOAD_STAGE_CORE_PRELOAD
|
|
: CONTENT_LOAD_STAGE_CORE;
|
|
break;
|
|
case CONTENT_LOAD_STAGE_CORE_PRELOAD:
|
|
if (!runloop_core_preload_ready())
|
|
break;
|
|
#ifdef HAVE_CORE_LOAD_CHECK
|
|
/* Kept for a re-run if the core stage's open is refused, even
|
|
* after a pass here: the core may move before that open */
|
|
if (!job->refused)
|
|
job->parked = content_load_parked_new(job);
|
|
#endif
|
|
job->stage = CONTENT_LOAD_STAGE_CORE;
|
|
break;
|
|
case CONTENT_LOAD_STAGE_CORE:
|
|
job->ok = content_load_stage_core(job);
|
|
#ifdef HAVE_CORE_LOAD_CHECK
|
|
/* Refused: this load ends as a failed one does, and runs again
|
|
* once the user answers the Security Warning. Whatever job->ok
|
|
* says: a menu load's init falls back to the dummy core itself
|
|
* and succeeds. */
|
|
content_load_park(job);
|
|
#endif
|
|
if (!job->ok)
|
|
{
|
|
if ( !job->fell_back
|
|
&& runloop_state_get_ptr()->current_core_type
|
|
!= CORE_TYPE_DUMMY)
|
|
{
|
|
/* The stage runs again, for the dummy core. */
|
|
content_load_job_fall_back(job);
|
|
break;
|
|
}
|
|
/* Not even the dummy core: no session to build drivers
|
|
* for, and the previous session's are freed as an
|
|
* unstaged failure leaves them. */
|
|
if (job->staged)
|
|
driver_uninit(DRIVERS_CMD_ALL, (enum driver_lifetime_flags)0);
|
|
#ifdef HAVE_WAYLAND
|
|
/* Nothing is coming for the window kept across the
|
|
* reinit: hand it back, and webOS returns to its
|
|
* dashboard rather than a window nothing draws into. */
|
|
gfx_ctx_wl_release_kept();
|
|
#endif
|
|
#if defined(_WIN32) && !defined(_XBOX) && !defined(__WINRT__)
|
|
/* nor for a Windows one */
|
|
win32_window_release_kept();
|
|
#endif
|
|
content_load_finish(job, p_content);
|
|
break;
|
|
}
|
|
job->stage = CONTENT_LOAD_STAGE_DRIVERS;
|
|
break;
|
|
case CONTENT_LOAD_STAGE_DRIVERS:
|
|
job->ok = content_load_stage_drivers(job);
|
|
content_load_finish(job, p_content);
|
|
break;
|
|
case CONTENT_LOAD_STAGE_NONE:
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* ---- the stages as tasks ----
|
|
*
|
|
* Staged, each stage is a task of the frontend's queue with
|
|
* RETRO_TASK_FLG_MAIN_THREAD: its handler runs on the main thread from
|
|
* task_queue_check(), once per check, and returns unfinished while the
|
|
* stage waits (the close, for a state task inside the core). Its
|
|
* callback pushes the next stage's task, so one stage runs per frame
|
|
* and the frame loop presents between them. The task's state is the
|
|
* stage it carries; the job is the file-scope one.
|
|
*
|
|
* Cancellation is not honoured: past the close there is no session
|
|
* to fall back to, so the stages run to their end regardless. */
|
|
|
|
static bool content_load_push_stage(struct content_load_job *job);
|
|
|
|
static void content_load_task_handler(retro_task_t *task)
|
|
{
|
|
struct content_load_job *job = (struct content_load_job*)task->user_data;
|
|
enum content_load_stage stage = (enum content_load_stage)(uintptr_t)task->state;
|
|
|
|
if (job->stage == stage)
|
|
content_load_step(job, content_state_get_ptr());
|
|
|
|
/* Moved on, or done: this stage's task is through. */
|
|
if (job->stage != stage)
|
|
task_set_flags(task, RETRO_TASK_FLG_FINISHED, true);
|
|
}
|
|
|
|
static void content_load_task_callback(retro_task_t *task,
|
|
void *task_data, void *user_data, const char *err)
|
|
{
|
|
struct content_load_job *job = (struct content_load_job*)user_data;
|
|
(void)task; (void)task_data; (void)err;
|
|
|
|
if (job->stage != CONTENT_LOAD_STAGE_NONE)
|
|
if (!content_load_push_stage(job))
|
|
{
|
|
/* No memory for the next stage: the session cannot be left
|
|
* half switched, so finish the stages here, in one go. */
|
|
while (job->stage != CONTENT_LOAD_STAGE_NONE)
|
|
content_load_step(job, content_state_get_ptr());
|
|
}
|
|
}
|
|
|
|
bool task_content_is_load_stage(const retro_task_t *task)
|
|
{
|
|
return task && task->handler == content_load_task_handler
|
|
&& (enum content_load_stage)(uintptr_t)task->state
|
|
!= CONTENT_LOAD_STAGE_CLOSE_WAIT
|
|
&& (enum content_load_stage)(uintptr_t)task->state
|
|
!= CONTENT_LOAD_STAGE_FIRMWARE;
|
|
}
|
|
|
|
static bool content_load_push_stage(struct content_load_job *job)
|
|
{
|
|
static const char *titles[] = {
|
|
NULL, "Closing content", "Closing content",
|
|
"Loading core", "Loading core", "Starting drivers" };
|
|
retro_task_t *task = task_init();
|
|
if (!task)
|
|
return false;
|
|
if ( (unsigned)job->stage < sizeof(titles) / sizeof(titles[0])
|
|
&& titles[job->stage])
|
|
task->title = strdup(titles[job->stage]);
|
|
task->handler = content_load_task_handler;
|
|
task->callback = content_load_task_callback;
|
|
task->user_data = job;
|
|
task->state = (void*)(uintptr_t)job->stage;
|
|
task->flags |= RETRO_TASK_FLG_MAIN_THREAD | RETRO_TASK_FLG_MUTE;
|
|
return task_queue_push(task);
|
|
}
|
|
|
|
/**
|
|
* content_load:
|
|
*
|
|
* Starts loading the content file and bringing the session up on
|
|
* it - or on the dummy core, if no content can be loaded.
|
|
*
|
|
* Staged, the stages are tasks (above) and the after-work runs when
|
|
* the last is through. Unstaged (startup), the whole load runs here.
|
|
*
|
|
* Returns: false (0) if the load could not be started - another is
|
|
* in flight, or no memory - otherwise true (1). Unstaged, false
|
|
* also reports a failed retroarch_main_init.
|
|
**/
|
|
static bool content_load(content_ctx_info_t *info,
|
|
content_state_t *p_content, unsigned after, bool staged)
|
|
{
|
|
struct content_load_job *job = &content_load_job;
|
|
struct rarch_main_wrap *wrap_args = NULL;
|
|
|
|
if (job->stage != CONTENT_LOAD_STAGE_NONE)
|
|
{
|
|
RARCH_LOG("[Content] A content load is already in flight.\n");
|
|
return false;
|
|
}
|
|
if (!(wrap_args = (struct rarch_main_wrap*)
|
|
malloc(sizeof(*wrap_args))))
|
|
return false;
|
|
|
|
wrap_args->argv = NULL;
|
|
wrap_args->content_path = NULL;
|
|
wrap_args->sram_path = NULL;
|
|
wrap_args->state_path = NULL;
|
|
wrap_args->config_path = NULL;
|
|
wrap_args->libretro_path = NULL;
|
|
wrap_args->flags = 0;
|
|
wrap_args->argc = 0;
|
|
|
|
memset(job, 0, sizeof(*job));
|
|
job->wrap_args = wrap_args;
|
|
job->info = *info;
|
|
job->argv_ptr = (char**)info->argv;
|
|
job->argc_ptr = (int*)&job->info.argc;
|
|
job->after = after;
|
|
job->staged = staged;
|
|
job->stage = CONTENT_LOAD_STAGE_DEINIT;
|
|
#ifdef HAVE_MENU
|
|
if (staged && config_get_ptr()->bools.core_firmware_notification_enable)
|
|
{
|
|
core_info_t *core = NULL;
|
|
if (core_info_find(path_get(RARCH_PATH_CORE), &core)
|
|
&& core && core->firmware_count)
|
|
job->stage = CONTENT_LOAD_STAGE_FIRMWARE;
|
|
}
|
|
#endif
|
|
|
|
if (staged)
|
|
{
|
|
if (!content_load_push_stage(job))
|
|
{
|
|
content_load_job_free(job);
|
|
return false;
|
|
}
|
|
#ifdef HAVE_MENU
|
|
/* The core title the menu holds while the load runs: the one
|
|
* this load is for, when its library is already open. */
|
|
{
|
|
char title[NAME_MAX_LENGTH + 64];
|
|
menu_entries_get_core_title(title, sizeof(title));
|
|
}
|
|
#endif
|
|
runloop_state_get_ptr()->content_switching = true;
|
|
return true;
|
|
}
|
|
|
|
#ifdef HAVE_CORE_LOAD_CHECK
|
|
core_load_check_set_startup(true);
|
|
#endif
|
|
while (job->stage != CONTENT_LOAD_STAGE_NONE)
|
|
content_load_step(job, p_content);
|
|
#ifdef HAVE_CORE_LOAD_CHECK
|
|
core_load_check_set_startup(false);
|
|
#endif
|
|
return content_load_job_result;
|
|
}
|
|
|
|
void menu_content_environment_get(int *argc, char *argv[],
|
|
void *args, void *params_data)
|
|
{
|
|
const char *a = NULL;
|
|
struct rarch_main_wrap *wrap_args = (struct rarch_main_wrap*)params_data;
|
|
runloop_state_t *runloop_st = runloop_state_get_ptr();
|
|
rarch_system_info_t *sys_info = &runloop_st->system;
|
|
|
|
if (!wrap_args)
|
|
return;
|
|
|
|
if (sys_info->load_no_content)
|
|
wrap_args->flags |= RARCH_MAIN_WRAP_FLAG_NO_CONTENT;
|
|
|
|
if (!retroarch_override_setting_is_set(
|
|
RARCH_OVERRIDE_SETTING_VERBOSITY, NULL))
|
|
{
|
|
if (verbosity_is_enabled())
|
|
wrap_args->flags |= RARCH_MAIN_WRAP_FLAG_VERBOSE;
|
|
}
|
|
|
|
wrap_args->flags |= RARCH_MAIN_WRAP_FLAG_TOUCHED;
|
|
wrap_args->config_path = NULL;
|
|
wrap_args->sram_path = NULL;
|
|
wrap_args->state_path = NULL;
|
|
wrap_args->content_path = NULL;
|
|
|
|
if (!path_is_empty(RARCH_PATH_CONFIG))
|
|
wrap_args->config_path = path_get(RARCH_PATH_CONFIG);
|
|
a = dir_get_ptr(RARCH_DIR_SAVEFILE);
|
|
if (a && *a)
|
|
wrap_args->sram_path = dir_get_ptr(RARCH_DIR_SAVEFILE);
|
|
a = dir_get_ptr(RARCH_DIR_SAVESTATE);
|
|
if (a && *a)
|
|
wrap_args->state_path = dir_get_ptr(RARCH_DIR_SAVESTATE);
|
|
if (!path_is_empty(RARCH_PATH_CONTENT))
|
|
wrap_args->content_path = path_get(RARCH_PATH_CONTENT);
|
|
if (!retroarch_override_setting_is_set(
|
|
RARCH_OVERRIDE_SETTING_LIBRETRO, NULL))
|
|
{
|
|
a = path_get(RARCH_PATH_CORE);
|
|
wrap_args->libretro_path = (a && *a) ? a : NULL;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* task_push_to_history_list:
|
|
*
|
|
* Will push the content entry to the history playlist.
|
|
**/
|
|
static void task_push_to_history_list(
|
|
content_state_t *p_content,
|
|
bool launched_from_menu,
|
|
bool launched_from_cli,
|
|
bool launched_from_companion_ui)
|
|
{
|
|
runloop_state_t *runloop_st = runloop_state_get_ptr();
|
|
uint8_t flags = content_get_flags();
|
|
|
|
/* Push entry to top of history playlist */
|
|
if ( (flags & CONTENT_ST_FLAG_IS_INITED)
|
|
|| (flags & CONTENT_ST_FLAG_CORE_DOES_NOT_NEED_CONTENT))
|
|
{
|
|
char tmp[PATH_MAX_LENGTH];
|
|
const char *path_content = path_get(RARCH_PATH_CONTENT);
|
|
struct retro_system_info *sysinfo = &runloop_st->system.info;
|
|
|
|
if (path_content && *path_content)
|
|
{
|
|
strlcpy(tmp, path_content, sizeof(tmp));
|
|
/* Path can be relative here.
|
|
* Ensure we're pushing absolute path. */
|
|
if (!launched_from_menu)
|
|
path_resolve_realpath(tmp, sizeof(tmp), true);
|
|
}
|
|
else
|
|
tmp[0] = '\0';
|
|
|
|
#ifdef HAVE_MENU
|
|
/* Push Quick Menu onto menu stack */
|
|
if (launched_from_cli)
|
|
menu_driver_ctl(RARCH_MENU_CTL_SET_PENDING_QUICK_MENU, NULL);
|
|
#endif
|
|
|
|
if (sysinfo && *tmp)
|
|
{
|
|
const char *core_path = NULL;
|
|
const char *core_name = NULL;
|
|
const char *label = NULL;
|
|
const char *crc32 = NULL;
|
|
const char *db_name = NULL;
|
|
playlist_t *playlist_hist = g_defaults.content_history;
|
|
settings_t *settings = config_get_ptr();
|
|
|
|
switch (path_is_media_type(tmp))
|
|
{
|
|
case RARCH_CONTENT_MOVIE:
|
|
#if defined(HAVE_FFMPEG) || defined(HAVE_MPV) || defined(HAVE_WEBMPLAYER)
|
|
playlist_hist = g_defaults.video_history;
|
|
core_name = "movieplayer";
|
|
core_path = "builtin";
|
|
#endif
|
|
break;
|
|
case RARCH_CONTENT_MUSIC:
|
|
playlist_hist = g_defaults.music_history;
|
|
core_name = "musicplayer";
|
|
core_path = "builtin";
|
|
break;
|
|
case RARCH_CONTENT_IMAGE:
|
|
#ifdef HAVE_IMAGEVIEWER
|
|
playlist_hist = g_defaults.image_history;
|
|
core_name = "imageviewer";
|
|
core_path = "builtin";
|
|
#endif
|
|
break;
|
|
default:
|
|
{
|
|
core_info_t *core_info = NULL;
|
|
/* Set core display name
|
|
* (As far as I can tell, core_info_get_current_core()
|
|
* should always provide a valid pointer here...) */
|
|
core_info_get_current_core(&core_info);
|
|
|
|
/* Set core path */
|
|
core_path = path_get(RARCH_PATH_CORE);
|
|
|
|
if (core_info)
|
|
core_name = core_info->display_name;
|
|
|
|
if (!core_name || !*core_name)
|
|
core_name = sysinfo->library_name;
|
|
|
|
if (launched_from_companion_ui)
|
|
{
|
|
/* Database name + checksum are supplied
|
|
* by the companion UI itself */
|
|
if (*p_content->companion_ui_crc32)
|
|
crc32 = p_content->companion_ui_crc32;
|
|
if (*p_content->companion_ui_db_name)
|
|
db_name = p_content->companion_ui_db_name;
|
|
}
|
|
#ifdef HAVE_MENU
|
|
else
|
|
{
|
|
menu_handle_t *menu = menu_state_get_ptr()->driver_data;
|
|
/* Set database name + checksum */
|
|
if (menu)
|
|
{
|
|
playlist_t *playlist_curr = playlist_get_cached();
|
|
|
|
if (playlist_index_is_valid(playlist_curr, menu->rpl_entry_selection_ptr, tmp, core_path))
|
|
{
|
|
playlist_get_crc32(playlist_curr, menu->rpl_entry_selection_ptr, &crc32);
|
|
playlist_get_db_name(playlist_curr, menu->rpl_entry_selection_ptr, &db_name);
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (*runloop_st->name.label)
|
|
label = runloop_st->name.label;
|
|
|
|
if (
|
|
settings
|
|
&& settings->bools.history_list_enable
|
|
&& playlist_hist)
|
|
{
|
|
char subsystem_name[PATH_MAX_LENGTH];
|
|
struct playlist_entry entry = {0};
|
|
|
|
subsystem_name[0] = '\0';
|
|
|
|
content_get_subsystem_friendly_name(path_get(RARCH_PATH_SUBSYSTEM), subsystem_name, sizeof(subsystem_name));
|
|
/* The push function reads our entry as const,
|
|
* so these casts are safe */
|
|
entry.path = (char*)tmp;
|
|
entry.label = (char*)label;
|
|
entry.core_path = (char*)core_path;
|
|
entry.core_name = (char*)core_name;
|
|
entry.crc32 = (char*)crc32;
|
|
entry.db_name = (char*)db_name;
|
|
entry.subsystem_ident = (char*)path_get(RARCH_PATH_SUBSYSTEM);
|
|
entry.subsystem_name = (char*)subsystem_name;
|
|
entry.subsystem_roms = (struct string_list*)path_get_subsystem_list();
|
|
PLAYLIST_SET_ENTRY_SLOT(&entry, runloop_st->entry_state_slot);
|
|
|
|
command_playlist_push_write(playlist_hist, &entry);
|
|
#if TARGET_OS_TV
|
|
update_topshelf();
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#ifndef HAVE_DYNAMIC
|
|
/**
|
|
* task_push_to_history_list_from_playlist_pre_load_static:
|
|
*
|
|
* Will push content from the currently selected playlist
|
|
* to the history playlist before loading content. Required
|
|
* on static platforms, where essential playlist information
|
|
* (label, db_name, etc.) would otherwise be lost when the
|
|
* core is forked.
|
|
**/
|
|
static bool task_push_to_history_list_from_playlist_pre_load_static(
|
|
const char *content_path,
|
|
const char *core)
|
|
{
|
|
const char *core_path = NULL;
|
|
const char *core_name = NULL;
|
|
const char *label = NULL;
|
|
const char *crc32 = NULL;
|
|
const char *db_name = NULL;
|
|
unsigned ss_entry_slot = 0;
|
|
playlist_t *playlist_hist = g_defaults.content_history;
|
|
settings_t *settings = config_get_ptr();
|
|
#ifdef HAVE_MENU
|
|
menu_handle_t *menu = menu_state_get_ptr()->driver_data;
|
|
#endif
|
|
|
|
if ( !settings
|
|
|| !settings->bools.history_list_enable
|
|
|| (!content_path || !*content_path))
|
|
return false;
|
|
|
|
switch (path_is_media_type(content_path))
|
|
{
|
|
case RARCH_CONTENT_MOVIE:
|
|
#if defined(HAVE_FFMPEG) || defined(HAVE_MPV) || defined(HAVE_WEBMPLAYER)
|
|
playlist_hist = g_defaults.video_history;
|
|
core_name = "movieplayer";
|
|
core_path = "builtin";
|
|
#endif
|
|
break;
|
|
case RARCH_CONTENT_MUSIC:
|
|
playlist_hist = g_defaults.music_history;
|
|
core_name = "musicplayer";
|
|
core_path = "builtin";
|
|
break;
|
|
case RARCH_CONTENT_IMAGE:
|
|
#ifdef HAVE_IMAGEVIEWER
|
|
playlist_hist = g_defaults.image_history;
|
|
core_name = "imageviewer";
|
|
core_path = "builtin";
|
|
#endif
|
|
break;
|
|
default:
|
|
{
|
|
core_info_t *core_info = NULL;
|
|
|
|
if ( (core && *core)
|
|
&& core_info_find(core, &core_info))
|
|
{
|
|
/* Set core path and core display name */
|
|
core_path = core_info->path;
|
|
core_name = core_info->display_name;
|
|
|
|
#ifdef HAVE_MENU
|
|
/* Read remaining information from currently selected
|
|
* playlist entry (label, database name, checksum,
|
|
* save state slot) */
|
|
if (menu)
|
|
{
|
|
playlist_t *playlist_curr = playlist_get_cached();
|
|
|
|
if (playlist_index_is_valid(playlist_curr,
|
|
menu->rpl_entry_selection_ptr,
|
|
content_path, core_path))
|
|
{
|
|
const struct playlist_entry *pl_entry = NULL;
|
|
|
|
playlist_get_index(playlist_curr,
|
|
menu->rpl_entry_selection_ptr,
|
|
&pl_entry);
|
|
|
|
if (pl_entry)
|
|
{
|
|
label = pl_entry->label;
|
|
crc32 = pl_entry->crc32;
|
|
ss_entry_slot = PLAYLIST_ENTRY_SLOT(pl_entry);
|
|
}
|
|
|
|
playlist_get_db_name(playlist_curr,
|
|
menu->rpl_entry_selection_ptr,
|
|
&db_name);
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
if ( (core_path && *core_path)
|
|
&& playlist_hist)
|
|
{
|
|
struct playlist_entry new_entry = {0};
|
|
|
|
/* The push function reads our entry as const,
|
|
* so these casts are safe */
|
|
new_entry.path = (char*)content_path;
|
|
new_entry.label = (char*)label;
|
|
new_entry.core_path = (char*)core_path;
|
|
new_entry.core_name = (char*)core_name;
|
|
new_entry.crc32 = (char*)crc32;
|
|
new_entry.db_name = (char*)db_name;
|
|
PLAYLIST_SET_ENTRY_SLOT(&new_entry, ss_entry_slot);
|
|
|
|
/* TODO/FIXME: Subsystems are not properly supported
|
|
* on static platforms, so exclude the following:
|
|
* - subsystem_ident
|
|
* - subsystem_name
|
|
* - subsystem_roms */
|
|
|
|
command_playlist_push_write(playlist_hist, &new_entry);
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
#endif
|
|
|
|
#ifdef HAVE_MENU
|
|
static bool command_event_cmd_exec(
|
|
content_state_t *p_content,
|
|
const char *data,
|
|
content_information_ctx_t *content_ctx,
|
|
bool launched_from_cli,
|
|
unsigned after
|
|
)
|
|
{
|
|
if (path_get(RARCH_PATH_CONTENT) != data)
|
|
{
|
|
path_clear(RARCH_PATH_CONTENT);
|
|
if (data && *data)
|
|
path_set(RARCH_PATH_CONTENT, data);
|
|
}
|
|
|
|
#if defined(HAVE_DYNAMIC)
|
|
{
|
|
content_ctx_info_t content_info;
|
|
|
|
content_info.argc = 0;
|
|
content_info.argv = NULL;
|
|
content_info.args = NULL;
|
|
content_info.environ_get = menu_content_environment_get;
|
|
|
|
/* Loads content into currently selected core. */
|
|
if (!content_load(&content_info, p_content,
|
|
CONTENT_LOAD_AFTER_HISTORY
|
|
| CONTENT_LOAD_AFTER_HISTORY_MENU
|
|
| (launched_from_cli ? CONTENT_LOAD_AFTER_HISTORY_CLI : 0)
|
|
| after,
|
|
true))
|
|
return false;
|
|
}
|
|
#else
|
|
/* Static build: the only way to run a different core is to
|
|
* fork/exec its executable. On platforms without fork support
|
|
* (GameCube, ...) report failure so the caller keeps the menu
|
|
* alive instead of shutting down as if a new instance had been
|
|
* started; the old behaviour was a silent exit/reboot. */
|
|
if (!frontend_driver_set_fork(FRONTEND_FORK_CORE_WITH_ARGS))
|
|
{
|
|
const char *_msg = msg_hash_to_str(MSG_FAILED_TO_LOAD_CONTENT);
|
|
RARCH_ERR("[Content] Core \"%s\" is not the running core and "
|
|
"this platform cannot switch cores at runtime.\n",
|
|
path_get(RARCH_PATH_CORE));
|
|
runloop_msg_queue_push(_msg, strlen(_msg), 1, 180, true, NULL,
|
|
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_ERROR);
|
|
return false;
|
|
}
|
|
#endif
|
|
|
|
return true;
|
|
}
|
|
#endif
|
|
|
|
bool task_push_start_dummy_core(content_ctx_info_t *content_info)
|
|
{
|
|
content_information_ctx_t content_ctx;
|
|
content_state_t *p_content = content_state_get_ptr();
|
|
bool ret = true;
|
|
settings_t *settings = config_get_ptr();
|
|
runloop_state_t *runloop_st = runloop_state_get_ptr();
|
|
rarch_system_info_t *sys_info = &runloop_st->system;
|
|
|
|
if (!content_info)
|
|
return false;
|
|
|
|
content_information_ctx_init(&content_ctx, settings, runloop_st, false);
|
|
|
|
if (!content_info->environ_get)
|
|
content_info->environ_get = menu_content_environment_get;
|
|
|
|
/* Clear content path */
|
|
path_clear(RARCH_PATH_CONTENT);
|
|
|
|
/* Preliminary stuff that has to be done before we
|
|
* load the actual content. Can differ per mode. */
|
|
sys_info->load_no_content = false;
|
|
retroarch_ctl(RARCH_CTL_STATE_FREE, NULL);
|
|
|
|
/* Loads content into currently selected core. */
|
|
ret = content_load(content_info, p_content,
|
|
CONTENT_LOAD_AFTER_HISTORY, true);
|
|
|
|
content_information_ctx_free(&content_ctx);
|
|
|
|
return ret;
|
|
}
|
|
|
|
#ifdef HAVE_MENU
|
|
bool task_push_load_content_from_playlist_from_menu(
|
|
const char *core_path,
|
|
const char *fullpath,
|
|
const char *label,
|
|
content_ctx_info_t *content_info,
|
|
retro_task_callback_t cb,
|
|
void *user_data)
|
|
{
|
|
content_information_ctx_t content_ctx;
|
|
content_state_t *p_content = content_state_get_ptr();
|
|
bool ret = true;
|
|
settings_t *settings = config_get_ptr();
|
|
runloop_state_t *runloop_st = runloop_state_get_ptr();
|
|
rarch_system_info_t *sys_info = &runloop_st->system;
|
|
#ifndef HAVE_DYNAMIC
|
|
bool force_core_reload = settings->bools.always_reload_core_on_run_content;
|
|
#endif
|
|
|
|
content_information_ctx_init(&content_ctx, settings, runloop_st, false);
|
|
|
|
if (label)
|
|
strlcpy(runloop_st->name.label, label, sizeof(runloop_st->name.label));
|
|
else
|
|
runloop_st->name.label[0] = '\0';
|
|
|
|
/* Is content required by this core? */
|
|
sys_info->load_no_content = fullpath ? false : true;
|
|
|
|
#ifndef HAVE_DYNAMIC
|
|
/* Check whether specified core is already loaded
|
|
* > If so, content can be launched directly with
|
|
* the currently loaded core */
|
|
if ((!force_core_reload || !frontend_driver_has_fork()) &&
|
|
retroarch_ctl(RARCH_CTL_IS_CORE_LOADED, (void*)core_path))
|
|
{
|
|
if (!content_info->environ_get)
|
|
content_info->environ_get = menu_content_environment_get;
|
|
|
|
/* Register content path */
|
|
path_clear(RARCH_PATH_CONTENT);
|
|
if (fullpath && *fullpath)
|
|
path_set(RARCH_PATH_CONTENT, fullpath);
|
|
|
|
/* Load content and update content history */
|
|
ret = content_load(content_info, p_content,
|
|
CONTENT_LOAD_AFTER_HISTORY
|
|
| CONTENT_LOAD_AFTER_HISTORY_MENU
|
|
| CONTENT_LOAD_AFTER_MENU_ON_FAIL, true);
|
|
|
|
goto end;
|
|
}
|
|
#endif
|
|
|
|
/* Specified core is not loaded
|
|
* > Load it
|
|
* > Forget manually loaded core */
|
|
path_set(RARCH_PATH_CORE, core_path);
|
|
path_clear(RARCH_PATH_CORE_LAST);
|
|
|
|
#ifdef HAVE_DYNAMIC
|
|
command_event(CMD_EVENT_LOAD_CORE, NULL);
|
|
#else
|
|
/* On targets that do not support dynamic core loading,
|
|
* must push content to the history list before calling
|
|
* command_event_cmd_exec() or playlist metadata will
|
|
* be lost */
|
|
task_push_to_history_list_from_playlist_pre_load_static(
|
|
fullpath, core_path);
|
|
#endif
|
|
|
|
/* Load content
|
|
* > On targets that do not support dynamic core loading,
|
|
* command_event_cmd_exec() will fork a new instance */
|
|
if ((ret = command_event_cmd_exec(p_content,
|
|
fullpath, &content_ctx, false,
|
|
CONTENT_LOAD_AFTER_MENU_ON_FAIL)))
|
|
{
|
|
#ifndef HAVE_DYNAMIC
|
|
/* No dynamic core loading support: if we reach
|
|
* this point then a new instance has been
|
|
* forked - have to shut down this one */
|
|
retroarch_ctl(RARCH_CTL_SET_SHUTDOWN, NULL);
|
|
retroarch_menu_running_finished(true);
|
|
#endif
|
|
}
|
|
|
|
#ifndef HAVE_DYNAMIC
|
|
end:
|
|
#endif
|
|
/* Handle load content failure */
|
|
if (!ret)
|
|
retroarch_menu_running();
|
|
|
|
content_information_ctx_free(&content_ctx);
|
|
|
|
return ret;
|
|
}
|
|
#endif
|
|
|
|
bool task_push_start_current_core(content_ctx_info_t *content_info)
|
|
{
|
|
content_information_ctx_t content_ctx;
|
|
bool ret = true;
|
|
content_state_t *p_content = content_state_get_ptr();
|
|
settings_t *settings = config_get_ptr();
|
|
runloop_state_t *runloop_st = runloop_state_get_ptr();
|
|
|
|
if (!content_info)
|
|
return false;
|
|
|
|
content_information_ctx_init(&content_ctx, settings, runloop_st, false);
|
|
|
|
if (!content_info->environ_get)
|
|
content_info->environ_get = menu_content_environment_get;
|
|
|
|
/* Clear content path */
|
|
path_clear(RARCH_PATH_CONTENT);
|
|
|
|
/* Preliminary stuff that has to be done before we
|
|
* load the actual content. Can differ per mode. */
|
|
runloop_set_current_core_type(CORE_TYPE_PLAIN, true);
|
|
|
|
/* Loads content into currently selected core. A load that falls
|
|
* back to the dummy core did not start this one: the menu comes
|
|
* back instead of the history entry and the Quick Menu. */
|
|
if (!(ret = content_load(content_info, p_content,
|
|
CONTENT_LOAD_AFTER_HISTORY
|
|
| CONTENT_LOAD_AFTER_HISTORY_MENU
|
|
| CONTENT_LOAD_AFTER_QUICK_MENU
|
|
| CONTENT_LOAD_AFTER_MENU_ON_FAIL
|
|
| CONTENT_LOAD_AFTER_DUMMY_IS_FAIL, true)))
|
|
{
|
|
#ifdef HAVE_MENU
|
|
retroarch_menu_running();
|
|
#endif
|
|
}
|
|
|
|
content_information_ctx_free(&content_ctx);
|
|
|
|
return ret;
|
|
}
|
|
|
|
bool task_push_load_new_core(
|
|
const char *core_path,
|
|
const char *fullpath,
|
|
content_ctx_info_t *content_info,
|
|
enum rarch_core_type type,
|
|
retro_task_callback_t cb,
|
|
void *user_data)
|
|
{
|
|
bool ret;
|
|
|
|
/* Set core path */
|
|
path_set(RARCH_PATH_CORE, core_path);
|
|
|
|
/* Remember core path for reloading */
|
|
if (!string_is_equal(core_path, path_get(RARCH_PATH_CORE_LAST)))
|
|
path_set(RARCH_PATH_CORE_LAST, core_path);
|
|
|
|
/* Load core */
|
|
ret = command_event(CMD_EVENT_LOAD_CORE, NULL);
|
|
|
|
#ifndef HAVE_DYNAMIC
|
|
/* Fork core? */
|
|
if (!frontend_driver_set_fork(FRONTEND_FORK_CORE))
|
|
return false;
|
|
#endif
|
|
|
|
/* Preliminary stuff that has to be done before we
|
|
* load the actual content. Can differ per mode. */
|
|
runloop_set_current_core_type(type, true);
|
|
|
|
return ret;
|
|
}
|
|
|
|
#ifdef HAVE_MENU
|
|
bool task_push_load_contentless_core_from_menu(
|
|
const char *core_path)
|
|
{
|
|
#if defined(HAVE_DYNAMIC)
|
|
content_ctx_info_t content_info = {0};
|
|
#endif
|
|
content_information_ctx_t content_ctx;
|
|
content_state_t *p_content = content_state_get_ptr();
|
|
bool ret = true;
|
|
runloop_state_t *runloop_st = runloop_state_get_ptr();
|
|
settings_t *settings = config_get_ptr();
|
|
bool flush_menu = true;
|
|
const char *menu_label = NULL;
|
|
|
|
if (!core_path || !*core_path)
|
|
return false;
|
|
|
|
content_information_ctx_init(&content_ctx, settings, runloop_st, false);
|
|
|
|
/* Set core path */
|
|
path_set(RARCH_PATH_CORE, core_path);
|
|
|
|
/* Clear content path */
|
|
path_clear(RARCH_PATH_CONTENT);
|
|
|
|
#if defined(HAVE_DYNAMIC)
|
|
content_info.environ_get = menu_content_environment_get;
|
|
|
|
/* Load core */
|
|
command_event(CMD_EVENT_LOAD_CORE, NULL);
|
|
runloop_set_current_core_type(CORE_TYPE_PLAIN, true);
|
|
|
|
menu_entries_get_last_stack(NULL, &menu_label, NULL, NULL, NULL);
|
|
|
|
if ( string_is_equal(menu_label, MENU_ENUM_LABEL_CONTENTLESS_CORES_TAB_STR)
|
|
|| string_is_equal(menu_label, MENU_ENUM_LABEL_DEFERRED_CONTENTLESS_CORES_LIST_STR))
|
|
flush_menu = false;
|
|
|
|
/* Loads content into currently selected core. A load that falls
|
|
* back to the dummy core did not start this one: the menu comes
|
|
* back instead of the Quick Menu. */
|
|
if (!(ret = content_load(&content_info, p_content,
|
|
CONTENT_LOAD_AFTER_QUICK_MENU
|
|
| (flush_menu ? 0 : CONTENT_LOAD_AFTER_QUICK_MENU_KEEP)
|
|
| CONTENT_LOAD_AFTER_MENU_ON_FAIL
|
|
| CONTENT_LOAD_AFTER_DUMMY_IS_FAIL, true)))
|
|
retroarch_menu_running();
|
|
#else
|
|
/* TODO/FIXME: Static builds do not support running
|
|
* a core directly from the 'command line' without
|
|
* supplying a content path, so this *will not work*.
|
|
* In order to support this functionality, the '-L'
|
|
* command line argument must be enabled for static
|
|
* builds to inform the frontend that the core should
|
|
* run automatically on launch. We will leave this
|
|
* non-functional code here as a place-marker for
|
|
* future devs who may wish to implement this... */
|
|
if (!(ret = command_event_cmd_exec(p_content,
|
|
path_get(RARCH_PATH_CONTENT), &content_ctx,
|
|
false, 0)))
|
|
{
|
|
retroarch_menu_running();
|
|
goto end;
|
|
}
|
|
command_event(CMD_EVENT_QUIT, NULL);
|
|
|
|
menu_entries_get_last_stack(NULL, &menu_label, NULL, NULL, NULL);
|
|
|
|
if ( string_is_equal(menu_label, MENU_ENUM_LABEL_CONTENTLESS_CORES_TAB_STR)
|
|
|| string_is_equal(menu_label, MENU_ENUM_LABEL_DEFERRED_CONTENTLESS_CORES_LIST_STR))
|
|
flush_menu = false;
|
|
|
|
/* Push Quick Menu onto menu stack */
|
|
menu_driver_ctl(RARCH_MENU_CTL_SET_PENDING_QUICK_MENU, &flush_menu);
|
|
|
|
end:
|
|
#endif
|
|
content_information_ctx_free(&content_ctx);
|
|
|
|
return ret;
|
|
}
|
|
|
|
#if defined(HAVE_DYNAMIC) && defined(HAVE_MENU)
|
|
/* ---- deferred menu load: prefetch, then the identical remainder ---- */
|
|
|
|
struct content_deferred_menu_load
|
|
{
|
|
char *fullpath;
|
|
char *core_path; /* the world this belongs to */
|
|
enum rarch_core_type type;
|
|
content_ctx_info_t info; /* argv-free by the deferral gate */
|
|
bool showed_animation; /* launch card already on screen */
|
|
};
|
|
|
|
static void task_content_deferred_menu_load_done(void *ud, bool all_ok);
|
|
|
|
/* Drop whatever the load did not consume. */
|
|
static void content_file_prefetch_free(content_state_t *p_content)
|
|
{
|
|
size_t i;
|
|
for (i = 0; i < p_content->prefetch_count; i++)
|
|
{
|
|
free(p_content->prefetch[i].path);
|
|
free(p_content->prefetch[i].data);
|
|
p_content->prefetch[i].path = NULL;
|
|
p_content->prefetch[i].data = NULL;
|
|
p_content->prefetch[i].size = 0;
|
|
}
|
|
p_content->prefetch_count = 0;
|
|
}
|
|
|
|
|
|
/* Fires when the prefetch task completes - on the main thread, from
|
|
* the queue's retire - and starts the remainder of
|
|
* task_push_load_content_with_new_core_from_menu: the load, then
|
|
* history and the Quick Menu once it is through. A prefetch that
|
|
* skipped files changed nothing; the load's ordinary reads cover
|
|
* whatever is not in the cache. */
|
|
static void task_content_deferred_menu_load_done(void *ud, bool all_ok)
|
|
{
|
|
struct content_deferred_menu_load *d = (struct content_deferred_menu_load*)ud;
|
|
content_state_t *p_content = content_state_get_ptr();
|
|
(void)all_ok;
|
|
|
|
p_content->flags &= ~CONTENT_ST_FLAG_DEFERRED_LOAD_PENDING;
|
|
|
|
/* A competing load may have replaced the world this continuation
|
|
* was parked for; the stamps say which one it belongs to. On a
|
|
* mismatch, stand down: drop the cache and the continuation, and
|
|
* leave the current content alone. */
|
|
if ( !string_is_equal(path_get(RARCH_PATH_CONTENT), d->fullpath)
|
|
|| !string_is_equal(path_get(RARCH_PATH_CORE), d->core_path))
|
|
{
|
|
RARCH_LOG("[Content] Dropping a deferred load superseded by "
|
|
"another: \"%s\".\n", d->fullpath);
|
|
content_file_prefetch_free(p_content);
|
|
free(d->core_path);
|
|
free(d->fullpath);
|
|
free(d);
|
|
return;
|
|
}
|
|
|
|
#if defined(HAVE_GFX_WIDGETS)
|
|
content_load_animation_showing = d->showed_animation;
|
|
#endif
|
|
if (!content_load(&d->info, p_content,
|
|
CONTENT_LOAD_AFTER_HISTORY
|
|
| CONTENT_LOAD_AFTER_HISTORY_MENU
|
|
| (d->type != CORE_TYPE_DUMMY ? CONTENT_LOAD_AFTER_QUICK_MENU : 0)
|
|
| CONTENT_LOAD_AFTER_MENU_ON_FAIL, true))
|
|
{
|
|
content_file_prefetch_free(p_content);
|
|
retroarch_menu_running();
|
|
}
|
|
free(d->core_path);
|
|
free(d->fullpath);
|
|
free(d);
|
|
}
|
|
|
|
#if defined(HAVE_GFX_WIDGETS)
|
|
/* Feeds the read percentage to the "Load Content" startup
|
|
* notification. Delivered on the thread that pumps the queue -
|
|
* the thread that drives the frame and owns widget state. */
|
|
static void content_file_prefetch_progress(void *ud, int8_t progress)
|
|
{
|
|
gfx_widget_set_load_content_progress(progress);
|
|
}
|
|
#endif
|
|
|
|
/* Deposit callback for task_push_content_prefetch. ud carries the
|
|
* deferred-load continuation for the done callback, not the content
|
|
* state - the state is a singleton and is fetched here, never cast
|
|
* from ud. */
|
|
static void content_file_prefetch_deposit(void *ud, const char *path,
|
|
uint8_t *data, size_t size)
|
|
{
|
|
content_state_t *p_content = content_state_get_ptr();
|
|
if (p_content->prefetch_count
|
|
>= ARRAY_SIZE(p_content->prefetch))
|
|
{
|
|
free(data);
|
|
return;
|
|
}
|
|
if (!(p_content->prefetch[p_content->prefetch_count].path
|
|
= strdup(path)))
|
|
{
|
|
free(data);
|
|
return;
|
|
}
|
|
p_content->prefetch[p_content->prefetch_count].data = data;
|
|
p_content->prefetch[p_content->prefetch_count].size = size;
|
|
p_content->prefetch_count++;
|
|
}
|
|
|
|
|
|
/* Returns true when the load was taken over by the deferred path. */
|
|
static bool task_content_defer_menu_load(content_state_t *p_content,
|
|
runloop_state_t *runloop_st,
|
|
const char *fullpath, enum rarch_core_type type,
|
|
content_ctx_info_t *content_info)
|
|
{
|
|
struct content_deferred_menu_load *d = NULL;
|
|
const char *paths[1];
|
|
|
|
if (type != CORE_TYPE_PLAIN)
|
|
return false;
|
|
if (!fullpath || !*fullpath)
|
|
return false; /* contentless: nothing to read */
|
|
if (content_info->argc || content_info->argv || content_info->args)
|
|
return false; /* only the plain menu shape */
|
|
if (p_content->flags & CONTENT_ST_FLAG_DEFERRED_LOAD_PENDING)
|
|
return false; /* one deferral at a time */
|
|
/* The cache's only consumer is content_file_load_into_memory(),
|
|
* reached only for a file the load reads into memory. A
|
|
* need_fullpath core is handed the path instead, so a prefetch
|
|
* would fill an allocation nothing takes. Mirror the load's own
|
|
* BLCK_NEED_FULLPATH decision for the core being loaded: its
|
|
* need_fullpath and its own per-extension overrides, as it
|
|
* declared them when LOAD_CORE asked it. The override list held
|
|
* here is still the running core's. (The caller's content_ctx is
|
|
* built before LOAD_CORE and without sys info; it cannot answer
|
|
* this.) */
|
|
{
|
|
bool need_fullpath = runloop_st->system.info.need_fullpath;
|
|
if (!runloop_core_probe_need_fullpath(path_get(RARCH_PATH_CORE),
|
|
path_get_extension(fullpath), &need_fullpath))
|
|
return false; /* its overrides are not known */
|
|
if (need_fullpath)
|
|
return false; /* the load hands the core a path */
|
|
}
|
|
/* The prefetch keys on this exact path, but the load rewrites
|
|
* some paths before reading them: a content:// SAF URI becomes a
|
|
* VFS path, and a bare archive ("foo.zip") becomes an explicit
|
|
* entry ("foo.zip#first"). Deferring either would prefetch under
|
|
* a key the load never looks up - a silent miss and a wasted
|
|
* read. Decline them; they take the synchronous path, exactly as
|
|
* before this feature existed. A path already carrying its entry
|
|
* ("foo.zip#rom") is stable and may defer. */
|
|
if (!strncmp(fullpath, "content://", STRLEN_CONST("content://")))
|
|
return false;
|
|
if ( path_is_compressed_file(fullpath)
|
|
&& !path_contains_compressed_file(fullpath))
|
|
return false; /* bare archive: load picks entry */
|
|
|
|
if (!(d = (struct content_deferred_menu_load*)calloc(1, sizeof(*d))))
|
|
return false;
|
|
if (!(d->fullpath = strdup(fullpath)))
|
|
{
|
|
free(d);
|
|
return false;
|
|
}
|
|
/* Stamp the world this continuation belongs to: a competing load
|
|
* leaves the prefetch in flight, so the continuation can fire
|
|
* after the user has loaded something else. */
|
|
if (!(d->core_path = strdup(path_get(RARCH_PATH_CORE))))
|
|
{
|
|
free(d->fullpath);
|
|
free(d);
|
|
return false;
|
|
}
|
|
d->type = type;
|
|
d->info = *content_info; /* argv-free: shallow is whole */
|
|
|
|
paths[0] = d->fullpath;
|
|
|
|
#if defined(HAVE_GFX_WIDGETS)
|
|
/* Start the launch notification here rather than after the load,
|
|
* so it can carry the read percentage while the content streams
|
|
* in. Gated on the same setting as before: with the notification
|
|
* off, nothing is shown and no progress is reported.
|
|
*
|
|
* Widgets persist across the driver reinit the load performs
|
|
* (dispgfx_widget_t.persisting), so the card started here
|
|
* survives into the loaded core. */
|
|
{
|
|
settings_t *settings = config_get_ptr();
|
|
if ( settings
|
|
&& settings->bools.menu_show_load_content_animation
|
|
&& gfx_widgets_ready())
|
|
{
|
|
gfx_widget_set_load_content_progress(-1);
|
|
if (gfx_widget_start_load_content_animation())
|
|
d->showed_animation = true;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
if (!task_push_content_prefetch_progress(paths, 1,
|
|
content_file_prefetch_deposit,
|
|
task_content_deferred_menu_load_done,
|
|
#if defined(HAVE_GFX_WIDGETS)
|
|
d->showed_animation ? content_file_prefetch_progress : NULL,
|
|
#else
|
|
NULL,
|
|
#endif
|
|
d))
|
|
{
|
|
free(d->core_path);
|
|
free(d->fullpath);
|
|
free(d);
|
|
return false;
|
|
}
|
|
p_content->flags |= CONTENT_ST_FLAG_DEFERRED_LOAD_PENDING;
|
|
return true;
|
|
}
|
|
#endif
|
|
|
|
bool task_push_load_content_with_new_core_from_menu(
|
|
const char *core_path,
|
|
const char *fullpath,
|
|
content_ctx_info_t *content_info,
|
|
enum rarch_core_type type,
|
|
retro_task_callback_t cb,
|
|
void *user_data)
|
|
{
|
|
content_information_ctx_t content_ctx;
|
|
content_state_t *p_content = content_state_get_ptr();
|
|
bool ret = true;
|
|
settings_t *settings = config_get_ptr();
|
|
runloop_state_t *runloop_st = runloop_state_get_ptr();
|
|
#ifndef HAVE_DYNAMIC
|
|
bool force_core_reload = settings->bools.always_reload_core_on_run_content;
|
|
/* Check whether specified core is already loaded
|
|
* > If so, we can skip loading the core and
|
|
* just load the content directly */
|
|
/* Forced reload needs fork support; without it the running
|
|
* core is all there is, so load in-process when it matches. */
|
|
if ( (!force_core_reload || !frontend_driver_has_fork())
|
|
&& (type == CORE_TYPE_PLAIN)
|
|
&& retroarch_ctl(RARCH_CTL_IS_CORE_LOADED, (void*)core_path))
|
|
return task_push_load_content_with_core(fullpath, content_info,
|
|
type, cb, user_data);
|
|
#endif
|
|
|
|
content_information_ctx_init(&content_ctx, settings, runloop_st, false);
|
|
|
|
runloop_st->name.label[0] = '\0';
|
|
|
|
path_set(RARCH_PATH_CONTENT, fullpath);
|
|
path_set(RARCH_PATH_CORE, core_path);
|
|
|
|
#ifdef HAVE_DYNAMIC
|
|
/* Load core */
|
|
command_event(CMD_EVENT_LOAD_CORE, NULL);
|
|
|
|
/* Load content */
|
|
if (!content_info->environ_get)
|
|
content_info->environ_get = menu_content_environment_get;
|
|
|
|
/* Stream the content's bytes in ahead of the load, a budgeted
|
|
* slice per task tick, so the menu keeps running instead of
|
|
* freezing for one long read. The deferral is taken only in the
|
|
* exact shape this menu path produces (no argv, plain core type,
|
|
* no deferral already in flight); anything else starts the load
|
|
* right away, and if the prefetch cannot even be pushed, so does
|
|
* everything. The continuation starts the identical job. */
|
|
if (task_content_defer_menu_load(p_content, runloop_st,
|
|
fullpath, type, content_info))
|
|
{
|
|
content_information_ctx_free(&content_ctx);
|
|
return true;
|
|
}
|
|
|
|
/* Loads content into currently selected core. */
|
|
if (!(ret = content_load(content_info, p_content,
|
|
CONTENT_LOAD_AFTER_HISTORY
|
|
| CONTENT_LOAD_AFTER_HISTORY_MENU
|
|
| (type != CORE_TYPE_DUMMY ? CONTENT_LOAD_AFTER_QUICK_MENU : 0)
|
|
| CONTENT_LOAD_AFTER_MENU_ON_FAIL, true)))
|
|
retroarch_menu_running();
|
|
#else
|
|
if (!(ret = command_event_cmd_exec(p_content,
|
|
path_get(RARCH_PATH_CONTENT), &content_ctx,
|
|
false, 0)))
|
|
{
|
|
retroarch_menu_running();
|
|
goto end;
|
|
}
|
|
command_event(CMD_EVENT_QUIT, NULL);
|
|
|
|
/* Push Quick Menu onto menu stack */
|
|
if (type != CORE_TYPE_DUMMY)
|
|
menu_driver_ctl(RARCH_MENU_CTL_SET_PENDING_QUICK_MENU, NULL);
|
|
|
|
end:
|
|
#endif
|
|
content_information_ctx_free(&content_ctx);
|
|
|
|
return ret;
|
|
}
|
|
#endif
|
|
|
|
static bool task_load_content_internal(
|
|
content_ctx_info_t *content_info,
|
|
bool loading_from_menu,
|
|
bool loading_from_cli,
|
|
bool loading_from_companion_ui,
|
|
unsigned after)
|
|
{
|
|
content_information_ctx_t content_ctx;
|
|
content_state_t *p_content = content_state_get_ptr();
|
|
bool ret = false;
|
|
runloop_state_t *runloop_st = runloop_state_get_ptr();
|
|
settings_t *settings = config_get_ptr();
|
|
|
|
content_information_ctx_init(&content_ctx, settings, runloop_st, true);
|
|
|
|
if (!content_info->environ_get)
|
|
content_info->environ_get = menu_content_environment_get;
|
|
|
|
#ifdef HAVE_PRESENCE
|
|
{
|
|
presence_userdata_t userdata;
|
|
userdata.status = PRESENCE_NETPLAY_NETPLAY_STOPPED;
|
|
command_event(CMD_EVENT_PRESENCE_UPDATE, &userdata);
|
|
userdata.status = PRESENCE_MENU;
|
|
command_event(CMD_EVENT_PRESENCE_UPDATE, &userdata);
|
|
}
|
|
#endif
|
|
|
|
/* Loads content into currently selected core. From the command
|
|
* line this is startup itself: no frame loop runs yet to advance
|
|
* a staged load, so it runs in one go. */
|
|
ret = content_load(content_info, p_content,
|
|
CONTENT_LOAD_AFTER_HISTORY
|
|
| CONTENT_LOAD_AFTER_HISTORY_MENU
|
|
| (loading_from_cli ? CONTENT_LOAD_AFTER_HISTORY_CLI : 0)
|
|
| (loading_from_companion_ui ? CONTENT_LOAD_AFTER_HISTORY_UI : 0)
|
|
| after,
|
|
!loading_from_cli);
|
|
|
|
content_information_ctx_free(&content_ctx);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static bool task_load_content_internal_wrap(
|
|
content_ctx_info_t *content_info,
|
|
enum rarch_core_type type,
|
|
bool load_from_companion_ui)
|
|
{
|
|
/* Load content; the Quick Menu once it is through. */
|
|
if (task_load_content_internal(content_info, true, false,
|
|
load_from_companion_ui,
|
|
(type != CORE_TYPE_DUMMY ? CONTENT_LOAD_AFTER_QUICK_MENU : 0)
|
|
| CONTENT_LOAD_AFTER_MENU_ON_FAIL))
|
|
return true;
|
|
|
|
#ifdef HAVE_MENU
|
|
retroarch_menu_running();
|
|
#endif
|
|
return false;
|
|
}
|
|
|
|
bool task_push_load_content_with_new_core_from_companion_ui(
|
|
const char *core_path,
|
|
const char *fullpath,
|
|
const char *label,
|
|
const char *db_name,
|
|
const char *crc32,
|
|
content_ctx_info_t *content_info,
|
|
retro_task_callback_t cb,
|
|
void *user_data)
|
|
{
|
|
runloop_state_t *runloop_st = runloop_state_get_ptr();
|
|
content_state_t *p_content = content_state_get_ptr();
|
|
|
|
p_content->companion_ui_db_name[0] = '\0';
|
|
p_content->companion_ui_crc32[0] = '\0';
|
|
|
|
path_set(RARCH_PATH_CONTENT, fullpath);
|
|
path_set(RARCH_PATH_CORE, core_path);
|
|
|
|
if (db_name && *db_name)
|
|
strlcpy(p_content->companion_ui_db_name,
|
|
db_name, sizeof(p_content->companion_ui_db_name));
|
|
|
|
if (crc32 && *crc32)
|
|
strlcpy(p_content->companion_ui_crc32,
|
|
crc32, sizeof(p_content->companion_ui_crc32));
|
|
|
|
#ifdef HAVE_DYNAMIC
|
|
command_event(CMD_EVENT_LOAD_CORE, NULL);
|
|
#endif
|
|
|
|
retroarch_ctl(RARCH_CTL_UNSET_LAUNCHED_FROM_CLI, NULL);
|
|
|
|
if (label)
|
|
strlcpy(runloop_st->name.label, label, sizeof(runloop_st->name.label));
|
|
else
|
|
runloop_st->name.label[0] = '\0';
|
|
|
|
return task_load_content_internal_wrap(content_info, CORE_TYPE_PLAIN, true);
|
|
}
|
|
|
|
bool task_push_load_content_from_cli(
|
|
const char *core_path,
|
|
const char *fullpath,
|
|
content_ctx_info_t *content_info,
|
|
enum rarch_core_type type,
|
|
retro_task_callback_t cb,
|
|
void *user_data)
|
|
{
|
|
return task_load_content_internal(content_info, true, true, false, 0);
|
|
}
|
|
|
|
bool task_push_start_builtin_core(
|
|
content_ctx_info_t *content_info,
|
|
enum rarch_core_type type,
|
|
retro_task_callback_t cb,
|
|
void *user_data)
|
|
{
|
|
/* Clear content path */
|
|
path_clear(RARCH_PATH_CONTENT);
|
|
|
|
/* Preliminary stuff that has to be done before we
|
|
* load the actual content. Can differ per mode. */
|
|
runloop_set_current_core_type(type, true);
|
|
|
|
return task_load_content_internal_wrap(content_info, type, false);
|
|
}
|
|
|
|
|
|
bool task_push_load_content_with_core(
|
|
const char *fullpath,
|
|
content_ctx_info_t *content_info,
|
|
enum rarch_core_type type,
|
|
retro_task_callback_t cb,
|
|
void *user_data)
|
|
{
|
|
path_set(RARCH_PATH_CONTENT, fullpath);
|
|
return task_load_content_internal_wrap(content_info, type, false);
|
|
}
|
|
|
|
bool task_push_load_content_with_current_core_from_companion_ui(
|
|
const char *fullpath,
|
|
content_ctx_info_t *content_info,
|
|
enum rarch_core_type type,
|
|
retro_task_callback_t cb,
|
|
void *user_data)
|
|
{
|
|
content_state_t *p_content = content_state_get_ptr();
|
|
|
|
/* TODO/FIXME: Enable setting of these values
|
|
* via function arguments */
|
|
p_content->companion_ui_db_name[0] = '\0';
|
|
p_content->companion_ui_crc32[0] = '\0';
|
|
|
|
/* Load content
|
|
* > TODO/FIXME: Set loading_from_companion_ui 'false' for
|
|
* now, until someone can implement the required higher
|
|
* level functionality in 'win32_common.c' and 'ui_cocoa.m' */
|
|
path_set(RARCH_PATH_CONTENT, fullpath);
|
|
return task_load_content_internal_wrap(content_info, type, false);
|
|
}
|
|
|
|
|
|
bool task_push_load_subsystem_with_core(
|
|
const char *fullpath,
|
|
const char *label,
|
|
content_ctx_info_t *content_info,
|
|
enum rarch_core_type type,
|
|
retro_task_callback_t cb,
|
|
void *user_data)
|
|
{
|
|
content_state_t *p_content = content_state_get_ptr();
|
|
runloop_state_t *runloop_st = runloop_state_get_ptr();
|
|
|
|
/* The content label is global state that survives until
|
|
* the next content load overwrites it, and it is what
|
|
* task_push_to_history_list() writes into the history
|
|
* playlist entry. Every other load path either sets it
|
|
* or clears it; this one did neither, so a subsystem
|
|
* launch inherited - and recorded - the label belonging
|
|
* to whatever content was loaded before it. */
|
|
if (label && *label)
|
|
strlcpy(runloop_st->name.label, label,
|
|
sizeof(runloop_st->name.label));
|
|
else
|
|
runloop_st->name.label[0] = '\0';
|
|
|
|
p_content->flags |= CONTENT_ST_FLAG_PENDING_SUBSYSTEM_INIT;
|
|
return task_load_content_internal_wrap(content_info, type, false);
|
|
}
|
|
|
|
uint8_t content_get_flags(void)
|
|
{
|
|
content_state_t *p_content = content_state_get_ptr();
|
|
return p_content->flags;
|
|
}
|
|
|
|
/* Clears the pending subsystem rom buffer*/
|
|
void content_clear_subsystem(void)
|
|
{
|
|
size_t i;
|
|
content_state_t *p_content = content_state_get_ptr();
|
|
|
|
p_content->pending_subsystem_rom_id = 0;
|
|
p_content->flags &= ~CONTENT_ST_FLAG_PENDING_SUBSYSTEM_INIT;
|
|
|
|
for (i = 0; i < RARCH_MAX_SUBSYSTEM_ROMS; i++)
|
|
{
|
|
if (p_content->pending_subsystem_roms[i])
|
|
{
|
|
free(p_content->pending_subsystem_roms[i]);
|
|
p_content->pending_subsystem_roms[i] = NULL;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Set the current subsystem*/
|
|
void content_set_subsystem(unsigned idx)
|
|
{
|
|
const struct retro_subsystem_info *subsystem = NULL;
|
|
runloop_state_t *runloop_st = runloop_state_get_ptr();
|
|
content_state_t *p_content = content_state_get_ptr();
|
|
rarch_system_info_t *sys_info = &runloop_st->system;
|
|
|
|
/* Core fully loaded, use the subsystem data */
|
|
if (sys_info->subsystem.data)
|
|
subsystem = sys_info->subsystem.data + idx;
|
|
/* Core not loaded completely, use the data we peeked on load core */
|
|
else
|
|
subsystem = runloop_st->subsystem_data + idx;
|
|
|
|
p_content->pending_subsystem_id = idx;
|
|
|
|
if ( subsystem
|
|
&& (runloop_st->subsystem_current_count > 0))
|
|
{
|
|
strlcpy(p_content->pending_subsystem_ident,
|
|
subsystem->ident, sizeof(p_content->pending_subsystem_ident));
|
|
|
|
p_content->pending_subsystem_rom_num = subsystem->num_roms;
|
|
}
|
|
|
|
RARCH_LOG("[Subsystem] Setting current subsystem to: %d(%s) Content amount: %d.\n",
|
|
p_content->pending_subsystem_id,
|
|
p_content->pending_subsystem_ident,
|
|
p_content->pending_subsystem_rom_num);
|
|
}
|
|
|
|
/* Sets the subsystem by name */
|
|
bool content_set_subsystem_by_name(const char* subsystem_name)
|
|
{
|
|
unsigned i;
|
|
runloop_state_t *runloop_st = runloop_state_get_ptr();
|
|
rarch_system_info_t *sys_info = &runloop_st->system;
|
|
/* Core not loaded completely, use the data we peeked on load core */
|
|
const struct retro_subsystem_info
|
|
*subsystem = runloop_st->subsystem_data;
|
|
|
|
/* Core fully loaded, use the subsystem data */
|
|
if (sys_info->subsystem.data)
|
|
subsystem = sys_info->subsystem.data;
|
|
|
|
for (i = 0; i < runloop_st->subsystem_current_count; i++, subsystem++)
|
|
{
|
|
if (string_is_equal(subsystem_name, subsystem->ident))
|
|
{
|
|
content_set_subsystem(i);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
size_t content_get_subsystem_friendly_name(const char* subsystem_name, char *s, size_t len)
|
|
{
|
|
size_t i;
|
|
runloop_state_t *runloop_st = runloop_state_get_ptr();
|
|
rarch_system_info_t *sys_info = &runloop_st->system;
|
|
/* Core not loaded completely, use the data we peeked on load core */
|
|
const struct retro_subsystem_info *subsystem = runloop_st->subsystem_data;
|
|
/* Core fully loaded, use the subsystem data */
|
|
if (sys_info->subsystem.data)
|
|
subsystem = sys_info->subsystem.data;
|
|
for (i = 0; i < runloop_st->subsystem_current_count; i++, subsystem++)
|
|
{
|
|
if (string_is_equal(subsystem_name, subsystem->ident))
|
|
return strlcpy(s, subsystem->desc, len);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/* Add a rom to the subsystem ROM buffer */
|
|
void content_add_subsystem(const char* path)
|
|
{
|
|
content_state_t *p_content = content_state_get_ptr();
|
|
size_t pending_size = PATH_MAX_LENGTH * sizeof(char);
|
|
char *rom_buf = NULL;
|
|
|
|
if (p_content->pending_subsystem_rom_id >= RARCH_MAX_SUBSYSTEM_ROMS)
|
|
{
|
|
RARCH_ERR("[Subsystem] Cannot add ROM - maximum subsystem ROM count reached.\n");
|
|
return;
|
|
}
|
|
|
|
if (!(rom_buf = (char*)malloc(pending_size)))
|
|
{
|
|
RARCH_ERR("[Subsystem] Failed to allocate memory for subsystem ROM path.\n");
|
|
return;
|
|
}
|
|
|
|
p_content->pending_subsystem_roms[p_content->pending_subsystem_rom_id] = rom_buf;
|
|
|
|
strlcpy(p_content->pending_subsystem_roms[
|
|
p_content->pending_subsystem_rom_id],
|
|
path, pending_size);
|
|
RARCH_LOG("[Subsystem] Subsystem id: %d Subsystem ident:"
|
|
" %s Content ID: %d, Content Path: \"%s\".\n",
|
|
p_content->pending_subsystem_id,
|
|
p_content->pending_subsystem_ident,
|
|
p_content->pending_subsystem_rom_id,
|
|
p_content->pending_subsystem_roms[
|
|
p_content->pending_subsystem_rom_id]);
|
|
p_content->pending_subsystem_rom_id++;
|
|
}
|
|
|
|
void content_set_does_not_need_content(void)
|
|
{
|
|
content_state_t *p_content = content_state_get_ptr();
|
|
p_content->flags |= CONTENT_ST_FLAG_CORE_DOES_NOT_NEED_CONTENT;
|
|
}
|
|
|
|
void content_unset_does_not_need_content(void)
|
|
{
|
|
content_state_t *p_content = content_state_get_ptr();
|
|
p_content->flags &= ~CONTENT_ST_FLAG_CORE_DOES_NOT_NEED_CONTENT;
|
|
}
|
|
|
|
|
|
|
|
|
|
char* content_get_subsystem_rom(unsigned index)
|
|
{
|
|
content_state_t *p_content = content_state_get_ptr();
|
|
return p_content->pending_subsystem_roms[index];
|
|
}
|
|
|
|
bool content_is_inited(void)
|
|
{
|
|
content_state_t *p_content = content_state_get_ptr();
|
|
return ((p_content->flags & CONTENT_ST_FLAG_IS_INITED) > 0);
|
|
}
|
|
|
|
void content_deinit(void)
|
|
{
|
|
content_state_t *p_content = content_state_get_ptr();
|
|
|
|
content_file_override_free(p_content);
|
|
content_file_list_free(p_content->content_list);
|
|
|
|
p_content->content_list = NULL;
|
|
p_content->flags &= ~(CONTENT_ST_FLAG_CORE_DOES_NOT_NEED_CONTENT
|
|
| CONTENT_ST_FLAG_IS_INITED);
|
|
}
|
|
|
|
/* Set environment variables before a subsystem load */
|
|
void content_set_subsystem_info(void)
|
|
{
|
|
content_state_t *p_content = content_state_get_ptr();
|
|
if (!(p_content->flags & CONTENT_ST_FLAG_PENDING_SUBSYSTEM_INIT))
|
|
return;
|
|
|
|
path_set(RARCH_PATH_SUBSYSTEM, p_content->pending_subsystem_ident);
|
|
runloop_path_set_special(p_content->pending_subsystem_roms,
|
|
p_content->pending_subsystem_rom_num);
|
|
}
|
|
|
|
/* Initializes and loads a content file for the currently
|
|
* selected libretro core. */
|
|
bool content_init(void)
|
|
{
|
|
struct string_list content;
|
|
content_information_ctx_t content_ctx;
|
|
enum msg_hash_enums error_enum = MSG_UNKNOWN;
|
|
content_state_t *p_content = content_state_get_ptr();
|
|
bool ret = true;
|
|
char *err_string = NULL;
|
|
runloop_state_t *runloop_st = runloop_state_get_ptr();
|
|
settings_t *settings = config_get_ptr();
|
|
|
|
content_file_list_free(p_content->content_list);
|
|
p_content->content_list = NULL;
|
|
|
|
content_information_ctx_init(&content_ctx, settings, runloop_st, true);
|
|
|
|
p_content->flags |= CONTENT_ST_FLAG_IS_INITED;
|
|
|
|
if (string_list_initialize(&content))
|
|
{
|
|
if (!content_file_init(&content_ctx, p_content,
|
|
&content, &error_enum, &err_string))
|
|
{
|
|
content_deinit();
|
|
ret = false;
|
|
}
|
|
string_list_deinitialize(&content);
|
|
}
|
|
|
|
content_information_ctx_free(&content_ctx);
|
|
|
|
if (error_enum != MSG_UNKNOWN)
|
|
{
|
|
switch (error_enum)
|
|
{
|
|
case MSG_ERROR_LIBRETRO_CORE_REQUIRES_SPECIAL_CONTENT:
|
|
case MSG_ERROR_LIBRETRO_CORE_REQUIRES_VFS:
|
|
case MSG_FAILED_TO_LOAD_CONTENT:
|
|
case MSG_ERROR_LIBRETRO_CORE_REQUIRES_CONTENT:
|
|
{
|
|
const char *_msg = msg_hash_to_str(error_enum);
|
|
RARCH_ERR("[Content] %s\n", _msg);
|
|
runloop_msg_queue_push(_msg, strlen(_msg), 2, ret ? 1 : 180, false, NULL,
|
|
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_ERROR);
|
|
}
|
|
break;
|
|
case MSG_UNKNOWN:
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (err_string)
|
|
{
|
|
/* Trim ending newline */
|
|
size_t err_len = strlen(err_string);
|
|
|
|
if (err_string[err_len - 1] == '\n')
|
|
err_string[err_len - 1] = '\0';
|
|
|
|
if (ret)
|
|
RARCH_LOG("[Content] %s\n", err_string);
|
|
else
|
|
RARCH_ERR("[Content] %s\n", err_string);
|
|
|
|
/* Do not flush the message queue here
|
|
* > This allows any core-generated error messages
|
|
* to propagate through to the frontend */
|
|
runloop_msg_queue_push(err_string, strlen(err_string), 2, ret ? 1 : 180, false, NULL,
|
|
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_ERROR);
|
|
free(err_string);
|
|
}
|
|
|
|
return ret;
|
|
}
|