libretro/RetroArch
1
0
Fork 0
mirror of https://github.com/libretro/RetroArch.git synced 2024-11-23 16:09:47 +00:00
Code Issues Actions 23 Packages Projects Releases Wiki Activity
951b98fe1b
RetroArch/disk_control_interface.c
LibretroAdmin 60030e373e
Reduce snprintfs + assorted cleanups (#14369) 
* Reduce snprintf and/or use them only for concatenating the
string formatting of numbers/values
* Reduce snprintfs
* Use snprintf for concatenation at parts
* * We don't need to NULL-terminate strings that get passed to strlcpy/strlcat
and friends
* Use snprintf for concatenation in certain instances
* Do away with some string intermediary copies where we can avoid it
* Fix warning unused variable
* * Reduce snprintf calls
* Rewrite snprintf calls into strlcpy where possible
* Use snprintf for concatenation when necessary
* Do away with some string intermediary copies in task_translation.c
* run_translation_service - make switch slightly smaller
2022-09-01 04:17:07 +02:00

911 lines
25 KiB
C
Raw Blame History

/* Copyright (C) 2010-2020 The RetroArch team
*
* ---------------------------------------------------------------------------------------
* The following license statement only applies to this file (disk_control_interface.c).
* ---------------------------------------------------------------------------------------
*
* Permission is hereby granted, free of charge,
* to any person obtaining a copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
* and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
* INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#include <string/stdstring.h>
#include <file/file_path.h>
#include "paths.h"
#include "retroarch.h"
#include "verbosity.h"
#include "msg_hash.h"
#include "disk_control_interface.h"
#ifdef HAVE_CHEEVOS
#include "cheevos/cheevos.h"
#endif
/*****************/
/* Configuration */
/*****************/
/**
* disk_control_reset_callback:
*
* Sets all disk interface callback functions
* to NULL
**/
static void disk_control_reset_callback(
disk_control_interface_t *disk_control)
{
if (!disk_control)
return;
memset(&disk_control->cb, 0,
sizeof(struct retro_disk_control_ext_callback));
}
/**
* disk_control_set_callback:
*
* Set v0 disk interface callback functions
**/
void disk_control_set_callback(
disk_control_interface_t *disk_control,
const struct retro_disk_control_callback *cb)
{
if (!disk_control)
return;
disk_control_reset_callback(disk_control);
if (!cb)
return;
disk_control->cb.set_eject_state = cb->set_eject_state;
disk_control->cb.get_eject_state = cb->get_eject_state;
disk_control->cb.get_image_index = cb->get_image_index;
disk_control->cb.set_image_index = cb->set_image_index;
disk_control->cb.get_num_images = cb->get_num_images;
disk_control->cb.replace_image_index = cb->replace_image_index;
disk_control->cb.add_image_index = cb->add_image_index;
}
/**
* disk_control_set_ext_callback:
*
* Set v1+ disk interface callback functions
**/
void disk_control_set_ext_callback(
disk_control_interface_t *disk_control,
const struct retro_disk_control_ext_callback *cb)
{
if (!disk_control)
return;
disk_control_reset_callback(disk_control);
if (!cb)
return;
disk_control->cb.set_eject_state = cb->set_eject_state;
disk_control->cb.get_eject_state = cb->get_eject_state;
disk_control->cb.get_image_index = cb->get_image_index;
disk_control->cb.set_image_index = cb->set_image_index;
disk_control->cb.get_num_images = cb->get_num_images;
disk_control->cb.replace_image_index = cb->replace_image_index;
disk_control->cb.add_image_index = cb->add_image_index;
disk_control->cb.set_initial_image = cb->set_initial_image;
disk_control->cb.get_image_path = cb->get_image_path;
disk_control->cb.get_image_label = cb->get_image_label;
}
/**********/
/* Status */
/**********/
/**
* disk_control_enabled:
*
* Leaf function.
*
* @return true if core supports basic disk control functionality
* - set_eject_state
* - get_eject_state
* - get_image_index
* - set_image_index
* - get_num_images
**/
bool disk_control_enabled(
disk_control_interface_t *disk_control)
{
if (!disk_control)
return false;
if (disk_control->cb.set_eject_state &&
disk_control->cb.get_eject_state &&
disk_control->cb.get_image_index &&
disk_control->cb.set_image_index &&
disk_control->cb.get_num_images)
return true;
return false;
}
/**
* disk_control_append_enabled:
*
* Leaf function.
*
* @return true if core supports disk append functionality
* - replace_image_index
* - add_image_index
**/
bool disk_control_append_enabled(
disk_control_interface_t *disk_control)
{
if ( disk_control
&& disk_control->cb.replace_image_index
&& disk_control->cb.add_image_index)
return true;
return false;
}
/**
* disk_control_image_label_enabled:
*
* Leaf function.
*
* @return true if core supports image labels
* - get_image_label
**/
bool disk_control_image_label_enabled(
disk_control_interface_t *disk_control)
{
return disk_control && disk_control->cb.get_image_label;
}
/**
* disk_control_initial_image_enabled:
*
* Leaf function.
*
* @return true if core supports setting initial disk index
* - set_initial_image
* - get_image_path
**/
bool disk_control_initial_image_enabled(
disk_control_interface_t *disk_control)
{
if ( disk_control
&& disk_control->cb.set_initial_image
&& disk_control->cb.get_image_path)
return true;
return false;
}
/***********/
/* Getters */
/***********/
/**
* disk_control_get_eject_state:
*
* @return true if disk is currently ejected
**/
bool disk_control_get_eject_state(
disk_control_interface_t *disk_control)
{
if (!disk_control || !disk_control->cb.get_eject_state)
return false;
return disk_control->cb.get_eject_state();
}
/**
* disk_control_get_num_images:
*
* @return number of disk images registered by the core
**/
unsigned disk_control_get_num_images(
disk_control_interface_t *disk_control)
{
if (!disk_control || !disk_control->cb.get_num_images)
return 0;
return disk_control->cb.get_num_images();
}
/**
* disk_control_get_image_index:
*
* @return currently selected disk image index
**/
unsigned disk_control_get_image_index(
disk_control_interface_t *disk_control)
{
if (!disk_control || !disk_control->cb.get_image_index)
return 0;
return disk_control->cb.get_image_index();
}
/**
* disk_control_get_image_label:
*
* Fetches core-provided disk image label
* (label is set to an empty string if core
* does not support image labels)
**/
void disk_control_get_image_label(
disk_control_interface_t *disk_control,
unsigned index, char *label, size_t len)
{
if (!label || len < 1)
return;
if (!disk_control)
goto error;
if (!disk_control->cb.get_image_label)
goto error;
if (!disk_control->cb.get_image_label(index, label, len))
goto error;
return;
error:
label[0] = '\0';
}
/***********/
/* Setters */
/***********/
/**
* disk_control_get_index_set_msg:
*
* Generates an appropriate log/notification message
* for a disk index change event
**/
static void disk_control_get_index_set_msg(
disk_control_interface_t *disk_control,
unsigned num_images, unsigned index, bool success,
unsigned *msg_duration, char *msg, size_t len)
{
bool has_label = false;
char image_label[128];
image_label[0] = '\0';
if (!disk_control || !msg_duration || !msg || len < 1)
return;
/* Attempt to get image label */
if (index < num_images)
{
disk_control_get_image_label(
disk_control, index, image_label, sizeof(image_label));
has_label = !string_is_empty(image_label);
}
/* Get message duration
* > Default is 60
* > If a label is shown, then increase duration by 50%
* > For errors, duration is always 180 */
*msg_duration = success ?
(has_label ? 90 : 60) :
180;
/* Check whether image was inserted or removed */
if (index < num_images)
{
size_t _len = strlcpy(msg,
success
? msg_hash_to_str(MSG_SETTING_DISK_IN_TRAY)
: msg_hash_to_str(MSG_FAILED_TO_SET_DISK), len);
if (has_label)
snprintf(
msg + _len, len - _len, ": %u/%u - %s",
index + 1, num_images, image_label);
else
snprintf(
msg + _len, len - _len, ": %u/%u",
index + 1, num_images);
}
else
strlcpy(
msg,
success
? msg_hash_to_str(MSG_REMOVED_DISK_FROM_TRAY)
: msg_hash_to_str(MSG_FAILED_TO_REMOVE_DISK_FROM_TRAY),
len);
}
/**
* disk_control_set_eject_state:
*
* Sets the eject state of the virtual disk tray
**/
bool disk_control_set_eject_state(
disk_control_interface_t *disk_control,
bool eject, bool verbosity)
{
bool error = false;
char msg[128];
msg[0] = '\0';
if (!disk_control || !disk_control->cb.set_eject_state)
return false;
/* Set eject state */
if (disk_control->cb.set_eject_state(eject))
strlcpy(
msg,
eject
? msg_hash_to_str(MSG_DISK_EJECTED)
: msg_hash_to_str(MSG_DISK_CLOSED),
sizeof(msg));
else
{
error = true;
strlcpy(
msg,
eject
? msg_hash_to_str(MSG_VIRTUAL_DISK_TRAY_EJECT)
: msg_hash_to_str(MSG_VIRTUAL_DISK_TRAY_CLOSE),
sizeof(msg));
}
if (!string_is_empty(msg))
{
if (error)
RARCH_ERR("[Disc]: %s\n", msg);
else
RARCH_LOG("[Disc]: %s\n", msg);
/* Errors should always be displayed */
if (verbosity || error)
runloop_msg_queue_push(
msg, 1, error ? 180 : 60,
true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
#ifdef HAVE_CHEEVOS
if (!error && !eject)
{
if (disk_control->cb.get_image_index && disk_control->cb.get_image_path)
{
char image_path[PATH_MAX_LENGTH] = "";
unsigned image_index = disk_control->cb.get_image_index();
if (disk_control->cb.get_image_path(image_index, image_path, sizeof(image_path)))
rcheevos_change_disc(image_path, false);
}
}
#endif
return !error;
}
/**
* disk_control_set_index:
*
* Sets currently selected disk index
*
* NOTE: Will fail if disk is not currently ejected
**/
bool disk_control_set_index(
disk_control_interface_t *disk_control,
unsigned index, bool verbosity)
{
bool error = false;
unsigned num_images = 0;
unsigned msg_duration = 0;
char msg[NAME_MAX_LENGTH];
msg[0] = '\0';
if (!disk_control)
return false;
if (!disk_control->cb.get_eject_state ||
!disk_control->cb.get_num_images ||
!disk_control->cb.set_image_index)
return false;
/* Ensure that disk is currently ejected */
if (!disk_control->cb.get_eject_state())
return false;
/* Get current number of disk images */
num_images = disk_control->cb.get_num_images();
/* Perform 'set index' action */
error = !disk_control->cb.set_image_index(index);
/* Get log/notification message */
disk_control_get_index_set_msg(
disk_control, num_images, index, !error,
&msg_duration, msg, sizeof(msg));
/* Output log/notification message */
if (!string_is_empty(msg))
{
if (error)
RARCH_ERR("[Disc]: %s\n", msg);
else
RARCH_LOG("[Disc]: %s\n", msg);
/* Errors should always be displayed */
if (verbosity || error)
runloop_msg_queue_push(
msg, 1, msg_duration,
true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT,
MESSAGE_QUEUE_CATEGORY_INFO);
}
/* If operation was successful, update disk
* index record (if enabled) */
if (!error && disk_control->record_enabled)
{
if (disk_control->cb.get_image_index &&
disk_control->cb.get_image_path)
{
char new_image_path[PATH_MAX_LENGTH] = {0};
/* Get current image index + path */
unsigned new_image_index = disk_control->cb.get_image_index();
bool image_path_valid = disk_control->cb.get_image_path(
new_image_index, new_image_path, sizeof(new_image_path));
if (image_path_valid)
disk_index_file_set(
&disk_control->index_record,
new_image_index, new_image_path);
else
disk_index_file_set(
&disk_control->index_record, 0, NULL);
}
}
return !error;
}
/**
* disk_control_set_index_next:
*
* Increments selected disk index
**/
bool disk_control_set_index_next(
disk_control_interface_t *disk_control,
bool verbosity)
{
unsigned num_images = 0;
unsigned image_index = 0;
bool disk_next_enable = false;
if (!disk_control)
return false;
if (!disk_control->cb.get_num_images ||
!disk_control->cb.get_image_index)
return false;
num_images = disk_control->cb.get_num_images();
image_index = disk_control->cb.get_image_index();
/* Would seem more sensible to check (num_images > 1)
* here, but seems we need to be able to cycle the
* same image for legacy reasons... */
disk_next_enable = (num_images > 0) && (num_images != UINT_MAX);
if (!disk_next_enable)
{
RARCH_ERR("[Disc]: %s\n", msg_hash_to_str(MSG_GOT_INVALID_DISK_INDEX));
return false;
}
if (image_index < (num_images - 1))
image_index++;
return disk_control_set_index(disk_control, image_index, verbosity);
}
/**
* disk_control_set_index_prev:
*
* Decrements selected disk index
**/
bool disk_control_set_index_prev(
disk_control_interface_t *disk_control,
bool verbosity)
{
unsigned num_images = 0;
unsigned image_index = 0;
bool disk_prev_enable = false;
if (!disk_control)
return false;
if (!disk_control->cb.get_num_images ||
!disk_control->cb.get_image_index)
return false;
num_images = disk_control->cb.get_num_images();
image_index = disk_control->cb.get_image_index();
/* Would seem more sensible to check (num_images > 1)
* here, but seems we need to be able to cycle the
* same image for legacy reasons... */
disk_prev_enable = (num_images > 0);
if (!disk_prev_enable)
{
RARCH_ERR("[Disc]: %s\n", msg_hash_to_str(MSG_GOT_INVALID_DISK_INDEX));
return false;
}
if (image_index > 0)
image_index--;
return disk_control_set_index(disk_control, image_index, verbosity);
}
/**
* disk_control_append_image:
*
* Appends specified image file to disk image list
**/
bool disk_control_append_image(
disk_control_interface_t *disk_control,
const char *image_path)
{
size_t _len;
bool initial_disk_ejected = false;
unsigned initial_index = 0;
unsigned new_index = 0;
const char *image_filename = NULL;
struct retro_game_info info = {0};
char msg[128];
/* Sanity check. If any of these fail then a
* frontend error has occurred - we will not
* deal with that here */
if (!disk_control)
return false;
if (!disk_control->cb.get_image_index ||
!disk_control->cb.get_num_images ||
!disk_control->cb.add_image_index ||
!disk_control->cb.replace_image_index ||
!disk_control->cb.get_eject_state)
return false;
if (string_is_empty(image_path))
return false;
image_filename = path_basename(image_path);
if (string_is_empty(image_filename))
return false;
/* Get initial disk eject state */
initial_disk_ejected = disk_control_get_eject_state(disk_control);
/* Cache initial image index */
initial_index = disk_control->cb.get_image_index();
/* If tray is currently closed, eject disk */
if (!initial_disk_ejected &&
!disk_control_set_eject_state(disk_control, true, false))
goto error;
/* Append image */
if (!disk_control->cb.add_image_index())
goto error;
if ((new_index = disk_control->cb.get_num_images()) < 1)
goto error;
new_index--;
info.path = image_path;
if (!disk_control->cb.replace_image_index(new_index, &info))
goto error;
/* Set new index */
if (!disk_control_set_index(disk_control, new_index, false))
goto error;
/* If tray was initially closed, insert disk
* (i.e. leave system in the state we found it) */
if ( !initial_disk_ejected
&& !disk_control_set_eject_state(disk_control, false, false))
goto error;
/* Display log */
_len = strlcpy(msg, msg_hash_to_str(MSG_APPENDED_DISK), sizeof(msg));
msg[_len ] = ':';
msg[_len+1] = ' ';
msg[_len+2] = '\0';
strlcat(msg, image_filename, sizeof(msg));
RARCH_LOG("[Disc]: %s\n", msg);
/* This message should always be displayed, since
* the menu itself does not provide sufficient
* visual feedback */
runloop_msg_queue_push(msg, 0, 120, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
return true;
error:
/* If we reach this point then everything is
* broken and the disk control interface is
* in an undefined state. Try to restore some
* sanity by reinserting the original disk...
* NOTE: If this fails then it's game over -
* just display the error notification and
* hope for the best... */
if (!disk_control->cb.get_eject_state())
disk_control_set_eject_state(disk_control, true, false);
disk_control_set_index(disk_control, initial_index, false);
if (!initial_disk_ejected)
disk_control_set_eject_state(disk_control, false, false);
_len = strlcpy(msg,
msg_hash_to_str(MSG_FAILED_TO_APPEND_DISK), sizeof(msg));
msg[_len ] = ':';
msg[_len+1] = ' ';
msg[_len+2] = '\0';
strlcat(msg, image_filename, sizeof(msg));
runloop_msg_queue_push(
msg, 0, 180,
true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
return false;
}
/*****************************/
/* 'Initial index' functions */
/*****************************/
/**
* disk_control_set_initial_index:
*
* Attempts to set current core's initial disk index.
* > disk_control->record_enabled will be set to
* 'false' if core does not support initial
* index functionality
* > disk_control->index_record will be loaded
* from file (if an existing record is found)
* NOTE: Must be called immediately before
* loading content
**/
bool disk_control_set_initial_index(
disk_control_interface_t *disk_control,
const char *content_path,
const char *dir_savefile)
{
if (!disk_control)
return false;
if (string_is_empty(content_path))
goto error;
/* Check that 'initial index' functionality is enabled */
if (!disk_control->cb.set_initial_image ||
!disk_control->cb.get_num_images ||
!disk_control->cb.get_image_index ||
!disk_control->cb.get_image_path)
goto error;
/* Attempt to initialise disk index record (reading
* from disk, if file exists) */
disk_control->record_enabled = disk_index_file_init(
&disk_control->index_record,
content_path, dir_savefile);
/* If record is enabled and initial index is *not*
* zero, notify current core */
if (disk_control->record_enabled &&
(disk_control->index_record.image_index != 0))
{
if (!disk_control->cb.set_initial_image(
disk_control->index_record.image_index,
disk_control->index_record.image_path))
{
/* Note: We don't bother with an on-screen
* notification at this stage, since an error
* here may not matter (have to wait until
* disk index is verified) */
RARCH_ERR(
"[Disc]: Failed to set initial disk index: [%u] %s\n",
disk_control->index_record.image_index,
disk_control->index_record.image_path);
return false;
}
}
return true;
error:
disk_control->record_enabled = false;
return false;
}
/**
* disk_control_verify_initial_index:
*
* Checks that initial index has been set correctly
* and provides user notification.
* > Sets disk_control->initial_num_images if
* if functionality is supported by core
* NOTE: Must be called immediately after
* loading content
**/
bool disk_control_verify_initial_index(
disk_control_interface_t *disk_control,
bool verbosity)
{
bool success = false;
unsigned image_index = 0;
char image_path[PATH_MAX_LENGTH];
image_path[0] = '\0';
if (!disk_control)
return false;
/* If index record is disabled, can return immediately */
if (!disk_control->record_enabled)
return false;
/* Check that 'initial index' functionality is enabled */
if (!disk_control->cb.set_initial_image ||
!disk_control->cb.get_num_images ||
!disk_control->cb.get_image_index ||
!disk_control->cb.get_image_path)
return false;
/* Cache initial number of images
* (required for error checking when saving
* disk index file) */
disk_control->initial_num_images =
disk_control->cb.get_num_images();
/* Get current image index + path */
image_index = disk_control->cb.get_image_index();
if (disk_control->cb.get_image_path(
image_index, image_path, sizeof(image_path)))
{
/* Check whether index + path match set
* values
* > Note that if set index was zero and
* set path was empty, we ignore the path
* read here (since this corresponds to a
* 'first run', where no existing disk index
* file was present) */
if ((image_index == disk_control->index_record.image_index) &&
(string_is_equal(image_path, disk_control->index_record.image_path) ||
((disk_control->index_record.image_index == 0) &&
string_is_empty(disk_control->index_record.image_path))))
success = true;
}
/* If current disk is incorrect, notify user */
if (!success)
{
RARCH_ERR(
"[Disc]: Failed to set initial disk index:\n> Expected"
" [%u] %s\n> Detected [%u] %s\n",
disk_control->index_record.image_index + 1,
disk_control->index_record.image_path,
image_index + 1,
image_path);
/* Ignore 'verbosity' setting - errors should
* always be displayed */
runloop_msg_queue_push(
msg_hash_to_str(MSG_FAILED_TO_SET_INITIAL_DISK),
0, 60,
true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
/* Since a failure here typically means that the
* original M3U content file has been altered,
* any existing disk index record file will be
* invalid. We therefore 'reset' and save the disk
* index record to prevent a repeat of the error on
* the next run */
disk_index_file_set(&disk_control->index_record, 0, NULL);
disk_index_file_save(&disk_control->index_record);
}
/* If current disk is correct and recorded image
* path is empty (i.e. first run), need to register
* current image path */
else if (string_is_empty(disk_control->index_record.image_path))
disk_index_file_set(
&disk_control->index_record, image_index, image_path);
/* Regardless of success/failure, notify user of
* current disk index *if* more than one disk
* is available */
if (disk_control->initial_num_images > 1)
{
unsigned msg_duration = 0;
char msg[PATH_MAX_LENGTH];
msg[0] = '\0';
disk_control_get_index_set_msg(
disk_control, disk_control->initial_num_images, image_index, true,
&msg_duration, msg, sizeof(msg));
RARCH_LOG("[Disc]: %s\n", msg);
/* Note: Do not flush message queue here, since
* it is likely other notifications will be
* generated before setting the disk index, and
* we do not want to 'overwrite' them */
if (verbosity)
runloop_msg_queue_push(
msg,
0, msg_duration,
false, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
#ifdef HAVE_CHEEVOS
if (image_index > 0)
rcheevos_change_disc(disk_control->index_record.image_path, true);
#endif
}
return success;
}
/**
* disk_control_save_image_index:
*
* Saves current disk index to file, if supported
* by current core
**/
bool disk_control_save_image_index(
disk_control_interface_t *disk_control)
{
if (!disk_control)
return false;
/* If index record is disabled, can return immediately */
if (!disk_control->record_enabled)
return false;
/* If core started with less than two disks,
* then a disk index record is unnecessary */
if (disk_control->initial_num_images < 2)
return false;
/* If current index is greater than initial
* number of disks then user has appended a
* disk and it is currently active. This setup
* *cannot* be restored, so cancel the file save */
if (disk_control->index_record.image_index >=
disk_control->initial_num_images)
return false;
/* Save record */
return disk_index_file_save(&disk_control->index_record);
}
Reference in New Issue View Git Blame Copy Permalink