mirror/RetroArch
1
0
Fork 0
mirror of https://github.com/libretro/RetroArch synced 2025-04-10 15:45:19 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'upstream/master'

Browse Source
This commit is contained in:
radius 2015-07-02 17:45:12 -05:00
commit 2836eb976f
33 changed files with 943 additions and 395 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
audio/audio_driver.c
View File

@ -25,7 +25,6 @@
#include "../retroarch.h" #include "../retroarch.h"
#include "../runloop.h" #include "../runloop.h"
#include "../performance.h" #include "../performance.h"
#include "../intl/intl.h"
#ifndef AUDIO_BUFFER_FREE_SAMPLES_COUNT #ifndef AUDIO_BUFFER_FREE_SAMPLES_COUNT
#define AUDIO_BUFFER_FREE_SAMPLES_COUNT (8 * 1024) #define AUDIO_BUFFER_FREE_SAMPLES_COUNT (8 * 1024)
@ -692,8 +691,6 @@ bool audio_driver_flush(const int16_t *data, size_t samples)
if (audio_driver_write(output_data, output_frames * output_size * 2) < 0) if (audio_driver_write(output_data, output_frames * output_size * 2) < 0)
{ {
RARCH_ERR(RETRO_LOG_AUDIO_WRITE_FAILED);
driver->audio_active = false; driver->audio_active = false;
return false; return false;
} }

35
command.c
View File

