diff --git a/.gitmodules b/.gitmodules index 71d65bba2f..92451c5e52 100644 --- a/.gitmodules +++ b/.gitmodules @@ -1,6 +1,6 @@ [submodule "deps/glslang/glslang"] path = deps/glslang/glslang - url = git://github.com/KhronosGroup/glslang.git + url = https://github.com/KhronosGroup/glslang.git [submodule "deps/SPIRV-Cross"] path = deps/SPIRV-Cross - url = git://github.com/KhronosGroup/SPIRV-Cross + url = https://github.com/KhronosGroup/SPIRV-Cross diff --git a/Makefile.common b/Makefile.common index 4565f1f57b..818ec1715b 100644 --- a/Makefile.common +++ b/Makefile.common @@ -246,7 +246,8 @@ OBJ += intl/msg_hash_de.o \ intl/msg_hash_nl.o \ intl/msg_hash_pl.o \ intl/msg_hash_pt.o \ - intl/msg_hash_ru.o + intl/msg_hash_ru.o \ + intl/msg_hash_vn.o endif diff --git a/Makefile.wiiu b/Makefile.wiiu index 62f0c303d2..a29b98c070 100644 --- a/Makefile.wiiu +++ b/Makefile.wiiu @@ -12,6 +12,7 @@ OBJ += wiiu/dynamic_libs/fs_functions.o OBJ += wiiu/dynamic_libs/padscore_functions.o OBJ += wiiu/dynamic_libs/vpad_functions.o OBJ += wiiu/system/memory.o +OBJ += wiiu/system/exception_handler.o OBJ += wiiu/dynamic_libs/gx2_functions.o OBJ += wiiu/dynamic_libs/socket_functions.o OBJ += wiiu/fs/fs_utils.o @@ -100,20 +101,20 @@ LIBDIRS := -L. CFLAGS := -mrvl -mcpu=750 -meabi -mhard-float LDFLAGS := -#LDFLAGS := $(CFLAGS) ifeq ($(DEBUG), 1) CFLAGS += -O0 -g else CFLAGS += -O3 endif +LDFLAGS := $(CFLAGS) ASFLAGS := $(CFLAGS) -mregnames CFLAGS += -ffast-math -Werror=implicit-function-declaration #CFLAGS += -fomit-frame-pointer -mword-relocations #CFLAGS += -Wall -CFLAGS += -DWIIU +CFLAGS += -DWIIU -DMSB_FIRST CFLAGS += -DHAVE_MAIN CFLAGS += -DRARCH_INTERNAL -DRARCH_CONSOLE -DSINC_LOWEST_QUALITY CFLAGS += -DHAVE_FILTERS_BUILTIN $(DEFINES) diff --git a/command.c b/command.c index 263d1bb17a..5609a4f3a0 100644 --- a/command.c +++ b/command.c @@ -1,5 +1,6 @@ /* RetroArch - A frontend for libretro. * Copyright (C) 2011-2016 - Daniel De Matteis + * Copyright (C) 2016 - Brad Parker * * 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- diff --git a/command.h b/command.h index 0b5843059f..475a02cb7d 100644 --- a/command.h +++ b/command.h @@ -1,6 +1,7 @@ /* RetroArch - A frontend for libretro. * Copyright (C) 2010-2014 - Hans-Kristian Arntzen * Copyright (C) 2011-2016 - Daniel De Matteis + * Copyright (C) 2016 - Brad Parker * * 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- diff --git a/config.def.h b/config.def.h index 867614efd5..040ea09e32 100644 --- a/config.def.h +++ b/config.def.h @@ -1,6 +1,7 @@ /* RetroArch - A frontend for libretro. * Copyright (C) 2010-2014 - Hans-Kristian Arntzen * Copyright (C) 2011-2016 - Daniel De Matteis + * Copyright (C) 2016 - Brad Parker * * 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- diff --git a/configuration.c b/configuration.c index a1eaecda86..281ad1ad01 100644 --- a/configuration.c +++ b/configuration.c @@ -1,6 +1,8 @@ /* RetroArch - A frontend for libretro. * Copyright (C) 2010-2014 - Hans-Kristian Arntzen * Copyright (C) 2011-2016 - Daniel De Matteis + * Copyright (C) 2014-2016 - Jean-André Santoni + * Copyright (C) 2016 - Brad Parker * * 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- diff --git a/configuration.h b/configuration.h index 0c1a46534f..9cf3d78e8f 100644 --- a/configuration.h +++ b/configuration.h @@ -1,6 +1,8 @@ /* RetroArch - A frontend for libretro. * Copyright (C) 2010-2014 - Hans-Kristian Arntzen * Copyright (C) 2011-2016 - Daniel De Matteis + * Copyright (C) 2014-2016 - Jean-André Santoni + * Copyright (C) 2016 - Brad Parker * * 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- diff --git a/content.h b/content.h index fa61dada24..6900c0fa55 100644 --- a/content.h +++ b/content.h @@ -1,6 +1,7 @@ /* RetroArch - A frontend for libretro. * Copyright (C) 2010-2014 - Hans-Kristian Arntzen * Copyright (C) 2011-2016 - Daniel De Matteis + * Copyright (C) 2016 - Brad Parker * * 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- diff --git a/core_impl.c b/core_impl.c index a53e9f0213..5d669d6f01 100644 --- a/core_impl.c +++ b/core_impl.c @@ -2,6 +2,7 @@ * Copyright (C) 2010-2014 - Hans-Kristian Arntzen * Copyright (C) 2011-2016 - Daniel De Matteis * Copyright (C) 2012-2015 - Michael Lelli + * Copyright (C) 2016 - Brad Parker * * 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- diff --git a/core_info.c b/core_info.c index 4a06e44f36..eca5785845 100644 --- a/core_info.c +++ b/core_info.c @@ -2,6 +2,7 @@ * Copyright (C) 2010-2014 - Hans-Kristian Arntzen * Copyright (C) 2011-2016 - Daniel De Matteis * Copyright (C) 2013-2015 - Jason Fetters + * Copyright (C) 2016 - Brad Parker * * 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- diff --git a/core_info.h b/core_info.h index b1f31e3c3b..469188185b 100644 --- a/core_info.h +++ b/core_info.h @@ -2,6 +2,7 @@ * Copyright (C) 2010-2014 - Hans-Kristian Arntzen * Copyright (C) 2011-2016 - Daniel De Matteis * Copyright (C) 2013-2015 - Jason Fetters + * Copyright (C) 2016 - Brad Parker * * 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- diff --git a/cores/libretro-ffmpeg/ffmpeg_core.c b/cores/libretro-ffmpeg/ffmpeg_core.c index c0eefbb081..6d090d4dfd 100644 --- a/cores/libretro-ffmpeg/ffmpeg_core.c +++ b/cores/libretro-ffmpeg/ffmpeg_core.c @@ -1,3 +1,4 @@ +/* Copyright (C) 2016 - Brad Parker */ #include #include #include diff --git a/database_info.c b/database_info.c index 49b46af3c6..37be9b16f9 100644 --- a/database_info.c +++ b/database_info.c @@ -2,6 +2,7 @@ * Copyright (C) 2010-2014 - Hans-Kristian Arntzen * Copyright (C) 2011-2016 - Daniel De Matteis * Copyright (C) 2013-2015 - Jason Fetters + * Copyright (C) 2016 - Brad Parker * * 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- diff --git a/database_info.h b/database_info.h index f6c63fe79f..7ec56de6a1 100644 --- a/database_info.h +++ b/database_info.h @@ -2,6 +2,7 @@ * Copyright (C) 2010-2014 - Hans-Kristian Arntzen * Copyright (C) 2011-2016 - Daniel De Matteis * Copyright (C) 2013-2015 - Jason Fetters + * Copyright (C) 2016 - Brad Parker * * 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- diff --git a/frontend/drivers/platform_wiiu.c b/frontend/drivers/platform_wiiu.c index 1c3fbd2b79..c97a6fe557 100644 --- a/frontend/drivers/platform_wiiu.c +++ b/frontend/drivers/platform_wiiu.c @@ -43,10 +43,15 @@ #include "dynamic_libs/vpad_functions.h" #include "dynamic_libs/padscore_functions.h" #include "dynamic_libs/socket_functions.h" +//#include "dynamic_libs/curl_functions.h" #include "dynamic_libs/ax_functions.h" +//#include "dynamic_libs/aoc_functions.h" +//#include "dynamic_libs/acp_functions.h" #include "fs/fs_utils.h" #include "fs/sd_fat_devoptab.h" #include "system/memory.h" +#include "system/exception_handler.h" +#include "system/exception.h" #include "utils/logger.h" #include "utils/utils.h" #include "common/common.h" @@ -224,6 +229,10 @@ static int log_write(struct _reent *r, int fd, const char *ptr, size_t len) return len; } +void net_print(const char* str) +{ + log_write(NULL, 0, str, strlen(str)); +} static devoptab_t dotab_stdout = { "stdout", // device name @@ -257,13 +266,24 @@ int __entry_menu(int argc, char **argv) InitSocketFunctionPointers(); log_init("10.42.0.1"); - devoptab_list[STD_OUT] = &dotab_stdout; devoptab_list[STD_ERR] = &dotab_stdout; + InitFSFunctionPointers(); + InitGX2FunctionPointers(); + InitSysFunctionPointers(); InitVPadFunctionPointers(); + InitPadScoreFunctionPointers(); + InitAXFunctionPointers(); +// InitCurlFunctionPointers(); +// InitAocFunctionPointers(); +// InitACPFunctionPointers(); + + memoryInitialize(); mount_sd_fat("sd"); +// setup_os_exceptions(); + InstallExceptionHandler(); VPADInit(); OSScreenInit(); @@ -287,8 +307,8 @@ int __entry_menu(int argc, char **argv) unsigned sleep_ms = 0; int ret = runloop_iterate(&sleep_ms); - if (ret == 1 && sleep_ms > 0) - retro_sleep(sleep_ms); +// if (ret == 1 && sleep_ms > 0) +// retro_sleep(sleep_ms); task_queue_ctl(TASK_QUEUE_CTL_CHECK, NULL); if (ret == -1) break; diff --git a/frontend/frontend_driver.c b/frontend/frontend_driver.c index 7a922bc394..30ea21f2e0 100644 --- a/frontend/frontend_driver.c +++ b/frontend/frontend_driver.c @@ -37,6 +37,9 @@ static frontend_ctx_driver_t *frontend_ctx_drivers[] = { #if defined(GEKKO) &frontend_ctx_gx, #endif +#if defined(WIIU) + &frontend_ctx_wiiu, +#endif #if defined(__QNX__) &frontend_ctx_qnx, #endif diff --git a/frontend/frontend_driver.h b/frontend/frontend_driver.h index f1d53bffe5..e5a723e8c4 100644 --- a/frontend/frontend_driver.h +++ b/frontend/frontend_driver.h @@ -92,6 +92,7 @@ typedef struct frontend_ctx_driver } frontend_ctx_driver_t; extern frontend_ctx_driver_t frontend_ctx_gx; +extern frontend_ctx_driver_t frontend_ctx_wiiu; extern frontend_ctx_driver_t frontend_ctx_ps3; extern frontend_ctx_driver_t frontend_ctx_xdk; extern frontend_ctx_driver_t frontend_ctx_qnx; diff --git a/gfx/drivers/wiiu_gfx.c b/gfx/drivers/wiiu_gfx.c index 79822ddd71..044e552ec2 100644 --- a/gfx/drivers/wiiu_gfx.c +++ b/gfx/drivers/wiiu_gfx.c @@ -39,22 +39,23 @@ typedef struct int width; int height; bool enable; - }menu; + } menu; void* texture; int tex_width; int tex_height; -}wiiu_video_t; +} wiiu_video_t; -static void *wiiu_gfx_init(const video_info_t *video, - const input_driver_t **input, void **input_data) +static void* wiiu_gfx_init(const video_info_t* video, + const input_driver_t** input, void** input_data) { *input = NULL; *input_data = NULL; wiiu_video_t* wiiu = calloc(1, sizeof(*wiiu)); - if(!wiiu) + + if (!wiiu) return NULL; wiiu->screen_buffer0_size = OSScreenGetBufferSizeEx(0); @@ -101,11 +102,11 @@ static void *wiiu_gfx_init(const video_info_t *video, return wiiu; } -static void wiiu_gfx_free(void *data) +static void wiiu_gfx_free(void* data) { wiiu_video_t* wiiu = (wiiu_video_t*) data; - if(!wiiu) + if (!wiiu) return; MEM1_free(wiiu->screen_buffer0); @@ -117,9 +118,9 @@ static void wiiu_gfx_free(void *data) } -static bool wiiu_gfx_frame(void *data, const void *frame, - unsigned width, unsigned height, uint64_t frame_count, - unsigned pitch, const char *msg) +static bool wiiu_gfx_frame(void* data, const void* frame, + unsigned width, unsigned height, uint64_t frame_count, + unsigned pitch, const char* msg) { (void)frame; (void)width; @@ -135,33 +136,51 @@ static bool wiiu_gfx_frame(void *data, const void *frame, snprintf(frames_str, sizeof(frames_str), "frames : %i", frames++); OSScreenClearBufferEx(1, 0); -// OSScreenPutFontEx(1, 0, 0, "Hello world on DRC!!!"); - const uint16_t* src = (uint16_t*)wiiu->menu.texture; - uint32_t* dst = (uint32_t*)((uint8_t*)wiiu->screen_buffer1 + wiiu->screen_buffer1_id * wiiu->screen_buffer1_size / 2); -// for (i = 0; i < wiiu->menu.height; i++) -// { -// memcpy(dst, src, wiiu->menu.width * sizeof(uint16_t)); -// dst += 896; -// src += wiiu->menu.tex_width; -// } - - dst += 896 * (480 - wiiu->menu.height) / 2 + (896 - wiiu->menu.width) / 2; - int x, y; - for(y = 0; y < wiiu->menu.height; y++) + if (wiiu->menu.enable) { - for(x = 0; x < wiiu->menu.width; x++) + const uint16_t* src = (uint16_t*)wiiu->menu.texture; + uint32_t* dst = (uint32_t*)((uint8_t*)wiiu->screen_buffer1 + wiiu->screen_buffer1_id * wiiu->screen_buffer1_size / 2); + + dst += 896 * (480 - wiiu->menu.height) / 2 + (896 - wiiu->menu.width) / 2; + int x, y; + + for (y = 0; y < wiiu->menu.height; y++) { - int r = ((src[x] >> 12) & 0xF) << 4; - int g = ((src[x] >> 8) & 0xF) << 4; - int b = ((src[x] >> 4) & 0xF) << 4; -// r = 0; -// g = 0; -// b = 0; - dst[x] = (r << 0) | (b << 8) | (g << 16); + for (x = 0; x < wiiu->menu.width; x++) + { + int r = ((src[x] >> 12) & 0xF) << 4; + int g = ((src[x] >> 8) & 0xF) << 4; + int b = ((src[x] >> 4) & 0xF) << 4; + dst[x] = (r << 0) | (b << 8) | (g << 16); + } + + src += wiiu->menu.tex_width; + dst += 896; + } + + } + else + { + const uint16_t* src = (uint16_t*)frame; + uint32_t* dst = (uint32_t*)((uint8_t*)wiiu->screen_buffer1 + wiiu->screen_buffer1_id * wiiu->screen_buffer1_size / 2); + + dst += (896 * (480 - height) + width) / 2; + int x, y; + + for (y = 0; y < height; y++) + { + for (x = 0; x < width; x++) + { + int r = ((src[x] >> 11) & 0x1F) << 3; + int g = ((src[x] >> 5) & 0x3F) << 2; + int b = ((src[x] >> 0) & 0x1F) << 3; + dst[x] = (r << 0) | (b << 8) | (g << 16); + } + + src += pitch/2; + dst += 896; } - src += wiiu->menu.tex_width; - dst += 896; } @@ -177,39 +196,39 @@ static bool wiiu_gfx_frame(void *data, const void *frame, return true; } -static void wiiu_gfx_set_nonblock_state(void *data, bool toggle) +static void wiiu_gfx_set_nonblock_state(void* data, bool toggle) { (void)data; (void)toggle; } -static bool wiiu_gfx_alive(void *data) +static bool wiiu_gfx_alive(void* data) { (void)data; return true; } -static bool wiiu_gfx_focus(void *data) +static bool wiiu_gfx_focus(void* data) { (void)data; return true; } -static bool wiiu_gfx_suppress_screensaver(void *data, bool enable) +static bool wiiu_gfx_suppress_screensaver(void* data, bool enable) { (void)data; (void)enable; return false; } -static bool wiiu_gfx_has_windowed(void *data) +static bool wiiu_gfx_has_windowed(void* data) { (void)data; return true; } -static bool wiiu_gfx_set_shader(void *data, - enum rarch_shader_type type, const char *path) +static bool wiiu_gfx_set_shader(void* data, + enum rarch_shader_type type, const char* path) { (void)data; (void)type; @@ -218,21 +237,21 @@ static bool wiiu_gfx_set_shader(void *data, return false; } -static void wiiu_gfx_set_rotation(void *data, - unsigned rotation) +static void wiiu_gfx_set_rotation(void* data, + unsigned rotation) { (void)data; (void)rotation; } -static void wiiu_gfx_viewport_info(void *data, - struct video_viewport *vp) +static void wiiu_gfx_viewport_info(void* data, + struct video_viewport* vp) { (void)data; (void)vp; } -static bool wiiu_gfx_read_viewport(void *data, uint8_t *buffer) +static bool wiiu_gfx_read_viewport(void* data, uint8_t* buffer) { (void)data; (void)buffer; @@ -240,12 +259,12 @@ static bool wiiu_gfx_read_viewport(void *data, uint8_t *buffer) return true; } -static uintptr_t wiiu_load_texture(void *video_data, void *data, - bool threaded, enum texture_filter_type filter_type) +static uintptr_t wiiu_load_texture(void* video_data, void* data, + bool threaded, enum texture_filter_type filter_type) { return 0; } -static void wiiu_unload_texture(void *data, uintptr_t handle) +static void wiiu_unload_texture(void* data, uintptr_t handle) { } @@ -271,19 +290,21 @@ static void wiiu_viewport_info(void* data, struct video_viewport* vp) vp->y = 0; } static void wiiu_set_texture_frame(void* data, const void* frame, bool rgb32, - unsigned width, unsigned height, float alpha) + unsigned width, unsigned height, float alpha) { int i; wiiu_video_t* wiiu = (wiiu_video_t*) data; - if(!wiiu) + + if (!wiiu) return; - if(!frame || !width || !height) + if (!frame || !width || !height) return; - if(width > wiiu->menu.tex_width) + if (width > wiiu->menu.tex_width) width = wiiu->menu.tex_width; - if(height > wiiu->menu.tex_height) + + if (height > wiiu->menu.tex_height) height = wiiu->menu.tex_height; wiiu->menu.width = width; @@ -291,6 +312,7 @@ static void wiiu_set_texture_frame(void* data, const void* frame, bool rgb32, const uint16_t* src = frame; uint16_t* dst = (uint16_t*)wiiu->menu.texture; + for (i = 0; i < height; i++) { memcpy(dst, src, width * sizeof(uint16_t)); @@ -307,8 +329,8 @@ static void wiiu_set_texture_enable(void* data, bool state, bool full_screen) } -static void wiiu_set_osd_msg(void *data, const char *msg, - const struct font_params *params, void *font) +static void wiiu_set_osd_msg(void* data, const char* msg, + const struct font_params* params, void* font) { } @@ -337,8 +359,8 @@ static const video_poke_interface_t wiiu_poke_interface = NULL }; -static void wiiu_gfx_get_poke_interface(void *data, - const video_poke_interface_t **iface) +static void wiiu_gfx_get_poke_interface(void* data, + const video_poke_interface_t** iface) { (void)data; *iface = &wiiu_poke_interface; @@ -362,7 +384,7 @@ video_driver_t video_wiiu = wiiu_gfx_read_viewport, NULL, /* read_frame_raw */ #ifdef HAVE_OVERLAY - NULL, /* overlay_interface */ + NULL, /* overlay_interface */ #endif - wiiu_gfx_get_poke_interface, + wiiu_gfx_get_poke_interface, }; diff --git a/gfx/drivers_context/x_ctx.c b/gfx/drivers_context/x_ctx.c index dcb1b374bf..e432dfb5ea 100644 --- a/gfx/drivers_context/x_ctx.c +++ b/gfx/drivers_context/x_ctx.c @@ -1,6 +1,7 @@ /* RetroArch - A frontend for libretro. * Copyright (C) 2010-2014 - Hans-Kristian Arntzen * Copyright (C) 2011-2016 - Daniel De Matteis + * Copyright (C) 2016 - Brad Parker * * 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- diff --git a/gfx/drivers_font/gl_raster_font.c b/gfx/drivers_font/gl_raster_font.c index 49caed5737..7743fc3b88 100644 --- a/gfx/drivers_font/gl_raster_font.c +++ b/gfx/drivers_font/gl_raster_font.c @@ -1,6 +1,7 @@ /* RetroArch - A frontend for libretro. * Copyright (C) 2010-2014 - Hans-Kristian Arntzen * Copyright (C) 2011-2016 - Daniel De Matteis + * Copyright (C) 2016 - Brad Parker * * 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- diff --git a/gfx/video_context_driver.c b/gfx/video_context_driver.c index 83cf7befbb..fe1970d676 100644 --- a/gfx/video_context_driver.c +++ b/gfx/video_context_driver.c @@ -1,6 +1,7 @@ /* RetroArch - A frontend for libretro. * Copyright (C) 2010-2014 - Hans-Kristian Arntzen * Copyright (C) 2011-2016 - Daniel De Matteis + * Copyright (C) 2016 - Brad Parker * * 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- diff --git a/gfx/video_context_driver.h b/gfx/video_context_driver.h index bcf2f934c4..694b086daf 100644 --- a/gfx/video_context_driver.h +++ b/gfx/video_context_driver.h @@ -1,6 +1,7 @@ /* RetroArch - A frontend for libretro. * Copyright (C) 2010-2014 - Hans-Kristian Arntzen * Copyright (C) 2011-2016 - Daniel De Matteis + * Copyright (C) 2016 - Brad Parker * * 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- diff --git a/griffin/griffin.c b/griffin/griffin.c index 757d9757a9..744a287125 100644 --- a/griffin/griffin.c +++ b/griffin/griffin.c @@ -817,6 +817,7 @@ RETROARCH #include "../intl/msg_hash_pt.c" #include "../intl/msg_hash_pl.c" #include "../intl/msg_hash_ru.c" +#include "../intl/msg_hash_vn.c" #endif #include "../intl/msg_hash_us.c" diff --git a/input/drivers/cocoa_input.c b/input/drivers/cocoa_input.c index d20ea096ac..a411880013 100644 --- a/input/drivers/cocoa_input.c +++ b/input/drivers/cocoa_input.c @@ -268,7 +268,7 @@ static int16_t cocoa_input_state(void *data, const struct retro_keybind **binds, unsigned port, unsigned device, unsigned idx, unsigned id) { - int16_t ret; + int16_t ret = 0; cocoa_input_data_t *apple = (cocoa_input_data_t*)data; if (!apple || !apple->joypad) diff --git a/input/drivers_joypad/wiiu_joypad.c b/input/drivers_joypad/wiiu_joypad.c index ad37dca9a0..a0f0adec59 100644 --- a/input/drivers_joypad/wiiu_joypad.c +++ b/input/drivers_joypad/wiiu_joypad.c @@ -29,6 +29,7 @@ #include "string.h" #include "dynamic_libs/vpad_functions.h" +#include "wiiu_dbg.h" #ifndef MAX_PADS #define MAX_PADS 1 diff --git a/input/input_config.c b/input/input_config.c index 48de5146fd..2fc281fd2b 100644 --- a/input/input_config.c +++ b/input/input_config.c @@ -1,6 +1,7 @@ /* RetroArch - A frontend for libretro. * Copyright (C) 2010-2014 - Hans-Kristian Arntzen * Copyright (C) 2011-2016 - Daniel De Matteis + * Copyright (C) 2016 - Brad Parker * * 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- diff --git a/intl/msg_hash_fr.c b/intl/msg_hash_fr.c index b88e444be5..25e89106ad 100644 --- a/intl/msg_hash_fr.c +++ b/intl/msg_hash_fr.c @@ -1,5 +1,6 @@ /* RetroArch - A frontend for libretro. * Copyright (C) 2011-2016 - Daniel De Matteis + * Copyright (C) 2014-2016 - Jean-André Santoni * * 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- diff --git a/intl/msg_hash_jp.c b/intl/msg_hash_jp.c index c7f2c7968b..136b82fd50 100644 --- a/intl/msg_hash_jp.c +++ b/intl/msg_hash_jp.c @@ -1,5 +1,6 @@ /* RetroArch - A frontend for libretro. * Copyright (C) 2011-2016 - Daniel De Matteis + * Copyright (C) 2016 - Brad Parker * * 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- diff --git a/intl/msg_hash_us.c b/intl/msg_hash_us.c index d604afaf95..8364602bff 100644 --- a/intl/msg_hash_us.c +++ b/intl/msg_hash_us.c @@ -1,5 +1,6 @@ /* RetroArch - A frontend for libretro. * Copyright (C) 2011-2016 - Daniel De Matteis + * Copyright (C) 2016 - Brad Parker * * 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- @@ -625,7 +626,7 @@ int menu_hash_get_help_us_enum(enum msg_hash_enums msg, char *s, size_t len) { /* Work around C89 limitations */ char u[501]; - const char * t = + const char * t = "RetroArch relies on an unique form of\n" "audio/video synchronization where it needs to be\n" "calibrated against the refresh rate of your\n" @@ -4171,9 +4172,9 @@ const char *msg_hash_to_str_us(enum msg_hash_enums msg) case MENU_ENUM_LABEL_VALUE_CHEAT_FILE: return "Cheat File"; case MENU_ENUM_LABEL_VALUE_CHEAT_FILE_LOAD: - return "Cheat File Load"; + return "Load Cheat File"; case MENU_ENUM_LABEL_VALUE_CHEAT_FILE_SAVE_AS: - return "Cheat File Save As"; + return "Save Cheat File As"; case MENU_ENUM_LABEL_VALUE_CORE_COUNTERS: return "Core Counters"; case MENU_ENUM_LABEL_VALUE_TAKE_SCREENSHOT: @@ -4632,6 +4633,8 @@ const char *msg_hash_to_str_us(enum msg_hash_enums msg) return "Chinese (Simplified)"; case MENU_ENUM_LABEL_VALUE_LANG_ESPERANTO: return "Esperanto"; + case MENU_ENUM_LABEL_VALUE_LANG_VIETNAMESE: + return "Vietnamese"; case MENU_ENUM_LABEL_VALUE_LEFT_ANALOG: return "Left Analog"; case MENU_ENUM_LABEL_VALUE_RIGHT_ANALOG: diff --git a/intl/msg_hash_vn.c b/intl/msg_hash_vn.c new file mode 100644 index 0000000000..35a22ab5af --- /dev/null +++ b/intl/msg_hash_vn.c @@ -0,0 +1,4824 @@ +/* RetroArch - A frontend for libretro. + * Copyright (C) 2011-2016 - Daniel De Matteis + * Copyright (C) 2016 - Brad Parker + * + * 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 . + */ + +#include +#include + +#include +#include + +#include "../msg_hash.h" +#include "../configuration.h" +#include "../verbosity.h" + +int menu_hash_get_help_vn_enum(enum msg_hash_enums msg, char *s, size_t len) +{ + uint32_t driver_hash = 0; + settings_t *settings = config_get_ptr(); + + if (msg <= MENU_ENUM_LABEL_INPUT_HOTKEY_BIND_END && + msg >= MENU_ENUM_LABEL_INPUT_HOTKEY_BIND_BEGIN) + { + unsigned idx = msg - MENU_ENUM_LABEL_INPUT_HOTKEY_BIND_BEGIN; + + switch (idx) + { + case RARCH_FAST_FORWARD_KEY: + snprintf(s, len, + "Toggles between fast-forwarding and \n" + "normal speed." + ); + break; + case RARCH_FAST_FORWARD_HOLD_KEY: + snprintf(s, len, + "Hold for fast-forward. \n" + " \n" + "Releasing button disables fast-forward." + ); + break; + case RARCH_PAUSE_TOGGLE: + snprintf(s, len, + "Toggle between paused and non-paused state."); + break; + case RARCH_FRAMEADVANCE: + snprintf(s, len, + "Frame advance when content is paused."); + break; + case RARCH_SHADER_NEXT: + snprintf(s, len, + "Applies next shader in directory."); + break; + case RARCH_SHADER_PREV: + snprintf(s, len, + "Applies previous shader in directory."); + break; + case RARCH_CHEAT_INDEX_PLUS: + case RARCH_CHEAT_INDEX_MINUS: + case RARCH_CHEAT_TOGGLE: + snprintf(s, len, + "Cheats."); + break; + case RARCH_RESET: + snprintf(s, len, + "Reset the content."); + break; + case RARCH_SCREENSHOT: + snprintf(s, len, + "Take screenshot."); + break; + case RARCH_MUTE: + snprintf(s, len, + "Mute/unmute audio."); + break; + case RARCH_OSK: + snprintf(s, len, + "Toggles onscreen keyboard."); + break; + case RARCH_NETPLAY_FLIP: + snprintf(s, len, + "Netplay flip users."); + break; + case RARCH_SLOWMOTION: + snprintf(s, len, + "Hold for slowmotion."); + break; + case RARCH_ENABLE_HOTKEY: + snprintf(s, len, + "Enable other hotkeys. \n" + " \n" + "If this hotkey is bound to either\n" + "a keyboard, joybutton or joyaxis, \n" + "all other hotkeys will be enabled only \n" + "if this one is held at the same time. \n" + " \n" + "This is useful for RETRO_KEYBOARD centric \n" + "implementations which query a large area of \n" + "the keyboard, where it is not desirable that \n" + "hotkeys get in the way. \n" + " \n" + "Alternatively, all hotkeys for keyboard \n" + "could be disabled by the user."); + break; + case RARCH_VOLUME_UP: + snprintf(s, len, + "Increases audio volume."); + break; + case RARCH_VOLUME_DOWN: + snprintf(s, len, + "Decreases audio volume."); + break; + case RARCH_OVERLAY_NEXT: + snprintf(s, len, + "Switches to next overlay. Wraps around."); + break; + case RARCH_DISK_EJECT_TOGGLE: + snprintf(s, len, + "Toggles eject for disks. \n" + " \n" + "Used for multiple-disk content. "); + break; + case RARCH_DISK_NEXT: + case RARCH_DISK_PREV: + snprintf(s, len, + "Cycles through disk images. Use after ejecting. \n" + " \n" + "Complete by toggling eject again."); + break; + case RARCH_GRAB_MOUSE_TOGGLE: + snprintf(s, len, + "Toggles mouse grab. \n" + " \n" + "When mouse is grabbed, RetroArch hides the \n" + "mouse, and keeps the mouse pointer inside \n" + "the window to allow relative mouse input to \n" + "work better."); + break; + case RARCH_MENU_TOGGLE: + snprintf(s, len, "Toggles menu."); + break; + case RARCH_LOAD_STATE_KEY: + snprintf(s, len, + "Loads state."); + break; + case RARCH_FULLSCREEN_TOGGLE_KEY: + snprintf(s, len, + "Toggles fullscreen."); + break; + case RARCH_QUIT_KEY: + snprintf(s, len, + "Key to exit RetroArch cleanly. \n" + " \n" + "Killing it in any hard way (SIGKILL, etc.) will \n" + "terminate RetroArch without saving RAM, etc." +#ifdef __unix__ + "\nOn Unix-likes, SIGINT/SIGTERM allows a clean \n" + "deinitialization." +#endif + ""); + break; + case RARCH_STATE_SLOT_PLUS: + case RARCH_STATE_SLOT_MINUS: + snprintf(s, len, + "State slots. \n" + " \n" + "With slot set to 0, save state name is \n" + "*.state (or whatever defined on commandline). \n" + " \n" + "When slot is not 0, path will be , \n" + "where is slot number."); + break; + case RARCH_SAVE_STATE_KEY: + snprintf(s, len, + "Saves state."); + break; + case RARCH_REWIND: + snprintf(s, len, + "Hold button down to rewind. \n" + " \n" + "Rewinding must be enabled."); + break; + case RARCH_MOVIE_RECORD_TOGGLE: + snprintf(s, len, + "Toggle between recording and not."); + break; + default: + if (string_is_empty(s)) + strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_NO_INFORMATION_AVAILABLE), len); + break; + } + + return 0; + } + + switch (msg) + { + case MENU_ENUM_LABEL_ACCOUNTS_RETRO_ACHIEVEMENTS: + snprintf(s, len, "Login details for your \n" + "Retro Achievements account. \n" + " \n" + "Visit retroachievements.org and sign up \n" + "for a free account. \n" + " \n" + "After you are done registering, you need \n" + "to input the username and password into \n" + "RetroArch."); + break; + case MENU_ENUM_LABEL_CHEEVOS_USERNAME: + snprintf(s, len, "Username for your Retro Achievements account."); + break; + case MENU_ENUM_LABEL_CHEEVOS_PASSWORD: + snprintf(s, len, "Password for your Retro Achievements account."); + break; + case MENU_ENUM_LABEL_USER_LANGUAGE: + snprintf(s, len, "Localizes the menu and all onscreen messages \n" + "according to the language you have selected \n" + "here. \n" + " \n" + "Requires a restart for the changes \n" + "to take effect. \n" + " \n" + "Note: not all languages might be currently \n" + "implemented. \n" + " \n" + "In case a language is not implemented, \n" + "we fallback to English."); + break; + case MENU_ENUM_LABEL_VIDEO_FONT_PATH: + snprintf(s, len, "Change the font that is used \n" + "for the Onscreen Display text."); + break; + case MENU_ENUM_LABEL_GAME_SPECIFIC_OPTIONS: + snprintf(s, len, "Automatically load content-specific core options."); + break; + case MENU_ENUM_LABEL_AUTO_OVERRIDES_ENABLE: + snprintf(s, len, "Automatically load override configurations."); + break; + case MENU_ENUM_LABEL_AUTO_REMAPS_ENABLE: + snprintf(s, len, "Automatically load input remapping files."); + break; + case MENU_ENUM_LABEL_SORT_SAVESTATES_ENABLE: + snprintf(s, len, "Sort save states in folders \n" + "named after the libretro core used."); + break; + case MENU_ENUM_LABEL_SORT_SAVEFILES_ENABLE: + snprintf(s, len, "Sort save files in folders \n" + "named after the libretro core used."); + break; + case MENU_ENUM_LABEL_RESUME_CONTENT: + snprintf(s, len, "Exits from the menu and returns back \n" + "to the content."); + break; + case MENU_ENUM_LABEL_RESTART_CONTENT: + snprintf(s, len, "Restarts the content from the beginning."); + break; + case MENU_ENUM_LABEL_CLOSE_CONTENT: + snprintf(s, len, "Closes the content and unloads it from \n" + "memory."); + break; + case MENU_ENUM_LABEL_UNDO_LOAD_STATE: + snprintf(s, len, "If a state was loaded, content will \n" + "go back to the state prior to loading."); + break; + case MENU_ENUM_LABEL_UNDO_SAVE_STATE: + snprintf(s, len, "If a state was overwritten, it will \n" + "roll back to the previous save state."); + break; + case MENU_ENUM_LABEL_TAKE_SCREENSHOT: + snprintf(s, len, "Create a screenshot. \n" + " \n" + "The screenshot will be stored inside the \n" + "Screenshot Directory."); + break; + case MENU_ENUM_LABEL_RUN: + snprintf(s, len, "Start the content."); + break; + case MENU_ENUM_LABEL_INFORMATION: + snprintf(s, len, "Show additional metadata information \n" + "about the content."); + break; + case MENU_ENUM_LABEL_FILE_BROWSER_CONFIG: + snprintf(s, len, "Configuration file."); + break; + case MENU_ENUM_LABEL_FILE_BROWSER_COMPRESSED_ARCHIVE: + snprintf(s, len, "Compressed archive file."); + break; + case MENU_ENUM_LABEL_FILE_BROWSER_RECORD_CONFIG: + snprintf(s, len, "Recording configuration file."); + break; + case MENU_ENUM_LABEL_FILE_BROWSER_CURSOR: + snprintf(s, len, "Database cursor file."); + break; + case MENU_ENUM_LABEL_FILE_CONFIG: + snprintf(s, len, "Configuration file."); + break; + case MENU_ENUM_LABEL_SCAN_THIS_DIRECTORY: + snprintf(s, len, + "Select this to scan the current directory \n" + "for content."); + break; + case MENU_ENUM_LABEL_USE_THIS_DIRECTORY: + snprintf(s, len, + "Select this to set this as the directory."); + break; + case MENU_ENUM_LABEL_CONTENT_DATABASE_DIRECTORY: + snprintf(s, len, + "Content Database Directory. \n" + " \n" + "Path to content database \n" + "directory."); + break; + case MENU_ENUM_LABEL_THUMBNAILS_DIRECTORY: + snprintf(s, len, + "Thumbnails Directory. \n" + " \n" + "To store thumbnail files."); + break; + case MENU_ENUM_LABEL_LIBRETRO_INFO_PATH: + snprintf(s, len, + "Core Info Directory. \n" + " \n" + "A directory for where to search \n" + "for libretro core information."); + break; + case MENU_ENUM_LABEL_PLAYLIST_DIRECTORY: + snprintf(s, len, + "Playlist Directory. \n" + " \n" + "Save all playlist files to this \n" + "directory."); + break; + case MENU_ENUM_LABEL_DUMMY_ON_CORE_SHUTDOWN: + snprintf(s, len, + "Some libretro cores might have \n" + "a shutdown feature. \n" + " \n" + "If this option is left disabled, \n" + "selecting the shutdown procedure \n" + "would trigger RetroArch being shut \n" + "down. \n" + " \n" + "Enabling this option will load a \n" + "dummy core instead so that we remain \n" + "inside the menu and RetroArch won't \n" + "shutdown."); + break; + case MENU_ENUM_LABEL_PARENT_DIRECTORY: + snprintf(s, len, + "Go back to the parent directory."); + break; + case MENU_ENUM_LABEL_FILE_BROWSER_SHADER_PRESET: + snprintf(s, len, + "Shader preset file."); + break; + case MENU_ENUM_LABEL_FILE_BROWSER_SHADER: + snprintf(s, len, + "Shader file."); + break; + case MENU_ENUM_LABEL_FILE_BROWSER_REMAP: + snprintf(s, len, + "Remap controls file."); + break; + case MENU_ENUM_LABEL_FILE_BROWSER_CHEAT: + snprintf(s, len, + "Cheat file."); + break; + case MENU_ENUM_LABEL_FILE_BROWSER_OVERLAY: + snprintf(s, len, + "Overlay file."); + break; + case MENU_ENUM_LABEL_FILE_BROWSER_RDB: + snprintf(s, len, + "Database file."); + break; + case MENU_ENUM_LABEL_FILE_BROWSER_FONT: + snprintf(s, len, + "TrueType font file."); + break; + case MENU_ENUM_LABEL_FILE_BROWSER_PLAIN_FILE: + snprintf(s, len, + "Plain file."); + break; + case MENU_ENUM_LABEL_FILE_BROWSER_MOVIE_OPEN: + snprintf(s, len, + "Video. \n" + " \n" + "Select it to open this file with the \n" + "video player."); + break; + case MENU_ENUM_LABEL_FILE_BROWSER_MUSIC_OPEN: + snprintf(s, len, + "Music. \n" + " \n" + "Select it to open this file with the \n" + "music player."); + break; + case MENU_ENUM_LABEL_FILE_BROWSER_IMAGE: + snprintf(s, len, + "Image file."); + break; + case MENU_ENUM_LABEL_FILE_BROWSER_IMAGE_OPEN_WITH_VIEWER: + snprintf(s, len, + "Image. \n" + " \n" + "Select it to open this file with the \n" + "image viewer."); + break; + case MENU_ENUM_LABEL_FILE_BROWSER_CORE_SELECT_FROM_COLLECTION: + snprintf(s, len, + "Libretro core. \n" + " \n" + "Selecting this will associate this core \n" + "to the game."); + break; + case MENU_ENUM_LABEL_FILE_BROWSER_CORE: + snprintf(s, len, + "Libretro core. \n" + " \n" + "Select this file to have RetroArch load this core."); + break; + case MENU_ENUM_LABEL_FILE_BROWSER_DIRECTORY: + snprintf(s, len, + "Directory. \n" + " \n" + "Select it to open this directory."); + break; + case MENU_ENUM_LABEL_CACHE_DIRECTORY: + snprintf(s, len, + "Cache Directory. \n" + " \n" + "Content decompressed by RetroArch will be \n" + "temporarily extracted to this directory."); + break; + case MENU_ENUM_LABEL_HISTORY_LIST_ENABLE: + snprintf(s, len, + "If enabled, every content loaded \n" + "in RetroArch will be automatically \n" + "added to the recent history list."); + break; + case MENU_ENUM_LABEL_RGUI_BROWSER_DIRECTORY: + snprintf(s, len, + "File Browser Directory. \n" + " \n" + "Sets start directory for menu file browser."); + break; + case MENU_ENUM_LABEL_INPUT_POLL_TYPE_BEHAVIOR: + snprintf(s, len, + "Influence how input polling is done inside \n" + "RetroArch. \n" + " \n" + "Early - Input polling is performed before \n" + "the frame is processed. \n" + "Normal - Input polling is performed when \n" + "polling is requested. \n" + "Late - Input polling is performed on \n" + "first input state request per frame.\n" + " \n" + "Setting it to 'Early' or 'Late' can result \n" + "in less latency, \n" + "depending on your configuration.\n\n" + "When netplay is enabled, the default polling \n" + "behavior (Normal) will be used, \n" + "regardless of the value set here." + ); + break; + case MENU_ENUM_LABEL_INPUT_DESCRIPTOR_HIDE_UNBOUND: + snprintf(s, len, + "Hide input descriptors that were not set \n" + "by the core."); + break; + case MENU_ENUM_LABEL_VIDEO_REFRESH_RATE: + snprintf(s, len, + "Video refresh rate of your monitor. \n" + "Used to calculate a suitable audio input rate."); + break; + case MENU_ENUM_LABEL_VIDEO_FORCE_SRGB_DISABLE: + snprintf(s, len, + "Forcibly disable sRGB FBO support. Some Intel \n" + "OpenGL drivers on Windows have video problems \n" + "with sRGB FBO support enabled."); + break; + case MENU_ENUM_LABEL_AUDIO_ENABLE: + snprintf(s, len, + "Enable audio output."); + break; + case MENU_ENUM_LABEL_AUDIO_SYNC: + snprintf(s, len, + "Synchronize audio (recommended)."); + break; + case MENU_ENUM_LABEL_AUDIO_LATENCY: + snprintf(s, len, + "Desired audio latency in milliseconds. \n" + "Might not be honored if the audio driver \n" + "can't provide given latency."); + break; + case MENU_ENUM_LABEL_VIDEO_ALLOW_ROTATE: + snprintf(s, len, + "Allow cores to set rotation. If false, \n" + "rotation requests are honored, but ignored.\n\n" + "Used for setups where one manually rotates \n" + "the monitor."); + break; + case MENU_ENUM_LABEL_INPUT_DESCRIPTOR_LABEL_SHOW: + snprintf(s, len, + "Show the input descriptors set by the core \n" + "instead of the default ones."); + break; + case MENU_ENUM_LABEL_CONTENT_HISTORY_SIZE: + snprintf(s, len, + "Number of entries that will be kept in \n" + "content history playlist."); + break; + case MENU_ENUM_LABEL_VIDEO_WINDOWED_FULLSCREEN: + snprintf(s, len, + "To use windowed mode or not when going \n" + "fullscreen."); + break; + case MENU_ENUM_LABEL_VIDEO_FONT_SIZE: + snprintf(s, len, + "Font size for on-screen messages."); + break; + case MENU_ENUM_LABEL_SAVESTATE_AUTO_INDEX: + snprintf(s, len, + "Automatically increment slot index on each save, \n" + "generating multiple savestate files. \n" + "When the content is loaded, state slot will be \n" + "set to the highest existing value (last savestate)."); + break; + case MENU_ENUM_LABEL_FPS_SHOW: + snprintf(s, len, + "Enables displaying the current frames \n" + "per second."); + break; + case MENU_ENUM_LABEL_VIDEO_FONT_ENABLE: + snprintf(s, len, + "Show and/or hide onscreen messages."); + break; + case MENU_ENUM_LABEL_VIDEO_MESSAGE_POS_X: + case MENU_ENUM_LABEL_VIDEO_MESSAGE_POS_Y: + snprintf(s, len, + "Offset for where messages will be placed \n" + "onscreen. Values are in range [0.0, 1.0]."); + break; + case MENU_ENUM_LABEL_INPUT_OVERLAY_ENABLE: + snprintf(s, len, + "Enable or disable the current overlay."); + break; + case MENU_ENUM_LABEL_INPUT_OVERLAY_HIDE_IN_MENU: + snprintf(s, len, + "Hide the current overlay from appearing \n" + "inside the menu."); + break; + case MENU_ENUM_LABEL_OVERLAY_PRESET: + snprintf(s, len, + "Path to input overlay."); + break; + case MENU_ENUM_LABEL_OVERLAY_OPACITY: + snprintf(s, len, + "Overlay opacity."); + break; + case MENU_ENUM_LABEL_INPUT_BIND_TIMEOUT: + snprintf(s, len, + "Input bind timer timeout (in seconds). \n" + "Amount of seconds to wait until proceeding \n" + "to the next bind."); + break; + case MENU_ENUM_LABEL_KEYBOARD_OVERLAY_PRESET: + snprintf(s, len, + "Path to onscreen keyboard overlay."); + break; + case MENU_ENUM_LABEL_OVERLAY_SCALE: + snprintf(s, len, + "Overlay scale."); + break; + case MENU_ENUM_LABEL_AUDIO_OUTPUT_RATE: + snprintf(s, len, + "Audio output samplerate."); + break; + case MENU_ENUM_LABEL_VIDEO_SHARED_CONTEXT: + snprintf(s, len, + "Set to true if hardware-rendered cores \n" + "should get their private context. \n" + "Avoids having to assume hardware state changes \n" + "inbetween frames." + ); + break; + case MENU_ENUM_LABEL_CORE_LIST: + snprintf(s, len, + "Load Core. \n" + " \n" + "Browse for a libretro core \n" + "implementation. Where the browser \n" + "starts depends on your Core Directory \n" + "path. If blank, it will start in root. \n" + " \n" + "If Core Directory is a directory, the menu \n" + "will use that as top folder. If Core \n" + "Directory is a full path, it will start \n" + "in the folder where the file is."); + break; + case MENU_ENUM_LABEL_VALUE_MENU_ENUM_CONTROLS_PROLOG: + snprintf(s, len, + "You can use the following controls below \n" + "on either your gamepad or keyboard in order\n" + "to control the menu: \n" + " \n" + ); + break; + case MENU_ENUM_LABEL_WELCOME_TO_RETROARCH: + snprintf(s, len, + "Welcome to RetroArch\n" + ); + break; + case MENU_ENUM_LABEL_VALUE_HELP_AUDIO_VIDEO_TROUBLESHOOTING_DESC: + { + /* Work around C89 limitations */ + char u[501]; + const char * t = + "RetroArch relies on an unique form of\n" + "audio/video synchronization where it needs to be\n" + "calibrated against the refresh rate of your\n" + "display for best performance results.\n" + " \n" + "If you experience any audio crackling or video\n" + "tearing, usually it means that you need to\n" + "calibrate the settings. Some choices below:\n" + " \n"; + snprintf(u, sizeof(u), /* can't inline this due to the printf arguments */ + "a) Go to '%s' -> '%s', and enable\n" + "'Threaded Video'. Refresh rate will not matter\n" + "in this mode, framerate will be higher,\n" + "but video might be less smooth.\n" + "b) Go to '%s' -> '%s', and look at\n" + "'%s'. Let it run for\n" + "2048 frames, then press 'OK'.", + msg_hash_to_str(MENU_ENUM_LABEL_VALUE_SETTINGS), + msg_hash_to_str(MENU_ENUM_LABEL_VALUE_VIDEO_SETTINGS), + msg_hash_to_str(MENU_ENUM_LABEL_VALUE_SETTINGS), + msg_hash_to_str(MENU_ENUM_LABEL_VALUE_VIDEO_SETTINGS), + msg_hash_to_str(MENU_ENUM_LABEL_VALUE_VIDEO_REFRESH_RATE_AUTO)); + strlcpy(s, t, len); + strlcat(s, u, len); + } + break; + case MENU_ENUM_LABEL_VALUE_HELP_SCANNING_CONTENT_DESC: + snprintf(s, len, + "To scan for content, go to '%s' and\n" + "select either '%s' or %s'.\n" + " \n" + "Files will be compared to database entries.\n" + "If there is a match, it will add an entry\n" + "to a collection.\n" + " \n" + "You can then easily access this content by\n" + "going to '%s' ->\n" + "'%s'\n" + "instead of having to go through the\n" + "filebrowser everytime.\n" + " \n" + "NOTE: Content for some cores might still not be\n" + "scannable." + , + msg_hash_to_str(MENU_ENUM_LABEL_VALUE_ADD_CONTENT_LIST), + msg_hash_to_str(MENU_ENUM_LABEL_VALUE_SCAN_DIRECTORY), + msg_hash_to_str(MENU_ENUM_LABEL_VALUE_SCAN_FILE), + msg_hash_to_str(MENU_ENUM_LABEL_VALUE_LOAD_CONTENT_LIST), + msg_hash_to_str(MENU_ENUM_LABEL_VALUE_CONTENT_COLLECTION_LIST) + ); + break; + case MENU_ENUM_LABEL_VALUE_EXTRACTING_PLEASE_WAIT: + snprintf(s, len, + "Welcome to RetroArch\n" + "\n" + "Extracting assets, please wait.\n" + "This might take a while...\n" + ); + break; + case MENU_ENUM_LABEL_INPUT_DRIVER: + if (settings) + driver_hash = msg_hash_calculate(settings->input.driver); + + switch (driver_hash) + { + case MENU_LABEL_INPUT_DRIVER_UDEV: + snprintf(s, len, + "udev Input driver. \n" + " \n" + "This driver can run without X. \n" + " \n" + "It uses the recent evdev joypad API \n" + "for joystick support. It supports \n" + "hotplugging and force feedback (if \n" + "supported by device). \n" + " \n" + "The driver reads evdev events for keyboard \n" + "support. It also supports keyboard callback, \n" + "mice and touchpads. \n" + " \n" + "By default in most distros, /dev/input nodes \n" + "are root-only (mode 600). You can set up a udev \n" + "rule which makes these accessible to non-root." + ); + break; + case MENU_LABEL_INPUT_DRIVER_LINUXRAW: + snprintf(s, len, + "linuxraw Input driver. \n" + " \n" + "This driver requires an active TTY. Keyboard \n" + "events are read directly from the TTY which \n" + "makes it simpler, but not as flexible as udev. \n" "Mice, etc, are not supported at all. \n" + " \n" + "This driver uses the older joystick API \n" + "(/dev/input/js*)."); + break; + default: + snprintf(s, len, + "Input driver.\n" + " \n" + "Depending on video driver, it might \n" + "force a different input driver."); + break; + } + break; + case MENU_ENUM_LABEL_LOAD_CONTENT_LIST: + snprintf(s, len, + "Load Content. \n" + "Browse for content. \n" + " \n" + "To load content, you need a \n" + "'Core' to use, and a content file. \n" + " \n" + "To control where the menu starts \n" + "to browse for content, set \n" + "'File Browser Directory'. \n" + "If not set, it will start in root. \n" + " \n" + "The browser will filter out \n" + "extensions for the last core set \n" + "in 'Load Core', and use that core \n" + "when content is loaded." + ); + break; + case MENU_ENUM_LABEL_LOAD_CONTENT_HISTORY: + snprintf(s, len, + "Loading content from history. \n" + " \n" + "As content is loaded, content and libretro \n" + "core combinations are saved to history. \n" + " \n" + "The history is saved to a file in the same \n" + "directory as the RetroArch config file. If \n" + "no config file was loaded in startup, history \n" + "will not be saved or loaded, and will not exist \n" + "in the main menu." + ); + break; + case MENU_ENUM_LABEL_VIDEO_DRIVER: + snprintf(s, len, + "Current Video driver."); + + if (string_is_equal(settings->video.driver, "gl")) + { + snprintf(s, len, + "OpenGL Video driver. \n" + " \n" + "This driver allows libretro GL cores to \n" + "be used in addition to software-rendered \n" + "core implementations.\n" + " \n" + "Performance for software-rendered and \n" + "libretro GL core implementations is \n" + "dependent on your graphics card's \n" + "underlying GL driver)."); + } + else if (string_is_equal(settings->video.driver, "sdl2")) + { + snprintf(s, len, + "SDL 2 Video driver.\n" + " \n" + "This is an SDL 2 software-rendered video \n" + "driver.\n" + " \n" + "Performance for software-rendered libretro \n" + "core implementations is dependent \n" + "on your platform SDL implementation."); + } + else if (string_is_equal(settings->video.driver, "sdl1")) + { + snprintf(s, len, + "SDL Video driver.\n" + " \n" + "This is an SDL 1.2 software-rendered video \n" + "driver.\n" + " \n" + "Performance is considered to be suboptimal. \n" + "Consider using it only as a last resort."); + } + else if (string_is_equal(settings->video.driver, "d3d")) + { + snprintf(s, len, + "Direct3D Video driver. \n" + " \n" + "Performance for software-rendered cores \n" + "is dependent on your graphic card's \n" + "underlying D3D driver)."); + } + else if (string_is_equal(settings->video.driver, "exynos")) + { + snprintf(s, len, + "Exynos-G2D Video Driver. \n" + " \n" + "This is a low-level Exynos video driver. \n" + "Uses the G2D block in Samsung Exynos SoC \n" + "for blit operations. \n" + " \n" + "Performance for software rendered cores \n" + "should be optimal."); + } + else if (string_is_equal(settings->video.driver, "drm")) + { + snprintf(s, len, + "Plain DRM Video Driver. \n" + " \n" + "This is a low-level video driver using. \n" + "libdrm for hardware scaling using \n" + "GPU overlays."); + } + else if (string_is_equal(settings->video.driver, "sunxi")) + { + snprintf(s, len, + "Sunxi-G2D Video Driver. \n" + " \n" + "This is a low-level Sunxi video driver. \n" + "Uses the G2D block in Allwinner SoCs."); + } + break; + case MENU_ENUM_LABEL_AUDIO_DSP_PLUGIN: + snprintf(s, len, + "Audio DSP plugin.\n" + " Processes audio before it's sent to \n" + "the driver." + ); + break; + case MENU_ENUM_LABEL_AUDIO_RESAMPLER_DRIVER: + if (settings) + driver_hash = msg_hash_calculate(settings->audio.resampler); + + switch (driver_hash) + { + case MENU_LABEL_AUDIO_RESAMPLER_DRIVER_SINC: + snprintf(s, len, + "Windowed SINC implementation."); + break; + case MENU_LABEL_AUDIO_RESAMPLER_DRIVER_CC: + snprintf(s, len, + "Convoluted Cosine implementation."); + break; + default: + if (string_is_empty(s)) + strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_NO_INFORMATION_AVAILABLE), len); + break; + } + break; + case MENU_ENUM_LABEL_VIDEO_SHADER_PRESET: + snprintf(s, len, + "Load Shader Preset. \n" + " \n" + " Load a " +#ifdef HAVE_CG + "Cg" +#endif +#ifdef HAVE_GLSL +#ifdef HAVE_CG + "/" +#endif + "GLSL" +#endif +#ifdef HAVE_HLSL +#if defined(HAVE_CG) || defined(HAVE_HLSL) + "/" +#endif + "HLSL" +#endif + " preset directly. \n" + "The menu shader menu is updated accordingly. \n" + " \n" + "If the CGP uses scaling methods which are not \n" + "simple, (i.e. source scaling, same scaling \n" + "factor for X/Y), the scaling factor displayed \n" + "in the menu might not be correct." + ); + break; + case MENU_ENUM_LABEL_VIDEO_SHADER_SCALE_PASS: + snprintf(s, len, + "Scale for this pass. \n" + " \n" + "The scale factor accumulates, i.e. 2x \n" + "for first pass and 2x for second pass \n" + "will give you a 4x total scale. \n" + " \n" + "If there is a scale factor for last \n" + "pass, the result is stretched to \n" + "screen with the filter specified in \n" + "'Default Filter'. \n" + " \n" + "If 'Don't Care' is set, either 1x \n" + "scale or stretch to fullscreen will \n" + "be used depending if it's not the last \n" + "pass or not." + ); + break; + case MENU_ENUM_LABEL_VIDEO_SHADER_NUM_PASSES: + snprintf(s, len, + "Shader Passes. \n" + " \n" + "RetroArch allows you to mix and match various \n" + "shaders with arbitrary shader passes, with \n" + "custom hardware filters and scale factors. \n" + " \n" + "This option specifies the number of shader \n" + "passes to use. If you set this to 0, and use \n" + "Apply Shader Changes, you use a 'blank' shader. \n" + " \n" + "The Default Filter option will affect the \n" + "stretching filter."); + break; + case MENU_ENUM_LABEL_VIDEO_SHADER_PARAMETERS: + snprintf(s, len, + "Shader Parameters. \n" + " \n" + "Modifies current shader directly. Will not be \n" + "saved to CGP/GLSLP preset file."); + break; + case MENU_ENUM_LABEL_VIDEO_SHADER_PRESET_PARAMETERS: + snprintf(s, len, + "Shader Preset Parameters. \n" + " \n" + "Modifies shader preset currently in menu." + ); + break; + case MENU_ENUM_LABEL_VIDEO_SHADER_PASS: + snprintf(s, len, + "Path to shader. \n" + " \n" + "All shaders must be of the same \n" + "type (i.e. CG, GLSL or HLSL). \n" + " \n" + "Set Shader Directory to set where \n" + "the browser starts to look for \n" + "shaders." + ); + break; + case MENU_ENUM_LABEL_CONFIG_SAVE_ON_EXIT: + snprintf(s, len, + "Saves config to disk on exit.\n" + "Useful for menu as settings can be\n" + "modified. Overwrites the config.\n" + " \n" + "#include's and comments are not \n" + "preserved. \n" + " \n" + "By design, the config file is \n" + "considered immutable as it is \n" + "likely maintained by the user, \n" + "and should not be overwritten \n" + "behind the user's back." +#if defined(RARCH_CONSOLE) || defined(RARCH_MOBILE) + "\nThis is not not the case on \n" + "consoles however, where \n" + "looking at the config file \n" + "manually isn't really an option." +#endif + ); + break; + case MENU_ENUM_LABEL_CONFIRM_ON_EXIT: + snprintf(s, len, "Are you sure you want to quit?"); + break; + case MENU_ENUM_LABEL_SHOW_HIDDEN_FILES: + snprintf(s, len, "Show hidden files\n" + "and folders."); + break; + case MENU_ENUM_LABEL_VIDEO_SHADER_FILTER_PASS: + snprintf(s, len, + "Hardware filter for this pass. \n" + " \n" + "If 'Don't Care' is set, 'Default \n" + "Filter' will be used." + ); + break; + case MENU_ENUM_LABEL_AUTOSAVE_INTERVAL: + snprintf(s, len, + "Autosaves the non-volatile SRAM \n" + "at a regular interval.\n" + " \n" + "This is disabled by default unless set \n" + "otherwise. The interval is measured in \n" + "seconds. \n" + " \n" + "A value of 0 disables autosave."); + break; + case MENU_ENUM_LABEL_INPUT_BIND_DEVICE_TYPE: + snprintf(s, len, + "Input Device Type. \n" + " \n" + "Picks which device type to use. This is \n" + "relevant for the libretro core itself." + ); + break; + case MENU_ENUM_LABEL_LIBRETRO_LOG_LEVEL: + snprintf(s, len, + "Sets log level for libretro cores \n" + "(GET_LOG_INTERFACE). \n" + " \n" + " If a log level issued by a libretro \n" + " core is below libretro_log level, it \n" + " is ignored.\n" + " \n" + " DEBUG logs are always ignored unless \n" + " verbose mode is activated (--verbose).\n" + " \n" + " DEBUG = 0\n" + " INFO = 1\n" + " WARN = 2\n" + " ERROR = 3" + ); + break; + case MENU_ENUM_LABEL_STATE_SLOT_INCREASE: + case MENU_ENUM_LABEL_STATE_SLOT_DECREASE: + snprintf(s, len, + "State slots.\n" + " \n" + " With slot set to 0, save state name is *.state \n" + " (or whatever defined on commandline).\n" + "When slot is != 0, path will be (path)(d), \n" + "where (d) is slot number."); + break; + case MENU_ENUM_LABEL_SHADER_APPLY_CHANGES: + snprintf(s, len, + "Apply Shader Changes. \n" + " \n" + "After changing shader settings, use this to \n" + "apply changes. \n" + " \n" + "Changing shader settings is a somewhat \n" + "expensive operation so it has to be \n" + "done explicitly. \n" + " \n" + "When you apply shaders, the menu shader \n" + "settings are saved to a temporary file (either \n" + "menu.cgp or menu.glslp) and loaded. The file \n" + "persists after RetroArch exits. The file is \n" + "saved to Shader Directory." + ); + break; + case MENU_ENUM_LABEL_MENU_TOGGLE: + snprintf(s, len, + "Toggles menu."); + break; + case MENU_ENUM_LABEL_GRAB_MOUSE_TOGGLE: + snprintf(s, len, + "Toggles mouse grab.\n" + " \n" + "When mouse is grabbed, RetroArch hides the \n" + "mouse, and keeps the mouse pointer inside \n" + "the window to allow relative mouse input to \n" + "work better."); + break; + case MENU_ENUM_LABEL_DISK_NEXT: + snprintf(s, len, + "Cycles through disk images. Use after \n" + "ejecting. \n" + " \n" + " Complete by toggling eject again."); + break; + case MENU_ENUM_LABEL_VIDEO_FILTER: +#ifdef HAVE_FILTERS_BUILTIN + snprintf(s, len, + "CPU-based video filter."); +#else + snprintf(s, len, + "CPU-based video filter.\n" + " \n" + "Path to a dynamic library."); +#endif + break; + case MENU_ENUM_LABEL_AUDIO_DEVICE: + snprintf(s, len, + "Override the default audio device \n" + "the audio driver uses.\n" + "This is driver dependent. E.g.\n" +#ifdef HAVE_ALSA + " \n" + "ALSA wants a PCM device." +#endif +#ifdef HAVE_OSS + " \n" + "OSS wants a path (e.g. /dev/dsp)." +#endif +#ifdef HAVE_JACK + " \n" + "JACK wants portnames (e.g. system:playback1\n" + ",system:playback_2)." +#endif +#ifdef HAVE_RSOUND + " \n" + "RSound wants an IP address to an RSound \n" + "server." +#endif + ); + break; + case MENU_ENUM_LABEL_DISK_EJECT_TOGGLE: + snprintf(s, len, + "Toggles eject for disks.\n" + " \n" + "Used for multiple-disk content."); + break; + case MENU_ENUM_LABEL_ENABLE_HOTKEY: + snprintf(s, len, + "Enable other hotkeys.\n" + " \n" + " If this hotkey is bound to either keyboard, \n" + "joybutton or joyaxis, all other hotkeys will \n" + "be disabled unless this hotkey is also held \n" + "at the same time. \n" + " \n" + "This is useful for RETRO_KEYBOARD centric \n" + "implementations which query a large area of \n" + "the keyboard, where it is not desirable that \n" + "hotkeys get in the way."); + break; + case MENU_ENUM_LABEL_REWIND_ENABLE: + snprintf(s, len, + "Enable rewinding.\n" + " \n" + "This will take a performance hit, \n" + "so it is disabled by default."); + break; + case MENU_ENUM_LABEL_LIBRETRO_DIR_PATH: + snprintf(s, len, + "Core Directory. \n" + " \n" + "A directory for where to search for \n" + "libretro core implementations."); + break; + case MENU_ENUM_LABEL_VIDEO_REFRESH_RATE_AUTO: + snprintf(s, len, + "Refresh Rate Auto.\n" + " \n" + "The accurate refresh rate of our monitor (Hz).\n" + "This is used to calculate audio input rate with \n" + "the formula: \n" + " \n" + "audio_input_rate = game input rate * display \n" + "refresh rate / game refresh rate\n" + " \n" + "If the implementation does not report any \n" + "values, NTSC defaults will be assumed for \n" + "compatibility.\n" + " \n" + "This value should stay close to 60Hz to avoid \n" + "large pitch changes. If your monitor does \n" + "not run at 60Hz, or something close to it, \n" + "disable VSync, and leave this at its default."); + break; + case MENU_ENUM_LABEL_VIDEO_ROTATION: + snprintf(s, len, + "Forces a certain rotation \n" + "of the screen.\n" + " \n" + "The rotation is added to rotations which\n" + "the libretro core sets (see Video Allow\n" + "Rotate)."); + break; + case MENU_ENUM_LABEL_VIDEO_SCALE: + snprintf(s, len, + "Fullscreen resolution.\n" + " \n" + "Resolution of 0 uses the \n" + "resolution of the environment.\n"); + break; + case MENU_ENUM_LABEL_FASTFORWARD_RATIO: + snprintf(s, len, + "Fastforward ratio." + " \n" + "The maximum rate at which content will\n" + "be run when using fast forward.\n" + " \n" + " (E.g. 5.0 for 60 fps content => 300 fps \n" + "cap).\n" + " \n" + "RetroArch will go to sleep to ensure that \n" + "the maximum rate will not be exceeded.\n" + "Do not rely on this cap to be perfectly \n" + "accurate."); + break; + case MENU_ENUM_LABEL_VIDEO_MONITOR_INDEX: + snprintf(s, len, + "Which monitor to prefer.\n" + " \n" + "0 (default) means no particular monitor \n" + "is preferred, 1 and up (1 being first \n" + "monitor), suggests RetroArch to use that \n" + "particular monitor."); + break; + case MENU_ENUM_LABEL_VIDEO_CROP_OVERSCAN: + snprintf(s, len, + "Forces cropping of overscanned \n" + "frames.\n" + " \n" + "Exact behavior of this option is \n" + "core-implementation specific."); + break; + case MENU_ENUM_LABEL_VIDEO_SCALE_INTEGER: + snprintf(s, len, + "Only scales video in integer \n" + "steps.\n" + " \n" + "The base size depends on system-reported \n" + "geometry and aspect ratio.\n" + " \n" + "If Force Aspect is not set, X/Y will be \n" + "integer scaled independently."); + break; + case MENU_ENUM_LABEL_AUDIO_VOLUME: + snprintf(s, len, + "Audio volume, expressed in dB.\n" + " \n" + " 0 dB is normal volume. No gain will be applied.\n" + "Gain can be controlled in runtime with Input\n" + "Volume Up / Input Volume Down."); + break; + case MENU_ENUM_LABEL_AUDIO_RATE_CONTROL_DELTA: + snprintf(s, len, + "Audio rate control.\n" + " \n" + "Setting this to 0 disables rate control.\n" + "Any other value controls audio rate control \n" + "delta.\n" + " \n" + "Defines how much input rate can be adjusted \n" + "dynamically.\n" + " \n" + " Input rate is defined as: \n" + " input rate * (1.0 +/- (rate control delta))"); + break; + case MENU_ENUM_LABEL_AUDIO_MAX_TIMING_SKEW: + snprintf(s, len, + "Maximum audio timing skew.\n" + " \n" + "Defines the maximum change in input rate.\n" + "You may want to increase this to enable\n" + "very large changes in timing, for example\n" + "running PAL cores on NTSC displays, at the\n" + "cost of inaccurate audio pitch.\n" + " \n" + " Input rate is defined as: \n" + " input rate * (1.0 +/- (max timing skew))"); + break; + case MENU_ENUM_LABEL_OVERLAY_NEXT: + snprintf(s, len, + "Toggles to next overlay.\n" + " \n" + "Wraps around."); + break; + case MENU_ENUM_LABEL_LOG_VERBOSITY: + snprintf(s, len, + "Enable or disable verbosity level \n" + "of frontend."); + break; + case MENU_ENUM_LABEL_VOLUME_UP: + snprintf(s, len, + "Increases audio volume."); + break; + case MENU_ENUM_LABEL_VOLUME_DOWN: + snprintf(s, len, + "Decreases audio volume."); + break; + case MENU_ENUM_LABEL_VIDEO_DISABLE_COMPOSITION: + snprintf(s, len, + "Forcibly disable composition.\n" + "Only valid on Windows Vista/7 for now."); + break; + case MENU_ENUM_LABEL_PERFCNT_ENABLE: + snprintf(s, len, + "Enable or disable frontend \n" + "performance counters."); + break; + case MENU_ENUM_LABEL_SYSTEM_DIRECTORY: + snprintf(s, len, + "System Directory. \n" + " \n" + "Sets the 'system' directory.\n" + "Cores can query for this\n" + "directory to load BIOSes, \n" + "system-specific configs, etc."); + break; + case MENU_ENUM_LABEL_SAVESTATE_AUTO_SAVE: + case MENU_ENUM_LABEL_SAVESTATE_AUTO_LOAD: + snprintf(s, len, + "Automatically saves a savestate at the \n" + "end of RetroArch's lifetime.\n" + " \n" + "RetroArch will automatically load any savestate\n" + "with this path on startup if 'Auto Load State\n" + "is enabled."); + break; + case MENU_ENUM_LABEL_VIDEO_THREADED: + snprintf(s, len, + "Use threaded video driver.\n" + " \n" + "Using this might improve performance at the \n" + "possible cost of latency and more video \n" + "stuttering."); + break; + case MENU_ENUM_LABEL_VIDEO_VSYNC: + snprintf(s, len, + "Video V-Sync.\n"); + break; + case MENU_ENUM_LABEL_VIDEO_HARD_SYNC: + snprintf(s, len, + "Attempts to hard-synchronize \n" + "CPU and GPU.\n" + " \n" + "Can reduce latency at the cost of \n" + "performance."); + break; + case MENU_ENUM_LABEL_REWIND_GRANULARITY: + snprintf(s, len, + "Rewind granularity.\n" + " \n" + " When rewinding defined number of \n" + "frames, you can rewind several frames \n" + "at a time, increasing the rewinding \n" + "speed."); + break; + case MENU_ENUM_LABEL_SCREENSHOT: + snprintf(s, len, + "Take screenshot."); + break; + case MENU_ENUM_LABEL_VIDEO_FRAME_DELAY: + snprintf(s, len, + "Sets how many milliseconds to delay\n" + "after VSync before running the core.\n" + "\n" + "Can reduce latency at the cost of\n" + "higher risk of stuttering.\n" + " \n" + "Maximum is 15."); + break; + case MENU_ENUM_LABEL_VIDEO_HARD_SYNC_FRAMES: + snprintf(s, len, + "Sets how many frames CPU can \n" + "run ahead of GPU when using 'GPU \n" + "Hard Sync'.\n" + " \n" + "Maximum is 3.\n" + " \n" + " 0: Syncs to GPU immediately.\n" + " 1: Syncs to previous frame.\n" + " 2: Etc ..."); + break; + case MENU_ENUM_LABEL_VIDEO_BLACK_FRAME_INSERTION: + snprintf(s, len, + "Inserts a black frame inbetween \n" + "frames.\n" + " \n" + "Useful for 120 Hz monitors who want to \n" + "play 60 Hz material with eliminated \n" + "ghosting.\n" + " \n" + "Video refresh rate should still be \n" + "configured as if it is a 60 Hz monitor \n" + "(divide refresh rate by 2)."); + break; + case MENU_ENUM_LABEL_RGUI_SHOW_START_SCREEN: + snprintf(s, len, + "Show startup screen in menu.\n" + "Is automatically set to false when seen\n" + "for the first time.\n" + " \n" + "This is only updated in config if\n" + "'Save Configuration on Exit' is enabled.\n"); + break; + case MENU_ENUM_LABEL_CORE_SPECIFIC_CONFIG: + snprintf(s, len, + "Load up a specific config file \n" + "based on the core being used.\n"); + break; + case MENU_ENUM_LABEL_VIDEO_FULLSCREEN: + snprintf(s, len, "Toggles fullscreen."); + break; + case MENU_ENUM_LABEL_BLOCK_SRAM_OVERWRITE: + snprintf(s, len, + "Block SRAM from being overwritten \n" + "when loading save states.\n" + " \n" + "Might potentially lead to buggy games."); + break; + case MENU_ENUM_LABEL_PAUSE_NONACTIVE: + snprintf(s, len, + "Pause gameplay when window focus \n" + "is lost."); + break; + case MENU_ENUM_LABEL_VIDEO_GPU_SCREENSHOT: + snprintf(s, len, + "Screenshots output of GPU shaded \n" + "material if available."); + break; + case MENU_ENUM_LABEL_SCREENSHOT_DIRECTORY: + snprintf(s, len, + "Screenshot Directory. \n" + " \n" + "Directory to dump screenshots to." + ); + break; + case MENU_ENUM_LABEL_VIDEO_SWAP_INTERVAL: + snprintf(s, len, + "VSync Swap Interval.\n" + " \n" + "Uses a custom swap interval for VSync. Set this \n" + "to effectively halve monitor refresh rate."); + break; + case MENU_ENUM_LABEL_SAVEFILE_DIRECTORY: + snprintf(s, len, + "Savefile Directory. \n" + " \n" + "Save all save files (*.srm) to this \n" + "directory. This includes related files like \n" + ".bsv, .rt, .psrm, etc...\n" + " \n" + "This will be overridden by explicit command line\n" + "options."); + break; + case MENU_ENUM_LABEL_SAVESTATE_DIRECTORY: + snprintf(s, len, + "Savestate Directory. \n" + " \n" + "Save all save states (*.state) to this \n" + "directory.\n" + " \n" + "This will be overridden by explicit command line\n" + "options."); + break; + case MENU_ENUM_LABEL_ASSETS_DIRECTORY: + snprintf(s, len, + "Assets Directory. \n" + " \n" + " This location is queried by default when \n" + "menu interfaces try to look for loadable \n" + "assets, etc."); + break; + case MENU_ENUM_LABEL_DYNAMIC_WALLPAPERS_DIRECTORY: + snprintf(s, len, + "Dynamic Wallpapers Directory. \n" + " \n" + " The place to store wallpapers that will \n" + "be loaded dynamically by the menu depending \n" + "on context."); + break; + case MENU_ENUM_LABEL_SLOWMOTION_RATIO: + snprintf(s, len, + "Slowmotion ratio." + " \n" + "When slowmotion, content will slow\n" + "down by factor."); + break; + case MENU_ENUM_LABEL_INPUT_AXIS_THRESHOLD: + snprintf(s, len, + "Defines axis threshold.\n" + " \n" + "How far an axis must be tilted to result\n" + "in a button press.\n" + " Possible values are [0.0, 1.0]."); + break; + case MENU_ENUM_LABEL_INPUT_TURBO_PERIOD: + snprintf(s, len, + "Turbo period.\n" + " \n" + "Describes the period of which turbo-enabled\n" + "buttons toggle.\n" + " \n" + "Numbers are described in frames." + ); + break; + case MENU_ENUM_LABEL_INPUT_DUTY_CYCLE: + snprintf(s, len, + "Duty cycle.\n" + " \n" + "Describes how long the period of a turbo-enabled\n" + "should be.\n" + " \n" + "Numbers are described in frames." + ); + break; + case MENU_ENUM_LABEL_INPUT_TOUCH_ENABLE: + snprintf(s, len, "Enable touch support."); + break; + case MENU_ENUM_LABEL_INPUT_PREFER_FRONT_TOUCH: + snprintf(s, len, "Use front instead of back touch."); + break; + case MENU_ENUM_LABEL_MOUSE_ENABLE: + snprintf(s, len, "Enable mouse input inside the menu."); + break; + case MENU_ENUM_LABEL_POINTER_ENABLE: + snprintf(s, len, "Enable touch input inside the menu."); + break; + case MENU_ENUM_LABEL_MENU_WALLPAPER: + snprintf(s, len, "Path to an image to set as menu wallpaper."); + break; + case MENU_ENUM_LABEL_NAVIGATION_WRAPAROUND: + snprintf(s, len, + "Wrap-around to beginning and/or end \n" + "if boundary of list is reached \n" + "horizontally and/or vertically."); + break; + case MENU_ENUM_LABEL_PAUSE_LIBRETRO: + snprintf(s, len, + "If disabled, the libretro core will keep \n" + "running in the background when we are in the \n" + "menu."); + break; + case MENU_ENUM_LABEL_SUSPEND_SCREENSAVER_ENABLE: + snprintf(s, len, + "Suspends the screensaver. Is a hint that \n" + "does not necessarily have to be \n" + "honored by the video driver."); + break; + case MENU_ENUM_LABEL_NETPLAY_MODE: + snprintf(s, len, + "Netplay client mode for the current user. \n" + "Will be 'Server' mode if disabled."); + break; + case MENU_ENUM_LABEL_NETPLAY_DELAY_FRAMES: + snprintf(s, len, + "The amount of delay frames to use for netplay. \n" + " \n" + "Increasing this value will increase \n" + "performance, but introduce more latency."); + break; + case MENU_ENUM_LABEL_NETPLAY_CHECK_FRAMES: + snprintf(s, len, + "The frequency in frames with which netplay \n" + "will verify that the host and client are in \n" + "sync. \n" + " \n" + "With most cores, this value will have no \n" + "visible effect and can be ignored. With \n" + "nondeterminstic cores, this value determines \n" + "how often the netplay peers will be brought \n" + "into sync. With buggy cores, setting this \n" + "to any non-zero value will cause severe \n" + "performance issues. Set to zero to perform \n" + "no checks. This value is only used on the \n" + "netplay host. \n"); + break; + case MENU_ENUM_LABEL_VIDEO_MAX_SWAPCHAIN_IMAGES: + snprintf(s, len, + "Maximum amount of swapchain images. This \n" + "can tell the video driver to use a specific \n" + "video buffering mode. \n" + " \n" + "Single buffering - 1\n" + "Double buffering - 2\n" + "Triple buffering - 3\n" + " \n" + "Setting the right buffering mode can have \n" + "a big impact on latency."); + break; + case MENU_ENUM_LABEL_VIDEO_SMOOTH: + snprintf(s, len, + "Smoothens picture with bilinear filtering. \n" + "Should be disabled if using shaders."); + break; + case MENU_ENUM_LABEL_TIMEDATE_ENABLE: + snprintf(s, len, + "Shows current date and/or time inside menu."); + break; + case MENU_ENUM_LABEL_CORE_ENABLE: + snprintf(s, len, + "Shows current core inside menu."); + break; + case MENU_ENUM_LABEL_NETPLAY_ENABLE_HOST: + snprintf(s, len, + "Enables Netplay in host (server) mode."); + break; + case MENU_ENUM_LABEL_NETPLAY_ENABLE_CLIENT: + snprintf(s, len, + "Enables Netplay in client mode."); + break; + case MENU_ENUM_LABEL_NETPLAY_DISCONNECT: + snprintf(s, len, + "Disconnects an active Netplay connection."); + break; + case MENU_ENUM_LABEL_NETPLAY_SETTINGS: + snprintf(s, len, + "Setting related to Netplay."); + break; + case MENU_ENUM_LABEL_DYNAMIC_WALLPAPER: + snprintf(s, len, + "Dynamically load a new wallpaper \n" + "depending on context."); + break; + case MENU_ENUM_LABEL_CORE_UPDATER_BUILDBOT_URL: + snprintf(s, len, + "URL to core updater directory on the \n" + "Libretro buildbot."); + break; + case MENU_ENUM_LABEL_BUILDBOT_ASSETS_URL: + snprintf(s, len, + "URL to assets updater directory on the \n" + "Libretro buildbot."); + break; + case MENU_ENUM_LABEL_INPUT_REMAP_BINDS_ENABLE: + snprintf(s, len, + "if enabled, overrides the input binds \n" + "with the remapped binds set for the \n" + "current core."); + break; + case MENU_ENUM_LABEL_OVERLAY_DIRECTORY: + snprintf(s, len, + "Overlay Directory. \n" + " \n" + "Defines a directory where overlays are \n" + "kept for easy access."); + break; + case MENU_ENUM_LABEL_INPUT_MAX_USERS: + snprintf(s, len, + "Maximum amount of users supported by \n" + "RetroArch."); + break; + case MENU_ENUM_LABEL_CORE_UPDATER_AUTO_EXTRACT_ARCHIVE: + snprintf(s, len, + "After downloading, automatically extract \n" + "archives that the downloads are contained \n" + "inside."); + break; + case MENU_ENUM_LABEL_NAVIGATION_BROWSER_FILTER_SUPPORTED_EXTENSIONS_ENABLE: + snprintf(s, len, + "Filter files being shown by \n" + "supported extensions."); + break; + case MENU_ENUM_LABEL_NETPLAY_NICKNAME: + snprintf(s, len, + "The username of the person running RetroArch. \n" + "This will be used for playing online games."); + break; + case MENU_ENUM_LABEL_NETPLAY_CLIENT_SWAP_INPUT: + snprintf(s, len, + "When being client over netplay, use \n" + "keybinds for player 1."); + break; + case MENU_ENUM_LABEL_NETPLAY_TCP_UDP_PORT: + snprintf(s, len, + "The port of the host IP address. \n" + "Can be either a TCP or UDP port."); + break; + case MENU_ENUM_LABEL_NETPLAY_SPECTATOR_MODE_ENABLE: + snprintf(s, len, + "Enable or disable spectator mode for \n" + "the user during netplay."); + break; + case MENU_ENUM_LABEL_NETPLAY_IP_ADDRESS: + snprintf(s, len, + "The address of the host to connect to."); + break; + case MENU_ENUM_LABEL_STDIN_CMD_ENABLE: + snprintf(s, len, + "Enable stdin command interface."); + break; + case MENU_ENUM_LABEL_UI_COMPANION_START_ON_BOOT: + snprintf(s, len, + "Start User Interface companion driver \n" + "on boot (if available)."); + break; + case MENU_ENUM_LABEL_MENU_DRIVER: + snprintf(s, len, "Menu driver to use."); + break; + case MENU_ENUM_LABEL_INPUT_MENU_ENUM_TOGGLE_GAMEPAD_COMBO: + snprintf(s, len, + "Gamepad button combination to toggle menu. \n" + " \n" + "0 - None \n" + "1 - Press L + R + Y + D-Pad Down \n" + "simultaneously. \n" + "2 - Press L3 + R3 simultaneously. \n" + "3 - Press Start + Select simultaneously."); + break; + case MENU_ENUM_LABEL_INPUT_ALL_USERS_CONTROL_MENU: + snprintf(s, len, "Allow any RetroPad to control the menu."); + break; + case MENU_ENUM_LABEL_INPUT_AUTODETECT_ENABLE: + snprintf(s, len, + "Enable input auto-detection.\n" + " \n" + "Will attempt to auto-configure \n" + "joypads, Plug-and-Play style."); + break; + case MENU_ENUM_LABEL_CAMERA_ALLOW: + snprintf(s, len, + "Allow or disallow camera access by \n" + "cores."); + break; + case MENU_ENUM_LABEL_LOCATION_ALLOW: + snprintf(s, len, + "Allow or disallow location services \n" + "access by cores."); + break; + case MENU_ENUM_LABEL_TURBO: + snprintf(s, len, + "Turbo enable.\n" + " \n" + "Holding the turbo while pressing another \n" + "button will let the button enter a turbo \n" + "mode where the button state is modulated \n" + "with a periodic signal. \n" + " \n" + "The modulation stops when the button \n" + "itself (not turbo button) is released."); + break; + case MENU_ENUM_LABEL_OSK_ENABLE: + snprintf(s, len, + "Enable/disable on-screen keyboard."); + break; + case MENU_ENUM_LABEL_AUDIO_MUTE: + snprintf(s, len, + "Mute/unmute audio."); + break; + case MENU_ENUM_LABEL_REWIND: + snprintf(s, len, + "Hold button down to rewind.\n" + " \n" + "Rewind must be enabled."); + break; + case MENU_ENUM_LABEL_EXIT_EMULATOR: + snprintf(s, len, + "Key to exit RetroArch cleanly." +#if !defined(RARCH_MOBILE) && !defined(RARCH_CONSOLE) + "\nKilling it in any hard way (SIGKILL, \n" + "etc) will terminate without saving\n" + "RAM, etc. On Unix-likes,\n" + "SIGINT/SIGTERM allows\n" + "a clean deinitialization." +#endif + ); + break; + case MENU_ENUM_LABEL_LOAD_STATE: + snprintf(s, len, + "Loads state."); + break; + case MENU_ENUM_LABEL_SAVE_STATE: + snprintf(s, len, + "Saves state."); + break; + case MENU_ENUM_LABEL_NETPLAY_FLIP_PLAYERS: + snprintf(s, len, + "Netplay flip users."); + break; + case MENU_ENUM_LABEL_CHEAT_INDEX_PLUS: + snprintf(s, len, + "Increment cheat index.\n"); + break; + case MENU_ENUM_LABEL_CHEAT_INDEX_MINUS: + snprintf(s, len, + "Decrement cheat index.\n"); + break; + case MENU_ENUM_LABEL_SHADER_PREV: + snprintf(s, len, + "Applies previous shader in directory."); + break; + case MENU_ENUM_LABEL_SHADER_NEXT: + snprintf(s, len, + "Applies next shader in directory."); + break; + case MENU_ENUM_LABEL_RESET: + snprintf(s, len, + "Reset the content.\n"); + break; + case MENU_ENUM_LABEL_PAUSE_TOGGLE: + snprintf(s, len, + "Toggle between paused and non-paused state."); + break; + case MENU_ENUM_LABEL_CHEAT_TOGGLE: + snprintf(s, len, + "Toggle cheat index.\n"); + break; + case MENU_ENUM_LABEL_HOLD_FAST_FORWARD: + snprintf(s, len, + "Hold for fast-forward. Releasing button \n" + "disables fast-forward."); + break; + case MENU_ENUM_LABEL_SLOWMOTION: + snprintf(s, len, + "Hold for slowmotion."); + break; + case MENU_ENUM_LABEL_FRAME_ADVANCE: + snprintf(s, len, + "Frame advance when content is paused."); + break; + case MENU_ENUM_LABEL_MOVIE_RECORD_TOGGLE: + snprintf(s, len, + "Toggle between recording and not."); + break; + case MENU_ENUM_LABEL_L_X_PLUS: + case MENU_ENUM_LABEL_L_X_MINUS: + case MENU_ENUM_LABEL_L_Y_PLUS: + case MENU_ENUM_LABEL_L_Y_MINUS: + case MENU_ENUM_LABEL_R_X_PLUS: + case MENU_ENUM_LABEL_R_X_MINUS: + case MENU_ENUM_LABEL_R_Y_PLUS: + case MENU_ENUM_LABEL_R_Y_MINUS: + snprintf(s, len, + "Axis for analog stick (DualShock-esque).\n" + " \n" + "Bound as usual, however, if a real analog \n" + "axis is bound, it can be read as a true analog.\n" + " \n" + "Positive X axis is right. \n" + "Positive Y axis is down."); + break; + case MENU_ENUM_LABEL_VALUE_WHAT_IS_A_CORE_DESC: + snprintf(s, len, + "RetroArch by itself does nothing. \n" + " \n" + "To make it do things, you need to \n" + "load a program into it. \n" + "\n" + "We call such a program 'Libretro core', \n" + "or 'core' in short. \n" + " \n" + "To load a core, select one from\n" + "'Load Core'.\n" + " \n" +#ifdef HAVE_NETWORKING + "You can obtain cores in several ways: \n" + "* Download them by going to\n" + "'%s' -> '%s'.\n" + "* Manually move them over to\n" + "'%s'.", + msg_hash_to_str(MENU_ENUM_LABEL_VALUE_ONLINE_UPDATER), + msg_hash_to_str(MENU_ENUM_LABEL_VALUE_CORE_UPDATER_LIST), + msg_hash_to_str(MENU_ENUM_LABEL_VALUE_LIBRETRO_DIR_PATH) +#else + "You can obtain cores by\n" + "manually moving them over to\n" + "'%s'.", + msg_hash_to_str(MENU_ENUM_LABEL_VALUE_LIBRETRO_DIR_PATH) +#endif + ); + break; + case MENU_ENUM_LABEL_VALUE_HELP_CHANGE_VIRTUAL_GAMEPAD_DESC: + snprintf(s, len, + "You can change the virtual gamepad overlay\n" + "by going to '%s' -> '%s'." + " \n" + "From there you can change the overlay,\n" + "change the size and opacity of the buttons, etc.\n" + " \n" + "NOTE: By default, virtual gamepad overlays are\n" + "hidden when in the menu.\n" + "If you'd like to change this behavior,\n" + "you can set '%s' to false.", + msg_hash_to_str(MENU_ENUM_LABEL_VALUE_SETTINGS), + msg_hash_to_str(MENU_ENUM_LABEL_VALUE_OVERLAY_SETTINGS), + msg_hash_to_str(MENU_ENUM_LABEL_VALUE_INPUT_OVERLAY_HIDE_IN_MENU) + ); + break; + default: + if (string_is_empty(s)) + strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_NO_INFORMATION_AVAILABLE), len); + return -1; + } + + return 0; +} + +#ifdef HAVE_MENU +static const char *menu_hash_to_str_vn_label_enum(enum msg_hash_enums msg) +{ + if (msg <= MENU_ENUM_LABEL_INPUT_HOTKEY_BIND_END && + msg >= MENU_ENUM_LABEL_INPUT_HOTKEY_BIND_BEGIN) + { + static char hotkey_lbl[128] = {0}; + unsigned idx = msg - MENU_ENUM_LABEL_INPUT_HOTKEY_BIND_BEGIN; + snprintf(hotkey_lbl, sizeof(hotkey_lbl), "input_hotkey_binds_%d", idx); + return hotkey_lbl; + } + + switch (msg) + { + case MENU_ENUM_SUBLABEL_VIDEO_THREADED: + return "Improves performance at the cost of latency and more video stuttering. Use only if you cannot obtain full speed otherwise."; + case MENU_ENUM_SUBLABEL_VIDEO_HARD_SYNC: + return "Hard-synchronize the CPU and GPU. Reduces latency at the cost of performance."; + case MENU_ENUM_SUBLABEL_MENU_SETTINGS: + return "Adjusts settings related to the appearance of the menu screen."; + case MSG_CONNECTION_SLOT: + return "Connection slot"; + case MSG_WAITING_FOR_CLIENT: + return "Waiting for client ..."; + case MSG_CONNECTING_TO_NETPLAY_HOST: + return "Connecting to netplay host"; + case MSG_GOT_CONNECTION_FROM: + return "Got connection from"; + case MSG_AUTODETECT: + return "Autodetect"; + case MSG_SUCCEEDED: + return "succeeded"; + case MSG_FAILED: + return "failed"; + case MSG_UNKNOWN_NETPLAY_COMMAND_RECEIVED: + return "Unknown netplay command received"; + case MSG_NETPLAY_USERS_HAS_FLIPPED: + return "Netplay users has flipped"; + case MSG_FILE_ALREADY_EXISTS_SAVING_TO_BACKUP_BUFFER: + return "File already exists. Saving to backup buffer"; + case MSG_AUTOLOADING_SAVESTATE_FROM: + return "Auto-loading savestate from"; + case MSG_CONNECTING_TO_PORT: + return "Connecting to port"; + case MSG_SETTING_DISK_IN_TRAY: + return "Setting disk in tray"; + case MSG_AUDIO_VOLUME: + return "Audio volume"; + case MSG_FAILED_TO_SET_DISK: + return "Failed to set disk"; + case MSG_FAILED_TO_START_AUDIO_DRIVER: + return "failed_to_start_audio_driver"; + case MSG_FOUND_LAST_STATE_SLOT: + return "found_last_state_slot"; + case MSG_DEVICE_CONFIGURED_IN_PORT: + return "configured in port"; + case MSG_DEVICE_NOT_CONFIGURED: + return "not configured"; + case MSG_DEVICE_DISCONNECTED_FROM_PORT: + return "Device disconnected from port"; + case MSG_CONNECT_DEVICE_FROM_A_VALID_PORT: + return "connect_device_from_a_valid_port"; + case MSG_DISCONNECT_DEVICE_FROM_A_VALID_PORT: + return "disconnect_device_from_a_valid_port"; + case MSG_DISCONNECTING_DEVICE_FROM_PORT: + return "disconnecting_device_from_port"; + case MSG_BRINGING_UP_COMMAND_INTERFACE_ON_PORT: + return "bringing_up_command_interface_at_port"; + case MENU_ENUM_LABEL_VIDEO_MAX_SWAPCHAIN_IMAGES: + return "video_max_swapchain_images"; + case MENU_ENUM_LABEL_CORE_SETTINGS: + return "core_settings"; + case MENU_ENUM_LABEL_CB_MENU_WALLPAPER: + return "cb_menu_wallpaper"; + case MENU_ENUM_LABEL_CB_MENU_THUMBNAIL: + return "cb_menu_thumbnail"; + case MENU_ENUM_LABEL_CB_LAKKA_LIST: + return "cb_lakka_list"; + case MENU_ENUM_LABEL_CB_THUMBNAILS_UPDATER_LIST: + return "cb_thumbnails_updater_list"; + case MENU_ENUM_LABEL_CB_CORE_UPDATER_LIST: + return "cb_core_updater_list"; + case MENU_ENUM_LABEL_CB_CORE_CONTENT_LIST: + return "cb_core_content_list"; + case MENU_ENUM_LABEL_CB_CORE_CONTENT_DIRS_LIST: + return "cb_core_content_dirs_list"; + case MENU_ENUM_LABEL_CB_CORE_THUMBNAILS_DOWNLOAD: + return "cb_core_thumbnails_download"; + case MENU_ENUM_LABEL_CB_CORE_UPDATER_DOWNLOAD: + return "cb_core_updater_download"; + case MENU_ENUM_LABEL_CB_UPDATE_CHEATS: + return "cb_update_cheats"; + case MENU_ENUM_LABEL_CB_UPDATE_OVERLAYS: + return "cb_update_overlays"; + case MENU_ENUM_LABEL_CB_UPDATE_DATABASES: + return "cb_update_databases"; + case MENU_ENUM_LABEL_CB_UPDATE_SHADERS_GLSL: + return "cb_update_shaders_glsl"; + case MENU_ENUM_LABEL_CB_UPDATE_SHADERS_CG: + return "cb_update_shaders_cg"; + case MENU_ENUM_LABEL_CB_UPDATE_CORE_INFO_FILES: + return "cb_update_core_info_files"; + case MENU_ENUM_LABEL_CB_CORE_CONTENT_DOWNLOAD: + return "cb_core_content_download"; + case MENU_ENUM_LABEL_CB_LAKKA_DOWNLOAD: + return "cb_lakka_download"; + case MENU_ENUM_LABEL_CB_UPDATE_ASSETS: + return "cb_update_assets"; + case MENU_ENUM_LABEL_CB_UPDATE_AUTOCONFIG_PROFILES: + return "cb_update_autoconfig_profiles"; + case MENU_ENUM_LABEL_CB_THUMBNAILS_UPDATER_DOWNLOAD: + return "cb_thumbnails_updater_download"; + case MENU_ENUM_LABEL_CONTENT_ACTIONS: + return "content_actions"; + case MENU_ENUM_LABEL_CPU_ARCHITECTURE: + return "system_information_cpu_architecture"; + case MENU_ENUM_LABEL_CPU_CORES: + return "system_information_cpu_cores"; + case MENU_ENUM_LABEL_NO_ITEMS: + return "no_items"; + case MENU_ENUM_LABEL_NO_PLAYLISTS: + return "no_playlists"; + case MENU_ENUM_LABEL_NO_HISTORY_AVAILABLE: + return "no_history"; + case MENU_ENUM_LABEL_NO_SHADER_PARAMETERS: + return "no_shader_parameters."; + case MENU_ENUM_LABEL_SETTINGS_TAB: + return "settings_tab"; + case MENU_ENUM_LABEL_HISTORY_TAB: + return "history_tab"; + case MENU_ENUM_LABEL_ADD_TAB: + return "add_tab"; + case MENU_ENUM_LABEL_PLAYLISTS_TAB: + return "playlists_tab"; + case MENU_ENUM_LABEL_MUSIC_TAB: + return "music_tab"; + case MENU_ENUM_LABEL_VIDEO_TAB: + return "video_tab"; + case MENU_ENUM_LABEL_IMAGES_TAB: + return "images_tab"; + case MENU_ENUM_LABEL_HORIZONTAL_MENU: + return "horizontal_menu"; + case MENU_ENUM_LABEL_PARENT_DIRECTORY: + return "parent_directory"; + case MENU_ENUM_LABEL_INPUT_PLAYER_ANALOG_DPAD_MODE: + return "input_player%u_analog_dpad_mode"; + case MENU_ENUM_LABEL_INPUT_LIBRETRO_DEVICE: + return "input_libretro_device_p%u"; + case MENU_ENUM_LABEL_RUN: + return "collection"; + case MENU_ENUM_LABEL_PLAYLIST_COLLECTION_ENTRY: + return "playlist_collection_entry"; + case MENU_ENUM_LABEL_CHEEVOS_LOCKED_ENTRY: + return "cheevos_locked_entry"; + case MENU_ENUM_LABEL_CHEEVOS_UNLOCKED_ENTRY: + return "cheevos_unlocked_entry"; + case MENU_ENUM_LABEL_CORE_INFO_ENTRY: + return "core_info_entry"; + case MENU_ENUM_LABEL_NETWORK_INFO_ENTRY: + return "network_info_entry"; + case MENU_ENUM_LABEL_PLAYLIST_ENTRY: + return "playlist_entry"; + case MENU_ENUM_LABEL_SYSTEM_INFO_ENTRY: + return "system_info_entry"; + case MENU_ENUM_LABEL_INPUT_USER_1_BINDS: + return "1_input_binds_list"; + case MENU_ENUM_LABEL_INPUT_USER_2_BINDS: + return "2_input_binds_list"; + case MENU_ENUM_LABEL_INPUT_USER_3_BINDS: + return "3_input_binds_list"; + case MENU_ENUM_LABEL_INPUT_USER_4_BINDS: + return "4_input_binds_list"; + case MENU_ENUM_LABEL_INPUT_USER_5_BINDS: + return "5_input_binds_list"; + case MENU_ENUM_LABEL_INPUT_USER_6_BINDS: + return "6_input_binds_list"; + case MENU_ENUM_LABEL_INPUT_USER_7_BINDS: + return "7_input_binds_list"; + case MENU_ENUM_LABEL_INPUT_USER_8_BINDS: + return "8_input_binds_list"; + case MENU_ENUM_LABEL_INPUT_USER_9_BINDS: + return "9_input_binds_list"; + case MENU_ENUM_LABEL_INPUT_USER_10_BINDS: + return "10_input_binds_list"; + case MENU_ENUM_LABEL_INPUT_USER_11_BINDS: + return "11_input_binds_list"; + case MENU_ENUM_LABEL_INPUT_USER_12_BINDS: + return "12_input_binds_list"; + case MENU_ENUM_LABEL_INPUT_USER_13_BINDS: + return "13_input_binds_list"; + case MENU_ENUM_LABEL_INPUT_USER_14_BINDS: + return "14_input_binds_list"; + case MENU_ENUM_LABEL_INPUT_USER_15_BINDS: + return "15_input_binds_list"; + case MENU_ENUM_LABEL_INPUT_USER_16_BINDS: + return "16_input_binds_list"; + case MENU_ENUM_LABEL_VIDEO_VIEWPORT_CUSTOM_X: + return "video_viewport_custom_x"; + case MENU_ENUM_LABEL_VIDEO_VIEWPORT_CUSTOM_Y: + return "video_viewport_custom_y"; + case MENU_ENUM_LABEL_VIDEO_VIEWPORT_CUSTOM_WIDTH: + return "video_viewport_custom_width"; + case MENU_ENUM_LABEL_VIDEO_VIEWPORT_CUSTOM_HEIGHT: + return "video_viewport_custom_height"; + case MENU_ENUM_LABEL_NO_CORES_AVAILABLE: + return "no_cores_available"; + case MENU_ENUM_LABEL_NO_CORE_OPTIONS_AVAILABLE: + return "no_core_options_available"; + case MENU_ENUM_LABEL_NO_CORE_INFORMATION_AVAILABLE: + return "no_core_information_available"; + case MENU_ENUM_LABEL_CORE_OPTION_ENTRY: + return "core_option_entry"; + case MENU_ENUM_LABEL_URL_ENTRY: + return "url_entry"; + case MENU_ENUM_LABEL_NO_PERFORMANCE_COUNTERS: + return "no_performance_counters"; + case MENU_ENUM_LABEL_NO_ENTRIES_TO_DISPLAY: + return "no_entries_to_display"; + case MENU_ENUM_LABEL_NO_ACHIEVEMENTS_TO_DISPLAY: + return "no_achievements_to_display"; + case MENU_ENUM_LABEL_CHEEVOS_UNLOCKED_ACHIEVEMENTS: + return "cheevos_unlocked_achievements"; + case MENU_ENUM_LABEL_CHEEVOS_LOCKED_ACHIEVEMENTS: + return "cheevos_locked_achievements"; + case MENU_ENUM_LABEL_MAIN_MENU: + return "main_menu"; + case MENU_ENUM_LABEL_MENU_LINEAR_FILTER: + return "menu_linear_filter"; + case MENU_ENUM_LABEL_MENU_ENUM_THROTTLE_FRAMERATE: + return "menu_throttle_framerate"; + case MENU_ENUM_LABEL_START_CORE: + return "start_core"; + case MENU_ENUM_LABEL_CHEEVOS_HARDCORE_MODE_ENABLE: + return "cheevos_hardcore_mode_enable"; + case MENU_ENUM_LABEL_CHEEVOS_TEST_UNOFFICIAL: + return "cheevos_test_unofficial"; + case MENU_ENUM_LABEL_CHEEVOS_ENABLE: + return "cheevos_enable"; + case MENU_ENUM_LABEL_INPUT_TOUCH_ENABLE: + return "input_touch_enable"; + case MENU_ENUM_LABEL_INPUT_PREFER_FRONT_TOUCH: + return "input_prefer_front_touch"; + case MENU_ENUM_LABEL_INPUT_ICADE_ENABLE: + return "input_icade_enable"; + case MENU_ENUM_LABEL_INPUT_KEYBOARD_GAMEPAD_MAPPING_TYPE: + return "keyboard_gamepad_mapping_type"; + case MENU_ENUM_LABEL_INPUT_SMALL_KEYBOARD_ENABLE: + return "input_small_keyboard_enable"; + case MENU_ENUM_LABEL_SAVE_CURRENT_CONFIG: + return "save_current_config"; + case MENU_ENUM_LABEL_SAVE_CURRENT_CONFIG_OVERRIDE_CORE: + return "save_current_config_override_core"; + case MENU_ENUM_LABEL_SAVE_CURRENT_CONFIG_OVERRIDE_GAME: + return "save_current_config_override_game"; + case MENU_ENUM_LABEL_STATE_SLOT: + return "state_slot"; + case MENU_ENUM_LABEL_CHEEVOS_USERNAME: + return "cheevos_username"; + case MENU_ENUM_LABEL_CHEEVOS_PASSWORD: + return "cheevos_password"; + case MENU_ENUM_LABEL_ACCOUNTS_CHEEVOS_USERNAME: + return "accounts_cheevos_username"; + case MENU_ENUM_LABEL_ACCOUNTS_RETRO_ACHIEVEMENTS: + return "retro_achievements"; + case MENU_ENUM_LABEL_DEFERRED_ACCOUNTS_CHEEVOS_LIST: + return "deferred_accounts_cheevos_list"; + case MENU_ENUM_LABEL_DEFERRED_USER_BINDS_LIST: + return "deferred_user_binds_list"; + case MENU_ENUM_LABEL_DEFERRED_ACCOUNTS_LIST: + return "deferred_accounts_list"; + case MENU_ENUM_LABEL_DEFERRED_INPUT_SETTINGS_LIST: + return "deferred_input_settings_list"; + case MENU_ENUM_LABEL_DEFERRED_DRIVER_SETTINGS_LIST: + return "deferred_driver_settings_list"; + case MENU_ENUM_LABEL_DEFERRED_AUDIO_SETTINGS_LIST: + return "deferred_audio_settings_list"; + case MENU_ENUM_LABEL_DEFERRED_CORE_SETTINGS_LIST: + return "deferred_core_settings_list"; + case MENU_ENUM_LABEL_DEFERRED_VIDEO_SETTINGS_LIST: + return "deferred_video_settings_list"; + case MENU_ENUM_LABEL_DEFERRED_CONFIGURATION_SETTINGS_LIST: + return "deferred_configuration_settings_list"; + case MENU_ENUM_LABEL_DEFERRED_SAVING_SETTINGS_LIST: + return "deferred_saving_settings_list"; + case MENU_ENUM_LABEL_DEFERRED_LOGGING_SETTINGS_LIST: + return "deferred_logging_settings_list"; + case MENU_ENUM_LABEL_DEFERRED_FRAME_THROTTLE_SETTINGS_LIST: + return "deferred_frame_throttle_settings_list"; + case MENU_ENUM_LABEL_DEFERRED_REWIND_SETTINGS_LIST: + return "deferred_rewind_settings_list"; + case MENU_ENUM_LABEL_DEFERRED_ONSCREEN_DISPLAY_SETTINGS_LIST: + return "deferred_onscreen_display_settings_list"; + case MENU_ENUM_LABEL_DEFERRED_ONSCREEN_OVERLAY_SETTINGS_LIST: + return "deferred_onscreen_overlay_settings_list"; + case MENU_ENUM_LABEL_DEFERRED_MENU_SETTINGS_LIST: + return "deferred_menu_settings_list"; + case MENU_ENUM_LABEL_DEFERRED_USER_INTERFACE_SETTINGS_LIST: + return "deferred_user_interface_settings_list"; + case MENU_ENUM_LABEL_DEFERRED_MENU_FILE_BROWSER_SETTINGS_LIST: + return "deferred_menu_file_browser_settings_list"; + case MENU_ENUM_LABEL_FILE_BROWSER_DIRECTORY: + return "file_browser_directory"; + case MENU_ENUM_LABEL_FILE_BROWSER_PLAIN_FILE: + return "file_browser_plain_file"; + case MENU_ENUM_LABEL_FILE_BROWSER_REMAP: + return "file_browser_remap"; + case MENU_ENUM_LABEL_FILE_BROWSER_SHADER: + return "file_browser_shader"; + case MENU_ENUM_LABEL_FILE_BROWSER_SHADER_PRESET: + return "file_browser_shader_preset"; + case MENU_ENUM_LABEL_FILE_BROWSER_CORE: + return "file_browser_core"; + case MENU_ENUM_LABEL_FILE_BROWSER_CORE_SELECT_FROM_COLLECTION: + return "file_browser_core_select_from_collection"; + case MENU_ENUM_LABEL_FILE_BROWSER_MUSIC_OPEN: + return "file_browser_music_open"; + case MENU_ENUM_LABEL_FILE_BROWSER_MOVIE_OPEN: + return "file_browser_movie_open"; + case MENU_ENUM_LABEL_FILE_BROWSER_IMAGE_OPEN_WITH_VIEWER: + return "file_browser_image_open_with_viewer"; + case MENU_ENUM_LABEL_FILE_BROWSER_IMAGE: + return "file_browser_image"; + case MENU_ENUM_LABEL_FILE_BROWSER_CORE_DETECTED: + return "file_browser_core_detected"; + case MENU_ENUM_LABEL_DEFERRED_RETRO_ACHIEVEMENTS_SETTINGS_LIST: + return "deferred_retro_achievements_settings_list"; + case MENU_ENUM_LABEL_DEFERRED_UPDATER_SETTINGS_LIST: + return "deferred_updater_settings_list"; + case MENU_ENUM_LABEL_DEFERRED_WIFI_SETTINGS_LIST: + return "deferred_wifi_settings_list"; + case MENU_ENUM_LABEL_DEFERRED_NETWORK_SETTINGS_LIST: + return "deferred_network_settings_list"; + case MENU_ENUM_LABEL_DEFERRED_LAKKA_SERVICES_LIST: + return "deferred_lakka_services_list"; + case MENU_ENUM_LABEL_DEFERRED_USER_SETTINGS_LIST: + return "deferred_user_settings_list"; + case MENU_ENUM_LABEL_DEFERRED_DIRECTORY_SETTINGS_LIST: + return "deferred_directory_settings_list"; + case MENU_ENUM_LABEL_DEFERRED_PRIVACY_SETTINGS_LIST: + return "deferred_privacy_settings_list"; + case MENU_ENUM_LABEL_ACCOUNTS_LIST: + return "accounts_list"; + case MENU_ENUM_LABEL_DEFERRED_INPUT_HOTKEY_BINDS_LIST: + return "deferred_input_hotkey_binds"; + case MENU_ENUM_LABEL_INPUT_HOTKEY_BINDS: + return "input_hotkey_binds"; + case MENU_ENUM_LABEL_INPUT_HOTKEY_BINDS_BEGIN: + return "input_hotkey_binds_begin"; + case MENU_ENUM_LABEL_INPUT_SETTINGS_BEGIN: + return "input_settings_begin"; + case MENU_ENUM_LABEL_PLAYLIST_SETTINGS_BEGIN: + return "playlist_settings_begin"; + case MENU_ENUM_LABEL_RECORDING_SETTINGS: + return "recording_settings"; + case MENU_ENUM_LABEL_PLAYLIST_SETTINGS: + return "playlist_settings"; + case MENU_ENUM_LABEL_DEFERRED_RECORDING_SETTINGS_LIST: + return "deferred_recording_settings"; + case MENU_ENUM_LABEL_DEFERRED_PLAYLIST_SETTINGS_LIST: + return "deferred_playlist_settings"; + case MENU_ENUM_LABEL_INPUT_SETTINGS: + return "input_settings"; + case MENU_ENUM_LABEL_DRIVER_SETTINGS: + return "driver_settings"; + case MENU_ENUM_LABEL_VIDEO_SETTINGS: + return "video_settings"; + case MENU_ENUM_LABEL_CONFIGURATION_SETTINGS: + return "configuration_settings"; + case MENU_ENUM_LABEL_SAVING_SETTINGS: + return "saving_settings"; + case MENU_ENUM_LABEL_LOGGING_SETTINGS: + return "logging_settings"; + case MENU_ENUM_LABEL_FRAME_THROTTLE_SETTINGS: + return "frame_throttle_settings"; + case MENU_ENUM_LABEL_REWIND_SETTINGS: + return "rewind_settings"; + case MENU_ENUM_LABEL_ONSCREEN_DISPLAY_SETTINGS: + return "onscreen_display_settings"; + case MENU_ENUM_LABEL_ONSCREEN_OVERLAY_SETTINGS: + return "onscreen_overlay_settings"; + case MENU_ENUM_LABEL_AUDIO_SETTINGS: + return "audio_settings"; + case MENU_ENUM_LABEL_MENU_SETTINGS: + return "menu_settings"; + case MENU_ENUM_LABEL_USER_INTERFACE_SETTINGS: + return "user_interface_settings"; + case MENU_ENUM_LABEL_MENU_FILE_BROWSER_SETTINGS: + return "menu_file_browser_settings"; + case MENU_ENUM_LABEL_RETRO_ACHIEVEMENTS_SETTINGS: + return "retro_achievements_settings"; + case MENU_ENUM_LABEL_UPDATER_SETTINGS: + return "updater_settings"; + case MENU_ENUM_LABEL_NETWORK_SETTINGS: + return "network_settings"; + case MENU_ENUM_LABEL_WIFI_SETTINGS: + return "wifi_settings"; + case MENU_ENUM_LABEL_USER_SETTINGS: + return "user_settings"; + case MENU_ENUM_LABEL_LAKKA_SERVICES: + return "lakka_services"; + case MENU_ENUM_LABEL_DIRECTORY_SETTINGS: + return "directory_settings"; + case MENU_ENUM_LABEL_PRIVACY_SETTINGS: + return "privacy_settings"; + case MENU_ENUM_LABEL_HELP_SCANNING_CONTENT: + return "help_scanning_content"; + case MENU_ENUM_LABEL_CHEEVOS_DESCRIPTION: + return "cheevos_description"; + case MENU_ENUM_LABEL_HELP_AUDIO_VIDEO_TROUBLESHOOTING: + return "help_audio_video_troubleshooting"; + case MENU_ENUM_LABEL_HELP_CHANGE_VIRTUAL_GAMEPAD: + return "help_change_virtual_gamepad"; + case MENU_ENUM_LABEL_HELP_WHAT_IS_A_CORE: + return "help_what_is_a_core"; + case MENU_ENUM_LABEL_HELP_LOADING_CONTENT: + return "help_loading_content"; + case MENU_ENUM_LABEL_HELP_LIST: + return "help_list"; + case MENU_ENUM_LABEL_HELP_CONTROLS: + return "help_controls"; + case MENU_ENUM_LABEL_DEFERRED_ARCHIVE_OPEN_DETECT_CORE: + return "deferred_archive_open_detect_core"; + case MENU_ENUM_LABEL_DEFERRED_ARCHIVE_OPEN: + return "deferred_archive_open"; + case MENU_ENUM_LABEL_LOAD_ARCHIVE_DETECT_CORE: + return "load_archive_detect_core"; + case MENU_ENUM_LABEL_LOAD_ARCHIVE: + return "load_archive"; + case MENU_ENUM_LABEL_DEFERRED_ARCHIVE_ACTION_DETECT_CORE: + return "deferred_archive_action_detect_core"; + case MENU_ENUM_LABEL_DEFERRED_ARCHIVE_ACTION: + return "deferred_archive_action"; + case MENU_ENUM_LABEL_OPEN_ARCHIVE_DETECT_CORE: + return "open_archive_detect_core"; + case MENU_ENUM_LABEL_OPEN_ARCHIVE: + return "open_archive"; + case MENU_ENUM_LABEL_INPUT_BACK_AS_MENU_ENUM_TOGGLE_ENABLE: + return "back_as_menu_toggle_enable"; + case MENU_ENUM_LABEL_INPUT_MENU_ENUM_TOGGLE_GAMEPAD_COMBO: + return "input_menu_toggle_gamepad_combo"; + case MENU_ENUM_LABEL_INPUT_ALL_USERS_CONTROL_MENU: + return "all_users_control_menu"; + case MENU_ENUM_LABEL_INPUT_OVERLAY_HIDE_IN_MENU: + return "overlay_hide_in_menu"; + case MENU_ENUM_LABEL_NO_PLAYLIST_ENTRIES_AVAILABLE: + return "no_playlist_entries_available"; + case MENU_ENUM_LABEL_DOWNLOADED_FILE_DETECT_CORE_LIST: + return "downloaded_file_detect_core_list"; + case MENU_ENUM_LABEL_UPDATE_CORE_INFO_FILES: + return "update_core_info_files"; + case MENU_ENUM_LABEL_DEFERRED_CORE_CONTENT_LIST: + return "deferred_core_content_list"; + case MENU_ENUM_LABEL_DEFERRED_CORE_CONTENT_DIRS_LIST: + return "deferred_core_content_dirs_list"; + case MENU_ENUM_LABEL_DEFERRED_CORE_CONTENT_DIRS_SUBDIR_LIST: + return "deferred_core_content_dirs_subdir_list"; + case MENU_ENUM_LABEL_DEFERRED_LAKKA_LIST: + return "deferred_lakka_list"; + case MENU_ENUM_LABEL_DOWNLOAD_CORE_CONTENT: + return "download_core_content"; + case MENU_ENUM_LABEL_DOWNLOAD_CORE_CONTENT_DIRS: + return "download_core_content_dirs"; + case MENU_ENUM_LABEL_CB_DOWNLOAD_URL: + return "cb_download_url"; + case MENU_ENUM_LABEL_SCAN_THIS_DIRECTORY: + return "scan_this_directory"; + case MENU_ENUM_LABEL_SCAN_FILE: + return "scan_file"; + case MENU_ENUM_LABEL_SCAN_DIRECTORY: + return "scan_directory"; + case MENU_ENUM_LABEL_ADD_CONTENT_LIST: + return "add_content"; + case MENU_ENUM_LABEL_CONNECT_WIFI: + return "connect_wifi"; + case MENU_ENUM_LABEL_OVERLAY_AUTOLOAD_PREFERRED: + return "overlay_autoload_preferred"; + case MENU_ENUM_LABEL_INFORMATION: + return "information"; + case MENU_ENUM_LABEL_INFORMATION_LIST: + return "information_list"; + case MENU_ENUM_LABEL_USE_BUILTIN_PLAYER: + return "use_builtin_player"; + case MENU_ENUM_LABEL_CONTENT_SETTINGS: + return "quick_menu"; + case MENU_ENUM_LABEL_LOAD_CONTENT_LIST: + return "load_content"; + case MENU_ENUM_LABEL_NO_SETTINGS_FOUND: + return "menu_label_no_settings_found"; + case MENU_ENUM_LABEL_SYSTEM_BGM_ENABLE: + return "system_bgm_enable"; + case MENU_ENUM_LABEL_AUDIO_BLOCK_FRAMES: + return "audio_block_frames"; + case MENU_ENUM_LABEL_INPUT_BIND_MODE: + return "input_bind_mode"; + case MENU_ENUM_LABEL_INPUT_DESCRIPTOR_LABEL_SHOW: + return "input_descriptor_label_show"; + case MENU_ENUM_LABEL_INPUT_DESCRIPTOR_HIDE_UNBOUND: + return "input_descriptor_hide_unbound"; + case MENU_ENUM_LABEL_VIDEO_FONT_ENABLE: + return "video_font_enable"; + case MENU_ENUM_LABEL_VIDEO_FONT_PATH: + return "video_font_path"; + case MENU_ENUM_LABEL_VIDEO_FONT_SIZE: + return "video_font_size"; + case MENU_ENUM_LABEL_VIDEO_MESSAGE_POS_X: + return "video_message_pos_x"; + case MENU_ENUM_LABEL_VIDEO_MESSAGE_POS_Y: + return "video_message_pos_y"; + case MENU_ENUM_LABEL_VIDEO_SOFT_FILTER: + return "soft_filter"; + case MENU_ENUM_LABEL_VIDEO_FILTER_FLICKER: + return "video_filter_flicker"; + case MENU_ENUM_LABEL_INPUT_REMAPPING_DIRECTORY: + return "input_remapping_directory"; + case MENU_ENUM_LABEL_JOYPAD_AUTOCONFIG_DIR: + return "joypad_autoconfig_dir"; + case MENU_ENUM_LABEL_RECORDING_CONFIG_DIRECTORY: + return "recording_config_directory"; + case MENU_ENUM_LABEL_RECORDING_OUTPUT_DIRECTORY: + return "recording_output_directory"; + case MENU_ENUM_LABEL_SCREENSHOT_DIRECTORY: + return "screenshot_directory"; + case MENU_ENUM_LABEL_PLAYLIST_DIRECTORY: + return "playlist_directory"; + case MENU_ENUM_LABEL_SAVEFILE_DIRECTORY: + return "savefile_directory"; + case MENU_ENUM_LABEL_SAVESTATE_DIRECTORY: + return "savestate_directory"; + case MENU_ENUM_LABEL_STDIN_CMD_ENABLE: + return "stdin_commands"; + case MENU_ENUM_LABEL_NETWORK_REMOTE_ENABLE: + return "network_remote_enable"; + case MENU_ENUM_LABEL_NETWORK_REMOTE_USER_1_ENABLE: + return "network_remote_user_1_enable"; + case MENU_ENUM_LABEL_NETWORK_REMOTE_USER_LAST_ENABLE: + return "network_remote_user_last_enable"; + case MENU_ENUM_LABEL_NETWORK_REMOTE_PORT: + return "network_remote_base_port"; + case MENU_ENUM_LABEL_VIDEO_DRIVER: + return "video_driver"; + case MENU_ENUM_LABEL_RECORD_ENABLE: + return "record_enable"; + case MENU_ENUM_LABEL_VIDEO_GPU_RECORD: + return "video_gpu_record"; + case MENU_ENUM_LABEL_RECORD_PATH: + return "record_path"; + case MENU_ENUM_LABEL_RECORD_USE_OUTPUT_DIRECTORY: + return "record_use_output_directory"; + case MENU_ENUM_LABEL_RECORD_CONFIG: + return "record_config"; + case MENU_ENUM_LABEL_VIDEO_POST_FILTER_RECORD: + return "video_post_filter_record"; + case MENU_ENUM_LABEL_CORE_ASSETS_DIRECTORY: + return "core_assets_directory"; + case MENU_ENUM_LABEL_ASSETS_DIRECTORY: + return "assets_directory"; + case MENU_ENUM_LABEL_DYNAMIC_WALLPAPERS_DIRECTORY: + return "dynamic_wallpapers_directory"; + case MENU_ENUM_LABEL_THUMBNAILS_DIRECTORY: + return "thumbnails_directory"; + case MENU_ENUM_LABEL_RGUI_BROWSER_DIRECTORY: + return "rgui_browser_directory"; + case MENU_ENUM_LABEL_RGUI_CONFIG_DIRECTORY: + return "rgui_config_directory"; + case MENU_ENUM_LABEL_LIBRETRO_INFO_PATH: + return "libretro_info_path"; + case MENU_ENUM_LABEL_LIBRETRO_DIR_PATH: + return "libretro_dir_path"; + case MENU_ENUM_LABEL_CURSOR_DIRECTORY: + return "cursor_directory"; + case MENU_ENUM_LABEL_CONTENT_DATABASE_DIRECTORY: + return "content_database_path"; + case MENU_ENUM_LABEL_SYSTEM_DIRECTORY: + return "system_directory"; + case MENU_ENUM_LABEL_CACHE_DIRECTORY: + return "cache_directory"; + case MENU_ENUM_LABEL_CHEAT_DATABASE_PATH: + return "cheat_database_path"; + case MENU_ENUM_LABEL_AUDIO_FILTER_DIR: + return "audio_filter_dir"; + case MENU_ENUM_LABEL_VIDEO_FILTER_DIR: + return "video_filter_dir"; + case MENU_ENUM_LABEL_VIDEO_SHADER_DIR: + return "video_shader_dir"; + case MENU_ENUM_LABEL_OVERLAY_DIRECTORY: + return "overlay_directory"; + case MENU_ENUM_LABEL_OSK_OVERLAY_DIRECTORY: + return "osk_overlay_directory"; + case MENU_ENUM_LABEL_NETPLAY_CLIENT_SWAP_INPUT: + return "netplay_client_swap_input"; + case MENU_ENUM_LABEL_NETPLAY_SPECTATOR_MODE_ENABLE: + return "netplay_spectator_mode_enable"; + case MENU_ENUM_LABEL_NETPLAY_IP_ADDRESS: + return "netplay_ip_address"; + case MENU_ENUM_LABEL_NETPLAY_TCP_UDP_PORT: + return "netplay_tcp_udp_port"; + case MENU_ENUM_LABEL_NETPLAY_ENABLE: + return "netplay_enable"; + case MENU_ENUM_LABEL_SSH_ENABLE: + return "ssh_enable"; + case MENU_ENUM_LABEL_SAMBA_ENABLE: + return "samba_enable"; + case MENU_ENUM_LABEL_BLUETOOTH_ENABLE: + return "bluetooth_enable"; + case MENU_ENUM_LABEL_NETPLAY_DELAY_FRAMES: + return "netplay_delay_frames"; + case MENU_ENUM_LABEL_NETPLAY_CHECK_FRAMES: + return "netplay_check_frames"; + case MENU_ENUM_LABEL_NETPLAY_MODE: + return "netplay_mode"; + case MENU_ENUM_LABEL_RGUI_SHOW_START_SCREEN: + return "rgui_show_start_screen"; + case MENU_ENUM_LABEL_TITLE_COLOR: + return "menu_title_color"; + case MENU_ENUM_LABEL_ENTRY_HOVER_COLOR: + return "menu_entry_hover_color"; + case MENU_ENUM_LABEL_TIMEDATE_ENABLE: + return "menu_timedate_enable"; + case MENU_ENUM_LABEL_THREADED_DATA_RUNLOOP_ENABLE: + return "threaded_data_runloop_enable"; + case MENU_ENUM_LABEL_ENTRY_NORMAL_COLOR: + return "menu_entry_normal_color"; + case MENU_ENUM_LABEL_SHOW_ADVANCED_SETTINGS: + return "menu_show_advanced_settings"; + case MENU_ENUM_LABEL_MOUSE_ENABLE: + return "menu_mouse_enable"; + case MENU_ENUM_LABEL_POINTER_ENABLE: + return "menu_pointer_enable"; + case MENU_ENUM_LABEL_CORE_ENABLE: + return "menu_core_enable"; + case MENU_ENUM_LABEL_NETPLAY_ENABLE_HOST: + return "menu_netplay_enable_host"; + case MENU_ENUM_LABEL_NETPLAY_ENABLE_CLIENT: + return "menu_netplay_enable_client"; + case MENU_ENUM_LABEL_NETPLAY_DISCONNECT: + return "menu_netplay_disconnect"; + case MENU_ENUM_LABEL_NETPLAY_SETTINGS: + return "menu_netplay_settings"; + case MENU_ENUM_LABEL_DPI_OVERRIDE_ENABLE: + return "dpi_override_enable"; + case MENU_ENUM_LABEL_DPI_OVERRIDE_VALUE: + return "dpi_override_value"; + case MENU_ENUM_LABEL_XMB_FONT: + return "xmb_font"; + case MENU_ENUM_LABEL_XMB_THEME: + return "xmb_theme"; + case MENU_ENUM_LABEL_XMB_MENU_COLOR_THEME: + return "xmb_menu_color_theme"; + case MENU_ENUM_LABEL_MATERIALUI_MENU_COLOR_THEME: + return "materialui_menu_color_theme"; + case MENU_ENUM_LABEL_MATERIALUI_MENU_HEADER_OPACITY: + return "materialui_menu_header_opacity"; + case MENU_ENUM_LABEL_MATERIALUI_MENU_FOOTER_OPACITY: + return "materialui_menu_footer_opacity"; + case MENU_ENUM_LABEL_XMB_SHADOWS_ENABLE: + return "xmb_shadows_enable"; + case MENU_ENUM_LABEL_XMB_SHOW_SETTINGS: + return "xmb_show_settings"; + case MENU_ENUM_LABEL_XMB_SHOW_IMAGES: + return "xmb_show_images"; + case MENU_ENUM_LABEL_XMB_SHOW_MUSIC: + return "xmb_show_music"; + case MENU_ENUM_LABEL_XMB_SHOW_VIDEO: + return "xmb_show_video"; + case MENU_ENUM_LABEL_XMB_SHOW_HISTORY: + return "xmb_show_history"; + case MENU_ENUM_LABEL_XMB_RIBBON_ENABLE: + return "xmb_ribbon_enable"; + case MENU_ENUM_LABEL_XMB_SCALE_FACTOR: + return "xmb_scale_factor"; + case MENU_ENUM_LABEL_XMB_ALPHA_FACTOR: + return "xmb_alpha_factor"; + case MENU_ENUM_LABEL_SUSPEND_SCREENSAVER_ENABLE: + return "suspend_screensaver_enable"; + case MENU_ENUM_LABEL_VIDEO_DISABLE_COMPOSITION: + return "video_disable_composition"; + case MENU_ENUM_LABEL_PAUSE_NONACTIVE: + return "pause_nonactive"; + case MENU_ENUM_LABEL_UI_COMPANION_START_ON_BOOT: + return "ui_companion_start_on_boot"; + case MENU_ENUM_LABEL_UI_COMPANION_ENABLE: + return "ui_companion_enable"; + case MENU_ENUM_LABEL_UI_MENUBAR_ENABLE: + return "ui_menubar_enable"; + case MENU_ENUM_LABEL_ARCHIVE_MODE: + return "archive_mode"; + case MENU_ENUM_LABEL_NETWORK_CMD_ENABLE: + return "network_cmd_enable"; + case MENU_ENUM_LABEL_NETWORK_CMD_PORT: + return "network_cmd_port"; + case MENU_ENUM_LABEL_HISTORY_LIST_ENABLE: + return "history_list_enable"; + case MENU_ENUM_LABEL_CONTENT_HISTORY_SIZE: + return "content_history_size"; + case MENU_ENUM_LABEL_VIDEO_REFRESH_RATE_AUTO: + return "video_refresh_rate_auto"; + case MENU_ENUM_LABEL_DUMMY_ON_CORE_SHUTDOWN: + return "dummy_on_core_shutdown"; + case MENU_ENUM_LABEL_CORE_SET_SUPPORTS_NO_CONTENT_ENABLE: + return "core_set_supports_no_content_enable"; + case MENU_ENUM_LABEL_FRAME_THROTTLE_ENABLE: + return "fastforward_ratio_throttle_enable"; + case MENU_ENUM_LABEL_FASTFORWARD_RATIO: + return "fastforward_ratio"; + case MENU_ENUM_LABEL_AUTO_REMAPS_ENABLE: + return "auto_remaps_enable"; + case MENU_ENUM_LABEL_AUTO_SHADERS_ENABLE: + return "auto_shaders_enable"; + case MENU_ENUM_LABEL_SLOWMOTION_RATIO: + return "slowmotion_ratio"; + case MENU_ENUM_LABEL_CORE_SPECIFIC_CONFIG: + return "core_specific_config"; + case MENU_ENUM_LABEL_GAME_SPECIFIC_OPTIONS: + return "game_specific_options"; + case MENU_ENUM_LABEL_GAME_SPECIFIC_OPTIONS_CREATE: + return "game_specific_options_create"; + case MENU_ENUM_LABEL_GAME_SPECIFIC_OPTIONS_IN_USE: + return "game_specific_options_in_use"; + case MENU_ENUM_LABEL_AUTO_OVERRIDES_ENABLE: + return "auto_overrides_enable"; + case MENU_ENUM_LABEL_CONFIG_SAVE_ON_EXIT: + return "config_save_on_exit"; + case MENU_ENUM_LABEL_CONFIRM_ON_EXIT: + return "confirm_on_exit"; + case MENU_ENUM_LABEL_SHOW_HIDDEN_FILES: + return "show_hidden_files"; + case MENU_ENUM_LABEL_VIDEO_SMOOTH: + return "video_smooth"; + case MENU_ENUM_LABEL_VIDEO_GAMMA: + return "video_gamma"; + case MENU_ENUM_LABEL_VIDEO_ALLOW_ROTATE: + return "video_allow_rotate"; + case MENU_ENUM_LABEL_VIDEO_HARD_SYNC: + return "video_hard_sync"; + case MENU_ENUM_LABEL_VIDEO_SWAP_INTERVAL: + return "video_swap_interval"; + case MENU_ENUM_LABEL_VIDEO_VSYNC: + return "video_vsync"; + case MENU_ENUM_LABEL_VIDEO_THREADED: + return "video_threaded"; + case MENU_ENUM_LABEL_VIDEO_ROTATION: + return "video_rotation"; + case MENU_ENUM_LABEL_VIDEO_GPU_SCREENSHOT: + return "video_gpu_screenshot"; + case MENU_ENUM_LABEL_VIDEO_CROP_OVERSCAN: + return "video_crop_overscan"; + case MENU_ENUM_LABEL_VIDEO_ASPECT_RATIO_INDEX: + return "aspect_ratio_index"; + case MENU_ENUM_LABEL_VIDEO_ASPECT_RATIO_AUTO: + return "video_aspect_ratio_auto"; + case MENU_ENUM_LABEL_VIDEO_FORCE_ASPECT: + return "video_force_aspect"; + case MENU_ENUM_LABEL_VIDEO_REFRESH_RATE: + return "video_refresh_rate"; + case MENU_ENUM_LABEL_VIDEO_FORCE_SRGB_DISABLE: + return "video_force_srgb_disable"; + case MENU_ENUM_LABEL_VIDEO_WINDOWED_FULLSCREEN: + return "video_windowed_fullscreen"; + case MENU_ENUM_LABEL_PAL60_ENABLE: + return "pal60_enable"; + case MENU_ENUM_LABEL_VIDEO_VFILTER: + return "video_vfilter"; + case MENU_ENUM_LABEL_VIDEO_VI_WIDTH: + return "video_vi_width"; + case MENU_ENUM_LABEL_VIDEO_BLACK_FRAME_INSERTION: + return "video_black_frame_insertion"; + case MENU_ENUM_LABEL_VIDEO_HARD_SYNC_FRAMES: + return "video_hard_sync_frames"; + case MENU_ENUM_LABEL_SORT_SAVEFILES_ENABLE: + return "sort_savefiles_enable"; + case MENU_ENUM_LABEL_SORT_SAVESTATES_ENABLE: + return "sort_savestates_enable"; + case MENU_ENUM_LABEL_VIDEO_FULLSCREEN: + return "video_fullscreen"; + case MENU_ENUM_LABEL_PERFCNT_ENABLE: + return "perfcnt_enable"; + case MENU_ENUM_LABEL_VIDEO_SCALE: + return "video_scale"; + case MENU_ENUM_LABEL_VIDEO_SCALE_INTEGER: + return "video_scale_integer"; + case MENU_ENUM_LABEL_LIBRETRO_LOG_LEVEL: + return "libretro_log_level"; + case MENU_ENUM_LABEL_LOG_VERBOSITY: + return "log_verbosity"; + case MENU_ENUM_LABEL_SAVESTATE_AUTO_SAVE: + return "savestate_auto_save"; + case MENU_ENUM_LABEL_SAVESTATE_AUTO_LOAD: + return "savestate_auto_load"; + case MENU_ENUM_LABEL_SAVESTATE_AUTO_INDEX: + return "savestate_auto_index"; + case MENU_ENUM_LABEL_AUTOSAVE_INTERVAL: + return "autosave_interval"; + case MENU_ENUM_LABEL_BLOCK_SRAM_OVERWRITE: + return "block_sram_overwrite"; + case MENU_ENUM_LABEL_VIDEO_SHARED_CONTEXT: + return "video_shared_context"; + case MENU_ENUM_LABEL_RESTART_RETROARCH: + return "restart_retroarch"; + case MENU_ENUM_LABEL_NETPLAY_NICKNAME: + return "netplay_nickname"; + case MENU_ENUM_LABEL_USER_LANGUAGE: + return "user_language"; + case MENU_ENUM_LABEL_CAMERA_ALLOW: + return "camera_allow"; + case MENU_ENUM_LABEL_LOCATION_ALLOW: + return "location_allow"; + case MENU_ENUM_LABEL_PAUSE_LIBRETRO: + return "menu_pause_libretro"; + case MENU_ENUM_LABEL_INPUT_OSK_OVERLAY_ENABLE: + return "input_osk_overlay_enable"; + case MENU_ENUM_LABEL_INPUT_OVERLAY_ENABLE: + return "input_overlay_enable"; + case MENU_ENUM_LABEL_VIDEO_MONITOR_INDEX: + return "video_monitor_index"; + case MENU_ENUM_LABEL_VIDEO_FRAME_DELAY: + return "video_frame_delay"; + case MENU_ENUM_LABEL_INPUT_DUTY_CYCLE: + return "input_duty_cycle"; + case MENU_ENUM_LABEL_INPUT_TURBO_PERIOD: + return "input_turbo_period"; + case MENU_ENUM_LABEL_INPUT_BIND_TIMEOUT: + return "input_bind_timeout"; + case MENU_ENUM_LABEL_INPUT_AXIS_THRESHOLD: + return "input_axis_threshold"; + case MENU_ENUM_LABEL_INPUT_REMAP_BINDS_ENABLE: + return "input_remap_binds_enable"; + case MENU_ENUM_LABEL_INPUT_MAX_USERS: + return "input_max_users"; + case MENU_ENUM_LABEL_INPUT_AUTODETECT_ENABLE: + return "input_autodetect_enable"; + case MENU_ENUM_LABEL_AUDIO_OUTPUT_RATE: + return "audio_output_rate"; + case MENU_ENUM_LABEL_AUDIO_MAX_TIMING_SKEW: + return "audio_max_timing_skew"; + case MENU_ENUM_LABEL_CHEAT_APPLY_CHANGES: + return "cheat_apply_changes"; + case MENU_ENUM_LABEL_REMAP_FILE_SAVE_CORE: + return "remap_file_save_core"; + case MENU_ENUM_LABEL_REMAP_FILE_SAVE_GAME: + return "remap_file_save_game"; + case MENU_ENUM_LABEL_CHEAT_NUM_PASSES: + return "cheat_num_passes"; + case MENU_ENUM_LABEL_SHADER_APPLY_CHANGES: + return "shader_apply_changes"; + case MENU_ENUM_LABEL_COLLECTION: + return "collection"; + case MENU_ENUM_LABEL_REWIND_ENABLE: + return "rewind_enable"; + case MENU_ENUM_LABEL_CONTENT_COLLECTION_LIST: + return "select_from_collection"; + case MENU_ENUM_LABEL_DETECT_CORE_LIST: + return "detect_core_list"; + case MENU_ENUM_LABEL_LOAD_CONTENT_HISTORY: + return "load_recent"; + case MENU_ENUM_LABEL_AUDIO_ENABLE: + return "audio_enable"; + case MENU_ENUM_LABEL_FPS_SHOW: + return "fps_show"; + case MENU_ENUM_LABEL_AUDIO_MUTE: + return "audio_mute_enable"; + case MENU_ENUM_LABEL_VIDEO_SHADER_PASS: + return "video_shader_pass"; + case MENU_ENUM_LABEL_AUDIO_VOLUME: + return "audio_volume"; + case MENU_ENUM_LABEL_AUDIO_SYNC: + return "audio_sync"; + case MENU_ENUM_LABEL_AUDIO_RATE_CONTROL_DELTA: + return "audio_rate_control_delta"; + case MENU_ENUM_LABEL_VIDEO_SHADER_FILTER_PASS: + return "video_shader_filter_pass"; + case MENU_ENUM_LABEL_VIDEO_SHADER_SCALE_PASS: + return "video_shader_scale_pass"; + case MENU_ENUM_LABEL_VIDEO_SHADER_NUM_PASSES: + return "video_shader_num_passes"; + case MENU_ENUM_LABEL_SHADER_PARAMETERS_ENTRY: + return "shader_parameters_entry"; + case MENU_ENUM_LABEL_RDB_ENTRY: + return "rdb_entry"; + case MENU_ENUM_LABEL_RDB_ENTRY_DESCRIPTION: + return "rdb_entry_description"; + case MENU_ENUM_LABEL_RDB_ENTRY_GENRE: + return "rdb_entry_genre"; + case MENU_ENUM_LABEL_RDB_ENTRY_ORIGIN: + return "rdb_entry_origin"; + case MENU_ENUM_LABEL_RDB_ENTRY_PUBLISHER: + return "rdb_entry_publisher"; + case MENU_ENUM_LABEL_RDB_ENTRY_DEVELOPER: + return "rdb_entry_developer"; + case MENU_ENUM_LABEL_RDB_ENTRY_FRANCHISE: + return "rdb_entry_franchise"; + case MENU_ENUM_LABEL_RDB_ENTRY_MAX_USERS: + return "rdb_entry_max_users"; + case MENU_ENUM_LABEL_RDB_ENTRY_NAME: + return "rdb_entry_name"; + case MENU_ENUM_LABEL_RDB_ENTRY_EDGE_MAGAZINE_RATING: + return "rdb_entry_edge_magazine_rating"; + case MENU_ENUM_LABEL_RDB_ENTRY_EDGE_MAGAZINE_REVIEW: + return "rdb_entry_edge_magazine_review"; + case MENU_ENUM_LABEL_RDB_ENTRY_FAMITSU_MAGAZINE_RATING: + return "rdb_entry_famitsu_magazine_rating"; + case MENU_ENUM_LABEL_RDB_ENTRY_TGDB_RATING: + return "rdb_entry_tgdb_rating"; + case MENU_ENUM_LABEL_RDB_ENTRY_EDGE_MAGAZINE_ISSUE: + return "rdb_entry_edge_magazine_issue"; + case MENU_ENUM_LABEL_RDB_ENTRY_RELEASE_MONTH: + return "rdb_entry_releasemonth"; + case MENU_ENUM_LABEL_RDB_ENTRY_RELEASE_YEAR: + return "rdb_entry_releaseyear"; + case MENU_ENUM_LABEL_RDB_ENTRY_ENHANCEMENT_HW: + return "rdb_entry_enhancement_hw"; + case MENU_ENUM_LABEL_RDB_ENTRY_SHA1: + return "rdb_entry_sha1"; + case MENU_ENUM_LABEL_RDB_ENTRY_CRC32: + return "rdb_entry_crc32"; + case MENU_ENUM_LABEL_RDB_ENTRY_MD5: + return "rdb_entry_md5"; + case MENU_ENUM_LABEL_RDB_ENTRY_BBFC_RATING: + return "rdb_entry_bbfc_rating"; + case MENU_ENUM_LABEL_RDB_ENTRY_ESRB_RATING: + return "rdb_entry_esrb_rating"; + case MENU_ENUM_LABEL_RDB_ENTRY_ELSPA_RATING: + return "rdb_entry_elspa_rating"; + case MENU_ENUM_LABEL_RDB_ENTRY_PEGI_RATING: + return "rdb_entry_pegi_rating"; + case MENU_ENUM_LABEL_RDB_ENTRY_CERO_RATING: + return "rdb_entry_cero_rating"; + case MENU_ENUM_LABEL_RDB_ENTRY_ANALOG: + return "rdb_entry_analog"; + case MENU_ENUM_LABEL_RDB_ENTRY_SERIAL: + return "rdb_entry_serial"; + case MENU_ENUM_LABEL_CONFIGURATIONS: + return "configurations"; + case MENU_ENUM_LABEL_REWIND_GRANULARITY: + return "rewind_granularity"; + case MENU_ENUM_LABEL_REMAP_FILE_LOAD: + return "remap_file_load"; + case MENU_ENUM_LABEL_CUSTOM_RATIO: + return "custom_ratio"; + case MENU_ENUM_LABEL_USE_THIS_DIRECTORY: + return "use_this_directory"; + case MENU_ENUM_LABEL_RDB_ENTRY_START_CONTENT: + return "rdb_entry_start_content"; + case MENU_ENUM_LABEL_CUSTOM_BIND: + return "custom_bind"; + case MENU_ENUM_LABEL_CUSTOM_BIND_ALL: + return "custom_bind_all"; + case MENU_ENUM_LABEL_DISK_OPTIONS: + return "core_disk_options"; + case MENU_ENUM_LABEL_CORE_CHEAT_OPTIONS: + return "core_cheat_options"; + case MENU_ENUM_LABEL_CORE_OPTIONS: + return "core_options"; + case MENU_ENUM_LABEL_DATABASE_MANAGER_LIST: + return "database_manager_list"; + case MENU_ENUM_LABEL_DEFERRED_DATABASE_MANAGER_LIST: + return "deferred_database_manager_list"; + case MENU_ENUM_LABEL_CURSOR_MANAGER_LIST: + return "cursor_manager_list"; + case MENU_ENUM_LABEL_DEFERRED_CURSOR_MANAGER_LIST: + return "deferred_cursor_manager_list"; + case MENU_ENUM_LABEL_CHEAT_FILE_LOAD: + return "cheat_file_load"; + case MENU_ENUM_LABEL_CHEAT_FILE_SAVE_AS: + return "cheat_file_save_as"; + case MENU_ENUM_LABEL_DEFERRED_RDB_ENTRY_DETAIL: + return "deferred_rdb_entry_detail"; + case MENU_ENUM_LABEL_FRONTEND_COUNTERS: + return "frontend_counters"; + case MENU_ENUM_LABEL_CORE_COUNTERS: + return "core_counters"; + case MENU_ENUM_LABEL_DISK_CYCLE_TRAY_STATUS: + return "disk_cycle_tray_status"; + case MENU_ENUM_LABEL_DISK_IMAGE_APPEND: + return "disk_image_append"; + case MENU_ENUM_LABEL_DEFERRED_CORE_LIST: + return "deferred_core_list"; + case MENU_ENUM_LABEL_DEFERRED_CORE_LIST_SET: + return "deferred_core_list_set"; + case MENU_ENUM_LABEL_INFO_SCREEN: + return "info_screen"; + case MENU_ENUM_LABEL_SETTINGS: + return "settings"; + case MENU_ENUM_LABEL_QUIT_RETROARCH: + return "quit_retroarch"; + case MENU_ENUM_LABEL_SHUTDOWN: + return "shutdown"; + case MENU_ENUM_LABEL_REBOOT: + return "reboot"; + case MENU_ENUM_LABEL_HELP: + return "help"; + case MENU_ENUM_LABEL_SAVE_NEW_CONFIG: + return "save_new_config"; + case MENU_ENUM_LABEL_RESTART_CONTENT: + return "restart_content"; + case MENU_ENUM_LABEL_TAKE_SCREENSHOT: + return "take_screenshot"; + case MENU_ENUM_LABEL_DELETE_ENTRY: + return "delete_entry"; + case MENU_ENUM_LABEL_CORE_UPDATER_LIST: + return "core_updater_list"; + case MENU_ENUM_LABEL_START_VIDEO_PROCESSOR: + return "menu_start_video_processor"; + case MENU_ENUM_LABEL_START_NET_RETROPAD: + return "menu_start_net_retropad"; + case MENU_ENUM_LABEL_THUMBNAILS_UPDATER_LIST: + return "thumbnails_updater_list"; + case MENU_ENUM_LABEL_CORE_UPDATER_BUILDBOT_URL: + return "core_updater_buildbot_url"; + case MENU_ENUM_LABEL_BUILDBOT_ASSETS_URL: + return "buildbot_assets_url"; + case MENU_ENUM_LABEL_NAVIGATION_WRAPAROUND: + return "menu_navigation_wraparound_enable"; + case MENU_ENUM_LABEL_NAVIGATION_BROWSER_FILTER_SUPPORTED_EXTENSIONS_ENABLE: + return "menu_navigation_browser_filter_supported_extensions_enable"; + case MENU_ENUM_LABEL_CORE_UPDATER_AUTO_EXTRACT_ARCHIVE: + return "core_updater_auto_extract_archive"; + case MENU_ENUM_LABEL_ACHIEVEMENT_LIST: + return "achievement_list"; + case MENU_ENUM_LABEL_SYSTEM_INFORMATION: + return "system_information"; + case MENU_ENUM_LABEL_NETWORK_INFORMATION: + return "network_information"; + case MENU_ENUM_LABEL_ONLINE_UPDATER: + return "online_updater"; + case MENU_ENUM_LABEL_NETPLAY: + return "netplay"; + case MENU_ENUM_LABEL_CORE_INFORMATION: + return "core_information"; + case MENU_ENUM_LABEL_CORE_LIST: + return "load_core"; + case MENU_ENUM_LABEL_LOAD_CONTENT: + return "load_content_default"; + case MENU_ENUM_LABEL_CLOSE_CONTENT: + return "unload_core"; + case MENU_ENUM_LABEL_MANAGEMENT: + return "database_settings"; + case MENU_ENUM_LABEL_SAVE_STATE: + return "savestate"; + case MENU_ENUM_LABEL_LOAD_STATE: + return "loadstate"; + case MENU_ENUM_LABEL_UNDO_LOAD_STATE: + return "undoloadstate"; + case MENU_ENUM_LABEL_UNDO_SAVE_STATE: + return "undosavestate"; + case MENU_ENUM_LABEL_RESUME_CONTENT: + return "resume_content"; + case MENU_ENUM_LABEL_INPUT_DRIVER: + return "input_driver"; + case MENU_ENUM_LABEL_AUDIO_DRIVER: + return "audio_driver"; + case MENU_ENUM_LABEL_JOYPAD_DRIVER: + return "input_joypad_driver"; + case MENU_ENUM_LABEL_AUDIO_RESAMPLER_DRIVER: + return "audio_resampler_driver"; + case MENU_ENUM_LABEL_RECORD_DRIVER: + return "record_driver"; + case MENU_ENUM_LABEL_MENU_DRIVER: + return "menu_driver"; + case MENU_ENUM_LABEL_CAMERA_DRIVER: + return "camera_driver"; + case MENU_ENUM_LABEL_WIFI_DRIVER: + return "wifi_driver"; + case MENU_ENUM_LABEL_LOCATION_DRIVER: + return "location_driver"; + case MENU_ENUM_LABEL_OVERLAY_SCALE: + return "input_overlay_scale"; + case MENU_ENUM_LABEL_OVERLAY_PRESET: + return "input_overlay"; + case MENU_ENUM_LABEL_KEYBOARD_OVERLAY_PRESET: + return "input_osk_overlay"; + case MENU_ENUM_LABEL_AUDIO_DEVICE: + return "audio_device"; + case MENU_ENUM_LABEL_AUDIO_LATENCY: + return "audio_latency"; + case MENU_ENUM_LABEL_OVERLAY_OPACITY: + return "input_overlay_opacity"; + case MENU_ENUM_LABEL_MENU_WALLPAPER: + return "menu_wallpaper"; + case MENU_ENUM_LABEL_DYNAMIC_WALLPAPER: + return "menu_dynamic_wallpaper_enable"; + case MENU_ENUM_LABEL_THUMBNAILS: + return "thumbnails"; + case MENU_ENUM_LABEL_CORE_INPUT_REMAPPING_OPTIONS: + return "core_input_remapping_options"; + case MENU_ENUM_LABEL_SHADER_OPTIONS: + return "shader_options"; + case MENU_ENUM_LABEL_VIDEO_SHADER_PARAMETERS: + return "video_shader_parameters"; + case MENU_ENUM_LABEL_VIDEO_SHADER_PRESET_PARAMETERS: + return "video_shader_preset_parameters"; + case MENU_ENUM_LABEL_VIDEO_SHADER_PRESET_SAVE_AS: + return "video_shader_preset_save_as"; + case MENU_ENUM_LABEL_VIDEO_SHADER_PRESET: + return "video_shader_preset"; + case MENU_ENUM_LABEL_VIDEO_FILTER: + return "video_filter"; + case MENU_ENUM_LABEL_DEFERRED_VIDEO_FILTER: + return "deferred_video_filter"; + case MENU_ENUM_LABEL_DEFERRED_CORE_UPDATER_LIST: + return "core_updater"; + case MENU_ENUM_LABEL_DEFERRED_THUMBNAILS_UPDATER_LIST: + return "deferred_thumbnails_updater_list"; + case MENU_ENUM_LABEL_AUDIO_DSP_PLUGIN: + return "audio_dsp_plugin"; + case MENU_ENUM_LABEL_UPDATE_ASSETS: + return "update_assets"; + case MENU_ENUM_LABEL_UPDATE_LAKKA: + return "update_lakka"; + case MENU_ENUM_LABEL_UPDATE_CHEATS: + return "update_cheats"; + case MENU_ENUM_LABEL_UPDATE_AUTOCONFIG_PROFILES: + return "update_autoconfig_profiles"; + case MENU_ENUM_LABEL_UPDATE_DATABASES: + return "update_databases"; + case MENU_ENUM_LABEL_UPDATE_OVERLAYS: + return "update_overlays"; + case MENU_ENUM_LABEL_UPDATE_CG_SHADERS: + return "update_cg_shaders"; + case MENU_ENUM_LABEL_UPDATE_GLSL_SHADERS: + return "update_glsl_shaders"; + case MENU_ENUM_LABEL_UPDATE_SLANG_SHADERS: + return "update_slang_shaders"; + case MENU_ENUM_LABEL_SCREEN_RESOLUTION: + return "screen_resolution"; + case MENU_ENUM_LABEL_USE_BUILTIN_IMAGE_VIEWER: + return "use_builtin_image_viewer"; + case MENU_ENUM_LABEL_INPUT_POLL_TYPE_BEHAVIOR: + return "input_poll_type_behavior"; + case MENU_ENUM_LABEL_MENU_WALLPAPER_OPACITY: + return "menu_wallpaper_opacity"; + default: + break; + } + + return "null"; +} +#endif + +const char *msg_hash_to_str_vn(enum msg_hash_enums msg) +{ +#ifdef HAVE_MENU + const char *ret = menu_hash_to_str_vn_label_enum(msg); + + if (ret && !string_is_equal(ret, "null")) + return ret; +#endif + + switch (msg) + { + case MENU_ENUM_SUBLABEL_CONFIG_SAVE_ON_EXIT: + return "Saves changes to configuration file on exit."; + case MENU_ENUM_SUBLABEL_VIDEO_HARD_SYNC_FRAMES: + return "Sets how many frames the CPU can run ahead of the GPU when using 'Hard GPU Sync'."; + case MENU_ENUM_SUBLABEL_VIDEO_REFRESH_RATE_AUTO: + return "The accurate estimated refresh rate of the monitor in Hz."; + case MENU_ENUM_SUBLABEL_VIDEO_MONITOR_INDEX: + return "Selects which display monitor to use."; + case MENU_ENUM_SUBLABEL_LOG_VERBOSITY: + return "Enable or disable logging to the terminal."; + case MENU_ENUM_SUBLABEL_SHOW_HIDDEN_FILES: + return "Show hidden files/directories inside the file browser."; + case MENU_ENUM_SUBLABEL_INPUT_MENU_ENUM_TOGGLE_GAMEPAD_COMBO: + return "Gamepad button combination to toggle menu."; + case MENU_ENUM_SUBLABEL_CPU_CORES: + return "Amount of cores that the CPU has."; + case MENU_ENUM_SUBLABEL_VIDEO_BLACK_FRAME_INSERTION: + return "Inserts a black frame inbetween frames. Useful for users of 120 Hz monitors who want to play 60 Hz material with eliminated ghosting."; + case MENU_ENUM_SUBLABEL_VIDEO_FRAME_DELAY: + return "Reduces latency at the cost of higher risk of video stuttering. Adds a delay after V-Sync (in ms)."; + case MENU_ENUM_SUBLABEL_ADD_CONTENT_LIST: + return "Download and/or scan content, and add it to your collection."; + case MENU_ENUM_SUBLABEL_NETPLAY: + return "Join or host a netplay session."; + case MENU_ENUM_SUBLABEL_FPS_SHOW: + return "Displays the current framerate per second onscreen."; + case MENU_ENUM_SUBLABEL_VIDEO_SETTINGS: + return "Adjusts settings for video output."; + case MENU_ENUM_SUBLABEL_AUDIO_SETTINGS: + return "Adjusts settings for audio output."; + case MENU_ENUM_SUBLABEL_INPUT_SETTINGS: + return "Adjusts settings for joypads, keyboard and mouse."; + case MENU_ENUM_SUBLABEL_WIFI_SETTINGS: + return "Scans for wireless networks and establishes connection."; + case MENU_ENUM_SUBLABEL_SERVICES_SETTINGS: + return "Manage operating system level services."; + case MENU_ENUM_SUBLABEL_SSH_ENABLE: + return "Enable or disable remote command line access."; + case MENU_ENUM_SUBLABEL_SAMBA_ENABLE: + return "Enable or disable network sharing of your folders."; + case MENU_ENUM_SUBLABEL_BLUETOOTH_ENABLE: + return "Enable or disable bluetooth."; + case MENU_ENUM_SUBLABEL_USER_LANGUAGE: + return "Sets the language of the interface."; + case MENU_ENUM_SUBLABEL_SUSPEND_SCREENSAVER_ENABLE: + return "Prevents your system's screensaver from becoming active."; + case MENU_ENUM_SUBLABEL_VIDEO_MAX_SWAPCHAIN_IMAGES: + return "Tells the video driver to explicitly use a specified buffering mode."; + case MENU_ENUM_SUBLABEL_ONLINE_UPDATER: + return "Download and update add-ons and components for RetroArch."; + case MENU_ENUM_SUBLABEL_INPUT_USER_BINDS: + return "Configure controls for this user."; + case MENU_ENUM_SUBLABEL_INPUT_HOTKEY_BINDS: + return "Configure hotkey settings."; + case MSG_VALUE_SHUTTING_DOWN: + return "Shutting down..."; + case MSG_VALUE_REBOOTING: + return "Rebooting..."; + case MSG_FAILED_TO_START_AUDIO_DRIVER: + return "Failed to start audio driver. Will continue without audio."; + case MSG_FOUND_LAST_STATE_SLOT: + return "Found last state slot"; + case MSG_VALUE_CONNECT_DEVICE_FROM_A_VALID_PORT: + return "Connect device from a valid port."; + case MSG_DISCONNECT_DEVICE_FROM_A_VALID_PORT: + return "Disconnect device from a valid port."; + case MSG_VALUE_DISCONNECTING_DEVICE_FROM_PORT: + return "Disconnecting device from port"; + case MSG_BRINGING_UP_COMMAND_INTERFACE_ON_PORT: + return "Bringing up command interface on port"; + case MSG_LOADING_HISTORY_FILE: + return "Loading history file"; + case MENU_ENUM_LABEL_VALUE_SHADER_PIPELINE_RIBBON_SIMPLIFIED: + return "Ribbon (simplified)"; + case MENU_ENUM_LABEL_VALUE_SHADER_PIPELINE_RIBBON: + return "Ribbon"; + case MENU_ENUM_LABEL_VALUE_MATERIALUI_MENU_FOOTER_OPACITY: + return "Footer Opacity"; + case MENU_ENUM_LABEL_VALUE_MATERIALUI_MENU_HEADER_OPACITY: + return "Header Opacity"; + case MENU_ENUM_LABEL_VALUE_MATERIALUI_MENU_COLOR_THEME_BLUE: + return "Blue"; + case MENU_ENUM_LABEL_VALUE_MATERIALUI_MENU_COLOR_THEME_BLUE_GREY: + return "Blue Grey"; + case MENU_ENUM_LABEL_VALUE_MATERIALUI_MENU_COLOR_THEME_RED: + return "Red"; + case MENU_ENUM_LABEL_VALUE_MATERIALUI_MENU_COLOR_THEME_YELLOW: + return "Yellow"; + case MENU_ENUM_LABEL_VALUE_MATERIALUI_MENU_COLOR_THEME_NVIDIA_SHIELD: + return "Shield"; + case MENU_ENUM_LABEL_VALUE_MATERIALUI_MENU_COLOR_THEME_GREEN: + return "Green"; + case MENU_ENUM_LABEL_VALUE_MATERIALUI_MENU_COLOR_THEME_DARK_BLUE: + return "Dark Blue"; + case MENU_ENUM_LABEL_VALUE_XMB_MENU_COLOR_THEME_PLAIN: + return "Plain"; + case MENU_ENUM_LABEL_VALUE_XMB_MENU_COLOR_THEME_LEGACY_RED: + return "Legacy Red"; + case MENU_ENUM_LABEL_VALUE_XMB_MENU_COLOR_THEME_DARK_PURPLE: + return "Dark Purple"; + case MENU_ENUM_LABEL_VALUE_XMB_MENU_COLOR_THEME_MIDNIGHT_BLUE: + return "Midnight Blue"; + case MENU_ENUM_LABEL_VALUE_XMB_MENU_COLOR_THEME_GOLDEN: + return "Golden"; + case MENU_ENUM_LABEL_VALUE_XMB_MENU_COLOR_THEME_ELECTRIC_BLUE: + return "Electric Blue"; + case MENU_ENUM_LABEL_VALUE_XMB_MENU_COLOR_THEME_APPLE_GREEN: + return "Apple Green"; + case MENU_ENUM_LABEL_VALUE_XMB_MENU_COLOR_THEME_UNDERSEA: + return "Undersea"; + case MENU_ENUM_LABEL_VALUE_XMB_MENU_COLOR_THEME_VOLCANIC_RED: + return "Volcanic Red"; + case MENU_ENUM_LABEL_VALUE_XMB_MENU_COLOR_THEME_DARK: + return "Dark"; + case MENU_ENUM_LABEL_VALUE_CHEEVOS_UNLOCKED_ENTRY: + return "Unlocked"; + case MENU_ENUM_LABEL_VALUE_CHEEVOS_LOCKED_ENTRY: + return "Locked"; + case MENU_ENUM_LABEL_VALUE_INPUT_POLL_TYPE_BEHAVIOR_LATE: + return "Late"; + case MENU_ENUM_LABEL_VALUE_INPUT_POLL_TYPE_BEHAVIOR_NORMAL: + return "Normal"; + case MENU_ENUM_LABEL_VALUE_INPUT_POLL_TYPE_BEHAVIOR_EARLY: + return "Early"; + case MSG_INTERNAL_MEMORY: + return "Internal Memory"; + case MSG_EXTERNAL_APPLICATION_DIR: + return "External Application Dir"; + case MSG_APPLICATION_DIR: + return "Application Dir"; + case MSG_PROGRAM: + return "RetroArch"; + case MSG_LIBRETRO_FRONTEND: + return "Frontend for libretro"; + case MSG_LOADING: + return "Loading"; + case MSG_GAME_SPECIFIC_CORE_OPTIONS_FOUND_AT: + return "Per-Game Options: game-specific core options found at"; + case MSG_RESTORING_DEFAULT_SHADER_PRESET_TO: + return "Shaders: restoring default shader preset to"; + case MSG_SORRY_UNIMPLEMENTED_CORES_DONT_DEMAND_CONTENT_NETPLAY: + return "Sorry, unimplemented: cores that don't demand content cannot participate in netplay."; + case MSG_FOUND_AUTO_SAVESTATE_IN: + return "Found auto savestate in"; + case MENU_ENUM_LABEL_VALUE_NETWORK_REMOTE_PORT: + return "Network Remote Base Port"; + case MSG_OVERRIDES_SAVED_SUCCESSFULLY: + return "Overrides saved successfully."; + case MSG_AUTOCONFIG_FILE_SAVED_SUCCESSFULLY: + return "Autoconfig file saved successfully."; + case MSG_OVERRIDES_ERROR_SAVING: + return "Error saving overrides."; + case MSG_AUTOCONFIG_FILE_ERROR_SAVING: + return "Error saving autoconf file."; + case MSG_DOWNLOAD_FAILED: + return "Download failed"; + case MSG_INPUT_CHEAT: + return "Input Cheat"; + case MSG_DECOMPRESSION_ALREADY_IN_PROGRESS: + return "Decompression already in progress."; + case MSG_DECOMPRESSION_FAILED: + return "Decompression failed."; + case MSG_CORE_OPTIONS_FILE_CREATED_SUCCESSFULLY: + return "Core options file created successfully."; + case MSG_FAILED_TO_CREATE_THE_DIRECTORY: + return "Failed to create the directory."; + case MSG_FAILED_TO_EXTRACT_CONTENT_FROM_COMPRESSED_FILE: + return "Failed to extract content from compressed file"; + case MSG_FILE_NOT_FOUND: + return "File not found"; + case MSG_ERROR_SAVING_CORE_OPTIONS_FILE: + return "Error saving core options file."; + case MSG_FAILED_TO_ALLOCATE_MEMORY_FOR_PATCHED_CONTENT: + return "Failed to allocate memory for patched content..."; + case MSG_DID_NOT_FIND_A_VALID_CONTENT_PATCH: + return "Did not find a valid content patch."; + case MSG_SEVERAL_PATCHES_ARE_EXPLICITLY_DEFINED: + return "Several patches are explicitly defined, ignoring all..."; + case MSG_REMAP_FILE_SAVED_SUCCESSFULLY: + return "Remap file saved successfully."; + case MSG_SHADER_PRESET_SAVED_SUCCESSFULLY: + return "Shader preset saved successfully."; + case MSG_ERROR_SAVING_REMAP_FILE: + return "Error saving remap file."; + case MSG_ERROR_SAVING_SHADER_PRESET: + return "Error saving shader preset."; + case MSG_INPUT_CHEAT_FILENAME: + return "Cheat Filename"; + case MSG_INPUT_PRESET_FILENAME: + return "Preset Filename"; + case MSG_DISK_EJECTED: + return "Ejected"; + case MSG_DISK_CLOSED: + return "Closed"; + case MSG_VERSION_OF_LIBRETRO_API: + return "Version of libretro API"; + case MSG_COMPILED_AGAINST_API: + return "Compiled against API"; + case MSG_FAILED_TO_LOAD: + return "Failed to load"; + case MSG_CONNECTED_TO: + return "Connected to"; + case MSG_FAILED_TO_ACCEPT_INCOMING_SPECTATOR: + return "Failed to accept incoming spectator."; + case MSG_FAILED_TO_GET_NICKNAME_FROM_CLIENT: + return "Failed to get nickname from client."; + case MSG_FAILED_TO_SEND_NICKNAME_TO_CLIENT: + return "Failed to send nickname to client."; + case MSG_USING_CORE_NAME_FOR_NEW_CONFIG: + return "Using core name for new config."; + case MSG_CANNOT_INFER_NEW_CONFIG_PATH: + return "Cannot infer new config path. Use current time."; + case MSG_NO_STATE_HAS_BEEN_LOADED_YET: + return "No state has been loaded yet."; + case MSG_NO_SAVE_STATE_HAS_BEEN_OVERWRITTEN_YET: + return "No save state has been overwritten yet."; + case MSG_RESTORED_OLD_SAVE_STATE: + return "Restored old save state."; + case MSG_SAVED_NEW_CONFIG_TO: + return "Saved new config to"; + case MSG_FAILED_SAVING_CONFIG_TO: + return "Failed saving config to"; + case MSG_FAILED_TO_RECEIVE_NICKNAME_SIZE_FROM_HOST: + return "Failed to receive nickname size from host."; + case MSG_FAILED_TO_RECEIVE_NICKNAME: + return "Failed to receive nickname."; + case MSG_FAILED_TO_RECEIVE_NICKNAME_FROM_HOST: + return "Failed to receive nickname from host."; + case MSG_FAILED_TO_SEND_NICKNAME_SIZE: + return "Failed to send nickname size."; + case MSG_FAILED_TO_SEND_SRAM_DATA_TO_CLIENT: + return "Failed to send SRAM data to client."; + case MSG_FAILED_TO_RECEIVE_HEADER_FROM_CLIENT: + return "Failed to receive header from client."; + case MSG_FAILED_TO_RECEIVE_SRAM_DATA_FROM_HOST: + return "Failed to receive SRAM data from host."; + case MSG_CONTENT_CRC32S_DIFFER: + return "Content CRC32s differ. Cannot use different games."; + case MSG_FAILED_TO_SEND_NICKNAME: + return "Failed to send nickname."; + case MSG_FAILED_TO_SEND_NICKNAME_TO_HOST: + return "Failed to send nickname to host."; + case MSG_INVALID_NICKNAME_SIZE: + return "Invalid nickname size."; + case MENU_ENUM_LABEL_VALUE_RDB_ENTRY_ANALOG: + return "Analog supported"; + case MENU_ENUM_LABEL_VALUE_RDB_ENTRY_SERIAL: + return "Serial"; + case MENU_ENUM_LABEL_VALUE_RDB_ENTRY_COOP: + return "Co-op supported"; + case MENU_ENUM_LABEL_VALUE_RDB_ENTRY_ENHANCEMENT_HW: + return "Enhancement Hardware"; + case MENU_ENUM_LABEL_VALUE_RDB_ENTRY_ELSPA_RATING: + return "ELSPA Rating"; + case MENU_ENUM_LABEL_VALUE_RDB_ENTRY_RUMBLE: + return "Rumble supported"; + case MENU_ENUM_LABEL_VALUE_RDB_ENTRY_PEGI_RATING: + return "PEGI Rating"; + case MENU_ENUM_LABEL_VALUE_RDB_ENTRY_EDGE_MAGAZINE_ISSUE: + return "Edge Magazine Issue"; + case MENU_ENUM_LABEL_VALUE_RDB_ENTRY_BBFC_RATING: + return "BBFC Rating"; + case MENU_ENUM_LABEL_VALUE_RDB_ENTRY_ESRB_RATING: + return "ESRB Rating"; + case MENU_ENUM_LABEL_VALUE_RDB_ENTRY_CERO_RATING: + return "CERO Rating"; + case MENU_ENUM_LABEL_VALUE_VIDEO_MAX_SWAPCHAIN_IMAGES: + return "Max swapchain images"; + case MSG_ERROR_LIBRETRO_CORE_REQUIRES_CONTENT: + return "Libretro core requires content, but nothing was provided."; + case MSG_CONTENT_LOADING_SKIPPED_IMPLEMENTATION_WILL_DO_IT: + return "Content loading skipped. Implementation will load it on its own."; + case MSG_ERROR_LIBRETRO_CORE_REQUIRES_SPECIAL_CONTENT: + return "Libretro core requires special content, but none were provided."; + case MSG_REVERTING_SAVEFILE_DIRECTORY_TO: + return "Reverting savefile directory to"; + case MSG_REVERTING_SAVESTATE_DIRECTORY_TO: + return "Reverting savestate directory to"; + case MSG_COULD_NOT_READ_MOVIE_HEADER: + return "Could not read movie header."; + case MSG_FAILED_TO_OPEN_LIBRETRO_CORE: + return "Failed to open libretro core"; + case MSG_COULD_NOT_FIND_ANY_NEXT_DRIVER: + return "Could not find any next driver"; + case MSG_MOVIE_FORMAT_DIFFERENT_SERIALIZER_VERSION: + return "Movie format seems to have a different serializer version. Will most likely fail."; + case MSG_CRC32_CHECKSUM_MISMATCH: + return "CRC32 checksum mismatch between content file and saved content checksum in replay file header; replay highly likely to desync on playback."; + case MSG_INFLATED_CHECKSUM_DID_NOT_MATCH_CRC32: + return "Inflated checksum did not match CRC32."; + case MSG_ERROR_PARSING_ARGUMENTS: + return "Error parsing arguments."; + case MSG_ERROR: + return "Error"; + case MSG_FOUND_DISK_LABEL: + return "Found disk label"; + case MSG_READING_FIRST_DATA_TRACK: + return "Reading first data track..."; + case MSG_FOUND_FIRST_DATA_TRACK_ON_FILE: + return "Found first data track on file"; + case MSG_COULD_NOT_FIND_VALID_DATA_TRACK: + return "Could not find valid data track"; + case MSG_COMPARING_WITH_KNOWN_MAGIC_NUMBERS: + return "Comparing with known magic numbers..."; + case MSG_COULD_NOT_FIND_COMPATIBLE_SYSTEM: + return "Could not find compatible system."; + case MSG_COULD_NOT_OPEN_DATA_TRACK: + return "could not open data track"; + case MSG_MEMORY: + return "Memory"; + case MSG_FRAMES: + return "Frames"; + case MSG_IN_BYTES: + return "in bytes"; + case MSG_IN_MEGABYTES: + return "in megabytes"; + case MSG_IN_GIGABYTES: + return "in gigabytes"; + case MSG_INTERFACE: + return "Interface"; + case MSG_FAILED_TO_PATCH: + return "Failed to patch"; + case MSG_FATAL_ERROR_RECEIVED_IN: + return "Fatal error received in"; + 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_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_COULD_NOT_READ_STATE_FROM_MOVIE: + return "Could not read state from movie."; + case MSG_MOVIE_FILE_IS_NOT_A_VALID_BSV1_FILE: + return "Movie file is not a valid BSV1 file."; + 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_UNDOING_SAVE_STATE: + return "Undoing save state"; + 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_AUTO_SAVE_STATE_TO: + return "Auto save state to"; + 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_UNDO_LOAD_STATE: + return "Failed to undo load state."; + case MSG_FAILED_TO_UNDO_SAVE_STATE: + return "Failed to undo save state."; + 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_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: + 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: + return "Slow motion."; + case MSG_SLOW_MOTION_REWIND: + return "Slow motion rewind."; + case MSG_REWINDING: + return "Rewinding."; + case MSG_REWIND_REACHED_END: + return "Reached end of rewind buffer."; + case MSG_CHEEVOS_HARDCORE_MODE_ENABLE: + return "Hardcore Mode Enabled: savestate & rewind were disabled."; + case MSG_DOWNLOADING: + return "Downloading"; + case MSG_EXTRACTING: + return "Extracting"; + case MSG_EXTRACTING_FILE: + return "Extracting file"; + case MSG_NO_CONTENT_STARTING_DUMMY_CORE: + return "No content, starting dummy core."; + case MENU_ENUM_LABEL_VALUE_RDB_ENTRY_EDGE_MAGAZINE_RATING: + return "Edge Magazine Rating"; + case MENU_ENUM_LABEL_VALUE_RDB_ENTRY_EDGE_MAGAZINE_REVIEW: + return "Edge Magazine Review"; + case MENU_ENUM_LABEL_VALUE_RDB_ENTRY_FAMITSU_MAGAZINE_RATING: + return "Famitsu Magazine Rating"; + case MENU_ENUM_LABEL_VALUE_RDB_ENTRY_TGDB_RATING: + return "TGDB Rating"; + case MENU_ENUM_LABEL_VALUE_CPU_ARCHITECTURE: + return "CPU Architecture:"; + case MENU_ENUM_LABEL_VALUE_CPU_CORES: + return "CPU Cores:"; + case MENU_ENUM_LABEL_VALUE_INTERNAL_STORAGE_STATUS: + return "Internal storage status"; + case MENU_ENUM_LABEL_VALUE_PARENT_DIRECTORY: + return "Parent directory"; + case MENU_ENUM_LABEL_VALUE_MORE: + return "..."; + case MENU_ENUM_LABEL_VALUE_RUN: + return "Run"; + case MENU_ENUM_LABEL_VALUE_VIDEO_VIEWPORT_CUSTOM_X: + return "Custom Viewport X"; + case MENU_ENUM_LABEL_VALUE_VIDEO_VIEWPORT_CUSTOM_Y: + return "Custom Viewport Y"; + case MENU_ENUM_LABEL_VALUE_VIDEO_VIEWPORT_CUSTOM_WIDTH: + return "Custom Viewport Width"; + case MENU_ENUM_LABEL_VALUE_VIDEO_VIEWPORT_CUSTOM_HEIGHT: + return "Custom Viewport Height"; + case MENU_ENUM_LABEL_VALUE_NO_ENTRIES_TO_DISPLAY: + return "No entries to display."; + case MENU_ENUM_LABEL_VALUE_NO_ACHIEVEMENTS_TO_DISPLAY: + return "No achievements to display."; + case MENU_ENUM_LABEL_VALUE_CHEEVOS_UNLOCKED_ACHIEVEMENTS: + return "Unlocked Achievements:"; + case MENU_ENUM_LABEL_VALUE_CHEEVOS_LOCKED_ACHIEVEMENTS: + return "Locked Achievements:"; + case MENU_ENUM_LABEL_VALUE_START_VIDEO_PROCESSOR: + return "Start Video Processor"; + case MENU_ENUM_LABEL_VALUE_START_NET_RETROPAD: + return "Start Remote RetroPad"; + case MENU_ENUM_LABEL_VALUE_THUMBNAILS_UPDATER_LIST: + return "Thumbnails Updater"; + case MENU_ENUM_LABEL_VALUE_MENU_LINEAR_FILTER: + return "Menu Linear Filter"; + case MENU_ENUM_LABEL_VALUE_MENU_ENUM_THROTTLE_FRAMERATE: + return "Throttle Menu Framerate"; + case MENU_ENUM_LABEL_VALUE_CHEEVOS_HARDCORE_MODE_ENABLE: + return "Hardcore Mode"; + case MENU_ENUM_LABEL_VALUE_CHEEVOS_TEST_UNOFFICIAL: + return "Test unofficial"; + case MENU_ENUM_LABEL_VALUE_CHEEVOS_SETTINGS: + return "Retro Achievements"; + case MENU_ENUM_LABEL_VALUE_INPUT_TOUCH_ENABLE: + return "Touch Enable"; + case MENU_ENUM_LABEL_VALUE_INPUT_PREFER_FRONT_TOUCH: + return "Prefer Front Touch"; + case MENU_ENUM_LABEL_VALUE_INPUT_ICADE_ENABLE: + return "Keyboard Gamepad Mapping Enable"; + case MENU_ENUM_LABEL_VALUE_INPUT_KEYBOARD_GAMEPAD_MAPPING_TYPE: + return "Keyboard Gamepad Mapping Type"; + case MENU_ENUM_LABEL_VALUE_INPUT_SMALL_KEYBOARD_ENABLE: + return "Small Keyboard Enable"; + case MENU_ENUM_LABEL_VALUE_SAVE_CURRENT_CONFIG_OVERRIDE_CORE: + return "Save Core Overrides"; + case MENU_ENUM_LABEL_VALUE_SAVE_CURRENT_CONFIG_OVERRIDE_GAME: + return "Save Game Overrides"; + case MENU_ENUM_LABEL_VALUE_SAVE_CURRENT_CONFIG: + return "Save Current Config"; + case MENU_ENUM_LABEL_VALUE_STATE_SLOT: + return "State Slot"; + case MENU_ENUM_LABEL_VALUE_ACCOUNTS_CHEEVOS_SETTINGS: + return "Accounts Cheevos"; + case MENU_ENUM_LABEL_VALUE_ACCOUNTS_CHEEVOS_USERNAME: + return "Username"; + case MENU_ENUM_LABEL_VALUE_ACCOUNTS_CHEEVOS_PASSWORD: + return "Password"; + case MENU_ENUM_LABEL_VALUE_ACCOUNTS_RETRO_ACHIEVEMENTS: + return "Retro Achievements"; + case MENU_ENUM_LABEL_VALUE_RETRO_ACHIEVEMENTS_SETTINGS: + return "Retro Achievements"; + case MENU_ENUM_LABEL_VALUE_ACCOUNTS_LIST: + return "Accounts"; + case MENU_ENUM_LABEL_VALUE_ACCOUNTS_LIST_END: + return "Accounts List Endpoint"; + case MENU_ENUM_LABEL_VALUE_HELP_SCANNING_CONTENT: + return "Scanning For Content"; + case MENU_ENUM_LABEL_VALUE_CHEEVOS_DESCRIPTION: + return "Description"; + case MENU_ENUM_LABEL_VALUE_HELP_AUDIO_VIDEO_TROUBLESHOOTING: + return "Audio/Video Troubleshooting"; + case MENU_ENUM_LABEL_VALUE_HELP_CHANGE_VIRTUAL_GAMEPAD: + return "Changing Virtual Gamepad Overlay"; + case MENU_ENUM_LABEL_VALUE_HELP_WHAT_IS_A_CORE: + return "What Is A Core?"; + case MENU_ENUM_LABEL_VALUE_HELP_LOADING_CONTENT: + return "Loading Content"; + case MENU_ENUM_LABEL_VALUE_HELP_LIST: + return "Help"; + case MENU_ENUM_LABEL_VALUE_HELP_CONTROLS: + return "Basic Menu Controls"; + case MENU_ENUM_LABEL_VALUE_BASIC_MENU_ENUM_CONTROLS: + return "Basic menu controls"; + case MENU_ENUM_LABEL_VALUE_BASIC_MENU_ENUM_CONTROLS_SCROLL_UP: + return "Scroll Up"; + case MENU_ENUM_LABEL_VALUE_BASIC_MENU_ENUM_CONTROLS_CONFIRM: + return "Confirm/OK"; + case MENU_ENUM_LABEL_VALUE_BASIC_MENU_ENUM_CONTROLS_BACK: + return "Back"; + case MENU_ENUM_LABEL_VALUE_BASIC_MENU_ENUM_CONTROLS_START: + return "Defaults"; + case MENU_ENUM_LABEL_VALUE_BASIC_MENU_ENUM_CONTROLS_INFO: + return "Info"; + case MENU_ENUM_LABEL_VALUE_BASIC_MENU_ENUM_CONTROLS_TOGGLE_MENU: + return "Toggle Menu"; + case MENU_ENUM_LABEL_VALUE_BASIC_MENU_ENUM_CONTROLS_QUIT: + return "Quit"; + case MENU_ENUM_LABEL_VALUE_BASIC_MENU_ENUM_CONTROLS_TOGGLE_KEYBOARD: + return "Toggle Keyboard"; + case MENU_ENUM_LABEL_VALUE_OPEN_ARCHIVE: + return "Open Archive As Folder"; + case MENU_ENUM_LABEL_VALUE_LOAD_ARCHIVE: + return "Load Archive With Core"; + case MENU_ENUM_LABEL_VALUE_INPUT_BACK_AS_MENU_ENUM_TOGGLE_ENABLE: + return "Back As Menu Toggle Enable"; + case MENU_ENUM_LABEL_VALUE_INPUT_MENU_ENUM_TOGGLE_GAMEPAD_COMBO: + return "Menu Toggle Gamepad Combo"; + case MENU_ENUM_LABEL_VALUE_INPUT_ALL_USERS_CONTROL_MENU: + return "All Users Control Menu"; + case MENU_ENUM_LABEL_VALUE_INPUT_OVERLAY_HIDE_IN_MENU: + return "Hide Overlay In Menu"; + case MENU_ENUM_LABEL_VALUE_LANG_POLISH: + return "Polish"; + case MENU_ENUM_LABEL_VALUE_OVERLAY_AUTOLOAD_PREFERRED: + return "Autoload Preferred Overlay"; + case MENU_ENUM_LABEL_VALUE_UPDATE_CORE_INFO_FILES: + return "Update Core Info Files"; + case MENU_ENUM_LABEL_VALUE_DOWNLOAD_CORE_CONTENT: + return "Download Content"; + case MENU_ENUM_LABEL_VALUE_DOWNLOAD_CORE: + return "Download Core..."; + case MENU_ENUM_LABEL_VALUE_SCAN_THIS_DIRECTORY: + return ""; + case MENU_ENUM_LABEL_VALUE_SCAN_FILE: + return "Scan File"; + case MENU_ENUM_LABEL_VALUE_SCAN_DIRECTORY: + return "Scan Directory"; + case MENU_ENUM_LABEL_VALUE_ADD_CONTENT_LIST: + return "Add Content"; + case MENU_ENUM_LABEL_VALUE_INFORMATION: + return "Information"; + case MENU_ENUM_LABEL_VALUE_INFORMATION_LIST: + return "Information"; + case MENU_ENUM_LABEL_VALUE_USE_BUILTIN_PLAYER: + return "Use Builtin Media Player"; + case MENU_ENUM_LABEL_VALUE_CONTENT_SETTINGS: + return "Quick Menu"; + case MENU_ENUM_LABEL_VALUE_RDB_ENTRY_CRC32: + return "CRC32"; + case MENU_ENUM_LABEL_VALUE_RDB_ENTRY_MD5: + return "MD5"; + case MENU_ENUM_LABEL_VALUE_LOAD_CONTENT_LIST: + return "Load Content"; + case MENU_ENUM_LABEL_VALUE_ASK_ARCHIVE: + return "Ask"; + case MENU_ENUM_LABEL_VALUE_PRIVACY_SETTINGS: + return "Privacy"; + case MENU_ENUM_LABEL_VALUE_MUSIC_TAB: + return "Music"; + case MENU_ENUM_LABEL_VALUE_VIDEO_TAB: + return "Video"; + case MENU_ENUM_LABEL_VALUE_IMAGES_TAB: + return "Images"; + case MENU_ENUM_LABEL_VALUE_HORIZONTAL_MENU: + return "Horizontal Menu"; + case MENU_ENUM_LABEL_VALUE_SETTINGS_TAB: + return "Settings"; + case MENU_ENUM_LABEL_VALUE_HISTORY_TAB: + return "History"; + case MENU_ENUM_LABEL_VALUE_ADD_TAB: + return "Import content"; + case MENU_ENUM_LABEL_VALUE_PLAYLISTS_TAB: + return "Playlists"; + case MENU_ENUM_LABEL_VALUE_NO_SETTINGS_FOUND: + return "No settings found."; + case MENU_ENUM_LABEL_VALUE_NO_PERFORMANCE_COUNTERS: + return "No performance counters."; + case MENU_ENUM_LABEL_VALUE_DRIVER_SETTINGS: + return "Driver"; + case MENU_ENUM_LABEL_VALUE_CONFIGURATION_SETTINGS: + return "Configuration"; + case MENU_ENUM_LABEL_VALUE_CORE_SETTINGS: + return "Core"; + case MENU_ENUM_LABEL_VALUE_VIDEO_SETTINGS: + return "Video"; + case MENU_ENUM_LABEL_VALUE_LOGGING_SETTINGS: + return "Logging"; + case MENU_ENUM_LABEL_VALUE_SAVING_SETTINGS: + return "Saving"; + case MENU_ENUM_LABEL_VALUE_REWIND_SETTINGS: + return "Rewind"; + case MENU_ENUM_LABEL_VALUE_SHADER: + return "Shader"; + case MENU_ENUM_LABEL_VALUE_CHEAT: + return "Cheat"; + case MENU_ENUM_LABEL_VALUE_USER: + return "User"; + case MENU_ENUM_LABEL_VALUE_SYSTEM_BGM_ENABLE: + return "System BGM Enable"; + case MENU_ENUM_LABEL_VALUE_RETROPAD: + return "RetroPad"; + case MENU_ENUM_LABEL_VALUE_RETROKEYBOARD: + return "RetroKeyboard"; + case MENU_ENUM_LABEL_VALUE_AUDIO_BLOCK_FRAMES: + return "Block Frames"; + case MENU_ENUM_LABEL_VALUE_INPUT_DESCRIPTOR_LABEL_SHOW: + return "Display Input Descriptor Labels"; + case MENU_ENUM_LABEL_VALUE_INPUT_DESCRIPTOR_HIDE_UNBOUND: + return "Hide Unbound Core Input Descriptors"; + case MENU_ENUM_LABEL_VALUE_VIDEO_FONT_ENABLE: + return "Display OSD Message"; + case MENU_ENUM_LABEL_VALUE_VIDEO_FONT_PATH: + return "OSD Message Font"; + case MENU_ENUM_LABEL_VALUE_VIDEO_FONT_SIZE: + return "OSD Message Size"; + case MENU_ENUM_LABEL_VALUE_VIDEO_MESSAGE_POS_X: + return "OSD Message X Position"; + case MENU_ENUM_LABEL_VALUE_VIDEO_MESSAGE_POS_Y: + return "OSD Message Y Position"; + case MENU_ENUM_LABEL_VALUE_VIDEO_SOFT_FILTER: + return "Soft Filter Enable"; + case MENU_ENUM_LABEL_VALUE_VIDEO_FILTER_FLICKER: + return "Flicker filter"; + case MENU_ENUM_LABEL_VALUE_DIRECTORY_CONTENT: + return ""; + case MENU_ENUM_LABEL_VALUE_UNKNOWN: + return "Unknown"; + case MENU_ENUM_LABEL_VALUE_DONT_CARE: + return "Don't care"; + case MENU_ENUM_LABEL_VALUE_LINEAR: + return "Linear"; + case MENU_ENUM_LABEL_VALUE_NEAREST: + return "Nearest"; + case MENU_ENUM_LABEL_VALUE_DIRECTORY_DEFAULT: + return ""; + case MENU_ENUM_LABEL_VALUE_DIRECTORY_NONE: + return ""; + case MENU_ENUM_LABEL_VALUE_NOT_AVAILABLE: + return "N/A"; + case MENU_ENUM_LABEL_VALUE_DATABASE_SELECTION: + return "Database Selection"; + case MENU_ENUM_LABEL_VALUE_CORE_ASSETS_DIR: + return "Core Assets Dir"; + case MENU_ENUM_LABEL_VALUE_CONTENT_DIR: + return "Content Dir"; + case MENU_ENUM_LABEL_VALUE_INPUT_REMAPPING_DIRECTORY: + return "Input Remapping Dir"; + case MENU_ENUM_LABEL_VALUE_JOYPAD_AUTOCONFIG_DIR: + return "Input Device Autoconfig Dir"; + case MENU_ENUM_LABEL_VALUE_RECORDING_CONFIG_DIRECTORY: + return "Recording Config Dir"; + case MENU_ENUM_LABEL_VALUE_RECORDING_OUTPUT_DIRECTORY: + return "Recording Output Dir"; + case MENU_ENUM_LABEL_VALUE_SCREENSHOT_DIRECTORY: + return "Screenshot Dir"; + case MENU_ENUM_LABEL_VALUE_PLAYLIST_DIRECTORY: + return "Playlist Dir"; + case MENU_ENUM_LABEL_VALUE_SAVEFILE_DIRECTORY: + return "Savefile Dir"; + case MENU_ENUM_LABEL_VALUE_SAVESTATE_DIRECTORY: + return "Savestate Dir"; + case MENU_ENUM_LABEL_VALUE_STDIN_CMD_ENABLE: + return "stdin Commands"; + case MENU_ENUM_LABEL_VALUE_NETWORK_REMOTE_ENABLE: + return "Network Gamepad"; + case MENU_ENUM_LABEL_VALUE_VIDEO_DRIVER: + return "Video Driver"; + case MENU_ENUM_LABEL_VALUE_RECORD_ENABLE: + return "Record Enable"; + case MENU_ENUM_LABEL_VALUE_VIDEO_GPU_RECORD: + return "GPU Record Enable"; + case MENU_ENUM_LABEL_VALUE_RECORD_PATH: + return "Output File"; + case MENU_ENUM_LABEL_VALUE_RECORD_USE_OUTPUT_DIRECTORY: + return "Use Output Dir"; + case MENU_ENUM_LABEL_VALUE_RECORD_CONFIG: + return "Record Config"; + case MENU_ENUM_LABEL_VALUE_CONFIG: + return "Config"; + case MENU_ENUM_LABEL_VALUE_VIDEO_POST_FILTER_RECORD: + return "Post filter record Enable"; + case MENU_ENUM_LABEL_VALUE_CORE_ASSETS_DIRECTORY: + return "Downloads Dir"; + case MENU_ENUM_LABEL_VALUE_ASSETS_DIRECTORY: + return "Assets Dir"; + case MENU_ENUM_LABEL_VALUE_DYNAMIC_WALLPAPERS_DIRECTORY: + return "Dynamic Wallpapers Dir"; + case MENU_ENUM_LABEL_VALUE_THUMBNAILS_DIRECTORY: + return "Thumbnails Dir"; + case MENU_ENUM_LABEL_VALUE_RGUI_BROWSER_DIRECTORY: + return "File Browser Dir"; + case MENU_ENUM_LABEL_VALUE_RGUI_CONFIG_DIRECTORY: + return "Config Dir"; + case MENU_ENUM_LABEL_VALUE_LIBRETRO_INFO_PATH: + return "Core Info Dir"; + case MENU_ENUM_LABEL_VALUE_LIBRETRO_DIR_PATH: + return "Core Dir"; + case MENU_ENUM_LABEL_VALUE_CURSOR_DIRECTORY: + return "Cursor Dir"; + case MENU_ENUM_LABEL_VALUE_CONTENT_DATABASE_DIRECTORY: + return "Content Database Dir"; + case MENU_ENUM_LABEL_VALUE_SYSTEM_DIRECTORY: + return "System/BIOS Dir"; + case MENU_ENUM_LABEL_VALUE_CHEAT_DATABASE_PATH: + return "Cheat File Dir"; + case MENU_ENUM_LABEL_VALUE_CACHE_DIRECTORY: + return "Cache Dir"; + case MENU_ENUM_LABEL_VALUE_AUDIO_FILTER_DIR: + return "Audio Filter Dir"; + case MENU_ENUM_LABEL_VALUE_VIDEO_SHADER_DIR: + return "Video Shader Dir"; + case MENU_ENUM_LABEL_VALUE_VIDEO_FILTER_DIR: + return "Video Filter Dir"; + case MENU_ENUM_LABEL_VALUE_OVERLAY_DIRECTORY: + return "Overlay Dir"; + case MENU_ENUM_LABEL_VALUE_OSK_OVERLAY_DIRECTORY: + return "OSK Overlay Dir"; + case MENU_ENUM_LABEL_VALUE_NETPLAY_CLIENT_SWAP_INPUT: + return "Netplay P2 Uses C1"; + case MENU_ENUM_LABEL_VALUE_NETPLAY_SPECTATOR_MODE_ENABLE: + return "Netplay Spectator Enable"; + case MENU_ENUM_LABEL_VALUE_NETPLAY_IP_ADDRESS: + return "Server Address"; + case MENU_ENUM_LABEL_VALUE_NETPLAY_TCP_UDP_PORT: + return "Netplay TCP/UDP Port"; + case MENU_ENUM_LABEL_VALUE_NETPLAY_ENABLE: + return "Netplay Enable"; + case MENU_ENUM_LABEL_VALUE_SSH_ENABLE: + return "SSH Enable"; + case MENU_ENUM_LABEL_VALUE_SAMBA_ENABLE: + return "SAMBA Enable"; + case MENU_ENUM_LABEL_VALUE_BLUETOOTH_ENABLE: + return "Bluetooth Enable"; + case MENU_ENUM_LABEL_VALUE_NETPLAY_DELAY_FRAMES: + return "Netplay Delay Frames"; + case MENU_ENUM_LABEL_VALUE_NETPLAY_CHECK_FRAMES: + return "Netplay Check Frames"; + case MENU_ENUM_LABEL_VALUE_NETPLAY_MODE: + return "Netplay Client Enable"; + case MENU_ENUM_LABEL_VALUE_RGUI_SHOW_START_SCREEN: + return "Show Start Screen"; + case MENU_ENUM_LABEL_VALUE_TITLE_COLOR: + return "Menu title color"; + case MENU_ENUM_LABEL_VALUE_ENTRY_HOVER_COLOR: + return "Menu entry hover color"; + case MENU_ENUM_LABEL_VALUE_TIMEDATE_ENABLE: + return "Display time / date"; + case MENU_ENUM_LABEL_VALUE_THREADED_DATA_RUNLOOP_ENABLE: + return "Threaded data runloop"; + case MENU_ENUM_LABEL_VALUE_ENTRY_NORMAL_COLOR: + return "Menu entry normal color"; + case MENU_ENUM_LABEL_VALUE_SHOW_ADVANCED_SETTINGS: + return "Show Advanced Settings"; + case MENU_ENUM_LABEL_VALUE_MOUSE_ENABLE: + return "Mouse Support"; + case MENU_ENUM_LABEL_VALUE_POINTER_ENABLE: + return "Touch Support"; + case MENU_ENUM_LABEL_VALUE_CORE_ENABLE: + return "Display core name"; + case MENU_ENUM_LABEL_VALUE_NETPLAY_ENABLE_HOST: + return "Start hosting"; + case MENU_ENUM_LABEL_VALUE_NETPLAY_ENABLE_CLIENT: + return "Connect to Netplay host"; + case MENU_ENUM_LABEL_VALUE_NETPLAY_DISCONNECT: + return "Disconnect"; + case MENU_ENUM_LABEL_VALUE_NETPLAY_SETTINGS: + return "Netplay settings"; + case MENU_ENUM_LABEL_VALUE_DPI_OVERRIDE_ENABLE: + return "DPI Override Enable"; + case MENU_ENUM_LABEL_VALUE_DPI_OVERRIDE_VALUE: + return "DPI Override"; + case MENU_ENUM_LABEL_VALUE_XMB_SCALE_FACTOR: + return "Menu Scale Factor"; + case MENU_ENUM_LABEL_VALUE_XMB_ALPHA_FACTOR: + return "Menu Alpha Factor"; + case MENU_ENUM_LABEL_VALUE_XMB_FONT: + return "Menu Font"; + case MENU_ENUM_LABEL_VALUE_XMB_THEME: + return "Menu Icon Theme"; + case MENU_ENUM_LABEL_VALUE_XMB_MENU_COLOR_THEME: + return "Menu Color Theme"; + case MENU_ENUM_LABEL_VALUE_MATERIALUI_MENU_COLOR_THEME: + return "Menu Color Theme"; + case MENU_ENUM_LABEL_VALUE_XMB_SHADOWS_ENABLE: + return "Icon Shadows Enable"; + case MENU_ENUM_LABEL_VALUE_XMB_SHOW_SETTINGS: + return "Show Settings Tab"; + case MENU_ENUM_LABEL_VALUE_XMB_SHOW_IMAGES: + return "Show Images Tab"; + case MENU_ENUM_LABEL_VALUE_XMB_SHOW_MUSIC: + return "Show Music Tab"; + case MENU_ENUM_LABEL_VALUE_XMB_SHOW_VIDEO: + return "Show Video Tab"; + case MENU_ENUM_LABEL_VALUE_XMB_SHOW_HISTORY: + return "Show History Tab"; + case MENU_ENUM_LABEL_VALUE_XMB_RIBBON_ENABLE: + return "Menu Shader Pipeline"; + case MENU_ENUM_LABEL_VALUE_XMB_ICON_THEME_MONOCHROME: + return "Monochrome"; + case MENU_ENUM_LABEL_VALUE_XMB_ICON_THEME_FLATUI: + return "FlatUI"; + case MENU_ENUM_LABEL_VALUE_XMB_ICON_THEME_RETROACTIVE: + return "RetroActive"; + case MENU_ENUM_LABEL_VALUE_XMB_ICON_THEME_PIXEL: + return "Pixel"; + case MENU_ENUM_LABEL_VALUE_XMB_ICON_THEME_CUSTOM: + return "Custom"; + case MENU_ENUM_LABEL_VALUE_SUSPEND_SCREENSAVER_ENABLE: + return "Suspend Screensaver"; + case MENU_ENUM_LABEL_VALUE_VIDEO_DISABLE_COMPOSITION: + return "Disable Desktop Composition"; + case MENU_ENUM_LABEL_VALUE_PAUSE_NONACTIVE: + return "Don't run in background"; + case MENU_ENUM_LABEL_VALUE_UI_COMPANION_START_ON_BOOT: + return "UI Companion Start On Boot"; + case MENU_ENUM_LABEL_VALUE_UI_COMPANION_ENABLE: + return "UI Companion Enable"; + case MENU_ENUM_LABEL_VALUE_UI_MENUBAR_ENABLE: + return "Menubar"; + case MENU_ENUM_LABEL_VALUE_ARCHIVE_MODE: + return "Archive File Association Action"; + case MENU_ENUM_LABEL_VALUE_NETWORK_CMD_ENABLE: + return "Network Commands"; + case MENU_ENUM_LABEL_VALUE_NETWORK_CMD_PORT: + return "Network Command Port"; + case MENU_ENUM_LABEL_VALUE_HISTORY_LIST_ENABLE: + return "History List Enable"; + case MENU_ENUM_LABEL_VALUE_CONTENT_HISTORY_SIZE: + return "History List Size"; + case MENU_ENUM_LABEL_VALUE_VIDEO_REFRESH_RATE_AUTO: + return "Estimated Monitor Framerate"; + case MENU_ENUM_LABEL_VALUE_DUMMY_ON_CORE_SHUTDOWN: + return "Dummy On Core Shutdown"; + case MENU_ENUM_LABEL_VALUE_CORE_SET_SUPPORTS_NO_CONTENT_ENABLE: + return "Automatically start a core"; + case MENU_ENUM_LABEL_VALUE_FRAME_THROTTLE_ENABLE: + return "Limit Maximum Run Speed"; + case MENU_ENUM_LABEL_VALUE_FASTFORWARD_RATIO: + return "Maximum Run Speed"; + case MENU_ENUM_LABEL_VALUE_AUTO_REMAPS_ENABLE: + return "Load Remap Files Automatically"; + case MENU_ENUM_LABEL_VALUE_AUTO_SHADERS_ENABLE: + return "Load Shader Presets Automatically"; + case MENU_ENUM_LABEL_VALUE_SLOWMOTION_RATIO: + return "Slow-Motion Ratio"; + case MENU_ENUM_LABEL_VALUE_CORE_SPECIFIC_CONFIG: + return "Configuration Per-Core"; + case MENU_ENUM_LABEL_VALUE_GAME_SPECIFIC_OPTIONS: + return "Load Content-specific core options automatically"; + case MENU_ENUM_LABEL_VALUE_GAME_SPECIFIC_OPTIONS_CREATE: + return "Create game-options file"; + case MENU_ENUM_LABEL_VALUE_GAME_SPECIFIC_OPTIONS_IN_USE: + return "Game-options file"; + case MENU_ENUM_LABEL_VALUE_AUTO_OVERRIDES_ENABLE: + return "Load Override Files Automatically"; + case MENU_ENUM_LABEL_VALUE_CONFIG_SAVE_ON_EXIT: + return "Save Configuration On Exit"; + case MENU_ENUM_LABEL_VALUE_CONFIRM_ON_EXIT: + return "Ask For Confirmation On Exit"; + case MENU_ENUM_LABEL_VALUE_SHOW_HIDDEN_FILES: + return "Show Hidden Files and Folders"; + case MENU_ENUM_LABEL_VALUE_VIDEO_SMOOTH: + return "HW Bilinear Filtering"; + case MENU_ENUM_LABEL_VALUE_VIDEO_GAMMA: + return "Video Gamma"; + case MENU_ENUM_LABEL_VALUE_VIDEO_ALLOW_ROTATE: + return "Allow rotation"; + case MENU_ENUM_LABEL_VALUE_VIDEO_HARD_SYNC: + return "Hard GPU Sync"; + case MENU_ENUM_LABEL_VALUE_VIDEO_SWAP_INTERVAL: + return "VSync Swap Interval"; + case MENU_ENUM_LABEL_VALUE_VIDEO_VSYNC: + return "VSync"; + case MENU_ENUM_LABEL_VALUE_VIDEO_THREADED: + return "Threaded Video"; + case MENU_ENUM_LABEL_VALUE_VIDEO_ROTATION: + return "Rotation"; + case MENU_ENUM_LABEL_VALUE_VIDEO_GPU_SCREENSHOT: + return "GPU Screenshot Enable"; + case MENU_ENUM_LABEL_VALUE_VIDEO_CROP_OVERSCAN: + return "Crop Overscan (Reload)"; + case MENU_ENUM_LABEL_VALUE_VIDEO_ASPECT_RATIO_INDEX: + return "Aspect Ratio Index"; + case MENU_ENUM_LABEL_VALUE_VIDEO_ASPECT_RATIO_AUTO: + return "Auto Aspect Ratio"; + case MENU_ENUM_LABEL_VALUE_VIDEO_FORCE_ASPECT: + return "Force aspect ratio"; + case MENU_ENUM_LABEL_VALUE_VIDEO_REFRESH_RATE: + return "Refresh Rate"; + case MENU_ENUM_LABEL_VALUE_VIDEO_FORCE_SRGB_DISABLE: + return "Force-disable sRGB FBO"; + case MENU_ENUM_LABEL_VALUE_VIDEO_WINDOWED_FULLSCREEN: + return "Windowed Fullscreen Mode"; + case MENU_ENUM_LABEL_VALUE_PAL60_ENABLE: + return "Use PAL60 Mode"; + case MENU_ENUM_LABEL_VALUE_VIDEO_VFILTER: + return "Deflicker"; + case MENU_ENUM_LABEL_VALUE_VIDEO_VI_WIDTH: + return "Set VI Screen Width"; + case MENU_ENUM_LABEL_VALUE_VIDEO_BLACK_FRAME_INSERTION: + return "Black Frame Insertion"; + case MENU_ENUM_LABEL_VALUE_VIDEO_HARD_SYNC_FRAMES: + return "Hard GPU Sync Frames"; + case MENU_ENUM_LABEL_VALUE_SORT_SAVEFILES_ENABLE: + return "Sort Saves In Folders"; + case MENU_ENUM_LABEL_VALUE_SORT_SAVESTATES_ENABLE: + return "Sort Savestates In Folders"; + case MENU_ENUM_LABEL_VALUE_VIDEO_FULLSCREEN: + return "Use Fullscreen Mode"; + case MENU_ENUM_LABEL_VALUE_VIDEO_SCALE: + return "Windowed Scale"; + case MENU_ENUM_LABEL_VALUE_VIDEO_SCALE_INTEGER: + return "Integer Scale"; + case MENU_ENUM_LABEL_VALUE_PERFCNT_ENABLE: + return "Performance Counters"; + case MENU_ENUM_LABEL_VALUE_LIBRETRO_LOG_LEVEL: + return "Core Logging Level"; + case MENU_ENUM_LABEL_VALUE_LOG_VERBOSITY: + return "Logging Verbosity"; + case MENU_ENUM_LABEL_VALUE_SAVESTATE_AUTO_LOAD: + return "Auto Load State"; + case MENU_ENUM_LABEL_VALUE_SAVESTATE_AUTO_INDEX: + return "Save State Auto Index"; + case MENU_ENUM_LABEL_VALUE_SAVESTATE_AUTO_SAVE: + return "Auto Save State"; + case MENU_ENUM_LABEL_VALUE_AUTOSAVE_INTERVAL: + return "SaveRAM Autosave Interval"; + case MENU_ENUM_LABEL_VALUE_BLOCK_SRAM_OVERWRITE: + return "Don't overwrite SaveRAM on loading savestate"; + case MENU_ENUM_LABEL_VALUE_VIDEO_SHARED_CONTEXT: + return "HW Shared Context Enable"; + case MENU_ENUM_LABEL_VALUE_RESTART_RETROARCH: + return "Restart RetroArch"; + case MENU_ENUM_LABEL_VALUE_NETPLAY_NICKNAME: + return "Username"; + case MENU_ENUM_LABEL_VALUE_USER_LANGUAGE: + return "Language"; + case MENU_ENUM_LABEL_VALUE_CAMERA_ALLOW: + return "Allow Camera"; + case MENU_ENUM_LABEL_VALUE_LOCATION_ALLOW: + return "Allow Location"; + case MENU_ENUM_LABEL_VALUE_PAUSE_LIBRETRO: + return "Pause when menu activated"; + case MENU_ENUM_LABEL_VALUE_INPUT_OSK_OVERLAY_ENABLE: + return "Display Keyboard Overlay"; + case MENU_ENUM_LABEL_VALUE_INPUT_OVERLAY_ENABLE: + return "Display Overlay"; + case MENU_ENUM_LABEL_VALUE_VIDEO_MONITOR_INDEX: + return "Monitor Index"; + case MENU_ENUM_LABEL_VALUE_VIDEO_FRAME_DELAY: + return "Frame Delay"; + case MENU_ENUM_LABEL_VALUE_INPUT_DUTY_CYCLE: + return "Duty Cycle"; + case MENU_ENUM_LABEL_VALUE_INPUT_TURBO_PERIOD: + return "Turbo Period"; + case MENU_ENUM_LABEL_VALUE_INPUT_BIND_TIMEOUT: + return "Bind Timeout"; + case MENU_ENUM_LABEL_VALUE_INPUT_AXIS_THRESHOLD: + return "Input Axis Threshold"; + case MENU_ENUM_LABEL_VALUE_INPUT_REMAP_BINDS_ENABLE: + return "Remap Binds Enable"; + case MENU_ENUM_LABEL_VALUE_INPUT_MAX_USERS: + return "Max Users"; + case MENU_ENUM_LABEL_VALUE_INPUT_AUTODETECT_ENABLE: + return "Autoconfig Enable"; + case MENU_ENUM_LABEL_VALUE_AUDIO_OUTPUT_RATE: + return "Audio Output Rate (KHz)"; + case MENU_ENUM_LABEL_VALUE_AUDIO_MAX_TIMING_SKEW: + return "Audio Maximum Timing Skew"; + case MENU_ENUM_LABEL_VALUE_CHEAT_NUM_PASSES: + return "Cheat Passes"; + case MENU_ENUM_LABEL_VALUE_REMAP_FILE_SAVE_CORE: + return "Save Core Remap File"; + case MENU_ENUM_LABEL_VALUE_REMAP_FILE_SAVE_GAME: + return "Save Game Remap File"; + case MENU_ENUM_LABEL_VALUE_CHEAT_APPLY_CHANGES: + return "Apply Cheat Changes"; + case MENU_ENUM_LABEL_VALUE_SHADER_APPLY_CHANGES: + return "Apply Shader Changes"; + case MENU_ENUM_LABEL_VALUE_REWIND_ENABLE: + return "Rewind Enable"; + case MENU_ENUM_LABEL_VALUE_CONTENT_COLLECTION_LIST: + return "Collections"; + case MENU_ENUM_LABEL_VALUE_DETECT_CORE_LIST: + return "Select File And Detect Core"; + case MENU_ENUM_LABEL_VALUE_DOWNLOADED_FILE_DETECT_CORE_LIST: + return "Downloads Dir"; + case MENU_ENUM_LABEL_VALUE_LOAD_CONTENT_HISTORY: + return "Load Recent"; + case MENU_ENUM_LABEL_VALUE_AUDIO_ENABLE: + return "Audio Enable"; + case MENU_ENUM_LABEL_VALUE_FPS_SHOW: + return "Display Framerate"; + case MENU_ENUM_LABEL_VALUE_AUDIO_MUTE: + return "Audio Mute"; + case MENU_ENUM_LABEL_VALUE_AUDIO_VOLUME: + return "Audio Volume Level (dB)"; + case MENU_ENUM_LABEL_VALUE_AUDIO_SYNC: + return "Audio Sync Enable"; + case MENU_ENUM_LABEL_VALUE_AUDIO_RATE_CONTROL_DELTA: + return "Audio Rate Control Delta"; + case MENU_ENUM_LABEL_VALUE_VIDEO_SHADER_NUM_PASSES: + return "Shader Passes"; + case MENU_ENUM_LABEL_VALUE_RDB_ENTRY_SHA1: + return "SHA1"; + case MENU_ENUM_LABEL_VALUE_CONFIGURATIONS: + return "Load Configuration"; + case MENU_ENUM_LABEL_VALUE_REWIND_GRANULARITY: + return "Rewind Granularity"; + case MENU_ENUM_LABEL_VALUE_REMAP_FILE_LOAD: + return "Load Remap File"; + case MENU_ENUM_LABEL_VALUE_CUSTOM_RATIO: + return "Custom Ratio"; + case MENU_ENUM_LABEL_VALUE_USE_THIS_DIRECTORY: + return ""; + case MENU_ENUM_LABEL_VALUE_RDB_ENTRY_START_CONTENT: + return "Start Content"; + case MENU_ENUM_LABEL_VALUE_DISK_OPTIONS: + return "Disk Control"; + case MENU_ENUM_LABEL_VALUE_CORE_OPTIONS: + return "Options"; + case MENU_ENUM_LABEL_VALUE_CORE_CHEAT_OPTIONS: + return "Cheats"; + case MENU_ENUM_LABEL_VALUE_REMAP_FILE: + return "Remap File"; + case MENU_ENUM_LABEL_VALUE_CHEAT_FILE: + return "Cheat File"; + case MENU_ENUM_LABEL_VALUE_CHEAT_FILE_LOAD: + return "Cheat File Load"; + case MENU_ENUM_LABEL_VALUE_CHEAT_FILE_SAVE_AS: + return "Cheat File Save As"; + case MENU_ENUM_LABEL_VALUE_CORE_COUNTERS: + return "Core Counters"; + case MENU_ENUM_LABEL_VALUE_TAKE_SCREENSHOT: + return "Take Screenshot"; + case MENU_ENUM_LABEL_VALUE_DELETE_ENTRY: + return "Remove"; + case MENU_ENUM_LABEL_VALUE_RESUME: + return "Resume"; + case MENU_ENUM_LABEL_VALUE_DISK_INDEX: + return "Disk Index"; + case MENU_ENUM_LABEL_VALUE_FRONTEND_COUNTERS: + return "Frontend Counters"; + case MENU_ENUM_LABEL_VALUE_DISK_IMAGE_APPEND: + return "Disk Image Append"; + case MENU_ENUM_LABEL_VALUE_DISK_CYCLE_TRAY_STATUS: + return "Disk Cycle Tray Status"; + case MENU_ENUM_LABEL_VALUE_NO_PLAYLIST_ENTRIES_AVAILABLE: + return "No playlist entries available."; + case MENU_ENUM_LABEL_VALUE_NO_HISTORY_AVAILABLE: + return "No history available."; + case MENU_ENUM_LABEL_VALUE_NO_CORE_INFORMATION_AVAILABLE: + return "No core information available."; + case MENU_ENUM_LABEL_VALUE_NO_CORE_OPTIONS_AVAILABLE: + return "No core options available."; + case MENU_ENUM_LABEL_VALUE_NO_CORES_AVAILABLE: + return "No cores available."; + case MENU_ENUM_LABEL_VALUE_NO_CORE: + return "No Core"; + case MENU_ENUM_LABEL_VALUE_DATABASE_MANAGER: + return "Database Manager"; + case MENU_ENUM_LABEL_VALUE_CURSOR_MANAGER: + return "Cursor Manager"; + case MENU_ENUM_LABEL_VALUE_MAIN_MENU: + return "Main Menu"; + case MENU_ENUM_LABEL_VALUE_SETTINGS: + return "Settings"; + case MENU_ENUM_LABEL_VALUE_QUIT_RETROARCH: + return "Quit RetroArch"; + case MENU_ENUM_LABEL_VALUE_SHUTDOWN: + return "Shutdown"; + case MENU_ENUM_LABEL_VALUE_REBOOT: + return "Reboot"; + case MENU_ENUM_LABEL_VALUE_HELP: + return "help"; + case MENU_ENUM_LABEL_VALUE_SAVE_NEW_CONFIG: + return "Save New Config"; + case MENU_ENUM_LABEL_VALUE_RESTART_CONTENT: + return "Restart"; + case MENU_ENUM_LABEL_VALUE_CORE_UPDATER_LIST: + return "Core Updater"; + case MENU_ENUM_LABEL_VALUE_CORE_UPDATER_BUILDBOT_URL: + return "Buildbot Cores URL"; + case MENU_ENUM_LABEL_VALUE_BUILDBOT_ASSETS_URL: + return "Buildbot Assets URL"; + case MENU_ENUM_LABEL_VALUE_NAVIGATION_WRAPAROUND: + return "Navigation Wrap-Around"; + case MENU_ENUM_LABEL_VALUE_NAVIGATION_BROWSER_FILTER_SUPPORTED_EXTENSIONS_ENABLE: + return "Filter unknown extensions"; + case MENU_ENUM_LABEL_VALUE_CORE_UPDATER_AUTO_EXTRACT_ARCHIVE: + return "Automatically extract downloaded archive"; + case MENU_ENUM_LABEL_VALUE_SYSTEM_INFORMATION: + return "System Information"; + case MENU_ENUM_LABEL_VALUE_NETWORK_INFORMATION: + return "Network Information"; + case MENU_ENUM_LABEL_VALUE_ACHIEVEMENT_LIST: + return "Achievement List"; + case MENU_ENUM_LABEL_VALUE_ONLINE_UPDATER: + return "Online Updater"; + case MENU_ENUM_LABEL_VALUE_NETPLAY: + return "Netplay"; + case MENU_ENUM_LABEL_VALUE_CORE_INFORMATION: + return "Core Information"; + case MENU_ENUM_LABEL_VALUE_DIRECTORY_NOT_FOUND: + return "Directory not found."; + case MENU_ENUM_LABEL_VALUE_NO_ITEMS: + return "No items."; + case MENU_ENUM_LABEL_VALUE_NO_PLAYLISTS: + return "No playlists."; + case MENU_ENUM_LABEL_VALUE_CORE_LIST: + return "Load Core"; + case MENU_ENUM_LABEL_VALUE_LOAD_CONTENT: + return "Select File"; + case MENU_ENUM_LABEL_VALUE_CLOSE_CONTENT: + return "Close"; + case MENU_ENUM_LABEL_VALUE_MANAGEMENT: + return "Database Settings"; + case MENU_ENUM_LABEL_VALUE_SAVE_STATE: + return "Save State"; + case MENU_ENUM_LABEL_VALUE_LOAD_STATE: + return "Load State"; + case MENU_ENUM_LABEL_VALUE_UNDO_LOAD_STATE: + return "Undo Load State"; + case MENU_ENUM_LABEL_VALUE_UNDO_SAVE_STATE: + return "Undo Save State"; + case MSG_UNDID_LOAD_STATE: + return "Undid load state."; + case MENU_ENUM_LABEL_VALUE_RESUME_CONTENT: + return "Resume"; + case MENU_ENUM_LABEL_VALUE_INPUT_DRIVER: + return "Input Driver"; + case MENU_ENUM_LABEL_VALUE_AUDIO_DRIVER: + return "Audio Driver"; + case MENU_ENUM_LABEL_VALUE_JOYPAD_DRIVER: + return "Joypad Driver"; + case MENU_ENUM_LABEL_VALUE_AUDIO_RESAMPLER_DRIVER: + return "Audio Resampler Driver"; + case MENU_ENUM_LABEL_VALUE_RECORD_DRIVER: + return "Record Driver"; + case MENU_ENUM_LABEL_VALUE_MENU_DRIVER: + return "Menu Driver"; + case MENU_ENUM_LABEL_VALUE_CAMERA_DRIVER: + return "Camera Driver"; + case MENU_ENUM_LABEL_VALUE_WIFI_DRIVER: + return "Wi-Fi Driver"; + case MENU_ENUM_LABEL_VALUE_LOCATION_DRIVER: + return "Location Driver"; + case MENU_ENUM_LABEL_VALUE_UNABLE_TO_READ_COMPRESSED_FILE: + return "Unable to read compressed file."; + case MENU_ENUM_LABEL_VALUE_OVERLAY_SCALE: + return "Overlay Scale"; + case MENU_ENUM_LABEL_VALUE_OVERLAY_PRESET: + return "Overlay Preset"; + case MENU_ENUM_LABEL_VALUE_AUDIO_LATENCY: + return "Audio Latency (ms)"; + case MENU_ENUM_LABEL_VALUE_AUDIO_DEVICE: + return "Audio Device"; + case MENU_ENUM_LABEL_VALUE_OVERLAY: + return "Overlay"; + case MENU_ENUM_LABEL_VALUE_KEYBOARD_OVERLAY_PRESET: + return "Keyboard Overlay Preset"; + case MENU_ENUM_LABEL_VALUE_OVERLAY_OPACITY: + return "Overlay Opacity"; + case MENU_ENUM_LABEL_VALUE_MENU_WALLPAPER: + return "Menu Wallpaper"; + case MENU_ENUM_LABEL_VALUE_DYNAMIC_WALLPAPER: + return "Dynamic Wallpaper"; + case MENU_ENUM_LABEL_VALUE_THUMBNAILS: + return "Thumbnails"; + case MENU_ENUM_LABEL_VALUE_CORE_INPUT_REMAPPING_OPTIONS: + return "Controls"; + case MENU_ENUM_LABEL_VALUE_SHADER_OPTIONS: + return "Shaders"; + case MENU_ENUM_LABEL_VALUE_VIDEO_SHADER_PARAMETERS: + return "Preview Shader Parameters"; + case MENU_ENUM_LABEL_VALUE_VIDEO_SHADER_PRESET_PARAMETERS: + return "Menu Shader Parameters"; + case MENU_ENUM_LABEL_VIDEO_SHADER_PRESET_TWO: + return "Shader Preset"; + case MENU_ENUM_LABEL_VALUE_VIDEO_SHADER_PRESET_SAVE_AS: + return "Save Shader Preset As"; + case MENU_ENUM_LABEL_VALUE_VIDEO_SHADER_PRESET_SAVE_CORE: + return "Save Core Preset"; + case MENU_ENUM_LABEL_VALUE_VIDEO_SHADER_PRESET_SAVE_GAME: + return "Save Game Preset"; + case MENU_ENUM_LABEL_VALUE_NO_SHADER_PARAMETERS: + return "No shader parameters."; + case MENU_ENUM_LABEL_VALUE_VIDEO_SHADER_PRESET: + return "Load Shader Preset"; + case MENU_ENUM_LABEL_VALUE_VIDEO_FILTER: + return "Video Filter"; + case MENU_ENUM_LABEL_VALUE_AUDIO_DSP_PLUGIN: + return "Audio DSP Plugin"; + case MENU_ENUM_LABEL_VALUE_SECONDS: + return "seconds"; + case MENU_ENUM_LABEL_VALUE_OFF: + return "OFF"; + case MENU_ENUM_LABEL_VALUE_ON: + return "ON"; + case MENU_ENUM_LABEL_VALUE_UPDATE_ASSETS: + return "Update Assets"; + case MENU_ENUM_LABEL_VALUE_UPDATE_LAKKA: + return "Update Lakka"; + case MENU_ENUM_LABEL_VALUE_UPDATE_CHEATS: + return "Update Cheats"; + case MENU_ENUM_LABEL_VALUE_UPDATE_AUTOCONFIG_PROFILES: + return "Update Autoconfig Profiles"; + case MENU_ENUM_LABEL_VALUE_UPDATE_DATABASES: + return "Update Databases"; + case MENU_ENUM_LABEL_VALUE_UPDATE_OVERLAYS: + return "Update Overlays"; + case MENU_ENUM_LABEL_VALUE_UPDATE_CG_SHADERS: + return "Update Cg Shaders"; + case MENU_ENUM_LABEL_VALUE_UPDATE_GLSL_SHADERS: + return "Update GLSL Shaders"; + case MENU_ENUM_LABEL_VALUE_UPDATE_SLANG_SHADERS: + return "Update Slang Shaders"; + case MENU_ENUM_LABEL_VALUE_CORE_INFO_CORE_NAME: + return "Core name"; + case MENU_ENUM_LABEL_VALUE_CORE_INFO_CORE_LABEL: + return "Core label"; + case MENU_ENUM_LABEL_VALUE_CORE_INFO_SYSTEM_NAME: + return "System name"; + case MENU_ENUM_LABEL_VALUE_CORE_INFO_SYSTEM_MANUFACTURER: + return "System manufacturer"; + case MENU_ENUM_LABEL_VALUE_CORE_INFO_CATEGORIES: + return "Categories"; + case MENU_ENUM_LABEL_VALUE_CORE_INFO_AUTHORS: + return "Authors"; + case MENU_ENUM_LABEL_VALUE_CORE_INFO_PERMISSIONS: + return "Permissions"; + case MENU_ENUM_LABEL_VALUE_CORE_INFO_LICENSES: + return "License(s)"; + case MENU_ENUM_LABEL_VALUE_SUPPORTED_CORES: + return "Supported cores"; + case MENU_ENUM_LABEL_VALUE_CORE_INFO_SUPPORTED_EXTENSIONS: + return "Supported extensions"; + case MENU_ENUM_LABEL_VALUE_CORE_INFO_FIRMWARE: + return "Firmware"; + case MENU_ENUM_LABEL_VALUE_CORE_INFO_CORE_NOTES: + return "Core notes"; + case MENU_ENUM_LABEL_VALUE_SYSTEM_INFO_BUILD_DATE: + return "Build date"; + case MENU_ENUM_LABEL_VALUE_SYSTEM_INFO_GIT_VERSION: + return "Git version"; + case MENU_ENUM_LABEL_VALUE_SYSTEM_INFO_CPU_FEATURES: + return "CPU Features"; + case MENU_ENUM_LABEL_VALUE_SYSTEM_INFO_FRONTEND_IDENTIFIER: + return "Frontend identifier"; + case MENU_ENUM_LABEL_VALUE_SYSTEM_INFO_FRONTEND_NAME: + return "Frontend name"; + case MENU_ENUM_LABEL_VALUE_SYSTEM_INFO_FRONTEND_OS: + return "Frontend OS"; + case MENU_ENUM_LABEL_VALUE_SYSTEM_INFO_RETRORATING_LEVEL: + return "RetroRating level"; + case MENU_ENUM_LABEL_VALUE_SYSTEM_INFO_POWER_SOURCE: + return "Power source"; + case MENU_ENUM_LABEL_VALUE_SYSTEM_INFO_POWER_SOURCE_NO_SOURCE: + return "No source"; + case MENU_ENUM_LABEL_VALUE_SYSTEM_INFO_POWER_SOURCE_CHARGING: + return "Charging"; + case MENU_ENUM_LABEL_VALUE_SYSTEM_INFO_POWER_SOURCE_CHARGED: + return "Charged"; + case MENU_ENUM_LABEL_VALUE_SYSTEM_INFO_POWER_SOURCE_DISCHARGING: + return "Discharging"; + case MENU_ENUM_LABEL_VALUE_SYSTEM_INFO_VIDEO_CONTEXT_DRIVER: + return "Video context driver"; + case MENU_ENUM_LABEL_VALUE_SYSTEM_INFO_DISPLAY_METRIC_MM_WIDTH: + return "Display metric width (mm)"; + case MENU_ENUM_LABEL_VALUE_SYSTEM_INFO_DISPLAY_METRIC_MM_HEIGHT: + return "Display metric height (mm)"; + case MENU_ENUM_LABEL_VALUE_SYSTEM_INFO_DISPLAY_METRIC_DPI: + return "Display metric DPI"; + case MENU_ENUM_LABEL_VALUE_SYSTEM_INFO_LIBRETRODB_SUPPORT: + return "LibretroDB support"; + case MENU_ENUM_LABEL_VALUE_SYSTEM_INFO_OVERLAY_SUPPORT: + return "Overlay support"; + case MENU_ENUM_LABEL_VALUE_SYSTEM_INFO_COMMAND_IFACE_SUPPORT: + return "Command interface support"; + case MENU_ENUM_LABEL_VALUE_SYSTEM_INFO_NETWORK_REMOTE_SUPPORT: + return "Network Gamepad support"; + case MENU_ENUM_LABEL_VALUE_SYSTEM_INFO_NETWORK_COMMAND_IFACE_SUPPORT: + return "Network Command interface support"; + case MENU_ENUM_LABEL_VALUE_SYSTEM_INFO_COCOA_SUPPORT: + return "Cocoa support"; + case MENU_ENUM_LABEL_VALUE_SYSTEM_INFO_RPNG_SUPPORT: + return "PNG support (RPNG)"; + case MENU_ENUM_LABEL_VALUE_SYSTEM_INFO_RJPEG_SUPPORT: + return "JPEG support (RJPEG)"; + case MENU_ENUM_LABEL_VALUE_SYSTEM_INFO_RBMP_SUPPORT: + return "BMP support (RBMP)"; + case MENU_ENUM_LABEL_VALUE_SYSTEM_INFO_RTGA_SUPPORT: + return "TGA support (RTGA)"; + case MENU_ENUM_LABEL_VALUE_SYSTEM_INFO_SDL_SUPPORT: + return "SDL1.2 support"; + case MENU_ENUM_LABEL_VALUE_SYSTEM_INFO_SDL2_SUPPORT: + return "SDL2 support"; + case MENU_ENUM_LABEL_VALUE_SYSTEM_INFO_VULKAN_SUPPORT: + return "Vulkan support"; + case MENU_ENUM_LABEL_VALUE_SYSTEM_INFO_OPENGL_SUPPORT: + return "OpenGL support"; + case MENU_ENUM_LABEL_VALUE_SYSTEM_INFO_OPENGLES_SUPPORT: + return "OpenGL ES support"; + case MENU_ENUM_LABEL_VALUE_SYSTEM_INFO_THREADING_SUPPORT: + return "Threading support"; + case MENU_ENUM_LABEL_VALUE_SYSTEM_INFO_KMS_SUPPORT: + return "KMS/EGL support"; + case MENU_ENUM_LABEL_VALUE_SYSTEM_INFO_UDEV_SUPPORT: + return "Udev support"; + case MENU_ENUM_LABEL_VALUE_SYSTEM_INFO_OPENVG_SUPPORT: + return "OpenVG support"; + case MENU_ENUM_LABEL_VALUE_SYSTEM_INFO_EGL_SUPPORT: + return "EGL support"; + case MENU_ENUM_LABEL_VALUE_SYSTEM_INFO_X11_SUPPORT: + return "X11 support"; + case MENU_ENUM_LABEL_VALUE_SYSTEM_INFO_WAYLAND_SUPPORT: + return "Wayland support"; + case MENU_ENUM_LABEL_VALUE_SYSTEM_INFO_XVIDEO_SUPPORT: + return "XVideo support"; + case MENU_ENUM_LABEL_VALUE_SYSTEM_INFO_ALSA_SUPPORT: + return "ALSA support"; + case MENU_ENUM_LABEL_VALUE_SYSTEM_INFO_OSS_SUPPORT: + return "OSS support"; + case MENU_ENUM_LABEL_VALUE_SYSTEM_INFO_OPENAL_SUPPORT: + return "OpenAL support"; + case MENU_ENUM_LABEL_VALUE_SYSTEM_INFO_OPENSL_SUPPORT: + return "OpenSL support"; + case MENU_ENUM_LABEL_VALUE_SYSTEM_INFO_RSOUND_SUPPORT: + return "RSound support"; + case MENU_ENUM_LABEL_VALUE_SYSTEM_INFO_ROARAUDIO_SUPPORT: + return "RoarAudio support"; + case MENU_ENUM_LABEL_VALUE_SYSTEM_INFO_JACK_SUPPORT: + return "JACK support"; + case MENU_ENUM_LABEL_VALUE_SYSTEM_INFO_PULSEAUDIO_SUPPORT: + return "PulseAudio support"; + case MENU_ENUM_LABEL_VALUE_SYSTEM_INFO_DSOUND_SUPPORT: + return "DirectSound support"; + case MENU_ENUM_LABEL_VALUE_SYSTEM_INFO_XAUDIO2_SUPPORT: + return "XAudio2 support"; + case MENU_ENUM_LABEL_VALUE_SYSTEM_INFO_ZLIB_SUPPORT: + return "Zlib support"; + case MENU_ENUM_LABEL_VALUE_SYSTEM_INFO_7ZIP_SUPPORT: + return "7zip support"; + case MENU_ENUM_LABEL_VALUE_SYSTEM_INFO_DYLIB_SUPPORT: + return "Dynamic library support"; + case MENU_ENUM_LABEL_VALUE_SYSTEM_INFO_CG_SUPPORT: + return "Cg support"; + case MENU_ENUM_LABEL_VALUE_SYSTEM_INFO_GLSL_SUPPORT: + return "GLSL support"; + case MENU_ENUM_LABEL_VALUE_SYSTEM_INFO_SLANG_SUPPORT: + return "Slang support"; + case MENU_ENUM_LABEL_VALUE_SYSTEM_INFO_HLSL_SUPPORT: + return "HLSL support"; + case MENU_ENUM_LABEL_VALUE_SYSTEM_INFO_LIBXML2_SUPPORT: + return "libxml2 XML parsing support"; + case MENU_ENUM_LABEL_VALUE_SYSTEM_INFO_SDL_IMAGE_SUPPORT: + return "SDL image support"; + case MENU_ENUM_LABEL_VALUE_SYSTEM_INFO_FBO_SUPPORT: + return "OpenGL/Direct3D render-to-texture (multi-pass shaders) support"; + case MENU_ENUM_LABEL_VALUE_SYSTEM_INFO_DYNAMIC_SUPPORT: + return "Dynamic run-time loading of libretro library"; + case MENU_ENUM_LABEL_VALUE_SYSTEM_INFO_FFMPEG_SUPPORT: + return "FFmpeg support"; + case MENU_ENUM_LABEL_VALUE_SYSTEM_INFO_CORETEXT_SUPPORT: + return "CoreText support"; + case MENU_ENUM_LABEL_VALUE_SYSTEM_INFO_FREETYPE_SUPPORT: + return "FreeType support"; + case MENU_ENUM_LABEL_VALUE_SYSTEM_INFO_NETPLAY_SUPPORT: + return "Netplay (peer-to-peer) support"; + case MENU_ENUM_LABEL_VALUE_SYSTEM_INFO_PYTHON_SUPPORT: + return "Python (script support in shaders) support"; + case MENU_ENUM_LABEL_VALUE_SYSTEM_INFO_V4L2_SUPPORT: + return "Video4Linux2 support"; + case MENU_ENUM_LABEL_VALUE_SYSTEM_INFO_LIBUSB_SUPPORT: + return "Libusb support"; + case MENU_ENUM_LABEL_VALUE_YES: + return "Yes"; + case MENU_ENUM_LABEL_VALUE_NO: + return "No"; + case MENU_ENUM_LABEL_VALUE_BACK: + return "BACK"; + case MSG_FAILED_TO_BIND_SOCKET: + return "Failed to bind socket."; + case MENU_ENUM_LABEL_VALUE_SCREEN_RESOLUTION: + return "Screen Resolution"; + case MENU_ENUM_LABEL_VALUE_DISABLED: + return "Disabled"; + case MENU_ENUM_LABEL_VALUE_PORT: + return "Port"; + case MENU_ENUM_LABEL_VALUE_NONE: + return "None"; + case MENU_ENUM_LABEL_VALUE_RDB_ENTRY_DEVELOPER: + return "Developer"; + case MENU_ENUM_LABEL_VALUE_RDB_ENTRY_PUBLISHER: + return "Publisher"; + case MENU_ENUM_LABEL_VALUE_RDB_ENTRY_DESCRIPTION: + return "Description"; + case MENU_ENUM_LABEL_VALUE_RDB_ENTRY_GENRE: + return "Genre"; + case MENU_ENUM_LABEL_VALUE_RDB_ENTRY_NAME: + return "Name"; + case MENU_ENUM_LABEL_VALUE_RDB_ENTRY_ORIGIN: + return "Origin"; + case MENU_ENUM_LABEL_VALUE_RDB_ENTRY_FRANCHISE: + return "Franchise"; + case MENU_ENUM_LABEL_VALUE_RDB_ENTRY_RELEASE_MONTH: + return "Releasedate Month"; + case MENU_ENUM_LABEL_VALUE_RDB_ENTRY_RELEASE_YEAR: + return "Releasedate Year"; + case MENU_ENUM_LABEL_VALUE_TRUE: + return "True"; + case MENU_ENUM_LABEL_VALUE_FALSE: + return "False"; + case MENU_ENUM_LABEL_VALUE_MISSING: + return "Missing"; + case MENU_ENUM_LABEL_VALUE_PRESENT: + return "Present"; + case MENU_ENUM_LABEL_VALUE_OPTIONAL: + return "Optional"; + case MENU_ENUM_LABEL_VALUE_REQUIRED: + return "Required"; + case MENU_ENUM_LABEL_VALUE_STATUS: + return "Status"; + case MENU_ENUM_LABEL_VALUE_AUDIO_SETTINGS: + return "Audio"; + case MENU_ENUM_LABEL_VALUE_INPUT_SETTINGS: + return "Input"; + case MENU_ENUM_LABEL_VALUE_ONSCREEN_DISPLAY_SETTINGS: + return "Onscreen Display"; + case MENU_ENUM_LABEL_VALUE_OVERLAY_SETTINGS: + return "Onscreen Overlay"; + case MENU_ENUM_LABEL_VALUE_ONSCREEN_OVERLAY_SETTINGS: + return "Onscreen Overlay"; + case MENU_ENUM_LABEL_VALUE_MENU_SETTINGS: + return "Menu"; + case MENU_ENUM_LABEL_VALUE_MULTIMEDIA_SETTINGS: + return "Multimedia"; + case MENU_ENUM_LABEL_VALUE_USER_INTERFACE_SETTINGS: + return "User Interface"; + case MENU_ENUM_LABEL_VALUE_MENU_FILE_BROWSER_SETTINGS: + return "Menu File Browser"; + case MENU_ENUM_LABEL_VALUE_CORE_UPDATER_SETTINGS: + return "Updater"; + case MENU_ENUM_LABEL_VALUE_UPDATER_SETTINGS: + return "Updater"; + case MENU_ENUM_LABEL_VALUE_NETWORK_SETTINGS: + return "Network"; + case MENU_ENUM_LABEL_VALUE_WIFI_SETTINGS: + return "Wi-Fi"; + case MENU_ENUM_LABEL_VALUE_LAKKA_SERVICES: + return "Lakka Services"; + case MENU_ENUM_LABEL_VALUE_PLAYLIST_SETTINGS: + return "Playlists"; + case MENU_ENUM_LABEL_VALUE_USER_SETTINGS: + return "User"; + case MENU_ENUM_LABEL_VALUE_DIRECTORY_SETTINGS: + return "Directory"; + case MENU_ENUM_LABEL_VALUE_RECORDING_SETTINGS: + return "Recording"; + case MENU_ENUM_LABEL_VALUE_NO_INFORMATION_AVAILABLE: + return "No information is available."; + case MENU_ENUM_LABEL_VALUE_INPUT_USER_BINDS: + return "Input User %u Binds"; + case MENU_ENUM_LABEL_VALUE_LANG_ENGLISH: + return "English"; + case MENU_ENUM_LABEL_VALUE_LANG_JAPANESE: + return "Japanese"; + case MENU_ENUM_LABEL_VALUE_LANG_FRENCH: + return "French"; + case MENU_ENUM_LABEL_VALUE_LANG_SPANISH: + return "Spanish"; + case MENU_ENUM_LABEL_VALUE_LANG_GERMAN: + return "German"; + case MENU_ENUM_LABEL_VALUE_LANG_ITALIAN: + return "Italian"; + case MENU_ENUM_LABEL_VALUE_LANG_DUTCH: + return "Dutch"; + case MENU_ENUM_LABEL_VALUE_LANG_PORTUGUESE: + return "Portuguese"; + case MENU_ENUM_LABEL_VALUE_LANG_RUSSIAN: + return "Russian"; + case MENU_ENUM_LABEL_VALUE_LANG_KOREAN: + return "Korean"; + case MENU_ENUM_LABEL_VALUE_LANG_CHINESE_TRADITIONAL: + return "Chinese (Traditional)"; + case MENU_ENUM_LABEL_VALUE_LANG_CHINESE_SIMPLIFIED: + return "Chinese (Simplified)"; + case MENU_ENUM_LABEL_VALUE_LANG_ESPERANTO: + return "Esperanto"; + case MENU_ENUM_LABEL_VALUE_LANG_VIETNAMESE: + return "Tiếng Việt"; + case MENU_ENUM_LABEL_VALUE_LEFT_ANALOG: + return "Left Analog"; + case MENU_ENUM_LABEL_VALUE_RIGHT_ANALOG: + return "Right Analog"; + case MENU_ENUM_LABEL_VALUE_INPUT_HOTKEY_BINDS: + return "Input Hotkey Binds"; + case MENU_ENUM_LABEL_VALUE_FRAME_THROTTLE_SETTINGS: + return "Frame Throttle"; + case MENU_ENUM_LABEL_VALUE_SEARCH: + return "Search:"; + case MENU_ENUM_LABEL_VALUE_USE_BUILTIN_IMAGE_VIEWER: + return "Use Builtin Image Viewer"; + case MENU_ENUM_LABEL_VALUE_ENABLE: + return "Enable"; + case MENU_ENUM_LABEL_VALUE_START_CORE: + return "Start Core"; + case MENU_ENUM_LABEL_VALUE_INPUT_POLL_TYPE_BEHAVIOR: + return "Poll Type Behavior"; + case MENU_ENUM_LABEL_VALUE_BASIC_MENU_CONTROLS_SCROLL_UP: + return "Scroll Up"; + case MENU_ENUM_LABEL_VALUE_BASIC_MENU_CONTROLS_SCROLL_DOWN: + return "Scroll Down"; + case MENU_ENUM_LABEL_VALUE_BASIC_MENU_CONTROLS_CONFIRM: + return "Confirm"; + case MENU_ENUM_LABEL_VALUE_BASIC_MENU_CONTROLS_BACK: + return "Back"; + case MENU_ENUM_LABEL_VALUE_BASIC_MENU_CONTROLS_START: + return "Start"; + case MENU_ENUM_LABEL_VALUE_BASIC_MENU_CONTROLS_INFO: + return "Info"; + case MENU_ENUM_LABEL_VALUE_BASIC_MENU_CONTROLS_TOGGLE_MENU: + return "Toggle Menu"; + case MENU_ENUM_LABEL_VALUE_BASIC_MENU_CONTROLS_QUIT: + return "Quit"; + case MENU_ENUM_LABEL_VALUE_BASIC_MENU_CONTROLS_TOGGLE_KEYBOARD: + return "Toggle Keyboard"; + case MENU_ENUM_LABEL_VALUE_THUMBNAIL_MODE_SCREENSHOTS: + return "Screenshots"; + case MENU_ENUM_LABEL_VALUE_THUMBNAIL_MODE_TITLE_SCREENS: + return "Title Screens"; + case MENU_ENUM_LABEL_VALUE_THUMBNAIL_MODE_BOXARTS: + return "Boxarts"; + case MENU_ENUM_LABEL_VALUE_MENU_WALLPAPER_OPACITY: + return "Wallpaper opacity"; + case MENU_ENUM_LABEL_VALUE_INPUT_JOYPAD_B: + return "B button (down)"; + case MENU_ENUM_LABEL_VALUE_INPUT_JOYPAD_Y: + return "Y button (left)"; + case MENU_ENUM_LABEL_VALUE_INPUT_JOYPAD_SELECT: + return "Select button"; + case MENU_ENUM_LABEL_VALUE_INPUT_JOYPAD_START: + return "Start button"; + case MENU_ENUM_LABEL_VALUE_INPUT_JOYPAD_UP: + return "Up D-pad"; + case MENU_ENUM_LABEL_VALUE_INPUT_JOYPAD_DOWN: + return "Down D-pad"; + case MENU_ENUM_LABEL_VALUE_INPUT_JOYPAD_LEFT: + return "Left D-pad"; + case MENU_ENUM_LABEL_VALUE_INPUT_JOYPAD_RIGHT: + return "Right D-pad"; + case MENU_ENUM_LABEL_VALUE_INPUT_JOYPAD_A: + return "A button (right)"; + case MENU_ENUM_LABEL_VALUE_INPUT_JOYPAD_X: + return "X button (top)"; + case MENU_ENUM_LABEL_VALUE_INPUT_JOYPAD_L: + return "L button (shoulder)"; + case MENU_ENUM_LABEL_VALUE_INPUT_JOYPAD_R: + return "R button (shoulder)"; + case MENU_ENUM_LABEL_VALUE_INPUT_JOYPAD_L2: + return "L2 button (trigger)"; + case MENU_ENUM_LABEL_VALUE_INPUT_JOYPAD_R2: + return "R2 button (trigger)"; + case MENU_ENUM_LABEL_VALUE_INPUT_JOYPAD_L3: + return "L3 button (thumb)"; + case MENU_ENUM_LABEL_VALUE_INPUT_JOYPAD_R3: + return "R3 button (thumb)"; + case MENU_ENUM_LABEL_VALUE_INPUT_ANALOG_LEFT_X: + return "Left Analog X"; + case MENU_ENUM_LABEL_VALUE_INPUT_ANALOG_LEFT_Y: + return "Left Analog Y"; + case MENU_ENUM_LABEL_VALUE_INPUT_ANALOG_RIGHT_X: + return "Right Analog X"; + case MENU_ENUM_LABEL_VALUE_INPUT_ANALOG_RIGHT_Y: + return "Right Analog Y"; + case MENU_ENUM_LABEL_VALUE_INPUT_ANALOG_LEFT_X_PLUS: + return "Left analog X+ (right)"; + case MENU_ENUM_LABEL_VALUE_INPUT_ANALOG_LEFT_X_MINUS: + return "Left analog X- (left)"; + case MENU_ENUM_LABEL_VALUE_INPUT_ANALOG_LEFT_Y_PLUS: + return "Left analog Y+ (down)"; + case MENU_ENUM_LABEL_VALUE_INPUT_ANALOG_LEFT_Y_MINUS: + return "Left analog Y- (up)"; + case MENU_ENUM_LABEL_VALUE_INPUT_ANALOG_RIGHT_X_PLUS: + return "Right analog X+ (right)"; + case MENU_ENUM_LABEL_VALUE_INPUT_ANALOG_RIGHT_X_MINUS: + return "Right analog X- (left)"; + case MENU_ENUM_LABEL_VALUE_INPUT_ANALOG_RIGHT_Y_PLUS: + return "Right analog Y+ (down)"; + case MENU_ENUM_LABEL_VALUE_INPUT_ANALOG_RIGHT_Y_MINUS: + return "Right analog Y- (up)"; + case MENU_ENUM_LABEL_VALUE_INPUT_TURBO_ENABLE: + return "Turbo enable"; + case MENU_ENUM_LABEL_VALUE_INPUT_META_FAST_FORWARD_KEY: + return "Fast forward toggle"; + case MENU_ENUM_LABEL_VALUE_INPUT_META_FAST_FORWARD_HOLD_KEY: + return "Fast forward hold"; + case MENU_ENUM_LABEL_VALUE_INPUT_META_LOAD_STATE_KEY: + return "Load state"; + case MENU_ENUM_LABEL_VALUE_INPUT_META_SAVE_STATE_KEY: + return "Save state"; + case MENU_ENUM_LABEL_VALUE_INPUT_META_FULLSCREEN_TOGGLE_KEY: + return "Fullscreen toggle"; + case MENU_ENUM_LABEL_VALUE_INPUT_META_QUIT_KEY: + return "Quit RetroArch"; + case MENU_ENUM_LABEL_VALUE_INPUT_META_STATE_SLOT_PLUS: + return "Savestate slot +"; + case MENU_ENUM_LABEL_VALUE_INPUT_META_STATE_SLOT_MINUS: + return "Savestate slot -"; + case MENU_ENUM_LABEL_VALUE_INPUT_META_REWIND: + return "Rewind"; + case MENU_ENUM_LABEL_VALUE_INPUT_META_MOVIE_RECORD_TOGGLE: + return "Movie record toggle"; + case MENU_ENUM_LABEL_VALUE_INPUT_META_PAUSE_TOGGLE: + return "Pause toggle"; + case MENU_ENUM_LABEL_VALUE_INPUT_META_FRAMEADVANCE: + return "Frameadvance"; + case MENU_ENUM_LABEL_VALUE_INPUT_META_RESET: + return "Reset game"; + case MENU_ENUM_LABEL_VALUE_INPUT_META_SHADER_NEXT: + return "Next shader"; + case MENU_ENUM_LABEL_VALUE_INPUT_META_SHADER_PREV: + return "Previous shader"; + case MENU_ENUM_LABEL_VALUE_INPUT_META_CHEAT_INDEX_PLUS: + return "Cheat index +"; + case MENU_ENUM_LABEL_VALUE_INPUT_META_CHEAT_INDEX_MINUS: + return "Cheat index -"; + case MENU_ENUM_LABEL_VALUE_INPUT_META_CHEAT_TOGGLE: + return "Cheat toggle"; + case MENU_ENUM_LABEL_VALUE_INPUT_META_SCREENSHOT: + return "Take screenshot"; + case MENU_ENUM_LABEL_VALUE_INPUT_META_MUTE: + return "Audio mute toggle"; + case MENU_ENUM_LABEL_VALUE_INPUT_META_OSK: + return "On-screen keyboard toggle"; + case MENU_ENUM_LABEL_VALUE_INPUT_META_NETPLAY_FLIP: + return "Netplay flip users"; + case MENU_ENUM_LABEL_VALUE_INPUT_META_SLOWMOTION: + return "Slow motion"; + case MENU_ENUM_LABEL_VALUE_INPUT_META_ENABLE_HOTKEY: + return "Enable hotkeys"; + case MENU_ENUM_LABEL_VALUE_INPUT_META_VOLUME_UP: + return "Volume +"; + case MENU_ENUM_LABEL_VALUE_INPUT_META_VOLUME_DOWN: + return "Volume -"; + case MENU_ENUM_LABEL_VALUE_INPUT_META_OVERLAY_NEXT: + return "Overlay next"; + case MENU_ENUM_LABEL_VALUE_INPUT_META_DISK_EJECT_TOGGLE: + return "Disk eject toggle"; + case MENU_ENUM_LABEL_VALUE_INPUT_META_DISK_NEXT: + return "Disk next"; + case MENU_ENUM_LABEL_VALUE_INPUT_META_DISK_PREV: + return "Disk prev"; + case MENU_ENUM_LABEL_VALUE_INPUT_META_GRAB_MOUSE_TOGGLE: + return "Grab mouse toggle"; + case MENU_ENUM_LABEL_VALUE_INPUT_META_MENU_TOGGLE: + return "Menu toggle"; + case MENU_ENUM_LABEL_VALUE_INPUT_DEVICE_INDEX: + return "Device Index"; + case MENU_ENUM_LABEL_VALUE_INPUT_DEVICE_TYPE: + return "Device Type"; + case MENU_ENUM_LABEL_VALUE_INPUT_ADC_TYPE: + return "Analog To Digital Type"; + case MENU_ENUM_LABEL_VALUE_INPUT_BIND_ALL: + return "Bind All"; + case MENU_ENUM_LABEL_VALUE_INPUT_BIND_DEFAULT_ALL: + return "Bind Default All"; + case MENU_ENUM_LABEL_VALUE_INPUT_SAVE_AUTOCONFIG: + return "Save Autoconfig"; + default: +#if 0 + RARCH_LOG("Unimplemented: [%d]\n", msg); +#endif + break; + } + + return "null"; +} diff --git a/lakka.h b/lakka.h index 54c3e7513c..f1659d2ef8 100644 --- a/lakka.h +++ b/lakka.h @@ -1,6 +1,7 @@ /* RetroArch - A frontend for libretro. * Copyright (C) 2010-2014 - Hans-Kristian Arntzen * Copyright (C) 2011-2016 - Daniel De Matteis + * Copyright (C) 2014-2016 - Jean-André Santoni * * 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- diff --git a/libretro-common/file/archive_file.c b/libretro-common/file/archive_file.c index 4a623557f9..3ac2d12db6 100644 --- a/libretro-common/file/archive_file.c +++ b/libretro-common/file/archive_file.c @@ -354,7 +354,10 @@ end: if (handle) { if (handle->backend) - handle->backend->stream_free(handle->stream); + { + if (handle->backend->stream_free) + handle->backend->stream_free(handle->stream); + } if (handle->data) free(handle->data); @@ -426,7 +429,8 @@ int file_archive_parse_file_iterate( } if (state->stream && state->backend) { - state->backend->stream_free(state->stream); + if (state->backend->stream_free) + state->backend->stream_free(state->stream); if (state->stream) free(state->stream); diff --git a/libretro-common/file/archive_file_zlib.c b/libretro-common/file/archive_file_zlib.c index c7577b2607..0269dea358 100644 --- a/libretro-common/file/archive_file_zlib.c +++ b/libretro-common/file/archive_file_zlib.c @@ -431,22 +431,18 @@ static int zip_parse_file_iterate_step_internal( } static int zip_parse_file_iterate_step(file_archive_transfer_t *state, - const char *valid_exts, struct archive_extract_userdata *userdata, file_archive_file_cb file_cb) + const char *valid_exts, struct archive_extract_userdata *userdata, + file_archive_file_cb file_cb) { - char filename[PATH_MAX_LENGTH]; - int ret; - const uint8_t *cdata = NULL; - uint32_t checksum = 0; - uint32_t size = 0; - uint32_t csize = 0; - unsigned cmode = 0; - unsigned payload = 0; - - filename[0] = '\0'; - - ret = zip_parse_file_iterate_step_internal(state, filename, - &cdata, &cmode, &size, &csize, - &checksum, &payload); + char filename[PATH_MAX_LENGTH] = {0}; + const uint8_t *cdata = NULL; + uint32_t checksum = 0; + uint32_t size = 0; + uint32_t csize = 0; + unsigned cmode = 0; + unsigned payload = 0; + int ret = zip_parse_file_iterate_step_internal( + state, filename, &cdata, &cmode, &size, &csize, &checksum, &payload); if (ret != 1) return ret; diff --git a/libretro-common/file/config_file.c b/libretro-common/file/config_file.c index 70c0984d1d..5f9dc1ffcb 100644 --- a/libretro-common/file/config_file.c +++ b/libretro-common/file/config_file.c @@ -399,6 +399,7 @@ static config_file_t *config_file_new_internal( free(conf->path); goto error; } + setvbuf(file, NULL, _IOFBF, 0x4000); while (!feof(file)) { @@ -890,6 +891,7 @@ bool config_file_write(config_file_t *conf, const char *path) file = fopen(path, "w"); if (!file) return false; + setvbuf(file, NULL, _IOFBF, 0x4000); } else file = stdout; diff --git a/libretro-common/include/libretro.h b/libretro-common/include/libretro.h index d1f4674e7f..1e10f4ef71 100644 --- a/libretro-common/include/libretro.h +++ b/libretro-common/include/libretro.h @@ -244,6 +244,7 @@ enum retro_language RETRO_LANGUAGE_CHINESE_SIMPLIFIED = 11, RETRO_LANGUAGE_ESPERANTO = 12, RETRO_LANGUAGE_POLISH = 13, + RETRO_LANGUAGE_VIETNAMESE = 14, RETRO_LANGUAGE_LAST, /* Ensure sizeof(enum) == sizeof(int) */ diff --git a/list_special.c b/list_special.c index 235f77ff96..5acfb61a51 100644 --- a/list_special.c +++ b/list_special.c @@ -1,6 +1,7 @@ /* RetroArch - A frontend for libretro. * Copyright (C) 2010-2014 - Hans-Kristian Arntzen * Copyright (C) 2011-2016 - Daniel De Matteis + * Copyright (C) 2016 - Brad Parker * * 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- diff --git a/list_special.h b/list_special.h index 709b4cb90a..b8995b0af0 100644 --- a/list_special.h +++ b/list_special.h @@ -1,6 +1,7 @@ /* RetroArch - A frontend for libretro. * Copyright (C) 2010-2014 - Hans-Kristian Arntzen * Copyright (C) 2011-2016 - Daniel De Matteis + * Copyright (C) 2016 - Brad Parker * * 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- diff --git a/managers/cheat_manager.c b/managers/cheat_manager.c index ad01f7e4a5..55cabb7039 100644 --- a/managers/cheat_manager.c +++ b/managers/cheat_manager.c @@ -1,7 +1,7 @@ /* RetroArch - A frontend for libretro. * Copyright (C) 2010-2014 - Hans-Kristian Arntzen * Copyright (C) 2011-2016 - 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. @@ -97,7 +97,9 @@ void cheat_manager_apply_cheats(void) core_set_cheat(&cheat_info); } } - + runloop_msg_queue_push("Applying cheat changes.", 1, 180, true); + RARCH_LOG("Applying cheat changes.\n"); + #ifdef HAVE_CHEEVOS data_bool = idx != 0; cheevos_apply_cheats(&data_bool); @@ -137,7 +139,7 @@ bool cheat_manager_save(const char *path) path, sizeof(buf)); fill_pathname_noext(cheats_file, buf, ".cht", sizeof(cheats_file)); - + conf = config_file_new(cheats_file); if (!conf) @@ -340,7 +342,7 @@ void cheat_manager_update(cheat_manager_t *handle, unsigned handle_idx) snprintf(msg, sizeof(msg), "Cheat: #%u [%s]: %s", handle_idx, handle->cheats[handle_idx].state ? "ON" : "OFF", - (handle->cheats[handle_idx].desc) ? + (handle->cheats[handle_idx].desc) ? (handle->cheats[handle_idx].desc) : (handle->cheats[handle_idx].code) ); runloop_msg_queue_push(msg, 1, 180, true); diff --git a/menu/cbs/menu_cbs_get_value.c b/menu/cbs/menu_cbs_get_value.c index 9daf1d1cac..48a5c40cd4 100644 --- a/menu/cbs/menu_cbs_get_value.c +++ b/menu/cbs/menu_cbs_get_value.c @@ -1545,12 +1545,16 @@ static void menu_action_setting_disp_set_label_setting_bool(file_list_t* list, { rarch_setting_t *setting = menu_setting_find(list->list[i].label); + *s = '\0'; *w = 19; - if (*setting->value.target.boolean) - strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_ON), len); - else - strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_OFF), len); + if (setting) + { + if (*setting->value.target.boolean) + strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_ON), len); + else + strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_OFF), len); + } strlcpy(s2, path, len2); } @@ -1581,11 +1585,12 @@ static void menu_action_setting_disp_set_label_setting_path(file_list_t* list, char *s2, size_t len2) { rarch_setting_t *setting = menu_setting_find(list->list[i].label); - const char *basename = path_basename(setting->value.target.string); + const char *basename = setting ? path_basename(setting->value.target.string) : NULL; *w = 19; - strlcpy(s, basename, len); + if (!string_is_empty(basename)) + strlcpy(s, basename, len); strlcpy(s2, path, len2); } diff --git a/menu/cbs/menu_cbs_ok.c b/menu/cbs/menu_cbs_ok.c index fe664b1848..0bafbca650 100644 --- a/menu/cbs/menu_cbs_ok.c +++ b/menu/cbs/menu_cbs_ok.c @@ -1,5 +1,6 @@ /* RetroArch - A frontend for libretro. * Copyright (C) 2011-2016 - Daniel De Matteis + * Copyright (C) 2016 - Brad Parker * * 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- diff --git a/menu/drivers/materialui.c b/menu/drivers/materialui.c index af25eae791..bb76758d72 100644 --- a/menu/drivers/materialui.c +++ b/menu/drivers/materialui.c @@ -1,6 +1,7 @@ /* RetroArch - A frontend for libretro. * Copyright (C) 2011-2016 - Daniel De Matteis - * Copyright (C) 2014-2015 - Jean-André Santoni + * Copyright (C) 2014-2016 - Jean-André Santoni + * Copyright (C) 2016 - Brad Parker * * 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- diff --git a/menu/drivers/menu_generic.c b/menu/drivers/menu_generic.c index 7da95506e9..a22f8154d8 100644 --- a/menu/drivers/menu_generic.c +++ b/menu/drivers/menu_generic.c @@ -2,6 +2,7 @@ * Copyright (C) 2010-2014 - Hans-Kristian Arntzen * Copyright (C) 2011-2016 - Daniel De Matteis * Copyright (C) 2012-2015 - Michael Lelli + * Copyright (C) 2016 - Brad Parker * * 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- diff --git a/menu/drivers/rgui.c b/menu/drivers/rgui.c index 226bc5fc1a..a40be48572 100644 --- a/menu/drivers/rgui.c +++ b/menu/drivers/rgui.c @@ -2,6 +2,7 @@ * Copyright (C) 2010-2014 - Hans-Kristian Arntzen * Copyright (C) 2011-2016 - Daniel De Matteis * Copyright (C) 2012-2015 - Michael Lelli + * Copyright (C) 2016 - Brad Parker * * 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- diff --git a/menu/drivers/xmb.c b/menu/drivers/xmb.c index b294e48ab3..4677896684 100644 --- a/menu/drivers/xmb.c +++ b/menu/drivers/xmb.c @@ -1,6 +1,7 @@ /* RetroArch - A frontend for libretro. * Copyright (C) 2011-2016 - Daniel De Matteis - * Copyright (C) 2014-2015 - Jean-André Santoni + * Copyright (C) 2014-2016 - Jean-André Santoni + * Copyright (C) 2016 - Brad Parker * * 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- diff --git a/menu/menu_animation.c b/menu/menu_animation.c index 1f2bfe3e87..175ac1998f 100644 --- a/menu/menu_animation.c +++ b/menu/menu_animation.c @@ -1,5 +1,5 @@ /* RetroArch - A frontend for libretro. - * Copyright (C) 2014-2015 - Jean-André Santoni + * Copyright (C) 2014-2016 - Jean-André Santoni * Copyright (C) 2011-2016 - Daniel De Matteis * * RetroArch is free software: you can redistribute it and/or modify it under the terms diff --git a/menu/menu_animation.h b/menu/menu_animation.h index 792bf4d60a..71daa5219a 100644 --- a/menu/menu_animation.h +++ b/menu/menu_animation.h @@ -1,5 +1,5 @@ /* RetroArch - A frontend for libretro. - * Copyright (C) 2014-2015 - Jean-André Santoni + * Copyright (C) 2014-2016 - Jean-André Santoni * Copyright (C) 2011-2016 - Daniel De Matteis * * RetroArch is free software: you can redistribute it and/or modify it under the terms diff --git a/menu/menu_display.c b/menu/menu_display.c index 72a3a38f64..7a05239a5b 100644 --- a/menu/menu_display.c +++ b/menu/menu_display.c @@ -1,5 +1,7 @@ /* RetroArch - A frontend for libretro. * Copyright (C) 2011-2016 - Daniel De Matteis + * Copyright (C) 2014-2016 - Jean-André Santoni + * Copyright (C) 2016 - Brad Parker * * 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- diff --git a/menu/menu_display.h b/menu/menu_display.h index a000a953a0..5801964d4d 100644 --- a/menu/menu_display.h +++ b/menu/menu_display.h @@ -1,5 +1,7 @@ /* RetroArch - A frontend for libretro. * Copyright (C) 2011-2016 - Daniel De Matteis + * Copyright (C) 2014-2016 - Jean-André Santoni + * Copyright (C) 2016 - Brad Parker * * 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- diff --git a/menu/menu_displaylist.c b/menu/menu_displaylist.c index 56739e7754..2789dd1e07 100644 --- a/menu/menu_displaylist.c +++ b/menu/menu_displaylist.c @@ -1,5 +1,7 @@ /* RetroArch - A frontend for libretro. * Copyright (C) 2011-2016 - Daniel De Matteis + * Copyright (C) 2014-2016 - Jean-André Santoni + * Copyright (C) 2016 - Brad Parker * * 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- @@ -2722,19 +2724,19 @@ static int menu_displaylist_parse_load_content_settings( MENU_ENUM_LABEL_SHADER_OPTIONS, MENU_SETTING_ACTION, 0, 0); #endif - + menu_entries_append_enum(info->list, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_SAVE_CURRENT_CONFIG_OVERRIDE_CORE), msg_hash_to_str(MENU_ENUM_LABEL_SAVE_CURRENT_CONFIG_OVERRIDE_CORE), MENU_ENUM_LABEL_SAVE_CURRENT_CONFIG_OVERRIDE_CORE, MENU_SETTING_ACTION, 0, 0); - + menu_entries_append_enum(info->list, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_SAVE_CURRENT_CONFIG_OVERRIDE_GAME), msg_hash_to_str(MENU_ENUM_LABEL_SAVE_CURRENT_CONFIG_OVERRIDE_GAME), MENU_ENUM_LABEL_SAVE_CURRENT_CONFIG_OVERRIDE_GAME, MENU_SETTING_ACTION, 0, 0); - + #ifdef HAVE_CHEEVOS if(settings->cheevos.enable) menu_entries_append_enum(info->list, @@ -3038,6 +3040,11 @@ static int menu_displaylist_parse_options_cheats( if (!cheat_manager_alloc_if_empty()) return -1; + menu_entries_append_enum(info->list, + msg_hash_to_str(MENU_ENUM_LABEL_VALUE_CHEAT_APPLY_CHANGES), + msg_hash_to_str(MENU_ENUM_LABEL_CHEAT_APPLY_CHANGES), + MENU_ENUM_LABEL_CHEAT_APPLY_CHANGES, + MENU_SETTING_ACTION, 0, 0); menu_entries_append_enum(info->list, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_CHEAT_FILE_LOAD), msg_hash_to_str(MENU_ENUM_LABEL_CHEAT_FILE_LOAD), @@ -3053,11 +3060,6 @@ static int menu_displaylist_parse_options_cheats( msg_hash_to_str(MENU_ENUM_LABEL_CHEAT_NUM_PASSES), MENU_ENUM_LABEL_CHEAT_NUM_PASSES, 0, 0, 0); - menu_entries_append_enum(info->list, - msg_hash_to_str(MENU_ENUM_LABEL_VALUE_CHEAT_APPLY_CHANGES), - msg_hash_to_str(MENU_ENUM_LABEL_CHEAT_APPLY_CHANGES), - MENU_ENUM_LABEL_CHEAT_APPLY_CHANGES, - MENU_SETTING_ACTION, 0, 0); for (i = 0; i < cheat_manager_get_size(); i++) { diff --git a/menu/menu_driver.c b/menu/menu_driver.c index 2b6ff3d5fd..afe39fd68a 100644 --- a/menu/menu_driver.c +++ b/menu/menu_driver.c @@ -1,6 +1,7 @@ /* RetroArch - A frontend for libretro. * Copyright (C) 2010-2014 - Hans-Kristian Arntzen * Copyright (C) 2011-2016 - Daniel De Matteis + * Copyright (C) 2016 - Brad Parker * * 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- diff --git a/menu/menu_driver.h b/menu/menu_driver.h index b8f1c3e7f5..a9986ae907 100644 --- a/menu/menu_driver.h +++ b/menu/menu_driver.h @@ -1,6 +1,7 @@ /* RetroArch - A frontend for libretro. * Copyright (C) 2010-2014 - Hans-Kristian Arntzen * Copyright (C) 2011-2016 - Daniel De Matteis + * Copyright (C) 2016 - Brad Parker * * 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- @@ -216,14 +217,13 @@ enum menu_settings_type typedef struct { char deferred_path[PATH_MAX_LENGTH]; - char scratch_buf[PATH_MAX_LENGTH]; char scratch2_buf[PATH_MAX_LENGTH]; uint64_t state; struct { - char msg[PATH_MAX_LENGTH]; + char msg[255]; } menu_state; char db_playlist_file[PATH_MAX_LENGTH]; diff --git a/menu/menu_event.c b/menu/menu_event.c index bda5cc502b..1ab6844a51 100644 --- a/menu/menu_event.c +++ b/menu/menu_event.c @@ -1,6 +1,7 @@ /* RetroArch - A frontend for libretro. * Copyright (C) 2010-2014 - Hans-Kristian Arntzen * Copyright (C) 2011-2016 - Daniel De Matteis + * Copyright (C) 2014-2016 - Jean-André Santoni * * 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- diff --git a/menu/menu_input.h b/menu/menu_input.h index ca19e665aa..90e30e3c3b 100644 --- a/menu/menu_input.h +++ b/menu/menu_input.h @@ -1,6 +1,7 @@ /* RetroArch - A frontend for libretro. * Copyright (C) 2010-2014 - Hans-Kristian Arntzen * Copyright (C) 2011-2016 - Daniel De Matteis + * Copyright (C) 2016 - Brad Parker * * 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- diff --git a/menu/menu_setting.c b/menu/menu_setting.c index 0aea94431d..9908605850 100644 --- a/menu/menu_setting.c +++ b/menu/menu_setting.c @@ -1,6 +1,8 @@ /* RetroArch - A frontend for libretro. * Copyright (C) 2010-2014 - Hans-Kristian Arntzen * Copyright (C) 2011-2016 - Daniel De Matteis + * Copyright (C) 2014-2016 - Jean-André Santoni + * Copyright (C) 2016 - Brad Parker * * 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- @@ -468,6 +470,7 @@ static void setting_get_string_representation_uint_user_language(void *data, modes[RETRO_LANGUAGE_CHINESE_SIMPLIFIED] = msg_hash_to_str(MENU_ENUM_LABEL_VALUE_LANG_CHINESE_SIMPLIFIED); modes[RETRO_LANGUAGE_ESPERANTO] = msg_hash_to_str(MENU_ENUM_LABEL_VALUE_LANG_ESPERANTO); modes[RETRO_LANGUAGE_POLISH] = msg_hash_to_str(MENU_ENUM_LABEL_VALUE_LANG_POLISH); + modes[RETRO_LANGUAGE_VIETNAMESE] = msg_hash_to_str(MENU_ENUM_LABEL_VALUE_LANG_VIETNAMESE); if (settings) strlcpy(s, modes[settings->user_language], len); diff --git a/menu/widgets/menu_dialog.c b/menu/widgets/menu_dialog.c index fcb86a8ba2..dc4fc34393 100644 --- a/menu/widgets/menu_dialog.c +++ b/menu/widgets/menu_dialog.c @@ -1,5 +1,6 @@ /* RetroArch - A frontend for libretro. * Copyright (C) 2011-2016 - Daniel De Matteis + * Copyright (C) 2016 - Brad Parker * * 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- diff --git a/menu/widgets/menu_dialog.h b/menu/widgets/menu_dialog.h index 90c9eb80ba..0d2975478f 100644 --- a/menu/widgets/menu_dialog.h +++ b/menu/widgets/menu_dialog.h @@ -1,6 +1,7 @@ /* RetroArch - A frontend for libretro. * Copyright (C) 2010-2014 - Hans-Kristian Arntzen * Copyright (C) 2011-2016 - Daniel De Matteis + * Copyright (C) 2016 - Brad Parker * * 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- diff --git a/msg_hash.c b/msg_hash.c index d2f1f3a0e8..36895f3742 100644 --- a/msg_hash.c +++ b/msg_hash.c @@ -1,5 +1,6 @@ /* RetroArch - A frontend for libretro. * Copyright (C) 2011-2016 - Daniel De Matteis + * Copyright (C) 2016 - Brad Parker * * 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- @@ -64,6 +65,9 @@ int menu_hash_get_help_enum(enum msg_hash_enums msg, char *s, size_t len) case RETRO_LANGUAGE_JAPANESE: ret = menu_hash_get_help_jp_enum(msg, s, len); break; + case RETRO_LANGUAGE_VIETNAMESE: + ret = menu_hash_get_help_vn_enum(msg, s, len); + break; default: break; } @@ -117,6 +121,9 @@ const char *msg_hash_to_str(enum msg_hash_enums msg) case RETRO_LANGUAGE_JAPANESE: ret = msg_hash_to_str_jp(msg); break; + case RETRO_LANGUAGE_VIETNAMESE: + ret = msg_hash_to_str_vn(msg); + break; default: break; } diff --git a/msg_hash.h b/msg_hash.h index cda9932697..2109169779 100644 --- a/msg_hash.h +++ b/msg_hash.h @@ -1,6 +1,7 @@ /* RetroArch - A frontend for libretro. * Copyright (C) 2010-2014 - Hans-Kristian Arntzen * Copyright (C) 2011-2016 - Daniel De Matteis + * Copyright (C) 2016 - Brad Parker * * 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- @@ -1858,6 +1859,7 @@ enum msg_hash_enums MENU_ENUM_LABEL_VALUE_LANG_CHINESE_SIMPLIFIED, MENU_ENUM_LABEL_VALUE_LANG_ESPERANTO, MENU_ENUM_LABEL_VALUE_LANG_POLISH, + MENU_ENUM_LABEL_VALUE_LANG_VIETNAMESE, MENU_ENUM_LABEL_VALUE_NONE, @@ -2237,6 +2239,9 @@ int menu_hash_get_help_pl_enum(enum msg_hash_enums msg, char *s, size_t len); const char *msg_hash_to_str_nl(enum msg_hash_enums msg); int menu_hash_get_help_nl_enum(enum msg_hash_enums msg, char *s, size_t len); +const char *msg_hash_to_str_vn(enum msg_hash_enums msg); +int menu_hash_get_help_vn_enum(enum msg_hash_enums msg, char *s, size_t len); + const char *msg_hash_to_str_us(enum msg_hash_enums msg); int menu_hash_get_help_us_enum(enum msg_hash_enums msg, char *s, size_t len); diff --git a/network/net_http_special.c b/network/net_http_special.c index ca92f092ac..cda037c098 100644 --- a/network/net_http_special.c +++ b/network/net_http_special.c @@ -1,6 +1,7 @@ /* RetroArch - A frontend for libretro. * Copyright (C) 2011-2016 - Daniel De Matteis * Copyright (C) 2015-2016 - Andre Leiradella + * Copyright (C) 2016 - Brad Parker * * 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- diff --git a/runloop.c b/runloop.c index 2ea2809cd6..eac56ebdd8 100644 --- a/runloop.c +++ b/runloop.c @@ -3,6 +3,7 @@ * Copyright (C) 2011-2016 - Daniel De Matteis * Copyright (C) 2012-2015 - Michael Lelli * Copyright (C) 2014-2015 - Jay McCarthy + * Copyright (C) 2016 - Brad Parker * * 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- diff --git a/runloop.h b/runloop.h index dd2d1ea1d3..335567a8fa 100644 --- a/runloop.h +++ b/runloop.h @@ -1,5 +1,6 @@ /* RetroArch - A frontend for libretro. * Copyright (C) 2011-2016 - Daniel De Matteis + * Copyright (C) 2016 - Brad Parker * * 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- diff --git a/setting_list.c b/setting_list.c index 44699be400..7b8d0b563d 100644 --- a/setting_list.c +++ b/setting_list.c @@ -80,6 +80,8 @@ rarch_setting_t setting_terminator_setting(void) result.enforce_minrange = false; result.enforce_maxrange = false; + result.dont_use_enum_idx_representation = false; + return result; } @@ -742,6 +744,7 @@ static rarch_setting_t setting_group_setting(enum setting_type type, const char* result.enforce_minrange = false; result.enforce_maxrange = false; + result.dont_use_enum_idx_representation = false; return result; } diff --git a/tasks/task_content.c b/tasks/task_content.c index 9f989251c0..343ba346f1 100644 --- a/tasks/task_content.c +++ b/tasks/task_content.c @@ -1,5 +1,6 @@ /* RetroArch - A frontend for libretro. * Copyright (C) 2011-2016 - Daniel De Matteis + * Copyright (C) 2016 - Brad Parker * * 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- diff --git a/tasks/task_database.c b/tasks/task_database.c index b18cb204dc..1504ee3f4e 100644 --- a/tasks/task_database.c +++ b/tasks/task_database.c @@ -1,5 +1,7 @@ /* RetroArch - A frontend for libretro. * Copyright (C) 2011-2016 - Daniel De Matteis + * Copyright (C) 2014-2016 - Jean-André Santoni + * Copyright (C) 2016 - Brad Parker * * 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- diff --git a/tasks/task_database_cue.c b/tasks/task_database_cue.c index 87561c2084..d0aa73ad10 100644 --- a/tasks/task_database_cue.c +++ b/tasks/task_database_cue.c @@ -1,6 +1,7 @@ /* RetroArch - A frontend for libretro. * Copyright (C) 2011-2016 - Daniel De Matteis * Copyright (C) 2014-2016 - Jean-André Santoni + * Copyright (C) 2016 - Brad Parker * * 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- diff --git a/tasks/task_decompress.c b/tasks/task_decompress.c index 2210ac3d54..43691626e0 100644 --- a/tasks/task_decompress.c +++ b/tasks/task_decompress.c @@ -1,5 +1,6 @@ /* RetroArch - A frontend for libretro. * Copyright (C) 2011-2016 - Daniel De Matteis + * Copyright (C) 2016 - Brad Parker * * 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- diff --git a/tasks/task_save.c b/tasks/task_save.c index 46f4ee883b..b4f499a718 100644 --- a/tasks/task_save.c +++ b/tasks/task_save.c @@ -1,5 +1,6 @@ /* RetroArch - A frontend for libretro. * Copyright (C) 2011-2016 - Daniel De Matteis + * Copyright (C) 2016 - Brad Parker * * 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- diff --git a/tasks/task_screenshot.c b/tasks/task_screenshot.c index f12ec19c49..4647441d57 100644 --- a/tasks/task_screenshot.c +++ b/tasks/task_screenshot.c @@ -1,6 +1,7 @@ /* RetroArch - A frontend for libretro. * Copyright (C) 2010-2014 - Hans-Kristian Arntzen * Copyright (C) 2011-2016 - Daniel De Matteis + * Copyright (C) 2016 - Brad Parker * * 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- diff --git a/wifi/drivers/connmanctl.c b/wifi/drivers/connmanctl.c index 3396aecdfe..d8e68dd678 100644 --- a/wifi/drivers/connmanctl.c +++ b/wifi/drivers/connmanctl.c @@ -1,5 +1,5 @@ /* RetroArch - A frontend for libretro. - * Copyright (C) 2010-2015 - Michael Lelli + * Copyright (C) 2014-2016 - Jean-André Santoni * * 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- diff --git a/wifi/drivers/nullwifi.c b/wifi/drivers/nullwifi.c index 36a2eb6279..a2e960f8b5 100644 --- a/wifi/drivers/nullwifi.c +++ b/wifi/drivers/nullwifi.c @@ -1,5 +1,5 @@ /* RetroArch - A frontend for libretro. - * Copyright (C) 2010-2015 - Michael Lelli + * Copyright (C) 2014-2016 - Jean-André Santoni * * 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- diff --git a/wifi/wifi_driver.c b/wifi/wifi_driver.c index b9f9bc4ff7..5c0d9c9f8f 100644 --- a/wifi/wifi_driver.c +++ b/wifi/wifi_driver.c @@ -1,6 +1,7 @@ /* RetroArch - A frontend for libretro. * Copyright (C) 2010-2014 - Hans-Kristian Arntzen * Copyright (C) 2011-2016 - Daniel De Matteis + * Copyright (C) 2014-2016 - Jean-André Santoni * * 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- diff --git a/wifi/wifi_driver.h b/wifi/wifi_driver.h index 2ec13f0829..55646255e4 100644 --- a/wifi/wifi_driver.h +++ b/wifi/wifi_driver.h @@ -1,6 +1,7 @@ /* RetroArch - A frontend for libretro. * Copyright (C) 2010-2014 - Hans-Kristian Arntzen * Copyright (C) 2011-2016 - Daniel De Matteis + * Copyright (C) 2014-2016 - Jean-André Santoni * * 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- diff --git a/wiiu/dynamic_libs/acp_functions.c b/wiiu/dynamic_libs/acp_functions.c new file mode 100644 index 0000000000..eb931f84b0 --- /dev/null +++ b/wiiu/dynamic_libs/acp_functions.c @@ -0,0 +1,40 @@ +/**************************************************************************** + * Copyright (C) 2015 + * by Dimok + * + * This software is provided 'as-is', without any express or implied + * warranty. In no event will the authors be held liable for any + * damages arising from the use of this software. + * + * Permission is granted to anyone to use this software for any + * purpose, including commercial applications, and to alter it and + * redistribute it freely, subject to the following restrictions: + * + * 1. The origin of this software must not be misrepresented; you + * must not claim that you wrote the original software. If you use + * this software in a product, an acknowledgment in the product + * documentation would be appreciated but is not required. + * + * 2. Altered source versions must be plainly marked as such, and + * must not be misrepresented as being the original software. + * + * 3. This notice may not be removed or altered from any source + * distribution. + ***************************************************************************/ +#include "os_functions.h" +#include "acp_functions.h" + +unsigned int acp_handle __attribute__((section(".data"))) = 0; + +EXPORT_DECL(void, GetMetaXml, void * _ACPMetaXml); + +void InitAcquireACP(void) +{ + OSDynLoad_Acquire("nn_acp.rpl", &acp_handle); +} + +void InitACPFunctionPointers(void) +{ + InitAcquireACP(); + OSDynLoad_FindExport(acp_handle,0,"GetMetaXml__Q2_2nn3acpFP11_ACPMetaXml",&GetMetaXml); +} diff --git a/wiiu/dynamic_libs/acp_functions.h b/wiiu/dynamic_libs/acp_functions.h new file mode 100644 index 0000000000..dc1822dc35 --- /dev/null +++ b/wiiu/dynamic_libs/acp_functions.h @@ -0,0 +1,42 @@ +/**************************************************************************** + * Copyright (C) 2015 + * by Dimok + * + * This software is provided 'as-is', without any express or implied + * warranty. In no event will the authors be held liable for any + * damages arising from the use of this software. + * + * Permission is granted to anyone to use this software for any + * purpose, including commercial applications, and to alter it and + * redistribute it freely, subject to the following restrictions: + * + * 1. The origin of this software must not be misrepresented; you + * must not claim that you wrote the original software. If you use + * this software in a product, an acknowledgment in the product + * documentation would be appreciated but is not required. + * + * 2. Altered source versions must be plainly marked as such, and + * must not be misrepresented as being the original software. + * + * 3. This notice may not be removed or altered from any source + * distribution. + ***************************************************************************/ +#ifndef __ACP_FUNCTIONS_H_ +#define __ACP_FUNCTIONS_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +#include + +extern unsigned int acp_handle; + +void InitACPFunctionPointers(void); +void InitAcquireACP(void); + +#ifdef __cplusplus +} +#endif + +#endif // __VPAD_FUNCTIONS_H_ diff --git a/wiiu/dynamic_libs/aoc_functions.c b/wiiu/dynamic_libs/aoc_functions.c new file mode 100644 index 0000000000..e74306d9c8 --- /dev/null +++ b/wiiu/dynamic_libs/aoc_functions.c @@ -0,0 +1,58 @@ +/**************************************************************************** + * Copyright (C) 2015 + * by Dimok + * + * This software is provided 'as-is', without any express or implied + * warranty. In no event will the authors be held liable for any + * damages arising from the use of this software. + * + * Permission is granted to anyone to use this software for any + * purpose, including commercial applications, and to alter it and + * redistribute it freely, subject to the following restrictions: + * + * 1. The origin of this software must not be misrepresented; you + * must not claim that you wrote the original software. If you use + * this software in a product, an acknowledgment in the product + * documentation would be appreciated but is not required. + * + * 2. Altered source versions must be plainly marked as such, and + * must not be misrepresented as being the original software. + * + * 3. This notice may not be removed or altered from any source + * distribution. + ***************************************************************************/ +#include "os_functions.h" +#include "aoc_functions.h" + +unsigned int aoc_handle __attribute__((section(".data"))) = 0; + +EXPORT_DECL(s32, AOC_Initialize, void); +EXPORT_DECL(s32, AOC_Finalize, void); +EXPORT_DECL(u32, AOC_CalculateWorkBufferSize, u32 num_titles); +EXPORT_DECL(s32, AOC_ListTitle, u32 * num_titles, void * titles, u32 max_titles, void * buffer, u32 buffer_size); +EXPORT_DECL(s32, AOC_OpenTitle, char* aoc_path, void * title, void * buffer, u32 buffer_size); +EXPORT_DECL(s32, AOC_CloseTitle, void * title); +EXPORT_DECL(s32, AOC_DeleteContent, u64 title_id, u16 contentIndexes[], u32 numberOfContent, void* buffer, u32 buffer_size); +EXPORT_DECL(s32, AOC_GetPurchaseInfo, u32 * bResult, u64 title_id, u16 contentIndexes[], u32 numberOfContent, void * buffer, u32 buffer_size); + +void InitAcquireAoc(void) +{ + OSDynLoad_Acquire("nn_aoc.rpl", &aoc_handle); +} + +void InitAocFunctionPointers(void) +{ + InitAcquireAoc(); + if(aoc_handle == 0) + return; + + //! assigning those is not mandatory and it does not always work to load them + OSDynLoad_FindExport(aoc_handle, 0, "AOC_Initialize", &AOC_Initialize); + OSDynLoad_FindExport(aoc_handle, 0, "AOC_Finalize", &AOC_Finalize); + OSDynLoad_FindExport(aoc_handle, 0, "AOC_CalculateWorkBufferSize", &AOC_CalculateWorkBufferSize); + OSDynLoad_FindExport(aoc_handle, 0, "AOC_ListTitle", &AOC_ListTitle); + OSDynLoad_FindExport(aoc_handle, 0, "AOC_OpenTitle", &AOC_OpenTitle); + OSDynLoad_FindExport(aoc_handle, 0, "AOC_CloseTitle", &AOC_CloseTitle); + OSDynLoad_FindExport(aoc_handle, 0, "AOC_DeleteContent", &AOC_DeleteContent); + OSDynLoad_FindExport(aoc_handle, 0, "AOC_GetPurchaseInfo", &AOC_GetPurchaseInfo); +} diff --git a/wiiu/dynamic_libs/aoc_functions.h b/wiiu/dynamic_libs/aoc_functions.h new file mode 100644 index 0000000000..efca771ab0 --- /dev/null +++ b/wiiu/dynamic_libs/aoc_functions.h @@ -0,0 +1,58 @@ +/**************************************************************************** + * Copyright (C) 2015 + * by Dimok + * + * This software is provided 'as-is', without any express or implied + * warranty. In no event will the authors be held liable for any + * damages arising from the use of this software. + * + * Permission is granted to anyone to use this software for any + * purpose, including commercial applications, and to alter it and + * redistribute it freely, subject to the following restrictions: + * + * 1. The origin of this software must not be misrepresented; you + * must not claim that you wrote the original software. If you use + * this software in a product, an acknowledgment in the product + * documentation would be appreciated but is not required. + * + * 2. Altered source versions must be plainly marked as such, and + * must not be misrepresented as being the original software. + * + * 3. This notice may not be removed or altered from any source + * distribution. + ***************************************************************************/ +#ifndef __AOC_FUNCTIONS_H_ +#define __AOC_FUNCTIONS_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +extern unsigned int aoc_handle; + +#define AOC_TITLE_SIZE 104 + +typedef struct { + u64 title_ID; + u32 group_ID; + u16 version; + char path[88]; +} AOC_TitleListType; + + +void InitAocFunctionPointers(void); +void InitAcquireAoc(void); + +extern s32 (* AOC_Initialize)(void); +extern s32 (* AOC_Finalize)(void); +extern u32 (* AOC_CalculateWorkBufferSize)(u32 num_titles); +extern s32 (* AOC_ListTitle)(u32 * num_titles, void * titles, u32 max_titles, void * buffer, u32 buffer_size); +extern s32 (* AOC_OpenTitle)(char* aoc_path, void * title, void * buffer, u32 buffer_size); +extern s32 (* AOC_CloseTitle)(void * title); +extern s32 (* AOC_DeleteContent)(u64 title_id, u16 contentIndexes[], u32 numberOfContent, void * buffer, u32 buffer_size); +extern s32 (* AOC_GetPurchaseInfo)(u32 * bResult, u64 title_id, u16 contentIndexes[], u32 numberOfContent, void * buffer, u32 buffer_size); +#ifdef __cplusplus +} +#endif + +#endif // __AOC_FUNCTIONS_H_ diff --git a/wiiu/dynamic_libs/ax_functions.c b/wiiu/dynamic_libs/ax_functions.c index d84d6f8450..e517f6d743 100644 --- a/wiiu/dynamic_libs/ax_functions.c +++ b/wiiu/dynamic_libs/ax_functions.c @@ -21,10 +21,14 @@ * 3. This notice may not be removed or altered from any source * distribution. ***************************************************************************/ +#include "common/common.h" #include "os_functions.h" #include "ax_functions.h" +unsigned int sound_handle __attribute__((section(".data"))) = 0; + EXPORT_DECL(void, AXInitWithParams, u32 * params); +EXPORT_DECL(void, AXInit, void); EXPORT_DECL(void, AXQuit, void); EXPORT_DECL(u32, AXGetInputSamplesPerSec, void); EXPORT_DECL(u32, AXGetInputSamplesPerFrame, void); @@ -45,15 +49,35 @@ EXPORT_DECL(u32, AXGetVoiceLoopCount, void *v); EXPORT_DECL(void, AXSetVoiceEndOffset, void *v, u32 offset); EXPORT_DECL(void, AXSetVoiceLoopOffset, void *v, u32 offset); +void InitAcquireAX(void) +{ + unsigned int *funcPointer = 0; + + if(OS_FIRMWARE >= 400) + { + AXInit = 0; + + OSDynLoad_Acquire("sndcore2.rpl", &sound_handle); + OS_FIND_EXPORT(sound_handle, AXInitWithParams); + OS_FIND_EXPORT(sound_handle, AXGetInputSamplesPerSec); + } + else + { + AXInitWithParams = 0; + AXGetInputSamplesPerSec = 0; + + OSDynLoad_Acquire("snd_core.rpl", &sound_handle); + OS_FIND_EXPORT(sound_handle, AXInit); + } +} + void InitAXFunctionPointers(void) { unsigned int *funcPointer = 0; - unsigned int sound_handle; - OSDynLoad_Acquire("sndcore2.rpl", &sound_handle); - OS_FIND_EXPORT(sound_handle, AXInitWithParams); + InitAcquireAX(); + OS_FIND_EXPORT(sound_handle, AXQuit); - OS_FIND_EXPORT(sound_handle, AXGetInputSamplesPerSec); OS_FIND_EXPORT(sound_handle, AXVoiceBegin); OS_FIND_EXPORT(sound_handle, AXVoiceEnd); OS_FIND_EXPORT(sound_handle, AXSetVoiceType); @@ -72,3 +96,23 @@ void InitAXFunctionPointers(void) OS_FIND_EXPORT(sound_handle, AXSetVoiceLoopOffset); } +void ProperlyEndTransitionAudio(void) +{ + bool (* check_os_audio_transition_flag_old)(void); + void (* AXInit_old)(void); + void (* AXQuit_old)(void); + + unsigned int *funcPointer = 0; + unsigned int sound_handle; + OSDynLoad_Acquire("snd_core.rpl", &sound_handle); + + OS_FIND_EXPORT_EX(sound_handle, check_os_audio_transition_flag, check_os_audio_transition_flag_old); + OS_FIND_EXPORT_EX(sound_handle, AXInit, AXInit_old); + OS_FIND_EXPORT_EX(sound_handle, AXQuit, AXQuit_old); + + if (check_os_audio_transition_flag_old()) + { + AXInit_old(); + AXQuit_old(); + } +} diff --git a/wiiu/dynamic_libs/ax_functions.h b/wiiu/dynamic_libs/ax_functions.h index df9647c086..086346f644 100644 --- a/wiiu/dynamic_libs/ax_functions.h +++ b/wiiu/dynamic_libs/ax_functions.h @@ -30,9 +30,14 @@ extern "C" { #include +extern unsigned int sound_handle; + void InitAXFunctionPointers(void); +void InitAcquireAX(void); +void ProperlyEndTransitionAudio(void); extern void (* AXInitWithParams)(u32 * params); +extern void (* AXInit)(void); extern void (* AXQuit)(void); extern u32 (* AXGetInputSamplesPerSec)(void); extern s32 (* AXVoiceBegin)(void *v); diff --git a/wiiu/dynamic_libs/curl_functions.c b/wiiu/dynamic_libs/curl_functions.c new file mode 100644 index 0000000000..d828cdb365 --- /dev/null +++ b/wiiu/dynamic_libs/curl_functions.c @@ -0,0 +1,54 @@ +/**************************************************************************** + * Copyright (C) 2015 + * by Dimok + * + * This software is provided 'as-is', without any express or implied + * warranty. In no event will the authors be held liable for any + * damages arising from the use of this software. + * + * Permission is granted to anyone to use this software for any + * purpose, including commercial applications, and to alter it and + * redistribute it freely, subject to the following restrictions: + * + * 1. The origin of this software must not be misrepresented; you + * must not claim that you wrote the original software. If you use + * this software in a product, an acknowledgment in the product + * documentation would be appreciated but is not required. + * + * 2. Altered source versions must be plainly marked as such, and + * must not be misrepresented as being the original software. + * + * 3. This notice may not be removed or altered from any source + * distribution. + ***************************************************************************/ +#include "os_functions.h" +#include "curl_functions.h" + +unsigned int libcurl_handle __attribute__((section(".data"))) = 0; + +EXPORT_DECL(CURLcode, n_curl_global_init, long flags); +EXPORT_DECL(CURL *, n_curl_easy_init, void); +EXPORT_DECL(CURLcode, n_curl_easy_setopt, CURL *curl, CURLoption option, ...); +EXPORT_DECL(CURLcode, n_curl_easy_perform, CURL *curl); +EXPORT_DECL(void, n_curl_easy_cleanup, CURL *curl); +EXPORT_DECL(CURLcode, n_curl_easy_getinfo, CURL *curl, CURLINFO info, ...); + +void InitAcquireCurl(void) +{ + OSDynLoad_Acquire("nlibcurl", &libcurl_handle); +} + +void InitCurlFunctionPointers(void) +{ + InitAcquireCurl(); + unsigned int *funcPointer = 0; + + OS_FIND_EXPORT_EX(libcurl_handle, curl_global_init, n_curl_global_init); + OS_FIND_EXPORT_EX(libcurl_handle, curl_easy_init, n_curl_easy_init); + OS_FIND_EXPORT_EX(libcurl_handle, curl_easy_setopt, n_curl_easy_setopt); + OS_FIND_EXPORT_EX(libcurl_handle, curl_easy_perform, n_curl_easy_perform); + OS_FIND_EXPORT_EX(libcurl_handle, curl_easy_cleanup, n_curl_easy_cleanup); + OS_FIND_EXPORT_EX(libcurl_handle, curl_easy_getinfo, n_curl_easy_getinfo); + + n_curl_global_init(CURL_GLOBAL_ALL); +} diff --git a/wiiu/dynamic_libs/curl_functions.h b/wiiu/dynamic_libs/curl_functions.h new file mode 100644 index 0000000000..e40740bf0b --- /dev/null +++ b/wiiu/dynamic_libs/curl_functions.h @@ -0,0 +1,51 @@ +/**************************************************************************** + * Copyright (C) 2015 + * by Dimok + * + * This software is provided 'as-is', without any express or implied + * warranty. In no event will the authors be held liable for any + * damages arising from the use of this software. + * + * Permission is granted to anyone to use this software for any + * purpose, including commercial applications, and to alter it and + * redistribute it freely, subject to the following restrictions: + * + * 1. The origin of this software must not be misrepresented; you + * must not claim that you wrote the original software. If you use + * this software in a product, an acknowledgment in the product + * documentation would be appreciated but is not required. + * + * 2. Altered source versions must be plainly marked as such, and + * must not be misrepresented as being the original software. + * + * 3. This notice may not be removed or altered from any source + * distribution. + ***************************************************************************/ +#ifndef __CURL_FUNCTIONS_H_ +#define __CURL_FUNCTIONS_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include "socket_functions.h" +typedef int socklen_t; +#include +#include + +void InitCurlFunctionPointers(void); +void InitAcquireCurl(void); + +extern CURLcode (* n_curl_global_init)(long flags); +extern CURL * (* n_curl_easy_init)(void); +extern CURLcode (* n_curl_easy_setopt)(CURL *curl, CURLoption option, ...); +extern CURLcode (* n_curl_easy_perform)(CURL *curl); +extern void (* n_curl_easy_cleanup)(CURL *curl); +extern CURLcode (* n_curl_easy_getinfo)(CURL *curl, CURLINFO info, ...); + +#ifdef __cplusplus +} +#endif + +#endif // __CURL_FUNCTIONS_H_ diff --git a/wiiu/dynamic_libs/fs_defs.h b/wiiu/dynamic_libs/fs_defs.h new file mode 100644 index 0000000000..1b1bc415f5 --- /dev/null +++ b/wiiu/dynamic_libs/fs_defs.h @@ -0,0 +1,61 @@ +#ifndef FS_DEFS_H +#define FS_DEFS_H + +#include + +#ifdef __cplusplus +extern "C" { +#endif + + +/* FS defines and types */ +#define FS_MAX_LOCALPATH_SIZE 511 +#define FS_MAX_MOUNTPATH_SIZE 128 +#define FS_MAX_FULLPATH_SIZE (FS_MAX_LOCALPATH_SIZE + FS_MAX_MOUNTPATH_SIZE) +#define FS_MAX_ARGPATH_SIZE FS_MAX_FULLPATH_SIZE + +#define FS_STATUS_OK 0 +#define FS_RET_UNSUPPORTED_CMD 0x0400 +#define FS_RET_NO_ERROR 0x0000 +#define FS_RET_ALL_ERROR (unsigned int)(-1) + +#define FS_STAT_FLAG_IS_DIRECTORY 0x80000000 + +/* max length of file/dir name */ +#define FS_MAX_ENTNAME_SIZE 256 + +#define FS_SOURCETYPE_EXTERNAL 0 +#define FS_SOURCETYPE_HFIO 1 + +#define FS_MOUNT_SOURCE_SIZE 0x300 +#define FS_CLIENT_SIZE 0x1700 +#define FS_CMD_BLOCK_SIZE 0xA80 + +typedef struct +{ + uint32_t flag; + uint32_t permission; + uint32_t owner_id; + uint32_t group_id; + uint32_t size; + uint32_t alloc_size; + uint64_t quota_size; + uint32_t ent_id; + uint64_t ctime; + uint64_t mtime; + uint8_t attributes[48]; +} __attribute__((packed)) FSStat; + +typedef struct +{ + FSStat stat; + char name[FS_MAX_ENTNAME_SIZE]; +} FSDirEntry; + + +#ifdef __cplusplus +} +#endif + +#endif /* FS_DEFS_H */ + diff --git a/wiiu/dynamic_libs/fs_functions.c b/wiiu/dynamic_libs/fs_functions.c index cdcc0bfe7b..08a4fb6de7 100644 --- a/wiiu/dynamic_libs/fs_functions.c +++ b/wiiu/dynamic_libs/fs_functions.c @@ -23,7 +23,6 @@ ***************************************************************************/ #include "fs_functions.h" #include "os_functions.h" -#include "utils/utils.h" EXPORT_DECL(int, FSInit, void); EXPORT_DECL(int, FSShutdown, void); @@ -69,6 +68,12 @@ EXPORT_DECL(int, FSGetStatFile, void *pClient, void *pCmd, int fd, void *buffer, EXPORT_DECL(int, FSSetPosFile, void *pClient, void *pCmd, int fd, int pos, int error); EXPORT_DECL(int, FSWriteFile, void *pClient, void *pCmd, const void *source, int block_size, int block_count, int fd, int flag, int error); +EXPORT_DECL(int, FSBindMount, void *pClient, void *pCmd, char *source, char *target, int error); +EXPORT_DECL(int, FSBindUnmount, void *pClient, void *pCmd, char *target, int error); + +EXPORT_DECL(int, FSMakeQuota, void *pClient, void *pCmd, const char *path,u32 mode, u64 size, int errHandling); +EXPORT_DECL(int, FSMakeQuotaAsync ,void *pClient, void *pCmd, const char *path,u32 mode, u64 size, int errHandling,const void *asyncParams); + void InitFSFunctionPointers(void) { unsigned int *funcPointer = 0; @@ -117,4 +122,10 @@ void InitFSFunctionPointers(void) OS_FIND_EXPORT(coreinit_handle, FSGetStatFile); OS_FIND_EXPORT(coreinit_handle, FSSetPosFile); OS_FIND_EXPORT(coreinit_handle, FSWriteFile); + + OS_FIND_EXPORT(coreinit_handle, FSBindMount); + OS_FIND_EXPORT(coreinit_handle, FSBindUnmount); + + OS_FIND_EXPORT(coreinit_handle, FSMakeQuota); + OS_FIND_EXPORT(coreinit_handle, FSMakeQuotaAsync); } diff --git a/wiiu/dynamic_libs/fs_functions.h b/wiiu/dynamic_libs/fs_functions.h index 7a185e1343..d0246550e3 100644 --- a/wiiu/dynamic_libs/fs_functions.h +++ b/wiiu/dynamic_libs/fs_functions.h @@ -28,7 +28,8 @@ extern "C" { #endif -#include "common/fs_defs.h" +#include +#include "fs_defs.h" void InitFSFunctionPointers(void); @@ -80,6 +81,13 @@ extern int (* FSGetStatFile)(void *pClient, void *pCmd, int fd, void *buffer, in extern int (* FSSetPosFile)(void *pClient, void *pCmd, int fd, int pos, int error); extern int (* FSWriteFile)(void *pClient, void *pCmd, const void *source, int block_size, int block_count, int fd, int flag, int error); +extern int (* FSBindMount)(void *pClient, void *pCmd, char *source, char *target, int error); +extern int (* FSBindUnmount)(void *pClient, void *pCmd, char *target, int error); + +extern int (* FSMakeQuota)( void *pClient, void *pCmd, const char *path,u32 mode, u64 size, int errHandling); +extern int (* FSMakeQuotaAsync)(void *pClient, void *pCmd, const char *path,u32 mode, u64 size, int errHandling,const void *asyncParams); + + #ifdef __cplusplus } #endif diff --git a/wiiu/dynamic_libs/gx2_functions.c b/wiiu/dynamic_libs/gx2_functions.c index b9bf671778..a34807ec6f 100644 --- a/wiiu/dynamic_libs/gx2_functions.c +++ b/wiiu/dynamic_libs/gx2_functions.c @@ -23,7 +23,8 @@ ***************************************************************************/ #include "os_functions.h" #include "gx2_types.h" -#include "utils/utils.h" + +unsigned int gx2_handle __attribute__((section(".data"))) = 0; EXPORT_DECL(void, GX2Init, u32 * init_attribs); EXPORT_DECL(void, GX2Shutdown, void); @@ -37,6 +38,7 @@ EXPORT_DECL(void, GX2SetContextState, const GX2ContextState* state); EXPORT_DECL(void, GX2DrawEx, s32 primitive_type, u32 count, u32 first_vertex, u32 instances_count); EXPORT_DECL(void, GX2DrawIndexedEx, s32 primitive_type, u32 count, s32 index_format, const void* idx, u32 first_vertex, u32 instances_count); EXPORT_DECL(void, GX2ClearDepthStencilEx, GX2DepthBuffer *depthBuffer, f32 depth_value, u8 stencil_value, s32 clear_mode); +EXPORT_DECL(void, GX2SetClearDepthStencil, GX2DepthBuffer *depthBuffer, f32 depth_value, u8 stencil_value); EXPORT_DECL(void, GX2CopyColorBufferToScanBuffer, const GX2ColorBuffer *colorBuffer, s32 scan_target); EXPORT_DECL(void, GX2SwapScanBuffers, void); EXPORT_DECL(void, GX2SetTVEnable, s32 enable); @@ -89,13 +91,19 @@ EXPORT_DECL(void, GX2SetDRCGamma, f32 gam); EXPORT_DECL(s32, GX2GetSystemTVScanMode, void); EXPORT_DECL(s32, GX2GetSystemDRCScanMode, void); EXPORT_DECL(void, GX2RSetAllocator, void * (* allocFunc)(u32, u32, u32), void (* freeFunc)(u32, void*)); +EXPORT_DECL(void, GX2CopySurface, GX2Surface * srcSurface,u32 srcMip,u32 srcSlice,GX2Surface * dstSurface,u32 dstMip,u32 dstSlice ); +EXPORT_DECL(void, GX2ClearBuffersEx, GX2ColorBuffer * colorBuffer,GX2DepthBuffer * depthBuffer,f32 r, f32 g, f32 b, f32 a,f32 depthValue,u8 stencilValue,int clearFlags); + +void InitAcquireGX2(void) +{ + OSDynLoad_Acquire("gx2.rpl", &gx2_handle); +} void InitGX2FunctionPointers(void) { unsigned int *funcPointer = 0; - unsigned int gx2_handle; - OSDynLoad_Acquire("gx2.rpl", &gx2_handle); + InitAcquireGX2(); OS_FIND_EXPORT(gx2_handle, GX2Init); OS_FIND_EXPORT(gx2_handle, GX2Shutdown); @@ -159,4 +167,7 @@ void InitGX2FunctionPointers(void) OS_FIND_EXPORT(gx2_handle, GX2GetSystemTVScanMode); OS_FIND_EXPORT(gx2_handle, GX2GetSystemDRCScanMode); OS_FIND_EXPORT(gx2_handle, GX2RSetAllocator); + OS_FIND_EXPORT(gx2_handle, GX2CopySurface); + OS_FIND_EXPORT(gx2_handle, GX2ClearBuffersEx); + OS_FIND_EXPORT(gx2_handle, GX2SetClearDepthStencil); } diff --git a/wiiu/dynamic_libs/gx2_functions.h b/wiiu/dynamic_libs/gx2_functions.h index 1737833305..0b06826eac 100644 --- a/wiiu/dynamic_libs/gx2_functions.h +++ b/wiiu/dynamic_libs/gx2_functions.h @@ -30,7 +30,10 @@ extern "C" { #include "gx2_types.h" +extern unsigned int gx2_handle; + void InitGX2FunctionPointers(void); +void InitAcquireGX2(void); extern void (* GX2Init)(u32 * init_attribs); extern void (* GX2Shutdown)(void); @@ -44,6 +47,7 @@ extern void (* GX2SetContextState)(const GX2ContextState* state); extern void (* GX2DrawEx)(s32 primitive_type, u32 count, u32 first_vertex, u32 instances_count); extern void (* GX2DrawIndexedEx)(s32 primitive_type, u32 count, s32 index_format, const void* idx, u32 first_vertex, u32 instances_count); extern void (* GX2ClearDepthStencilEx)(GX2DepthBuffer *depthBuffer, f32 depth_value, u8 stencil_value, s32 clear_mode); +extern void (* GX2SetClearDepthStencil)(GX2DepthBuffer *depthBuffer, f32 depth_value, u8 stencil_value); extern void (* GX2CopyColorBufferToScanBuffer)(const GX2ColorBuffer *colorBuffer, s32 scan_target); extern void (* GX2SwapScanBuffers)(void); extern void (* GX2SetTVEnable)(s32 enable); @@ -96,6 +100,8 @@ extern void (* GX2SetDRCGamma)(f32 val); extern s32 (* GX2GetSystemTVScanMode)(void); extern s32 (* GX2GetSystemDRCScanMode)(void); extern void (* GX2RSetAllocator)(void * (*allocFunc)(u32, u32, u32), void (*freeFunc)(u32, void*)); +extern void (* GX2CopySurface)(GX2Surface * srcSurface,u32 srcMip,u32 srcSlice,GX2Surface * dstSurface,u32 dstMip,u32 dstSlice ); +extern void (* GX2ClearBuffersEx)(GX2ColorBuffer * colorBuffer,GX2DepthBuffer * depthBuffer,f32 r, f32 g, f32 b, f32 a,f32 depthValue,u8 stencilValue,int clearFlags); static inline void GX2InitDepthBuffer(GX2DepthBuffer *depthBuffer, s32 dimension, u32 width, u32 height, u32 depth, s32 format, s32 aa) { diff --git a/wiiu/dynamic_libs/os_functions.c b/wiiu/dynamic_libs/os_functions.c index b492bc059d..4845ec3269 100644 --- a/wiiu/dynamic_libs/os_functions.c +++ b/wiiu/dynamic_libs/os_functions.c @@ -24,7 +24,7 @@ #include "common/common.h" #include "os_functions.h" -unsigned int coreinit_handle = 0; +unsigned int coreinit_handle __attribute__((section(".data"))) = 0; //!---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //! Lib handle functions @@ -32,6 +32,11 @@ unsigned int coreinit_handle = 0; EXPORT_DECL(int, OSDynLoad_Acquire, const char* rpl, u32 *handle); EXPORT_DECL(int, OSDynLoad_FindExport, u32 handle, int isdata, const char *symbol, void *address); +//!---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- +//! Security functions +//!---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- +EXPORT_DECL(int, OSGetSecurityLevel, void); + //!---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //! Thread functions //!---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- @@ -45,6 +50,9 @@ EXPORT_DECL(int, OSJoinThread, void * thread, int * ret_val); EXPORT_DECL(void, OSDetachThread, void * thread); EXPORT_DECL(void, OSSleepTicks, u64 ticks); EXPORT_DECL(u64, OSGetTick, void); +EXPORT_DECL(u64, OSGetTime, void); +EXPORT_DECL(void, OSTicksToCalendarTime, u64 time, OSCalendarTime * calendarTime); + //!---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //! Mutex functions @@ -58,6 +66,7 @@ EXPORT_DECL(int, OSTryLockMutex, void* mutex); //! System functions //!---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- EXPORT_DECL(u64, OSGetTitleID, void); +EXPORT_DECL(void, OSGetArgcArgv, int* argc, char*** argv); EXPORT_DECL(void, __Exit, void); EXPORT_DECL(void, OSFatal, const char* msg); EXPORT_DECL(void, OSSetExceptionCallback, u8 exceptionType, exception_callback newCallback); @@ -65,6 +74,7 @@ EXPORT_DECL(void, DCFlushRange, const void *addr, u32 length); EXPORT_DECL(void, ICInvalidateRange, const void *addr, u32 length); EXPORT_DECL(void*, OSEffectiveToPhysical, const void*); EXPORT_DECL(int, __os_snprintf, char* s, int n, const char * format, ...); +EXPORT_DECL(int *, __gh_errno_ptr, void); EXPORT_DECL(void, OSScreenInit, void); EXPORT_DECL(unsigned int, OSScreenGetBufferSizeEx, unsigned int bufferNum); @@ -81,6 +91,7 @@ EXPORT_VAR(unsigned int *, pMEMAllocFromDefaultHeapEx); EXPORT_VAR(unsigned int *, pMEMAllocFromDefaultHeap); EXPORT_VAR(unsigned int *, pMEMFreeToDefaultHeap); +EXPORT_DECL(int, MEMGetSizeForMBlockExpHeap, void* ptr); EXPORT_DECL(int, MEMGetBaseHeapHandle, int mem_arena); EXPORT_DECL(unsigned int, MEMGetAllocatableSizeForFrmHeapEx, int heap, int align); EXPORT_DECL(void *, MEMAllocFromFrmHeapEx, int heap, unsigned int size, int align); @@ -90,33 +101,79 @@ EXPORT_DECL(int , MEMCreateExpHeapEx, void* address, unsigned int size, unsigned EXPORT_DECL(void *, MEMDestroyExpHeap, int heap); EXPORT_DECL(void, MEMFreeToExpHeap, int heap, void* ptr); +//!---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- +//! MCP functions +//!---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- +EXPORT_DECL(int, MCP_Open, void); +EXPORT_DECL(int, MCP_Close, int handle); +EXPORT_DECL(int, MCP_GetOwnTitleInfo, int handle, void * data); + //!---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //! Loader functions (not real rpl) //!---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- EXPORT_DECL(int, LiWaitIopComplete, int unknown_syscall_arg_r3, int * remaining_bytes); EXPORT_DECL(int, LiWaitIopCompleteWithInterrupts, int unknown_syscall_arg_r3, int * remaining_bytes); +EXPORT_DECL(void, addr_LiWaitOneChunk, void); +EXPORT_DECL(void, addr_sgIsLoadingBuffer, void); +EXPORT_DECL(void, addr_gDynloadInitialized, void); -void InitOSFunctionPointers(void) +//!---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- +//! Kernel function addresses +//!---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- +EXPORT_DECL(void, addr_PrepareTitle_hook, void); + +//!---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- +//! Other function addresses +//!---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- +EXPORT_DECL(void, DCInvalidateRange, void *buffer, uint32_t length); + +//!---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- +//! Energy Saver functions +//!---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- +//Burn-in Reduction +EXPORT_DECL(int, IMEnableDim,void); +EXPORT_DECL(int, IMDisableDim,void); +EXPORT_DECL(int, IMIsDimEnabled,int * result); +//Auto power down +EXPORT_DECL(int, IMEnableAPD,void); +EXPORT_DECL(int, IMDisableAPD,void); +EXPORT_DECL(int, IMIsAPDEnabled,int * result); +EXPORT_DECL(int, IMIsAPDEnabledBySysSettings,int * result); + +void InitAcquireOS(void) { - unsigned int *funcPointer = 0; - //!---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- + //!---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //! Lib handle functions //!---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- EXPORT_FUNC_WRITE(OSDynLoad_Acquire, (int (*)(const char*, unsigned *))OS_SPECIFICS->addr_OSDynLoad_Acquire); EXPORT_FUNC_WRITE(OSDynLoad_FindExport, (int (*)(u32, int, const char *, void *))OS_SPECIFICS->addr_OSDynLoad_FindExport); OSDynLoad_Acquire("coreinit.rpl", &coreinit_handle); +} +void InitOSFunctionPointers(void) +{ + unsigned int *funcPointer = 0; + + InitAcquireOS(); + + //!---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- + //! Security functions + //!---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- + OS_FIND_EXPORT(coreinit_handle, OSGetSecurityLevel); //!---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //! System functions //!---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- OS_FIND_EXPORT(coreinit_handle, OSFatal); OS_FIND_EXPORT(coreinit_handle, OSGetTitleID); + OS_FIND_EXPORT(coreinit_handle, OSGetArgcArgv); OS_FIND_EXPORT(coreinit_handle, OSSetExceptionCallback); OS_FIND_EXPORT(coreinit_handle, DCFlushRange); OS_FIND_EXPORT(coreinit_handle, ICInvalidateRange); OS_FIND_EXPORT(coreinit_handle, OSEffectiveToPhysical); OS_FIND_EXPORT(coreinit_handle, __os_snprintf); + OS_FIND_EXPORT(coreinit_handle, __gh_errno_ptr); + OSDynLoad_FindExport(coreinit_handle, 0, "_Exit", &__Exit); OS_FIND_EXPORT(coreinit_handle, OSScreenInit); @@ -139,6 +196,9 @@ void InitOSFunctionPointers(void) OS_FIND_EXPORT(coreinit_handle, OSDetachThread); OS_FIND_EXPORT(coreinit_handle, OSSleepTicks); OS_FIND_EXPORT(coreinit_handle, OSGetTick); + OS_FIND_EXPORT(coreinit_handle, OSGetTime); + OS_FIND_EXPORT(coreinit_handle, OSTicksToCalendarTime); + //!---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //! Mutex functions //!---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- @@ -146,6 +206,12 @@ void InitOSFunctionPointers(void) OS_FIND_EXPORT(coreinit_handle, OSLockMutex); OS_FIND_EXPORT(coreinit_handle, OSUnlockMutex); OS_FIND_EXPORT(coreinit_handle, OSTryLockMutex); + //!---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- + //! MCP functions + //!---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- + OS_FIND_EXPORT(coreinit_handle, MCP_Open); + OS_FIND_EXPORT(coreinit_handle, MCP_Close); + OS_FIND_EXPORT(coreinit_handle, MCP_GetOwnTitleInfo); //!---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //! Memory functions @@ -154,6 +220,7 @@ void InitOSFunctionPointers(void) OSDynLoad_FindExport(coreinit_handle, 1, "MEMAllocFromDefaultHeap", &pMEMAllocFromDefaultHeap); OSDynLoad_FindExport(coreinit_handle, 1, "MEMFreeToDefaultHeap", &pMEMFreeToDefaultHeap); + OS_FIND_EXPORT(coreinit_handle, MEMGetSizeForMBlockExpHeap); OS_FIND_EXPORT(coreinit_handle, MEMGetBaseHeapHandle); OS_FIND_EXPORT(coreinit_handle, MEMGetAllocatableSizeForFrmHeapEx); OS_FIND_EXPORT(coreinit_handle, MEMAllocFromFrmHeapEx); @@ -162,5 +229,100 @@ void InitOSFunctionPointers(void) OS_FIND_EXPORT(coreinit_handle, MEMCreateExpHeapEx); OS_FIND_EXPORT(coreinit_handle, MEMDestroyExpHeap); OS_FIND_EXPORT(coreinit_handle, MEMFreeToExpHeap); -} + //!---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- + //! Other function addresses + //!---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- + OS_FIND_EXPORT(coreinit_handle, DCInvalidateRange); + + //!---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- + //! Energy Saver functions + //!---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- + //Burn-in Reduction + OS_FIND_EXPORT(coreinit_handle, IMEnableDim); + OS_FIND_EXPORT(coreinit_handle, IMDisableDim); + OS_FIND_EXPORT(coreinit_handle, IMIsDimEnabled); + //Auto power down + OS_FIND_EXPORT(coreinit_handle, IMEnableAPD); + OS_FIND_EXPORT(coreinit_handle, IMDisableAPD); + OS_FIND_EXPORT(coreinit_handle, IMIsAPDEnabled); + OS_FIND_EXPORT(coreinit_handle, IMIsAPDEnabledBySysSettings); + + //!---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- + //! Special non library functions + //!---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- + if(OS_FIRMWARE == 532 || OS_FIRMWARE == 540) + { + EXPORT_FUNC_WRITE(LiWaitIopComplete, (int (*)(int, int *))0x0100FFA4); // loader.elf + EXPORT_FUNC_WRITE(LiWaitIopCompleteWithInterrupts, (int (*)(int, int *))0x0100FE90); // loader.elf + EXPORT_FUNC_WRITE(addr_LiWaitOneChunk, (int (*)(int, int *))0x010007EC); // loader.elf + EXPORT_FUNC_WRITE(addr_PrepareTitle_hook, (int (*)(int, int *))0xFFF18558); // kernel.elf + + EXPORT_FUNC_WRITE(addr_sgIsLoadingBuffer, (int (*)(int, int *))0xEFE19D00); // loader.elf + EXPORT_FUNC_WRITE(addr_gDynloadInitialized, (int (*)(int, int *))0xEFE13C3C); // loader.elf + } + else if(OS_FIRMWARE == 500 || OS_FIRMWARE == 510) + { + EXPORT_FUNC_WRITE(LiWaitIopComplete, (int (*)(int, int *))0x0100FBC4); + EXPORT_FUNC_WRITE(LiWaitIopCompleteWithInterrupts, (int (*)(int, int *))0x0100FAB0); + EXPORT_FUNC_WRITE(addr_LiWaitOneChunk, (int (*)(int, int *))0x010007EC); + EXPORT_FUNC_WRITE(addr_PrepareTitle_hook, (int (*)(int, int *))0xFFF18534); + + EXPORT_FUNC_WRITE(addr_sgIsLoadingBuffer, (int (*)(int, int *))0xEFE19D00); + EXPORT_FUNC_WRITE(addr_gDynloadInitialized, (int (*)(int, int *))0xEFE13C3C); + } + else if(OS_FIRMWARE == 410) + { + EXPORT_FUNC_WRITE(LiWaitIopComplete, (int (*)(int, int *))0x0100F78C); + EXPORT_FUNC_WRITE(LiWaitIopCompleteWithInterrupts, (int (*)(int, int *))0x0100F678); + EXPORT_FUNC_WRITE(addr_LiWaitOneChunk, (int (*)(int, int *))0x010007F8); + EXPORT_FUNC_WRITE(addr_PrepareTitle_hook, (int (*)(int, int *))0xFFF166DC); + + EXPORT_FUNC_WRITE(addr_sgIsLoadingBuffer, (int (*)(int, int *))0xEFE19CC0); + EXPORT_FUNC_WRITE(addr_gDynloadInitialized, (int (*)(int, int *))0xEFE13BFC); + } + else if(OS_FIRMWARE == 400) //same for 402 and 403 + { + EXPORT_FUNC_WRITE(LiWaitIopComplete, (int (*)(int, int *))0x0100F78C); + EXPORT_FUNC_WRITE(LiWaitIopCompleteWithInterrupts, (int (*)(int, int *))0x0100F678); + EXPORT_FUNC_WRITE(addr_LiWaitOneChunk, (int (*)(int, int *))0x010007F8); + EXPORT_FUNC_WRITE(addr_PrepareTitle_hook, (int (*)(int, int *))0xFFF15E70); + + EXPORT_FUNC_WRITE(addr_sgIsLoadingBuffer, (int (*)(int, int *))0xEFE19CC0); + EXPORT_FUNC_WRITE(addr_gDynloadInitialized, (int (*)(int, int *))0xEFE13BFC); + } + else if(OS_FIRMWARE == 550) + { + EXPORT_FUNC_WRITE(LiWaitIopComplete, (int (*)(int, int *))0x01010180); + EXPORT_FUNC_WRITE(LiWaitIopCompleteWithInterrupts, (int (*)(int, int *))0x0101006C); + EXPORT_FUNC_WRITE(addr_LiWaitOneChunk, (int (*)(int, int *))0x0100080C); + EXPORT_FUNC_WRITE(addr_PrepareTitle_hook, (int (*)(int, int *))0xFFF184E4); + + EXPORT_FUNC_WRITE(addr_sgIsLoadingBuffer, (int (*)(int, int *))0xEFE19E80); + EXPORT_FUNC_WRITE(addr_gDynloadInitialized, (int (*)(int, int *))0xEFE13DBC); + } + else if(OS_FIRMWARE == 310) + { + EXPORT_FUNC_WRITE(LiWaitIopComplete, (int (*)(int, int *))0x0100C4E4); + EXPORT_FUNC_WRITE(LiWaitIopCompleteWithInterrupts, (int (*)(int, int *))0x0100C3D4); + EXPORT_FUNC_WRITE(addr_LiWaitOneChunk, (int (*)(int, int *))0x010004D8); + EXPORT_FUNC_WRITE(addr_PrepareTitle_hook, (int (*)(int, int *))0xFFF15A0C); + + EXPORT_FUNC_WRITE(addr_sgIsLoadingBuffer, (int (*)(int, int *))0xEFE19340); + EXPORT_FUNC_WRITE(addr_gDynloadInitialized, (int (*)(int, int *))0xEFE1329C); + } + else if(OS_FIRMWARE == 300) + { + EXPORT_FUNC_WRITE(LiWaitIopComplete, (int (*)(int, int *))0x0100C4E4); + EXPORT_FUNC_WRITE(LiWaitIopCompleteWithInterrupts, (int (*)(int, int *))0x0100C3D4); + EXPORT_FUNC_WRITE(addr_LiWaitOneChunk, (int (*)(int, int *))0x010004D8); + EXPORT_FUNC_WRITE(addr_PrepareTitle_hook, (int (*)(int, int *))0xFFF15974); + + EXPORT_FUNC_WRITE(addr_sgIsLoadingBuffer, (int (*)(int, int *))0xEFE19340); + EXPORT_FUNC_WRITE(addr_gDynloadInitialized, (int (*)(int, int *))0xEFE1329C); + } + else + { + OSFatal("Missing all OS specific addresses."); + } +} diff --git a/wiiu/dynamic_libs/os_functions.h b/wiiu/dynamic_libs/os_functions.h index 0354e53d69..cae471c694 100644 --- a/wiiu/dynamic_libs/os_functions.h +++ b/wiiu/dynamic_libs/os_functions.h @@ -26,6 +26,7 @@ #include #include "common/os_defs.h" +#include "os_types.h" #ifdef __cplusplus extern "C" { @@ -33,10 +34,8 @@ extern "C" { #define BUS_SPEED 248625000 //#define SECS_TO_TICKS(sec) (((unsigned long long)(sec)) * (BUS_SPEED/4)) -#define SECS_TO_TICKS(sec) sec -#define MILLISECS_TO_TICKS(msec) (SECS_TO_TICKS(msec) / 1000) +//#define MILLISECS_TO_TICKS(msec) (SECS_TO_TICKS(msec) / 1000) //#define MICROSECS_TO_TICKS(usec) (SECS_TO_TICKS(usec) / 1000000) -#define MICROSECS_TO_TICKS(usec) usec //#define usleep(usecs) OSSleepTicks(MICROSECS_TO_TICKS(usecs)) //#define sleep(secs) OSSleepTicks(SECS_TO_TICKS(secs)) @@ -68,6 +67,7 @@ extern "C" { /* Handle for coreinit */ extern unsigned int coreinit_handle; void InitOSFunctionPointers(void); +void InitAcquireOS(void); //!---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //! Lib handle functions @@ -75,6 +75,11 @@ void InitOSFunctionPointers(void); extern int (* OSDynLoad_Acquire)(const char* rpl, u32 *handle); extern int (* OSDynLoad_FindExport)(u32 handle, int isdata, const char *symbol, void *address); +//!---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- +//! Security functions +//!---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- +extern int (* OSGetSecurityLevel)(void); + //!---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //! Thread functions //!---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- @@ -88,6 +93,8 @@ extern int (* OSSetThreadPriority)(void * thread, int priority); extern void (* OSDetachThread)(void * thread); extern void (* OSSleepTicks)(u64 ticks); extern u64 (* OSGetTick)(void); +extern u64 (* OSGetTime)(void); +extern void (*OSTicksToCalendarTime)(u64 time, OSCalendarTime *calendarTime); //!---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //! Mutex functions @@ -101,12 +108,14 @@ extern int (* OSTryLockMutex)(void* mutex); //! System functions //!---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- extern u64 (* OSGetTitleID)(void); +extern void (* OSGetArgcArgv)(int* argc, char*** argv); extern void (* __Exit)(void); extern void (* OSFatal)(const char* msg); extern void (* DCFlushRange)(const void *addr, u32 length); extern void (* ICInvalidateRange)(const void *addr, u32 length); extern void* (* OSEffectiveToPhysical)(const void*); extern int (* __os_snprintf)(char* s, int n, const char * format, ...); +extern int * (* __gh_errno_ptr)(void); extern void (*OSScreenInit)(void); extern unsigned int (*OSScreenGetBufferSizeEx)(unsigned int bufferNum); @@ -119,9 +128,44 @@ extern int (*OSScreenEnableEx)(unsigned int bufferNum, int enable); typedef unsigned char (*exception_callback)(void * interruptedContext); extern void (* OSSetExceptionCallback)(u8 exceptionType, exception_callback newCallback); +//!---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- +//! MCP functions +//!---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- +extern int (* MCP_Open)(void); +extern int (* MCP_Close)(int handle); +extern int (* MCP_GetOwnTitleInfo)(int handle, void * data); + +//!---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- +//! LOADER functions +//!---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- extern int (* LiWaitIopComplete)(int unknown_syscall_arg_r3, int * remaining_bytes); extern int (* LiWaitIopCompleteWithInterrupts)(int unknown_syscall_arg_r3, int * remaining_bytes); +extern void (* addr_LiWaitOneChunk)(void); +extern void (* addr_sgIsLoadingBuffer)(void); +extern void (* addr_gDynloadInitialized)(void); +//!---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- +//! Kernel function addresses +//!---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- +extern void (* addr_PrepareTitle_hook)(void); + +//!---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- +//! Other function addresses +//!---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- +extern void (*DCInvalidateRange)(void *buffer, uint32_t length); + +//!---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- +//! Energy Saver functions +//!---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- +////Burn-in Reduction +extern int (*IMEnableDim)(void); +extern int (*IMDisableDim)(void); +extern int (*IMIsDimEnabled)(int * result); +//Auto power down +extern int (*IMEnableAPD)(void); +extern int (*IMDisableAPD)(void); +extern int (*IMIsAPDEnabled)(int * result); +extern int (*IMIsAPDEnabledBySysSettings)(int * result); #ifdef __cplusplus } diff --git a/wiiu/dynamic_libs/os_types.h b/wiiu/dynamic_libs/os_types.h new file mode 100644 index 0000000000..aaa18feeab --- /dev/null +++ b/wiiu/dynamic_libs/os_types.h @@ -0,0 +1,27 @@ +#ifndef _OS_TYPES_H_ +#define _OS_TYPES_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +#include + +typedef struct _OSCalendarTime { + int sec; + int min; + int hour; + int mday; + int mon; + int year; + int wday; + int yday; + int msec; + int usec; +} OSCalendarTime; + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/wiiu/dynamic_libs/padscore_functions.c b/wiiu/dynamic_libs/padscore_functions.c index c51764fa26..f7ca8e9b9b 100644 --- a/wiiu/dynamic_libs/padscore_functions.c +++ b/wiiu/dynamic_libs/padscore_functions.c @@ -24,27 +24,38 @@ #include "os_functions.h" #include "padscore_functions.h" +unsigned int padscore_handle __attribute__((section(".data"))) = 0; + EXPORT_DECL(void, KPADInit, void); +EXPORT_DECL(void, WPADInit, void); EXPORT_DECL(s32, WPADProbe, s32 chan, u32 * pad_type); EXPORT_DECL(s32, WPADSetDataFormat, s32 chan, s32 format); EXPORT_DECL(void, WPADEnableURCC, s32 enable); EXPORT_DECL(void, WPADRead, s32 chan, void * data); EXPORT_DECL(s32, KPADRead, s32 chan, void * data, u32 size); +EXPORT_DECL(void,WPADSetAutoSleepTime,u8 minute); +EXPORT_DECL(void,WPADDisconnect,s32 chan); + +void InitAcquirePadScore(void) +{ + OSDynLoad_Acquire("padscore.rpl", &padscore_handle); +} void InitPadScoreFunctionPointers(void) { unsigned int *funcPointer = 0; - unsigned int padscore_handle; - OSDynLoad_Acquire("padscore.rpl", &padscore_handle); + InitAcquirePadScore(); + OS_FIND_EXPORT(padscore_handle, WPADInit); OS_FIND_EXPORT(padscore_handle, KPADInit); OS_FIND_EXPORT(padscore_handle, WPADProbe); OS_FIND_EXPORT(padscore_handle, WPADSetDataFormat); OS_FIND_EXPORT(padscore_handle, WPADEnableURCC); OS_FIND_EXPORT(padscore_handle, WPADRead); OS_FIND_EXPORT(padscore_handle, KPADRead); + OS_FIND_EXPORT(padscore_handle, WPADSetAutoSleepTime); + OS_FIND_EXPORT(padscore_handle, WPADDisconnect); KPADInit(); WPADEnableURCC(1); } - diff --git a/wiiu/dynamic_libs/padscore_functions.h b/wiiu/dynamic_libs/padscore_functions.h index 26eda1a6f3..5b000b19c8 100644 --- a/wiiu/dynamic_libs/padscore_functions.h +++ b/wiiu/dynamic_libs/padscore_functions.h @@ -28,6 +28,10 @@ extern "C" { #endif +#include "dynamic_libs/vpad_functions.h" + +extern unsigned int padscore_handle; + #include #define WPAD_BUTTON_LEFT 0x0001 @@ -60,8 +64,34 @@ extern "C" { #define WPAD_CLASSIC_BUTTON_DOWN 0x4000 #define WPAD_CLASSIC_BUTTON_RIGHT 0x8000 -void InitPadScoreFunctionPointers(void); +#define WPAD_PRO_BUTTON_UP 0x00000001 +#define WPAD_PRO_BUTTON_LEFT 0x00000002 +#define WPAD_PRO_TRIGGER_ZR 0x00000004 +#define WPAD_PRO_BUTTON_X 0x00000008 +#define WPAD_PRO_BUTTON_A 0x00000010 +#define WPAD_PRO_BUTTON_Y 0x00000020 +#define WPAD_PRO_BUTTON_B 0x00000040 +#define WPAD_PRO_TRIGGER_ZL 0x00000080 +#define WPAD_PRO_RESERVED 0x00000100 +#define WPAD_PRO_TRIGGER_R 0x00000200 +#define WPAD_PRO_BUTTON_PLUS 0x00000400 +#define WPAD_PRO_BUTTON_HOME 0x00000800 +#define WPAD_PRO_BUTTON_MINUS 0x00001000 +#define WPAD_PRO_TRIGGER_L 0x00002000 +#define WPAD_PRO_BUTTON_DOWN 0x00004000 +#define WPAD_PRO_BUTTON_RIGHT 0x00008000 +#define WPAD_PRO_BUTTON_STICK_R 0x00010000 +#define WPAD_PRO_BUTTON_STICK_L 0x00020000 +#define WPAD_PRO_STICK_L_EMULATION_UP 0x00200000 +#define WPAD_PRO_STICK_L_EMULATION_DOWN 0x00100000 +#define WPAD_PRO_STICK_L_EMULATION_LEFT 0x00040000 +#define WPAD_PRO_STICK_L_EMULATION_RIGHT 0x00080000 + +#define WPAD_PRO_STICK_R_EMULATION_UP 0x02000000 +#define WPAD_PRO_STICK_R_EMULATION_DOWN 0x01000000 +#define WPAD_PRO_STICK_R_EMULATION_LEFT 0x00400000 +#define WPAD_PRO_STICK_R_EMULATION_RIGHT 0x00800000 typedef struct _KPADData { @@ -78,7 +108,7 @@ typedef struct _KPADData u8 device_type; u8 wpad_error; u8 pos_valid; - u8 unused_4[1]; + u8 format; union { @@ -101,19 +131,38 @@ typedef struct _KPADData f32 rtrigger; } classic; + struct + { + u32 btns_h; + u32 btns_d; + u32 btns_r; + f32 lstick_x; + f32 lstick_y; + f32 rstick_x; + f32 rstick_y; + int charging; + int wired; + } pro; + u32 unused_6[20]; }; u32 unused_7[16]; } KPADData; +void InitPadScoreFunctionPointers(void); +void InitAcquirePadScore(void); typedef void (* wpad_connect_callback_t)(s32 chan, s32 status); extern void (* KPADInit)(void); +extern void (* WPADInit)(void); extern s32 (* WPADProbe)(s32 chan, u32 * pad_type); extern s32 (* WPADSetDataFormat)(s32 chan, s32 format); extern void (* WPADEnableURCC)(s32 enable); extern void (* WPADRead)(s32 chan, void * data); extern s32 (* KPADRead)(s32 chan, void * data, u32 size); +extern s32 (* KPADReadEx)(s32 chan, KPADData * data, u32 size, s32 *error); +extern void (*WPADSetAutoSleepTime)(u8 time); +extern void (*WPADDisconnect)( s32 chan ); #ifdef __cplusplus } diff --git a/wiiu/dynamic_libs/socket_functions.c b/wiiu/dynamic_libs/socket_functions.c index 8f72ced04e..de2c31f53f 100644 --- a/wiiu/dynamic_libs/socket_functions.c +++ b/wiiu/dynamic_libs/socket_functions.c @@ -26,6 +26,8 @@ u32 hostIpAddress = 0; +unsigned int nsysnet_handle __attribute__((section(".data"))) = 0; + EXPORT_DECL(void, socket_lib_init, void); EXPORT_DECL(int, socket, int domain, int type, int protocol); EXPORT_DECL(int, socketclose, int s); @@ -35,27 +37,26 @@ EXPORT_DECL(int, listen, s32 s,u32 backlog); EXPORT_DECL(int, accept, s32 s,struct sockaddr *addr,s32 *addrlen); EXPORT_DECL(int, send, int s, const void *buffer, int size, int flags); EXPORT_DECL(int, recv, int s, void *buffer, int size, int flags); +EXPORT_DECL(int, recvfrom,int sockfd, void *buf, int len, int flags,struct sockaddr *src_addr, int *addrlen); EXPORT_DECL(int, sendto, int s, const void *buffer, int size, int flags, const struct sockaddr *dest, int dest_len); EXPORT_DECL(int, setsockopt, int s, int level, int optname, void *optval, int optlen); EXPORT_DECL(char *, inet_ntoa, struct in_addr in); EXPORT_DECL(int, inet_aton, const char *cp, struct in_addr *inp); +EXPORT_DECL(int, NSSLWrite, int connection, const void* buf, int len,int * written); +EXPORT_DECL(int, NSSLRead, int connection, const void* buf, int len,int * read); +EXPORT_DECL(int, NSSLCreateConnection, int context, const char* host, int hotlen,int options,int sock,int block); + +void InitAcquireSocket(void) +{ + OSDynLoad_Acquire("nsysnet.rpl", &nsysnet_handle); +} + void InitSocketFunctionPointers(void) { - unsigned int nsysnet_handle; unsigned int *funcPointer = 0; - OSDynLoad_Acquire("nsysnet.rpl", &nsysnet_handle); - unsigned int nn_ac_handle; - int(*ACInitialize)(); - int(*ACGetStartupId) (unsigned int *id); - int(*ACConnectWithConfigId) (unsigned int id); - int(*ACGetAssignedAddress) (u32 * ip); - OSDynLoad_Acquire("nn_ac.rpl", &nn_ac_handle); - OSDynLoad_FindExport(nn_ac_handle, 0, "ACInitialize", &ACInitialize); - OSDynLoad_FindExport(nn_ac_handle, 0, "ACGetStartupId", &ACGetStartupId); - OSDynLoad_FindExport(nn_ac_handle, 0, "ACConnectWithConfigId",&ACConnectWithConfigId); - OSDynLoad_FindExport(nn_ac_handle, 0, "ACGetAssignedAddress",&ACGetAssignedAddress); + InitAcquireSocket(); OS_FIND_EXPORT(nsysnet_handle, socket_lib_init); OS_FIND_EXPORT(nsysnet_handle, socket); @@ -66,17 +67,15 @@ void InitSocketFunctionPointers(void) OS_FIND_EXPORT(nsysnet_handle, accept); OS_FIND_EXPORT(nsysnet_handle, send); OS_FIND_EXPORT(nsysnet_handle, recv); + OS_FIND_EXPORT(nsysnet_handle, recvfrom); OS_FIND_EXPORT(nsysnet_handle, sendto); OS_FIND_EXPORT(nsysnet_handle, setsockopt); OS_FIND_EXPORT(nsysnet_handle, inet_ntoa); OS_FIND_EXPORT(nsysnet_handle, inet_aton); - unsigned int nn_startupid; - ACInitialize(); - ACGetStartupId(&nn_startupid); - ACConnectWithConfigId(nn_startupid); - ACGetAssignedAddress(&hostIpAddress); + OS_FIND_EXPORT(nsysnet_handle, NSSLWrite); + OS_FIND_EXPORT(nsysnet_handle, NSSLRead); + OS_FIND_EXPORT(nsysnet_handle, NSSLCreateConnection); socket_lib_init(); } - diff --git a/wiiu/dynamic_libs/socket_functions.h b/wiiu/dynamic_libs/socket_functions.h index c051246a2e..1e4df1a293 100644 --- a/wiiu/dynamic_libs/socket_functions.h +++ b/wiiu/dynamic_libs/socket_functions.h @@ -28,6 +28,8 @@ extern "C" { #endif +extern unsigned int nsysnet_handle; + #include #define INADDR_ANY 0 @@ -47,6 +49,10 @@ extern "C" { #define SO_REUSEADDR 0x0004 #define SO_NONBLOCK 0x1016 #define SO_MYADDR 0x1013 +#define SO_RCVTIMEO 0x1006 + +#define SOL_SOCKET -1 +#define MSG_DONTWAIT 32 #define htonl(x) x #define htons(x) x @@ -72,6 +78,7 @@ struct sockaddr void InitSocketFunctionPointers(void); +void InitAcquireSocket(void); extern void (*socket_lib_init)(void); extern int (*socket)(int domain, int type, int protocol); @@ -82,9 +89,15 @@ extern int (*listen)(s32 s,u32 backlog); extern int (*accept)(s32 s,struct sockaddr *addr,s32 *addrlen); extern int (*send)(int s, const void *buffer, int size, int flags); extern int (*recv)(int s, void *buffer, int size, int flags); +extern int (*recvfrom)(int sockfd, void *buf, int len, int flags,struct sockaddr *src_addr, int *addrlen); + extern int (*sendto)(int s, const void *buffer, int size, int flags, const struct sockaddr *dest, int dest_len); extern int (*setsockopt)(int s, int level, int optname, void *optval, int optlen); +extern int (* NSSLWrite)(int connection, const void* buf, int len,int * written); +extern int (* NSSLRead)(int connection, const void* buf, int len,int * read); +extern int (* NSSLCreateConnection)(int context, const char* host, int hotlen,int options,int sock,int block); + extern char * (*inet_ntoa)(struct in_addr in); extern int (*inet_aton)(const char *cp, struct in_addr *inp); diff --git a/wiiu/dynamic_libs/sys_functions.c b/wiiu/dynamic_libs/sys_functions.c index ea7649e973..c0545498fd 100644 --- a/wiiu/dynamic_libs/sys_functions.c +++ b/wiiu/dynamic_libs/sys_functions.c @@ -23,18 +23,27 @@ ***************************************************************************/ #include "os_functions.h" -EXPORT_DECL(void, _SYSLaunchTitleByPathFromLauncher, const char* path, int len, int zero); -EXPORT_DECL(int, SYSRelaunchTitle, int argc, char* argv); + unsigned int sysapp_handle __attribute__((section(".data"))) = 0; + +EXPORT_DECL(int, _SYSLaunchTitleByPathFromLauncher, const char* path, int len, int zero); +EXPORT_DECL(int, SYSRelaunchTitle, int argc, char** argv); EXPORT_DECL(int, SYSLaunchMenu, void); +EXPORT_DECL(int, SYSCheckTitleExists, u64 titleId); +EXPORT_DECL(int, SYSLaunchTitle, u64 titleId); + +void InitAcquireSys(void) +{ + OSDynLoad_Acquire("sysapp.rpl", &sysapp_handle); +} void InitSysFunctionPointers(void) { unsigned int *funcPointer = 0; - unsigned int sysapp_handle; - OSDynLoad_Acquire("sysapp.rpl", &sysapp_handle); + InitAcquireSys(); OS_FIND_EXPORT(sysapp_handle, _SYSLaunchTitleByPathFromLauncher); OS_FIND_EXPORT(sysapp_handle, SYSRelaunchTitle); OS_FIND_EXPORT(sysapp_handle, SYSLaunchMenu); + OS_FIND_EXPORT(sysapp_handle, SYSCheckTitleExists); + OS_FIND_EXPORT(sysapp_handle, SYSLaunchTitle); } - diff --git a/wiiu/dynamic_libs/sys_functions.h b/wiiu/dynamic_libs/sys_functions.h index 18c90658c1..08ca21b922 100644 --- a/wiiu/dynamic_libs/sys_functions.h +++ b/wiiu/dynamic_libs/sys_functions.h @@ -28,11 +28,16 @@ extern "C" { #endif -void InitSysFunctionPointers(void); +extern unsigned int sysapp_handle; -extern void(*_SYSLaunchTitleByPathFromLauncher)(const char* path, int len, int zero); -extern int (* SYSRelaunchTitle)(int argc, char* argv); +void InitSysFunctionPointers(void); +void InitAcquireSys(void); + +extern int(*_SYSLaunchTitleByPathFromLauncher)(const char* path, int len, int zero); +extern int (* SYSRelaunchTitle)(int argc, char** argv); extern int (* SYSLaunchMenu)(void); +extern int (* SYSCheckTitleExists)(u64 titleId); +extern int (* SYSLaunchTitle)(u64 titleId); #ifdef __cplusplus diff --git a/wiiu/dynamic_libs/syshid_functions.c b/wiiu/dynamic_libs/syshid_functions.c new file mode 100644 index 0000000000..996d39d42e --- /dev/null +++ b/wiiu/dynamic_libs/syshid_functions.c @@ -0,0 +1,78 @@ +/**************************************************************************** + * Copyright (C) 2015 + * by Dimok + * + * This software is provided 'as-is', without any express or implied + * warranty. In no event will the authors be held liable for any + * damages arising from the use of this software. + * + * Permission is granted to anyone to use this software for any + * purpose, including commercial applications, and to alter it and + * redistribute it freely, subject to the following restrictions: + * + * 1. The origin of this software must not be misrepresented; you + * must not claim that you wrote the original software. If you use + * this software in a product, an acknowledgment in the product + * documentation would be appreciated but is not required. + * + * 2. Altered source versions must be plainly marked as such, and + * must not be misrepresented as being the original software. + * + * 3. This notice may not be removed or altered from any source + * distribution. + ***************************************************************************/ +#include "os_functions.h" +#include "syshid_functions.h" + +unsigned int syshid_handle __attribute__((section(".data"))) = 0; + +EXPORT_DECL(int, HIDSetup,void); +EXPORT_DECL(int, HIDTeardown,void); + +EXPORT_DECL(int, HIDAddClient,HIDClient *p_client, HIDAttachCallback attach_callback); +EXPORT_DECL(int, HIDDelClient,HIDClient *p_client); + +EXPORT_DECL(int, HIDGetDescriptor,unsigned int handle,u8 descriptor_type,u8 descriptor_index, u16 language_id, unsigned char *p_buffer, unsigned int buffer_length, HIDCallback hc, void *p_user); +EXPORT_DECL(int, HIDSetDescriptor,unsigned int handle,u8 descriptor_type,u8 descriptor_index, u16 language_id, unsigned char *p_buffer, unsigned int buffer_length, HIDCallback hc, void *p_user); + +EXPORT_DECL(int, HIDSetProtocol,unsigned int handle,u8 interface_index,u8 protocol, HIDCallback hc, void *p_user); +EXPORT_DECL(int, HIDGetProtocol,unsigned int handle,u8 interface_index,u8 * protocol, HIDCallback hc, void *p_user); + +EXPORT_DECL(int, HIDGetReport,u32 handle, u8 report_type, u8 report_id, u8 *p_buffer, u32 buffer_length, HIDCallback hc, void *p_user); +EXPORT_DECL(int, HIDSetReport,u32 handle, u8 report_type, u8 report_id, u8 *p_buffer, u32 buffer_length, HIDCallback hc, void *p_user); + +EXPORT_DECL(int, HIDSetIdle,unsigned int handle, u8 interface_index,u8 duration, HIDCallback hc, void *p_user); + +EXPORT_DECL(int, HIDRead,unsigned int handle, unsigned char *p_buffer, unsigned int buffer_length, HIDCallback hc, void *p_user); +EXPORT_DECL(int, HIDWrite,unsigned int handle, unsigned char *p_buffer, unsigned int buffer_length, HIDCallback hc, void *p_user); + +void InitAcquireSysHID(void) +{ + OSDynLoad_Acquire("nsyshid.rpl", &syshid_handle); +} + +void InitSysHIDFunctionPointers(void) +{ + InitAcquireSysHID(); + + if(syshid_handle == 0){ + return; + } + + unsigned int funcPointer = 0; + + //! assigning those is not mandatory and it does not always work to load them + OS_FIND_EXPORT(syshid_handle, HIDSetup); + OS_FIND_EXPORT(syshid_handle, HIDTeardown); + OS_FIND_EXPORT(syshid_handle, HIDAddClient); + OS_FIND_EXPORT(syshid_handle, HIDDelClient); + OS_FIND_EXPORT(syshid_handle, HIDGetDescriptor); + OS_FIND_EXPORT(syshid_handle, HIDSetDescriptor); + OS_FIND_EXPORT(syshid_handle, HIDRead); + OS_FIND_EXPORT(syshid_handle, HIDWrite); + OS_FIND_EXPORT(syshid_handle, HIDSetProtocol); + OS_FIND_EXPORT(syshid_handle, HIDGetProtocol); + OS_FIND_EXPORT(syshid_handle, HIDSetIdle); + OS_FIND_EXPORT(syshid_handle, HIDGetReport); + OS_FIND_EXPORT(syshid_handle, HIDSetReport); +} diff --git a/wiiu/dynamic_libs/syshid_functions.h b/wiiu/dynamic_libs/syshid_functions.h new file mode 100644 index 0000000000..08213b4b28 --- /dev/null +++ b/wiiu/dynamic_libs/syshid_functions.h @@ -0,0 +1,90 @@ +/**************************************************************************** + * Copyright (C) 2015 + * by Dimok + * + * This software is provided 'as-is', without any express or implied + * warranty. In no event will the authors be held liable for any + * damages arising from the use of this software. + * + * Permission is granted to anyone to use this software for any + * purpose, including commercial applications, and to alter it and + * redistribute it freely, subject to the following restrictions: + * + * 1. The origin of this software must not be misrepresented; you + * must not claim that you wrote the original software. If you use + * this software in a product, an acknowledgment in the product + * documentation would be appreciated but is not required. + * + * 2. Altered source versions must be plainly marked as such, and + * must not be misrepresented as being the original software. + * + * 3. This notice may not be removed or altered from any source + * distribution. + ***************************************************************************/ +#ifndef __SYSHID_FUNCTIONS_H_ +#define __SYSHID_FUNCTIONS_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +extern unsigned int syshid_handle; + +typedef struct +{ + unsigned int handle; + unsigned int physical_device_inst; + unsigned short vid; + unsigned short pid; + unsigned char interface_index; + unsigned char sub_class; + unsigned char protocol; + + unsigned short max_packet_size_rx; + unsigned short max_packet_size_tx; + +} HIDDevice; + +typedef struct _HIDClient HIDClient; + +#define HID_DEVICE_DETACH 0 +#define HID_DEVICE_ATTACH 1 + +typedef int (*HIDAttachCallback)(HIDClient *p_hc,HIDDevice *p_hd,unsigned int attach); + +struct _HIDClient +{ + HIDClient *next; + HIDAttachCallback attach_cb; +}; + +typedef void (*HIDCallback)(unsigned int handle,int error,unsigned char *p_buffer,unsigned int bytes_transferred,void *p_user); + +void InitSysHIDFunctionPointers(void); +void InitAcquireSysHID(void); + +extern int(*HIDSetup)(void); +extern int(*HIDTeardown)(void); + +extern int(*HIDAddClient)(HIDClient *p_client, HIDAttachCallback attach_callback); +extern int(*HIDDelClient)(HIDClient *p_client); + +extern int(*HIDGetDescriptor)(unsigned int handle,u8 descriptor_type,u8 descriptor_index, u16 language_id, unsigned char *p_buffer, unsigned int buffer_length, HIDCallback hc, void *p_user); +extern int(*HIDSetDescriptor)(unsigned int handle,u8 descriptor_type,u8 descriptor_index, u16 language_id, unsigned char *p_buffer, unsigned int buffer_length, HIDCallback hc, void *p_user); + +extern int(*HIDGetReport)(u32 handle, u8 report_type, u8 report_id, u8 *p_buffer, u32 buffer_length, HIDCallback hc, void *p_user); +extern int(*HIDSetReport)(u32 handle, u8 report_type, u8 report_id, u8 *p_buffer, u32 buffer_length, HIDCallback hc, void *p_user); + +extern int(*HIDSetIdle)(unsigned int handle, u8 interface_index,u8 duration, HIDCallback hc, void *p_user); + +extern int(* HIDSetProtocol)(unsigned int handle,u8 interface_index,u8 protocol, HIDCallback hc, void *p_user); +extern int(* HIDGetProtocol)(unsigned int handle,u8 interface_index,u8 * protocol, HIDCallback hc, void *p_user); + +extern int(*HIDRead)(unsigned int handle, unsigned char *p_buffer, unsigned int buffer_length, HIDCallback hc, void *p_user); +extern int(*HIDWrite)(unsigned int handle, unsigned char *p_buffer, unsigned int buffer_length, HIDCallback hc, void *p_user); + +#ifdef __cplusplus +} +#endif + +#endif // __SYSHID_FUNCTIONS_H_ diff --git a/wiiu/dynamic_libs/vpad_functions.c b/wiiu/dynamic_libs/vpad_functions.c index a2d8e3ff40..201cf343c8 100644 --- a/wiiu/dynamic_libs/vpad_functions.c +++ b/wiiu/dynamic_libs/vpad_functions.c @@ -24,16 +24,32 @@ #include "os_functions.h" #include "vpad_functions.h" +unsigned int vpad_handle __attribute__((section(".data"))) = 0; +unsigned int vpadbase_handle __attribute__((section(".data"))) = 0; + EXPORT_DECL(void, VPADInit, void); -EXPORT_DECL(void, VPADRead, int chan, VPADData *buffer, u32 buffer_size, s32 *error); +EXPORT_DECL(int, VPADRead, int chan, VPADData *buffer, u32 buffer_size, s32 *error); +EXPORT_DECL(int, VPADGetLcdMode, int padnum, int *lcdmode); +EXPORT_DECL(int, VPADSetLcdMode, int padnum, int lcdmode); +EXPORT_DECL(int, VPADBASEGetMotorOnRemainingCount, int padnum); +EXPORT_DECL(int, VPADBASESetMotorOnRemainingCount, int padnum, int counter); + +void InitAcquireVPad(void) +{ + OSDynLoad_Acquire("vpad.rpl", &vpad_handle); + OSDynLoad_Acquire("vpadbase.rpl", &vpadbase_handle); +} void InitVPadFunctionPointers(void) { unsigned int *funcPointer = 0; - unsigned int vpad_handle; - OSDynLoad_Acquire("vpad.rpl", &vpad_handle); + + InitAcquireVPad(); OS_FIND_EXPORT(vpad_handle, VPADInit); OS_FIND_EXPORT(vpad_handle, VPADRead); + OS_FIND_EXPORT(vpad_handle, VPADGetLcdMode); + OS_FIND_EXPORT(vpad_handle, VPADSetLcdMode); + OS_FIND_EXPORT(vpadbase_handle, VPADBASEGetMotorOnRemainingCount); + OS_FIND_EXPORT(vpadbase_handle, VPADBASESetMotorOnRemainingCount); } - diff --git a/wiiu/dynamic_libs/vpad_functions.h b/wiiu/dynamic_libs/vpad_functions.h index 00f7983be8..4fafda2d80 100644 --- a/wiiu/dynamic_libs/vpad_functions.h +++ b/wiiu/dynamic_libs/vpad_functions.h @@ -28,6 +28,9 @@ extern "C" { #endif +extern unsigned int vpad_handle; +extern unsigned int vpadbase_handle; + #include #define VPAD_BUTTON_A 0x8000 @@ -50,16 +53,20 @@ extern "C" { #define VPAD_BUTTON_STICK_L 0x00040000 #define VPAD_BUTTON_TV 0x00010000 -#define VPAD_STICK_R_EMULATION_LEFT 0x04000000 -#define VPAD_STICK_R_EMULATION_RIGHT 0x02000000 -#define VPAD_STICK_R_EMULATION_UP 0x01000000 -#define VPAD_STICK_R_EMULATION_DOWN 0x00800000 +#define VPAD_STICK_R_EMULATION_LEFT 0x04000000 +#define VPAD_STICK_R_EMULATION_RIGHT 0x02000000 +#define VPAD_STICK_R_EMULATION_UP 0x01000000 +#define VPAD_STICK_R_EMULATION_DOWN 0x00800000 -#define VPAD_STICK_L_EMULATION_LEFT 0x40000000 -#define VPAD_STICK_L_EMULATION_RIGHT 0x20000000 -#define VPAD_STICK_L_EMULATION_UP 0x10000000 -#define VPAD_STICK_L_EMULATION_DOWN 0x08000000 +#define VPAD_STICK_L_EMULATION_LEFT 0x40000000 +#define VPAD_STICK_L_EMULATION_RIGHT 0x20000000 +#define VPAD_STICK_L_EMULATION_UP 0x10000000 +#define VPAD_STICK_L_EMULATION_DOWN 0x08000000 +//! Own definitions +#define VPAD_BUTTON_TOUCH 0x00080000 +#define VPAD_MASK_EMULATED_STICKS 0x7F800000 +#define VPAD_MASK_BUTTONS ~VPAD_MASK_EMULATED_STICKS typedef struct { @@ -91,9 +98,14 @@ typedef struct } VPADData; void InitVPadFunctionPointers(void); +void InitAcquireVPad(void); +extern int (* VPADRead)(int chan, VPADData *buffer, u32 buffer_size, s32 *error); +extern int (* VPADGetLcdMode)(int padnum, int *lcdmode); +extern int (* VPADSetLcdMode)(int padnum, int lcdmode); extern void (* VPADInit)(void); -extern void (* VPADRead)(int chan, VPADData *buffer, u32 buffer_size, s32 *error); +extern int (* VPADBASEGetMotorOnRemainingCount)(int lcdmode); +extern int (* VPADBASESetMotorOnRemainingCount)(int lcdmode,int counter); #ifdef __cplusplus } diff --git a/wiiu/fs/fs_utils.c b/wiiu/fs/fs_utils.c index efa2e556b3..20af6dd1fd 100644 --- a/wiiu/fs/fs_utils.c +++ b/wiiu/fs/fs_utils.c @@ -3,7 +3,6 @@ #include #include #include -#include "common/fs_defs.h" #include "dynamic_libs/fs_functions.h" diff --git a/wiiu/fs/sd_fat_devoptab.c b/wiiu/fs/sd_fat_devoptab.c index f5b278bfae..2cee53e323 100644 --- a/wiiu/fs/sd_fat_devoptab.c +++ b/wiiu/fs/sd_fat_devoptab.c @@ -278,6 +278,7 @@ static ssize_t sd_fat_write_r (struct _reent *r, int fd, const char *ptr, size_t memcpy(tmpBuf, ptr + done, write_size); int result = FSWriteFile(file->dev->pClient, file->dev->pCmd, tmpBuf, 0x01, write_size, file->fd, 0, -1); + FSFlushFile(file->dev->pClient, file->dev->pCmd, file->fd, -1); if(result < 0) { r->_errno = result; diff --git a/wiiu/link.ld b/wiiu/link.ld index fc569d1267..f066c4ce3b 100644 --- a/wiiu/link.ld +++ b/wiiu/link.ld @@ -31,9 +31,6 @@ SECTIONS { } __CODE_END = .; - /DISCARD/ : { - *(*); - } } /******************************************************** FS ********************************************************/ diff --git a/wiiu/net.sh b/wiiu/net.sh index 81ba0d9fc6..a4705fe947 100755 --- a/wiiu/net.sh +++ b/wiiu/net.sh @@ -1,2 +1,4 @@ -python2 wiiu/wiiload.py retroarch_wiiu.elf sd:/zz.gb -netcat -p 4405 -l 10.42.0.170 +export WIILOAD=tcp:$1 +powerpc-eabi-strip retroarch_wiiu.elf -o retroarch_wiiu_stripped.elf +wiiload retroarch_wiiu_stripped.elf +netcat -p 4405 -l $1 diff --git a/wiiu/system/exception.h b/wiiu/system/exception.h new file mode 100644 index 0000000000..c322943f00 --- /dev/null +++ b/wiiu/system/exception.h @@ -0,0 +1,52 @@ +/* source: https://github.com/QuarkTheAwesome/URetro */ + +#include "wiiu/dynamic_libs/os_functions.h" + + +#ifndef __EXCEPTION_H__ +#define __EXCEPTION_H__ + +void exception_disassembly_helper(char *fmt, int addr,int opcode, char* s) +{ + char* *store = (char**)0x1ab5d140; + char *buffer = (char *)store[0]; + if (addr == ((int*)store)[1]) { + store[0] += __os_snprintf(buffer,512,"> 0x%08X 0x%08X %s\n", addr,opcode,s); + } else { + store[0] += __os_snprintf(buffer,512," 0x%08X 0x%08X %s\n", addr,opcode,s); + } + +} +unsigned char exception_handler(void* contextIn) { + + //Temporary hacky fix, please ignore me. + + unsigned int coreinit_handle; + OSDynLoad_Acquire("coreinit.rpl", &coreinit_handle); + void (*DisassemblePPCRange)(void *start, void *end, void *printf_func, int *find_symbol_func, int flags); + OSDynLoad_FindExport(coreinit_handle, 0, "DisassemblePPCRange", &DisassemblePPCRange); + + int* context = (int*)contextIn; + + char buf2[512]; + int* store = (int*)0x1AB5D140; + store[0] = (int)buf2; + store[1] = (int)context[38]; + + + DisassemblePPCRange((void*)context[38]-0x18, (void*)context[38]+0x4, (void*)exception_disassembly_helper, 0, 0); + char buf[2048]; + __os_snprintf(buf, 2048, "SP:%08X LR:%08X PC:%08X CR:%08X CTR:%08X\nXER:%08X SR0:%08X SR1:%08X EX0:%08X EX1:%08X\nr0:%08X r2:%08X r3:%08X r4:%08X r5:%08X\nr6:%08X r7:%08X r8:%08X r9:%08X r10:%08X\nr11:%08X r12:%08X r13:%08X r14:%08X r15:%08X\nr16:%08X r17:%08X r18:%08X r19:%08X r20:%08X\nr21:%08X r22:%08X r23:%08X r24:%08X r25:%08X\nr26:%08X r27:%08X r28:%08X r29:%08X r30:%08X\nr31:%08X\n%s", context[3], context[35], context[38], context[34], context[36], context[37], context[38], context[39], context[40], context[41], context[2], context[4], context[5], context[6], context[7], context[8], context[9], context[10], context[11], context[12], context[13], context[14], context[15], context[16], context[17], context[18], context[19], context[20], context[21], context[22], context[23], context[24], context[25], context[26], context[27], context[28], context[29], context[30], context[31], context[32], context[33], buf2); + void net_print(const char* str); + net_print(buf); + OSFatal(buf); + + return 0; +} +void InstallExceptionHandler() { + OSSetExceptionCallback(2, &exception_handler); + OSSetExceptionCallback(3, &exception_handler); + OSSetExceptionCallback(6, &exception_handler); +} + +#endif //__EXCEPTION_H__ diff --git a/wiiu/system/exception_handler.c b/wiiu/system/exception_handler.c new file mode 100644 index 0000000000..716141dbaf --- /dev/null +++ b/wiiu/system/exception_handler.c @@ -0,0 +1,171 @@ +#include +#include "dynamic_libs/os_functions.h" +#include "exception_handler.h" +#include "wiiu/wiiu_dbg.h" + +#define OS_EXCEPTION_MODE_GLOBAL_ALL_CORES 4 + +#define OS_EXCEPTION_DSI 2 +#define OS_EXCEPTION_ISI 3 +#define OS_EXCEPTION_PROGRAM 6 + +/* Exceptions */ +typedef struct OSContext +{ + /* OSContext identifier */ + uint32_t tag1; + uint32_t tag2; + + /* GPRs */ + uint32_t gpr[32]; + + /* Special registers */ + uint32_t cr; + uint32_t lr; + uint32_t ctr; + uint32_t xer; + + /* Initial PC and MSR */ + uint32_t srr0; + uint32_t srr1; + + /* Only valid during DSI exception */ + uint32_t exception_specific0; + uint32_t exception_specific1; + + /* There is actually a lot more here but we don't need the rest*/ +} OSContext; + +#define CPU_STACK_TRACE_DEPTH 10 +#define __stringify(rn) #rn + +#define mfspr(_rn) \ +({ register uint32_t _rval = 0; \ + asm volatile("mfspr %0," __stringify(_rn) \ + : "=r" (_rval));\ + _rval; \ +}) + +typedef struct _framerec { + struct _framerec *up; + void *lr; +} frame_rec, *frame_rec_t; + +static const char *exception_names[] = { + "DSI", + "ISI", + "PROGRAM" +}; + +static const char exception_print_formats[18][45] = { + "Exception type %s occurred!\n", // 0 + "GPR00 %08X GPR08 %08X GPR16 %08X GPR24 %08X\n", // 1 + "GPR01 %08X GPR09 %08X GPR17 %08X GPR25 %08X\n", // 2 + "GPR02 %08X GPR10 %08X GPR18 %08X GPR26 %08X\n", // 3 + "GPR03 %08X GPR11 %08X GPR19 %08X GPR27 %08X\n", // 4 + "GPR04 %08X GPR12 %08X GPR20 %08X GPR28 %08X\n", // 5 + "GPR05 %08X GPR13 %08X GPR21 %08X GPR29 %08X\n", // 6 + "GPR06 %08X GPR14 %08X GPR22 %08X GPR30 %08X\n", // 7 + "GPR07 %08X GPR15 %08X GPR23 %08X GPR31 %08X\n", // 8 + "LR %08X SRR0 %08x SRR1 %08x\n", // 9 + "DAR %08X DSISR %08X\n", // 10 + "STACK DUMP:", // 11 + " --> ", // 12 + " -->\n", // 13 + "\n", // 14 + "%p", // 15 + "\nCODE DUMP:\n", // 16 + "%p: %08X %08X %08X %08X\n", // 17 +}; + +static unsigned char exception_cb(void * c, unsigned char exception_type) { + char buf[4096]; + int pos = 0; + + OSContext *context = (OSContext *) c; + /* + * This part is mostly from libogc. Thanks to the devs over there. + */ + pos += sprintf(buf + pos, exception_print_formats[0], exception_names[exception_type]); + pos += sprintf(buf + pos, exception_print_formats[1], context->gpr[0], context->gpr[8], context->gpr[16], context->gpr[24]); + pos += sprintf(buf + pos, exception_print_formats[2], context->gpr[1], context->gpr[9], context->gpr[17], context->gpr[25]); + pos += sprintf(buf + pos, exception_print_formats[3], context->gpr[2], context->gpr[10], context->gpr[18], context->gpr[26]); + pos += sprintf(buf + pos, exception_print_formats[4], context->gpr[3], context->gpr[11], context->gpr[19], context->gpr[27]); + pos += sprintf(buf + pos, exception_print_formats[5], context->gpr[4], context->gpr[12], context->gpr[20], context->gpr[28]); + pos += sprintf(buf + pos, exception_print_formats[6], context->gpr[5], context->gpr[13], context->gpr[21], context->gpr[29]); + pos += sprintf(buf + pos, exception_print_formats[7], context->gpr[6], context->gpr[14], context->gpr[22], context->gpr[30]); + pos += sprintf(buf + pos, exception_print_formats[8], context->gpr[7], context->gpr[15], context->gpr[23], context->gpr[31]); + pos += sprintf(buf + pos, exception_print_formats[9], context->lr, context->srr0, context->srr1); + + //if(exception_type == OS_EXCEPTION_DSI) { + pos += sprintf(buf + pos, exception_print_formats[10], context->exception_specific1, context->exception_specific0); // this freezes + //} + + void *pc = (void*)context->srr0; + void *lr = (void*)context->lr; + void *r1 = (void*)context->gpr[1]; + register uint32_t i = 0; + register frame_rec_t l,p = (frame_rec_t)lr; + + l = p; + p = r1; + if(!p) + asm volatile("mr %0,%%r1" : "=r"(p)); + + pos += sprintf(buf + pos, exception_print_formats[11]); + + for(i = 0; i < CPU_STACK_TRACE_DEPTH-1 && p->up; p = p->up, i++) { + if(i % 4) + pos += sprintf(buf + pos, exception_print_formats[12]); + else { + if(i > 0) + pos += sprintf(buf + pos, exception_print_formats[13]); + else + pos += sprintf(buf + pos, exception_print_formats[14]); + } + + switch(i) { + case 0: + if(pc) + pos += sprintf(buf + pos, exception_print_formats[15],pc); + break; + case 1: + if(!l) + l = (frame_rec_t)mfspr(8); + pos += sprintf(buf + pos, exception_print_formats[15],(void*)l); + break; + default: + pos += sprintf(buf + pos, exception_print_formats[15],(void*)(p->up->lr)); + break; + } + } + + //if(exception_type == OS_EXCEPTION_DSI) { + uint32_t *pAdd = (uint32_t*)context->srr0; + pos += sprintf(buf + pos, exception_print_formats[16]); + // TODO by Dimok: this was actually be 3 instead of 2 lines in libogc .... but there is just no more space anymore on the screen + for (i = 0; i < 8; i += 4) + pos += sprintf(buf + pos, exception_print_formats[17], &(pAdd[i]),pAdd[i], pAdd[i+1], pAdd[i+2], pAdd[i+3]); + //} + void net_print(const char* str); + + net_print(buf); + OSFatal(buf); + return 1; +} + +static unsigned char dsi_exception_cb(void * context) { + return exception_cb(context, 0); +} +static unsigned char isi_exception_cb(void * context) { + return exception_cb(context, 1); +} +static unsigned char program_exception_cb(void * context) { + return exception_cb(context, 2); +} + +void setup_os_exceptions(void) { + OSSetExceptionCallback(OS_EXCEPTION_DSI, &dsi_exception_cb); + OSSetExceptionCallback(OS_EXCEPTION_ISI, &isi_exception_cb); + OSSetExceptionCallback(OS_EXCEPTION_PROGRAM, &program_exception_cb); +} diff --git a/wiiu/system/exception_handler.h b/wiiu/system/exception_handler.h new file mode 100644 index 0000000000..7626f92877 --- /dev/null +++ b/wiiu/system/exception_handler.h @@ -0,0 +1,14 @@ +#ifndef __EXCEPTION_HANDLER_H_ +#define __EXCEPTION_HANDLER_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +void setup_os_exceptions(void); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/wiiu/system/memory.c b/wiiu/system/memory.c index 46f2d313a6..64c0fa0ce9 100644 --- a/wiiu/system/memory.c +++ b/wiiu/system/memory.c @@ -38,6 +38,7 @@ extern unsigned int * pMEMAllocFromDefaultHeapEx; extern unsigned int * pMEMAllocFromDefaultHeap; extern unsigned int * pMEMFreeToDefaultHeap; +extern int (*MEMGetSizeForMBlockExpHeap)(void *ptr); extern int (* MEMGetBaseHeapHandle)(int mem_arena); extern unsigned int (* MEMGetAllocatableSizeForFrmHeapEx)(int heap, int align); extern void *(* MEMAllocFromFrmHeapEx)(int heap, unsigned int size, int align); @@ -76,12 +77,15 @@ void memoryRelease(void) bucket_heap = -1; } +#if 0 //!------------------------------------------------------------------------------------------- //! wraps //!------------------------------------------------------------------------------------------- void *__wrap_malloc(size_t size) { // pointer to a function resolve + if(!size) + return NULL; return ((void * (*)(size_t))(*pMEMAllocFromDefaultHeap))(size); } @@ -89,7 +93,8 @@ void *__wrap_memalign(size_t align, size_t size) { if (align < 4) align = 4; - + if(!size) + return NULL; // pointer to a function resolve return ((void * (*)(size_t, size_t))(*pMEMAllocFromDefaultHeapEx))(size, align); } @@ -159,7 +164,106 @@ void *__wrap__realloc_r(struct _reent *r, void *p, size_t size) { return __wrap_realloc(p, size); } +#else +void * +__wrap_memalign(size_t alignment, size_t size) { + return MEMAllocFromExpHeapEx(MEMGetBaseHeapHandle(MEMORY_ARENA_2), size, alignment); +} + +void * +__wrap_malloc(size_t size) { + return __wrap_memalign(4, size); +} + +void +__wrap_free(void *ptr) { + if (ptr) { + MEMFreeToExpHeap(MEMGetBaseHeapHandle(MEMORY_ARENA_2), ptr); + } +} + +size_t +__wrap_malloc_usable_size(void *ptr) { + return MEMGetSizeForMBlockExpHeap(ptr); +} + +void * +__wrap_realloc(void *ptr, size_t size) { + if (!ptr) { + return __wrap_malloc(size); + } + + if (__wrap_malloc_usable_size(ptr) >= size) { + return ptr; + } + + void *realloc_ptr = __wrap_malloc(size); + + if(!realloc_ptr) { + return NULL; + } + + memcpy(realloc_ptr, ptr, __wrap_malloc_usable_size(ptr)); + __wrap_free(ptr); + + return realloc_ptr; +} + +void * +__wrap_calloc(size_t num, size_t size) { + void *ptr = __wrap_malloc(num*size); + + if(ptr) { + memset(ptr, 0, num*size); + } + + return ptr; +} + +void * +__wrap_valloc(size_t size) { + return __wrap_memalign(64, size); +} + + + +void * +__wrap__memalign_r(struct _reent *r, size_t alignment, size_t size) { + return __wrap_memalign(alignment, size); +} + +void * +__wrap__malloc_r(struct _reent *r, size_t size) { + return __wrap_malloc(size); +} + +void +__wrap__free_r(struct _reent *r, void *ptr) { + return __wrap_free(ptr); +} + +void * +__wrap__realloc_r(struct _reent *r, void *ptr, size_t size) { + return __wrap_realloc(ptr, size); +} + +void * +__wrap__calloc_r(struct _reent *r, size_t num, size_t size) { + return __wrap_calloc(num, size); +} + +size_t +__wrap__malloc_usable_size_r(struct _reent *r, void *ptr) { + return __wrap_malloc_usable_size(ptr); +} + +void * +__wrap__valloc_r(struct _reent *r, size_t size) { + return __wrap_valloc(size); +} + +#endif //!------------------------------------------------------------------------------------------- //! some wrappers //!-------------------------------------------------------------------------------------------