mirror/RetroArch
1
0
Fork 0
mirror of https://github.com/libretro/RetroArch synced 2025-04-07 13:23:32 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #7938 from frangarcj/orbis2

Browse Source 
[ORBIS] Some driver fixes and host filesystem support
This commit is contained in:
Twinaphex 2019-01-08 20:18:48 +01:00 committed by GitHub
commit 6aa501bc70
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
30 changed files with 1024 additions and 48 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
AUTHORS.h
View File

@ -25,6 +25,7 @@ Amiga1200Gamer (amigagamer)
Andre Leiradella (leiradel) Andre Leiradella (leiradel)
Andrés (fr500) Andrés (fr500)
Anthony J. Bentley (bentley) Anthony J. Bentley (bentley)
Antonio Jose Ramos Marquez (psxdev)
AridRayne AridRayne
Arto Vainiolehto (arakerlu) Arto Vainiolehto (arakerlu)
asako (asakous) asako (asakous)

1
Makefile.common
View File

@ -189,6 +189,7 @@ OBJ += frontend/frontend.o \
$(LIBRETRO_COMM_DIR)/file/nbio/nbio_linux.o \ $(LIBRETRO_COMM_DIR)/file/nbio/nbio_linux.o \
$(LIBRETRO_COMM_DIR)/file/nbio/nbio_unixmmap.o \ $(LIBRETRO_COMM_DIR)/file/nbio/nbio_unixmmap.o \
$(LIBRETRO_COMM_DIR)/file/nbio/nbio_windowsmmap.o \ $(LIBRETRO_COMM_DIR)/file/nbio/nbio_windowsmmap.o \
$(LIBRETRO_COMM_DIR)/file/nbio/nbio_orbis.o \
$(LIBRETRO_COMM_DIR)/file/nbio/nbio_intf.o \ $(LIBRETRO_COMM_DIR)/file/nbio/nbio_intf.o \
$(LIBRETRO_COMM_DIR)/file/file_path.o \ $(LIBRETRO_COMM_DIR)/file/file_path.o \
file_path_special.o \ file_path_special.o \

10
Makefile.orbis
View File

@ -29,7 +29,7 @@ else
HAVE_RJPEG := 1 HAVE_RJPEG := 1
HAVE_RBMP := 1 HAVE_RBMP := 1
HAVE_RTGA := 1 HAVE_RTGA := 1
HAVE_ZLIB := 0 HAVE_ZLIB := 1
HAVE_OVERLAY := 1 HAVE_OVERLAY := 1
HAVE_7ZIP := 1 HAVE_7ZIP := 1
HAVE_EGL := 1 HAVE_EGL := 1
@ -59,9 +59,9 @@ else
BLACKLIST := BLACKLIST :=
OBJ := $(filter-out $(BLACKLIST),$(OBJ)) OBJ := $(filter-out $(BLACKLIST),$(OBJ))
#OBJ += input/drivers/psp_input.o OBJ += input/drivers/ps4_input.o
#OBJ += input/drivers_joypad/psp_joypad.o OBJ += input/drivers_joypad/ps4_joypad.o
#OBJ += audio/drivers/psp_audio.o OBJ += audio/drivers/psp_audio.o
#OBJ += frontend/drivers/platform_orbis.o #OBJ += frontend/drivers/platform_orbis.o
endif endif
@ -120,7 +120,7 @@ ifeq ($(WHOLE_ARCHIVE_LINK), 1)
endif endif
CXXFLAGS := $(CFLAGS) CXXFLAGS := $(CFLAGS)
PS4_LIBS := -lps4link -ldebugnet -lorbisFile -lelfloader -lorbisKeyboard -lorbis2d -lpng -lz -lorbisGl -lorbisPad -lorbisAudio -lmod -lorbisAudio -lmod -lorbisFileBrowser -lorbisXbmFont -lSceNet_stub -lScePigletv2VSH_stub -lSceSystemService_stub -lSceUserService_stub -lScePad_stub -lSceAudioOut_stub -lSceIme_stub -lSceSysmodule_stub \ PS4_LIBS := -lps4link -ldebugnet -lorbisFile -lelfloader -lorbisKeyboard -lorbis2d -lpng -lz -lorbisGl -lorbisPad -lorbisAudio -lmod -lorbisFileBrowser -lorbisXbmFont -lSceNet_stub -lScePigletv2VSH_stub -lSceSystemService_stub -lSceUserService_stub -lScePad_stub -lSceAudioOut_stub -lSceIme_stub -lSceSysmodule_stub \
-lPs4_extension_kernel_call_standard -lPs4_extension_kernel_execute_dynlib_prepare_dlclose -lPs4_common_kernel -lPs4_common_user -lPs4_common_generic -lPs4LibCInternalAdaptive_stub -lPs4LibKernelAdaptive_stub -lSceLibcInternal_stub -lkernel_stub -lps4Kernel_stub -lPs4_base_stub_resolve_minimal -lPs4_base_kernel_dlsym_standard -lPs4_base_kernel_seek_elf_address_standard -lPs4_base_assembler_register_parameter_standard -lPs4_base_assembler_system_call_standard -lPs4_extension_kernel_call_standard -lPs4_extension_kernel_execute_dynlib_prepare_dlclose -lPs4_common_kernel -lPs4_common_user -lPs4_common_generic -lPs4LibCInternalAdaptive_stub -lPs4LibKernelAdaptive_stub -lSceLibcInternal_stub -lkernel_stub -lps4Kernel_stub -lPs4_base_stub_resolve_minimal -lPs4_base_kernel_dlsym_standard -lPs4_base_kernel_seek_elf_address_standard -lPs4_base_assembler_register_parameter_standard -lPs4_base_assembler_system_call_standard
LIBS := $(WHOLE_START) -lretro_orbis $(WHOLE_END) $(PS4_LIBS) LIBS := $(WHOLE_START) -lretro_orbis $(WHOLE_END) $(PS4_LIBS)

2
audio/audio_driver.c
View File