@ -27,10 +27,10 @@
#include <compat/posix_string.h> #include <compat/posix_string.h>
#include <file/file_path.h> #include <file/file_path.h>
#include <retro_miscellaneous.h> #include <retro_miscellaneous.h>
#include <rhash.h>
#include <net/net_compat.h> #include <net/net_compat.h>
#include "msg_hash.h"
#if defined(HAVE_NETWORK_CMD) && defined(HAVE_NETPLAY) #if defined(HAVE_NETWORK_CMD) && defined(HAVE_NETPLAY)
#include "netplay.h" #include "netplay.h"
#endif #endif
@ -230,7 +230,7 @@ static bool cmd_set_shader(const char *arg)
char msg[PATH_MAX_LENGTH] = {0}; char msg[PATH_MAX_LENGTH] = {0};
enum rarch_shader_type type = RARCH_SHADER_NONE; enum rarch_shader_type type = RARCH_SHADER_NONE;
const char *ext = path_get_extension(arg); const char *ext = path_get_extension(arg);
uint32_t ext_hash = djb2_calculate(ext); uint32_t ext_hash = msg_hash_calculate(ext);
switch (ext_hash) switch (ext_hash)
{ {
@ -248,7 +248,9 @@ static bool cmd_set_shader(const char *arg)
snprintf(msg, sizeof(msg), "Shader: \"%s\"", arg); snprintf(msg, sizeof(msg), "Shader: \"%s\"", arg);
rarch_main_msg_queue_push(msg, 1, 120, true); rarch_main_msg_queue_push(msg, 1, 120, true);
RARCH_LOG("Applying shader \"%s\".\n", arg); RARCH_LOG("%s \"%s\".\n",
msg_hash_to_str(MSG_APPLYING_SHADER),
arg);
return video_driver_set_shader(type, arg); return video_driver_set_shader(type, arg);
} }
@ -314,7 +316,10 @@ static void parse_sub_msg(rarch_cmd_t *handle, const char *tok)
handle->state[map[index].id] = true; handle->state[map[index].id] = true;
} }
else else
RARCH_WARN("Unrecognized command \"%s\" received.\n", tok); RARCH_WARN("%s \"%s\" %s.\n",
msg_hash_to_str(MSG_UNRECOGNIZED_COMMAND),
tok,
msg_hash_to_str(MSG_RECEIVED));
} }
static void parse_msg(rarch_cmd_t *handle, char *buf) static void parse_msg(rarch_cmd_t *handle, char *buf)
@ -379,19 +384,24 @@ static void network_cmd_poll(rarch_cmd_t *handle)
static size_t read_stdin(char *buf, size_t size) static size_t read_stdin(char *buf, size_t size)
{ {
DWORD i; DWORD i;
DWORD has_read = 0;
DWORD avail = 0;
bool echo = false;
HANDLE hnd = GetStdHandle(STD_INPUT_HANDLE); HANDLE hnd = GetStdHandle(STD_INPUT_HANDLE);
if (hnd == INVALID_HANDLE_VALUE) if (hnd == INVALID_HANDLE_VALUE)
return 0; return 0;
/* Check first if we're a pipe /* Check first if we're a pipe
* (not console). */ * (not console). */
DWORD avail = 0;
bool echo = false;
/* If not a pipe, check if we're running in a console. */ /* If not a pipe, check if we're running in a console. */
if (!PeekNamedPipe(hnd, NULL, 0, NULL, &avail, NULL)) if (!PeekNamedPipe(hnd, NULL, 0, NULL, &avail, NULL))
{ {
DWORD mode = 0; INPUT_RECORD recs[256];
bool has_key = false;
DWORD mode = 0, has_read = 0;
if (!GetConsoleMode(hnd, &mode)) if (!GetConsoleMode(hnd, &mode))
return 0; return 0;
@ -401,13 +411,10 @@ static size_t read_stdin(char *buf, size_t size)
return 0; return 0;
/* Win32, Y U NO SANE NONBLOCK READ!? */ /* Win32, Y U NO SANE NONBLOCK READ!? */
DWORD has_read = 0;
INPUT_RECORD recs[256];
if (!PeekConsoleInput(hnd, recs, if (!PeekConsoleInput(hnd, recs,
sizeof(recs) / sizeof(recs[0]), &has_read)) sizeof(recs) / sizeof(recs[0]), &has_read))
return 0; return 0;
bool has_key = false;
for (i = 0; i < has_read; i++) for (i = 0; i < has_read; i++)
{ {
/* Very crude, but should get the job done. */ /* Very crude, but should get the job done. */
@ -436,7 +443,6 @@ static size_t read_stdin(char *buf, size_t size)
if (avail > size) if (avail > size)
avail = size; avail = size;
DWORD has_read = 0;
if (!ReadFile(hnd, buf, avail, &has_read, NULL)) if (!ReadFile(hnd, buf, avail, &has_read, NULL))
return 0; return 0;
@ -619,7 +625,7 @@ bool network_cmd_send(const char *cmd_)
const char *host = NULL; const char *host = NULL;
const char *port_ = NULL; const char *port_ = NULL;
global_t *global = global_get_ptr(); global_t *global = global_get_ptr();
bool old_verbose = global->verbosity; bool old_verbose = global ? global->verbosity : false;
uint16_t port = DEFAULT_NETWORK_CMD_PORT; uint16_t port = DEFAULT_NETWORK_CMD_PORT;
if (!network_init()) if (!network_init())
@ -648,7 +654,8 @@ bool network_cmd_send(const char *cmd_)
if (port_) if (port_)
port = strtoul(port_, NULL, 0); port = strtoul(port_, NULL, 0);
RARCH_LOG("Sending command: \"%s\" to %s:%hu\n", RARCH_LOG("%s: \"%s\" to %s:%hu\n",
msg_hash_to_str(MSG_SENDING_COMMAND),
cmd, host, (unsigned short)port); cmd, host, (unsigned short)port);
ret = verify_command(cmd) && send_udp_packet(host, port, cmd); ret = verify_command(cmd) && send_udp_packet(host, port, cmd);

175
command_event.c
View File

@ -24,7 +24,7 @@
#include "dynamic.h" #include "dynamic.h"
#include "content.h" #include "content.h"
#include "screenshot.h" #include "screenshot.h"
#include "intl/intl.h" #include "msg_hash.h"
#include "retroarch.h" #include "retroarch.h"
#include "dir_list_special.h" #include "dir_list_special.h"
@ -82,9 +82,12 @@ static void event_free_temporary_content(void)
{ {
const char *path = global->temporary_content->elems[i].data; const char *path = global->temporary_content->elems[i].data;
RARCH_LOG("Removing temporary content file: %s.\n", path); RARCH_LOG("%s: %s.\n",
msg_hash_to_str(MSG_REMOVING_TEMPORARY_CONTENT_FILE), path);
if (remove(path) < 0) if (remove(path) < 0)
RARCH_ERR("Failed to remove temporary file: %s.\n", path); RARCH_ERR("%s: %s.\n",
msg_hash_to_str(MSG_FAILED_TO_REMOVE_TEMPORARY_FILE),
path);
} }
string_list_free(global->temporary_content); string_list_free(global->temporary_content);
} }
@ -119,7 +122,7 @@ static void event_init_autosave(void)
settings->autosave_interval); settings->autosave_interval);
if (!global->autosave[i]) if (!global->autosave[i])
RARCH_WARN(RETRO_LOG_INIT_AUTOSAVE_FAILED); RARCH_WARN("%s\n", msg_hash_to_str(MSG_AUTOSAVE_FAILED));
} }
} }
@ -151,7 +154,11 @@ static void event_save_files(void)
{ {
unsigned type = global->savefiles->elems[i].attr.i; unsigned type = global->savefiles->elems[i].attr.i;
const char *path = global->savefiles->elems[i].data; const char *path = global->savefiles->elems[i].data;
RARCH_LOG("Saving RAM type #%u to \"%s\".\n", type, path); RARCH_LOG("%s #%u %s \"%s\".\n",
msg_hash_to_str(MSG_SAVING_RAM_TYPE),
type,
msg_hash_to_str(MSG_TO),
path);
save_ram_file(path, type); save_ram_file(path, type);
} }
} }
@ -166,32 +173,36 @@ static void event_init_movie(void)
if (!(global->bsv.movie = bsv_movie_init(global->bsv.movie_start_path, if (!(global->bsv.movie = bsv_movie_init(global->bsv.movie_start_path,
RARCH_MOVIE_PLAYBACK))) RARCH_MOVIE_PLAYBACK)))
{ {
RARCH_ERR("Failed to load movie file: \"%s\".\n", RARCH_ERR("%s: \"%s\".\n",
msg_hash_to_str(MSG_FAILED_TO_LOAD_MOVIE_FILE),
global->bsv.movie_start_path); global->bsv.movie_start_path);
rarch_fail(1, "event_init_movie()"); rarch_fail(1, "event_init_movie()");
} }
global->bsv.movie_playback = true; global->bsv.movie_playback = true;
rarch_main_msg_queue_push("Starting movie playback.", 2, 180, false); rarch_main_msg_queue_push_new(MSG_STARTING_MOVIE_PLAYBACK, 2, 180, false);
RARCH_LOG("Starting movie playback.\n"); RARCH_LOG("%s.\n", msg_hash_to_str(MSG_STARTING_MOVIE_PLAYBACK));
settings->rewind_granularity = 1; settings->rewind_granularity = 1;
} }
else if (global->bsv.movie_start_recording) else if (global->bsv.movie_start_recording)
{ {
char msg[PATH_MAX_LENGTH] = {0}; char msg[PATH_MAX_LENGTH] = {0};
snprintf(msg, sizeof(msg), "Starting movie record to \"%s\".", snprintf(msg, sizeof(msg),
"%s \"%s\".",
msg_hash_to_str(MSG_STARTING_MOVIE_RECORD_TO),
global->bsv.movie_start_path); global->bsv.movie_start_path);
if (!(global->bsv.movie = bsv_movie_init(global->bsv.movie_start_path, if (!(global->bsv.movie = bsv_movie_init(global->bsv.movie_start_path,
RARCH_MOVIE_RECORD))) RARCH_MOVIE_RECORD)))
{ {
rarch_main_msg_queue_push("Failed to start movie record.", 1, 180, true); rarch_main_msg_queue_push_new(MSG_FAILED_TO_START_MOVIE_RECORD, 1, 180, true);
RARCH_ERR("Failed to start movie record.\n"); RARCH_ERR("%s.\n", msg_hash_to_str(MSG_FAILED_TO_START_MOVIE_RECORD));
return; return;
} }
rarch_main_msg_queue_push(msg, 1, 180, true); rarch_main_msg_queue_push(msg, 1, 180, true);
RARCH_LOG("Starting movie record to \"%s\".\n", RARCH_LOG("%s \"%s\".\n",
msg_hash_to_str(MSG_STARTING_MOVIE_RECORD_TO),
global->bsv.movie_start_path); global->bsv.movie_start_path);
settings->rewind_granularity = 1; settings->rewind_granularity = 1;
} }
@ -220,13 +231,16 @@ static void event_disk_control_set_eject(bool new_state, bool print_log)
*msg = '\0'; *msg = '\0';
if (control->set_eject_state(new_state)) if (control->set_eject_state(new_state))
snprintf(msg, sizeof(msg), "%s virtual disk tray.", snprintf(msg, sizeof(msg), "%s %s",
new_state ? "Ejected" : "Closed"); new_state ? "Ejected" : "Closed",
msg_hash_to_str(MSG_VIRTUAL_DISK_TRAY));
else else
{ {
error = true; error = true;
snprintf(msg, sizeof(msg), "Failed to %s virtual disk tray.", snprintf(msg, sizeof(msg), "%s %s %s",
new_state ? "eject" : "close"); msg_hash_to_str(MSG_FAILED_TO),
new_state ? "eject" : "close",
msg_hash_to_str(MSG_VIRTUAL_DISK_TRAY));
} }
if (*msg) if (*msg)
@ -273,7 +287,7 @@ void event_disk_control_append_image(const char *path)
info.path = path; info.path = path;
control->replace_image_index(new_idx, &info); control->replace_image_index(new_idx, &info);
strlcpy(msg, "Appended disk: ", sizeof(msg)); snprintf(msg, sizeof(msg), "%s: ", msg_hash_to_str(MSG_APPENDED_DISK));
strlcat(msg, path, sizeof(msg)); strlcat(msg, path, sizeof(msg));
RARCH_LOG("%s\n", msg); RARCH_LOG("%s\n", msg);
rarch_main_msg_queue_push(msg, 0, 180, true); rarch_main_msg_queue_push(msg, 0, 180, true);
@ -337,7 +351,9 @@ static void event_disk_control_set_index(unsigned idx)
snprintf(msg, sizeof(msg), "Setting disk %u of %u in tray.", snprintf(msg, sizeof(msg), "Setting disk %u of %u in tray.",
idx + 1, num_disks); idx + 1, num_disks);
else else
strlcpy(msg, "Removed disk from tray.", sizeof(msg)); strlcpy(msg,
msg_hash_to_str(MSG_REMOVED_DISK_FROM_TRAY),
sizeof(msg));
} }
else else
{ {
@ -345,7 +361,9 @@ static void event_disk_control_set_index(unsigned idx)
snprintf(msg, sizeof(msg), "Failed to set disk %u of %u.", snprintf(msg, sizeof(msg), "Failed to set disk %u of %u.",
idx + 1, num_disks); idx + 1, num_disks);
else else
strlcpy(msg, "Failed to remove disk from tray.", sizeof(msg)); strlcpy(msg,
msg_hash_to_str(MSG_FAILED_TO_REMOVE_DISK_FROM_TRAY),
sizeof(msg));
error = true; error = true;
} }
@ -385,7 +403,7 @@ static void event_check_disk_prev(
if (!disk_prev_enable) if (!disk_prev_enable)
{ {
RARCH_ERR("Got invalid disk index from libretro.\n"); RARCH_ERR("%s.\n", msg_hash_to_str(MSG_GOT_INVALID_DISK_INDEX));
return; return;
} }
@ -420,7 +438,7 @@ static void event_check_disk_next(
if (!disk_next_enable) if (!disk_next_enable)
{ {
RARCH_ERR("Got invalid disk index from libretro.\n"); RARCH_ERR("%s.\n", msg_hash_to_str(MSG_GOT_INVALID_DISK_INDEX));
return; return;
} }
@ -684,7 +702,8 @@ static bool event_init_content(void)
event_set_savestate_auto_index(); event_set_savestate_auto_index();
if (event_load_save_files()) if (event_load_save_files())
RARCH_LOG("Skipping SRAM load.\n"); RARCH_LOG("%s.\n",
msg_hash_to_str(MSG_SKIPPING_SRAM_LOAD));
event_load_auto_state(); event_load_auto_state();
event_command(EVENT_CMD_BSV_MOVIE_INIT); event_command(EVENT_CMD_BSV_MOVIE_INIT);
@ -801,9 +820,8 @@ static bool event_save_core_config(void)
sizeof(config_dir)); sizeof(config_dir));
else else
{ {
const char *message = "Config directory not set. Cannot save new config."; rarch_main_msg_queue_push_new(MSG_CONFIG_DIRECTORY_NOT_SET, 1, 180, true);
rarch_main_msg_queue_push(message, 1, 180, true); RARCH_ERR("%s\n", msg_hash_to_str(MSG_CONFIG_DIRECTORY_NOT_SET));
RARCH_ERR("%s\n", message);
return false; return false;
} }
@ -891,14 +909,17 @@ static void event_save_state(const char *path,
if (!save_state(path)) if (!save_state(path))
{ {
snprintf(s, len, "Failed to save state to \"%s\".", path); snprintf(s, len, "%s \"%s\".",
msg_hash_to_str(MSG_FAILED_TO_SAVE_STATE_TO),
path);
return; return;
} }
if (settings->state_slot < 0) if (settings->state_slot < 0)
snprintf(s, len, "Saved state to slot #-1 (auto)."); snprintf(s, len, "%s #-1 (auto).", msg_hash_to_str(MSG_SAVED_STATE_TO_SLOT));
else else
snprintf(s, len, "Saved state to slot #%d.", settings->state_slot); snprintf(s, len, "%s #%d.", msg_hash_to_str(MSG_SAVED_STATE_TO_SLOT),
settings->state_slot);
} }
/** /**
@ -915,15 +936,17 @@ static void event_load_state(const char *path, char *s, size_t len)
if (!load_state(path)) if (!load_state(path))
{ {
snprintf(s, len, "Failed to load state from \"%s\".", path); snprintf(s, len, "%s \"%s\".",
msg_hash_to_str(MSG_FAILED_TO_LOAD_STATE),
path);
return; return;
} }
if (settings->state_slot < 0) if (settings->state_slot < 0)
snprintf(s, len, "Loaded state from slot #-1 (auto)."); snprintf(s, len, "%s #-1 (auto).", msg_hash_to_str(MSG_LOADED_STATE_FROM_SLOT));
else else
snprintf(s, len, "Loaded state from slot #%d.", settings->state_slot); snprintf(s, len, "%s #%d.", msg_hash_to_str(MSG_LOADED_STATE_FROM_SLOT),
settings->state_slot);
} }
static void event_main_state(unsigned cmd) static void event_main_state(unsigned cmd)
@ -937,19 +960,25 @@ static void event_main_state(unsigned cmd)
snprintf(path, sizeof(path), "%s%d", snprintf(path, sizeof(path), "%s%d",
global->savestate_name, settings->state_slot); global->savestate_name, settings->state_slot);
else if (settings->state_slot < 0) else if (settings->state_slot < 0)
fill_pathname_join_delim(path, global->savestate_name, "auto", '.', sizeof(path)); fill_pathname_join_delim(path,
global->savestate_name, "auto", '.', sizeof(path));
else else
strlcpy(path, global->savestate_name, sizeof(path)); strlcpy(path, global->savestate_name, sizeof(path));
if (pretro_serialize_size()) if (pretro_serialize_size())
{ {
if (cmd == EVENT_CMD_SAVE_STATE) switch (cmd)
event_save_state(path, msg, sizeof(msg)); {
else if (cmd == EVENT_CMD_LOAD_STATE) case EVENT_CMD_SAVE_STATE:
event_load_state(path, msg, sizeof(msg)); event_save_state(path, msg, sizeof(msg));
break;
case EVENT_CMD_LOAD_STATE:
event_load_state(path, msg, sizeof(msg));
break;
}
} }
else else
strlcpy(msg, "Core does not support save states.", sizeof(msg)); strlcpy(msg, msg_hash_to_str(MSG_CORE_DOES_NOT_SUPPORT_SAVESTATES), sizeof(msg));
rarch_main_msg_queue_push(msg, 2, 180, true); rarch_main_msg_queue_push(msg, 2, 180, true);
RARCH_LOG("%s\n", msg); RARCH_LOG("%s\n", msg);
@ -1080,8 +1109,8 @@ bool event_command(enum event_command cmd)
event_init_controllers(); event_init_controllers();
break; break;
case EVENT_CMD_RESET: case EVENT_CMD_RESET:
RARCH_LOG(RETRO_LOG_RESETTING_CONTENT); RARCH_LOG("%s.\n", msg_hash_to_str(MSG_RESET));
rarch_main_msg_queue_push("Reset.", 1, 120, true); rarch_main_msg_queue_push_new(MSG_RESET, 1, 120, true);
pretro_reset(); pretro_reset();
/* bSNES since v073r01 resets controllers to JOYPAD /* bSNES since v073r01 resets controllers to JOYPAD
@ -1214,11 +1243,13 @@ bool event_command(enum event_command cmd)
case EVENT_CMD_AUDIO_MUTE_TOGGLE: case EVENT_CMD_AUDIO_MUTE_TOGGLE:
{ {
const char *msg = !settings->audio.mute_enable ? const char *msg = !settings->audio.mute_enable ?
"Audio muted." : "Audio unmuted."; msg_hash_to_str(MSG_AUDIO_MUTED):
msg_hash_to_str(MSG_AUDIO_UNMUTED);
if (!audio_driver_mute_toggle()) if (!audio_driver_mute_toggle())
{ {
RARCH_ERR("Failed to unmute audio.\n"); RARCH_ERR("%s.\n",
msg_hash_to_str(MSG_FAILED_TO_UNMUTE_AUDIO));
return false; return false;
} }
@ -1249,11 +1280,15 @@ bool event_command(enum event_command cmd)
break; break;
} }
driver->overlay = input_overlay_new(driver->osk_enable ? settings->osk.overlay : settings->input.overlay, driver->overlay = input_overlay_new(
driver->osk_enable ? settings->osk.enable : settings->input.overlay_enable, driver->osk_enable ?
settings->input.overlay_opacity, settings->input.overlay_scale); settings->osk.overlay : settings->input.overlay,
driver->osk_enable ?
settings->osk.enable : settings->input.overlay_enable,
settings->input.overlay_opacity,
settings->input.overlay_scale);
if (!driver->overlay) if (!driver->overlay)
RARCH_ERR("Failed to load overlay.\n"); RARCH_ERR("%s.\n", msg_hash_to_str(MSG_FAILED_TO_LOAD_OVERLAY));
#endif #endif
break; break;
case EVENT_CMD_OVERLAY_NEXT: case EVENT_CMD_OVERLAY_NEXT:
@ -1302,7 +1337,9 @@ bool event_command(enum event_command cmd)
event_command(EVENT_CMD_HISTORY_DEINIT); event_command(EVENT_CMD_HISTORY_DEINIT);
if (!settings->history_list_enable) if (!settings->history_list_enable)
return false; return false;
RARCH_LOG("Loading history file: [%s].\n", settings->content_history_path); RARCH_LOG("%s: [%s].\n",
msg_hash_to_str(MSG_LOADING_HISTORY_FILE),
settings->content_history_path);
g_defaults.history = content_playlist_init( g_defaults.history = content_playlist_init(
settings->content_history_path, settings->content_history_path,
settings->content_history_size); settings->content_history_size);
@ -1325,15 +1362,15 @@ bool event_command(enum event_command cmd)
global->core_info = core_info_list_new(); global->core_info = core_info_list_new();
break; break;
case EVENT_CMD_CORE_DEINIT: case EVENT_CMD_CORE_DEINIT:
{ {
struct retro_hw_render_callback *cb = video_driver_callback(); struct retro_hw_render_callback *cb = video_driver_callback();
event_deinit_core(true); event_deinit_core(true);
if (cb) if (cb)
memset(cb, 0, sizeof(*cb)); memset(cb, 0, sizeof(*cb));
break; break;
} }
case EVENT_CMD_CORE_INIT: case EVENT_CMD_CORE_INIT:
if (!event_init_core()) if (!event_init_core())
return false; return false;
@ -1407,7 +1444,7 @@ bool event_command(enum event_command cmd)
case EVENT_CMD_PAUSE_CHECKS: case EVENT_CMD_PAUSE_CHECKS:
if (runloop->is_paused) if (runloop->is_paused)
{ {
RARCH_LOG("Paused.\n"); RARCH_LOG("%s\n", msg_hash_to_str(MSG_PAUSED));
event_command(EVENT_CMD_AUDIO_STOP); event_command(EVENT_CMD_AUDIO_STOP);
if (settings->video.black_frame_insertion) if (settings->video.black_frame_insertion)
@ -1415,7 +1452,7 @@ bool event_command(enum event_command cmd)
} }
else else
{ {
RARCH_LOG("Unpaused.\n"); RARCH_LOG("%s\n", msg_hash_to_str(MSG_UNPAUSED));
event_command(EVENT_CMD_AUDIO_START); event_command(EVENT_CMD_AUDIO_START);
} }
break; break;
@ -1471,7 +1508,8 @@ bool event_command(enum event_command cmd)
dir_list_sort(global->shader_dir.list, false); dir_list_sort(global->shader_dir.list, false);
for (i = 0; i < global->shader_dir.list->size; i++) for (i = 0; i < global->shader_dir.list->size; i++)
RARCH_LOG("Found shader \"%s\"\n", RARCH_LOG("%s \"%s\"\n",
msg_hash_to_str(MSG_FOUND_SHADER),
global->shader_dir.list->elems[i].data); global->shader_dir.list->elems[i].data);
break; break;
case EVENT_CMD_SAVEFILES: case EVENT_CMD_SAVEFILES:
@ -1493,7 +1531,8 @@ bool event_command(enum event_command cmd)
; ;
if (!global->use_sram) if (!global->use_sram)
RARCH_LOG("SRAM will not be saved.\n"); RARCH_LOG("%s\n",
msg_hash_to_str(MSG_SRAM_WILL_NOT_BE_SAVED));
if (global->use_sram) if (global->use_sram)
event_command(EVENT_CMD_AUTOSAVE_INIT); event_command(EVENT_CMD_AUTOSAVE_INIT);
@ -1608,7 +1647,9 @@ bool event_command(enum event_command cmd)
event_check_disk_eject(control); event_check_disk_eject(control);
} }
else else
rarch_main_msg_queue_push("Core does not support Disk Options.", 1, 120, true); rarch_main_msg_queue_push_new(
MSG_CORE_DOES_NOT_SUPPORT_DISK_OPTIONS,
1, 120, true);
break; break;
case EVENT_CMD_DISK_NEXT: case EVENT_CMD_DISK_NEXT:
if (system && system->disk_control.get_num_images) if (system && system->disk_control.get_num_images)
@ -1626,7 +1667,9 @@ bool event_command(enum event_command cmd)
event_check_disk_next(control); event_check_disk_next(control);
} }
else else
rarch_main_msg_queue_push("Core does not support Disk Options.", 1, 120, true); rarch_main_msg_queue_push_new(
MSG_CORE_DOES_NOT_SUPPORT_DISK_OPTIONS,
1, 120, true);
break; break;
case EVENT_CMD_DISK_PREV: case EVENT_CMD_DISK_PREV:
if (system && system->disk_control.get_num_images) if (system && system->disk_control.get_num_images)
@ -1644,7 +1687,9 @@ bool event_command(enum event_command cmd)
event_check_disk_prev(control); event_check_disk_prev(control);
} }
else else
rarch_main_msg_queue_push("Core does not support Disk Options.", 1, 120, true); rarch_main_msg_queue_push_new(
MSG_CORE_DOES_NOT_SUPPORT_DISK_OPTIONS,
1, 120, true);
break; break;
case EVENT_CMD_RUMBLE_STOP: case EVENT_CMD_RUMBLE_STOP:
for (i = 0; i < MAX_USERS; i++) for (i = 0; i < MAX_USERS; i++)
@ -1662,7 +1707,8 @@ bool event_command(enum event_command cmd)
if (!driver->input || !input_driver_grab_mouse(grab_mouse_state)) if (!driver->input || !input_driver_grab_mouse(grab_mouse_state))
return false; return false;
RARCH_LOG("Grab mouse state: %s.\n", RARCH_LOG("%s: %s.\n",
msg_hash_to_str(MSG_GRAB_MOUSE_STATE),
grab_mouse_state ? "yes" : "no"); grab_mouse_state ? "yes" : "no");
video_driver_show_mouse(!grab_mouse_state); video_driver_show_mouse(!grab_mouse_state);
@ -1679,11 +1725,8 @@ bool event_command(enum event_command cmd)
break; break;
case EVENT_CMD_NONE: case EVENT_CMD_NONE:
default: default:
goto error; return false;
} }
return true; return true;
error:
return false;
} }

6
config.features.h
View File

@ -304,10 +304,4 @@ static const bool _avfoundation_supp = false;
#endif #endif
#endif #endif
#ifdef _WIN32
#define RARCH_DEFAULT_CONF_PATH_STR "\n\t\tDefaults to retroarch.cfg in same directory as retroarch.exe.\n\t\tIf a default config is not found, " RETRO_FRONTEND " will attempt to create one."
#else
#define RARCH_DEFAULT_CONF_PATH_STR "\n\t\tBy default looks for config in $XDG_CONFIG_HOME/retroarch/retroarch.cfg,\n\t\t$HOME/.config/retroarch/retroarch.cfg,\n\t\tand $HOME/.retroarch.cfg.\n\t\tIf a default config is not found, " RETRO_FRONTEND " will attempt to create one based on the skeleton config (" GLOBAL_CONFIG_DIR "/retroarch.cfg)."
#endif
#endif #endif

130
configuration.c
View File

@ -455,7 +455,8 @@ static void config_set_defaults(void)
#endif #endif
settings->multimedia.builtin_imageviewer_enable = true; settings->multimedia.builtin_imageviewer_enable = true;
settings->video.scale = scale; settings->video.scale = scale;
settings->video.fullscreen = global->force_fullscreen ? true : fullscreen; settings->video.fullscreen = global->force_fullscreen
? true : fullscreen;
settings->video.windowed_fullscreen = windowed_fullscreen; settings->video.windowed_fullscreen = windowed_fullscreen;
settings->video.monitor_index = monitor_index; settings->video.monitor_index = monitor_index;
settings->video.fullscreen_x = fullscreen_x; settings->video.fullscreen_x = fullscreen_x;
@ -1219,28 +1220,48 @@ static bool config_load_file(const char *path, bool set_defaults)
#ifdef HAVE_MENU #ifdef HAVE_MENU
#ifdef HAVE_THREADS #ifdef HAVE_THREADS
CONFIG_GET_BOOL_BASE(conf, settings, menu.threaded_data_runloop_enable, "threaded_data_runloop_enable"); CONFIG_GET_BOOL_BASE(conf, settings, menu.threaded_data_runloop_enable,
"threaded_data_runloop_enable");
#endif #endif
CONFIG_GET_BOOL_BASE(conf, settings, menu.dpi.override_enable, "dpi_override_enable"); CONFIG_GET_BOOL_BASE(conf, settings, menu.dpi.override_enable,
CONFIG_GET_INT_BASE (conf, settings, menu.dpi.override_value, "dpi_override_value"); "dpi_override_enable");
CONFIG_GET_INT_BASE (conf, settings, menu.dpi.override_value,
"dpi_override_value");
CONFIG_GET_BOOL_BASE(conf, settings, menu.pause_libretro, "menu_pause_libretro"); CONFIG_GET_BOOL_BASE(conf, settings, menu.pause_libretro,
CONFIG_GET_BOOL_BASE(conf, settings, menu.mouse.enable, "menu_mouse_enable"); "menu_pause_libretro");
CONFIG_GET_BOOL_BASE(conf, settings, menu.pointer.enable, "menu_pointer_enable"); CONFIG_GET_BOOL_BASE(conf, settings, menu.mouse.enable,
CONFIG_GET_BOOL_BASE(conf, settings, menu.timedate_enable, "menu_timedate_enable"); "menu_mouse_enable");
CONFIG_GET_BOOL_BASE(conf, settings, menu.core_enable, "menu_core_enable"); CONFIG_GET_BOOL_BASE(conf, settings, menu.pointer.enable,
CONFIG_GET_BOOL_BASE(conf, settings, menu.dynamic_wallpaper_enable, "menu_dynamic_wallpaper_enable"); "menu_pointer_enable");
CONFIG_GET_BOOL_BASE(conf, settings, menu.boxart_enable, "menu_boxart_enable"); CONFIG_GET_BOOL_BASE(conf, settings, menu.timedate_enable,
CONFIG_GET_BOOL_BASE(conf, settings, menu.navigation.wraparound.horizontal_enable, "menu_navigation_wraparound_horizontal_enable"); "menu_timedate_enable");
CONFIG_GET_BOOL_BASE(conf, settings, menu.navigation.wraparound.vertical_enable, "menu_navigation_wraparound_vertical_enable"); CONFIG_GET_BOOL_BASE(conf, settings, menu.core_enable,
CONFIG_GET_BOOL_BASE(conf, settings, menu.navigation.browser.filter.supported_extensions_enable, "menu_navigation_browser_filter_supported_extensions_enable"); "menu_core_enable");
CONFIG_GET_BOOL_BASE(conf, settings, menu.collapse_subgroups_enable, "menu_collapse_subgroups_enable"); CONFIG_GET_BOOL_BASE(conf, settings, menu.dynamic_wallpaper_enable,
CONFIG_GET_BOOL_BASE(conf, settings, menu.show_advanced_settings, "menu_show_advanced_settings"); "menu_dynamic_wallpaper_enable");
CONFIG_GET_HEX_BASE(conf, settings, menu.entry_normal_color, "menu_entry_normal_color"); CONFIG_GET_BOOL_BASE(conf, settings, menu.boxart_enable,
CONFIG_GET_HEX_BASE(conf, settings, menu.entry_hover_color, "menu_entry_hover_color"); "menu_boxart_enable");
CONFIG_GET_HEX_BASE(conf, settings, menu.title_color, "menu_title_color"); CONFIG_GET_BOOL_BASE(conf, settings, menu.navigation.wraparound.horizontal_enable,
config_get_path(conf, "menu_wallpaper", settings->menu.wallpaper, sizeof(settings->menu.wallpaper)); "menu_navigation_wraparound_horizontal_enable");
CONFIG_GET_BOOL_BASE(conf, settings, menu.navigation.wraparound.vertical_enable,
"menu_navigation_wraparound_vertical_enable");
CONFIG_GET_BOOL_BASE(conf, settings,
menu.navigation.browser.filter.supported_extensions_enable,
"menu_navigation_browser_filter_supported_extensions_enable");
CONFIG_GET_BOOL_BASE(conf, settings, menu.collapse_subgroups_enable,
"menu_collapse_subgroups_enable");
CONFIG_GET_BOOL_BASE(conf, settings, menu.show_advanced_settings,
"menu_show_advanced_settings");
CONFIG_GET_HEX_BASE(conf, settings, menu.entry_normal_color,
"menu_entry_normal_color");
CONFIG_GET_HEX_BASE(conf, settings, menu.entry_hover_color,
"menu_entry_hover_color");
CONFIG_GET_HEX_BASE(conf, settings, menu.title_color,
"menu_title_color");
config_get_path(conf, "menu_wallpaper",
settings->menu.wallpaper, sizeof(settings->menu.wallpaper));
if (!strcmp(settings->menu.wallpaper, "default")) if (!strcmp(settings->menu.wallpaper, "default"))
*settings->menu.wallpaper = '\0'; *settings->menu.wallpaper = '\0';
#endif #endif
@ -1463,16 +1484,24 @@ static bool config_load_file(const char *path, bool set_defaults)
} }
} }
config_get_path(conf, "input_remapping_path", settings->input.remapping_path, sizeof(settings->input.remapping_path)); config_get_path(conf, "input_remapping_path", settings->input.remapping_path,
sizeof(settings->input.remapping_path));
config_get_path(conf, "resampler_directory", settings->resampler_directory, sizeof(settings->resampler_directory)); config_get_path(conf, "resampler_directory", settings->resampler_directory,
config_get_path(conf, "extraction_directory", settings->extraction_directory, sizeof(settings->extraction_directory)); sizeof(settings->resampler_directory));
config_get_path(conf, "input_remapping_directory", settings->input_remapping_directory, sizeof(settings->input_remapping_directory)); config_get_path(conf, "extraction_directory", settings->extraction_directory,
config_get_path(conf, "core_assets_directory", settings->core_assets_directory, sizeof(settings->core_assets_directory)); sizeof(settings->extraction_directory));
config_get_path(conf, "assets_directory", settings->assets_directory, sizeof(settings->assets_directory)); config_get_path(conf, "input_remapping_directory", settings->input_remapping_directory,
config_get_path(conf, "dynamic_wallpapers_directory", settings->dynamic_wallpapers_directory, sizeof(settings->dynamic_wallpapers_directory)); sizeof(settings->input_remapping_directory));
config_get_path(conf, "boxarts_directory", settings->boxarts_directory, sizeof(settings->boxarts_directory)); config_get_path(conf, "core_assets_directory", settings->core_assets_directory,
config_get_path(conf, "playlist_directory", settings->playlist_directory, sizeof(settings->playlist_directory)); sizeof(settings->core_assets_directory));
config_get_path(conf, "assets_directory", settings->assets_directory,
sizeof(settings->assets_directory));
config_get_path(conf, "dynamic_wallpapers_directory", settings->dynamic_wallpapers_directory,
sizeof(settings->dynamic_wallpapers_directory));
config_get_path(conf, "boxarts_directory", settings->boxarts_directory,
sizeof(settings->boxarts_directory));
config_get_path(conf, "playlist_directory", settings->playlist_directory,
sizeof(settings->playlist_directory));
if (!strcmp(settings->core_assets_directory, "default")) if (!strcmp(settings->core_assets_directory, "default"))
*settings->core_assets_directory = '\0'; *settings->core_assets_directory = '\0';
if (!strcmp(settings->assets_directory, "default")) if (!strcmp(settings->assets_directory, "default"))
@ -1484,10 +1513,12 @@ static bool config_load_file(const char *path, bool set_defaults)
if (!strcmp(settings->playlist_directory, "default")) if (!strcmp(settings->playlist_directory, "default"))
*settings->playlist_directory = '\0'; *settings->playlist_directory = '\0';
#ifdef HAVE_MENU #ifdef HAVE_MENU
config_get_path(conf, "rgui_browser_directory", settings->menu_content_directory, sizeof(settings->menu_content_directory)); config_get_path(conf, "rgui_browser_directory", settings->menu_content_directory,
sizeof(settings->menu_content_directory));
if (!strcmp(settings->menu_content_directory, "default")) if (!strcmp(settings->menu_content_directory, "default"))
*settings->menu_content_directory = '\0'; *settings->menu_content_directory = '\0';
config_get_path(conf, "rgui_config_directory", settings->menu_config_directory, sizeof(settings->menu_config_directory)); config_get_path(conf, "rgui_config_directory", settings->menu_config_directory,
sizeof(settings->menu_config_directory));
if (!strcmp(settings->menu_config_directory, "default")) if (!strcmp(settings->menu_config_directory, "default"))
*settings->menu_config_directory = '\0'; *settings->menu_config_directory = '\0';
CONFIG_GET_BOOL_BASE(conf, settings, menu_show_start_screen, "rgui_show_start_screen"); CONFIG_GET_BOOL_BASE(conf, settings, menu_show_start_screen, "rgui_show_start_screen");
@ -1501,8 +1532,10 @@ static bool config_load_file(const char *path, bool set_defaults)
CONFIG_GET_INT_BASE(conf, settings, archive.mode, "archive_mode"); CONFIG_GET_INT_BASE(conf, settings, archive.mode, "archive_mode");
config_get_path(conf, "recording_output_directory", global->record.output_dir, sizeof(global->record.output_dir)); config_get_path(conf, "recording_output_directory", global->record.output_dir,
config_get_path(conf, "recording_config_directory", global->record.config_dir, sizeof(global->record.config_dir)); sizeof(global->record.output_dir));
config_get_path(conf, "recording_config_directory", global->record.config_dir,
sizeof(global->record.config_dir));
#ifdef HAVE_OVERLAY #ifdef HAVE_OVERLAY
config_get_path(conf, "overlay_directory", global->overlay_dir, sizeof(global->overlay_dir)); config_get_path(conf, "overlay_directory", global->overlay_dir, sizeof(global->overlay_dir));
@ -1543,7 +1576,8 @@ static bool config_load_file(const char *path, bool set_defaults)
if (settings->fastforward_ratio <= 0.0f) if (settings->fastforward_ratio <= 0.0f)
settings->fastforward_ratio = 1.0f; settings->fastforward_ratio = 1.0f;
CONFIG_GET_BOOL_BASE(conf, settings, fastforward_ratio_throttle_enable, "fastforward_ratio_throttle_enable"); CONFIG_GET_BOOL_BASE(conf, settings, fastforward_ratio_throttle_enable,
"fastforward_ratio_throttle_enable");
CONFIG_GET_BOOL_BASE(conf, settings, pause_nonactive, "pause_nonactive"); CONFIG_GET_BOOL_BASE(conf, settings, pause_nonactive, "pause_nonactive");
CONFIG_GET_INT_BASE(conf, settings, autosave_interval, "autosave_interval"); CONFIG_GET_INT_BASE(conf, settings, autosave_interval, "autosave_interval");
@ -2182,8 +2216,6 @@ static void save_keybind(config_file_t *conf, const char *prefix,
save_keybind_axis(conf, prefix, base, bind); save_keybind_axis(conf, prefix, base, bind);
} }
/** /**
* save_keybinds_user: * save_keybinds_user:
* @conf : pointer to config file object * @conf : pointer to config file object
@ -2366,7 +2398,8 @@ bool config_save_file(const char *path)
config_set_string(conf, "location_driver", settings->location.driver); config_set_string(conf, "location_driver", settings->location.driver);
#ifdef HAVE_MENU #ifdef HAVE_MENU
#ifdef HAVE_THREADS #ifdef HAVE_THREADS
config_set_bool(conf,"threaded_data_runloop_enable", settings->menu.threaded_data_runloop_enable); config_set_bool(conf,"threaded_data_runloop_enable",
settings->menu.threaded_data_runloop_enable);
#endif #endif
config_set_bool(conf, "dpi_override_enable", settings->menu.dpi.override_enable); config_set_bool(conf, "dpi_override_enable", settings->menu.dpi.override_enable);
@ -2377,7 +2410,8 @@ bool config_save_file(const char *path)
config_set_bool(conf,"menu_pointer_enable", settings->menu.pointer.enable); config_set_bool(conf,"menu_pointer_enable", settings->menu.pointer.enable);
config_set_bool(conf,"menu_timedate_enable", settings->menu.timedate_enable); config_set_bool(conf,"menu_timedate_enable", settings->menu.timedate_enable);
config_set_bool(conf,"menu_core_enable", settings->menu.core_enable); config_set_bool(conf,"menu_core_enable", settings->menu.core_enable);
config_set_bool(conf,"menu_dynamic_wallpaper_enable", settings->menu.dynamic_wallpaper_enable); config_set_bool(conf,"menu_dynamic_wallpaper_enable",
settings->menu.dynamic_wallpaper_enable);
config_set_bool(conf,"menu_boxart_enable", settings->menu.boxart_enable); config_set_bool(conf,"menu_boxart_enable", settings->menu.boxart_enable);
config_set_path(conf, "menu_wallpaper", settings->menu.wallpaper); config_set_path(conf, "menu_wallpaper", settings->menu.wallpaper);
#endif #endif
@ -2401,9 +2435,12 @@ bool config_save_file(const char *path)
config_set_string(conf, "audio_device", settings->audio.device); config_set_string(conf, "audio_device", settings->audio.device);
config_set_string(conf, "video_filter", settings->video.softfilter_plugin); config_set_string(conf, "video_filter", settings->video.softfilter_plugin);
config_set_string(conf, "audio_dsp_plugin", settings->audio.dsp_plugin); config_set_string(conf, "audio_dsp_plugin", settings->audio.dsp_plugin);
config_set_string(conf, "core_updater_buildbot_url", settings->network.buildbot_url); config_set_string(conf, "core_updater_buildbot_url",
config_set_string(conf, "core_updater_buildbot_assets_url", settings->network.buildbot_assets_url); settings->network.buildbot_url);
config_set_bool(conf, "core_updater_auto_extract_archive", settings->network.buildbot_auto_extract_archive); config_set_string(conf, "core_updater_buildbot_assets_url",
settings->network.buildbot_assets_url);
config_set_bool(conf, "core_updater_auto_extract_archive",
settings->network.buildbot_auto_extract_archive);
config_set_string(conf, "camera_device", settings->camera.device); config_set_string(conf, "camera_device", settings->camera.device);
config_set_bool(conf, "camera_allow", settings->camera.allow); config_set_bool(conf, "camera_allow", settings->camera.allow);
config_set_bool(conf, "audio_rate_control", settings->audio.rate_control); config_set_bool(conf, "audio_rate_control", settings->audio.rate_control);
@ -2484,7 +2521,8 @@ bool config_save_file(const char *path)
settings->menu.navigation.wraparound.horizontal_enable); settings->menu.navigation.wraparound.horizontal_enable);
config_set_bool(conf, "menu_navigation_wraparound_vertical_enable", config_set_bool(conf, "menu_navigation_wraparound_vertical_enable",
settings->menu.navigation.wraparound.vertical_enable); settings->menu.navigation.wraparound.vertical_enable);
config_set_bool(conf, "menu_navigation_browser_filter_supported_extensions_enable", config_set_bool(conf,
"menu_navigation_browser_filter_supported_extensions_enable",
settings->menu.navigation.browser.filter.supported_extensions_enable); settings->menu.navigation.browser.filter.supported_extensions_enable);
config_set_bool(conf, "menu_collapse_subgroups_enable", config_set_bool(conf, "menu_collapse_subgroups_enable",
settings->menu.collapse_subgroups_enable); settings->menu.collapse_subgroups_enable);
@ -2562,7 +2600,8 @@ bool config_save_file(const char *path)
settings->history_list_enable); settings->history_list_enable);
config_set_float(conf, "fastforward_ratio", settings->fastforward_ratio); config_set_float(conf, "fastforward_ratio", settings->fastforward_ratio);
config_set_bool(conf, "fastforward_ratio_throttle_enable", settings->fastforward_ratio_throttle_enable); config_set_bool(conf, "fastforward_ratio_throttle_enable",
settings->fastforward_ratio_throttle_enable);
config_set_float(conf, "slowmotion_ratio", settings->slowmotion_ratio); config_set_float(conf, "slowmotion_ratio", settings->slowmotion_ratio);
config_set_bool(conf, "config_save_on_exit", config_set_bool(conf, "config_save_on_exit",
@ -2620,7 +2659,8 @@ bool config_save_file(const char *path)
config_set_bool(conf, "log_verbosity", global->verbosity); config_set_bool(conf, "log_verbosity", global->verbosity);
config_set_bool(conf, "perfcnt_enable", global->perfcnt_enable); config_set_bool(conf, "perfcnt_enable", global->perfcnt_enable);
config_set_bool(conf, "core_set_supports_no_game_enable", settings->core.set_supports_no_game_enable); config_set_bool(conf, "core_set_supports_no_game_enable",
settings->core.set_supports_no_game_enable);
config_set_int(conf, "archive_mode", settings->archive.mode); config_set_int(conf, "archive_mode", settings->archive.mode);

61
content.c
View File

@ -33,8 +33,8 @@
#include <compat/strl.h> #include <compat/strl.h>
#include <file/file_path.h> #include <file/file_path.h>
#include <file/file_extract.h> #include <file/file_extract.h>
#include <rhash.h>
#include "msg_hash.h"
#include "content.h" #include "content.h"
#include "file_ops.h" #include "file_ops.h"
#include "general.h" #include "general.h"
@ -61,7 +61,8 @@ static bool read_content_file(unsigned i, const char *path, void **buf,
uint8_t *ret_buf = NULL; uint8_t *ret_buf = NULL;
global_t *global = global_get_ptr(); global_t *global = global_get_ptr();
RARCH_LOG("Loading content file: %s.\n", path); RARCH_LOG("%s: %s.\n",
msg_hash_to_str(MSG_LOADING_CONTENT_FILE), path);
if (!read_file(path, (void**) &ret_buf, length)) if (!read_file(path, (void**) &ret_buf, length))
return false; return false;
@ -149,7 +150,9 @@ bool save_state(const char *path)
void *data = NULL; void *data = NULL;
size_t size = pretro_serialize_size(); size_t size = pretro_serialize_size();
RARCH_LOG("Saving state: \"%s\".\n", path); RARCH_LOG("%s: \"%s\".\n",
msg_hash_to_str(MSG_SAVING_STATE),
path);
if (size == 0) if (size == 0)
return false; return false;
@ -157,19 +160,21 @@ bool save_state(const char *path)
data = malloc(size); data = malloc(size);
if (!data) if (!data)
{
RARCH_ERR("Failed to allocate memory for save state buffer.\n");
return false; return false;
}
RARCH_LOG("State size: %d bytes.\n", (int)size); RARCH_LOG("%s: %d %s.\n",
msg_hash_to_str(MSG_STATE_SIZE),
(int)size,
msg_hash_to_str(MSG_BYTES));
ret = pretro_serialize(data, size); ret = pretro_serialize(data, size);
if (ret) if (ret)
ret = write_file(path, data, size); ret = write_file(path, data, size);
if (!ret) if (!ret)
RARCH_ERR("Failed to save state to \"%s\".\n", path); RARCH_ERR("%s \"%s\".\n",
msg_hash_to_str(MSG_FAILED_TO_SAVE_STATE_TO),
path);
free(data); free(data);
@ -195,20 +200,28 @@ bool load_state(const char *path)
global_t *global = global_get_ptr(); global_t *global = global_get_ptr();
bool ret = read_file(path, &buf, &size); bool ret = read_file(path, &buf, &size);
RARCH_LOG("Loading state: \"%s\".\n", path); RARCH_LOG("%s: \"%s\".\n",
msg_hash_to_str(MSG_LOADING_STATE),
path);
if (!ret || size < 0) if (!ret || size < 0)
{ {
RARCH_ERR("Failed to load state from \"%s\".\n", path); RARCH_ERR("%s \"%s\".\n",
msg_hash_to_str(MSG_FAILED_TO_LOAD_STATE),
path);
return false; return false;
} }
RARCH_LOG("State size: %u bytes.\n", (unsigned)size); RARCH_LOG("%s: %u %s.\n",
msg_hash_to_str(MSG_STATE_SIZE),
(unsigned)size,
msg_hash_to_str(MSG_BYTES));
if (settings->block_sram_overwrite && global->savefiles if (settings->block_sram_overwrite && global->savefiles
&& global->savefiles->size) && global->savefiles->size)
{ {
RARCH_LOG("Blocking SRAM overwrite.\n"); RARCH_LOG("%s.\n",
msg_hash_to_str(MSG_BLOCKING_SRAM_OVERWRITE));
blocks = (struct sram_block*) blocks = (struct sram_block*)
calloc(global->savefiles->size, sizeof(*blocks)); calloc(global->savefiles->size, sizeof(*blocks));
@ -285,8 +298,11 @@ void load_ram_file(const char *path, int type)
{ {
if (rc > (ssize_t)size) if (rc > (ssize_t)size)
{ {
RARCH_WARN("SRAM is larger than implementation expects, doing partial load (truncating %u bytes to %u).\n", RARCH_WARN("SRAM is larger than implementation expects, doing partial load (truncating %u %s %s %u).\n",
(unsigned)rc, (unsigned)size); (unsigned)rc,
msg_hash_to_str(MSG_BYTES),
msg_hash_to_str(MSG_TO),
(unsigned)size);
rc = size; rc = size;
} }
memcpy(data, buf, rc); memcpy(data, buf, rc);
@ -318,13 +334,16 @@ void save_ram_file(const char *path, int type)
if (!write_file(path, data, size)) if (!write_file(path, data, size))
{ {
RARCH_ERR("Failed to save SRAM.\n"); RARCH_ERR("%s.\n",
msg_hash_to_str(MSG_FAILED_TO_SAVE_SRAM));
RARCH_WARN("Attempting to recover ...\n"); RARCH_WARN("Attempting to recover ...\n");
dump_to_file_desperate(data, size, type); dump_to_file_desperate(data, size, type);
return; return;
} }
RARCH_LOG("Saved successfully to \"%s\".\n", path); RARCH_LOG("%s \"%s\".\n",
msg_hash_to_str(MSG_SAVED_SUCCESSFULLY_TO),
path);
} }
static bool load_content_dont_need_fullpath( static bool load_content_dont_need_fullpath(
@ -344,7 +363,9 @@ static bool load_content_dont_need_fullpath(
if (!ret || len < 0) if (!ret || len < 0)
{ {
RARCH_ERR("Could not read content file \"%s\".\n", path); RARCH_ERR("%s \"%s\".\n",
msg_hash_to_str(MSG_COULD_NOT_READ_CONTENT_FILE),
path);
return false; return false;
} }
@ -402,7 +423,9 @@ static bool load_content_need_fullpath(
if (!ret || len < 0) if (!ret || len < 0)
{ {
RARCH_ERR("Could not read content file \"%s\".\n", path); RARCH_ERR("%s \"%s\".\n",
msg_hash_to_str(MSG_COULD_NOT_READ_CONTENT_FILE),
path);
return false; return false;
} }
@ -488,7 +511,7 @@ static bool load_content(const struct retro_subsystem_info *special,
ret = pretro_load_game(*content->elems[0].data ? info : NULL); ret = pretro_load_game(*content->elems[0].data ? info : NULL);
if (!ret) if (!ret)
RARCH_ERR("Failed to load content.\n"); RARCH_ERR("%s.\n", msg_hash_to_str(MSG_FAILED_TO_LOAD_CONTENT));
end: end:
for (i = 0; i < content->size; i++) for (i = 0; i < content->size; i++)

6
database_info.c
View File

@ -16,13 +16,13 @@
*/ */
#include <file/file_extract.h> #include <file/file_extract.h>
#include <rhash.h>
#include "file_ext.h" #include "file_ext.h"
#include "dir_list_special.h" #include "dir_list_special.h"
#include "database_info.h" #include "database_info.h"
#include "file_ops.h" #include "file_ops.h"
#include "msg_hash.h"
#include "general.h" #include "general.h"
#include "runloop.h" #include "runloop.h"
@ -117,7 +117,7 @@ int database_info_build_query(char *s, size_t len,
database_info_build_query_add_bracket_open(s, len); database_info_build_query_add_bracket_open(s, len);
value = djb2_calculate(label); value = msg_hash_calculate(label);
switch (value) switch (value)
{ {
@ -247,7 +247,7 @@ static int database_cursor_iterate(libretrodb_cursor_t *cur,
continue; continue;
str = key->val.string.buff; str = key->val.string.buff;
value = djb2_calculate(str); value = msg_hash_calculate(str);
switch (value) switch (value)
{ {

5
driver.c
View File

@ -14,11 +14,10 @@
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
*/ */
#include <rhash.h>
#include "driver.h" #include "driver.h"
#include "general.h" #include "general.h"
#include "retroarch.h" #include "retroarch.h"
#include "msg_hash.h"
#include "compat/posix_string.h" #include "compat/posix_string.h"
#include "gfx/video_monitor.h" #include "gfx/video_monitor.h"
#include "audio/audio_monitor.h" #include "audio/audio_monitor.h"
@ -90,7 +89,7 @@ static const void *find_driver_nonempty(const char *label, int i,
char *s, size_t len) char *s, size_t len)
{ {
const void *drv = NULL; const void *drv = NULL;
uint32_t hash = djb2_calculate(label); uint32_t hash = msg_hash_calculate(label);
switch (hash) switch (hash)
{ {

12
dynamic.c
View File

@ -44,6 +44,7 @@
#include "runloop.h" #include "runloop.h"
#include "configuration.h" #include "configuration.h"
#include "general.h" #include "general.h"
#include "msg_hash.h"
#include "input/input_sensor.h" #include "input/input_sensor.h"
@ -311,7 +312,7 @@ static void load_symbols(enum rarch_core_type type)
{ {
/* Try to verify that -lretro was not linked in from other modules /* Try to verify that -lretro was not linked in from other modules
* since loading it dynamically and with -l will fail hard. */ * since loading it dynamically and with -l will fail hard. */
RARCH_ERR("Serious problem. RetroArch wants to load libretro dyamically, but it is already linked.\n"); RARCH_ERR("Serious problem. RetroArch wants to load libretro cores dyamically, but it is already linked.\n");
RARCH_ERR("This could happen if other modules RetroArch depends on link against libretro directly.\n"); RARCH_ERR("This could happen if other modules RetroArch depends on link against libretro directly.\n");
RARCH_ERR("Proceeding could cause a crash. Aborting ...\n"); RARCH_ERR("Proceeding could cause a crash. Aborting ...\n");
rarch_fail(1, "init_libretro_sym()"); rarch_fail(1, "init_libretro_sym()");
@ -319,7 +320,7 @@ static void load_symbols(enum rarch_core_type type)
if (!*settings->libretro) if (!*settings->libretro)
{ {
RARCH_ERR("RetroArch is built for dynamic libretro, but libretro_path is not set. Cannot continue.\n"); RARCH_ERR("RetroArch is built for dynamic libretro cores, but libretro_path is not set. Cannot continue.\n");
rarch_fail(1, "init_libretro_sym()"); rarch_fail(1, "init_libretro_sym()");
} }
@ -329,12 +330,12 @@ static void load_symbols(enum rarch_core_type type)
path_resolve_realpath(settings->libretro, path_resolve_realpath(settings->libretro,
sizeof(settings->libretro)); sizeof(settings->libretro));
RARCH_LOG("Loading dynamic libretro from: \"%s\"\n", RARCH_LOG("Loading dynamic libretro core from: \"%s\"\n",
settings->libretro); settings->libretro);
lib_handle = dylib_load(settings->libretro); lib_handle = dylib_load(settings->libretro);
if (!lib_handle) if (!lib_handle)
{ {
RARCH_ERR("Failed to open dynamic library: \"%s\"\n", RARCH_ERR("Failed to open libretro core: \"%s\"\n",
settings->libretro); settings->libretro);
rarch_fail(1, "load_dynamic()"); rarch_fail(1, "load_dynamic()");
} }
@ -504,7 +505,8 @@ void libretro_get_current_core_pathname(char *name, size_t size)
return; return;
pretro_get_system_info(&info); pretro_get_system_info(&info);
id = info.library_name ? info.library_name : "Unknown"; id = info.library_name ? info.library_name :
msg_hash_to_str(MSG_UNKNOWN);
if (!id || strlen(id) >= size) if (!id || strlen(id) >= size)
{ {

11
gfx/drivers/gl.c
View File

@ -1655,11 +1655,14 @@ static bool gl_frame(void *data, const void *frame,
gl_set_prev_texture(gl, &gl->tex_info); gl_set_prev_texture(gl, &gl->tex_info);
#if defined(HAVE_MENU) #if defined(HAVE_MENU)
if (menu_driver_alive())
menu_driver_frame();
if (gl->menu_texture_enable) if (gl->menu_texture_enable)
gl_draw_texture(gl); {
if (menu_driver_alive())
menu_driver_frame();
if (gl->menu_texture_enable)
gl_draw_texture(gl);
}
#endif #endif
if (msg && driver->font_osd_driver && driver->font_osd_data) if (msg && driver->font_osd_driver && driver->font_osd_data)

12
input/drivers/android_input.c
View File

@ -278,11 +278,7 @@ static bool android_input_lookup_name(char *buf,
goto error; goto error;
CALL_INT_METHOD(env, *vendorId, device, getVendorId); CALL_INT_METHOD(env, *vendorId, device, getVendorId);
if (!*vendorId)
{
RARCH_ERR("Failed to find vendor id for device ID: %d\n", id);
goto error;
}
RARCH_LOG("device vendor id: %d\n", *vendorId); RARCH_LOG("device vendor id: %d\n", *vendorId);
getProductId = NULL; getProductId = NULL;
@ -292,11 +288,7 @@ static bool android_input_lookup_name(char *buf,
*productId = 0; *productId = 0;
CALL_INT_METHOD(env, *productId, device, getProductId); CALL_INT_METHOD(env, *productId, device, getProductId);
if (!*productId)
{
RARCH_ERR("Failed to find product id for device ID: %d\n", id);
goto error;
}
RARCH_LOG("device product id: %d\n", *productId); RARCH_LOG("device product id: %d\n", *productId);
return true; return true;

44
intl/english.h
View File

@ -17,8 +17,6 @@
#ifndef __INTL_ENGLISH_H #ifndef __INTL_ENGLISH_H
#define __INTL_ENGLISH_H #define __INTL_ENGLISH_H
#define RETRO_FRONTEND "RetroArch"
#define RETRO_LBL_JOYPAD_B "RetroPad B Button" #define RETRO_LBL_JOYPAD_B "RetroPad B Button"
#define RETRO_LBL_JOYPAD_Y "RetroPad Y Button" #define RETRO_LBL_JOYPAD_Y "RetroPad Y Button"
#define RETRO_LBL_JOYPAD_SELECT "RetroPad Select Button" #define RETRO_LBL_JOYPAD_SELECT "RetroPad Select Button"
@ -81,46 +79,4 @@
#define RETRO_LBL_GRAB_MOUSE_TOGGLE "Grab mouse toggle" #define RETRO_LBL_GRAB_MOUSE_TOGGLE "Grab mouse toggle"
#define RETRO_LBL_MENU_TOGGLE "Menu toggle" #define RETRO_LBL_MENU_TOGGLE "Menu toggle"
#define TERM_STR "\n"
#define RETRO_MSG_INIT_RECORDING_SKIPPED "Using libretro dummy core. Skipping recording."
#define RETRO_MSG_INIT_RECORDING_FAILED "Failed to start recording."
#define RETRO_MSG_TAKE_SCREENSHOT "Taking screenshot."
#define RETRO_MSG_TAKE_SCREENSHOT_FAILED "Failed to take screenshot."
#define RETRO_MSG_TAKE_SCREENSHOT_ERROR "Cannot take screenshot. GPU rendering is used and read_viewport is not supported."
#define RETRO_MSG_AUDIO_WRITE_FAILED "Audio backend failed to write. Will continue without sound."
#define RETRO_MSG_MOVIE_STARTED_INIT_NETPLAY_FAILED "Movie playback has started. Cannot start netplay."
#define RETRO_MSG_INIT_NETPLAY_FAILED "Failed to initialize netplay."
#define RETRO_MSG_INIT_AUTOSAVE_FAILED "Could not initialize autosave."
#define RETRO_MSG_REWINDING "Rewinding."
#define RETRO_MSG_REWIND_REACHED_END "Reached end of rewind buffer."
#define RETRO_MSG_MOVIE_RECORD_STOPPING "Stopping movie record."
#define RETRO_MSG_MOVIE_PLAYBACK_ENDED "Movie playback ended."
#define RETRO_MSG_LIBRETRO_ABI_BREAK RETRO_FRONTEND " is compiled against a different version of libretro than this libretro implementation."
#define RETRO_MSG_RESETTING_CONTENT "Resetting content."
#define RETRO_MSG_REWIND_INIT "Initializing rewind buffer with size: "
#define RETRO_MSG_REWIND_INIT_FAILED "Failed to initialize rewind buffer. Rewinding will be disabled"
#define RETRO_MSG_REWIND_INIT_FAILED_NO_SAVESTATES "Implementation does not support save states. Cannot use rewind."
#define RETRO_MSG_REWIND_INIT_FAILED_THREADED_AUDIO "Implementation uses threaded audio. Cannot use rewind."
#define RETRO_LOG_INIT_RECORDING_SKIPPED RETRO_MSG_INIT_RECORDING_SKIPPED TERM_STR
#define RETRO_LOG_INIT_RECORDING_FAILED RETRO_MSG_INIT_RECORDING_FAILED TERM_STR
#define RETRO_LOG_TAKE_SCREENSHOT RETRO_MSG_TAKE_SCREENSHOT TERM_STR
#define RETRO_LOG_TAKE_SCREENSHOT_FAILED RETRO_MSG_TAKE_SCREENSHOT_FAILED TERM_STR
#define RETRO_LOG_TAKE_SCREENSHOT_ERROR RETRO_MSG_TAKE_SCREENSHOT_ERROR TERM_STR
#define RETRO_LOG_AUDIO_WRITE_FAILED RETRO_MSG_AUDIO_WRITE_FAILED TERM_STR
#define RETRO_LOG_MOVIE_STARTED_INIT_NETPLAY_FAILED RETRO_MSG_MOVIE_STARTED_INIT_NETPLAY_FAILED TERM_STR
#define RETRO_LOG_INIT_NETPLAY_FAILED RETRO_MSG_INIT_NETPLAY_FAILED TERM_STR
#define RETRO_LOG_INIT_AUTOSAVE_FAILED RETRO_MSG_INIT_AUTOSAVE_FAILED TERM_STR
#define RETRO_LOG_REWINDING RETRO_MSG_REWINDING TERM_STR
#define RETRO_LOG_REWIND_REACHED_END RETRO_MSG_REWIND_REACHED_END TERM_STR
#define RETRO_LOG_MOVIE_RECORD_STOPPING RETRO_MSG_MOVIE_RECORD_STOPPING TERM_STR
#define RETRO_LOG_MOVIE_PLAYBACK_ENDED RETRO_MSG_MOVIE_PLAYBACK_ENDED TERM_STR
#define RETRO_LOG_LIBRETRO_ABI_BREAK RETRO_MSG_LIBRETRO_ABI_BREAK RETRO_FRONTEND TERM_STR
#define RETRO_LOG_RESETTING_CONTENT RETRO_MSG_RESETTING_CONTENT TERM_STR
#define RETRO_LOG_REWIND_INIT RETRO_MSG_REWIND_INIT TERM_STR
#define RETRO_LOG_REWIND_INIT_FAILED RETRO_MSG_REWIND_INIT_FAILED TERM_STR
#define RETRO_LOG_REWIND_INIT_FAILED_NO_SAVESTATES RETRO_MSG_REWIND_INIT_FAILED_NO_SAVESTATES TERM_STR
#define RETRO_LOG_REWIND_INIT_FAILED_THREADED_AUDIO RETRO_MSG_REWIND_INIT_FAILED_THREADED_AUDIO TERM_STR
#endif #endif

119
intl/msg_hash_pt.c
View File

@ -20,7 +20,124 @@ const char *msg_hash_to_str_pt(uint32_t hash)
{ {
switch (hash) switch (hash)
{ {
case 0: case MSG_UNKNOWN:
return "Desconhecido";
case MSG_RECEIVED:
return "recebido";
case MSG_UNRECOGNIZED_COMMAND:
return "Comando desconhecido";
case MSG_SENDING_COMMAND:
return "Enviando comando";
case MSG_GOT_INVALID_DISK_INDEX:
return "Índice de disco inválido.";
case MSG_FAILED_TO_REMOVE_DISK_FROM_TRAY:
return "Falha ao remover disco da bandeja.";
case MSG_REMOVED_DISK_FROM_TRAY:
return "Disco removido da bandeja.";
case MSG_VIRTUAL_DISK_TRAY:
return "bandeja de disco virtual.";
case MSG_FAILED_TO:
return "Falha ao";
case MSG_TO:
return "para";
case MSG_SAVING_RAM_TYPE:
return "Salvando tipo de RAM";
case MSG_SAVING_STATE:
return "Salvando estado";
case MSG_LOADING_STATE:
return "Carregando estado";
case MSG_FAILED_TO_LOAD_MOVIE_FILE:
return "Falha ao carregar vídeo";
case MSG_FAILED_TO_LOAD_CONTENT:
return "Falha ao carregar conteúdo";
case MSG_COULD_NOT_READ_CONTENT_FILE:
return "Incapaz de ler arquivo de conteúdo";
case MSG_GRAB_MOUSE_STATE:
return "Obter estado do mouse";
case MSG_PAUSED:
return "Pausado.";
case MSG_UNPAUSED:
return "Despausado.";
case MSG_FAILED_TO_LOAD_OVERLAY:
return "Falha ao carregar overlay.";
case MSG_FAILED_TO_UNMUTE_AUDIO:
return "Falha ao desativar mudo.";
case MSG_AUDIO_MUTED:
return "Áudio mudo.";
case MSG_AUDIO_UNMUTED:
return "Áudio normal.";
case MSG_RESET:
return "Reiniciar";
case MSG_FAILED_TO_LOAD_STATE:
return "Falha ao carregar estado de";
case MSG_FAILED_TO_SAVE_STATE_TO:
return "Falha ao salvar estado em";
case MSG_FAILED_TO_SAVE_SRAM:
return "Falha ao salvar SRAM";
case MSG_STATE_SIZE:
return "Tamanho do estado";
case MSG_BLOCKING_SRAM_OVERWRITE:
return "Bloqueando Sobrescrição de SRAM";
case MSG_CORE_DOES_NOT_SUPPORT_SAVESTATES:
return "O core não suporta savestates.";
case MSG_SAVED_STATE_TO_SLOT:
return "Estado salvo no slot";
case MSG_SAVED_SUCCESSFULLY_TO:
return "Salvo com sucesso em";
case MSG_BYTES:
return "bytes";
case MSG_CONFIG_DIRECTORY_NOT_SET:
return "Diretório de configurações não definido. Incapaz de salvar.";
case MSG_SKIPPING_SRAM_LOAD:
return "Ignorando carregamento de SRAM.";
case MSG_APPENDED_DISK:
return "Disco anexado";
case MSG_STARTING_MOVIE_PLAYBACK:
return "Iniciando reprodução de vídeo.";
case MSG_FAILED_TO_REMOVE_TEMPORARY_FILE:
return "Falha ao remover arquivo temporário";
case MSG_REMOVING_TEMPORARY_CONTENT_FILE:
return "Removendo conteúdo temporário";
case MSG_LOADED_STATE_FROM_SLOT:
return "Estado carregado do slot";
case MSG_DOWNLOAD_PROGRESS:
return "Progresso do download";
case MSG_COULD_NOT_PROCESS_ZIP_FILE:
return "Incapaz de processar arquivo ZIP.";
case MSG_DOWNLOAD_COMPLETE:
return "Download concluído";
case MSG_SCANNING_OF_DIRECTORY_FINISHED:
return "Exame de diretório concluído";
case MSG_SCANNING:
return "Examinando";
case MSG_REDIRECTING_CHEATFILE_TO:
return "Redirecionando cheat para";
case MSG_REDIRECTING_SAVEFILE_TO:
return "Redirecionando save para";
case MSG_REDIRECTING_SAVESTATE_TO:
return "Redirecionando savestate para";
case MSG_SHADER:
return "Shader";
case MSG_APPLYING_SHADER:
return "Aplicando shader";
case MSG_FAILED_TO_APPLY_SHADER:
return "Falha ao aplicar shader.";
case MSG_STARTING_MOVIE_RECORD_TO:
return "Iniciando gravação de vídeo em";
case MSG_FAILED_TO_START_MOVIE_RECORD:
return "Falha ao iniciar gravação de vídeo.";
case MSG_STATE_SLOT:
return "Slot de estado";
case MSG_RESTARTING_RECORDING_DUE_TO_DRIVER_REINIT:
return "Reiniciando gravação devido a reinício de driver.";
case MSG_SLOW_MOTION:
return "Câmera lenta.";
case MSG_SLOW_MOTION_REWIND:
return "Retrocesso em câmera lenta.";
case MSG_REWINDING:
return "Retrocedendo.";
case MSG_REWIND_REACHED_END:
return "Final do buffer de retrocesso atingido.";
default: default:
break; break;
} }

158
intl/msg_hash_us.c
View File

@ -20,10 +20,164 @@ const char *msg_hash_to_str_us(uint32_t hash)
{ {
switch (hash) switch (hash)
{ {
case MSG_RESTARTING_RECORDING_DUE_TO_DRIVER_REINIT: case MSG_PROGRAM:
return "Restarting recording due to driver reinit."; return "RetroArch";
case MSG_MOVIE_RECORD_STOPPED:
return "Stopping movie record.";
case MSG_MOVIE_PLAYBACK_ENDED:
return "Movie playback ended.";
case MSG_AUTOSAVE_FAILED:
return "Could not initialize autosave.";
case MSG_NETPLAY_FAILED_MOVIE_PLAYBACK_HAS_STARTED:
return "Movie playback has started. Cannot start netplay.";
case MSG_NETPLAY_FAILED:
return "Failed to initialize netplay.";
case MSG_LIBRETRO_ABI_BREAK:
return "is compiled against a different version of libretro than this libretro implementation.";
case MSG_REWIND_INIT_FAILED_NO_SAVESTATES:
return "Implementation does not support save states. Cannot use rewind.";
case MSG_REWIND_INIT_FAILED_THREADED_AUDIO:
return "Implementation uses threaded audio. Cannot use rewind.";
case MSG_REWIND_INIT_FAILED:
return "Failed to initialize rewind buffer. Rewinding will be disabled.";
case MSG_REWIND_INIT:
return "Initializing rewind buffer with size";
case MSG_CUSTOM_TIMING_GIVEN:
return "Custom timing given";
case MSG_VIEWPORT_SIZE_CALCULATION_FAILED:
return "Viewport size calculation failed! Will continue using raw data. This will probably not work right ...";
case MSG_HW_RENDERED_MUST_USE_POSTSHADED_RECORDING:
return "Libretro core is hardware rendered. Must use post-shaded recording as well.";
case MSG_RECORDING_TO:
return "Recording to";
case MSG_DETECTED_VIEWPORT_OF:
return "Detected viewport of";
case MSG_TAKING_SCREENSHOT:
return "Taking screenshot.";
case MSG_FAILED_TO_TAKE_SCREENSHOT:
return "Failed to take screenshot.";
case MSG_FAILED_TO_START_RECORDING:
return "Failed to start recording.";
case MSG_RECORDING_TERMINATED_DUE_TO_RESIZE:
return "Recording terminated due to resize.";
case MSG_USING_LIBRETRO_DUMMY_CORE_RECORDING_SKIPPED:
return "Using libretro dummy core. Skipping recording.";
case MSG_UNKNOWN:
return "Unknown";
case MSG_LOADING_CONTENT_FILE:
return "Loading content file";
case MSG_RECEIVED:
return "received";
case MSG_UNRECOGNIZED_COMMAND:
return "Unrecognized command";
case MSG_SENDING_COMMAND:
return "Sending command";
case MSG_GOT_INVALID_DISK_INDEX:
return "Got invalid disk index.";
case MSG_FAILED_TO_REMOVE_DISK_FROM_TRAY:
return "Failed to remove disk from tray.";
case MSG_REMOVED_DISK_FROM_TRAY:
return "Removed disk from tray.";
case MSG_VIRTUAL_DISK_TRAY:
return "virtual disk tray.";
case MSG_FAILED_TO:
return "Failed to";
case MSG_TO:
return "to";
case MSG_SAVING_RAM_TYPE:
return "Saving RAM type";
case MSG_SAVING_STATE:
return "Saving state";
case MSG_LOADING_STATE:
return "Loading state";
case MSG_FAILED_TO_LOAD_MOVIE_FILE:
return "Failed to load movie file";
case MSG_FAILED_TO_LOAD_CONTENT:
return "Failed to load content";
case MSG_COULD_NOT_READ_CONTENT_FILE:
return "Could not read content file";
case MSG_GRAB_MOUSE_STATE:
return "Grab mouse state";
case MSG_PAUSED:
return "Paused.";
case MSG_UNPAUSED:
return "Unpaused.";
case MSG_FAILED_TO_LOAD_OVERLAY:
return "Failed to load overlay.";
case MSG_FAILED_TO_UNMUTE_AUDIO:
return "Failed to unmute audio.";
case MSG_AUDIO_MUTED:
return "Audio muted.";
case MSG_AUDIO_UNMUTED:
return "Audio unmuted.";
case MSG_RESET:
return "Reset";
case MSG_FAILED_TO_LOAD_STATE:
return "Failed to load state from";
case MSG_FAILED_TO_SAVE_STATE_TO:
return "Failed to save state to";
case MSG_FAILED_TO_SAVE_SRAM:
return "Failed to save SRAM";
case MSG_STATE_SIZE:
return "State size";
case MSG_FOUND_SHADER:
return "Found shader";
case MSG_SRAM_WILL_NOT_BE_SAVED:
return "SRAM will not be saved.";
case MSG_BLOCKING_SRAM_OVERWRITE:
return "Blocking SRAM Overwrite";
case MSG_CORE_DOES_NOT_SUPPORT_SAVESTATES:
return "Core does not support save states.";
case MSG_SAVED_STATE_TO_SLOT:
return "Saved state to slot";
case MSG_SAVED_SUCCESSFULLY_TO:
return "Saved successfully to";
case MSG_BYTES:
return "bytes";
case MSG_CONFIG_DIRECTORY_NOT_SET:
return "Config directory not set. Cannot save new config.";
case MSG_SKIPPING_SRAM_LOAD:
return "Skipping SRAM load.";
case MSG_APPENDED_DISK:
return "Appended disk";
case MSG_STARTING_MOVIE_PLAYBACK:
return "Starting movie playback.";
case MSG_FAILED_TO_REMOVE_TEMPORARY_FILE:
return "Failed to remove temporary file";
case MSG_REMOVING_TEMPORARY_CONTENT_FILE:
return "Removing temporary content file";
case MSG_LOADED_STATE_FROM_SLOT:
return "Loaded state from slot";
case MSG_DOWNLOAD_PROGRESS:
return "Download progress";
case MSG_COULD_NOT_PROCESS_ZIP_FILE:
return "Could not process ZIP file.";
case MSG_DOWNLOAD_COMPLETE:
return "Download complete";
case MSG_SCANNING_OF_DIRECTORY_FINISHED:
return "Scanning of directory finished";
case MSG_SCANNING:
return "Scanning";
case MSG_REDIRECTING_CHEATFILE_TO:
return "Redirecting cheat file to";
case MSG_REDIRECTING_SAVEFILE_TO:
return "Redirecting save file to";
case MSG_REDIRECTING_SAVESTATE_TO:
return "Redirecting savestate to";
case MSG_SHADER:
return "Shader";
case MSG_APPLYING_SHADER:
return "Applying shader";
case MSG_FAILED_TO_APPLY_SHADER:
return "Failed to apply shader.";
case MSG_STARTING_MOVIE_RECORD_TO:
return "Starting movie record to";
case MSG_FAILED_TO_START_MOVIE_RECORD: case MSG_FAILED_TO_START_MOVIE_RECORD:
return "Failed to start movie record."; return "Failed to start movie record.";
case MSG_STATE_SLOT:
return "State slot";
case MSG_RESTARTING_RECORDING_DUE_TO_DRIVER_REINIT:
return "Restarting recording due to driver reinit.";
case MSG_SLOW_MOTION: case MSG_SLOW_MOTION:
return "Slow motion."; return "Slow motion.";
case MSG_SLOW_MOTION_REWIND: case MSG_SLOW_MOTION_REWIND:

2
libretro-common/include/retro_log.h
View File

@ -65,7 +65,7 @@ FILE *rarch_main_log_file(void);
#define PROGRAM_NAME "N/A" #define PROGRAM_NAME "N/A"
#endif #endif
#if defined(RARCH_INTERNAL) #if defined(RARCH_INTERNAL) && !defined(ANDROID)
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {

1
libretro_version_1.c
View File

@ -39,7 +39,6 @@
#include "audio/audio_utils.h" #include "audio/audio_utils.h"
#include "record/record_driver.h" #include "record/record_driver.h"
#include "gfx/video_pixel_converter.h" #include "gfx/video_pixel_converter.h"
#include "intl/intl.h"
#ifdef HAVE_NETPLAY #ifdef HAVE_NETPLAY
#include "netplay.h" #include "netplay.h"

2
menu/cbs/menu_cbs_get_value.c
View File

@ -22,8 +22,8 @@
#include "../../general.h" #include "../../general.h"
#include "../../performance.h" #include "../../performance.h"
#include "../../intl/intl.h"
#include "../../system.h" #include "../../system.h"
#include "../../intl/intl.h"
const char axis_labels[4][128] = { const char axis_labels[4][128] = {
RETRO_LBL_ANALOG_LEFT_X, RETRO_LBL_ANALOG_LEFT_X,

8
menu/drivers/xmb.c
View File

@ -83,6 +83,7 @@ enum
XMB_TEXTURE_FOLDER, XMB_TEXTURE_FOLDER,
XMB_TEXTURE_ZIP, XMB_TEXTURE_ZIP,
XMB_TEXTURE_MUSIC, XMB_TEXTURE_MUSIC,
XMB_TEXTURE_IMAGE,
XMB_TEXTURE_CORE, XMB_TEXTURE_CORE,
XMB_TEXTURE_RDB, XMB_TEXTURE_RDB,
XMB_TEXTURE_CURSOR, XMB_TEXTURE_CURSOR,
@ -1123,6 +1124,8 @@ static GLuint xmb_icon_get_id(xmb_handle_t *xmb,
return xmb->textures.list[XMB_TEXTURE_ZIP].id; return xmb->textures.list[XMB_TEXTURE_ZIP].id;
case MENU_FILE_MUSIC: case MENU_FILE_MUSIC:
return xmb->textures.list[XMB_TEXTURE_MUSIC].id; return xmb->textures.list[XMB_TEXTURE_MUSIC].id;
case MENU_FILE_IMAGEVIEWER:
return xmb->textures.list[XMB_TEXTURE_IMAGE].id;
case MENU_FILE_CORE: case MENU_FILE_CORE:
return xmb->textures.list[XMB_TEXTURE_CORE].id; return xmb->textures.list[XMB_TEXTURE_CORE].id;
case MENU_FILE_RDB: case MENU_FILE_RDB:
@ -1302,6 +1305,8 @@ static void xmb_draw_items(xmb_handle_t *xmb, gl_t *gl,
break; break;
case MENU_VALUE_MUSIC: case MENU_VALUE_MUSIC:
break; break;
case MENU_VALUE_IMAGE:
break;
case MENU_VALUE_ON: case MENU_VALUE_ON:
if (xmb->textures.list[XMB_TEXTURE_SWITCH_ON].id) if (xmb->textures.list[XMB_TEXTURE_SWITCH_ON].id)
texture_switch = xmb->textures.list[XMB_TEXTURE_SWITCH_ON].id; texture_switch = xmb->textures.list[XMB_TEXTURE_SWITCH_ON].id;
@ -2085,6 +2090,9 @@ static void xmb_context_reset_textures(xmb_handle_t *xmb, const char *iconpath)
case XMB_TEXTURE_MUSIC: case XMB_TEXTURE_MUSIC:
fill_pathname_join(path, iconpath, "music.png", sizeof(path)); fill_pathname_join(path, iconpath, "music.png", sizeof(path));
break; break;
case XMB_TEXTURE_IMAGE:
fill_pathname_join(path, iconpath, "image.png", sizeof(path));
break;
case XMB_TEXTURE_CORE: case XMB_TEXTURE_CORE:
fill_pathname_join(path, iconpath, "core.png", sizeof(path)); fill_pathname_join(path, iconpath, "core.png", sizeof(path));
break; break;

16
menu/intl/menu_hash_pt.c
View File

@ -92,7 +92,7 @@ const char *menu_hash_to_str_pt(uint32_t hash)
case MENU_LABEL_VALUE_AUDIO_BLOCK_FRAMES: case MENU_LABEL_VALUE_AUDIO_BLOCK_FRAMES:
return "Quadros de Blocos de Áudio"; return "Quadros de Blocos de Áudio";
case MENU_LABEL_VALUE_INPUT_BIND_MODE: case MENU_LABEL_VALUE_INPUT_BIND_MODE:
return "Modo Vínculo"; return "Modo de Associações";
case MENU_LABEL_VALUE_AUTOCONFIG_DESCRIPTOR_LABEL_SHOW: case MENU_LABEL_VALUE_AUTOCONFIG_DESCRIPTOR_LABEL_SHOW:
return "Mostrar Rótulos de Autoconfiguração"; return "Mostrar Rótulos de Autoconfiguração";
case MENU_LABEL_VALUE_INPUT_DESCRIPTOR_LABEL_SHOW: case MENU_LABEL_VALUE_INPUT_DESCRIPTOR_LABEL_SHOW:
@ -324,9 +324,9 @@ const char *menu_hash_to_str_pt(uint32_t hash)
case MENU_LABEL_VALUE_VIDEO_FULLSCREEN: case MENU_LABEL_VALUE_VIDEO_FULLSCREEN:
return "Usar Modo Tela Cheia"; return "Usar Modo Tela Cheia";
case MENU_LABEL_VALUE_VIDEO_SCALE: case MENU_LABEL_VALUE_VIDEO_SCALE:
return "Interpolação em Janela"; return "Variar Escala em Janela";
case MENU_LABEL_VALUE_VIDEO_SCALE_INTEGER: case MENU_LABEL_VALUE_VIDEO_SCALE_INTEGER:
return "Interpolação em Inteiros"; return "Escala em Degraus Inteiros";
case MENU_LABEL_VALUE_PERFCNT_ENABLE: case MENU_LABEL_VALUE_PERFCNT_ENABLE:
return "Contadores de Desempenho"; return "Contadores de Desempenho";
case MENU_LABEL_VALUE_LIBRETRO_LOG_LEVEL: case MENU_LABEL_VALUE_LIBRETRO_LOG_LEVEL:
@ -404,7 +404,7 @@ const char *menu_hash_to_str_pt(uint32_t hash)
case MENU_LABEL_VALUE_FPS_SHOW: case MENU_LABEL_VALUE_FPS_SHOW:
return "Mostrar Taxa de Quadros"; return "Mostrar Taxa de Quadros";
case MENU_LABEL_VALUE_AUDIO_MUTE: case MENU_LABEL_VALUE_AUDIO_MUTE:
return "Desligar Áudio"; return "Silenciar Áudio";
case MENU_LABEL_VALUE_AUDIO_VOLUME: case MENU_LABEL_VALUE_AUDIO_VOLUME:
return "Volume de Áudio (dB)"; return "Volume de Áudio (dB)";
case MENU_LABEL_VALUE_AUDIO_SYNC: case MENU_LABEL_VALUE_AUDIO_SYNC:
@ -841,6 +841,14 @@ const char *menu_hash_to_str_pt(uint32_t hash)
return "Analógico Esquerdo"; return "Analógico Esquerdo";
case MENU_VALUE_RIGHT_ANALOG: case MENU_VALUE_RIGHT_ANALOG:
return "Analógico Direito"; return "Analógico Direito";
case MENU_LABEL_VALUE_INPUT_HOTKEY_BINDS:
return "Associação de Teclas de Atalho";
case MENU_LABEL_VALUE_FRAME_THROTTLE_SETTINGS:
return "Definições do Limitador de Quadros";
case MENU_VALUE_SEARCH:
return "Busca:";
case MENU_LABEL_VALUE_USE_BUILTIN_IMAGE_VIEWER:
return "Usar Visualizador de Imagens Interno";
default: default:
break; break;
} }

1
menu/menu_hash.h
View File

@ -480,6 +480,7 @@ extern "C" {
#define MENU_VALUE_FALSE 0x0f6bcef0U #define MENU_VALUE_FALSE 0x0f6bcef0U
#define MENU_VALUE_COMP 0x6a166ba5U #define MENU_VALUE_COMP 0x6a166ba5U
#define MENU_VALUE_MUSIC 0xc4a73997U #define MENU_VALUE_MUSIC 0xc4a73997U
#define MENU_VALUE_IMAGE 0xbab7ebf9U
#define MENU_VALUE_CORE 0x6a167f7fU #define MENU_VALUE_CORE 0x6a167f7fU
#define MENU_VALUE_CURSOR 0x57bba8b4U #define MENU_VALUE_CURSOR 0x57bba8b4U
#define MENU_VALUE_FILE 0x6a496536U #define MENU_VALUE_FILE 0x6a496536U

12
menu/menu_setting.c
View File

@ -505,9 +505,9 @@ int setting_set_with_string_representation(rarch_setting_t* setting,
sscanf(value, "%d", setting->value.integer); sscanf(value, "%d", setting->value.integer);
if (setting->flags & SD_FLAG_HAS_RANGE) if (setting->flags & SD_FLAG_HAS_RANGE)
{ {
if (*setting->value.integer < setting->min) if (setting->enforce_minrange && *setting->value.integer < setting->min)
*setting->value.integer = setting->min; *setting->value.integer = setting->min;
if (*setting->value.integer > setting->max) if (setting->enforce_maxrange && *setting->value.integer > setting->max)
*setting->value.integer = setting->max; *setting->value.integer = setting->max;
} }
break; break;
@ -515,9 +515,9 @@ int setting_set_with_string_representation(rarch_setting_t* setting,
sscanf(value, "%u", setting->value.unsigned_integer); sscanf(value, "%u", setting->value.unsigned_integer);
if (setting->flags & SD_FLAG_HAS_RANGE) if (setting->flags & SD_FLAG_HAS_RANGE)
{ {
if (*setting->value.unsigned_integer < setting->min) if (setting->enforce_minrange && *setting->value.unsigned_integer < setting->min)
*setting->value.unsigned_integer = setting->min; *setting->value.unsigned_integer = setting->min;
if (*setting->value.unsigned_integer > setting->max) if (setting->enforce_maxrange && *setting->value.unsigned_integer > setting->max)
*setting->value.unsigned_integer = setting->max; *setting->value.unsigned_integer = setting->max;
} }
break; break;
@ -525,9 +525,9 @@ int setting_set_with_string_representation(rarch_setting_t* setting,
sscanf(value, "%f", setting->value.fraction); sscanf(value, "%f", setting->value.fraction);
if (setting->flags & SD_FLAG_HAS_RANGE) if (setting->flags & SD_FLAG_HAS_RANGE)
{ {
if (*setting->value.fraction < setting->min) if (setting->enforce_minrange && *setting->value.fraction < setting->min)
*setting->value.fraction = setting->min; *setting->value.fraction = setting->min;
if (*setting->value.fraction > setting->max) if (setting->enforce_maxrange && *setting->value.fraction > setting->max)
*setting->value.fraction = setting->max; *setting->value.fraction = setting->max;
} }
break; break;

3
msg_hash.c
View File

@ -26,7 +26,7 @@ const char *msg_hash_to_str(uint32_t hash)
settings_t *settings = config_get_ptr(); settings_t *settings = config_get_ptr();
if (!settings) if (!settings)
return "null"; goto end;
switch (settings->user_language) switch (settings->user_language)
{ {
@ -57,6 +57,7 @@ const char *msg_hash_to_str(uint32_t hash)
if (ret && strcmp(ret, "null") != 0) if (ret && strcmp(ret, "null") != 0)
return ret; return ret;
end:
return msg_hash_to_str_us(hash); return msg_hash_to_str_us(hash);
} }

178
msg_hash.h Normal file
View File

@ -0,0 +1,178 @@
/* RetroArch - A frontend for libretro.
* Copyright (C) 2010-2014 - Hans-Kristian Arntzen
* Copyright (C) 2011-2015 - Daniel De Matteis
*
* 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/>.
*/
#ifndef __MSG_HASH_H
#define __MSG_HASH_H
#include <stdint.h>
#include <stddef.h>
#define MSG_UNKNOWN 0x3a834e55U
#define MSG_PROGRAM 0xc339565dU
#define MSG_FOUND_SHADER 0x817f42b7U
#define MSG_LOADING_HISTORY_FILE 0x865210d3U
#define MSG_SRAM_WILL_NOT_BE_SAVED 0x16f17d61U
#define MSG_RECEIVED 0xfe0c06acU
#define MSG_LOADING_CONTENT_FILE 0x236398dcU
#define MSG_USING_LIBRETRO_DUMMY_CORE_RECORDING_SKIPPED 0x9e8a1febU
#define MSG_RECORDING_TERMINATED_DUE_TO_RESIZE 0x361a07feU
#define MSG_FAILED_TO_START_RECORDING 0x90c3e2d5U
#define MSG_REWIND_INIT 0xf7732001U
#define MSG_REWIND_INIT_FAILED 0x9c1db0a6U
#define MSG_REWIND_INIT_FAILED_THREADED_AUDIO 0x359001b6U
#define MSG_REWIND_INIT_FAILED_NO_SAVESTATES 0x979b9cc3U
#define MSG_LIBRETRO_ABI_BREAK 0xf02cccd7U
#define MSG_NETPLAY_FAILED 0x61ee3426U
#define MSG_NETPLAY_FAILED_MOVIE_PLAYBACK_HAS_STARTED 0xb1e5dbfcU
#define MSG_DETECTED_VIEWPORT_OF 0xdf7002baU
#define MSG_RECORDING_TO 0x189fd324U
#define MSG_HW_RENDERED_MUST_USE_POSTSHADED_RECORDING 0x7f9f7659U
#define MSG_VIEWPORT_SIZE_CALCULATION_FAILED 0x9da84911U
#define MSG_AUTOSAVE_FAILED 0x9a02d8d1U
#define MSG_MOVIE_RECORD_STOPPED 0xbc7832c1U
#define MSG_MOVIE_PLAYBACK_ENDED 0xbeadce2aU
#define MSG_TAKING_SCREENSHOT 0xdcfda0e0U
#define MSG_FAILED_TO_TAKE_SCREENSHOT 0x7a480a2dU
#define MSG_CUSTOM_TIMING_GIVEN 0x259c95dfU
#define MSG_SAVING_STATE 0xe4f3eb4dU
#define MSG_LOADING_STATE 0x68d8d483U
#define MSG_FAILED_TO_SAVE_STATE_TO 0xcc005f3cU
#define MSG_FAILED_TO_SAVE_SRAM 0x0f72de6cU
#define MSG_STATE_SIZE 0x27b67400U
#define MSG_FAILED_TO_LOAD_CONTENT 0x0186e5a5U
#define MSG_COULD_NOT_READ_CONTENT_FILE 0x2dc7f4a0U
#define MSG_SAVED_SUCCESSFULLY_TO 0x9f59a7deU
#define MSG_BYTES 0x0f30b64cU
#define MSG_BLOCKING_SRAM_OVERWRITE 0x1f91d486U
#define MSG_UNRECOGNIZED_COMMAND 0x946b8a50U
#define MSG_SENDING_COMMAND 0x562cf28bU
#define MSG_RESTARTING_RECORDING_DUE_TO_DRIVER_REINIT 0x5aa753b8U
#define MSG_REWINDING 0xccbeec2cU
#define MSG_SLOW_MOTION_REWIND 0x385adb27U
#define MSG_SLOW_MOTION 0x744c437fU
#define MSG_REWIND_REACHED_END 0x4f1aab8fU
#define MSG_FAILED_TO_START_MOVIE_RECORD 0x61221776U
#define MSG_STATE_SLOT 0x27b67f67U
#define MSG_STARTING_MOVIE_RECORD_TO 0x6a7e0d50U
#define MSG_FAILED_TO_START_MOVIE_RECORD 0x61221776U
#define MSG_FAILED_TO_APPLY_SHADER 0x2094eb67U
#define MSG_APPLYING_SHADER 0x35599b7fU
#define MSG_SHADER 0x1bb1211cU
#define MSG_REDIRECTING_SAVESTATE_TO 0x8d98f7a6U
#define MSG_REDIRECTING_SAVEFILE_TO 0x868c54a5U
#define MSG_REDIRECTING_CHEATFILE_TO 0xd5f1b27bU
#define MSG_SCANNING 0x4c547516U
#define MSG_SCANNING_OF_DIRECTORY_FINISHED 0x399632a7U
#define MSG_DOWNLOAD_COMPLETE 0x4b9c4f75U
#define MSG_COULD_NOT_PROCESS_ZIP_FILE 0xc18c89bbU
#define MSG_DOWNLOAD_PROGRESS 0x35ed9411U
#define MSG_LOADED_STATE_FROM_SLOT 0xadb48582U
#define MSG_REMOVING_TEMPORARY_CONTENT_FILE 0x7121c9e7U
#define MSG_FAILED_TO_REMOVE_TEMPORARY_FILE 0xb6707b1aU
#define MSG_STARTING_MOVIE_PLAYBACK 0x96e545b6U
#define MSG_APPENDED_DISK 0x814ea0f0U
#define MSG_SKIPPING_SRAM_LOAD 0x88d4c8dbU
#define MSG_CONFIG_DIRECTORY_NOT_SET 0xcd45252aU
#define MSG_SAVED_STATE_TO_SLOT 0xe1e3dc3bU
#define MSG_CORE_DOES_NOT_SUPPORT_SAVESTATES 0xd50adf46U
#define MSG_FAILED_TO_LOAD_STATE 0x91f348ebU
#define MSG_RESET 0x10474288U
#define MSG_AUDIO_MUTED 0xfa0c3bd5U
#define MSG_AUDIO_UNMUTED 0x0512bab8U
#define MSG_FAILED_TO_UNMUTE_AUDIO 0xf698763aU
#define MSG_FAILED_TO_LOAD_OVERLAY 0xacf201ecU
#define MSG_PAUSED 0x143e3307U
#define MSG_UNPAUSED 0x95aede0aU
#define MSG_CORE_DOES_NOT_SUPPORT_DISK_OPTIONS 0x6ba5abf9U
#define MSG_GRAB_MOUSE_STATE 0x893a7329U
#define MSG_FAILED_TO_LOAD_MOVIE_FILE 0x9455a5a9U
#define MSG_FAILED_TO 0x768f6dacU
#define MSG_SAVING_RAM_TYPE 0x9cd21d2dU
#define MSG_TO 0x005979a8U
#define MSG_VIRTUAL_DISK_TRAY 0x4aa37f15U
#define MSG_REMOVED_DISK_FROM_TRAY 0xf26a9653U
#define MSG_FAILED_TO_REMOVE_DISK_FROM_TRAY 0xc1c9a655U
#define MSG_GOT_INVALID_DISK_INDEX 0xb138dd76U
const char *msg_hash_to_str(uint32_t hash);
const char *msg_hash_to_str_fr(uint32_t hash);
const char *msg_hash_to_str_de(uint32_t hash);
const char *msg_hash_to_str_es(uint32_t hash);
const char *msg_hash_to_str_eo(uint32_t hash);
const char *msg_hash_to_str_it(uint32_t hash);
const char *msg_hash_to_str_pt(uint32_t hash);
const char *msg_hash_to_str_nl(uint32_t hash);
const char *msg_hash_to_str_us(uint32_t hash);
uint32_t msg_hash_calculate(const char *s);
#endif

10
netplay.c
View File

@ -25,7 +25,7 @@
#include "general.h" #include "general.h"
#include "autosave.h" #include "autosave.h"
#include "dynamic.h" #include "dynamic.h"
#include "intl/intl.h" #include "msg_hash.h"
#include "system.h" #include "system.h"
struct delta_frame struct delta_frame
@ -1660,7 +1660,7 @@ bool init_netplay(void)
if (global->bsv.movie_start_playback) if (global->bsv.movie_start_playback)
{ {
RARCH_WARN(RETRO_LOG_MOVIE_STARTED_INIT_NETPLAY_FAILED); RARCH_WARN("%s\n", msg_hash_to_str(MSG_NETPLAY_FAILED_MOVIE_PLAYBACK_HAS_STARTED));
return false; return false;
} }
@ -1684,10 +1684,10 @@ bool init_netplay(void)
return true; return true;
global->netplay_is_client = false; global->netplay_is_client = false;
RARCH_WARN(RETRO_LOG_INIT_NETPLAY_FAILED); RARCH_WARN("%s\n", msg_hash_to_str(MSG_NETPLAY_FAILED));
rarch_main_msg_queue_push( rarch_main_msg_queue_push_new(
RETRO_MSG_INIT_NETPLAY_FAILED, MSG_NETPLAY_FAILED_MOVIE_PLAYBACK_HAS_STARTED,
0, 180, false); 0, 180, false);
return false; return false;
} }

7
patch.c
View File

@ -148,9 +148,11 @@ patch_error_t bps_apply_patch(
case SOURCE_COPY: case SOURCE_COPY:
case TARGET_COPY: case TARGET_COPY:
{ {
int offset = bps_decode(&bps); int offset = bps_decode(&bps);
bool negative = offset & 1; bool negative = offset & 1;
offset >>= 1; offset >>= 1;
if (negative) if (negative)
offset = -offset; offset = -offset;
@ -257,7 +259,8 @@ static uint64_t ups_decode(struct ups_data *data)
while (true) while (true)
{ {
uint8_t x = ups_patch_read(data); uint8_t x = ups_patch_read(data);
offset += (x & 0x7f) * shift; offset += (x & 0x7f) * shift;
if (x & 0x80) if (x & 0x80)
break; break;
shift <<= 7; shift <<= 7;

43
record/record_driver.c
View File

@ -23,9 +23,9 @@
#include "../general.h" #include "../general.h"
#include "../retroarch.h" #include "../retroarch.h"
#include "../runloop.h" #include "../runloop.h"
#include "../intl/intl.h"
#include "../gfx/video_driver.h" #include "../gfx/video_driver.h"
#include "../gfx/video_viewport.h" #include "../gfx/video_viewport.h"
#include "../msg_hash.h"
#ifdef HAVE_CONFIG_H #ifdef HAVE_CONFIG_H
#include "../config.h" #include "../config.h"
@ -121,22 +121,22 @@ void find_record_driver(void)
int i = find_driver_index("record_driver", settings->record.driver); int i = find_driver_index("record_driver", settings->record.driver);
if (i >= 0) if (i >= 0)
driver->recording = (const record_driver_t*)audio_driver_find_handle(i); driver->recording = (const record_driver_t*)record_driver_find_handle(i);
else else
{ {
unsigned d; unsigned d;
RARCH_ERR("Couldn't find any audio driver named \"%s\"\n", RARCH_ERR("Couldn't find any record driver named \"%s\"\n",
settings->audio.driver); settings->audio.driver);
RARCH_LOG_OUTPUT("Available audio drivers are:\n"); RARCH_LOG_OUTPUT("Available record drivers are:\n");
for (d = 0; audio_driver_find_handle(d); d++) for (d = 0; record_driver_find_handle(d); d++)
RARCH_LOG_OUTPUT("\t%s\n", record_driver_find_ident(d)); RARCH_LOG_OUTPUT("\t%s\n", record_driver_find_ident(d));
RARCH_WARN("Going to default to first audio driver...\n"); RARCH_WARN("Going to default to first record driver...\n");
driver->audio = (const audio_driver_t*)audio_driver_find_handle(0); driver->recording = (const record_driver_t*)record_driver_find_handle(0);
if (!driver->audio) if (!driver->recording)
rarch_fail(1, "find_audio_driver()"); rarch_fail(1, "find_record_driver()");
} }
} }
@ -216,7 +216,8 @@ void recording_dump_frame(const void *data, unsigned width,
if (!vp.width || !vp.height) if (!vp.width || !vp.height)
{ {
RARCH_WARN("Viewport size calculation failed! Will continue using raw data. This will probably not work right ...\n"); RARCH_WARN("%s \n",
msg_hash_to_str(MSG_VIEWPORT_SIZE_CALCULATION_FAILED));
event_command(EVENT_CMD_GPU_RECORD_DEINIT); event_command(EVENT_CMD_GPU_RECORD_DEINIT);
recording_dump_frame(data, width, height, pitch); recording_dump_frame(data, width, height, pitch);
@ -227,10 +228,9 @@ void recording_dump_frame(const void *data, unsigned width,
if (vp.width != global->record.gpu_width || if (vp.width != global->record.gpu_width ||
vp.height != global->record.gpu_height) vp.height != global->record.gpu_height)
{ {
static const char msg[] = "Recording terminated due to resize."; RARCH_WARN("%s\n", msg_hash_to_str(MSG_RECORDING_TERMINATED_DUE_TO_RESIZE));
RARCH_WARN("%s\n", msg);
rarch_main_msg_queue_push(msg, 1, 180, true); rarch_main_msg_queue_push_new(MSG_RECORDING_TERMINATED_DUE_TO_RESIZE, 1, 180, true);
event_command(EVENT_CMD_RECORD_DEINIT); event_command(EVENT_CMD_RECORD_DEINIT);
return; return;
} }
@ -301,17 +301,18 @@ bool recording_init(void)
if (global->core_type == CORE_TYPE_DUMMY) if (global->core_type == CORE_TYPE_DUMMY)
{ {
RARCH_WARN(RETRO_LOG_INIT_RECORDING_SKIPPED); RARCH_WARN(msg_hash_to_str(MSG_USING_LIBRETRO_DUMMY_CORE_RECORDING_SKIPPED));
return false; return false;
} }
if (!settings->video.gpu_record && hw_render->context_type) if (!settings->video.gpu_record && hw_render->context_type)
{ {
RARCH_WARN("Libretro core is hardware rendered. Must use post-shaded recording as well.\n"); RARCH_WARN("%s.\n", msg_hash_to_str(MSG_HW_RENDERED_MUST_USE_POSTSHADED_RECORDING));
return false; return false;
} }
RARCH_LOG("Custom timing given: FPS: %.4f, Sample rate: %.4f\n", RARCH_LOG("%s: FPS: %.4f, Sample rate: %.4f\n",
msg_hash_to_str(MSG_CUSTOM_TIMING_GIVEN),
(float)av_info->timing.fps, (float)av_info->timing.fps,
(float)av_info->timing.sample_rate); (float)av_info->timing.sample_rate);
@ -365,15 +366,12 @@ bool recording_init(void)
global->record.gpu_width = vp.width; global->record.gpu_width = vp.width;
global->record.gpu_height = vp.height; global->record.gpu_height = vp.height;
RARCH_LOG("Detected viewport of %u x %u\n", RARCH_LOG("%s %u x %u\n", msg_hash_to_str(MSG_DETECTED_VIEWPORT_OF),
vp.width, vp.height); vp.width, vp.height);
global->record.gpu_buffer = (uint8_t*)malloc(vp.width * vp.height * 3); global->record.gpu_buffer = (uint8_t*)malloc(vp.width * vp.height * 3);
if (!global->record.gpu_buffer) if (!global->record.gpu_buffer)
{
RARCH_ERR("Failed to allocate GPU record buffer.\n");
return false; return false;
}
} }
else else
{ {
@ -407,7 +405,8 @@ bool recording_init(void)
} }
} }
RARCH_LOG("Recording to %s @ %ux%u. (FB size: %ux%u pix_fmt: %u)\n", RARCH_LOG("%s %s @ %ux%u. (FB size: %ux%u pix_fmt: %u)\n",
msg_hash_to_str(MSG_RECORDING_TO),
global->record.path, global->record.path,
params.out_width, params.out_height, params.out_width, params.out_height,
params.fb_width, params.fb_height, params.fb_width, params.fb_height,
@ -415,7 +414,7 @@ bool recording_init(void)
if (!record_driver_init_first(&driver->recording, &driver->recording_data, &params)) if (!record_driver_init_first(&driver->recording, &driver->recording_data, &params))
{ {
RARCH_ERR(RETRO_LOG_INIT_RECORDING_FAILED); RARCH_ERR(msg_hash_to_str(MSG_FAILED_TO_START_RECORDING));
event_command(EVENT_CMD_GPU_RECORD_DEINIT); event_command(EVENT_CMD_GPU_RECORD_DEINIT);
return false; return false;

60
retroarch.c
View File

@ -22,10 +22,6 @@
#include <errno.h> #include <errno.h>
#include <boolean.h> #include <boolean.h>
#ifdef HAVE_FFMPEG
#include <rhash.h>
#endif
#ifdef _WIN32 #ifdef _WIN32
#ifdef _XBOX #ifdef _XBOX
#include <xtl.h> #include <xtl.h>
@ -40,7 +36,7 @@
#include <compat/posix_string.h> #include <compat/posix_string.h>
#include <file/file_path.h> #include <file/file_path.h>
#include <rhash.h> #include "msg_hash.h"
#include "libretro_version_1.h" #include "libretro_version_1.h"
#include "dynamic.h" #include "dynamic.h"
@ -53,7 +49,6 @@
#include "system.h" #include "system.h"
#include "git_version.h" #include "git_version.h"
#include "intl/intl.h"
#ifdef HAVE_MENU #ifdef HAVE_MENU
#include "menu/menu.h" #include "menu/menu.h"
@ -150,10 +145,9 @@ static void print_version(void)
{ {
char str[PATH_MAX_LENGTH] = {0}; char str[PATH_MAX_LENGTH] = {0};
fprintf(stderr, "%s: Frontend for libretro -- v%s", msg_hash_to_str(MSG_PROGRAM), PACKAGE_VERSION);
#ifdef HAVE_GIT_VERSION #ifdef HAVE_GIT_VERSION
printf(RETRO_FRONTEND ": Frontend for libretro -- v" PACKAGE_VERSION " -- %s --\n", rarch_git_version); printf(" -- %s --\n", rarch_git_version);
#else
puts(RETRO_FRONTEND ": Frontend for libretro -- v" PACKAGE_VERSION " --");
#endif #endif
rarch_info_get_capabilities(RARCH_CAPABILITIES_COMPILER, str, sizeof(str)); rarch_info_get_capabilities(RARCH_CAPABILITIES_COMPILER, str, sizeof(str));
fprintf(stdout, "%s", str); fprintf(stdout, "%s", str);
@ -175,16 +169,22 @@ static void print_help(const char *arg0)
puts(" -h, --help Show this help message."); puts(" -h, --help Show this help message.");
puts(" -v, --verbose Verbose logging."); puts(" -v, --verbose Verbose logging.");
puts(" --log-file=FILE Log " RETRO_FRONTEND " messages to FILE."); puts(" --log-file=FILE Log messages to FILE.");
puts(" --version Show " RETRO_FRONTEND " version."); puts(" --version Show version.");
puts(" --features Prints available features compiled into " RETRO_FRONTEND "."); puts(" --features Prints available features compiled into program.");
puts(" --menu Do not require content or libretro core to be loaded,\n" puts(" --menu Do not require content or libretro core to be loaded,\n"
" starts directly in menu. If no arguments are passed to\n" " starts directly in menu. If no arguments are passed to\n"
" " RETRO_FRONTEND ", it is equivalent to using --menu as only argument."); " the program, it is equivalent to using --menu as only argument.");
puts(" -s, --save=PATH Path for save files (*.srm)."); puts(" -s, --save=PATH Path for save files (*.srm).");
puts(" -S, --savestate=PATH Path for the save state files (*.state)."); puts(" -S, --savestate=PATH Path for the save state files (*.state).");
puts(" -f, --fullscreen Start " RETRO_FRONTEND " in fullscreen regardless of config settings."); puts(" -f, --fullscreen Start the program in fullscreen regardless of config settings.");
puts(" -c, --config=FILE Path for config file." RARCH_DEFAULT_CONF_PATH_STR); puts(" -c, --config=FILE Path for config file."
#ifdef _WIN32
"\n\t\tDefaults to retroarch.cfg in same directory as retroarch.exe.\n\t\tIf a default config is not found, the program will attempt to create one."
#else
"\n\t\tBy default looks for config in $XDG_CONFIG_HOME/retroarch/retroarch.cfg,\n\t\t$HOME/.config/retroarch/retroarch.cfg,\n\t\tand $HOME/.retroarch.cfg.\n\t\tIf a default config is not found, the program will attempt to create one based on the skeleton config (" GLOBAL_CONFIG_DIR "/retroarch.cfg)."
#endif
);
puts(" --appendconfig=FILE\n" puts(" --appendconfig=FILE\n"
" Extra config files are loaded in, and take priority over\n" " Extra config files are loaded in, and take priority over\n"
" config selected in -c (or default). Multiple configs are\n" " config selected in -c (or default). Multiple configs are\n"
@ -223,7 +223,7 @@ static void print_help(const char *arg0)
#endif #endif
puts(" --nick=NICK Picks a username (for use with netplay). Not mandatory."); puts(" --nick=NICK Picks a username (for use with netplay). Not mandatory.");
#if defined(HAVE_NETWORK_CMD) && defined(HAVE_NETPLAY) #if defined(HAVE_NETWORK_CMD) && defined(HAVE_NETPLAY)
puts(" --command Sends a command over UDP to an already running " RETRO_FRONTEND " process."); puts(" --command Sends a command over UDP to an already running program process.");
puts(" Available commands are listed if command is invalid."); puts(" Available commands are listed if command is invalid.");
#endif #endif
@ -235,7 +235,7 @@ static void print_help(const char *arg0)
puts(" --bps=FILE Specifies path for BPS patch that will be applied to content."); puts(" --bps=FILE Specifies path for BPS patch that will be applied to content.");
puts(" --ips=FILE Specifies path for IPS patch that will be applied to content."); puts(" --ips=FILE Specifies path for IPS patch that will be applied to content.");
puts(" --no-patch Disables all forms of content patching."); puts(" --no-patch Disables all forms of content patching.");
puts(" -D, --detach Detach " RETRO_FRONTEND " from the running console. Not relevant for all platforms."); puts(" -D, --detach Detach program from the running console. Not relevant for all platforms.");
puts(" --max-frames=NUMBER\n" puts(" --max-frames=NUMBER\n"
" Runs for the specified number of frames, then exits.\n"); " Runs for the specified number of frames, then exits.\n");
} }
@ -305,7 +305,8 @@ static void set_special_paths(char **argv, unsigned num_content)
{ {
fill_pathname_dir(global->savestate_name, global->basename, fill_pathname_dir(global->savestate_name, global->basename,
".state", sizeof(global->savestate_name)); ".state", sizeof(global->savestate_name));
RARCH_LOG("Redirecting save state to \"%s\".\n", RARCH_LOG("%s \"%s\".\n",
msg_hash_to_str(MSG_REDIRECTING_SAVESTATE_TO),
global->savestate_name); global->savestate_name);
} }
@ -325,7 +326,7 @@ void set_paths_redirect(const char *path)
uint32_t global_library_name_hash = ((global && info->info.library_name && uint32_t global_library_name_hash = ((global && info->info.library_name &&
(info->info.library_name[0] != '\0')) (info->info.library_name[0] != '\0'))
? djb2_calculate(info->info.library_name) : 0); ? msg_hash_calculate(info->info.library_name) : 0);
if( if(
global_library_name_hash != 0 && global_library_name_hash != 0 &&
@ -381,21 +382,27 @@ void set_paths_redirect(const char *path)
{ {
fill_pathname_dir(global->savefile_name, global->basename, fill_pathname_dir(global->savefile_name, global->basename,
".srm", sizeof(global->savefile_name)); ".srm", sizeof(global->savefile_name));
RARCH_LOG("Redirecting save file to \"%s\".\n", global->savefile_name); RARCH_LOG("%s \"%s\".\n",
msg_hash_to_str(MSG_REDIRECTING_SAVEFILE_TO),
global->savefile_name);
} }
if (path_is_directory(global->savestate_name)) if (path_is_directory(global->savestate_name))
{ {
fill_pathname_dir(global->savestate_name, global->basename, fill_pathname_dir(global->savestate_name, global->basename,
".state", sizeof(global->savestate_name)); ".state", sizeof(global->savestate_name));
RARCH_LOG("Redirecting save state to \"%s\".\n", global->savestate_name); RARCH_LOG("%s \"%s\".\n",
msg_hash_to_str(MSG_REDIRECTING_SAVESTATE_TO),
global->savestate_name);
} }
if (path_is_directory(global->cheatfile_name)) if (path_is_directory(global->cheatfile_name))
{ {
fill_pathname_dir(global->cheatfile_name, global->basename, fill_pathname_dir(global->cheatfile_name, global->basename,
".state", sizeof(global->cheatfile_name)); ".state", sizeof(global->cheatfile_name));
RARCH_LOG("Redirecting cheat file to \"%s\".\n", global->cheatfile_name); RARCH_LOG("%s \"%s\".\n",
msg_hash_to_str(MSG_REDIRECTING_CHEATFILE_TO),
global->cheatfile_name);
} }
} }
@ -429,7 +436,7 @@ void rarch_set_paths(const char *path)
enum rarch_content_type rarch_path_is_media_type(const char *path) enum rarch_content_type rarch_path_is_media_type(const char *path)
{ {
uint32_t hash_ext = djb2_calculate(path_get_extension(path)); uint32_t hash_ext = msg_hash_calculate(path_get_extension(path));
switch (hash_ext) switch (hash_ext)
{ {
@ -965,7 +972,8 @@ static void rarch_init_savefile_paths(void)
{ {
fill_pathname_dir(global->savefile_name, global->basename, ".srm", fill_pathname_dir(global->savefile_name, global->basename, ".srm",
sizeof(global->savefile_name)); sizeof(global->savefile_name));
RARCH_LOG("Redirecting save file to \"%s\".\n", RARCH_LOG("%s \"%s\".\n",
msg_hash_to_str(MSG_REDIRECTING_SAVEFILE_TO),
global->savefile_name); global->savefile_name);
} }
} }
@ -1105,7 +1113,7 @@ void rarch_verify_api_version(void)
RARCH_LOG("Compiled against API: %u\n", RETRO_API_VERSION); RARCH_LOG("Compiled against API: %u\n", RETRO_API_VERSION);
if (pretro_api_version() != RETRO_API_VERSION) if (pretro_api_version() != RETRO_API_VERSION)
RARCH_WARN(RETRO_LOG_LIBRETRO_ABI_BREAK); RARCH_WARN("%s\n", msg_hash_to_str(MSG_LIBRETRO_ABI_BREAK));
} }
#define FAIL_CPU(simd_type) do { \ #define FAIL_CPU(simd_type) do { \
@ -1530,7 +1538,7 @@ int rarch_defer_core(core_info_list_t *core_info, const char *dir,
size_t supported = 0; size_t supported = 0;
settings_t *settings = config_get_ptr(); settings_t *settings = config_get_ptr();
global_t *global = global_get_ptr(); global_t *global = global_get_ptr();
uint32_t menu_label_hash = djb2_calculate(menu_label); uint32_t menu_label_hash = msg_hash_calculate(menu_label);
fill_pathname_join(s, dir, path, len); fill_pathname_join(s, dir, path, len);

50
rewind.c
View File

@ -21,13 +21,14 @@
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include <retro_inline.h> #include <retro_inline.h>
#include "intl/intl.h"
#include "dynamic.h" #include "dynamic.h"
#include "general.h" #include "general.h"
#include "msg_hash.h"
#ifndef UINT16_MAX #ifndef UINT16_MAX
#define UINT16_MAX 0xffff #define UINT16_MAX 0xffff
#endif #endif
#ifndef UINT32_MAX #ifndef UINT32_MAX
#define UINT32_MAX 0xffffffffu #define UINT32_MAX 0xffffffffu
#endif #endif
@ -64,15 +65,19 @@ size thisstart;
size_t state_manager_raw_maxsize(size_t uncomp) size_t state_manager_raw_maxsize(size_t uncomp)
{ {
const int maxcblkcover = UINT16_MAX * sizeof(uint16_t); /* bytes covered by a compressed block */ /* bytes covered by a compressed block */
size_t uncomp16 = (uncomp + sizeof(uint16_t) - 1) & ~sizeof(uint16_t); /* uncompressed size, rounded to 16 bits */ const int maxcblkcover = UINT16_MAX * sizeof(uint16_t);
size_t maxcblks = (uncomp + maxcblkcover - 1) / maxcblkcover; /* number of blocks */ /* uncompressed size, rounded to 16 bits */
return uncomp16 + maxcblks * sizeof(uint16_t)*2 /* two u16 overhead per block */ + sizeof(uint16_t)*3; /* three u16 to end it */ size_t uncomp16 = (uncomp + sizeof(uint16_t) - 1) & ~sizeof(uint16_t);
/* number of blocks */
size_t maxcblks = (uncomp + maxcblkcover - 1) / maxcblkcover;
return uncomp16 + maxcblks * sizeof(uint16_t) * 2 /* two u16 overhead per block */ + sizeof(uint16_t) *
3; /* three u16 to end it */
} }
void *state_manager_raw_alloc(size_t len, uint16_t uniq) void *state_manager_raw_alloc(size_t len, uint16_t uniq)
{ {
size_t len16 = (len + sizeof(uint16_t) - 1) & ~sizeof(uint16_t); size_t len16 = (len + sizeof(uint16_t) - 1) & ~sizeof(uint16_t);
uint16_t *ret = (uint16_t*)calloc(len16 + sizeof(uint16_t) * 4 + 16, 1); uint16_t *ret = (uint16_t*)calloc(len16 + sizeof(uint16_t) * 4 + 16, 1);
@ -218,12 +223,14 @@ static INLINE size_t find_same(const uint16_t *a, const uint16_t *b)
return a - a_org; return a - a_org;
} }
size_t state_manager_raw_compress(const void *src, const void *dst, size_t len, void *patch) size_t state_manager_raw_compress(const void *src,
const void *dst, size_t len, void *patch)
{ {
const uint16_t *old16 = (const uint16_t*)src; const uint16_t *old16 = (const uint16_t*)src;
const uint16_t *new16 = (const uint16_t*)dst; const uint16_t *new16 = (const uint16_t*)dst;
uint16_t *compressed16 = (uint16_t*)patch; uint16_t *compressed16 = (uint16_t*)patch;
size_t num16s = (len + sizeof(uint16_t) - 1) / sizeof(uint16_t); size_t num16s = (len + sizeof(uint16_t) - 1)
/ sizeof(uint16_t);
while (num16s) while (num16s)
{ {
@ -276,9 +283,10 @@ size_t state_manager_raw_compress(const void *src, const void *dst, size_t len,
return (uint8_t*)(compressed16+3) - (uint8_t*)patch; return (uint8_t*)(compressed16+3) - (uint8_t*)patch;
} }
void state_manager_raw_decompress(const void *patch, size_t patchlen, void *data, size_t datalen) void state_manager_raw_decompress(const void *patch,
size_t patchlen, void *data, size_t datalen)
{ {
uint16_t *out16 = (uint16_t*)data; uint16_t *out16 = (uint16_t*)data;
const uint16_t *patch16 = (const uint16_t*)patch; const uint16_t *patch16 = (const uint16_t*)patch;
(void)patchlen; (void)patchlen;
@ -383,13 +391,13 @@ state_manager_t *state_manager_new(size_t state_size, size_t buffer_size)
if (!state) if (!state)
return NULL; return NULL;
state->blocksize = (state_size + sizeof(uint16_t) - 1) & ~sizeof(uint16_t); state->blocksize = (state_size + sizeof(uint16_t) - 1) & ~sizeof(uint16_t);
/* the compressed data is surrounded by pointers to the other side */ /* the compressed data is surrounded by pointers to the other side */
state->maxcompsize = state_manager_raw_maxsize(state_size) + sizeof(size_t) * 2; state->maxcompsize = state_manager_raw_maxsize(state_size) + sizeof(size_t) * 2;
state->data = (uint8_t*)malloc(buffer_size); state->data = (uint8_t*)malloc(buffer_size);
state->thisblock = (uint8_t*)state_manager_raw_alloc(state_size, 0); state->thisblock = (uint8_t*)state_manager_raw_alloc(state_size, 0);
state->nextblock = (uint8_t*)state_manager_raw_alloc(state_size, 1); state->nextblock = (uint8_t*)state_manager_raw_alloc(state_size, 1);
if (!state->data || !state->thisblock || !state->nextblock) if (!state->data || !state->thisblock || !state->nextblock)
goto error; goto error;
@ -560,7 +568,7 @@ void init_rewind(void)
if (audio_driver_has_callback()) if (audio_driver_has_callback())
{ {
RARCH_ERR(RETRO_LOG_REWIND_INIT_FAILED_THREADED_AUDIO); RARCH_ERR("%s.\n", msg_hash_to_str(MSG_REWIND_INIT_FAILED));
return; return;
} }
@ -568,18 +576,20 @@ void init_rewind(void)
if (!global->rewind.size) if (!global->rewind.size)
{ {
RARCH_ERR(RETRO_LOG_REWIND_INIT_FAILED_NO_SAVESTATES); RARCH_ERR("%s.\n",
msg_hash_to_str(MSG_REWIND_INIT_FAILED_THREADED_AUDIO));
return; return;
} }
RARCH_LOG(RETRO_MSG_REWIND_INIT "%u MB\n", RARCH_LOG("%s: %u MB\n",
msg_hash_to_str(MSG_REWIND_INIT),
(unsigned)(settings->rewind_buffer_size / 1000000)); (unsigned)(settings->rewind_buffer_size / 1000000));
global->rewind.state = state_manager_new(global->rewind.size, global->rewind.state = state_manager_new(global->rewind.size,
settings->rewind_buffer_size); settings->rewind_buffer_size);
if (!global->rewind.state) if (!global->rewind.state)
RARCH_WARN(RETRO_LOG_REWIND_INIT_FAILED); RARCH_WARN("%s.\n", msg_hash_to_str(MSG_REWIND_INIT_FAILED));
state_manager_push_where(global->rewind.state, &state); state_manager_push_where(global->rewind.state, &state);
pretro_serialize(state, global->rewind.size); pretro_serialize(state, global->rewind.size);

50
runloop.c
View File

@ -21,12 +21,10 @@
#include <retro_log.h> #include <retro_log.h>
#include <compat/strl.h> #include <compat/strl.h>
#include <rhash.h>
#include "configuration.h" #include "configuration.h"
#include "dynamic.h" #include "dynamic.h"
#include "performance.h" #include "performance.h"
#include "intl/intl.h"
#include "retroarch.h" #include "retroarch.h"
#include "runloop.h" #include "runloop.h"
#include "runloop_data.h" #include "runloop_data.h"
@ -142,7 +140,8 @@ static void check_stateslots(bool pressed_increase, bool pressed_decrease)
else else
return; return;
snprintf(msg, sizeof(msg), "State slot: %d", snprintf(msg, sizeof(msg), "%s: %d",
msg_hash_to_str(MSG_STATE_SLOT),
settings->state_slot); settings->state_slot);
rarch_main_msg_queue_push(msg, 1, 180, true); rarch_main_msg_queue_push(msg, 1, 180, true);
@ -268,7 +267,9 @@ static bool check_movie_init(void)
strlcpy(path, global->bsv.movie_path, sizeof(path)); strlcpy(path, global->bsv.movie_path, sizeof(path));
strlcat(path, ".bsv", sizeof(path)); strlcat(path, ".bsv", sizeof(path));
snprintf(msg, sizeof(msg), "Starting movie record to \"%s\".", path); snprintf(msg, sizeof(msg), "%s \"%s\".",
msg_hash_to_str(MSG_STARTING_MOVIE_RECORD_TO),
path);
global->bsv.movie = bsv_movie_init(path, RARCH_MOVIE_RECORD); global->bsv.movie = bsv_movie_init(path, RARCH_MOVIE_RECORD);
@ -279,14 +280,16 @@ static bool check_movie_init(void)
if (global->bsv.movie) if (global->bsv.movie)
{ {
rarch_main_msg_queue_push(msg, 1, 180, true); rarch_main_msg_queue_push(msg, 1, 180, true);
RARCH_LOG("Starting movie record to \"%s\".\n", path); RARCH_LOG("%s \"%s\".\n",
msg_hash_to_str(MSG_STARTING_MOVIE_RECORD_TO),
path);
} }
else else
{ {
rarch_main_msg_queue_push_new( rarch_main_msg_queue_push_new(
MSG_FAILED_TO_START_MOVIE_RECORD, MSG_FAILED_TO_START_MOVIE_RECORD,
1, 180, true); 1, 180, true);
RARCH_ERR("Failed to start movie record.\n"); RARCH_ERR(msg_hash_to_str(MSG_FAILED_TO_START_MOVIE_RECORD));
} }
return ret; return ret;
@ -305,9 +308,9 @@ static bool check_movie_record(void)
if (!global->bsv.movie) if (!global->bsv.movie)
return false; return false;
rarch_main_msg_queue_push( rarch_main_msg_queue_push_new(
RETRO_MSG_MOVIE_RECORD_STOPPING, 2, 180, true); MSG_MOVIE_RECORD_STOPPED, 2, 180, true);
RARCH_LOG(RETRO_LOG_MOVIE_RECORD_STOPPING); RARCH_LOG("%s\n", msg_hash_to_str(MSG_MOVIE_RECORD_STOPPED));
event_command(EVENT_CMD_BSV_MOVIE_DEINIT); event_command(EVENT_CMD_BSV_MOVIE_DEINIT);
@ -327,9 +330,9 @@ static bool check_movie_playback(void)
if (!global->bsv.movie_end) if (!global->bsv.movie_end)
return false; return false;
rarch_main_msg_queue_push( rarch_main_msg_queue_push_new(
RETRO_MSG_MOVIE_PLAYBACK_ENDED, 1, 180, false); MSG_MOVIE_PLAYBACK_ENDED, 1, 180, false);
RARCH_LOG(RETRO_LOG_MOVIE_PLAYBACK_ENDED); RARCH_LOG("%s\n", msg_hash_to_str(MSG_MOVIE_PLAYBACK_ENDED));
event_command(EVENT_CMD_BSV_MOVIE_DEINIT); event_command(EVENT_CMD_BSV_MOVIE_DEINIT);
@ -395,7 +398,7 @@ static void check_shader_dir(bool pressed_next, bool pressed_prev)
shader = global->shader_dir.list->elems[global->shader_dir.ptr].data; shader = global->shader_dir.list->elems[global->shader_dir.ptr].data;
ext = path_get_extension(shader); ext = path_get_extension(shader);
ext_hash = djb2_calculate(ext); ext_hash = msg_hash_calculate(ext);
switch (ext_hash) switch (ext_hash)
{ {
@ -411,13 +414,16 @@ static void check_shader_dir(bool pressed_next, bool pressed_prev)
return; return;
} }
snprintf(msg, sizeof(msg), "Shader #%u: \"%s\".", snprintf(msg, sizeof(msg), "%s #%u: \"%s\".",
msg_hash_to_str(MSG_SHADER),
(unsigned)global->shader_dir.ptr, shader); (unsigned)global->shader_dir.ptr, shader);
rarch_main_msg_queue_push(msg, 1, 120, true); rarch_main_msg_queue_push(msg, 1, 120, true);
RARCH_LOG("Applying shader \"%s\".\n", shader); RARCH_LOG("%s \"%s\".\n",
msg_hash_to_str(MSG_APPLYING_SHADER),
shader);
if (!video_driver_set_shader(type, shader)) if (!video_driver_set_shader(type, shader))
RARCH_WARN("Failed to apply shader.\n"); RARCH_WARN(msg_hash_to_str(MSG_FAILED_TO_APPLY_SHADER));
} }
#ifdef HAVE_MENU #ifdef HAVE_MENU
@ -548,7 +554,8 @@ static int do_state_checks(event_cmd_state_t *cmd)
#ifdef HAVE_NETPLAY #ifdef HAVE_NETPLAY
if (driver->netplay_data) if (driver->netplay_data)
return do_netplay_state_checks(cmd->netplay_flip_pressed, cmd->fullscreen_toggle); return do_netplay_state_checks(cmd->netplay_flip_pressed,
cmd->fullscreen_toggle);
#endif #endif
check_pause(cmd->pause_pressed, cmd->frameadvance_pressed); check_pause(cmd->pause_pressed, cmd->frameadvance_pressed);
@ -560,8 +567,10 @@ static int do_state_checks(event_cmd_state_t *cmd)
cmd->rewind_pressed)) cmd->rewind_pressed))
return 1; return 1;
check_fast_forward_button(cmd->fastforward_pressed, cmd->hold_pressed, cmd->old_hold_pressed); check_fast_forward_button(cmd->fastforward_pressed,
check_stateslots(cmd->state_slot_increase, cmd->state_slot_decrease); cmd->hold_pressed, cmd->old_hold_pressed);
check_stateslots(cmd->state_slot_increase,
cmd->state_slot_decrease);
if (cmd->save_state_pressed) if (cmd->save_state_pressed)
event_command(EVENT_CMD_SAVE_STATE); event_command(EVENT_CMD_SAVE_STATE);
@ -574,7 +583,8 @@ static int do_state_checks(event_cmd_state_t *cmd)
if (cmd->movie_record) if (cmd->movie_record)
check_movie(); check_movie();
check_shader_dir(cmd->shader_next_pressed, cmd->shader_prev_pressed); check_shader_dir(cmd->shader_next_pressed,
cmd->shader_prev_pressed);
if (cmd->disk_eject_pressed) if (cmd->disk_eject_pressed)
event_command(EVENT_CMD_DISK_EJECT_TOGGLE); event_command(EVENT_CMD_DISK_EJECT_TOGGLE);

12
screenshot.c
View File

@ -35,7 +35,7 @@
#endif #endif
#include "general.h" #include "general.h"
#include "intl/intl.h" #include "msg_hash.h"
#include "gfx/scaler/scaler.h" #include "gfx/scaler/scaler.h"
#include "retroarch.h" #include "retroarch.h"
#include "runloop.h" #include "runloop.h"
@ -316,20 +316,20 @@ bool take_screenshot(void)
} }
else else
{ {
RARCH_ERR(RETRO_LOG_TAKE_SCREENSHOT_ERROR); RARCH_ERR("%s.\n", msg_hash_to_str(MSG_FAILED_TO_TAKE_SCREENSHOT));
ret = false; ret = false;
} }
if (ret) if (ret)
{ {
RARCH_LOG(RETRO_LOG_TAKE_SCREENSHOT); RARCH_LOG("%s.\n", msg_hash_to_str(MSG_TAKING_SCREENSHOT));
msg = RETRO_MSG_TAKE_SCREENSHOT; msg = msg_hash_to_str(MSG_TAKING_SCREENSHOT);
} }
else else
{ {
RARCH_WARN(RETRO_LOG_TAKE_SCREENSHOT_FAILED); RARCH_WARN("%s.\n", msg_hash_to_str(MSG_FAILED_TO_TAKE_SCREENSHOT));
msg = RETRO_MSG_TAKE_SCREENSHOT_FAILED; msg = msg_hash_to_str(MSG_FAILED_TO_TAKE_SCREENSHOT);
} }
rarch_main_msg_queue_push(msg, 1, runloop->is_paused ? 1 : 180, true); rarch_main_msg_queue_push(msg, 1, runloop->is_paused ? 1 : 180, true);

9
system.c
View File

@ -17,7 +17,7 @@
#include "system.h" #include "system.h"
#include "dynamic.h" #include "dynamic.h"
#include "intl/intl.h" #include "msg_hash.h"
#ifdef HAVE_ZLIB #ifdef HAVE_ZLIB
#define DEFAULT_EXT "zip" #define DEFAULT_EXT "zip"
@ -69,13 +69,14 @@ void rarch_system_info_init(void)
pretro_get_system_info(&system->info); pretro_get_system_info(&system->info);
if (!system->info.library_name) if (!system->info.library_name)
system->info.library_name = "Unknown"; system->info.library_name = msg_hash_to_str(MSG_UNKNOWN);
if (!system->info.library_version) if (!system->info.library_version)
system->info.library_version = "v0"; system->info.library_version = "v0";
#ifndef RARCH_CONSOLE #ifndef RARCH_CONSOLE
snprintf(system->title_buf, sizeof(system->title_buf), strlcpy(system->title_buf,
RETRO_FRONTEND " : "); msg_hash_to_str(MSG_PROGRAM), sizeof(system->title_buf));
strlcat(system->title_buf, " : ", sizeof(system->title_buf));
#endif #endif
strlcat(system->title_buf, system->info.library_name, sizeof(system->title_buf)); strlcat(system->title_buf, system->info.library_name, sizeof(system->title_buf));
strlcat(system->title_buf, " ", sizeof(system->title_buf)); strlcat(system->title_buf, " ", sizeof(system->title_buf));

43
tasks/task_database.c
View File

@ -16,11 +16,9 @@
#include <compat/strcasestr.h> #include <compat/strcasestr.h>
#include <compat/strl.h> #include <compat/strl.h>
#include <rhash.h>
#include "../dir_list_special.h" #include "../dir_list_special.h"
#include "../file_ops.h" #include "../file_ops.h"
#include "../msg_hash.h"
#include "../general.h" #include "../general.h"
#include "../runloop_data.h" #include "../runloop_data.h"
#include "tasks.h" #include "tasks.h"
@ -58,11 +56,14 @@ static int database_info_iterate_start
snprintf(msg, sizeof(msg), snprintf(msg, sizeof(msg),
#ifdef _WIN32 #ifdef _WIN32
"%Iu/%Iu: Scanning %s...\n", "%Iu/%Iu: %s %s...\n",
#else #else
"%zu/%zu: Scanning %s...\n", "%zu/%zu: %s %s...\n",
#endif #endif
db->list_ptr, db->list->size, name); db->list_ptr,
db->list->size,
msg_hash_to_str(MSG_SCANNING),
name);
if (msg[0] != '\0') if (msg[0] != '\0')
rarch_main_msg_queue_push(msg, 1, 180, true); rarch_main_msg_queue_push(msg, 1, 180, true);
@ -85,7 +86,7 @@ static int database_info_iterate_playlist(
path_parent_dir(parent_dir); path_parent_dir(parent_dir);
extension_hash = djb2_calculate(path_get_extension(name)); extension_hash = msg_hash_calculate(path_get_extension(name));
switch (extension_hash) switch (extension_hash)
{ {
@ -151,13 +152,6 @@ static int database_info_list_iterate_new(database_state_handle_t *db_state, con
return 0; return 0;
} }
/* TODO/FIXME -
* * - What 'core' to bind a playlist entry to if
* we are in Load Content (Detect Core)? Let the user
* choose the core to be loaded with it upon selecting
* the playlist entry?
* * - Implement ZIP handling.
**/
static int database_info_list_iterate_found_match( static int database_info_list_iterate_found_match(
database_state_handle_t *db_state, database_state_handle_t *db_state,
database_info_handle_t *db, database_info_handle_t *db,
@ -168,13 +162,14 @@ static int database_info_list_iterate_found_match(
char db_playlist_path[PATH_MAX_LENGTH] = {0}; char db_playlist_path[PATH_MAX_LENGTH] = {0};
char db_playlist_base_str[PATH_MAX_LENGTH] = {0}; char db_playlist_base_str[PATH_MAX_LENGTH] = {0};
char entry_path_str[PATH_MAX_LENGTH] = {0}; char entry_path_str[PATH_MAX_LENGTH] = {0};
content_playlist_t *playlist = NULL; content_playlist_t *playlist = NULL;
settings_t *settings = config_get_ptr(); settings_t *settings = config_get_ptr();
const char *db_path = db_state->list->elems[db_state->list_index].data; const char *db_path = db_state->list->elems[db_state->list_index].data;
const char *entry_path = db ? db->list->elems[db->list_ptr].data : NULL; const char *entry_path = db ? db->list->elems[db->list_ptr].data : NULL;
database_info_t *db_info_entry = &db_state->info->list[db_state->entry_index]; database_info_t *db_info_entry = &db_state->info->list[db_state->entry_index];
fill_short_pathname_representation(db_playlist_base_str, db_path, sizeof(db_playlist_base_str)); fill_short_pathname_representation(db_playlist_base_str,
db_path, sizeof(db_playlist_base_str));
path_remove_extension(db_playlist_base_str); path_remove_extension(db_playlist_base_str);
@ -205,7 +200,8 @@ static int database_info_list_iterate_found_match(
RARCH_LOG("entry path str: %s\n", entry_path_str); RARCH_LOG("entry path str: %s\n", entry_path_str);
#endif #endif
content_playlist_push(playlist, entry_path_str, db_info_entry->name, "DETECT", "DETECT", db_crc, db_playlist_base_str); content_playlist_push(playlist, entry_path_str,
db_info_entry->name, "DETECT", "DETECT", db_crc, db_playlist_base_str);
content_playlist_write_file(playlist); content_playlist_write_file(playlist);
content_playlist_free(playlist); content_playlist_free(playlist);
@ -296,9 +292,6 @@ static int database_info_iterate_playlist_zip(
return 1; return 1;
} }
static int database_info_iterate(database_state_handle_t *state, database_info_handle_t *db) static int database_info_iterate(database_state_handle_t *state, database_info_handle_t *db)
{ {
const char *name = db ? db->list->elems[db->list_ptr].data : NULL; const char *name = db ? db->list->elems[db->list_ptr].data : NULL;
@ -342,7 +335,7 @@ static int database_info_poll(db_handle_t *db)
if (str_list->size > 0) if (str_list->size > 0)
strlcpy(elem0, str_list->elems[0].data, sizeof(elem0)); strlcpy(elem0, str_list->elems[0].data, sizeof(elem0));
if (str_list->size > 1) if (str_list->size > 1)
cb_type_hash = djb2_calculate(str_list->elems[1].data); cb_type_hash = msg_hash_calculate(str_list->elems[1].data);
switch (cb_type_hash) switch (cb_type_hash)
{ {
@ -413,7 +406,7 @@ void rarch_main_data_db_iterate(bool is_thread, void *data)
} }
else else
{ {
rarch_main_msg_queue_push("Scanning of directory finished.\n", 0, 180, true); rarch_main_msg_queue_push_new(MSG_SCANNING_OF_DIRECTORY_FINISHED, 0, 180, true);
db->status = DATABASE_STATUS_FREE; db->status = DATABASE_STATUS_FREE;
} }
break; break;

54
tasks/task_http.c
View File

@ -19,11 +19,11 @@
#include <string/string_list.h> #include <string/string_list.h>
#include <compat/strl.h> #include <compat/strl.h>
#include <file/file_path.h> #include <file/file_path.h>
#include <rhash.h>
#include <net/net_compat.h> #include <net/net_compat.h>
#include "../file_ops.h" #include "../file_ops.h"
#include "../general.h" #include "../general.h"
#include "../msg_hash.h"
#include "../runloop_data.h" #include "../runloop_data.h"
#include "tasks.h" #include "tasks.h"
@ -102,10 +102,10 @@ static int cb_generic_download(void *data, size_t len,
if (!write_file(output_path, data, len)) if (!write_file(output_path, data, len))
return -1; return -1;
snprintf(msg, sizeof(msg), "Download complete: %s.", snprintf(msg, sizeof(msg), "%s: %s.",
msg_hash_to_str(MSG_DOWNLOAD_COMPLETE),
core_updater_path); core_updater_path);
rarch_main_msg_queue_push(msg, 1, 90, true); rarch_main_msg_queue_push(msg, 1, 90, true);
#ifdef HAVE_ZLIB #ifdef HAVE_ZLIB
@ -118,7 +118,7 @@ static int cb_generic_download(void *data, size_t len,
{ {
if (!zlib_parse_file(output_path, NULL, zlib_extract_core_callback, if (!zlib_parse_file(output_path, NULL, zlib_extract_core_callback,
(void*)dir_path)) (void*)dir_path))
RARCH_LOG("Could not process ZIP file.\n"); RARCH_LOG(msg_hash_to_str(MSG_COULD_NOT_PROCESS_ZIP_FILE));
if (path_file_exists(output_path)) if (path_file_exists(output_path))
remove(output_path); remove(output_path);
@ -251,7 +251,7 @@ static int cb_http_conn_default(void *data_, size_t len)
if (http->connection.elem1[0] != '\0') if (http->connection.elem1[0] != '\0')
{ {
uint32_t label_hash = djb2_calculate(http->connection.elem1); uint32_t label_hash = msg_hash_calculate(http->connection.elem1);
switch (label_hash) switch (label_hash)
{ {
@ -352,27 +352,29 @@ static int rarch_main_data_http_iterate_poll(http_handle_t *http)
**/ **/
static int rarch_main_data_http_iterate_transfer(void *data) static int rarch_main_data_http_iterate_transfer(void *data)
{ {
http_handle_t *http = (http_handle_t*)data; http_handle_t *http = (http_handle_t*)data;
size_t pos = 0, tot = 0; size_t pos = 0, tot = 0;
int percent = 0; int percent = 0;
if (!net_http_update(http->handle, &pos, &tot))
{ if (!net_http_update(http->handle, &pos, &tot))
if(tot != 0) {
percent=(unsigned long long)pos*100/(unsigned long long)tot; if(tot != 0)
else percent = (unsigned long long)pos * 100
percent=0; / (unsigned long long)tot;
if (percent > 0) if (percent > 0)
{ {
char tmp[PATH_MAX_LENGTH] = {0}; char tmp[PATH_MAX_LENGTH] = {0};
snprintf(tmp, sizeof(tmp), "Download progress: %d%%", percent); snprintf(tmp, sizeof(tmp), "%s: %d%%",
data_runloop_osd_msg(tmp, sizeof(tmp)); msg_hash_to_str(MSG_DOWNLOAD_PROGRESS),
} percent);
data_runloop_osd_msg(tmp, sizeof(tmp));
return -1; }
}
return -1;
return 0; }
return 0;
} }
void rarch_main_data_http_iterate(bool is_thread, void *data) void rarch_main_data_http_iterate(bool is_thread, void *data)