Skip to content

Instantly share code, notes, and snippets.

@xyzz

xyzz/pcsx.diff Secret

Last active Jul 12, 2020
Star
Embed
What would you like to do?
Learn more about clone URLs
Download ZIP
Raw
pcsx.diff
diff --new-file -w -r pcsx_rearmed/build_clean.sh pcsx_rearmed_custom/build_clean.sh
0a1,18
> #!/bin/bash
> # clean make resource
> make clean
> rm -f plugins/*.so
> rm -f build.log
> # clean configure resource
> rm -f config.log
> rm -f config.mak
> # clean binary data
> if [ -e ../rootfs/usr/sony/bin/pcsx ]; then
> rm -f ../rootfs/usr/sony/bin/pcsx
> fi
> if [ -e ../rootfs/usr/sony/bin/plugins ]; then
> rm -rf ../rootfs/usr/sony/bin/plugins
> fi
>
> TARGET_EXECUTABLE=pcsx
> rm -f ${TARGET_EXECUTABLE}.unstripped
diff --new-file -w -r pcsx_rearmed/build_pcsx_continue.sh pcsx_rearmed_custom/build_pcsx_continue.sh
0a1,9
> #!/bin/bash
> if [ ! -e config.log ]; then
> # run configure
> echo "CFLAGS=-march=armv7-a ./configure --sound-drivers=sdl"
> CFLAGS=-march=armv7-a ./configure --sound-drivers=sdl
> fi
> # build.log include stdout & stderr
> echo "make -j 4 2>&1 | tee build.log"
> make -k -j 4 2>&1 | tee build.log
diff --new-file -w -r pcsx_rearmed/build_pcsx_enable_menu.sh pcsx_rearmed_custom/build_pcsx_enable_menu.sh
0a1,2
> #!/bin/bash
> ./build_pcsx.sh enable_menu
diff --new-file -w -r pcsx_rearmed/build_pcsx.sh pcsx_rearmed_custom/build_pcsx.sh
0a1,39
> #!/bin/bash
> #
> # 使い方:
> # $./build_pcsx.sh
> # →リリース用のpcsxがビルドされます。
> #
> # $./build_pcsx.sh enable_menu
> # →Joysticの「select + △」押下でpcsxのメニューが開くpcsxがビルドされます。
> #
> #
> source /usr/local/oecore-x86_64/environment-setup-cortexa7hf-neon-vfpv4-poky-linux-gnueabi
> if [ ! -e config.log ]; then
> # run configure
> # set sdl2-config path
> export PATH=$PATH:$SDKTARGETSYSROOT/usr/bin
> CROSS_COMPILE=arm-poky-linux-gnueabi CFLAGS="-march=armv7ve -mfloat-abi=hard -mfpu=neon-vfpv4 -mcpu=cortex-a7 -mtune=cortex-a7" ./configure --sound-drivers=sdl
> fi
> # build.log include stdout & stderr
> if [ $# -eq 1 ]; then
> if [ $1 = "enable_menu" ]; then
> BUILD_OPTION="CONFIG_ENABLE_MENU=1"
> fi
> fi
> echo "make $BUILD_OPTION -j4 2>&1 | tee build.log"
> make $BUILD_OPTION -j4 2>&1 | tee build.log
>
> TARGET_EXECUTABLE=pcsx
> STRIP_OPTION=-s
> cp ${TARGET_EXECUTABLE} ${TARGET_EXECUTABLE}.unstripped
> $(${STRIP} ${STRIP_OPTION} -o ${TARGET_EXECUTABLE} ${TARGET_EXECUTABLE}.unstripped)
>
> if [ -e ./pcsx ]; then
> mkdir -p ../rootfs/usr/sony/bin/
> cp ./pcsx ../rootfs/usr/sony/bin/
> fi
> if [ -e ./plugins ]; then
> mkdir -p ../rootfs/usr/sony/bin/plugins
> cp ./plugins/gpu_peops.so ../rootfs/usr/sony/bin/plugins
> fi
diff --new-file -w -r pcsx_rearmed/build_pcsx.sh.bak pcsx_rearmed_custom/build_pcsx.sh.bak
0a1,12
> #!/bin/bash
> if [ ! -e config.log ]; then
> # run configure
> echo "CFLAGS=-march=armv7-a ./configure --sound-drivers=sdl --disable-neon"
> CFLAGS=-march=armv7-a ./configure --sound-drivers=sdl --disable-neon
>
> mv config.mak config.mak.org
> sed s/SDL/SDL2/ config.mak.org > config.mak
> fi
> # build.log include stdout & stderr
> echo "make -j 4 2>&1 | tee build.log"
> make -j 4 2>&1 | tee build.log
diff --new-file -w -r pcsx_rearmed/configure pcsx_rearmed_custom/configure
255,259c255,259
< floatabi_set_by_gcc=`$CC -v 2>&1 | grep -q -- --with-float= && echo yes` || true
< if [ "$floatabi_set_by_gcc" != "yes" ]; then
< echo "$CFLAGS" | grep -q -- '-mfloat-abi=' || CFLAGS="$CFLAGS -mfloat-abi=softfp"
< echo "$ASFLAGS" | grep -q -- '-mfloat-abi=' || ASFLAGS="$ASFLAGS -mfloat-abi=softfp"
< fi
---
> #floatabi_set_by_gcc=`$CC -v 2>&1 | grep -q -- --with-float= && echo yes` || true
> #if [ "$floatabi_set_by_gcc" != "yes" ]; then
> #echo "$CFLAGS" | grep -q -- '-mfloat-abi=' || CFLAGS="$CFLAGS -mfloat-abi=softfp"
> #echo "$ASFLAGS" | grep -q -- '-mfloat-abi=' || ASFLAGS="$ASFLAGS -mfloat-abi=softfp"
> #fi
405c405
< if [ "$need_sdl" = "yes" ] || check_sdl `sdl-config --cflags --libs`; then
---
> if [ "$need_sdl" = "yes" ] || check_sdl `sdl2-config --cflags --libs`; then
424,428c424,428
< which sdl-config > /dev/null || \
< fail "sdl-config is missing; please install libsdl (libsdl1.2-dev)"
< CFLAGS="$CFLAGS `sdl-config --cflags`"
< MAIN_LDLIBS="`sdl-config --libs` $MAIN_LDLIBS"
< check_sdl || fail "please install libsdl (libsdl1.2-dev)"
---
> which sdl2-config > /dev/null || \
> fail "sdl2-config is missing; please install libsdl2"
> CFLAGS="$CFLAGS `pkg-config --cflags sdl2`"
> MAIN_LDLIBS="`pkg-config --libs sdl2` $MAIN_LDLIBS"
> check_sdl || fail "please install libsdl2"
451c451
< need_xlib="yes"
---
> need_xlib="no"
533a534,535
>
> MAIN_LDLIBS="$MAIN_LDLIBS -lwayland-client -lwayland-egl"
diff --new-file -w -r pcsx_rearmed/frontend/cspace.c pcsx_rearmed_custom/frontend/cspace.c
36a37,51
> void bgr555_to_rgb565_without_neon(void *dst_, const void *src_, int bytes)
> {
> const unsigned int *src = src_;
> unsigned int *dst = dst_;
> unsigned int p;
> int x;
>
> for (x = 0; x < bytes / 4; x++) {
> p = src[x];
> p = ((p & 0x7c007c00) >> 10) | ((p & 0x03e003e0) << 1)
> | ((p & 0x001f001f) << 11);
> dst[x] = p;
> }
> }
>
diff --new-file -w -r pcsx_rearmed/frontend/cspace.h pcsx_rearmed_custom/frontend/cspace.h
6a7,9
> #ifdef __ARM_NEON__
> void bgr555_to_rgb565_without_neon(void *dst, const void *src, int bytes);
> #endif __ARM_NEON__
diff --new-file -w -r pcsx_rearmed/frontend/libpicofe/.gitignore pcsx_rearmed_custom/frontend/libpicofe/.gitignore
1,4d0
< *.o
< *.swp
< cscope.out
< tags
diff --new-file -w -r pcsx_rearmed/frontend/libpicofe/gl.c pcsx_rearmed_custom/frontend/libpicofe/gl.c
44a45
>
49a51,52
> printf("frontend/libpicore/gl.c : gl_init()\n");
>
56c59
< tmp_texture_mem = calloc(1, 1024 * 512 * 2);
---
> tmp_texture_mem = calloc(1, 1024 * 1024 * 3);
106,107c109,110
< glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 1024, 512, 0, GL_RGB,
< GL_UNSIGNED_SHORT_5_6_5, tmp_texture_mem);
---
> glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 1024, 1024, 0, GL_RGB,
> GL_UNSIGNED_BYTE, tmp_texture_mem);
135,138c138,141
< -1.0f, 1.0f, 0.0f, // 0 0 1
< 1.0f, 1.0f, 0.0f, // 1 ^
< -1.0f, -1.0f, 0.0f, // 2 | 2 3
< 1.0f, -1.0f, 0.0f, // 3 +-->
---
> -0.95f, 0.95f, 0.0f, // 0 0 1
> 0.95f, 0.95f, 0.0f, // 1 ^
> -0.95f, -0.95f, 0.0f, // 2 | 2 3
> 0.95f, -0.95f, 0.0f, // 3 +-->
148c151
< int gl_flip(const void *fb, int w, int h)
---
> int gl_flip(const void *fb, int w, int h, int rgb888)
155c158
< float f_h = (float)h / 512.0f;
---
> float f_h = (float)h / 1024.0f;
164c167,171
< glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, w, h,
---
> if( rgb888 ){
> glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, w, h > 1024 ? 1024 : h,
> GL_RGB, GL_UNSIGNED_BYTE, fb);
> }else{
> glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, w, h > 1024 ? 1024 : h,
165a173
> }
diff --new-file -w -r pcsx_rearmed/frontend/libpicofe/gl.h pcsx_rearmed_custom/frontend/libpicofe/gl.h
7c7
< int gl_flip(const void *fb, int w, int h);
---
> int gl_flip(const void *fb, int w, int h, int rgb888);
diff --new-file -w -r pcsx_rearmed/frontend/libpicofe/gl_platform.c pcsx_rearmed_custom/frontend/libpicofe/gl_platform.c
8a9,22
> #include <errno.h>
> #include <stdbool.h>
> #include <string.h>
> #include <time.h>
> #include <assert.h>
>
> #include <EGL/egl.h>
> #include <wayland-client.h>
> #include <wayland-egl.h>
> #include <libdrm/drm_fourcc.h>
> //#include <xf86drm.h>
> //#include <xf86drmMode.h>
>
>
17c31
< #include <X11/Xlib.h>
---
> //#include <X11/Xlib.h>
20,21c34,35
< static Display *x11display;
< static Window x11window;
---
> //static Display *x11display;
> //static Window x11window;
27,29c41,43
< static FPTR(XGetGeometry);
< static FPTR(XGetWindowAttributes);
< static FPTR(XTranslateCoordinates);
---
> //static FPTR(XGetGeometry);
> //static FPTR(XGetWindowAttributes);
> //static FPTR(XTranslateCoordinates);
33c47
< XWindowAttributes xattrs_root;
---
> // XWindowAttributes xattrs_root;
37c51
< Window root, dummyw;
---
> // Window root, dummyw;
48c62
< if (x11display == NULL || x11window == 0)
---
> // if (x11display == NULL || x11window == 0)
51,53c65,67
< pXGetGeometry(x11display, x11window, &root, &dx, &dy, &dw, &dh,
< &dummy, &dummy);
< pXGetWindowAttributes(x11display, root, &xattrs_root);
---
> // pXGetGeometry(x11display, x11window, &root, &dx, &dy, &dw, &dh,
> // &dummy, &dummy);
> // pXGetWindowAttributes(x11display, root, &xattrs_root);
55,56c69,70
< if (dw == xattrs_root.width && dh == xattrs_root.height)
< return; // use fullscreen
---
> // if (dw == xattrs_root.width && dh == xattrs_root.height)
> // return; // use fullscreen
58,59c72,73
< pXTranslateCoordinates(x11display, x11window, root,
< dx, dy, &dx, &dy, &dummyw);
---
> // pXTranslateCoordinates(x11display, x11window, root,
> // dx, dy, &dx, &dy, &dummyw);
63,64c77,78
< dx += (disp_w - xattrs_root.width) / 2;
< dy += (disp_h - xattrs_root.height) / 2;
---
> // dx += (disp_w - xattrs_root.width) / 2;
> // dy += (disp_h - xattrs_root.height) / 2;
66,69c80,83
< rect->x = dx;
< rect->y = dy;
< rect->width = dw;
< rect->height = dh;
---
> // rect->x = dx;
> // rect->y = dy;
> // rect->width = dw;
> // rect->height = dh;
97,98c111,112
< x11display = NULL;
< x11window = 0;
---
> // x11display = NULL;
> // x11window = 0;
100,111c114,125
< x11lib = dlopen("libX11.so.6", RTLD_LAZY);
< if (x11lib != NULL) {
< pXGetGeometry = dlsym(x11lib, "XGetGeometry");
< pXGetWindowAttributes = dlsym(x11lib, "XGetWindowAttributes");
< pXTranslateCoordinates = dlsym(x11lib, "XTranslateCoordinates");
< if (pXGetGeometry != NULL && pXGetWindowAttributes != NULL
< && pXTranslateCoordinates != NULL)
< {
< x11display = *display;
< x11window = (Window)*window;
< }
< }
---
> // x11lib = dlopen("libX11.so.6", RTLD_LAZY);
> // if (x11lib != NULL) {
> // pXGetGeometry = dlsym(x11lib, "XGetGeometry");
> // pXGetWindowAttributes = dlsym(x11lib, "XGetWindowAttributes");
> // pXTranslateCoordinates = dlsym(x11lib, "XTranslateCoordinates");
> // if (pXGetGeometry != NULL && pXGetWindowAttributes != NULL
> // && pXTranslateCoordinates != NULL)
> // {
> // x11display = *display;
> // x11window = (Window)*window;
> // }
> // }
133,134c147,148
< x11display = NULL;
< x11window = 0;
---
> // x11display = NULL;
> // x11window = 0;
138a153,313
> #if 1
> struct wayland_info {
> struct wl_display *display;
> struct wl_registry *registry;
> struct wl_compositor *compositor;
> struct wl_shell *shell;
>
> bool roundtrip_needed;
>
> struct {
> struct wl_shell_surface *shell_surface;
> struct wl_surface *surface;
> struct wl_egl_window *egl_window;
> EGLSurface egl_surface;
> } surface;
>
> };
> #endif
>
> #if 0
> static void
> global_handler(void *data, struct wl_registry *registry, uint32_t id,
> const char *interface, uint32_t version)
> {
> struct wayland_info *info = data;
>
> if (strcmp(interface, "wl_compositor") == 0) {
> info->compositor = wl_registry_bind(registry, id,
> &wl_compositor_interface, 1);
> }
> else if (strcmp(interface, "wl_shell") == 0) {
> info->shell = wl_registry_bind(registry, id,
> &wl_shell_interface, 1);
> }
> }
>
> static void
> global_remove_handler(void *data, struct wl_registry *registry, uint32_t name)
> {
>
> }
>
> static const struct wl_registry_listener registry_listener = {
> global_handler,
> global_remove_handler
> };
>
> static void
> handle_ping (void *data, struct wl_shell_surface *shell_surface,
> uint32_t serial)
> {
> wl_shell_surface_pong (shell_surface, serial);
> }
>
>
> static void
> handle_configure (void *data, struct wl_shell_surface *shell_surface,
> uint32_t edges, int32_t width, int32_t height)
> {
> struct wayland_info *info = data;
>
> wl_egl_window_resize (info->surface.egl_window, width, height, 0, 0);
> printf("handle_configure ReSize Window[%d, %d]\n", width, height);
> }
>
> static void
> handle_popup_done (void *data, struct wl_shell_surface *shell_surface)
> {
> }
>
> static const struct wl_shell_surface_listener shell_surface_listener = {
> handle_ping,
> handle_configure,
> handle_popup_done
> };
>
> static void
> create_surface(struct wayland_info *info)
> {
> info->surface.shell_surface = wl_shell_get_shell_surface (info->shell, info->surface.surface);
> wl_shell_surface_add_listener(info->surface.shell_surface, &shell_surface_listener, info);
> wl_shell_surface_set_toplevel(info->surface.shell_surface);
> }
>
> int __gl_platform_init(void **display, void **window, int *quirks)
> {
>
> struct wayland_info *info = malloc(sizeof(struct wayland_info));
>
> if (info == NULL)
> return 0;
>
> info->display = wl_display_connect(NULL);
> if (!info->display) {
> printf("wl_display_connect is failed\n");
> exit(EXIT_SUCCESS);
> }
>
> info->registry = wl_display_get_registry(info->display);
> wl_registry_add_listener(info->registry, &registry_listener, info);
> wl_display_dispatch (info->display);
> wl_display_roundtrip(info->display);
>
> *display = info->display;
>
> info->surface.surface = wl_compositor_create_surface(info->compositor);
> create_surface(info);
>
> wl_display_roundtrip(info->display);
>
> info->surface.egl_window = wl_egl_window_create(info->surface.surface,
> 1280,
> 720);
> *window = info->surface.egl_window;
>
> return 0;
> }
>
> void gl_platform_finish(void)
> {
> }
> #endif
>
> #if 1
> #if 1
> static struct wl_display * aa_display;
> static struct wl_shell_surface *aa_shell_surface;
> static struct wl_surface *aa_surface;
> static struct wl_egl_window *aa_window;
>
> void gl_setup_wl_information(struct wl_display * idisplay,
> struct wl_surface *isurface,
> struct wl_shell_surface *ishell_surface)
> {
> aa_display = idisplay;
> aa_surface = isurface;
> aa_shell_surface = ishell_surface;
>
> printf("gl_setup_wl_information, display:0x%x, surface: 0x%x\n",
> aa_display, aa_surface);
>
> }
> #endif
>
> #if 0
> static struct wl_display * plat_display;
> static struct wl_surface *plat_surface;
> static struct wl_egl_window *plat_window;
>
> void gl_setup_wl_information(struct wl_display * idisplay,
> struct wl_surface *isurface)
> {
> plat_display = idisplay;
> plat_surface = isurface;
>
> printf("aaaa gl_setup_wl_information, display:0x%x, surface: 0x%x\n",
> plat_display, plat_surface);
>
> }
> #endif
>
140a316,348
> #if 1
> struct wayland_info *info = malloc(sizeof(struct wayland_info));
>
> if (info == NULL)
> return 0;
>
> info->display = aa_display;
> if (!info->display) {
> printf("wl_display_connect is failed\n");
> }
>
>
> *display = info->display;
>
> info->surface.surface = aa_surface;
> info->surface.shell_surface = aa_shell_surface;
>
>
> printf("gl_platform_init before window_create\n");
>
> info->surface.egl_window = wl_egl_window_create(info->surface.surface,
> 960,
> 720);
> *window = info->surface.egl_window;
>
> printf("gl_platform_init, display:0x%x, window: 0x%x\n",
> info->display, info->surface.egl_window);
> #endif
>
> //plat_window = wl_egl_window_create(plat_surface, 1280, 720); //640, 480);
> //*display = plat_display;
> //*window = plat_window;
>
145a354
> //wl_egl_window_destroy(plat_window);
148a358,359
>
> #endif
diff --new-file -w -r pcsx_rearmed/frontend/libpicofe/input.c pcsx_rearmed_custom/frontend/libpicofe/input.c
14a15
> #include <SDL.h>
18a20
> #include "../main.h"
250c252
<
---
> SDL_QuitSubSystem(SDL_INIT_JOYSTICK);
318c320
< while (1)
---
> while (!power_off_flg)
471a474,476
> if (power_off_flg) {
> break;
> }
1026a1032,1045
>
> typedef int bool;
> #define true 1
> #define false 0
>
> bool bIsValidHotPlugEvent(SDL_Event *arg_pEvent) {
> bool bRet = false;
>
> if((arg_pEvent->jdevice.type == SDL_JOYDEVICEADDED) ||
> (arg_pEvent->jdevice.type == SDL_JOYDEVICEREMOVED)) {
> bRet = true;
> }
> return bRet;
> }
diff --new-file -w -r pcsx_rearmed/frontend/libpicofe/input.h pcsx_rearmed_custom/frontend/libpicofe/input.h
79a80
> int p2_connected;
diff --new-file -w -r pcsx_rearmed/frontend/libpicofe/in_sdl.c pcsx_rearmed_custom/frontend/libpicofe/in_sdl.c
13a14,17
> #include <sys/types.h>
> #include <sys/stat.h>
> #include <fcntl.h>
>
15a20,26
> #if SDL_MAJOR_VERSION == 2
> #include "keysym.h"
> typedef int bool;
> #define true 1
> #define false 0
> //#define CONFIG_DEBUG
> #endif
31a43,458
> #if SDL_MAJOR_VERSION == 2
> SDLK_to_MY_SDLK SDLK_to_My_SDLK_ARRAY[] = {
> {SDLK_UNKNOWN, MY_SDLK_UNKNOWN},
>
> {SDLK_RETURN, MY_SDLK_RETURN},
> {SDLK_ESCAPE, MY_SDLK_ESCAPE},
> {SDLK_BACKSPACE, MY_SDLK_BACKSPACE},
> {SDLK_TAB, MY_SDLK_TAB},
> {SDLK_SPACE, MY_SDLK_SPACE},
> {SDLK_EXCLAIM, MY_SDLK_EXCLAIM},
> {SDLK_QUOTEDBL, MY_SDLK_QUOTEDBL},
> {SDLK_HASH, MY_SDLK_HASH},
> {SDLK_PERCENT, MY_SDLK_PERCENT},
> {SDLK_DOLLAR, MY_SDLK_DOLLAR},
> {SDLK_AMPERSAND, MY_SDLK_AMPERSAND},
> {SDLK_QUOTE, MY_SDLK_QUOTE},
> {SDLK_LEFTPAREN, MY_SDLK_LEFTPAREN},
> {SDLK_RIGHTPAREN, MY_SDLK_RIGHTPAREN},
> {SDLK_ASTERISK, MY_SDLK_ASTERISK},
> {SDLK_PLUS, MY_SDLK_PLUS},
> {SDLK_COMMA, MY_SDLK_COMMA},
> {SDLK_MINUS, MY_SDLK_MINUS},
> {SDLK_PERIOD, MY_SDLK_PERIOD},
> {SDLK_SLASH, MY_SDLK_SLASH},
> {SDLK_0, MY_SDLK_0},
> {SDLK_1, MY_SDLK_1},
> {SDLK_2, MY_SDLK_2},
> {SDLK_3, MY_SDLK_3},
> {SDLK_4, MY_SDLK_4},
> {SDLK_5, MY_SDLK_5},
> {SDLK_6, MY_SDLK_6},
> {SDLK_7, MY_SDLK_7},
> {SDLK_8, MY_SDLK_8},
> {SDLK_9, MY_SDLK_9},
> {SDLK_COLON, MY_SDLK_COLON},
> {SDLK_SEMICOLON, MY_SDLK_SEMICOLON},
> {SDLK_LESS, MY_SDLK_LESS},
> {SDLK_EQUALS, MY_SDLK_EQUALS},
> {SDLK_GREATER, MY_SDLK_GREATER},
> {SDLK_QUESTION, MY_SDLK_QUESTION},
> {SDLK_AT, MY_SDLK_AT},
> /*
> Skip uppercase letters
> */
> {SDLK_LEFTBRACKET, MY_SDLK_LEFTBRACKET},
> {SDLK_BACKSLASH, MY_SDLK_BACKSLASH},
> {SDLK_RIGHTBRACKET, MY_SDLK_RIGHTBRACKET},
> {SDLK_CARET, MY_SDLK_CARET},
> {SDLK_UNDERSCORE, MY_SDLK_UNDERSCORE},
> {SDLK_BACKQUOTE, MY_SDLK_BACKQUOTE},
> {SDLK_a, MY_SDLK_a},
> {SDLK_b, MY_SDLK_b},
> {SDLK_c, MY_SDLK_c},
> {SDLK_d, MY_SDLK_d},
> {SDLK_e, MY_SDLK_e},
> {SDLK_f, MY_SDLK_f},
> {SDLK_g, MY_SDLK_g},
> {SDLK_h, MY_SDLK_h},
> {SDLK_i, MY_SDLK_i},
> {SDLK_j, MY_SDLK_j},
> {SDLK_k, MY_SDLK_k},
> {SDLK_l, MY_SDLK_l},
> {SDLK_m, MY_SDLK_m},
> {SDLK_n, MY_SDLK_n},
> {SDLK_o, MY_SDLK_o},
> {SDLK_p, MY_SDLK_p},
> {SDLK_q, MY_SDLK_q},
> {SDLK_r, MY_SDLK_r},
> {SDLK_s, MY_SDLK_s},
> {SDLK_t, MY_SDLK_t},
> {SDLK_u, MY_SDLK_u},
> {SDLK_v, MY_SDLK_v},
> {SDLK_w, MY_SDLK_w},
> {SDLK_x, MY_SDLK_x},
> {SDLK_y, MY_SDLK_y},
> {SDLK_z, MY_SDLK_z},
>
> {SDLK_CAPSLOCK, MY_SDLK_CAPSLOCK},
>
> {SDLK_F1, MY_SDLK_F1},
> {SDLK_F2, MY_SDLK_F2},
> {SDLK_F3, MY_SDLK_F3},
> {SDLK_F4, MY_SDLK_F4},
> {SDLK_F5, MY_SDLK_F5},
> {SDLK_F6, MY_SDLK_F6},
> {SDLK_F7, MY_SDLK_F7},
> {SDLK_F8, MY_SDLK_F8},
> {SDLK_F9, MY_SDLK_F9},
> {SDLK_F10, MY_SDLK_F10},
> {SDLK_F11, MY_SDLK_F11},
> {SDLK_F12, MY_SDLK_F12},
>
> {SDLK_PRINTSCREEN, MY_SDLK_PRINTSCREEN},
> {SDLK_SCROLLLOCK, MY_SDLK_SCROLLLOCK},
> {SDLK_PAUSE, MY_SDLK_PAUSE},
> {SDLK_INSERT, MY_SDLK_INSERT},
> {SDLK_HOME, MY_SDLK_HOME},
> {SDLK_PAGEUP, MY_SDLK_PAGEUP},
> {SDLK_DELETE, MY_SDLK_DELETE},
> {SDLK_END, MY_SDLK_END},
> {SDLK_PAGEDOWN, MY_SDLK_PAGEDOWN},
> {SDLK_RIGHT, MY_SDLK_RIGHT},
> {SDLK_LEFT, MY_SDLK_LEFT},
> {SDLK_DOWN, MY_SDLK_DOWN},
> {SDLK_UP, MY_SDLK_UP},
>
> {SDLK_NUMLOCKCLEAR, MY_SDLK_NUMLOCKCLEAR},
> {SDLK_KP_DIVIDE, MY_SDLK_KP_DIVIDE},
> {SDLK_KP_MULTIPLY, MY_SDLK_KP_MULTIPLY},
> {SDLK_KP_MINUS, MY_SDLK_KP_MINUS},
> {SDLK_KP_PLUS, MY_SDLK_KP_PLUS},
> {SDLK_KP_ENTER, MY_SDLK_KP_ENTER},
> {SDLK_KP_1, MY_SDLK_KP_1},
> {SDLK_KP_2, MY_SDLK_KP_2},
> {SDLK_KP_3, MY_SDLK_KP_3},
> {SDLK_KP_4, MY_SDLK_KP_4},
> {SDLK_KP_5, MY_SDLK_KP_5},
> {SDLK_KP_6, MY_SDLK_KP_6},
> {SDLK_KP_7, MY_SDLK_KP_7},
> {SDLK_KP_8, MY_SDLK_KP_8},
> {SDLK_KP_9, MY_SDLK_KP_9},
> {SDLK_KP_0, MY_SDLK_KP_0},
> {SDLK_KP_PERIOD, MY_SDLK_KP_PERIOD},
>
> {SDLK_APPLICATION, MY_SDLK_APPLICATION},
> {SDLK_POWER, MY_SDLK_POWER},
> {SDLK_KP_EQUALS, MY_SDLK_KP_EQUALS},
> {SDLK_F13, MY_SDLK_F13},
> {SDLK_F14, MY_SDLK_F14},
> {SDLK_F15, MY_SDLK_F15},
> {SDLK_F16, MY_SDLK_F16},
> {SDLK_F17, MY_SDLK_F17},
> {SDLK_F18, MY_SDLK_F18},
> {SDLK_F19, MY_SDLK_F19},
> {SDLK_F20, MY_SDLK_F20},
> {SDLK_F21, MY_SDLK_F21},
> {SDLK_F22, MY_SDLK_F22},
> {SDLK_F23, MY_SDLK_F23},
> {SDLK_F24, MY_SDLK_F24},
> {SDLK_EXECUTE, MY_SDLK_EXECUTE},
> {SDLK_HELP, MY_SDLK_HELP},
> {SDLK_MENU, MY_SDLK_MENU},
> {SDLK_SELECT, MY_SDLK_SELECT},
> {SDLK_STOP, MY_SDLK_STOP},
> {SDLK_AGAIN, MY_SDLK_AGAIN},
> {SDLK_UNDO, MY_SDLK_UNDO},
> {SDLK_CUT, MY_SDLK_CUT},
> {SDLK_COPY, MY_SDLK_COPY},
> {SDLK_PASTE, MY_SDLK_PASTE},
> {SDLK_FIND, MY_SDLK_FIND},
> {SDLK_MUTE, MY_SDLK_MUTE},
> {SDLK_VOLUMEUP, MY_SDLK_VOLUMEUP},
> {SDLK_VOLUMEDOWN, MY_SDLK_VOLUMEDOWN},
> {SDLK_KP_COMMA, MY_SDLK_KP_COMMA},
> {SDLK_KP_EQUALSAS400, MY_SDLK_KP_EQUALSAS400},
>
> {SDLK_ALTERASE, MY_SDLK_ALTERASE},
> {SDLK_SYSREQ, MY_SDLK_SYSREQ},
> {SDLK_CANCEL, MY_SDLK_CANCEL},
> {SDLK_CLEAR, MY_SDLK_CLEAR},
> {SDLK_PRIOR, MY_SDLK_PRIOR},
> {SDLK_RETURN2, MY_SDLK_RETURN2},
> {SDLK_SEPARATOR, MY_SDLK_SEPARATOR},
> {SDLK_OUT, MY_SDLK_OUT},
> {SDLK_OPER, MY_SDLK_OPER},
> {SDLK_CLEARAGAIN, MY_SDLK_CLEARAGAIN},
> {SDLK_CRSEL, MY_SDLK_CRSEL},
> {SDLK_EXSEL, MY_SDLK_EXSEL},
>
> {SDLK_KP_00, MY_SDLK_KP_00},
> {SDLK_KP_000, MY_SDLK_KP_000},
> {SDLK_THOUSANDSSEPARATOR, MY_SDLK_THOUSANDSSEPARATOR},
> {SDLK_DECIMALSEPARATOR, MY_SDLK_DECIMALSEPARATOR},
> {SDLK_CURRENCYUNIT, MY_SDLK_CURRENCYUNIT},
> {SDLK_CURRENCYSUBUNIT, MY_SDLK_CURRENCYSUBUNIT},
> {SDLK_KP_LEFTPAREN, MY_SDLK_KP_LEFTPAREN},
> {SDLK_KP_RIGHTPAREN, MY_SDLK_KP_RIGHTPAREN},
> {SDLK_KP_LEFTBRACE, MY_SDLK_KP_LEFTBRACE},
> {SDLK_KP_RIGHTBRACE, MY_SDLK_KP_RIGHTBRACE},
> {SDLK_KP_TAB, MY_SDLK_KP_TAB},
> {SDLK_KP_BACKSPACE, MY_SDLK_KP_BACKSPACE},
> {SDLK_KP_A, MY_SDLK_KP_A},
> {SDLK_KP_B, MY_SDLK_KP_B},
> {SDLK_KP_C, MY_SDLK_KP_C},
> {SDLK_KP_D, MY_SDLK_KP_D},
> {SDLK_KP_E, MY_SDLK_KP_E},
> {SDLK_KP_F, MY_SDLK_KP_F},
> {SDLK_KP_XOR, MY_SDLK_KP_XOR},
> {SDLK_KP_POWER, MY_SDLK_KP_POWER},
> {SDLK_KP_PERCENT, MY_SDLK_KP_PERCENT},
> {SDLK_KP_LESS, MY_SDLK_KP_LESS},
> {SDLK_KP_GREATER, MY_SDLK_KP_GREATER},
> {SDLK_KP_AMPERSAND, MY_SDLK_KP_AMPERSAND},
> {SDLK_KP_DBLAMPERSAND, MY_SDLK_KP_DBLAMPERSAND},
> {SDLK_KP_VERTICALBAR, MY_SDLK_KP_VERTICALBAR},
> {SDLK_KP_DBLVERTICALBAR, MY_SDLK_KP_DBLVERTICALBAR},
> {SDLK_KP_COLON, MY_SDLK_KP_COLON},
> {SDLK_KP_HASH, MY_SDLK_KP_HASH},
> {SDLK_KP_SPACE, MY_SDLK_KP_SPACE},
> {SDLK_KP_AT, MY_SDLK_KP_AT},
> {SDLK_KP_EXCLAM, MY_SDLK_KP_EXCLAM},
> {SDLK_KP_MEMSTORE, MY_SDLK_KP_MEMSTORE},
> {SDLK_KP_MEMRECALL, MY_SDLK_KP_MEMRECALL},
> {SDLK_KP_MEMCLEAR, MY_SDLK_KP_MEMCLEAR},
> {SDLK_KP_MEMADD, MY_SDLK_KP_MEMADD},
> {SDLK_KP_MEMSUBTRACT, MY_SDLK_KP_MEMSUBTRACT},
> {SDLK_KP_MEMMULTIPLY, MY_SDLK_KP_MEMMULTIPLY},
> {SDLK_KP_MEMDIVIDE, MY_SDLK_KP_MEMDIVIDE},
> {SDLK_KP_PLUSMINUS, MY_SDLK_KP_PLUSMINUS},
> {SDLK_KP_CLEAR, MY_SDLK_KP_CLEAR},
> {SDLK_KP_CLEARENTRY, MY_SDLK_KP_CLEARENTRY},
> {SDLK_KP_BINARY, MY_SDLK_KP_BINARY},
> {SDLK_KP_OCTAL, MY_SDLK_KP_OCTAL},
> {SDLK_KP_DECIMAL, MY_SDLK_KP_DECIMAL},
> {SDLK_KP_HEXADECIMAL, MY_SDLK_KP_HEXADECIMAL},
>
> {SDLK_LCTRL, MY_SDLK_LCTRL},
> {SDLK_LSHIFT, MY_SDLK_LSHIFT},
> {SDLK_LALT, MY_SDLK_LALT},
> {SDLK_LGUI, MY_SDLK_LGUI},
> {SDLK_RCTRL, MY_SDLK_RCTRL},
> {SDLK_RSHIFT, MY_SDLK_RSHIFT},
> {SDLK_RALT, MY_SDLK_RALT},
> {SDLK_RGUI, MY_SDLK_RGUI},
>
> {SDLK_MODE, MY_SDLK_MODE},
>
> {SDLK_AUDIONEXT, MY_SDLK_AUDIONEXT},
> {SDLK_AUDIOPREV, MY_SDLK_AUDIOPREV},
> {SDLK_AUDIOSTOP, MY_SDLK_AUDIOSTOP},
> {SDLK_AUDIOPLAY, MY_SDLK_AUDIOPLAY},
> {SDLK_AUDIOMUTE, MY_SDLK_AUDIOMUTE},
> {SDLK_MEDIASELECT, MY_SDLK_MEDIASELECT},
> {SDLK_WWW, MY_SDLK_WWW},
> {SDLK_MAIL, MY_SDLK_MAIL},
> {SDLK_CALCULATOR, MY_SDLK_CALCULATOR},
> {SDLK_COMPUTER, MY_SDLK_COMPUTER},
> {SDLK_AC_SEARCH, MY_SDLK_AC_SEARCH},
> {SDLK_AC_HOME, MY_SDLK_AC_HOME},
> {SDLK_AC_BACK, MY_SDLK_AC_BACK},
> {SDLK_AC_FORWARD, MY_SDLK_AC_FORWARD},
> {SDLK_AC_STOP, MY_SDLK_AC_STOP},
> {SDLK_AC_REFRESH, MY_SDLK_AC_REFRESH},
> {SDLK_AC_BOOKMARKS, MY_SDLK_AC_BOOKMARKS},
>
> {SDLK_BRIGHTNESSDOWN, MY_SDLK_BRIGHTNESSDOWN},
> {SDLK_BRIGHTNESSUP, MY_SDLK_BRIGHTNESSUP},
> {SDLK_DISPLAYSWITCH, MY_SDLK_DISPLAYSWITCH},
> {SDLK_KBDILLUMTOGGLE, MY_SDLK_KBDILLUMTOGGLE},
> {SDLK_KBDILLUMDOWN, MY_SDLK_KBDILLUMDOWN},
> {SDLK_KBDILLUMUP, MY_SDLK_KBDILLUMUP},
> {SDLK_EJECT, MY_SDLK_EJECT},
> {SDLK_SLEEP, MY_SDLK_SLEEP},
> //{SDLK_APP1, MY_SDLK_APP1},
> //{SDLK_APP2, MY_SDLK_APP2},
>
> //{SDLK_AUDIOREWIND, MY_SDLK_AUDIOREWIND},
> //{SDLK_AUDIOFASTFORWARD, MY_SDLK_AUDIOFASTFORWARD},
>
> {SDLK_LAST, MY_SDLK_UNKNOWN}
> };
>
> static int func_SDLK_TO_MY_SDLK(int argSDLK) {
> int i = 0;
>
> do {
> if(SDLK_to_My_SDLK_ARRAY[i].m_SDLK == argSDLK) {
> break;
> }
> i++;
> } while(SDLK_to_My_SDLK_ARRAY[i].m_SDLK != SDLK_LAST);
> return SDLK_to_My_SDLK_ARRAY[i].m_MySDLK;
> }
>
> // SDL1で定義されているものを文字列と指定
> static const char * const in_sdl_keys[SDLK_LAST] = {
> [MY_SDLK_BACKSPACE] = "backspace",
> [MY_SDLK_TAB] = "tab",
> [MY_SDLK_CLEAR] = "clear",
> [MY_SDLK_RETURN] = "return",
> [MY_SDLK_PAUSE] = "pause",
> [MY_SDLK_ESCAPE] = "escape",
> [MY_SDLK_SPACE] = "space",
> [MY_SDLK_EXCLAIM] = "!",
> [MY_SDLK_QUOTEDBL] = "\"",
> [MY_SDLK_HASH] = "#",
> [MY_SDLK_DOLLAR] = "$",
> [MY_SDLK_AMPERSAND] = "&",
> [MY_SDLK_QUOTE] = "'",
> [MY_SDLK_LEFTPAREN] = "(",
> [MY_SDLK_RIGHTPAREN] = ")",
> [MY_SDLK_ASTERISK] = "*",
> [MY_SDLK_PLUS] = "+",
> [MY_SDLK_COMMA] = ",",
> [MY_SDLK_MINUS] = "-",
> [MY_SDLK_PERIOD] = ".",
> [MY_SDLK_SLASH] = "/",
> [MY_SDLK_0] = "0",
> [MY_SDLK_1] = "1",
> [MY_SDLK_2] = "2",
> [MY_SDLK_3] = "3",
> [MY_SDLK_4] = "4",
> [MY_SDLK_5] = "5",
> [MY_SDLK_6] = "6",
> [MY_SDLK_7] = "7",
> [MY_SDLK_8] = "8",
> [MY_SDLK_9] = "9",
> [MY_SDLK_COLON] = ":",
> [MY_SDLK_SEMICOLON] = ";",
> [MY_SDLK_LESS] = "<",
> [MY_SDLK_EQUALS] = "=",
> [MY_SDLK_GREATER] = ">",
> [MY_SDLK_QUESTION] = "?",
> [MY_SDLK_AT] = "@",
> [MY_SDLK_LEFTBRACKET] = "[",
> [MY_SDLK_BACKSLASH] = "\\",
> [MY_SDLK_RIGHTBRACKET] = "]",
> [MY_SDLK_CARET] = "^",
> [MY_SDLK_UNDERSCORE] = "_",
> [MY_SDLK_BACKQUOTE] = "`",
> [MY_SDLK_a] = "a",
> [MY_SDLK_b] = "b",
> [MY_SDLK_c] = "c",
> [MY_SDLK_d] = "d",
> [MY_SDLK_e] = "e",
> [MY_SDLK_f] = "f",
> [MY_SDLK_g] = "g",
> [MY_SDLK_h] = "h",
> [MY_SDLK_i] = "i",
> [MY_SDLK_j] = "j",
> [MY_SDLK_k] = "k",
> [MY_SDLK_l] = "l",
> [MY_SDLK_m] = "m",
> [MY_SDLK_n] = "n",
> [MY_SDLK_o] = "o",
> [MY_SDLK_p] = "p",
> [MY_SDLK_q] = "q",
> [MY_SDLK_r] = "r",
> [MY_SDLK_s] = "s",
> [MY_SDLK_t] = "t",
> [MY_SDLK_u] = "u",
> [MY_SDLK_v] = "v",
> [MY_SDLK_w] = "w",
> [MY_SDLK_x] = "x",
> [MY_SDLK_y] = "y",
> [MY_SDLK_z] = "z",
> [MY_SDLK_DELETE] = "delete",
>
> [MY_SDLK_KP_0] = "[0]",
> [MY_SDLK_KP_1] = "[1]",
> [MY_SDLK_KP_2] = "[2]",
> [MY_SDLK_KP_3] = "[3]",
> [MY_SDLK_KP_4] = "[4]",
> [MY_SDLK_KP_5] = "[5]",
> [MY_SDLK_KP_6] = "[6]",
> [MY_SDLK_KP_7] = "[7]",
> [MY_SDLK_KP_8] = "[8]",
> [MY_SDLK_KP_9] = "[9]",
> [MY_SDLK_KP_PERIOD] = "[.]",
> [MY_SDLK_KP_DIVIDE] = "[/]",
> [MY_SDLK_KP_MULTIPLY] = "[*]",
> [MY_SDLK_KP_MINUS] = "[-]",
> [MY_SDLK_KP_PLUS] = "[+]",
> [MY_SDLK_KP_ENTER] = "enter",
> [MY_SDLK_KP_EQUALS] = "equals",
>
> [MY_SDLK_UP] = "up",
> [MY_SDLK_DOWN] = "down",
> [MY_SDLK_RIGHT] = "right",
> [MY_SDLK_LEFT] = "left",
> [MY_SDLK_INSERT] = "insert",
> [MY_SDLK_HOME] = "home",
> [MY_SDLK_END] = "end",
> [MY_SDLK_PAGEUP] = "page up",
> [MY_SDLK_PAGEDOWN] = "page down",
>
> [MY_SDLK_F1] = "f1",
> [MY_SDLK_F2] = "f2",
> [MY_SDLK_F3] = "f3",
> [MY_SDLK_F4] = "f4",
> [MY_SDLK_F5] = "f5",
> [MY_SDLK_F6] = "f6",
> [MY_SDLK_F7] = "f7",
> [MY_SDLK_F8] = "f8",
> [MY_SDLK_F9] = "f9",
> [MY_SDLK_F10] = "f10",
> [MY_SDLK_F11] = "f11",
> [MY_SDLK_F12] = "f12",
> [MY_SDLK_F13] = "f13",
> [MY_SDLK_F14] = "f14",
> [MY_SDLK_F15] = "f15",
>
> [MY_SDLK_NUMLOCKCLEAR] = "numlock",
> [MY_SDLK_CAPSLOCK] = "caps lock",
> [MY_SDLK_SCROLLLOCK] = "scroll lock",
> [MY_SDLK_RSHIFT] = "right shift",
> [MY_SDLK_LSHIFT] = "left shift",
> [MY_SDLK_RCTRL] = "right ctrl",
> [MY_SDLK_LCTRL] = "left ctrl",
> [MY_SDLK_RALT] = "right alt",
> [MY_SDLK_LALT] = "left alt",
> #ifdef NOTDEF
> [MY_SDLK_RMETA] = "right meta",
> [MY_SDLK_LMETA] = "left meta",
> [MY_SDLK_LSUPER] = "left super", /* "Windows" keys */
> [MY_SDLK_RSUPER] = "right super",
> #endif
> [MY_SDLK_MODE] = "alt gr",
> #ifdef NOTDEF
> [MY_SDLK_COMPOSE] = "compose",
> #endif
> [MY_SDLK_EJECT] = "eject",
> [MY_SDLK_SLEEP] = "sleep",
> [MY_SDLK_AUDIOPLAY] = "reset",
> };
> #else
163a591,593
> [SDLK_EJECT] = "eject",
> [SDLK_SLEEP] = "sleep",
> [SDLK_AUDIOPLAY] = "reset",
164a595
> #endif
190a622,630
> int fd0 = open("/dev/input/joystick0",O_RDONLY);
> int fd1 = open("/dev/input/joystick1",O_RDONLY);
>
> if( fd1 != -1 ){
> p2_connected = 1;
> }else{
> p2_connected = 0;
> }
>
205a646,654
> #if SDL_MAJOR_VERSION == 2
>
> if(fd1 != -1 && fd0 == -1) {
> snprintf(name, sizeof(name), IN_SDL_PREFIX "%s [%d]", SDL_JoystickName(joy), 1);
> } else {
> snprintf(name, sizeof(name), IN_SDL_PREFIX "%s", SDL_JoystickName(joy));
> }
>
> #else
206a656
> #endif
209a660,664
> if(fd0 != -1)
> close(fd0);
> if(fd1 != -1)
> close(fd1);
>
211a667
>
273a730,737
> #ifdef CONFIG_DEBUG
> printf("%s:%d SDL_JOYAXISMOTION which=%d axis=%d value=%d\n",
> __func__,
> __LINE__,
> event->jaxis.which,
> event->jaxis.axis,
> event->jaxis.value);
> #endif
286a751,753
> #if SDL_MAJOR_VERSION == 2
> kc = event->jaxis.axis ? MY_SDLK_UP : MY_SDLK_LEFT;
> #else
287a755
> #endif
295a764,766
> #if SDL_MAJOR_VERSION == 2
> kc = event->jaxis.axis ? MY_SDLK_DOWN : MY_SDLK_RIGHT;
> #else
296a768
> #endif
304a777,783
> #ifdef CONFIG_DEBUG
> printf("%s:%d SDL_JOYBUTTONxxxx which=%d button=%d\n",
> __func__,
> __LINE__,
> event->jbutton.which,
> event->jbutton.button);
> #endif
306a786,788
> #if SDL_MAJOR_VERSION == 2
> kc = (int)event->jbutton.button + MY_SDLK_WORLD_0;
> #else
307a790
> #endif
311a795,801
> #ifdef CONFIG_DEBUG
> printf("%s:%d event=0x%x(%d)\n",
> __func__,
> __LINE__,
> event->type,
> event->type);
> #endif
324a815,1007
> #if SDL_MAJOR_VERSION == 2
> static void ControlJoysticEscape(struct in_sdl_state *arg_pState,
> SDL_Event *arg_pEvent)
> {
> SDL_Event myEvent;
> static bool bIsCurrentSelectButtonDown = false;
> static bool bIsCurrentStartButtonDown = false;
>
> bool bIsFormerSelectButtonDown = bIsCurrentSelectButtonDown;
> bool bIsFormerStartButtonDown = bIsCurrentStartButtonDown;
> char *env_menu, *endptr;
> #ifdef CONFIG_ENABLE_MENU
> int env = 2;
> #else
> int env = 0;
> #endif
> #ifdef CONFIG_DEBUG
> printf("%s:%d keysym.scancode=%d keysym.sym=%d keysym.mod=%d\n",
> __func__,
> __LINE__,
> myEvent.key.keysym.scancode,
> myEvent.key.keysym.sym,
> myEvent.key.keysym.mod);
> printf("ControlJoysticEscape SDLK_WORLD %d",(arg_pEvent->jbutton.button + MY_SDLK_WORLD_0));
>
> #endif
>
> if (arg_pState->joy) {
> env_menu = getenv("PCSX_ESC_KEY");
> if(env_menu != NULL) {
> env = strtol(env_menu, &endptr, 10);
> if(strlen(endptr) > 0 || env > 2) {
> #ifdef CONFIG_ENABLE_MENU
> env = 2;
> #else
> env = 0;
> #endif
> }
> }
>
> switch(env) {
> case 0:
> break;
> case 1:
> if((arg_pEvent->jbutton.button + MY_SDLK_WORLD_0) == MY_SDLK_WORLD_8) {
> // "select" key event
> switch (arg_pEvent->type) {
> case SDL_JOYBUTTONDOWN:
> bIsCurrentSelectButtonDown = true;
> break;
> case SDL_JOYBUTTONUP:
> bIsCurrentSelectButtonDown = false;
> break;
> }
>
> } else if(((arg_pEvent->jbutton.button + MY_SDLK_WORLD_0) == MY_SDLK_WORLD_9)) {
> // "start" key event
> switch (arg_pEvent->type) {
> case SDL_JOYBUTTONDOWN:
> bIsCurrentStartButtonDown = true;
> break;
> case SDL_JOYBUTTONUP:
> bIsCurrentStartButtonDown = false;
> break;
> }
> }
>
> if(!((bIsFormerSelectButtonDown == true) && (bIsFormerStartButtonDown == true))
> &&
> ((bIsCurrentSelectButtonDown == true) && (bIsCurrentStartButtonDown == true))) {
>
> switch((arg_pEvent->jbutton.button + MY_SDLK_WORLD_0)) {
> case MY_SDLK_WORLD_9:
> #ifdef CONFIG_DEBUG
> printf("ControlJoysticEscape SDL_SCANCODE_ESCAPE - SDL_KEYDOWN");
> #endif
> myEvent.key.keysym.scancode = SDL_SCANCODE_ESCAPE;
> myEvent.key.keysym.sym = SDLK_ESCAPE;
> break;
> }
>
> // make ESC-key/Open-key/Reset-key down event
> myEvent.type = myEvent.key.type = SDL_KEYDOWN;
> myEvent.key.timestamp = arg_pEvent->key.timestamp;
> myEvent.key.windowID = 1;
> myEvent.key.state = 1;
> myEvent.key.repeat = 0;
> myEvent.key.keysym.mod = 0;
>
> SDL_PushEvent(&myEvent);
>
> } else if(((bIsFormerSelectButtonDown == true) && (bIsFormerStartButtonDown == true))
> &&
> !((bIsCurrentSelectButtonDown == true) && (bIsCurrentStartButtonDown == true))) {
>
> // make ESC-key up event
> switch((arg_pEvent->jbutton.button + MY_SDLK_WORLD_0)) {
> case MY_SDLK_WORLD_9:
> #ifdef CONFIG_DEBUG
> printf("ControlJoysticEscape SDL_SCANCODE_ESCAPE - SDL_KEYUP");
> #endif
> myEvent.key.keysym.scancode = SDL_SCANCODE_ESCAPE;
> myEvent.key.keysym.sym = SDLK_ESCAPE;
> break;
> case MY_SDLK_WORLD_0:
> #ifdef CONFIG_DEBUG
> printf("ControlJoysticEscape SDL_SCANCODE_F9 - SDL_KEYUP");
> #endif
> myEvent.key.keysym.scancode = SDL_SCANCODE_F9;
> myEvent.key.keysym.sym = SDLK_F9;
> break;
> case MY_SDLK_WORLD_1:
> #ifdef CONFIG_DEBUG
> printf("ControlJoysticEscape SDL_SCANCODE_F10 - SDL_KEYUP");
> #endif
> myEvent.key.keysym.scancode = SDL_SCANCODE_F10;
> myEvent.key.keysym.sym = SDLK_F10;
> break;
> }
>
> // make ESC-key/Open-key/Reset-key up event
> myEvent.type = myEvent.key.type = SDL_KEYUP;
> myEvent.key.timestamp = arg_pEvent->key.timestamp;
> myEvent.key.windowID = 1;
> myEvent.key.state = 0;
> myEvent.key.repeat = 0;
> myEvent.key.keysym.mod = 0;
>
> SDL_PushEvent(&myEvent);
> }
> break;
> case 2:
> if((arg_pEvent->jbutton.button + MY_SDLK_WORLD_0) == MY_SDLK_WORLD_8) {
> // "select" key event
> switch (arg_pEvent->type) {
> case SDL_JOYBUTTONDOWN:
> bIsCurrentSelectButtonDown = true;
> break;
> case SDL_JOYBUTTONUP:
> bIsCurrentSelectButtonDown = false;
> break;
> }
>
> } else if(((arg_pEvent->jbutton.button + MY_SDLK_WORLD_0) == MY_SDLK_WORLD_0)) {
> // "tryangle" key event
> switch (arg_pEvent->type) {
> case SDL_JOYBUTTONDOWN:
> bIsCurrentStartButtonDown = true;
> break;
> case SDL_JOYBUTTONUP:
> bIsCurrentStartButtonDown = false;
> break;
> }
> }
>
> if(!((bIsFormerSelectButtonDown == true) && (bIsFormerStartButtonDown == true))
> &&
> ((bIsCurrentSelectButtonDown == true) && (bIsCurrentStartButtonDown == true))) {
> myEvent.key.keysym.scancode = SDL_SCANCODE_ESCAPE;
> myEvent.key.keysym.sym = SDLK_ESCAPE;
> myEvent.type = myEvent.key.type = SDL_KEYDOWN;
> myEvent.key.timestamp = arg_pEvent->key.timestamp;
> myEvent.key.windowID = 1;
> myEvent.key.state = 1;
> myEvent.key.repeat = 0;
> myEvent.key.keysym.mod = 0;
>
> SDL_PushEvent(&myEvent);
>
> } else if(((bIsFormerSelectButtonDown == true) && (bIsFormerStartButtonDown == true))
> &&
> !((bIsCurrentSelectButtonDown == true) && (bIsCurrentStartButtonDown == true))) {
> myEvent.key.keysym.scancode = SDL_SCANCODE_ESCAPE;
> myEvent.key.keysym.sym = SDLK_ESCAPE;
>
> // make ESC-key/Open-key/Reset-key up event
> myEvent.type = myEvent.key.type = SDL_KEYUP;
> myEvent.key.timestamp = arg_pEvent->key.timestamp;
> myEvent.key.windowID = 1;
> myEvent.key.state = 0;
> myEvent.key.repeat = 0;
> myEvent.key.keysym.mod = 0;
>
> SDL_PushEvent(&myEvent);
> }
> default:
> break;
> }
> }
> }
>
> #endif
> #if SDL_MAJOR_VERSION == 1
326a1010
> #endif
330a1015,1018
> #ifdef CONFIG_DEBUG
> static int cnt=0;
> #endif
> #if SDL_MAJOR_VERSION == 1
331a1020,1060
> #else
> static int checkjoy0=0;
> int i=0, eventcnt=0;
> Uint32 minType;
> Uint32 maxType;
> eventcnt = SDL_PeepEvents(events,
> sizeof(events) / sizeof(events[0]),
> SDL_GETEVENT,
> SDL_JOYDEVICEADDED,
> SDL_JOYDEVICEREMOVED);
> if(eventcnt) {
> #ifdef CONFIG_DEBUG
> printf("eventcnt : %d\n", eventcnt);
> printf("events->type : 0x%x\n", events->type);
> printf("jdevice.which : %d\n", events->jdevice.which);
> #endif
> int check = 0;
> for(i=0; i < eventcnt; i++) {
> check = bIsValidHotPlugEvent(&events[i]);
> if(check) {
> in_probe();
> }
> }
> SDL_PumpEvents();
> SDL_FlushEvents(SDL_FIRSTEVENT, SDL_LASTEVENT);
> fflush(stdout);
> if (check) {
> // SDL_JOYDEVICEADDED or SDL_JOYDEVICEREMOVED イベントあり
> // デバイス情報領域が再確保
> return -1;
> } else {
> for (i = 0; i < SDLK_LAST / KEYBITS_WORD_BITS + 1; i++) {
> if(state == NULL)
> break;
> state->keystate[i] = 0;
> }
> return 0;
> }
> }
>
> #endif
333c1062
< int i, ret, retval = 0;
---
> int ret, retval = 0;
340a1070,1087
> #if SDL_MAJOR_VERSION == 2
> minType = SDL_KEYDOWN;
> maxType = SDL_KEYUP;
> if(state->joy) {
> minType = SDL_JOYAXISMOTION;
> maxType = SDL_JOYDEVICEREMOVED;
> }
> num_events = SDL_PeepEvents(NULL,
> 0,
> SDL_PEEKEVENT,
> minType,
> maxType);
> #ifdef CONFIG_DEBUG
> if(num_events) {
> printf("%s:%d %d joy=%p num_events=%d\n",__func__,__LINE__,++cnt,state->joy,num_events);
> }
> #endif
> #else
341a1089
> #endif
343a1092,1098
> #if SDL_MAJOR_VERSION == 2
> count = SDL_PeepEvents(events,
> maxcount,
> SDL_GETEVENT,
> minType,
> maxType);
> #else
344a1100
> #endif
348a1105,1165
> #if SDL_MAJOR_VERSION == 2
> ControlJoysticEscape(state, event);
>
> if (state->joy)
> ret = handle_joy_event(state,
> event, one_kc, one_down);
> else {
> #ifdef CONFIG_DEBUG
> printf("%s:%d type=0x%x key.type=0x%x timestamp=%d windowID=%d state=%d repeat=%d keysym.scancode=%d keysym.sym=%d keysym.mod=%d\n",
> __func__,
> __LINE__,
> event->type,
> event->key.type,
> event->key.timestamp,
> event->key.windowID,
> event->key.state,
> event->key.repeat,
> event->key.keysym.scancode,
> event->key.keysym.sym,
> event->key.keysym.mod);
> #endif
> event->key.keysym.sym = func_SDLK_TO_MY_SDLK(event->key.keysym.sym);
> ret = handle_event(state,
> event, one_kc, one_down);
> }
> #ifdef CONFIG_DEBUG
> if(one_kc) {
> printf("%s:%d i=%d type(SDL_KEYDOWN or SDL_KEYUP)=0x%x timestamp=%d windowID=%d state(SDL_PRESSED or SDL_RELEASED)=%d repeat=%d one_key=0x%x(%d) scancode=0x%x(%d) sym=0x%x(%d) mod=%d\n" ,
> __func__,
> __LINE__,
> i,
> (event->key).type, /* Uint32 */
> (event->key).timestamp, /* Uint32 */
> (event->key).windowID, /* Uint32 */
> (event->key).state, /* Uint8 */
> (event->key).repeat, /* Uint8 */
> *one_kc,
> *one_kc,
> (event->key).keysym.scancode, /* enum */
> (event->key).keysym.scancode, /* enum */
> (event->key).keysym.sym, /* int32 */
> (event->key).keysym.sym, /* int32 */
> (event->key).keysym.mod); /* Uint16 */
> } else {
> printf("%s:%d i=%d type(SDL_KEYDOWN or SDL_KEYUP)=0x%x timestamp=%d windowID=%d state(SDL_PRESSED or SDL_RELEASED)=%d repeat=%d scancode=0x%x(%d) sym=0x%x(%d) mod=%d\n" ,
> __func__,
> __LINE__,
> i,
> (event->key).type, /* Uint32 */
> (event->key).timestamp, /* Uint32 */
> (event->key).windowID, /* Uint32 */
> (event->key).state, /* Uint8 */
> (event->key).repeat, /* Uint8 */
> (event->key).keysym.scancode, /* enum */
> (event->key).keysym.scancode, /* enum */
> (event->key).keysym.sym, /* int32 */
> (event->key).keysym.sym, /* int32 */
> (event->key).keysym.mod); /* Uint16 */
> }
> #endif // #ifdef CONFIG_DEBUG
> #else // #if SDL_MAJOR_VERSION == 2
354a1172
> #endif // #if SDL_MAJOR_VERSION == 2
389c1207,1208
< collect_events(state, NULL, NULL);
---
> if (collect_events(state, NULL, NULL) < 0)
> return 0;
diff --new-file -w -r pcsx_rearmed/frontend/libpicofe/keysym.h pcsx_rearmed_custom/frontend/libpicofe/keysym.h
0a1,286
> #ifndef _keysym_h
> #define _keysym_h
>
> #include <SDL.h>
> #if SDL_MAJOR_VERSION == 2
> typedef enum {
> MY_SDLK_UNKNOWN = 0,
>
> MY_SDLK_RETURN,
> MY_SDLK_ESCAPE,
> MY_SDLK_BACKSPACE,
> MY_SDLK_TAB,
> MY_SDLK_SPACE,
> MY_SDLK_EXCLAIM,
> MY_SDLK_QUOTEDBL,
> MY_SDLK_HASH,
> MY_SDLK_PERCENT,
> MY_SDLK_DOLLAR,
> MY_SDLK_AMPERSAND,
> MY_SDLK_QUOTE,
> MY_SDLK_LEFTPAREN,
> MY_SDLK_RIGHTPAREN,
> MY_SDLK_ASTERISK,
> MY_SDLK_PLUS,
> MY_SDLK_COMMA,
> MY_SDLK_MINUS,
> MY_SDLK_PERIOD,
> MY_SDLK_SLASH,
> MY_SDLK_0,
> MY_SDLK_1,
> MY_SDLK_2,
> MY_SDLK_3,
> MY_SDLK_4,
> MY_SDLK_5,
> MY_SDLK_6,
> MY_SDLK_7,
> MY_SDLK_8,
> MY_SDLK_9,
> MY_SDLK_COLON,
> MY_SDLK_SEMICOLON,
> MY_SDLK_LESS,
> MY_SDLK_EQUALS,
> MY_SDLK_GREATER,
> MY_SDLK_QUESTION,
> MY_SDLK_AT,
> /*
> Skip uppercase letters
> */
> MY_SDLK_LEFTBRACKET,
> MY_SDLK_BACKSLASH,
> MY_SDLK_RIGHTBRACKET,
> MY_SDLK_CARET,
> MY_SDLK_UNDERSCORE,
> MY_SDLK_BACKQUOTE,
> MY_SDLK_a,
> MY_SDLK_b,
> MY_SDLK_c,
> MY_SDLK_d,
> MY_SDLK_e,
> MY_SDLK_f,
> MY_SDLK_g,
> MY_SDLK_h,
> MY_SDLK_i,
> MY_SDLK_j,
> MY_SDLK_k,
> MY_SDLK_l,
> MY_SDLK_m,
> MY_SDLK_n,
> MY_SDLK_o,
> MY_SDLK_p,
> MY_SDLK_q,
> MY_SDLK_r,
> MY_SDLK_s,
> MY_SDLK_t,
> MY_SDLK_u,
> MY_SDLK_v,
> MY_SDLK_w,
> MY_SDLK_x,
> MY_SDLK_y,
> MY_SDLK_z,
>
> MY_SDLK_CAPSLOCK,
>
> MY_SDLK_F1,
> MY_SDLK_F2,
> MY_SDLK_F3,
> MY_SDLK_F4,
> MY_SDLK_F5,
> MY_SDLK_F6,
> MY_SDLK_F7,
> MY_SDLK_F8,
> MY_SDLK_F9,
> MY_SDLK_F10,
> MY_SDLK_F11,
> MY_SDLK_F12,
>
> MY_SDLK_PRINTSCREEN,
> MY_SDLK_SCROLLLOCK,
> MY_SDLK_PAUSE,
> MY_SDLK_INSERT,
> MY_SDLK_HOME,
> MY_SDLK_PAGEUP,
> MY_SDLK_DELETE,
> MY_SDLK_END,
> MY_SDLK_PAGEDOWN,
> MY_SDLK_RIGHT,
> MY_SDLK_LEFT,
> MY_SDLK_DOWN,
> MY_SDLK_UP,
>
> MY_SDLK_NUMLOCKCLEAR,
> MY_SDLK_KP_DIVIDE,
> MY_SDLK_KP_MULTIPLY,
> MY_SDLK_KP_MINUS,
> MY_SDLK_KP_PLUS,
> MY_SDLK_KP_ENTER,
> MY_SDLK_KP_1,
> MY_SDLK_KP_2,
> MY_SDLK_KP_3,
> MY_SDLK_KP_4,
> MY_SDLK_KP_5,
> MY_SDLK_KP_6,
> MY_SDLK_KP_7,
> MY_SDLK_KP_8,
> MY_SDLK_KP_9,
> MY_SDLK_KP_0,
> MY_SDLK_KP_PERIOD,
>
> MY_SDLK_APPLICATION,
> MY_SDLK_POWER,
> MY_SDLK_KP_EQUALS,
> MY_SDLK_F13,
> MY_SDLK_F14,
> MY_SDLK_F15,
> MY_SDLK_F16,
> MY_SDLK_F17,
> MY_SDLK_F18,
> MY_SDLK_F19,
> MY_SDLK_F20,
> MY_SDLK_F21,
> MY_SDLK_F22,
> MY_SDLK_F23,
> MY_SDLK_F24,
> MY_SDLK_EXECUTE,
> MY_SDLK_HELP,
> MY_SDLK_MENU,
> MY_SDLK_SELECT,
> MY_SDLK_STOP,
> MY_SDLK_AGAIN,
> MY_SDLK_UNDO,
> MY_SDLK_CUT,
> MY_SDLK_COPY,
> MY_SDLK_PASTE,
> MY_SDLK_FIND,
> MY_SDLK_MUTE,
> MY_SDLK_VOLUMEUP,
> MY_SDLK_VOLUMEDOWN,
> MY_SDLK_KP_COMMA,
> MY_SDLK_KP_EQUALSAS400,
>
> MY_SDLK_ALTERASE,
> MY_SDLK_SYSREQ,
> MY_SDLK_CANCEL,
> MY_SDLK_CLEAR,
> MY_SDLK_PRIOR,
> MY_SDLK_RETURN2,
> MY_SDLK_SEPARATOR,
> MY_SDLK_OUT,
> MY_SDLK_OPER,
> MY_SDLK_CLEARAGAIN,
> MY_SDLK_CRSEL,
> MY_SDLK_EXSEL,
>
> MY_SDLK_KP_00,
> MY_SDLK_KP_000,
> MY_SDLK_THOUSANDSSEPARATOR,
> MY_SDLK_DECIMALSEPARATOR,
> MY_SDLK_CURRENCYUNIT,
> MY_SDLK_CURRENCYSUBUNIT,
> MY_SDLK_KP_LEFTPAREN,
> MY_SDLK_KP_RIGHTPAREN,
> MY_SDLK_KP_LEFTBRACE,
> MY_SDLK_KP_RIGHTBRACE,
> MY_SDLK_KP_TAB,
> MY_SDLK_KP_BACKSPACE,
> MY_SDLK_KP_A,
> MY_SDLK_KP_B,
> MY_SDLK_KP_C,
> MY_SDLK_KP_D,
> MY_SDLK_KP_E,
> MY_SDLK_KP_F,
> MY_SDLK_KP_XOR,
> MY_SDLK_KP_POWER,
> MY_SDLK_KP_PERCENT,
> MY_SDLK_KP_LESS,
> MY_SDLK_KP_GREATER,
> MY_SDLK_KP_AMPERSAND,
> MY_SDLK_KP_DBLAMPERSAND,
> MY_SDLK_KP_VERTICALBAR,
> MY_SDLK_KP_DBLVERTICALBAR,
> MY_SDLK_KP_COLON,
> MY_SDLK_KP_HASH,
> MY_SDLK_KP_SPACE,
> MY_SDLK_KP_AT,
> MY_SDLK_KP_EXCLAM,
> MY_SDLK_KP_MEMSTORE,
> MY_SDLK_KP_MEMRECALL,
> MY_SDLK_KP_MEMCLEAR,
> MY_SDLK_KP_MEMADD,
> MY_SDLK_KP_MEMSUBTRACT,
> MY_SDLK_KP_MEMMULTIPLY,
> MY_SDLK_KP_MEMDIVIDE,
> MY_SDLK_KP_PLUSMINUS,
> MY_SDLK_KP_CLEAR,
> MY_SDLK_KP_CLEARENTRY,
> MY_SDLK_KP_BINARY,
> MY_SDLK_KP_OCTAL,
> MY_SDLK_KP_DECIMAL,
> MY_SDLK_KP_HEXADECIMAL,
>
> MY_SDLK_LCTRL,
> MY_SDLK_LSHIFT,
> MY_SDLK_LALT,
> MY_SDLK_LGUI,
> MY_SDLK_RCTRL,
> MY_SDLK_RSHIFT,
> MY_SDLK_RALT,
> MY_SDLK_RGUI,
>
> MY_SDLK_MODE,
>
> MY_SDLK_AUDIONEXT,
> MY_SDLK_AUDIOPREV,
> MY_SDLK_AUDIOSTOP,
> MY_SDLK_AUDIOPLAY,
> MY_SDLK_AUDIOMUTE,
> MY_SDLK_MEDIASELECT,
> MY_SDLK_WWW,
> MY_SDLK_MAIL,
> MY_SDLK_CALCULATOR,
> MY_SDLK_COMPUTER,
> MY_SDLK_AC_SEARCH,
> MY_SDLK_AC_HOME,
> MY_SDLK_AC_BACK,
> MY_SDLK_AC_FORWARD,
> MY_SDLK_AC_STOP,
> MY_SDLK_AC_REFRESH,
> MY_SDLK_AC_BOOKMARKS,
>
> MY_SDLK_BRIGHTNESSDOWN,
> MY_SDLK_BRIGHTNESSUP,
> MY_SDLK_DISPLAYSWITCH,
> MY_SDLK_KBDILLUMTOGGLE,
> MY_SDLK_KBDILLUMDOWN,
> MY_SDLK_KBDILLUMUP,
> MY_SDLK_EJECT,
> MY_SDLK_SLEEP,
> MY_SDLK_APP1,
> MY_SDLK_APP2,
>
> MY_SDLK_AUDIOREWIND,
> MY_SDLK_AUDIOFASTFORWARD,
>
> MY_SDLK_WORLD_0,
> MY_SDLK_WORLD_1,
> MY_SDLK_WORLD_2,
> MY_SDLK_WORLD_3,
> MY_SDLK_WORLD_4,
> MY_SDLK_WORLD_5,
> MY_SDLK_WORLD_6,
> MY_SDLK_WORLD_7,
> MY_SDLK_WORLD_8,
> MY_SDLK_WORLD_9,
>
> MY_SDLK_LAST,
> SDLK_LAST = MY_SDLK_LAST
> } MySDLKey;
>
> typedef struct {
> int m_SDLK;
> int m_MySDLK;
> } SDLK_to_MY_SDLK;
>
> #endif // #if SDL_MAJOR_VERSION == 2
>
> #endif // #ifndef _keysym_h
diff --new-file -w -r pcsx_rearmed/frontend/libpicofe/menu.c pcsx_rearmed_custom/frontend/libpicofe/menu.c
26a27,28
> #define DISK_IMG_DIR "/usr/sony/share/data/images/Disk/"
>
358,359c360
< unsigned int p = *sorc++;
< *dest++ = (p&0xf79ef79e)>>1;
---
> *dest++ = *sorc++;
437a439,457
> void show_text_image(const char *lang_image_path, const char *ok_image_path)
> {
> char buff[128];
> int msg_x = 115, msg_y = 110;
> int btn_x = 280, btn_y = 353;
> int ok_x = 258, ok_y = 380;
>
> menu_draw_begin(1, 1);
>
> readpng(g_menuscreen_ptr + (msg_x + msg_y * g_menuscreen_w) * 2, lang_image_path, READPNG_BG, g_menuscreen_w, g_menuscreen_h);
>
> sprintf(buff, "%s%s", DISK_IMG_DIR, "Ball_Btn_SD.png");
> readpng(g_menuscreen_ptr + (btn_x + btn_y * g_menuscreen_w) * 2, buff, READPNG_BG, g_menuscreen_w, g_menuscreen_h);
>
> readpng(g_menuscreen_ptr + (ok_x + ok_y * g_menuscreen_w) * 2, ok_image_path, READPNG_BG, g_menuscreen_w, g_menuscreen_h);
>
> menu_draw_end();
> }
>
859c879
< int n, int sel, int show_help)
---
> int n, int sel, int show_help, int curr_sel, int sel_min)
874,875c894,895
< darken_ptr = (short *)g_menuscreen_ptr + g_menuscreen_w * max_cnt/2 * me_sfont_h;
< menu_darken_bg(darken_ptr, darken_ptr, g_menuscreen_w * me_sfont_h * 8 / 10, 0);
---
> // darken_ptr = (short *)g_menuscreen_ptr + g_menuscreen_w * max_cnt/2 * me_sfont_h;
> // menu_darken_bg(darken_ptr, darken_ptr, g_menuscreen_w * me_sfont_h * 8 / 10, 0);
879c899
< smalltext_out16(14, (start - 2) * me_sfont_h, curdir, 0xffff);
---
> // smalltext_out16(14, (start - 2) * me_sfont_h, curdir, 0xffff);
885,886c905,906
< smalltext_out16(x, pos * me_sfont_h, "/", 0xfff6);
< smalltext_out16(x + me_sfont_w, pos * me_sfont_h, namelist[i+1]->d_name, 0xfff6);
---
> // smalltext_out16(x, pos * me_sfont_h, "/", 0xfff6);
> // smalltext_out16(x + me_sfont_w, pos * me_sfont_h, namelist[i+1]->d_name, 0xfff6);
889c909
< smalltext_out16(x, pos * me_sfont_h, namelist[i+1]->d_name, color);
---
> // smalltext_out16(x, pos * me_sfont_h, namelist[i+1]->d_name, color);
892c912
< smalltext_out16(5, max_cnt/2 * me_sfont_h, ">", 0xffff);
---
> // smalltext_out16(5, max_cnt/2 * me_sfont_h, ">", 0xffff);
895,898c915,918
< darken_ptr = (short *)g_menuscreen_ptr
< + g_menuscreen_w * (g_menuscreen_h - me_sfont_h * 5 / 2);
< menu_darken_bg(darken_ptr, darken_ptr,
< g_menuscreen_w * (me_sfont_h * 5 / 2), 1);
---
> // darken_ptr = (short *)g_menuscreen_ptr
> // + g_menuscreen_w * (g_menuscreen_h - me_sfont_h * 5 / 2);
> // menu_darken_bg(darken_ptr, darken_ptr,
> // g_menuscreen_w * (me_sfont_h * 5 / 2), 1);
902c922
< smalltext_out16(x, g_menuscreen_h - me_sfont_h * 3 - 2, buff, 0xe78c);
---
> // smalltext_out16(x, g_menuscreen_h - me_sfont_h * 3 - 2, buff, 0xe78c);
907c927
< smalltext_out16(x, g_menuscreen_h - me_sfont_h * 2 - 2, buff, 0xe78c);
---
> // smalltext_out16(x, g_menuscreen_h - me_sfont_h * 2 - 2, buff, 0xe78c);
912c932,991
< smalltext_out16(x, g_menuscreen_h - me_sfont_h * 1 - 2, buff, 0xe78c);
---
> // smalltext_out16(x, g_menuscreen_h - me_sfont_h * 1 - 2, buff, 0xe78c);
> }
> int disc_num = n - 1;
> int skin_dir;
>
> // show paths of current directory and focused file
> if (sel_min == 0 || disc_num > 4) {
> smalltext_out16(x, me_sfont_h, curdir, 0xffff);
> if (disc_num > 0) {
> smalltext_out16(x, me_sfont_h * 3, namelist[sel+1]->d_name, 0xffff);
> }
> }
> else if (disc_num > 0) {
> int disc_img_w = 98;
> int disc_img_interval = 12;
> int num_img_offset = 39;
> int disc_img_y = 213;
> int num_img_y = 301;
> int msg_img_x = 106;
> int msg_img_y = 152;
> int disc_img_start = g_menuscreen_w - disc_img_w - (disc_img_w+disc_img_interval) * (disc_num-1) + disc_img_y * g_menuscreen_w * 2;
> int num_img_start = disc_img_start + num_img_offset * 2 + (num_img_y-disc_img_y) * g_menuscreen_w * 2;
> char num_one[] = "Text_one.png";
> char num_two[] = "Text_two.png";
> char num_three[] = "Text_three.png";
> char num_four[] = "Text_four.png";
> char *num_image[4] = {num_one, num_two, num_three, num_four};
>
> // disc_img_start must be even
> if (disc_img_start % 2) {
> disc_img_start--;
> }
>
> // show message of disc change
> readpng(g_menuscreen_ptr + (msg_img_x + msg_img_y * g_menuscreen_w) * 2, changedisc_message, READPNG_BG, g_menuscreen_w , g_menuscreen_h);
>
> // show normal disc images
> snprintf(buff, sizeof(buff), "%s%s", DISK_IMG_DIR, "Nomal_Disk.png");
> for (i = 0; i < disc_num; i++) {
> readpng(g_menuscreen_ptr + disc_img_start + (disc_img_w+disc_img_interval) * 2 * i, buff, READPNG_BG, g_menuscreen_w , g_menuscreen_h);
> }
>
> // show current disc image
> snprintf(buff, sizeof(buff), "%s%s", DISK_IMG_DIR, "Corrent_Disk.png");
> readpng(g_menuscreen_ptr + disc_img_start + (disc_img_w+disc_img_interval) * 2 * (curr_sel-1), buff, READPNG_BG, g_menuscreen_w , g_menuscreen_h);
>
> // show numbers
> for (i = 0; i < disc_num; i++) {
> snprintf(buff, sizeof(buff), "%s%s", DISK_IMG_DIR, num_image[i]);
> readpng(g_menuscreen_ptr + num_img_start + (disc_img_w+disc_img_interval) * 2 * i, buff, READPNG_BG, g_menuscreen_w , g_menuscreen_h);
> }
>
> // show forcus
> if (sel > 0) {
> snprintf(buff, sizeof(buff), "%s%s", DISK_IMG_DIR, "Select_Disk.png");
> readpng(g_menuscreen_ptr + disc_img_start + (disc_img_w+disc_img_interval) * 2 * (sel-1), buff, READPNG_BG, g_menuscreen_w , g_menuscreen_h);
> }
> }
> else {
> smalltext_out16(x, me_sfont_h * 3, "..", 0xffff);
985c1064
< const char *basedir))
---
> const char *basedir), int sel_min)
1075c1154,1155
< sel = 0;
---
> // sel = 0;
> sel = sel_min;
1087,1089c1167
< draw_dirlist(curr_path, namelist, n, sel, show_help);
< while (in_menu_wait_any(NULL, 50) & (PBTN_MOK|PBTN_MBACK|PBTN_MENU))
< ;
---
> int curr_sel = sel;
1091c1169,1183
< for (;;)
---
> // focus next disc image
> if (sel_min) {
> if (++sel > n-2) {
> sel = sel_min;
> }
> }
>
> draw_dirlist(curr_path, namelist, n, sel, show_help, curr_sel, sel_min);
> while (in_menu_wait_any(NULL, 50) & (PBTN_MOK|PBTN_MBACK|PBTN_MENU)) {
> if (power_off_flg) {
> break;
> }
> }
>
> while (!power_off_flg)
1093,1101c1185,1190
< draw_dirlist(curr_path, namelist, n, sel, show_help);
< inp = in_menu_wait(PBTN_UP|PBTN_DOWN|PBTN_LEFT|PBTN_RIGHT
< | PBTN_L|PBTN_R|PBTN_MA2|PBTN_MA3|PBTN_MOK|PBTN_MBACK
< | PBTN_MENU|PBTN_CHAR, &cinp, 33);
< if (inp & PBTN_MA3) {
< g_menu_filter_off = !g_menu_filter_off;
< snprintf(sel_fname, sizeof(sel_fname), "%s",
< namelist[sel+1]->d_name);
< goto rescan;
---
> draw_dirlist(curr_path, namelist, n, sel, show_help, curr_sel, sel_min);
> inp = in_menu_wait(PBTN_LEFT|PBTN_RIGHT|PBTN_MOK|PBTN_MBACK, &cinp, 33);
> /* wait until ok, back is released */
> while (in_menu_wait_any(NULL, 50) & (PBTN_MOK|PBTN_MBACK)) {
> if (power_off_flg) {
> break;
1103,1108c1192,1194
< if (inp & PBTN_UP ) { sel--; if (sel < 0) sel = n-2; }
< if (inp & PBTN_DOWN) { sel++; if (sel > n-2) sel = 0; }
< if (inp & PBTN_LEFT) { sel-=10; if (sel < 0) sel = 0; }
< if (inp & PBTN_L) { sel-=24; if (sel < 0) sel = 0; }
< if (inp & PBTN_RIGHT) { sel+=10; if (sel > n-2) sel = n-2; }
< if (inp & PBTN_R) { sel+=24; if (sel > n-2) sel = n-2; }
---
> }
> if (inp == PBTN_LEFT) { sel--; if (sel < sel_min) sel = sel_min; }
> if (inp == PBTN_RIGHT) { sel++; if (sel > n-2) sel = n-2; }
1110c1196
< if ((inp & PBTN_MOK) || (inp & (PBTN_MENU|PBTN_MA2)) == (PBTN_MENU|PBTN_MA2))
---
> if (inp == PBTN_MOK)
1111a1198,1201
> if (sel == curr_sel && (isTitleName(PARASITE_EVE_DISC_1_JP) || isTitleName(PARASITE_EVE_DISC_2_JP)
> || isTitleName(PARASITE_EVE_DISC_1_US) || isTitleName(PARASITE_EVE_DISC_2_US))) {
> continue;
> }
1147c1237
< ret = menu_loop_romsel(newdir, newlen, filter_exts, extra_filter);
---
> ret = menu_loop_romsel(newdir, newlen, filter_exts, extra_filter, sel_min);
1152,1161c1242
< else if (inp & PBTN_MA2) {
< g_autostateld_opt = !g_autostateld_opt;
< show_help = 3;
< }
< else if (inp & PBTN_CHAR) {
< // must be last
< sel = dirent_seek_char(namelist, n, sel, cinp);
< }
<
< if (inp & PBTN_MBACK)
---
> if (inp == PBTN_MBACK)
diff --new-file -w -r pcsx_rearmed/frontend/libpicofe/menu.h pcsx_rearmed_custom/frontend/libpicofe/menu.h
125a126
> void show_text_image(const char *lang_image_path, const char *ok_image_path);
diff --new-file -w -r pcsx_rearmed/frontend/libpicofe/plat.h pcsx_rearmed_custom/frontend/libpicofe/plat.h
96c96
< void plat_video_menu_enter(int is_rom_loaded);
---
> void plat_video_menu_enter(int is_rom_loaded, int bpp);
diff --new-file -w -r pcsx_rearmed/frontend/libpicofe/plat_sdl.c pcsx_rearmed_custom/frontend/libpicofe/plat_sdl.c
23a24,25
>
>
24a27
> #if SDL_MAJOR_VERSION == 1
25a29
> #endif
29a34,39
> #if SDL_MAJOR_VERSION == 2
> static const char *vid_drv_name;
> SDL_Window *sdl2_window;
> SDL_Renderer *sdl2_renderer;
> SDL_Texture *sdl2_texture;
> #else
30a41
> #endif
36a48
> int gl_works = 0;
42a55,59
> if (w != prev_w || h != prev_h) {
> force = 1;
> }
>
> printf("plat_sdl_change_video_mode() start w=%d,h=%d,force=%d \n",w,h,force);
67c84
<
---
> #if SDL_MAJOR_VERSION == 1
71a89
> #endif
77a96
> #if SDL_MAJOR_VERSION == 1
78a98,101
> #else
> Uint32 flags = SDL_WINDOW_OPENGL;
> //Uint32 flags = SDL_RESIZABLE | SDL_SWSURFACE;
> #endif
81c104,105
<
---
> printf("plat_sdl_change_video_mode() plat_target.vout_fullscreen=%d fs_w=%d,fs_h=%d\n",plat_target.vout_fullscreen,fs_w,fs_h);
> #if SDL_MAJOR_VERSION == 1
87c111
<
---
> #endif
91a116,124
> #if SDL_MAJOR_VERSION == 2
> plat_sdl_screen = SDL_GetWindowSurface(sdl2_window);
> printf("002 plat_sdl_change_video_mode : SDL_GetWindowSurface() \n");
> printf(" win_w=%d, win_h=%d flags=%d \n",win_w,win_h,flags);
> if (plat_sdl_screen == NULL) {
> fprintf(stderr, "002 plat_sdl_change_video_mode : SDL_GetWindowSurface failed: %s\n", SDL_GetError());
> plat_target.vout_method = 0;
> }
> #else
92a126
>
94c128
< fprintf(stderr, "SDL_SetVideoMode failed: %s\n", SDL_GetError());
---
> fprintf(stderr, "002 plat_sdl_change_video_mode : SDL_SetVideoMode failed: %s\n", SDL_GetError());
96a131
> #endif
99a135
> #if SDL_MAJOR_VERSION == 1
110a147,149
> #else
> plat_target.vout_method = 0;
> #endif
112a152
> printf("plat_sdl_change_video_mode : gl_init()\n");
115c155,156
< fprintf(stderr, "warning: could not init GL.\n");
---
> printf(" \n");
> fprintf(stderr, "warning: could not plat_sdl_change_video_mode : gl_init.\n");
117a159,161
> else {
> printf(" gl_init() success!\n");
> }
121a166
> #if SDL_MAJOR_VERSION == 2
122a168,174
> plat_sdl_screen = SDL_GetWindowSurface(sdl2_window);
> printf("001 plat_sdl_change_video_mode : SDL_GetWindowSurface() \n");
> if (plat_sdl_screen == NULL) {
> fprintf(stderr, "001 SDL_GetWindowSurface failed: %s\n", SDL_GetError());
> return -1;
> }
> #else
125c177
< fprintf(stderr, "SDL_SetVideoMode failed: %s\n", SDL_GetError());
---
> fprintf(stderr, "001 plat_sdl_change_video_mode : SDL_SetVideoMode failed: %s\n", SDL_GetError());
127a180,182
> #endif
>
>
131c186
< if (plat_sdl_resize_cb != NULL)
---
> if (plat_sdl_resize_cb != NULL) {
132a188
> }
133a190
> printf("plat_sdl_change_video_mode() end\n");
136a194,198
>
>
>
>
>
141a204,205
> printf("frontend/libpicofe/plat.sdl.c : plat_sdl_event_handler() %d\n",event->type);
>
142a207
> #if SDL_MAJOR_VERSION == 1
156a222
> #if SDL_MAJOR_VERSION == 1
157a224
> #endif
169a237
> #endif
176a245,260
>
>
>
>
>
>
>
>
>
> #if SDL_MAJOR_VERSION == 2
> void gl_setup_wl_information(struct wl_display * idisplay,
> struct wl_surface *isurface,
> struct wl_shell_surface *ishell_surface);
>
> int plat_sdl_init(int isGame)
> #else
177a262
> #endif
178a264
> printf("+ /frontend/libpicofe/plat_sdl_init()\n");
179a266
> #if SDL_MAJOR_VERSION == 1
180a268
> #endif
183c271
< int gl_works = 0;
---
>
185a274,281
> #ifdef UI_INTEGRATION
> printf("SDL_Init() not used. for UI_INTEGRATION\n");
> #else
>
> #if SDL_MAJOR_VERSION == 2
> printf("plat_sdl_init() : SDL_Init(SDL_INIT_VIDEO), %d\n", SDL_INIT_VIDEO);
> ret = SDL_Init(SDL_INIT_VIDEO);
> #else
186a283
> #endif
188c285
< fprintf(stderr, "SDL_Init failed: %s\n", SDL_GetError());
---
> fprintf(stderr, "plat_sdl_init() : SDL_Init() failed: %s\n", SDL_GetError());
191a289,331
> #endif
>
>
> #if SDL_MAJOR_VERSION == 2
> /* */
>
> sdl2_window = SDL_CreateWindow("Title", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 640, 480, SDL_WINDOW_FULLSCREEN_DESKTOP);
>
>
>
> if (sdl2_window == NULL) {
> printf("- /frontend/libpicofe/plat_sdl_init() : SDL_CreateWindow() Error %s\n",SDL_GetError());
> return -1;
> }
> else {
> /* */
> // SDL_SetWindowSize(sdl2_window,640,480);
> // printf("SDL_SetWindowSize()\n");
>
> SDL_GetWindowSize(sdl2_window, &fs_w, &fs_h);
> printf("SDL_GetWindowSize w=%d,h=%d\n", fs_w, fs_h);
> }
> //sdl2_renderer = SDL_CreateRenderer(sdl2_window, -1, SDL_RENDERER_ACCELERATED);
> sdl2_renderer = SDL_CreateRenderer(sdl2_window, -1, SDL_RENDERER_SOFTWARE);
> if (sdl2_renderer == NULL) {
> printf("- /frontend/libpicofe/plat_sdl_init() SDL_CreateRenderer Error %s\n",SDL_GetError());
> return -1;
> }
> else {
> printf("plat_sdl_init() : SDL_CreateRenderer() Success.\n");
> }
> SDL_RenderSetLogicalSize(sdl2_renderer, 640, 480);
>
> /* */
> sdl2_texture = SDL_CreateTexture(sdl2_renderer,SDL_PIXELFORMAT_RGBA8888,SDL_TEXTUREACCESS_TARGET,fs_w, fs_h);
> if (sdl2_texture == NULL) {
> printf("SDL_CreateTexture() Error %s\n",SDL_GetError());
> return -1;
> }
> else {
> printf("plat_sdl_init() : SDL_CreateTexture Success.\n");
> }
> #else
198c338
<
---
> #endif
204a345,348
> #if SDL_MAJOR_VERSION == 2
> if (sdl2_window && h > WM_DECORATION_H)
> h -= WM_DECORATION_H;
> #else
206a351
> #endif
210a356
> /***************************************************/
212a359,372
> #if SDL_MAJOR_VERSION == 2
> plat_sdl_screen = SDL_GetWindowSurface(sdl2_window);
> printf("002 plat_sdl_init : SDL_GetWindowSurface() \n");
> printf(" plat_sdl_screen->w=%d,plat_sdl_screen->h=%d\n",plat_sdl_screen->w,plat_sdl_screen->h);
> if (plat_sdl_screen == NULL) {
> fprintf(stderr, "002 plat_sdl_init : SDL_GetWindowSurface() failed: %s\n", SDL_GetError());
> goto fail;
> }
> if (plat_sdl_screen->w < 320 || plat_sdl_screen->h < 240) {
> fprintf(stderr, "resolution %dx%d is too small, sorry.\n",
> plat_sdl_screen->w, plat_sdl_screen->h);
> goto fail;
> }
> #else
213a374
>
215c376
< fprintf(stderr, "SDL_SetVideoMode failed: %s\n", SDL_GetError());
---
> fprintf(stderr, "002 plat_sdl_init : SDL_SetVideoMode failed: %s\n", SDL_GetError());
223a385
> #endif
225,226c387,423
< g_menuscreen_w = window_w = plat_sdl_screen->w;
< g_menuscreen_h = window_h = plat_sdl_screen->h;
---
>
> #if SDL_MAJOR_VERSION == 2
>
> #if 1
> // SDL_SetWindowSize(sdl2_window,640,480);
> // printf("SDL_SetWindowSize()\n");
> SDL_GetWindowSize(sdl2_window,&plat_sdl_screen->w,&plat_sdl_screen->h);
> #endif
>
> printf(" plat_sdl_screen->w=%d,plat_sdl_screen->h=%d\n",plat_sdl_screen->w,plat_sdl_screen->h);
>
>
> SDL_GetWindowSize(sdl2_window,&window_w,&window_h);
> printf("SDL_GetWindowSize() window_w=%d,window_h=%d\n",window_w,window_h);
>
> //#ifdef SDL2_0_DEBUG
> // g_menuscreen_w = window_w = plat_sdl_screen->w * 2;
> // g_menuscreen_h = window_h = plat_sdl_screen->h;
> //#else
> //
> //#if 0
> // g_menuscreen_w = window_w = 640;
> // g_menuscreen_h = window_h = 480;
> //#else
> // g_menuscreen_w = window_w = plat_sdl_screen->w;
> // g_menuscreen_h = window_h = plat_sdl_screen->h;
> //#endif
> //
> //#endif
>
> #else
> // g_menuscreen_w = window_w = plat_sdl_screen->w;
> // g_menuscreen_h = window_h = plat_sdl_screen->h;
> g_menuscreen_w = 640;
> g_menuscreen_h = 480;
> #endif
>
228a426,433
> #if SDL_MAJOR_VERSION == 2
> plat_sdl_screen = SDL_GetWindowSurface(sdl2_window);
> printf("003 plat_sdl_init : SDL_GetWindowSurface() \n");
> if (plat_sdl_screen == NULL) {
> fprintf(stderr, "003 plat_sdl_init : SDL_GetWindowSurface() failed: %s\n", SDL_GetError());
> goto fail;
> }
> #else
230a436
>
232c438
< fprintf(stderr, "SDL_SetVideoMode failed: %s\n", SDL_GetError());
---
> fprintf(stderr, "003 SDL_SetVideoMode failed: %s\n", SDL_GetError());
234a441
> #endif
235a443,444
> #if SDL_MAJOR_VERSION == 1
> /****************************************************************************/
252a462
> #endif
254a465,468
> #if SDL_MAJOR_VERSION == 2
> vid_drv_name = SDL_GetCurrentVideoDriver();
> printf("plat_sdl_init : SDL_GetCurrentVideoDriver() vid_drv_name=%s\n",vid_drv_name);
> #else
255a470,471
> #endif
>
258a475,477
> #if SDL_MAJOR_VERSION == 2
> ret = SDL_GetWindowWMInfo(sdl2_window,&wminfo);
> #else
259a479
> #endif
265a486,487
>
> #if 1
266a489,495
> ret = SDL_GetWindowWMInfo(sdl2_window, &wminfo);
> if (ret > 0) {
> gl_setup_wl_information(wminfo.info.wl.display, wminfo.info.wl.surface, wminfo.info.wl.shell_surface);
>
> printf("wminfo: 0x%x, 0x%x, 0x%x\n",
> wminfo.info.wl.display, wminfo.info.wl.surface, wminfo.info.wl.shell_surface);
> }
268a498,505
> #endif
>
>
>
> #ifdef SDL2_0_DEBUG
> #if SDL_MAJOR_VERSION == 2
> if (isGame) {
> #endif
269a507
> printf("plat_sdl_init : gl_init() ret=%d\n",ret);
271a510
> printf("plat_sdl_init : gl_finish()\n");
273a513,526
> #if SDL_MAJOR_VERSION == 2
> }
> #endif
>
> #else
> ret = gl_init(display, window, &gl_quirks);
> printf("plat_sdl_init : gl_init() ret=%d\n",ret);
> if (ret == 0) {
> gl_works = 1;
> printf("plat_sdl_init : gl_finish()\n");
> gl_finish();
> }
> #endif
>
276a530,531
>
> printf("plat_sdl_init : overlay_works=%d\n",overlay_works);
280a536
> printf("plat_sdl_init : gl_works=%d\n",gl_works);
284a541,545
> int j;
> for(j=0;j<i;j++) {
> printf("plat_sdl_init : vout_list[%d]=%s\n",j,vout_list[j]);
> }
>
286a548,549
>
> printf("- /frontend/libpicofe/plat_sdl_init() end\n");
289a553,556
> #ifdef UI_INTEGRATION
> printf("SDL_Quit() not used. for UI_INTEGRATION\n");
> #else
> printf("SDL_Quit()\n");
290a558,559
> #endif
> printf("- /frontend/libpicofe/plat_sdl_init() fail\n");
293a563
>
295a566,567
> printf("+ /frontend/libpicofe/plat_sdl_finish()\n");
> #if SDL_MAJOR_VERSION == 1
299a572
> #endif
306c579,583
< if (strcmp(vid_drv_name, "x11") != 0)
---
> if (strcmp(vid_drv_name, "x11") != 0) {
> #if SDL_MAJOR_VERSION == 2
> SDL_GetWindowSurface(sdl2_window);
> printf("005 /frontend/libpicofe/SDL_GetWindowSurface() \n");
> #else
307a585,592
> printf("SDL_SetVideoMode\n");
> #endif
> }
>
> #ifdef UI_INTEGRATION
> printf("SDL_Quit() not used. for UI_INTEGRATION\n");
> #else
> printf("SDL_Quit()\n");
308a594,596
> #endif
>
> printf("- /frontend/libpicofe/plat_sdl_finish()\n");
312a601,602
> printf("plat_sdl_overlay_clear()\n");
> #if SDL_MAJOR_VERSION == 1
321a612
> #endif
diff --new-file -w -r pcsx_rearmed/frontend/libpicofe/plat_sdl.h pcsx_rearmed_custom/frontend/libpicofe/plat_sdl.h
2a3
>
3a5
> #if SDL_MAJOR_VERSION == 1
4a7,14
> #endif
>
> #if SDL_MAJOR_VERSION == 2
> extern SDL_Window *sdl2_window;
> extern SDL_Renderer *sdl2_renderer;
> extern SDL_Texture *sdl2_texture;
> #endif
>
8a19,21
> #if SDL_MAJOR_VERSION == 2
> int plat_sdl_init(int isGame);
> #else
9a23
> #endif
diff --new-file -w -r pcsx_rearmed/frontend/libpicofe/readpng.c pcsx_rearmed_custom/frontend/libpicofe/readpng.c
15a16
> #include <unistd.h>
56c57,58
< png_read_png(png_ptr, info_ptr, PNG_TRANSFORM_STRIP_16 | PNG_TRANSFORM_STRIP_ALPHA | PNG_TRANSFORM_PACKING, NULL);
---
> // png_read_png(png_ptr, info_ptr, PNG_TRANSFORM_STRIP_16 | PNG_TRANSFORM_STRIP_ALPHA | PNG_TRANSFORM_PACKING, NULL);
> png_read_png(png_ptr, info_ptr, PNG_TRANSFORM_STRIP_16 | PNG_TRANSFORM_PACKING, NULL);
89,90c91,93
<
< for (h = 0; h < height; h++)
---
> int w_rate = 1; // reduction rate of width
> int h_rate = 1; // reduction rate of height
> for (h = 0; h < height / h_rate; h++)
92,93c95,96
< unsigned char *src = row_ptr[h + y_ofs] + x_ofs * 3;
< int len = width;
---
> unsigned char *src = row_ptr[h * h_rate + y_ofs] + x_ofs * 4;
> int len = width / w_rate;
95a99
> if (src[3] & 0xff) {
101d104
< src += 3;
103c106,111
< dst += req_w - width;
---
> else {
> *dst++;
> }
> src += 4 * w_rate;
> }
> dst += req_w - width / w_rate;
269a278
> fsync(fileno(f));
diff --new-file -w -r pcsx_rearmed/frontend/main.c pcsx_rearmed_custom/frontend/main.c
13a14,16
> #include <pthread.h>
> #include <sys/inotify.h>
> #include <sys/stat.h>
39a43
> static int isOpenEnabled = 0;
44a49,53
> #define EVENT_SIZE (sizeof (struct inotify_event))
> #define BUF_LEN 4096
>
>
>
52a62,64
> int from_escape = 0;
> int power_off_flg = 0;
> int is_high_temperature = 0;
55a68,100
> int isUnknowCdrom;
> int holdResetEvent;
>
> int display_mode = DISPLAY_MODE_DEFAULT;
> int language = LANGUAGE_DEFAULT;
> int region = REGION_DEFAULT;
> int enter_mode = ENTER_DEFAULT;
>
> static int cpu_temp_limit = DEFAULT_TEMP_LIMIT;
>
> const char *lang_list[13] = {
> "German", // de_de
> "E_UK", // en_gb
> "E", // en_us
> "Spanish_LA", // es_419
> "Spanish", // es_es
> "French_CA", // fr_ca
> "French", // fr_fr
> "Italian", // it_it
> "Dutch", // nl_nl
> "Portuguese_BR", // pt_br
> "Portuguese", // pt_pt
> "Russian", // ru_ru
> "J" // ja_jp
> };
>
> char changedisc_message[128];
> char solodisc_message[128];
> char nottime_message[128];
> char ok_image[128];
>
> static pthread_t th_power_off_state = (pthread_t)0;
> static pthread_t cpu_temp_thread = (pthread_t)0;
70a116
> if (CdromLabel[0] != '\0' && !(g_opts & OPT_AUTOSAVE)) {
71a118,121
> }
> else {
> strncpy(trimlabel, CdromLabel_old, 32);
> }
78a129
> if (CdromId[0] != '\0' && !(g_opts & OPT_AUTOSAVE)) {
79a131,134
> }
> else {
> snprintf(buf, size, fmt, trimlabel, CdromId_old, i);
> }
108c163
< MAKE_PATH(Config.Mcd2, MEMCARD_DIR, "card2.mcd");
---
> MAKE_PATH(Config.Mcd2, MEMCARD_DIR, "none");
132a188,191
> pl_rearmed_cbs.gpu_peops.isToShinDen = 0;
> pl_rearmed_cbs.gpu_peops.isBiosLogoEnd = 0;
> pl_rearmed_cbs.gpu_peops.scenes = 0;
> pl_rearmed_cbs.gpu_peops.regions = 0;
174a234
> from_escape = 1;
258a319,322
> case SACTION_SYNC_STATE:
> emu_sync_state2();
> time_to_sync_state = 0;
> return;
271a336,397
> // add for open button
> case SACTION_CD_CHANGE:
> if (!isOpenEnabled) {
> isOpenEnabled = CheckOpenEnabled();
> if (!isOpenEnabled) {
> return;
> }
> }
> toggle_fast_forward(1);
> swap_cd();
> return;
> // add for power button
> case SACTION_POWER_OFF:
> power_off();
> return;
> // add for reset button
> case SACTION_RESET_EVENT:
> // save state of restart point
> // save state of restart point
> if (!(g_opts & OPT_AUTOSAVE) && isUnknownCdrom) {
> holdResetEvent = 1;
> }
> if ((memcardFlag==0)&&(memcardFlagOld==0)) {
> }
> else {
> memcardResetFlag = 1;
> return;
> }
> if (holdResetEvent) return;
> ret = emu_auto_save_state(0);
> snprintf(hud_msg, sizeof(hud_msg), ret == 0 ? "LOADED" : "FAIL!");
> if (ret) {
> char path[MAXPATHLEN];
> struct stat st;
>
> snprintf(path, sizeof(path), "." PCSX_DOT_DIR "filename.txt");
> ret = stat(path, &st);
> if (!ret) {
> remove(path);
> }
> }
> else {
> // screen picture
> char buf[MAXPATHLEN];
> void *scrbuf;
> int w, h, bpp;
>
> scrbuf = pl_prepare_screenshot(&w, &h, &bpp);
> get_gameid_filename(buf, sizeof(buf),
> "." SCSHOT_DIR "%.32s-%.9s.png", 0);
> ret = -1;
> if (scrbuf != 0 && bpp == 16)
> ret = writepng(buf, scrbuf, w, h);
> if (ret == 0)
> snprintf(hud_msg, sizeof(hud_msg), "SCREENSHOT TAKEN");
>
> // save file
> make_file_name();
> }
> // emulator exit
> stop = 1;
> g_emu_want_quit = 1;
397c523
< snprintf(hud_msg, sizeof(hud_msg), BOOT_MSG);
---
> //snprintf(hud_msg, sizeof(hud_msg), BOOT_MSG);
480c606,607
< create_profile_dir("/screenshots/");
---
> // create_profile_dir("/screenshots/");
> create_profile_dir(SCSHOT_DIR);
489c616
< for (i = 1; i <= 9; i++) {
---
> for (i = 1; i <= 2; i++) {
501a629,648
> static int check_prepare_suspend(void)
> {
> char path[256];
> int ret = -1;
> FILE *f;
> snprintf(path, sizeof(path), POWER_DIR POWER_OFF_FILE);
> f = fopen(path, "rb");
> if (f == NULL) {
> ret = 0;
> }
> else {
> ret = -1;
> fclose(f);
> }
> return ret;
> }
>
> #ifdef UI_INTEGRATION
> int main_ui(int argc, char *argv[]);
>
503a651,663
> printf("+ frontend/main()\n");
> main_ui(argc,argv);
> printf("- frontend/main()\n");
> }
> int main_ui(int argc, char *argv[])
> {
> printf("+ frontend/main_ui()\n");
> #else
> int main(int argc, char *argv[])
> {
> //printf("+ frontend/main()\n");
> #endif
>
510a671
> int isGame = 0;
523a685,686
> printf("argv[i]=%s\n",argv[i]);
> printf("argv[i+1]=%s\n",argv[i+1]);
543a707,739
> else if (!strcmp(argv[i], "-display")) {
> if (i+1 >= argc) {
> break;
> }
> display_mode = atoi(argv[++i]);
> if (DISPLAY_MODE_MIN > display_mode || DISPLAY_MODE_MAX < display_mode) {
> display_mode = DISPLAY_MODE_DEFAULT;
> }
> }
> else if (!strcmp(argv[i], "-lang")) {
> if (i+1 >= argc) {
> break;
> }
> language = atoi(argv[++i]);
> if (LANGUAGE_MIN > language || LANGUAGE_MAX < language) {
> language = LANGUAGE_DEFAULT;
> }
> }
> else if (!strcmp(argv[i], "-region")) {
> if (i+1 >= argc) {
> break;
> }
> region = atoi(argv[++i]);
> if (REGION_MIN > region || REGION_MAX < region) {
> region = REGION_DEFAULT;
> }
> }
> else if (!strcmp(argv[i], "-enter")) {
> if (i+1 >= argc) {
> break;
> }
> enter_mode = atoi(argv[++i]);
> }
557a754,758
> }
> else if (!strcmp(argv[i], "-v") ||
> !strcmp(argv[i], "--version")) {
> printf(REV "\n");
> return 0;
570a772,775
> sprintf(changedisc_message, "%s%s%s%s", LANG_IMG_DIR, "msg_current_inserted_disc_info_", lang_list[language-1], ".png");
> sprintf(solodisc_message, "%s%s%s%s", LANG_IMG_DIR, "msg_cant_change_discs_this_game_", lang_list[language-1], ".png");
> sprintf(nottime_message, "%s%s%s%s", LANG_IMG_DIR, "msg_cant_change_discs_now_", lang_list[language-1], ".png");
> sprintf(ok_image, "%s%s%s%s", DISK_IMG_DIR, "OK_SD_Btn_", lang_list[language-1], ".png");
572c777,778
< if (cdfile)
---
> if (cdfile) {
> printf("set_cd_image(cdfile)\n");
573a780
> }
580c787,791
< plat_init();
---
> if (cdfile != NULL) {
> isGame = 1;
> }
> plat_init(isGame, enter_mode);
> setTitleName();
605a817,819
> // save file
> make_file_name();
> save_error(ERROR_PCSXCRITICALERROR, "Sorry, error occurred during running system...");
643a858,870
> // create thread for watching communication file
> if (create_power_off_thread() != 0) {
> printf("failed to create power off thread\n");
> return -1;
> }
> if (check_prepare_suspend() != 0) {
> power_off();
> }
> // create thread for watching cpu temperature
> if (begin_watch_cpu_temperature() != 0) {
> printf("failed to create thread for watching cpu temperature\n");
> return -1;
> }
644a872,874
> StartCheckOpen();
>
> printf("while (g_emu_want_quit=%d) start \n",g_emu_want_quit);
651c881,884
< if (emu_action != SACTION_NONE)
---
> #ifdef UI_INTEGRATION
> g_emu_want_quit = -1;
> #else
> if (emu_action != SACTION_NONE) {
653a887,889
> #endif
> }
> printf("while (g_emu_want_quit=%d) end \n",g_emu_want_quit);
660a897,899
> unlink(STATUS_DIR"001.sts");
>
> printf("- plat_sdl/main.c:main()\n");
764a1004,1021
> int emu_auto_save_state(int slot)
> {
> char fname[MAXPATHLEN];
> int ret;
>
> ret = get_state_filename(fname, sizeof(fname), slot);
> if (ret != 0)
> return ret;
>
> ret = SaveStateWork(fname);
> #ifdef HAVE_PRE_ARMV7 /* XXX GPH hack */
> sync();
> #endif
> SysPrintf("* %s \"%s\" [%d]\n",
> ret == 0 ? "saved" : "failed to save", fname, slot);
> return ret;
> }
>
1031a1289,1450
> static int check_poweroff_event(int power_fd) {
> int i = 0;
> char buffer[BUF_LEN];
> int event_length = 0;
> char file_name[sizeof(POWER_OFF_FILE)] = POWER_OFF_FILE;
>
> event_length = read(power_fd, buffer, BUF_LEN);
> if(event_length <= 0) {
> return 1;
> }
> while (i < event_length) {
> struct inotify_event* event = (struct inotify_event *) &buffer[i];
> if (strcmp(file_name, event->name) == 0) {
> return 0;
> }
> i += EVENT_SIZE + event->len;
> }
> return 1;
> }
>
> static void power_manage(void) {
> int power_fd = -1;
> int power_wd = -1;
> int is_power_on = 1;
>
> power_fd = inotify_init();
> if(power_fd == -1) {
> printf("ERROR:failed to init inotify for power manage\n");
> return;
> }
>
> power_wd = inotify_add_watch(power_fd, POWER_DIR, IN_CREATE);
> if(power_wd == -1) {
> printf("ERROR:failed to add watch descriptor for power manage\n");
> return;
> }
>
> while (is_power_on) {
> is_power_on = check_poweroff_event(power_fd);
> }
>
> inotify_rm_watch(power_fd, power_wd);
> close(power_fd);
>
> power_off_flg = 1;
>
> return;
> }
>
> int create_power_off_thread(void) {
> int ret;
> pthread_attr_t power_manage_attr;
>
> if (th_power_off_state > 0) {
> printf("auto power off thread is already started, id [%d] \n", th_power_off_state);
> return -1;
> }
> pthread_attr_init(&power_manage_attr);
> pthread_attr_setdetachstate(&power_manage_attr , PTHREAD_CREATE_DETACHED);
>
> ret = pthread_create(&th_power_off_state, &power_manage_attr, (void*)power_manage, NULL);
> pthread_attr_destroy(&power_manage_attr);
>
> return ret;
> }
>
> void power_off(void)
> {
> char path[MAXPATHLEN];
> struct stat st;
>
> snprintf(path, sizeof(path), "." PCSX_DOT_DIR "filename.txt");
> if(stat(path, &st) == 0) {
> remove(path);
> }
>
> // terminate pcsx
> stop = 1;
> g_emu_want_quit = 1;
> }
>
> // sub-thread for watching cpu temperature
> static int check_cpu_temperature(int cpu_temp_fd)
> {
> int cpu_temperature, cpu_mode;
> FILE *fp;
> char buffer[BUF_LEN];
> int ret;
>
> int is_normal_temp = 1;
> int event_length = 0;
>
> event_length = read(cpu_temp_fd, buffer, BUF_LEN);
> if(event_length <= 0) {
> return 0;
> }
> fp = fopen(CPU_TEMP_FILE, "r");
> ret = fscanf(fp, "%d%d", &cpu_temperature, &cpu_mode);
> if (ret != EOF) {
> is_normal_temp = (cpu_temperature < cpu_temp_limit) ? 1 : 0;
> }
> fclose(fp);
> return is_normal_temp;
> }
>
> static void watch_cpu_temperature(void)
> {
> int cpu_temp_fd;
> int cpu_temp_wd;
> char temp_limit_str[strlen(CPU_TEMP_LIMIT_STRING)+1];
> int temp_limit_val;
> int ret;
> FILE *fp;
>
> cpu_temp_fd = inotify_init();
> if (cpu_temp_fd == -1) {
> printf("ERROR:failed to init inotify for cpu temperature\n");
> }
>
> cpu_temp_wd = inotify_add_watch(cpu_temp_fd, CPU_TEMP_FILE, IN_MODIFY);
> if (cpu_temp_wd == -1) {
> printf("ERROR:failed to add watch descriptor for cpu temperature\n");
> }
>
> fp = fopen(CPU_TEMP_LIMIT_FILE, "r");
> if (fp != NULL) {
> do {
> ret = fscanf(fp, "%s%d", &temp_limit_str, &temp_limit_val);
> if (strcmp(temp_limit_str, CPU_TEMP_LIMIT_STRING) == 0) {
> cpu_temp_limit = temp_limit_val;
> break;
> }
> } while (ret != EOF);
> }
> fclose(fp);
>
> while (1) {
> ret = check_cpu_temperature(cpu_temp_fd);
> if (ret == 0) {
> break;
> }
> }
>
> inotify_rm_watch(cpu_temp_fd, cpu_temp_wd);
> close(cpu_temp_fd);
>
> is_high_temperature = 1;
> }
>
> int begin_watch_cpu_temperature(void)
> {
> int ret;
> pthread_attr_t cpu_temp_attr;
>
> pthread_attr_init(&cpu_temp_attr);
> pthread_attr_setdetachstate(&cpu_temp_attr , PTHREAD_CREATE_DETACHED);
>
> ret = pthread_create(&cpu_temp_thread, &cpu_temp_attr, watch_cpu_temperature, NULL);
> pthread_attr_destroy(&cpu_temp_attr);
>
> return ret;
> }
diff --new-file -w -r pcsx_rearmed/frontend/main.h pcsx_rearmed_custom/frontend/main.h
33a34,36
> #define SCSHOT_DIR "/.pcsx/screenshots/"
> #define LANG_IMG_DIR "/usr/sony/share/data/images/BMP_TXT_SST/"
> #define DISK_IMG_DIR "/usr/sony/share/data/images/Disk/"
36a40,66
> #define POWER_DIR "/data/power/"
> #define POWER_OFF_FILE "prepare_suspend"
>
> #define CPU_TEMP_FILE "/dev/shm/power/cpu_temp"
>