@ -119,7 +119,7 @@ static const audio_driver_t *audio_drivers[] = {
#ifdef EMSCRIPTEN #ifdef EMSCRIPTEN
&audio_rwebaudio, &audio_rwebaudio,
#endif #endif
#if defined(PSP) || defined(VITA) #if defined(PSP) || defined(VITA) || defined(ORBIS)
&audio_psp, &audio_psp,
#endif #endif
#if defined(PS2) #if defined(PS2)

38
audio/drivers/psp_audio.c
View File

@ -16,21 +16,28 @@
*/ */
#include <stdint.h> #include <stdint.h>
#if defined(VITA) || defined(PSP)
#include <malloc.h> #include <malloc.h>
#endif
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
#include <rthreads/rthreads.h> #include <rthreads/rthreads.h>
#include <queues/fifo_queue.h> #include <queues/fifo_queue.h>
#ifdef VITA #if defined(VITA)
#include <psp2/kernel/processmgr.h> #include <psp2/kernel/processmgr.h>
#include <psp2/kernel/threadmgr.h> #include <psp2/kernel/threadmgr.h>
#include <psp2/kernel/sysmem.h> #include <psp2/kernel/sysmem.h>
#include <psp2/audioout.h> #include <psp2/audioout.h>
#else #elif defined(PSP)
#include <pspkernel.h> #include <pspkernel.h>
#include <pspaudio.h> #include <pspaudio.h>
#elif defined(ORBIS)
#include <audioout.h>
#define SCE_AUDIO_OUT_PORT_TYPE_MAIN 0
#define SCE_AUDIO_OUT_MODE_STEREO 1
#define SceUID uint32_t
#endif #endif
#include "../audio_driver.h" #include "../audio_driver.h"
@ -64,10 +71,14 @@ static void audioMainLoop(void *data)
{ {
psp_audio_t* psp = (psp_audio_t*)data; psp_audio_t* psp = (psp_audio_t*)data;
#ifdef VITA #if defined(VITA)
int port = sceAudioOutOpenPort( int port = sceAudioOutOpenPort(
SCE_AUDIO_OUT_PORT_TYPE_MAIN, AUDIO_OUT_COUNT, SCE_AUDIO_OUT_PORT_TYPE_MAIN, AUDIO_OUT_COUNT,
psp->rate, SCE_AUDIO_OUT_MODE_STEREO); psp->rate, SCE_AUDIO_OUT_MODE_STEREO);
#elif defined(ORBIS)
int port = sceAudioOutOpen(0xff,
SCE_AUDIO_OUT_PORT_TYPE_MAIN, 0, AUDIO_OUT_COUNT,
psp->rate, SCE_AUDIO_OUT_MODE_STEREO);
#else #else
sceAudioSRCChReserve(AUDIO_OUT_COUNT, psp->rate, 2); sceAudioSRCChReserve(AUDIO_OUT_COUNT, psp->rate, 2);
#endif #endif
@ -95,7 +106,7 @@ static void audioMainLoop(void *data)
scond_signal(psp->cond); scond_signal(psp->cond);
slock_unlock(psp->cond_lock); slock_unlock(psp->cond_lock);
#ifdef VITA #if defined(VITA) || defined(ORBIS)
sceAudioOutOutput(port, sceAudioOutOutput(port,
cond ? (psp->zeroBuffer) cond ? (psp->zeroBuffer)
: (psp->buffer + read_pos_2)); : (psp->buffer + read_pos_2));
@ -105,8 +116,10 @@ static void audioMainLoop(void *data)
#endif #endif
} }
#ifdef VITA #if defined(VITA)
sceAudioOutReleasePort(port); sceAudioOutReleasePort(port);
#elif defined(ORBIS)
sceAudioOutClose(port);
#else #else
sceAudioSRCChRelease(); sceAudioSRCChRelease();
#endif #endif
@ -127,12 +140,23 @@ static void *psp_audio_init(const char *device,
(void)device; (void)device;
(void)latency; (void)latency;
#ifdef ORBIS
psp->buffer = (uint32_t*)
malloc(AUDIO_BUFFER_SIZE * sizeof(uint32_t));
#else
/* Cache aligned, not necessary but helpful. */ /* Cache aligned, not necessary but helpful. */
psp->buffer = (uint32_t*) psp->buffer = (uint32_t*)
memalign(64, AUDIO_BUFFER_SIZE * sizeof(uint32_t)); memalign(64, AUDIO_BUFFER_SIZE * sizeof(uint32_t));
#endif
memset(psp->buffer, 0, AUDIO_BUFFER_SIZE * sizeof(uint32_t)); memset(psp->buffer, 0, AUDIO_BUFFER_SIZE * sizeof(uint32_t));
#ifdef ORBIS
psp->zeroBuffer = (uint32_t*)
malloc(AUDIO_OUT_COUNT * sizeof(uint32_t));
#else
psp->zeroBuffer = (uint32_t*) psp->zeroBuffer = (uint32_t*)
memalign(64, AUDIO_OUT_COUNT * sizeof(uint32_t)); memalign(64, AUDIO_OUT_COUNT * sizeof(uint32_t));
#endif
memset(psp->zeroBuffer, 0, AUDIO_OUT_COUNT * sizeof(uint32_t)); memset(psp->zeroBuffer, 0, AUDIO_OUT_COUNT * sizeof(uint32_t));
psp->read_pos = 0; psp->read_pos = 0;
@ -302,8 +326,10 @@ audio_driver_t audio_psp = {
psp_audio_set_nonblock_state, psp_audio_set_nonblock_state,
psp_audio_free, psp_audio_free,
psp_audio_use_float, psp_audio_use_float,
#ifdef VITA #if defined(VITA)
"vita", "vita",
#elif defined(ORBIS)
"orbis",
#else #else
"psp", "psp",
#endif #endif

2
config.def.h
View File

@ -405,7 +405,7 @@ static unsigned menu_toggle_gamepad_combo = INPUT_TOGGLE_L3_R3;
static unsigned menu_toggle_gamepad_combo = INPUT_TOGGLE_HOLD_START; static unsigned menu_toggle_gamepad_combo = INPUT_TOGGLE_HOLD_START;
#elif defined(VITA) #elif defined(VITA)
static unsigned menu_toggle_gamepad_combo = INPUT_TOGGLE_L1_R1_START_SELECT; static unsigned menu_toggle_gamepad_combo = INPUT_TOGGLE_L1_R1_START_SELECT;
#elif defined(SWITCH) #elif defined(SWITCH) || defined(ORBIS)
static unsigned menu_toggle_gamepad_combo = INPUT_TOGGLE_START_SELECT; static unsigned menu_toggle_gamepad_combo = INPUT_TOGGLE_START_SELECT;
#else #else
static unsigned menu_toggle_gamepad_combo = INPUT_TOGGLE_NONE; static unsigned menu_toggle_gamepad_combo = INPUT_TOGGLE_NONE;

16
configuration.c
View File

@ -218,6 +218,7 @@ enum input_driver_enum
INPUT_X, INPUT_X,
INPUT_WAYLAND, INPUT_WAYLAND,
INPUT_DINPUT, INPUT_DINPUT,
INPUT_PS4,
INPUT_PS3, INPUT_PS3,
INPUT_PSP, INPUT_PSP,
INPUT_PS2, INPUT_PS2,
@ -244,6 +245,7 @@ enum joypad_driver_enum
JOYPAD_GX, JOYPAD_GX,
JOYPAD_WIIU, JOYPAD_WIIU,
JOYPAD_XDK, JOYPAD_XDK,
JOYPAD_PS4,
JOYPAD_PSP, JOYPAD_PSP,
JOYPAD_PS2, JOYPAD_PS2,
JOYPAD_CTR, JOYPAD_CTR,
@ -371,7 +373,7 @@ static enum audio_driver_enum AUDIO_DEFAULT_DRIVER = AUDIO_XENON360;
static enum audio_driver_enum AUDIO_DEFAULT_DRIVER = AUDIO_WII; static enum audio_driver_enum AUDIO_DEFAULT_DRIVER = AUDIO_WII;
#elif defined(WIIU) #elif defined(WIIU)
static enum audio_driver_enum AUDIO_DEFAULT_DRIVER = AUDIO_WIIU; static enum audio_driver_enum AUDIO_DEFAULT_DRIVER = AUDIO_WIIU;
#elif defined(PSP) || defined(VITA) #elif defined(PSP) || defined(VITA) || defined(ORBIS)
static enum audio_driver_enum AUDIO_DEFAULT_DRIVER = AUDIO_PSP; static enum audio_driver_enum AUDIO_DEFAULT_DRIVER = AUDIO_PSP;
#elif defined(PS2) #elif defined(PS2)
static enum audio_driver_enum AUDIO_DEFAULT_DRIVER = AUDIO_PS2; static enum audio_driver_enum AUDIO_DEFAULT_DRIVER = AUDIO_PS2;
@ -453,6 +455,8 @@ static enum input_driver_enum INPUT_DEFAULT_DRIVER = INPUT_SDL2;
static enum input_driver_enum INPUT_DEFAULT_DRIVER = INPUT_RWEBINPUT; static enum input_driver_enum INPUT_DEFAULT_DRIVER = INPUT_RWEBINPUT;
#elif defined(_WIN32) #elif defined(_WIN32)
static enum input_driver_enum INPUT_DEFAULT_DRIVER = INPUT_DINPUT; static enum input_driver_enum INPUT_DEFAULT_DRIVER = INPUT_DINPUT;
#elif defined(ORBIS)
static enum input_driver_enum INPUT_DEFAULT_DRIVER = INPUT_PS4;
#elif defined(__CELLOS_LV2__) #elif defined(__CELLOS_LV2__)
static enum input_driver_enum INPUT_DEFAULT_DRIVER = INPUT_PS3; static enum input_driver_enum INPUT_DEFAULT_DRIVER = INPUT_PS3;
#elif defined(PSP) || defined(VITA) #elif defined(PSP) || defined(VITA)
@ -499,6 +503,8 @@ static enum joypad_driver_enum JOYPAD_DEFAULT_DRIVER = JOYPAD_GX;
static enum joypad_driver_enum JOYPAD_DEFAULT_DRIVER = JOYPAD_WIIU; static enum joypad_driver_enum JOYPAD_DEFAULT_DRIVER = JOYPAD_WIIU;
#elif defined(_XBOX) #elif defined(_XBOX)
static enum joypad_driver_enum JOYPAD_DEFAULT_DRIVER = JOYPAD_XDK; static enum joypad_driver_enum JOYPAD_DEFAULT_DRIVER = JOYPAD_XDK;
#elif defined(ORBIS)
static enum joypad_driver_enum JOYPAD_DEFAULT_DRIVER = JOYPAD_PS4;
#elif defined(PSP) || defined(VITA) #elif defined(PSP) || defined(VITA)
static enum joypad_driver_enum JOYPAD_DEFAULT_DRIVER = JOYPAD_PSP; static enum joypad_driver_enum JOYPAD_DEFAULT_DRIVER = JOYPAD_PSP;
#elif defined(PS2) #elif defined(PS2)
@ -687,8 +693,10 @@ const char *config_get_default_audio(void)
case AUDIO_WIIU: case AUDIO_WIIU:
return "AX"; return "AX";
case AUDIO_PSP: case AUDIO_PSP:
#ifdef VITA #if defined(VITA)
return "vita"; return "vita";
#elif defined(ORBIS)
return "orbis";
#else #else
return "psp"; return "psp";
#endif #endif
@ -843,6 +851,8 @@ const char *config_get_default_input(void)
{ {
case INPUT_ANDROID: case INPUT_ANDROID:
return "android"; return "android";
case INPUT_PS4:
return "ps4";
case INPUT_PS3: case INPUT_PS3:
return "ps3"; return "ps3";
case INPUT_PSP: case INPUT_PSP:
@ -909,6 +919,8 @@ const char *config_get_default_joypad(void)
switch (default_driver) switch (default_driver)
{ {
case JOYPAD_PS4:
return "ps4";
case JOYPAD_PS3: case JOYPAD_PS3:
return "ps3"; return "ps3";
case JOYPAD_XINPUT: case JOYPAD_XINPUT:

4
dirs.c
View File

@ -308,7 +308,11 @@ void dir_check_defaults(void)
/* early return for people with a custom folder setup /* early return for people with a custom folder setup
so it doesn't create unnecessary directories so it doesn't create unnecessary directories
*/ */
#ifdef ORBIS
if (filestream_exists("host0:app/custom.ini"))
#else
if (filestream_exists("custom.ini")) if (filestream_exists("custom.ini"))
#endif
return; return;
for (i = 0; i < DEFAULT_DIR_LAST; i++) for (i = 0; i < DEFAULT_DIR_LAST; i++)

34
frontend/drivers/platform_orbis.c
View File

@ -34,6 +34,7 @@
#include <ps4link.h> #include <ps4link.h>
#include <orbisKeyboard.h> #include <orbisKeyboard.h>
#include <debugnet.h> #include <debugnet.h>
#include <orbisFile.h>
#include <pthread.h> #include <pthread.h>
@ -106,13 +107,32 @@ static void frontend_orbis_get_environment_settings(int *argc, char *argv[],
#if defined(HAVE_LOGGER) #if defined(HAVE_LOGGER)
logger_init(); logger_init();
#elif defined(HAVE_FILE_LOGGER) #elif defined(HAVE_FILE_LOGGER)
retro_main_log_file_init("host0:/temp/retroarch-log.txt"); retro_main_log_file_init("host0:app/temp/retroarch-log.txt");
#endif #endif
#endif #endif
strlcpy(eboot_path, "host0:/", sizeof(eboot_path)); int ret;
sceSystemServiceHideSplashScreen();
uintptr_t intptr=0;
sscanf(argv[1],"%p",&intptr);
argv[1] = NULL;
myConf=(OrbisGlobalConf *)intptr;
ret=ps4LinkInitWithConf(myConf->confLink);
if(!ret)
{
ps4LinkFinish();
return;
}
orbisFileInit();
orbisPadInitWithConf(myConf->confPad);
scePadClose(myConf->confPad->padHandle);
strlcpy(eboot_path, "host0:app", sizeof(eboot_path));
strlcpy(g_defaults.dirs[DEFAULT_DIR_PORT], eboot_path, sizeof(g_defaults.dirs[DEFAULT_DIR_PORT])); strlcpy(g_defaults.dirs[DEFAULT_DIR_PORT], eboot_path, sizeof(g_defaults.dirs[DEFAULT_DIR_PORT]));
strlcpy(user_path, "host0:/data/retroarch/", sizeof(user_path)); strlcpy(user_path, "host0:app/data/retroarch/", sizeof(user_path));
RARCH_LOG("port dir: [%s]\n", g_defaults.dirs[DEFAULT_DIR_PORT]); RARCH_LOG("port dir: [%s]\n", g_defaults.dirs[DEFAULT_DIR_PORT]);
@ -159,7 +179,7 @@ static void frontend_orbis_get_environment_settings(int *argc, char *argv[],
params = (struct rarch_main_wrap*)params_data; params = (struct rarch_main_wrap*)params_data;
params->verbose = true; params->verbose = true;
if (!string_is_empty(argv[1])) if (!string_is_empty(argv[2]))
{ {
static char path[PATH_MAX_LENGTH] = {0}; static char path[PATH_MAX_LENGTH] = {0};
struct rarch_main_wrap *args = struct rarch_main_wrap *args =
@ -167,7 +187,7 @@ static void frontend_orbis_get_environment_settings(int *argc, char *argv[],
if (args) if (args)
{ {
strlcpy(path, argv[1], sizeof(path)); strlcpy(path, argv[2], sizeof(path));
args->touched = true; args->touched = true;
args->no_content = false; args->no_content = false;
@ -182,7 +202,7 @@ static void frontend_orbis_get_environment_settings(int *argc, char *argv[],
RARCH_LOG("argv[1]: %s\n", argv[1]); RARCH_LOG("argv[1]: %s\n", argv[1]);
RARCH_LOG("argv[2]: %s\n", argv[2]); RARCH_LOG("argv[2]: %s\n", argv[2]);
RARCH_LOG("Auto-start game %s.\n", argv[1]); RARCH_LOG("Auto-start game %s.\n", argv[2]);
} }
} }
#endif #endif
@ -307,7 +327,7 @@ static int frontend_orbis_parse_drive_list(void *data, bool load_content)
MSG_UNKNOWN; MSG_UNKNOWN;
menu_entries_append_enum(list, menu_entries_append_enum(list,
"app0", "host0:app",
msg_hash_to_str(MENU_ENUM_LABEL_FILE_DETECT_CORE_LIST_PUSH_DIR), msg_hash_to_str(MENU_ENUM_LABEL_FILE_DETECT_CORE_LIST_PUSH_DIR),
enum_idx, enum_idx,
FILE_TYPE_DIRECTORY, 0, 0); FILE_TYPE_DIRECTORY, 0, 0);

2
frontend/frontend.c
View File

@ -161,7 +161,6 @@ int rarch_main(int argc, char *argv[], void *data)
} }
#ifndef HAVE_MAIN #ifndef HAVE_MAIN
#ifndef ORBIS
#ifdef __cplusplus #ifdef __cplusplus
extern "C" extern "C"
#endif #endif
@ -170,4 +169,3 @@ int main(int argc, char *argv[])
return rarch_main(argc, argv, NULL); return rarch_main(argc, argv, NULL);
} }
#endif #endif
#endif

3
frontend/frontend_driver.c
View File

@ -85,6 +85,9 @@ static frontend_ctx_driver_t *frontend_ctx_drivers[] = {
#endif #endif
#ifdef SWITCH #ifdef SWITCH
&frontend_ctx_switch, &frontend_ctx_switch,
#endif
#if defined(ORBIS)
&frontend_ctx_orbis,
#endif #endif
&frontend_ctx_null, &frontend_ctx_null,
NULL NULL

1
frontend/frontend_driver.h
View File

@ -129,6 +129,7 @@ extern frontend_ctx_driver_t frontend_ctx_xenon;
extern frontend_ctx_driver_t frontend_ctx_emscripten; extern frontend_ctx_driver_t frontend_ctx_emscripten;
extern frontend_ctx_driver_t frontend_ctx_dos; extern frontend_ctx_driver_t frontend_ctx_dos;
extern frontend_ctx_driver_t frontend_ctx_switch; extern frontend_ctx_driver_t frontend_ctx_switch;
extern frontend_ctx_driver_t frontend_ctx_orbis;
extern frontend_ctx_driver_t frontend_ctx_null; extern frontend_ctx_driver_t frontend_ctx_null;
/** /**

7
gfx/common/egl_common.c
View File

@ -419,7 +419,12 @@ bool egl_create_context(egl_ctx_data_t *egl, const EGLint *egl_attribs)
bool egl_create_surface(egl_ctx_data_t *egl, void *native_window) bool egl_create_surface(egl_ctx_data_t *egl, void *native_window)
{ {
egl->surf = eglCreateWindowSurface(egl->dpy, egl->config, (NativeWindowType)native_window, NULL); EGLint window_attribs[] = {
EGL_RENDER_BUFFER, EGL_BACK_BUFFER,
EGL_NONE,
};
egl->surf = eglCreateWindowSurface(egl->dpy, egl->config, (NativeWindowType)native_window, window_attribs);
if (egl->surf == EGL_NO_SURFACE) if (egl->surf == EGL_NO_SURFACE)
return false; return false;

20
gfx/drivers_context/orbis_ctx.c
View File

@ -58,11 +58,17 @@ static void *orbis_ctx_init(video_frame_info_t *video_info, void *video_driver)
EGLint n; EGLint n;
EGLint major, minor; EGLint major, minor;
static const EGLint attribs[] = { static const EGLint attribs[] = {
EGL_BLUE_SIZE, 8,
EGL_GREEN_SIZE, 8,
EGL_RED_SIZE, 8, EGL_RED_SIZE, 8,
EGL_ALPHA_SIZE, 8, EGL_GREEN_SIZE, 8,
EGL_NONE}; EGL_BLUE_SIZE, 8,
EGL_ALPHA_SIZE, 8,
EGL_DEPTH_SIZE, 16,
EGL_STENCIL_SIZE, 0,
EGL_SAMPLE_BUFFERS, 0,
EGL_SAMPLES, 0,
EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
EGL_NONE};
#endif #endif
orbis_ctx_data_t *ctx_orbis = (orbis_ctx_data_t *)calloc(1, sizeof(*ctx_orbis)); orbis_ctx_data_t *ctx_orbis = (orbis_ctx_data_t *)calloc(1, sizeof(*ctx_orbis));
@ -143,8 +149,8 @@ static bool orbis_ctx_set_video_mode(void *data,
orbis_ctx_data_t *ctx_orbis = (orbis_ctx_data_t *)data; orbis_ctx_data_t *ctx_orbis = (orbis_ctx_data_t *)data;
ctx_orbis->width = ATTR_ORBISGL_HEIGHT; ctx_orbis->width = ATTR_ORBISGL_WIDTH;
ctx_orbis->height = ATTR_ORBISGL_WIDTH; ctx_orbis->height = ATTR_ORBISGL_HEIGHT;
ctx_orbis->native_window.width = ctx_orbis->width; ctx_orbis->native_window.width = ctx_orbis->width;
ctx_orbis->native_window.height = ctx_orbis->height; ctx_orbis->native_window.height = ctx_orbis->height;
@ -218,7 +224,7 @@ static void orbis_ctx_set_swap_interval(void *data,
orbis_ctx_data_t *ctx_orbis = (orbis_ctx_data_t *)data; orbis_ctx_data_t *ctx_orbis = (orbis_ctx_data_t *)data;
#ifdef HAVE_EGL #ifdef HAVE_EGL
egl_set_swap_interval(&ctx_orbis->egl, swap_interval); egl_set_swap_interval(&ctx_orbis->egl, 0);
#endif #endif
} }

6
griffin/griffin.c
View File

@ -572,6 +572,9 @@ INPUT
#elif defined(SN_TARGET_PSP2) || defined(PSP) || defined(VITA) #elif defined(SN_TARGET_PSP2) || defined(PSP) || defined(VITA)
#include "../input/drivers/psp_input.c" #include "../input/drivers/psp_input.c"
#include "../input/drivers_joypad/psp_joypad.c" #include "../input/drivers_joypad/psp_joypad.c"
#elif defined(ORBIS)
#include "../input/drivers/ps4_input.c"
#include "../input/drivers_joypad/ps4_joypad.c"
#elif defined(PS2) #elif defined(PS2)
#include "../input/drivers/ps2_input.c" #include "../input/drivers/ps2_input.c"
#include "../input/drivers_joypad/ps2_joypad.c" #include "../input/drivers_joypad/ps2_joypad.c"
@ -773,7 +776,7 @@ AUDIO
#include "../audio/drivers/wiiu_audio.c" #include "../audio/drivers/wiiu_audio.c"
#elif defined(EMSCRIPTEN) #elif defined(EMSCRIPTEN)
#include "../audio/drivers/rwebaudio.c" #include "../audio/drivers/rwebaudio.c"
#elif defined(PSP) || defined(VITA) #elif defined(PSP) || defined(VITA) || defined(ORBIS)
#include "../audio/drivers/psp_audio.c" #include "../audio/drivers/psp_audio.c"
#elif defined(PS2) #elif defined(PS2)
#include "../audio/drivers/ps2_audio.c" #include "../audio/drivers/ps2_audio.c"
@ -930,6 +933,7 @@ FILE
#include "../libretro-common/file/nbio/nbio_linux.c" #include "../libretro-common/file/nbio/nbio_linux.c"
#include "../libretro-common/file/nbio/nbio_unixmmap.c" #include "../libretro-common/file/nbio/nbio_unixmmap.c"
#include "../libretro-common/file/nbio/nbio_windowsmmap.c" #include "../libretro-common/file/nbio/nbio_windowsmmap.c"
#include "../libretro-common/file/nbio/nbio_orbis.c"
#include "../libretro-common/file/nbio/nbio_intf.c" #include "../libretro-common/file/nbio/nbio_intf.c"
/*============================================================ /*============================================================

155
input/drivers/ps4_input.c Normal file
View File

@ -0,0 +1,155 @@
/* RetroArch - A frontend for libretro.
* Copyright (C) 2010-2014 - Hans-Kristian Arntzen
* Copyright (C) 2011-2017 - Daniel De Matteis
*
* RetroArch is free software: you can redistribute it and/or modify it under the terms
* of the GNU General Public License as published by the Free Software Found-
* ation, either version 3 of the License, or (at your option) any later version.
*
* RetroArch is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
* PURPOSE. See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along with RetroArch.
* If not, see <http://www.gnu.org/licenses/>.
*/
#include <stdint.h>
#include <stdlib.h>
#ifdef HAVE_CONFIG_H
#include "../../config.h"
#endif
#include <pad.h>
#include <boolean.h>
#include <libretro.h>
#include <retro_miscellaneous.h>
#include "../input_driver.h"
/* TODO/FIXME -
* fix game focus toggle */
typedef struct ps4_input
{
bool blocked;
const input_device_driver_t *joypad;
} ps4_input_t;
static void ps4_input_poll(void *data)
{
ps4_input_t *ps4 = (ps4_input_t*)data;
if (ps4 && ps4->joypad)
ps4->joypad->poll();
}
static int16_t ps4_input_state(void *data,
rarch_joypad_info_t joypad_info,
const struct retro_keybind **binds,
unsigned port, unsigned device,
unsigned idx, unsigned id)
{
ps4_input_t *ps4 = (ps4_input_t*)data;
switch (device)
{
case RETRO_DEVICE_JOYPAD:
return input_joypad_pressed(ps4->joypad, joypad_info, port, binds[port], id);
case RETRO_DEVICE_ANALOG:
if (binds[port])
return input_joypad_analog(ps4->joypad, joypad_info, port, idx, id, binds[port]);
break;
}
return 0;
}
static void ps4_input_free_input(void *data)
{
ps4_input_t *ps4 = (ps4_input_t*)data;
if (ps4 && ps4->joypad)
ps4->joypad->destroy();
free(data);
}
static void* ps4_input_initialize(const char *joypad_driver)
{
ps4_input_t *ps4 = (ps4_input_t*)calloc(1, sizeof(*ps4));
if (!ps4)
return NULL;
ps4->joypad = input_joypad_init_driver(joypad_driver, ps4);
return ps4;
}
static uint64_t ps4_input_get_capabilities(void *data)
{
(void)data;
return (1 << RETRO_DEVICE_JOYPAD) | (1 << RETRO_DEVICE_ANALOG);
}
static const input_device_driver_t *ps4_input_get_joypad_driver(void *data)
{
ps4_input_t *ps4 = (ps4_input_t*)data;
if (ps4)
return ps4->joypad;
return NULL;
}
static void ps4_input_grab_mouse(void *data, bool state)
{
(void)data;
(void)state;
}
static bool ps4_input_set_rumble(void *data, unsigned port,
enum retro_rumble_effect effect, uint16_t strength)
{
ps4_input_t *ps4 = (ps4_input_t*)data;
if (ps4 && ps4->joypad)
return input_joypad_set_rumble(ps4->joypad,
port, effect, strength);
return false;
}
static bool ps4_input_keyboard_mapping_is_blocked(void *data)
{
ps4_input_t *ps4 = (ps4_input_t*)data;
if (!ps4)
return false;
return ps4->blocked;
}
static void ps4_input_keyboard_mapping_set_block(void *data, bool value)
{
ps4_input_t *ps4 = (ps4_input_t*)data;
if (!ps4)
return;
ps4->blocked = value;
}
input_driver_t input_ps4 = {
ps4_input_initialize,
ps4_input_poll,
ps4_input_state,
ps4_input_free_input,
NULL,
NULL,
ps4_input_get_capabilities,
"ps4",
ps4_input_grab_mouse,
NULL,
ps4_input_set_rumble,
ps4_input_get_joypad_driver,
NULL,
ps4_input_keyboard_mapping_is_blocked,
ps4_input_keyboard_mapping_set_block,
};

223
input/drivers_joypad/ps4_joypad.c Normal file
View File

@ -0,0 +1,223 @@
/* RetroArch - A frontend for libretro.
* Copyright (C) 2010-2014 - Hans-Kristian Arntzen
* Copyright (C) 2011-2017 - Daniel De Matteis
* Copyright (C) 2013-2014 - CatalystG
*
* RetroArch is free software: you can redistribute it and/or modify it under the terms
* of the GNU General Public License as published by the Free Software Found-
* ation, either version 3 of the License, or (at your option) any later version.
*
* RetroArch is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
* PURPOSE. See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along with RetroArch.
* If not, see <http://www.gnu.org/licenses/>.
*/
#include <stdint.h>
#include <stddef.h>
#include <boolean.h>
#include "../input_driver.h"
#include "../../tasks/tasks_internal.h"
#include <userservice.h>
#include <pad.h>
#define PS4_MAX_ORBISPADS 16
#define SCE_USER_SERVICE_MAX_LOGIN_USERS 16
#define SCE_USER_SERVICE_USER_ID_INVALID 0xFFFFFFFF
#define SCE_ORBISPAD_ERROR_ALREADY_OPENED 0x80920004
#define ORBISPAD_L3 0x00000002
#define ORBISPAD_R3 0x00000004
#define ORBISPAD_OPTIONS 0x00000008
#define ORBISPAD_UP 0x00000010
#define ORBISPAD_RIGHT 0x00000020
#define ORBISPAD_DOWN 0x00000040
#define ORBISPAD_LEFT 0x00000080
#define ORBISPAD_L2 0x00000100
#define ORBISPAD_R2 0x00000200
#define ORBISPAD_L1 0x00000400
#define ORBISPAD_R1 0x00000800
#define ORBISPAD_TRIANGLE 0x00001000
#define ORBISPAD_CIRCLE 0x00002000
#define ORBISPAD_CROSS 0x00004000
#define ORBISPAD_SQUARE 0x00008000
#define ORBISPAD_TOUCH_PAD 0x00100000
#define ORBISPAD_INTERCEPTED 0x80000000
typedef struct SceUserServiceLoginUserIdList {
int32_t userId[SCE_USER_SERVICE_MAX_LOGIN_USERS];
} SceUserServiceLoginUserIdList;
int sceUserServiceGetLoginUserIdList(SceUserServiceLoginUserIdList* userIdList);
/*
* Global var's
*/
typedef struct
{
SceUserServiceUserId userId;
int handle;
bool connected;
} ds_joypad_state;
static ds_joypad_state ds_joypad_states[PS4_MAX_ORBISPADS];
static uint64_t pad_state[PS4_MAX_ORBISPADS];
static int16_t analog_state[PS4_MAX_ORBISPADS][2][2];
static int16_t num_players = 0;
static const char *ps4_joypad_name(unsigned pad)
{
return "PS4 Controller";
}
static bool ps4_joypad_init(void *data)
{
num_players = 0;
scePadInit();
SceUserServiceLoginUserIdList userIdList;
int result = sceUserServiceGetLoginUserIdList(&userIdList);
RARCH_LOG("sceUserServiceGetLoginUserIdList %x ", result);
if (result == 0)
{
for (int i = 0; i < SCE_USER_SERVICE_MAX_LOGIN_USERS; i++)
{
SceUserServiceUserId userId = userIdList.userId[i];
RARCH_LOG("USER %d ID %x\n", i, userId);
if (userId != SCE_USER_SERVICE_USER_ID_INVALID)
{
int index = 0;
while(index < num_players){
ds_joypad_states[index].userId = userId;
index++;
}
if (index == num_players)
{
ds_joypad_states[num_players].handle = scePadOpen(userId, 0, 0, NULL);
RARCH_LOG("USER %x HANDLE %x\n", userId, ds_joypad_states[num_players].handle);
if (ds_joypad_states[num_players].handle > 0){
ds_joypad_states[num_players].connected = true;
ds_joypad_states[num_players].userId = userId;
RARCH_LOG("NEW PAD: num_players %x \n", num_players);
bool auto_configure = input_autoconfigure_connect( ps4_joypad_name(num_players),
NULL,
ps4_joypad.ident,
num_players,
0,
0);
if (!auto_configure) {
input_config_set_device_name(num_players, ps4_joypad_name(num_players));
}
num_players++;
}
}
}
}
}
return true;
}
static bool ps4_joypad_button(unsigned port_num, uint16_t joykey)
{
if (port_num >= PS4_MAX_ORBISPADS)
return false;
return (pad_state[port_num] & (UINT64_C(1) << joykey));
}
static void ps4_joypad_get_buttons(unsigned port_num, input_bits_t *state)
{
if (port_num < PS4_MAX_ORBISPADS)
{
BITS_COPY16_PTR( state, pad_state[port_num] );
}
else
BIT256_CLEAR_ALL_PTR(state);
}
static int16_t ps4_joypad_axis(unsigned port_num, uint32_t joyaxis)
{
return 0;
}
static void ps4_joypad_poll(void)
{
unsigned player;
unsigned players_count = num_players;
ScePadData buttons;
for (player = 0; player < players_count; player++)
{
unsigned j, k;
unsigned i = player;
unsigned p = player;
int ret = scePadReadState(ds_joypad_states[player].handle,&buttons);
if (ret == 0)
{
int32_t state_tmp = buttons.buttons;
pad_state[i] = 0;
pad_state[i] |= (state_tmp & ORBISPAD_LEFT) ? (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_LEFT) : 0;
pad_state[i] |= (state_tmp & ORBISPAD_DOWN) ? (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_DOWN) : 0;
pad_state[i] |= (state_tmp & ORBISPAD_RIGHT) ? (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_RIGHT) : 0;
pad_state[i] |= (state_tmp & ORBISPAD_UP) ? (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_UP) : 0;
pad_state[i] |= (state_tmp & ORBISPAD_OPTIONS) ? (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_START) : 0;
pad_state[i] |= (state_tmp & ORBISPAD_TOUCH_PAD) ? (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_SELECT) : 0;
pad_state[i] |= (state_tmp & ORBISPAD_TRIANGLE) ? (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_X) : 0;
pad_state[i] |= (state_tmp & ORBISPAD_SQUARE) ? (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_Y) : 0;
pad_state[i] |= (state_tmp & ORBISPAD_CROSS) ? (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_B) : 0;
pad_state[i] |= (state_tmp & ORBISPAD_CIRCLE) ? (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_A) : 0;
pad_state[i] |= (state_tmp & ORBISPAD_R1) ? (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_R) : 0;
pad_state[i] |= (state_tmp & ORBISPAD_L1) ? (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_L) : 0;
pad_state[i] |= (state_tmp & ORBISPAD_R2) ? (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_R2) : 0;
pad_state[i] |= (state_tmp & ORBISPAD_L2) ? (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_L2) : 0;
pad_state[i] |= (state_tmp & ORBISPAD_R3) ? (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_R3) : 0;
pad_state[i] |= (state_tmp & ORBISPAD_L3) ? (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_L3) : 0;
}
}
}
static bool ps4_joypad_query_pad(unsigned pad)
{
return pad < PS4_MAX_ORBISPADS && pad_state[pad];
}
static bool ps4_joypad_rumble(unsigned pad,
enum retro_rumble_effect effect, uint16_t strength)
{
return false;
}
static void ps4_joypad_destroy(void)
{
}
input_device_driver_t ps4_joypad = {
ps4_joypad_init,
ps4_joypad_query_pad,
ps4_joypad_destroy,
ps4_joypad_button,
ps4_joypad_get_buttons,
ps4_joypad_axis,
ps4_joypad_poll,
ps4_joypad_rumble,
ps4_joypad_name,
"ps4",
};

3
input/input_autodetect_builtin.c
View File

@ -659,6 +659,9 @@ const char* const input_builtin_autoconfs[] =
DECL_AUTOCONF_DEVICE("QNX Controller", "qnx", QNX_DEFAULT_BINDS), DECL_AUTOCONF_DEVICE("QNX Controller", "qnx", QNX_DEFAULT_BINDS),
DECL_AUTOCONF_DEVICE("DS4 Controller", "qnx", QNX_DUALSHOCK_BINDS), DECL_AUTOCONF_DEVICE("DS4 Controller", "qnx", QNX_DUALSHOCK_BINDS),
#endif #endif
#if defined(ORBIS)
DECL_AUTOCONF_DEVICE("PS4 Controller", "ps4", PS3INPUT_DEFAULT_BINDS),
#endif
#if defined(VITA) || defined(SN_TARGET_PSP2) #if defined(VITA) || defined(SN_TARGET_PSP2)
DECL_AUTOCONF_DEVICE("Vita Controller", "vita", PSPINPUT_DEFAULT_BINDS), DECL_AUTOCONF_DEVICE("Vita Controller", "vita", PSPINPUT_DEFAULT_BINDS),
DECL_AUTOCONF_DEVICE("DS3 Controller", "vita", PSPINPUT_DEFAULT_BINDS), DECL_AUTOCONF_DEVICE("DS3 Controller", "vita", PSPINPUT_DEFAULT_BINDS),

6
input/input_driver.c
View File

@ -80,6 +80,9 @@ void fire_connection_listener(unsigned port, input_device_driver_t *driver)
} }
static const input_driver_t *input_drivers[] = { static const input_driver_t *input_drivers[] = {
#ifdef ORBIS
&input_ps4,
#endif
#ifdef __CELLOS_LV2__ #ifdef __CELLOS_LV2__
&input_ps3, &input_ps3,
#endif #endif
@ -164,6 +167,9 @@ static input_device_driver_t *joypad_drivers[] = {
#ifdef _XBOX #ifdef _XBOX
&xdk_joypad, &xdk_joypad,
#endif #endif
#if defined(ORBIS)
&ps4_joypad,
#endif
#if defined(PSP) || defined(VITA) #if defined(PSP) || defined(VITA)
&psp_joypad, &psp_joypad,
#endif #endif

2
input/input_driver.h
View File

@ -804,6 +804,7 @@ extern input_device_driver_t parport_joypad;
extern input_device_driver_t udev_joypad; extern input_device_driver_t udev_joypad;
extern input_device_driver_t xinput_joypad; extern input_device_driver_t xinput_joypad;
extern input_device_driver_t sdl_joypad; extern input_device_driver_t sdl_joypad;
extern input_device_driver_t ps4_joypad;
extern input_device_driver_t ps3_joypad; extern input_device_driver_t ps3_joypad;
extern input_device_driver_t psp_joypad; extern input_device_driver_t psp_joypad;
extern input_device_driver_t ps2_joypad; extern input_device_driver_t ps2_joypad;
@ -824,6 +825,7 @@ extern input_driver_t input_android;
extern input_driver_t input_sdl; extern input_driver_t input_sdl;
extern input_driver_t input_dinput; extern input_driver_t input_dinput;
extern input_driver_t input_x; extern input_driver_t input_x;
extern input_driver_t input_ps4;
extern input_driver_t input_ps3; extern input_driver_t input_ps3;
extern input_driver_t input_psp; extern input_driver_t input_psp;
extern input_driver_t input_ps2; extern input_driver_t input_ps2;

48
libretro-common/file/config_file.c
View File

@ -34,7 +34,10 @@
#elif defined(_XBOX) #elif defined(_XBOX)
#include <xtl.h> #include <xtl.h>
#endif #endif
#ifdef ORBIS
#include <sys/fcntl.h>
#include <orbisFile.h>
#endif
#include <retro_miscellaneous.h> #include <retro_miscellaneous.h>
#include <compat/strl.h> #include <compat/strl.h>
#include <compat/posix_string.h> #include <compat/posix_string.h>
@ -413,10 +416,10 @@ static config_file_t *config_file_new_internal(
if (!path || !*path) if (!path || !*path)
return conf; return conf;
#if !defined(ORBIS)
if (path_is_directory(path)) if (path_is_directory(path))
goto error; goto error;
#endif
conf->path = strdup(path); conf->path = strdup(path);
if (!conf->path) if (!conf->path)
goto error; goto error;
@ -980,6 +983,15 @@ bool config_file_write(config_file_t *conf, const char *path, bool sort)
if (!string_is_empty(path)) if (!string_is_empty(path))
{ {
void* buf = NULL; void* buf = NULL;
#ifdef ORBIS
int fd = orbisOpen(path,O_RDWR|O_CREAT,0644);
RARCH_LOG("[Config]config_file_write orbisOpen path=%s fd=%d\n", path, fd);
if (fd<0)
return false;
config_file_dump_orbis(conf,fd);
orbisClose(fd);
RARCH_LOG("[Config]config_file_write orbisClose path=%s fd=%d\n", path, fd);
#else
FILE *file = (FILE*)fopen_utf8(path, "wb"); FILE *file = (FILE*)fopen_utf8(path, "wb");
if (!file) if (!file)
return false; return false;
@ -995,6 +1007,7 @@ bool config_file_write(config_file_t *conf, const char *path, bool sort)
if (file != stdout) if (file != stdout)
fclose(file); fclose(file);
free(buf); free(buf);
#endif
} }
else else
config_file_dump(conf, stdout, sort); config_file_dump(conf, stdout, sort);
@ -1002,6 +1015,35 @@ bool config_file_write(config_file_t *conf, const char *path, bool sort)
return true; return true;
} }
#ifdef ORBIS
void config_file_dump_orbis(config_file_t *conf, int fd)
{
struct config_entry_list *list = NULL;
struct config_include_list *includes = conf->includes;
while (includes)
{
char cad[256];
sprintf(cad,"#include %s\n", includes->path);
orbisWrite(fd,cad,strlen(cad));
includes = includes->next;
}
list = merge_sort_linked_list((struct config_entry_list*)conf->entries, config_sort_compare_func);
conf->entries = list;
while (list)
{
if (!list->readonly && list->key)
{
char newlist[256];
sprintf(newlist,"%s = %s\n", list->key, list->value);
orbisWrite(fd,newlist,strlen(newlist));
}
list = list->next;
}
}
#endif
void config_file_dump(config_file_t *conf, FILE *file, bool sort) void config_file_dump(config_file_t *conf, FILE *file, bool sort)
{ {
struct config_entry_list *list = NULL; struct config_entry_list *list = NULL;

26
libretro-common/file/file_path.c
View File

@ -75,6 +75,11 @@
#include <unistd.h> #include <unistd.h>
#endif #endif
#if defined(ORBIS)
#include <orbisFile.h>
#include <sys/fcntl.h>
#include <sys/dirent.h>
#endif
#if defined(PSP) #if defined(PSP)
#include <pspkernel.h> #include <pspkernel.h>
#endif #endif
@ -120,6 +125,9 @@ enum stat_mode
static bool path_stat(const char *path, enum stat_mode mode, int32_t *size) static bool path_stat(const char *path, enum stat_mode mode, int32_t *size)
{ {
#if defined(ORBIS)
return false; //by now
#endif
#if defined(VITA) || defined(PSP) #if defined(VITA) || defined(PSP)
SceIoStat buf; SceIoStat buf;
char *tmp = strdup(path); char *tmp = strdup(path);
@ -232,7 +240,21 @@ static bool path_stat(const char *path, enum stat_mode mode, int32_t *size)
*/ */
bool path_is_directory(const char *path) bool path_is_directory(const char *path)
{ {
#ifdef ORBIS
if (!path)
{
return false;
}
int dfd = orbisDopen(path);
if (dfd < 0)
{
return false;
}
orbisDclose(dfd);
return true;
#else
return path_stat(path, IS_DIRECTORY, NULL); return path_stat(path, IS_DIRECTORY, NULL);
#endif
} }
bool path_is_character_special(const char *path) bool path_is_character_special(const char *path)
@ -258,7 +280,7 @@ static bool path_mkdir_error(int ret)
{ {
#if defined(VITA) #if defined(VITA)
return (ret == SCE_ERROR_ERRNO_EEXIST); return (ret == SCE_ERROR_ERRNO_EEXIST);
#elif defined(PSP) || defined(PS2) || defined(_3DS) || defined(WIIU) || defined(SWITCH) #elif defined(PSP) || defined(PS2) || defined(_3DS) || defined(WIIU) || defined(SWITCH) || defined(ORBIS)
return (ret == -1); return (ret == -1);
#else #else
return (ret < 0 && errno == EEXIST); return (ret < 0 && errno == EEXIST);
@ -329,6 +351,8 @@ bool path_mkdir(const char *dir)
int ret = sceIoMkdir(dir, 0777); int ret = sceIoMkdir(dir, 0777);
#elif defined(PS2) #elif defined(PS2)
int ret =fileXioMkdir(dir, 0777); int ret =fileXioMkdir(dir, 0777);
#elif defined(ORBIS)
int ret =orbisMkdir(dir, 0755);
#elif defined(__QNX__) #elif defined(__QNX__)
int ret = mkdir(dir, 0777); int ret = mkdir(dir, 0777);
#else #else

3
libretro-common/file/nbio/nbio_intf.c
View File

@ -32,6 +32,7 @@
extern nbio_intf_t nbio_linux; extern nbio_intf_t nbio_linux;
extern nbio_intf_t nbio_mmap_unix; extern nbio_intf_t nbio_mmap_unix;
extern nbio_intf_t nbio_mmap_win32; extern nbio_intf_t nbio_mmap_win32;
extern nbio_intf_t nbio_orbis;
extern nbio_intf_t nbio_stdio; extern nbio_intf_t nbio_stdio;
#if defined(_linux__) #if defined(_linux__)
@ -40,6 +41,8 @@ static nbio_intf_t *internal_nbio = &nbio_linux;
static nbio_intf_t *internal_nbio = &nbio_mmap_unix; static nbio_intf_t *internal_nbio = &nbio_mmap_unix;
#elif defined(_WIN32) && !defined(_XBOX) #elif defined(_WIN32) && !defined(_XBOX)
static nbio_intf_t *internal_nbio = &nbio_mmap_win32; static nbio_intf_t *internal_nbio = &nbio_mmap_win32;
#elif defined(ORBIS)
static nbio_intf_t *internal_nbio = &nbio_orbis;
#else #else
static nbio_intf_t *internal_nbio = &nbio_stdio; static nbio_intf_t *internal_nbio = &nbio_stdio;
#endif #endif

295
libretro-common/file/nbio/nbio_orbis.c Normal file
View File

@ -0,0 +1,295 @@
/* Copyright (C) 2010-2018 The RetroArch team
*
* ---------------------------------------------------------------------------------------
* The following license statement only applies to this file (nbio_orbis.c).
* ---------------------------------------------------------------------------------------
*
* Permission is hereby granted, free of charge,
* to any person obtaining a copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
* and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
* INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#include <file/nbio.h>
#if defined(ORBIS)
#include <stdio.h>
#include <stdlib.h>
#include <orbisFile.h>
#include <unistd.h>
#include <sys/fcntl.h>
struct nbio_orbis_t
{
int fd;
void* data;
size_t progress;
size_t len;
/*
* possible values:
* NBIO_READ, NBIO_WRITE - obvious
* -1 - currently doing nothing
* -2 - the pointer was reallocated since the last operation
*/
signed char op;
unsigned int mode;
};
static void *nbio_orbis_open(const char * filename, unsigned int mode)
{
RARCH_LOG("[NBIO_ORBIS] open %s\n" , filename);
static const int o_flags[] = { O_RDONLY, O_RDWR|O_CREAT|O_TRUNC, O_RDWR, O_RDONLY, O_RDWR|O_CREAT|O_TRUNC };
void *buf = NULL;
struct nbio_orbis_t* handle = NULL;
size_t len = 0;
int fd = orbisOpen(filename, o_flags[mode], 0644);
if (fd < 0)
return NULL;
handle = (struct nbio_orbis_t*)malloc(sizeof(struct nbio_orbis_t));
if (!handle)
goto error;
handle->fd = fd;
switch (mode)
{
case NBIO_WRITE:
case BIO_WRITE:
break;
default:
len=orbisLseek(handle->fd, 0, SEEK_END);
orbisLseek(handle->fd, 0, SEEK_SET);
break;
}
handle->mode = mode;
if (len)
buf = malloc(len);
if (!buf)
{
RARCH_LOG("[NBIO_ORBIS] open error malloc %d bytes\n",len);
}
if (len && !buf)
goto error;
handle->data = buf;
handle->len = len;
handle->progress = handle->len;
handle->op = -2;
return handle;
error:
if (handle)
free(handle);
RARCH_LOG("[NBIO_ORBIS] open error closing %s\n" , filename);
orbisClose(fd);
return NULL;
}
static void nbio_orbis_begin_read(void *data)
{
struct nbio_orbis_t *handle = (struct nbio_orbis_t*)data;
if (!handle)
return;
RARCH_LOG("[NBIO_ORBIS] begin read fd=%d\n", handle->fd );
if (handle->op >= 0)
{
RARCH_LOG("[NBIO_ORBIS] ERROR - attempted file read operation while busy\n");
//abort();
return;
}
orbisLseek(handle->fd, 0, SEEK_SET);
handle->op = NBIO_READ;
handle->progress = 0;
}
static void nbio_orbis_begin_write(void *data)
{
struct nbio_orbis_t *handle = (struct nbio_orbis_t*)data;
if (!handle)
return;
RARCH_LOG("[NBIO_ORBIS] begin write fd=%d\n", handle->fd );
if (handle->op >= 0)
{
RARCH_LOG("[NBIO_ORBIS] ERROR - attempted file write operation while busy\n");
//abort();
return;
}
orbisLseek(handle->fd, 0, SEEK_SET);
handle->op = NBIO_WRITE;
handle->progress = 0;
}
static bool nbio_orbis_iterate(void *data)
{
size_t amount = 65536;
struct nbio_orbis_t *handle = (struct nbio_orbis_t*)data;
if (!handle)
return false;
RARCH_LOG("[NBIO_ORBIS] begin iterate fd=%d\n", handle->fd );
if (amount > handle->len - handle->progress)
amount = handle->len - handle->progress;
switch (handle->op)
{
case NBIO_READ:
if (handle->mode == BIO_READ)
{
amount = handle->len;
RARCH_LOG("[NBIO_ORBIS] iterate BIO_READ fd=%d readbytes=%d\n", handle->fd, orbisRead(handle->fd, (char*)handle->data, amount));
}
else
{
RARCH_LOG("[NBIO_ORBIS] iterate read fd=%d handle->progress=%d readbytes=%d\n", handle->fd, handle->progress, orbisRead(handle->fd, (char*)handle->data + handle->progress, amount));
}
break;
case NBIO_WRITE:
if (handle->mode == BIO_WRITE)
{
size_t written = 0;
amount = handle->len;
written = orbisWrite(handle->fd, (char*)handle->data, amount);
RARCH_LOG("[NBIO_ORBIS] iterate BIO_WRITE fd=%d writebytes=%d\n", handle->fd, written);
if (written != amount)
{
RARCH_LOG("[NBIO_ORBIS] iterate BIO_WRITE error fd=%d amount=%d != writebytes=%d\n", handle->fd, amount, written);
return false;
}
}
else
{
RARCH_LOG("[NBIO_ORBIS] iterate write fd=%d writebytes=%d\n", handle->fd, orbisWrite(handle->fd, (char*)handle->data + handle->progress, amount));
}
break;
}
handle->progress += amount;
RARCH_LOG("[NBIO_ORBIS] end iterate fd=%d\n", handle->fd );
if (handle->progress == handle->len)
handle->op = -1;
return (handle->op < 0);
}
static void nbio_orbis_resize(void *data, size_t len)
{
struct nbio_orbis_t *handle = (struct nbio_orbis_t*)data;
if (!handle)
return;
if (handle->op >= 0)
{
RARCH_LOG("[NBIO_ORBIS] ERROR - attempted file resize operation while busy\n");
//abort();
return;
}
if (len < handle->len)
{
RARCH_LOG("[NBIO_ORBIS] ERROR - attempted file shrink operation, not implemented");
//abort();
return;
}
handle->len = len;
handle->data = realloc(handle->data, handle->len);
handle->op = -1;
handle->progress = handle->len;
}
static void *nbio_orbis_get_ptr(void *data, size_t* len)
{
struct nbio_orbis_t *handle = (struct nbio_orbis_t*)data;
if (!handle)
return NULL;
RARCH_LOG("[NBIO_ORBIS] get pointer\n");
if (len)
*len = handle->len;
if (handle->op == -1)
return handle->data;
return NULL;
}
static void nbio_orbis_cancel(void *data)
{
struct nbio_orbis_t *handle = (struct nbio_orbis_t*)data;
if (!handle)
return;
RARCH_LOG("[NBIO_ORBIS] cancel \n");
handle->op = -1;
handle->progress = handle->len;
}
static void nbio_orbis_free(void *data)
{
struct nbio_orbis_t *handle = (struct nbio_orbis_t*)data;
if (!handle)
return;
RARCH_LOG("[NBIO_ORBIS] begin free fd=%d\n", handle->fd );
if (handle->op >= 0)
{
RARCH_LOG("[NBIO_ORBIS] ERROR - attempted free() while busy\n");
//abort();
return;
}
RARCH_LOG("[NBIO_ORBIS] free close fd=%d\n",handle->fd);
orbisClose(handle->fd);
free(handle->data);
handle->data = NULL;
free(handle);
}
nbio_intf_t nbio_orbis = {
nbio_orbis_open,
nbio_orbis_begin_read,
nbio_orbis_begin_write,
nbio_orbis_iterate,
nbio_orbis_resize,
nbio_orbis_get_ptr,
nbio_orbis_cancel,
nbio_orbis_free,
"nbio_orbis",
};
#else
nbio_intf_t nbio_orbis = {
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
"nbio_orbis",
};
#endif

26
libretro-common/file/retro_dirent.c
View File

@ -50,6 +50,11 @@
# include <psp2/io/fcntl.h> # include <psp2/io/fcntl.h>
# include <psp2/io/dirent.h> # include <psp2/io/dirent.h>
# include <psp2/io/stat.h> # include <psp2/io/stat.h>
#elif defined(ORBIS)
# include <orbisFile.h>
# include <ps4link.h>
# include <sys/dirent.h>
# include <sys/fcntl.h>
#else #else
# if defined(PSP) # if defined(PSP)
# include <pspiofilemgr.h> # include <pspiofilemgr.h>
@ -98,6 +103,9 @@ struct RDIR
CellFsErrno error; CellFsErrno error;
int directory; int directory;
CellFsDirent entry; CellFsDirent entry;
#elif defined(ORBIS)
int directory;
struct dirent entry;
#else #else
DIR *directory; DIR *directory;
const struct dirent *entry; const struct dirent *entry;
@ -159,6 +167,8 @@ struct RDIR *retro_opendir(const char *name)
rdir->entry = NULL; rdir->entry = NULL;
#elif defined(__CELLOS_LV2__) #elif defined(__CELLOS_LV2__)
rdir->error = cellFsOpendir(name, &rdir->directory); rdir->error = cellFsOpendir(name, &rdir->directory);
#elif defined(ORBIS)
rdir->directory = orbisDopen(name);
#else #else
rdir->directory = opendir(name); rdir->directory = opendir(name);
rdir->entry = NULL; rdir->entry = NULL;
@ -175,7 +185,7 @@ bool retro_dirent_error(struct RDIR *rdir)
{ {
#if defined(_WIN32) #if defined(_WIN32)
return (rdir->directory == INVALID_HANDLE_VALUE); return (rdir->directory == INVALID_HANDLE_VALUE);
#elif defined(VITA) || defined(PSP) || defined(PS2) #elif defined(VITA) || defined(PSP) || defined(PS2) || defined(ORBIS)
return (rdir->directory < 0); return (rdir->directory < 0);
#elif defined(__CELLOS_LV2__) #elif defined(__CELLOS_LV2__)
return (rdir->error != CELL_FS_SUCCEEDED); return (rdir->error != CELL_FS_SUCCEEDED);
@ -207,6 +217,8 @@ int retro_readdir(struct RDIR *rdir)
uint64_t nread; uint64_t nread;
rdir->error = cellFsReaddir(rdir->directory, &rdir->entry, &nread); rdir->error = cellFsReaddir(rdir->directory, &rdir->entry, &nread);
return (nread != 0); return (nread != 0);
#elif defined(ORBIS)
return (orbisDread(rdir->directory, &rdir->entry) > 0);
#else #else
return ((rdir->entry = readdir(rdir->directory)) != NULL); return ((rdir->entry = readdir(rdir->directory)) != NULL);
#endif #endif
@ -231,7 +243,7 @@ const char *retro_dirent_get_name(struct RDIR *rdir)
free(name); free(name);
#endif #endif
return (char*)rdir->entry.cFileName; return (char*)rdir->entry.cFileName;
#elif defined(VITA) || defined(PSP) || defined(__CELLOS_LV2__) #elif defined(VITA) || defined(PSP) || defined(__CELLOS_LV2__) || defined(ORBIS)
return rdir->entry.d_name; return rdir->entry.d_name;
#elif defined(PS2) #elif defined(PS2)
return rdir->entry.name; return rdir->entry.name;
@ -270,6 +282,14 @@ bool retro_dirent_is_dir(struct RDIR *rdir, const char *path)
#elif defined(__CELLOS_LV2__) #elif defined(__CELLOS_LV2__)
CellFsDirent *entry = (CellFsDirent*)&rdir->entry; CellFsDirent *entry = (CellFsDirent*)&rdir->entry;
return (entry->d_type == CELL_FS_TYPE_DIRECTORY); return (entry->d_type == CELL_FS_TYPE_DIRECTORY);
#elif defined(ORBIS)
const struct dirent *entry = &rdir->entry;
if (entry->d_type==DT_DIR)
{
return true;
}
if (!(entry->d_type == DT_UNKNOWN || entry->d_type == DT_LNK))
return false;
#else #else
struct stat buf; struct stat buf;
#if defined(DT_DIR) #if defined(DT_DIR)
@ -311,6 +331,8 @@ void retro_closedir(struct RDIR *rdir)
fileXioDclose(rdir->directory); fileXioDclose(rdir->directory);
#elif defined(__CELLOS_LV2__) #elif defined(__CELLOS_LV2__)
rdir->error = cellFsClosedir(rdir->directory); rdir->error = cellFsClosedir(rdir->directory);
#elif defined(ORBIS)
orbisDclose(rdir->directory);
#else #else
if (rdir->directory) if (rdir->directory)
closedir(rdir->directory); closedir(rdir->directory);

6
libretro-common/include/file/config_file.h
View File

@ -183,6 +183,12 @@ bool config_file_write(config_file_t *conf, const char *path, bool val);
/* Dump the current config to an already opened file. /* Dump the current config to an already opened file.
* Does not close the file. */ * Does not close the file. */
void config_file_dump(config_file_t *conf, FILE *file);
#ifdef ORBIS
void config_file_dump_orbis(config_file_t *conf, int fd);
#endif
void config_file_dump(config_file_t *conf, FILE *file, bool val); void config_file_dump(config_file_t *conf, FILE *file, bool val);
bool config_file_exists(const char *path); bool config_file_exists(const char *path);

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

@ -77,7 +77,7 @@ static INLINE bool bits_any_set(uint32_t* ptr, uint32_t count)
#ifndef PATH_MAX_LENGTH #ifndef PATH_MAX_LENGTH
#if defined(__CELLOS_LV2__) #if defined(__CELLOS_LV2__)
#define PATH_MAX_LENGTH CELL_FS_MAX_FS_PATH_LENGTH #define PATH_MAX_LENGTH CELL_FS_MAX_FS_PATH_LENGTH
#elif defined(_XBOX1) || defined(_3DS) || defined(PSP) || defined(PS2) || defined(GEKKO)|| defined(WIIU) #elif defined(_XBOX1) || defined(_3DS) || defined(PSP) || defined(PS2) || defined(GEKKO)|| defined(WIIU) || defined(ORBIS)
#define PATH_MAX_LENGTH 512 #define PATH_MAX_LENGTH 512
#else #else
#define PATH_MAX_LENGTH 4096 #define PATH_MAX_LENGTH 4096

120
libretro-common/vfs/vfs_implementation.c
View File

@ -56,6 +56,10 @@
# include <dirent.h> # include <dirent.h>
# endif # endif
# include <unistd.h> # include <unistd.h>
# if defined(ORBIS)
# include <sys/fcntl.h>
# include <orbisFile.h>
# endif
#endif #endif
#ifdef __CELLOS_LV2__ #ifdef __CELLOS_LV2__
@ -123,6 +127,7 @@ int64_t retro_vfs_file_seek_internal(libretro_vfs_implementation_file *stream, i
goto error; goto error;
if ((stream->hints & RFILE_HINT_UNBUFFERED) == 0) if ((stream->hints & RFILE_HINT_UNBUFFERED) == 0)
{
/* VC2005 and up have a special 64-bit fseek */ /* VC2005 and up have a special 64-bit fseek */
#ifdef ATLEAST_VC2005 #ifdef ATLEAST_VC2005
return _fseeki64(stream->fp, offset, whence); return _fseeki64(stream->fp, offset, whence);
@ -130,10 +135,22 @@ int64_t retro_vfs_file_seek_internal(libretro_vfs_implementation_file *stream, i
return fseek(stream->fp, (long)offset, whence); return fseek(stream->fp, (long)offset, whence);
#elif defined(PS2) #elif defined(PS2)
return fioLseek(fileno(stream->fp), (off_t)offset, whence); return fioLseek(fileno(stream->fp), (off_t)offset, whence);
#elif defined(ORBIS)
int ret;
ret = orbisLseek(stream->fd, offset, whence);
RARCH_LOG("[VFS]retro_vfs_file_seek_internal orbisLseek return %d on fd=%d filename=%s\n", ret, stream->fd, stream->orig_path);
if (ret < 0)
{
return -1;
}
else
{
return 0;
}
#else #else
return fseeko(stream->fp, (off_t)offset, whence); return fseeko(stream->fp, (off_t)offset, whence);
#endif #endif
}
#ifdef HAVE_MMAP #ifdef HAVE_MMAP
/* Need to check stream->mapped because this function is /* Need to check stream->mapped because this function is
* called in filestream_open() */ * called in filestream_open() */
@ -236,25 +253,28 @@ libretro_vfs_implementation_file *retro_vfs_file_open_impl(const char *path, uns
mode_str = "wb"; mode_str = "wb";
flags = O_WRONLY | O_CREAT | O_TRUNC; flags = O_WRONLY | O_CREAT | O_TRUNC;
#if !defined(ORBIS)
#if defined(PS2) #if defined(PS2)
flags |= FIO_S_IRUSR | FIO_S_IWUSR; flags |= FIO_S_IRUSR | FIO_S_IWUSR;
#elif !defined(_WIN32) #elif !defined(_WIN32)
flags |= S_IRUSR | S_IWUSR; flags |= S_IRUSR | S_IWUSR;
#else #else
flags |= O_BINARY; flags |= O_BINARY;
#endif
#endif #endif
break; break;
case RETRO_VFS_FILE_ACCESS_READ_WRITE: case RETRO_VFS_FILE_ACCESS_READ_WRITE:
mode_str = "w+b"; mode_str = "w+b";
flags = O_RDWR | O_CREAT | O_TRUNC; flags = O_RDWR | O_CREAT | O_TRUNC;
#if !defined(ORBIS)
#if defined(PS2) #if defined(PS2)
flags |= FIO_S_IRUSR | FIO_S_IWUSR; flags |= FIO_S_IRUSR | FIO_S_IWUSR;
#elif !defined(_WIN32) #elif !defined(_WIN32)
flags |= S_IRUSR | S_IWUSR; flags |= S_IRUSR | S_IWUSR;
#else #else
flags |= O_BINARY; flags |= O_BINARY;
#endif
#endif #endif
break; break;
@ -263,12 +283,14 @@ libretro_vfs_implementation_file *retro_vfs_file_open_impl(const char *path, uns
mode_str = "r+b"; mode_str = "r+b";
flags = O_RDWR; flags = O_RDWR;
#if !defined(ORBIS)
#if defined(PS2) #if defined(PS2)
flags |= FIO_S_IRUSR | FIO_S_IWUSR; flags |= FIO_S_IRUSR | FIO_S_IWUSR;
#elif !defined(_WIN32) #elif !defined(_WIN32)
flags |= S_IRUSR | S_IWUSR; flags |= S_IRUSR | S_IWUSR;
#else #else
flags |= O_BINARY; flags |= O_BINARY;
#endif
#endif #endif
break; break;
@ -278,6 +300,16 @@ libretro_vfs_implementation_file *retro_vfs_file_open_impl(const char *path, uns
if ((stream->hints & RFILE_HINT_UNBUFFERED) == 0) if ((stream->hints & RFILE_HINT_UNBUFFERED) == 0)
{ {
#ifdef ORBIS
int fd = orbisOpen(path, flags, 0644);
RARCH_LOG("[VFS]retro_vfs_file_open_impl orbisOpen fd=%d path=%s\n", fd, path);
if( fd < 0)
{
stream->fd=-1;
goto error;
}
stream->fd = fd;
#else
FILE *fp = (FILE*)fopen_utf8(path, mode_str); FILE *fp = (FILE*)fopen_utf8(path, mode_str);
if (!fp) if (!fp)
@ -340,14 +372,18 @@ libretro_vfs_implementation_file *retro_vfs_file_open_impl(const char *path, uns
} }
#endif #endif
} }
#ifdef ORBIS
stream->size = orbisLseek(stream->fd, 0, SEEK_END);
orbisLseek(stream->fd, 0, SEEK_SET);
RARCH_LOG("[VFS]retro_vfs_file_open_impl size=%d fd=%d path=%s\n", stream->size, stream->fd, stream->orig_path);
#else
retro_vfs_file_seek_internal(stream, 0, SEEK_SET); retro_vfs_file_seek_internal(stream, 0, SEEK_SET);
retro_vfs_file_seek_internal(stream, 0, SEEK_END); retro_vfs_file_seek_internal(stream, 0, SEEK_END);
stream->size = retro_vfs_file_tell_impl(stream); stream->size = retro_vfs_file_tell_impl(stream);
retro_vfs_file_seek_internal(stream, 0, SEEK_SET); retro_vfs_file_seek_internal(stream, 0, SEEK_SET);
#endif
return stream; return stream;
error: error:
@ -374,7 +410,15 @@ int retro_vfs_file_close_impl(libretro_vfs_implementation_file *stream)
} }
if (stream->fd > 0) if (stream->fd > 0)
{
#ifdef ORBIS
RARCH_LOG("[VFS]retro_vfs_file_close_impl orbisClose fd=%d path=%s\n", stream->fd, stream->orig_path);
orbisClose(stream->fd);
stream->fd=-1;
#else
close(stream->fd); close(stream->fd);
#endif
}
if (stream->buf) if (stream->buf)
free(stream->buf); free(stream->buf);
if (stream->orig_path) if (stream->orig_path)
@ -386,7 +430,11 @@ int retro_vfs_file_close_impl(libretro_vfs_implementation_file *stream)
int retro_vfs_file_error_impl(libretro_vfs_implementation_file *stream) int retro_vfs_file_error_impl(libretro_vfs_implementation_file *stream)
{ {
#ifdef ORBIS
return 0;
#else
return ferror(stream->fp); return ferror(stream->fp);
#endif
} }
int64_t retro_vfs_file_size_impl(libretro_vfs_implementation_file *stream) int64_t retro_vfs_file_size_impl(libretro_vfs_implementation_file *stream)
@ -404,7 +452,7 @@ int64_t retro_vfs_file_truncate_impl(libretro_vfs_implementation_file *stream, i
#ifdef _WIN32 #ifdef _WIN32
if(_chsize(_fileno(stream->fp), length) != 0) if(_chsize(_fileno(stream->fp), length) != 0)
return -1; return -1;
#elif !defined(VITA) && !defined(PSP) && !defined(PS2) && (!defined(SWITCH) || defined(HAVE_LIBNX)) #elif !defined(VITA) && !defined(PSP) && !defined(PS2) && !defined(ORBIS) && (!defined(SWITCH) || defined(HAVE_LIBNX))
if(ftruncate(fileno(stream->fp), length) != 0) if(ftruncate(fileno(stream->fp), length) != 0)
return -1; return -1;
#endif #endif
@ -418,13 +466,27 @@ int64_t retro_vfs_file_tell_impl(libretro_vfs_implementation_file *stream)
return -1; return -1;
if ((stream->hints & RFILE_HINT_UNBUFFERED) == 0) if ((stream->hints & RFILE_HINT_UNBUFFERED) == 0)
{
#ifdef ORBIS
int64_t ret = orbisLseek(stream->fd, 0, SEEK_CUR);
RARCH_LOG("[VFS]retro_vfs_file_tell_impl orbisLseek fd=%d path=%s ret=%d\n", stream->fd, stream->orig_path, ret);
if(ret < 0)
{
return -1;
}
else
{
return ret;
}
#else
/* VC2005 and up have a special 64-bit ftell */ /* VC2005 and up have a special 64-bit ftell */
#ifdef ATLEAST_VC2005 #ifdef ATLEAST_VC2005
return _ftelli64(stream->fp); return _ftelli64(stream->fp);
#else #else
return ftell(stream->fp); return ftell(stream->fp);
#endif #endif
#endif
}
#ifdef HAVE_MMAP #ifdef HAVE_MMAP
/* Need to check stream->mapped because this function /* Need to check stream->mapped because this function
* is called in filestream_open() */ * is called in filestream_open() */
@ -462,8 +524,22 @@ int64_t retro_vfs_file_read_impl(libretro_vfs_implementation_file *stream, void
goto error; goto error;
if ((stream->hints & RFILE_HINT_UNBUFFERED) == 0) if ((stream->hints & RFILE_HINT_UNBUFFERED) == 0)
{
#ifdef ORBIS
int64_t ret = orbisRead(stream->fd, s, (size_t)len);
RARCH_LOG("[VFS]retro_vfs_file_read_impl orbisRead fd=%d path=%s bytesread=%d\n", stream->fd, stream->orig_path, ret);
if( ret < 0)
{
return -1;
}
else
{
return 0;
}
#else
return fread(s, 1, (size_t)len, stream->fp); return fread(s, 1, (size_t)len, stream->fp);
#endif
}
#ifdef HAVE_MMAP #ifdef HAVE_MMAP
if (stream->hints & RETRO_VFS_FILE_ACCESS_HINT_FREQUENT_ACCESS) if (stream->hints & RETRO_VFS_FILE_ACCESS_HINT_FREQUENT_ACCESS)
{ {
@ -492,8 +568,22 @@ int64_t retro_vfs_file_write_impl(libretro_vfs_implementation_file *stream, cons
goto error; goto error;
if ((stream->hints & RFILE_HINT_UNBUFFERED) == 0) if ((stream->hints & RFILE_HINT_UNBUFFERED) == 0)
{
#ifdef ORBIS
int64_t ret = orbisWrite(stream->fd, s, (size_t)len);
RARCH_LOG("[VFS]retro_vfs_file_write_impl orbisWrite fd=%d path=%s byteswrite=%d\n", stream->fd, stream->orig_path, ret);
if( ret < 0)
{
return -1;
}
else
{
return 0;
}
#else
return fwrite(s, 1, (size_t)len, stream->fp); return fwrite(s, 1, (size_t)len, stream->fp);
#endif
}
#ifdef HAVE_MMAP #ifdef HAVE_MMAP
if (stream->hints & RETRO_VFS_FILE_ACCESS_HINT_FREQUENT_ACCESS) if (stream->hints & RETRO_VFS_FILE_ACCESS_HINT_FREQUENT_ACCESS)
goto error; goto error;
@ -508,7 +598,11 @@ int retro_vfs_file_flush_impl(libretro_vfs_implementation_file *stream)
{ {
if (!stream) if (!stream)
return -1; return -1;
#ifdef ORBIS
return 0;
#else
return fflush(stream->fp)==0 ? 0 : -1; return fflush(stream->fp)==0 ? 0 : -1;
#endif
} }
int retro_vfs_file_remove_impl(const char *path) int retro_vfs_file_remove_impl(const char *path)
@ -546,9 +640,14 @@ int retro_vfs_file_remove_impl(const char *path)
return 0; return 0;
} }
#endif #endif
#else
#ifdef ORBIS
//by now no remove
return 0;
#else #else
if (remove(path) == 0) if (remove(path) == 0)
return 0; return 0;
#endif
#endif #endif
return -1; return -1;
} }
@ -609,9 +708,14 @@ int retro_vfs_file_rename_impl(const char *old_path, const char *new_path)
free(new_path_wide); free(new_path_wide);
#endif #endif
return -1; return -1;
#else
#ifdef ORBIS
//by now no remove
return 0;
#else #else
return rename(old_path, new_path)==0 ? 0 : -1; return rename(old_path, new_path)==0 ? 0 : -1;
#endif #endif
#endif
} }
const char *retro_vfs_file_get_path_impl(libretro_vfs_implementation_file *stream) const char *retro_vfs_file_get_path_impl(libretro_vfs_implementation_file *stream)

5
menu/drivers/xmb.c
View File

@ -4997,6 +4997,11 @@ static void xmb_context_reset_background(const char *iconpath)
task_push_image_load(path, task_push_image_load(path,
menu_display_handle_wallpaper_upload, NULL); menu_display_handle_wallpaper_upload, NULL);
#ifdef ORBIS
// to avoid weird behaviour on orbis with remote host
RARCH_LOG("[XMB] after task\n");
sleep(5);
#endif
if (path) if (path)
free(path); free(path);
} }

5
retroarch.c
View File

@ -739,6 +739,11 @@ static void retroarch_parse_input_and_config(int argc, char *argv[])
optstring = "hs:fvS:A:c:U:DN:d:" optstring = "hs:fvS:A:c:U:DN:d:"
BSV_MOVIE_ARG NETPLAY_ARG DYNAMIC_ARG FFMPEG_RECORD_ARG; BSV_MOVIE_ARG NETPLAY_ARG DYNAMIC_ARG FFMPEG_RECORD_ARG;
#ifdef ORBIS
argv = &(argv[2]);
argc = argc - 2;
#endif
#ifndef HAVE_MENU #ifndef HAVE_MENU
if (argc == 1) if (argc == 1)
{ {