diff --git a/README-raspberrypi.txt b/README-raspberrypi.txt new file mode 100644 index 000000000..a95932dae --- /dev/null +++ b/README-raspberrypi.txt @@ -0,0 +1,48 @@ +================================================================================ +SDL2 for Raspberry Pi +================================================================================ + +Requirements: + +Raspbian (other Linux distros may work as well). + +================================================================================ + Features +================================================================================ + +* Works without X11 +* Hardware accelerated OpenGL ES 2.x +* Sound via ALSA +* Input (mouse/keyboard/joystick) via EVDEV +* Hotplugging of input devices via UDEV + +================================================================================ + Raspbian Build Dependencies +================================================================================ + +sudo apt-get install libudev-dev libasound2-dev + +You also need the VideoCore binary stuff that ships in /opt/vc for EGL and +OpenGL ES 2.x, it usually comes pre installed, but in any case: + +sudo apt-get install libraspberrypi0 libraspberrypi-bin libraspberrypi-dev + +================================================================================ + No HDMI Audio +================================================================================ + +If you notice that ALSA works but there's no audio over HDMI, try adding: + + hdmi_drive=2 + +to your config.txt file and reboot. + +Reference: http://www.raspberrypi.org/phpBB3/viewtopic.php?t=5062 + +================================================================================ + Notes +================================================================================ + +* Building has only been tested natively (i.e. not cross compiled). Cross + compilation might work though, feedback is welcome! +* No Text Input yet. \ No newline at end of file diff --git a/build-scripts/config.guess b/build-scripts/config.guess index 137bedf2e..ddb36220a 100644 --- a/build-scripts/config.guess +++ b/build-scripts/config.guess @@ -896,12 +896,16 @@ EOF then echo ${UNAME_MACHINE}-unknown-linux-gnu else + case `sed -n '/^Hardware/s/^.*: \(.*\)/\1/p' < /proc/cpuinfo` in + BCM2708) MANUFACTURER=raspberry;; + *) MANUFACTURER=unknown;; + esac if echo __ARM_PCS_VFP | $CC_FOR_BUILD -E - 2>/dev/null \ | grep -q __ARM_PCS_VFP then - echo ${UNAME_MACHINE}-unknown-linux-gnueabi + echo ${UNAME_MACHINE}-${MANUFACTURER}-linux-gnueabi else - echo ${UNAME_MACHINE}-unknown-linux-gnueabihf + echo ${UNAME_MACHINE}-${MANUFACTURER}-linux-gnueabihf fi fi exit ;; diff --git a/configure b/configure index dffecba4e..c38982cc7 100755 --- a/configure +++ b/configure @@ -22028,6 +22028,21 @@ fi case "$host" in *-*-linux*|*-*-uclinux*|*-*-gnu*|*-*-k*bsd*-gnu|*-*-bsdi*|*-*-freebsd*|*-*-dragonfly*|*-*-netbsd*|*-*-openbsd*|*-*-sysv5*|*-*-solaris*|*-*-hpux*|*-*-aix*|*-*-minix*) case "$host" in + *-raspberry-linux*) + # Raspberry Pi + ARCH=linux + RPI_CFLAGS="-I/opt/vc/include -I/opt/vc/include/interface/vcos/pthreads -I/opt/vc/include/interface/vmcs_host/linux" + RPI_LDFLAGS="-L/opt/vc/lib -lbcm_host" + CFLAGS="$CFLAGS $RPI_CFLAGS" + SDL_CFLAGS="$SDL_CFLAGS $RPI_CFLAGS" + EXTRA_CFLAGS="$EXTRA_CFLAGS $RPI_CFLAGS" + SDL_LIBS="$SDL_LIBS $RPI_LDFLAGS" + + if test x$enable_video = xyes; then + SOURCES="$SOURCES $srcdir/src/video/raspberry/*.c" + $as_echo "#define SDL_VIDEO_DRIVER_RPI 1" >>confdefs.h + fi + ;; *-*-linux*) ARCH=linux ;; *-*-uclinux*) ARCH=linux ;; *-*-kfreebsd*-gnu) ARCH=kfreebsd-gnu ;; @@ -22151,6 +22166,14 @@ $as_echo "#define SDL_TIMER_UNIX 1" >>confdefs.h SOURCES="$SOURCES $srcdir/src/timer/unix/*.c" have_timers=yes fi + # Set up files for udev hotplugging support + if test x$enable_libudev = xyes && test x$have_libudev_h_hdr = xyes; then + SOURCES="$SOURCES $srcdir/src/core/linux/SDL_udev.c" + fi + # Set up files for evdev input + if test x$use_input_events = xyes; then + SOURCES="$SOURCES $srcdir/src/input/evdev/*.c" + fi ;; *-*-cygwin* | *-*-mingw32*) ARCH=win32 diff --git a/configure.in b/configure.in index a1fc311fd..f1d64497b 100644 --- a/configure.in +++ b/configure.in @@ -2343,6 +2343,21 @@ dnl Set up the configuration based on the host platform! case "$host" in *-*-linux*|*-*-uclinux*|*-*-gnu*|*-*-k*bsd*-gnu|*-*-bsdi*|*-*-freebsd*|*-*-dragonfly*|*-*-netbsd*|*-*-openbsd*|*-*-sysv5*|*-*-solaris*|*-*-hpux*|*-*-aix*|*-*-minix*) case "$host" in + *-raspberry-linux*) + # Raspberry Pi + ARCH=linux + RPI_CFLAGS="-I/opt/vc/include -I/opt/vc/include/interface/vcos/pthreads -I/opt/vc/include/interface/vmcs_host/linux" + RPI_LDFLAGS="-L/opt/vc/lib -lbcm_host" + CFLAGS="$CFLAGS $RPI_CFLAGS" + SDL_CFLAGS="$SDL_CFLAGS $RPI_CFLAGS" + EXTRA_CFLAGS="$EXTRA_CFLAGS $RPI_CFLAGS" + SDL_LIBS="$SDL_LIBS $RPI_LDFLAGS" + + if test x$enable_video = xyes; then + SOURCES="$SOURCES $srcdir/src/video/raspberry/*.c" + $as_echo "#define SDL_VIDEO_DRIVER_RPI 1" >>confdefs.h + fi + ;; *-*-linux*) ARCH=linux ;; *-*-uclinux*) ARCH=linux ;; *-*-kfreebsd*-gnu) ARCH=kfreebsd-gnu ;; @@ -2450,6 +2465,14 @@ case "$host" in SOURCES="$SOURCES $srcdir/src/timer/unix/*.c" have_timers=yes fi + # Set up files for udev hotplugging support + if test x$enable_libudev = xyes && test x$have_libudev_h_hdr = xyes; then + SOURCES="$SOURCES $srcdir/src/core/linux/SDL_udev.c" + fi + # Set up files for evdev input + if test x$use_input_events = xyes; then + SOURCES="$SOURCES $srcdir/src/input/evdev/*.c" + fi ;; *-*-cygwin* | *-*-mingw32*) ARCH=win32 diff --git a/include/SDL_config.h.in b/include/SDL_config.h.in index 551c8b3e7..08299411b 100644 --- a/include/SDL_config.h.in +++ b/include/SDL_config.h.in @@ -259,6 +259,7 @@ #undef SDL_VIDEO_DRIVER_DUMMY #undef SDL_VIDEO_DRIVER_WINDOWS #undef SDL_VIDEO_DRIVER_X11 +#undef SDL_VIDEO_DRIVER_RPI #undef SDL_VIDEO_DRIVER_X11_DYNAMIC #undef SDL_VIDEO_DRIVER_X11_DYNAMIC_XEXT #undef SDL_VIDEO_DRIVER_X11_DYNAMIC_XCURSOR diff --git a/src/core/linux/SDL_udev.c b/src/core/linux/SDL_udev.c new file mode 100644 index 000000000..82f3e6636 --- /dev/null +++ b/src/core/linux/SDL_udev.c @@ -0,0 +1,404 @@ +/* + Simple DirectMedia Layer + Copyright (C) 1997-2013 Sam Lantinga + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. +*/ + +/* + * To list the properties of a device, try something like: + * udevadm info -a -n snd/hwC0D0 (for a sound card) + * udevadm info --query=all -n input/event3 (for a keyboard, mouse, etc) + * udevadm info --query=property -n input/event2 + */ + +#include "SDL_udev.h" + +#ifdef SDL_USE_LIBUDEV + +static char* SDL_UDEV_LIBS[] = { "libudev.so.1", "libudev.so.0" }; + +#define _THIS SDL_UDEV_PrivateData *_this +static _THIS = NULL; + +#include "SDL.h" + +static SDL_bool SDL_UDEV_load_sym(const char *fn, void **addr); +static int SDL_UDEV_load_syms(void); +static SDL_bool SDL_UDEV_hotplug_update_available(void); +static void device_event(SDL_UDEV_deviceevent type, struct udev_device *dev); + +static SDL_bool +SDL_UDEV_load_sym(const char *fn, void **addr) +{ + *addr = SDL_LoadFunction(_this->udev_handle, fn); + if (*addr == NULL) { + /* Don't call SDL_SetError(): SDL_LoadFunction already did. */ + return SDL_FALSE; + } + + return SDL_TRUE; +} + +static int +SDL_UDEV_load_syms(void) +{ + /* cast funcs to char* first, to please GCC's strict aliasing rules. */ + #define SDL_UDEV_SYM(x) \ + if (!SDL_UDEV_load_sym(#x, (void **) (char *) & _this->x)) return -1 + + SDL_UDEV_SYM(udev_device_get_action); + SDL_UDEV_SYM(udev_device_get_devnode); + SDL_UDEV_SYM(udev_device_get_subsystem); + SDL_UDEV_SYM(udev_device_get_property_value); + SDL_UDEV_SYM(udev_device_new_from_syspath); + SDL_UDEV_SYM(udev_device_unref); + SDL_UDEV_SYM(udev_enumerate_add_match_property); + SDL_UDEV_SYM(udev_enumerate_add_match_subsystem); + SDL_UDEV_SYM(udev_enumerate_get_list_entry); + SDL_UDEV_SYM(udev_enumerate_new); + SDL_UDEV_SYM(udev_enumerate_scan_devices); + SDL_UDEV_SYM(udev_enumerate_unref); + SDL_UDEV_SYM(udev_list_entry_get_name); + SDL_UDEV_SYM(udev_list_entry_get_next); + SDL_UDEV_SYM(udev_monitor_enable_receiving); + SDL_UDEV_SYM(udev_monitor_filter_add_match_subsystem_devtype); + SDL_UDEV_SYM(udev_monitor_get_fd); + SDL_UDEV_SYM(udev_monitor_new_from_netlink); + SDL_UDEV_SYM(udev_monitor_receive_device); + SDL_UDEV_SYM(udev_monitor_unref); + SDL_UDEV_SYM(udev_new); + SDL_UDEV_SYM(udev_unref); + SDL_UDEV_SYM(udev_device_new_from_devnum); + SDL_UDEV_SYM(udev_device_get_devnum); + #undef SDL_UDEV_SYM + + return 0; +} + +static SDL_bool +SDL_UDEV_hotplug_update_available(void) +{ + if (_this->udev_mon != NULL) { + const int fd = _this->udev_monitor_get_fd(_this->udev_mon); + fd_set fds; + struct timeval tv; + + FD_ZERO(&fds); + FD_SET(fd, &fds); + tv.tv_sec = 0; + tv.tv_usec = 0; + if ((select(fd+1, &fds, NULL, NULL, &tv) > 0) && (FD_ISSET(fd, &fds))) { + return SDL_TRUE; + } + } + return SDL_FALSE; +} + + +int +SDL_UDEV_Init(void) +{ + int retval = 0; + + if (_this == NULL) { + _this = (SDL_UDEV_PrivateData *) SDL_calloc(1, sizeof(*_this)); + if(_this == NULL) { + return SDL_OutOfMemory(); + } + + retval = SDL_UDEV_LoadLibrary(); + if (retval < 0) { + SDL_UDEV_Quit(); + return retval; + } + + /* Set up udev monitoring + * Listen for input devices (mouse, keyboard, joystick, etc) and sound devices + */ + + _this->udev = _this->udev_new(); + if (_this->udev == NULL) { + SDL_UDEV_Quit(); + return SDL_SetError("udev_new() failed"); + } + + _this->udev_mon = _this->udev_monitor_new_from_netlink(_this->udev, "udev"); + if (_this->udev_mon == NULL) { + SDL_UDEV_Quit(); + return SDL_SetError("udev_monitor_new_from_netlink() failed"); + } + + _this->udev_monitor_filter_add_match_subsystem_devtype(_this->udev_mon, "input", NULL); + _this->udev_monitor_filter_add_match_subsystem_devtype(_this->udev_mon, "sound", NULL); + _this->udev_monitor_enable_receiving(_this->udev_mon); + + /* Do an initial scan of existing devices */ + SDL_UDEV_Scan(); + + } + + _this->ref_count += 1; + + return retval; +} + +void +SDL_UDEV_Quit(void) +{ + SDL_UDEV_CallbackList *item; + + if (_this == NULL) { + return; + } + + _this->ref_count -= 1; + + if (_this->ref_count < 1) { + + if (_this->udev_mon != NULL) { + _this->udev_monitor_unref(_this->udev_mon); + _this->udev_mon = NULL; + } + if (_this->udev != NULL) { + _this->udev_unref(_this->udev); + _this->udev = NULL; + } + + /* Remove existing devices */ + while (_this->first != NULL) { + item = _this->first; + _this->first = _this->first->next; + SDL_free(item); + } + + SDL_UDEV_UnloadLibrary(); + SDL_free(_this); + _this = NULL; + } +} + +void +SDL_UDEV_Scan(void) +{ + struct udev_enumerate *enumerate = NULL; + struct udev_list_entry *devs = NULL; + struct udev_list_entry *item = NULL; + + if (_this == NULL) { + return; + } + + enumerate = _this->udev_enumerate_new(_this->udev); + if (enumerate == NULL) { + SDL_UDEV_Quit(); + SDL_SetError("udev_monitor_new_from_netlink() failed"); + return; + } + + _this->udev_enumerate_add_match_subsystem(enumerate, "input"); + _this->udev_enumerate_add_match_subsystem(enumerate, "sound"); + + _this->udev_enumerate_scan_devices(enumerate); + devs = _this->udev_enumerate_get_list_entry(enumerate); + for (item = devs; item; item = _this->udev_list_entry_get_next(item)) { + const char *path = _this->udev_list_entry_get_name(item); + struct udev_device *dev = _this->udev_device_new_from_syspath(_this->udev, path); + if (dev != NULL) { + device_event(SDL_UDEV_DEVICEADDED, dev); + _this->udev_device_unref(dev); + } + } + + _this->udev_enumerate_unref(enumerate); +} + + +void +SDL_UDEV_UnloadLibrary(void) +{ + if (_this == NULL) { + return; + } + + if (_this->udev_handle != NULL) { + SDL_UnloadObject(_this->udev_handle); + _this->udev_handle = NULL; + } +} + +int +SDL_UDEV_LoadLibrary(void) +{ + int retval = 0, i; + + if (_this == NULL) { + return SDL_SetError("UDEV not initialized"); + } + + + if (_this->udev_handle == NULL) { + for( i = 0 ; i < SDL_arraysize(SDL_UDEV_LIBS); i++) { + _this->udev_handle = SDL_LoadObject(SDL_UDEV_LIBS[i]); + if (_this->udev_handle != NULL) { + retval = SDL_UDEV_load_syms(); + if (retval < 0) { + SDL_UDEV_UnloadLibrary(); + } + else { + break; + } + } + } + + if (_this->udev_handle == NULL) { + retval = -1; + /* Don't call SDL_SetError(): SDL_LoadObject already did. */ + } + } + + return retval; +} + +static void +device_event(SDL_UDEV_deviceevent type, struct udev_device *dev) +{ + const char *subsystem; + const char *val = NULL; + SDL_UDEV_deviceclass devclass = 0; + const char *path; + SDL_UDEV_CallbackList *item; + + path = _this->udev_device_get_devnode(dev); + if (path == NULL) { + return; + } + + subsystem = _this->udev_device_get_subsystem(dev); + if (SDL_strcmp(subsystem, "sound") == 0) { + devclass = SDL_UDEV_DEVICE_SOUND; + } + else if (SDL_strcmp(subsystem, "input") == 0) { + val = _this->udev_device_get_property_value(dev, "ID_INPUT_JOYSTICK"); + if (val != NULL && SDL_strcmp(val, "1") == 0 ) { + devclass = SDL_UDEV_DEVICE_JOYSTICK; + } + + if (devclass == 0) { + val = _this->udev_device_get_property_value(dev, "ID_INPUT_MOUSE"); + if (val != NULL && SDL_strcmp(val, "1") == 0 ) { + devclass = SDL_UDEV_DEVICE_MOUSE; + } + } + + if (devclass == 0) { + val = _this->udev_device_get_property_value(dev, "ID_INPUT_KEYBOARD"); + if (val != NULL && SDL_strcmp(val, "1") == 0 ) { + devclass = SDL_UDEV_DEVICE_KEYBOARD; + } + } + + if (devclass == 0) { + return; + } + } + else { + return; + } + + /* Process callbacks */ + for (item = _this->first; item != NULL; item = item->next) { + item->callback(type, devclass, path); + } +} + +void +SDL_UDEV_Poll(void) +{ + struct udev_device *dev = NULL; + const char *action = NULL; + + if (_this == NULL) { + return; + } + + while (SDL_UDEV_hotplug_update_available()) { + dev = _this->udev_monitor_receive_device(_this->udev_mon); + if (dev == NULL) { + break; + } + action = _this->udev_device_get_action(dev); + + if (SDL_strcmp(action, "add") == 0) { + device_event(SDL_UDEV_DEVICEADDED, dev); + } else if (SDL_strcmp(action, "remove") == 0) { + device_event(SDL_UDEV_DEVICEREMOVED, dev); + } + + _this->udev_device_unref(dev); + } +} + +int +SDL_UDEV_AddCallback(SDL_UDEV_Callback cb) +{ + SDL_UDEV_CallbackList *item; + item = (SDL_UDEV_CallbackList *) SDL_calloc(1, sizeof (SDL_UDEV_CallbackList)); + if (item == NULL) { + return SDL_OutOfMemory(); + } + + item->callback = cb; + + if (_this->last == NULL) { + _this->first = _this->last = item; + } else { + _this->last->next = item; + _this->last = item; + } + + return 1; +} + +void +SDL_UDEV_DelCallback(SDL_UDEV_Callback cb) +{ + SDL_UDEV_CallbackList *item; + SDL_UDEV_CallbackList *prev = NULL; + + for (item = _this->first; item != NULL; item = item->next) { + /* found it, remove it. */ + if (item->callback == cb) { + if (prev != NULL) { + prev->next = item->next; + } else { + SDL_assert(_this->first == item); + _this->first = item->next; + } + if (item == _this->last) { + _this->last = prev; + } + SDL_free(item); + return; + } + prev = item; + } + +} + + +#endif /* SDL_USE_LIBUDEV */ \ No newline at end of file diff --git a/src/core/linux/SDL_udev.h b/src/core/linux/SDL_udev.h new file mode 100644 index 000000000..0ec86db1c --- /dev/null +++ b/src/core/linux/SDL_udev.h @@ -0,0 +1,114 @@ +/* + Simple DirectMedia Layer + Copyright (C) 1997-2013 Sam Lantinga + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. +*/ + +#include "SDL_config.h" + +#ifndef _SDL_udev_h +#define _SDL_udev_h + +#if HAVE_LIBUDEV_H + +#ifndef SDL_USE_LIBUDEV +#define SDL_USE_LIBUDEV 1 +#endif + +#include "SDL_loadso.h" +#include "SDL_events.h" +#include +#include +#include + +/** + * \brief Device type + */ + +typedef enum +{ + SDL_UDEV_DEVICEADDED = 0x0001, + SDL_UDEV_DEVICEREMOVED +} SDL_UDEV_deviceevent; + +typedef enum +{ + SDL_UDEV_DEVICE_MOUSE = 0x0001, + SDL_UDEV_DEVICE_KEYBOARD, + SDL_UDEV_DEVICE_JOYSTICK, + SDL_UDEV_DEVICE_SOUND +} SDL_UDEV_deviceclass; + +typedef void (*SDL_UDEV_Callback)(SDL_UDEV_deviceevent udev_type, SDL_UDEV_deviceclass udev_class, const char *devpath); + +typedef struct SDL_UDEV_CallbackList { + SDL_UDEV_Callback callback; + struct SDL_UDEV_CallbackList *next; +} SDL_UDEV_CallbackList; + +typedef struct SDL_UDEV_PrivateData +{ + const char *udev_library; + void *udev_handle; + struct udev *udev; + struct udev_monitor *udev_mon; + int ref_count; + SDL_UDEV_CallbackList *first, *last; + + /* Function pointers */ + const char *(*udev_device_get_action)(struct udev_device *); + const char *(*udev_device_get_devnode)(struct udev_device *); + const char *(*udev_device_get_subsystem)(struct udev_device *); + const char *(*udev_device_get_property_value)(struct udev_device *, const char *); + struct udev_device *(*udev_device_new_from_syspath)(struct udev *, const char *); + void (*udev_device_unref)(struct udev_device *); + int (*udev_enumerate_add_match_property)(struct udev_enumerate *, const char *, const char *); + int (*udev_enumerate_add_match_subsystem)(struct udev_enumerate *, const char *); + struct udev_list_entry *(*udev_enumerate_get_list_entry)(struct udev_enumerate *); + struct udev_enumerate *(*udev_enumerate_new)(struct udev *); + int (*udev_enumerate_scan_devices)(struct udev_enumerate *); + void (*udev_enumerate_unref)(struct udev_enumerate *); + const char *(*udev_list_entry_get_name)(struct udev_list_entry *); + struct udev_list_entry *(*udev_list_entry_get_next)(struct udev_list_entry *); + int (*udev_monitor_enable_receiving)(struct udev_monitor *); + int (*udev_monitor_filter_add_match_subsystem_devtype)(struct udev_monitor *, const char *, const char *); + int (*udev_monitor_get_fd)(struct udev_monitor *); + struct udev_monitor *(*udev_monitor_new_from_netlink)(struct udev *, const char *); + struct udev_device *(*udev_monitor_receive_device)(struct udev_monitor *); + void (*udev_monitor_unref)(struct udev_monitor *); + struct udev *(*udev_new)(void); + void (*udev_unref)(struct udev *); + struct udev_device * (*udev_device_new_from_devnum)(struct udev *udev, char type, dev_t devnum); + dev_t (*udev_device_get_devnum) (struct udev_device *udev_device); +} SDL_UDEV_PrivateData; + +extern int SDL_UDEV_Init(void); +extern void SDL_UDEV_Quit(void); +extern void SDL_UDEV_UnloadLibrary(void); +extern int SDL_UDEV_LoadLibrary(void); +extern void SDL_UDEV_Poll(void); +extern void SDL_UDEV_Scan(void); +extern int SDL_UDEV_AddCallback(SDL_UDEV_Callback cb); +extern void SDL_UDEV_DelCallback(SDL_UDEV_Callback cb); + + + + +#endif /* HAVE_LIBUDEV_H */ + +#endif /* _SDL_udev_h */ \ No newline at end of file diff --git a/src/events/SDL_mouse.c b/src/events/SDL_mouse.c index e322437b8..0886f54fa 100644 --- a/src/events/SDL_mouse.c +++ b/src/events/SDL_mouse.c @@ -246,13 +246,11 @@ SDL_PrivateSendMouseMotion(SDL_Window * window, SDL_MouseID mouseID, int relativ mouse->xdelta += xrel; mouse->ydelta += yrel; -#if 0 /* FIXME */ /* Move the mouse cursor, if needed */ if (mouse->cursor_shown && !mouse->relative_mode && mouse->MoveCursor && mouse->cur_cursor) { mouse->MoveCursor(mouse->cur_cursor); } -#endif /* Post the event, if desired */ posted = 0; diff --git a/src/input/evdev/SDL_evdev.c b/src/input/evdev/SDL_evdev.c new file mode 100644 index 000000000..ea911d68c --- /dev/null +++ b/src/input/evdev/SDL_evdev.c @@ -0,0 +1,646 @@ +/* + Simple DirectMedia Layer + Copyright (C) 1997-2013 Sam Lantinga + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. +*/ +#include "SDL_config.h" + +#ifdef SDL_INPUT_LINUXEV + +/* This is based on the linux joystick driver */ +/* References: https://www.kernel.org/doc/Documentation/input/input.txt + * https://www.kernel.org/doc/Documentation/input/event-codes.txt + * /usr/include/linux/input.h + * The evtest application is also useful to debug the protocol + */ + + +#include "SDL_evdev.h" +#define _THIS SDL_EVDEV_PrivateData *_this +static _THIS = NULL; + +#include +#include +#include +#include +#include /* For the definition of PATH_MAX */ + + +#include "SDL.h" +#include "SDL_assert.h" +#include "SDL_endian.h" +#include "../../core/linux/SDL_udev.h" +#include "SDL_scancode.h" +#include "../../events/SDL_events_c.h" + +/* This isn't defined in older Linux kernel headers */ +#ifndef SYN_DROPPED +#define SYN_DROPPED 3 +#endif + + +static int SDL_EVDEV_device_removed(const char *devpath); +static int SDL_EVDEV_device_added(const SDL_UDEV_deviceclass devclass, const char *devpath); +static SDL_Scancode SDL_EVDEV_translate_keycode(int keycode); +static void SDL_EVDEV_sync_device(SDL_evdevlist_item *item); +void SDL_EVDEV_udev_callback(SDL_UDEV_deviceevent udev_type, SDL_UDEV_deviceclass udev_class, const char *devpath); + +static SDL_Scancode EVDEV_Keycodes[] = { + SDL_SCANCODE_UNKNOWN, /* KEY_RESERVED 0 */ + SDL_SCANCODE_ESCAPE, /* KEY_ESC 1 */ + SDL_SCANCODE_1, /* KEY_1 2 */ + SDL_SCANCODE_2, /* KEY_2 3 */ + SDL_SCANCODE_3, /* KEY_3 4 */ + SDL_SCANCODE_4, /* KEY_4 5 */ + SDL_SCANCODE_5, /* KEY_5 6 */ + SDL_SCANCODE_6, /* KEY_6 7 */ + SDL_SCANCODE_7, /* KEY_7 8 */ + SDL_SCANCODE_8, /* KEY_8 9 */ + SDL_SCANCODE_9, /* KEY_9 10 */ + SDL_SCANCODE_0, /* KEY_0 11 */ + SDL_SCANCODE_MINUS, /* KEY_MINUS 12 */ + SDL_SCANCODE_EQUALS, /* KEY_EQUAL 13 */ + SDL_SCANCODE_BACKSPACE, /* KEY_BACKSPACE 14 */ + SDL_SCANCODE_TAB, /* KEY_TAB 15 */ + SDL_SCANCODE_Q, /* KEY_Q 16 */ + SDL_SCANCODE_W, /* KEY_W 17 */ + SDL_SCANCODE_E, /* KEY_E 18 */ + SDL_SCANCODE_R, /* KEY_R 19 */ + SDL_SCANCODE_T, /* KEY_T 20 */ + SDL_SCANCODE_Y, /* KEY_Y 21 */ + SDL_SCANCODE_U, /* KEY_U 22 */ + SDL_SCANCODE_I, /* KEY_I 23 */ + SDL_SCANCODE_O, /* KEY_O 24 */ + SDL_SCANCODE_P, /* KEY_P 25 */ + SDL_SCANCODE_LEFTBRACKET, /* KEY_LEFTBRACE 26 */ + SDL_SCANCODE_RIGHTBRACKET, /* KEY_RIGHTBRACE 27 */ + SDL_SCANCODE_RETURN, /* KEY_ENTER 28 */ + SDL_SCANCODE_LCTRL, /* KEY_LEFTCTRL 29 */ + SDL_SCANCODE_A, /* KEY_A 30 */ + SDL_SCANCODE_S, /* KEY_S 31 */ + SDL_SCANCODE_D, /* KEY_D 32 */ + SDL_SCANCODE_F, /* KEY_F 33 */ + SDL_SCANCODE_G, /* KEY_G 34 */ + SDL_SCANCODE_H, /* KEY_H 35 */ + SDL_SCANCODE_J, /* KEY_J 36 */ + SDL_SCANCODE_K, /* KEY_K 37 */ + SDL_SCANCODE_L, /* KEY_L 38 */ + SDL_SCANCODE_SEMICOLON, /* KEY_SEMICOLON 39 */ + SDL_SCANCODE_APOSTROPHE, /* KEY_APOSTROPHE 40 */ + SDL_SCANCODE_GRAVE, /* KEY_GRAVE 41 */ + SDL_SCANCODE_LSHIFT, /* KEY_LEFTSHIFT 42 */ + SDL_SCANCODE_BACKSLASH, /* KEY_BACKSLASH 43 */ + SDL_SCANCODE_Z, /* KEY_Z 44 */ + SDL_SCANCODE_X, /* KEY_X 45 */ + SDL_SCANCODE_C, /* KEY_C 46 */ + SDL_SCANCODE_V, /* KEY_V 47 */ + SDL_SCANCODE_B, /* KEY_B 48 */ + SDL_SCANCODE_N, /* KEY_N 49 */ + SDL_SCANCODE_M, /* KEY_M 50 */ + SDL_SCANCODE_COMMA, /* KEY_COMMA 51 */ + SDL_SCANCODE_PERIOD, /* KEY_DOT 52 */ + SDL_SCANCODE_SLASH, /* KEY_SLASH 53 */ + SDL_SCANCODE_RSHIFT, /* KEY_RIGHTSHIFT 54 */ + SDL_SCANCODE_KP_MULTIPLY, /* KEY_KPASTERISK 55 */ + SDL_SCANCODE_LALT, /* KEY_LEFTALT 56 */ + SDL_SCANCODE_SPACE, /* KEY_SPACE 57 */ + SDL_SCANCODE_CAPSLOCK, /* KEY_CAPSLOCK 58 */ + SDL_SCANCODE_F1, /* KEY_F1 59 */ + SDL_SCANCODE_F2, /* KEY_F2 60 */ + SDL_SCANCODE_F3, /* KEY_F3 61 */ + SDL_SCANCODE_F4, /* KEY_F4 62 */ + SDL_SCANCODE_F5, /* KEY_F5 63 */ + SDL_SCANCODE_F6, /* KEY_F6 64 */ + SDL_SCANCODE_F7, /* KEY_F7 65 */ + SDL_SCANCODE_F8, /* KEY_F8 66 */ + SDL_SCANCODE_F9, /* KEY_F9 67 */ + SDL_SCANCODE_F10, /* KEY_F10 68 */ + SDL_SCANCODE_NUMLOCKCLEAR, /* KEY_NUMLOCK 69 */ + SDL_SCANCODE_SCROLLLOCK, /* KEY_SCROLLLOCK 70 */ + SDL_SCANCODE_KP_7, /* KEY_KP7 71 */ + SDL_SCANCODE_KP_8, /* KEY_KP8 72 */ + SDL_SCANCODE_KP_9, /* KEY_KP9 73 */ + SDL_SCANCODE_KP_MINUS, /* KEY_KPMINUS 74 */ + SDL_SCANCODE_KP_4, /* KEY_KP4 75 */ + SDL_SCANCODE_KP_5, /* KEY_KP5 76 */ + SDL_SCANCODE_KP_6, /* KEY_KP6 77 */ + SDL_SCANCODE_KP_PLUS, /* KEY_KPPLUS 78 */ + SDL_SCANCODE_KP_1, /* KEY_KP1 79 */ + SDL_SCANCODE_KP_2, /* KEY_KP2 80 */ + SDL_SCANCODE_KP_3, /* KEY_KP3 81 */ + SDL_SCANCODE_KP_0, /* KEY_KP0 82 */ + SDL_SCANCODE_KP_PERIOD, /* KEY_KPDOT 83 */ + SDL_SCANCODE_UNKNOWN, /* 84 */ + SDL_SCANCODE_LANG5, /* KEY_ZENKAKUHANKAKU 85 */ + SDL_SCANCODE_UNKNOWN, /* KEY_102ND 86 */ + SDL_SCANCODE_F11, /* KEY_F11 87 */ + SDL_SCANCODE_F12, /* KEY_F12 88 */ + SDL_SCANCODE_UNKNOWN, /* KEY_RO 89 */ + SDL_SCANCODE_LANG3, /* KEY_KATAKANA 90 */ + SDL_SCANCODE_LANG4, /* KEY_HIRAGANA 91 */ + SDL_SCANCODE_UNKNOWN, /* KEY_HENKAN 92 */ + SDL_SCANCODE_LANG3, /* KEY_KATAKANAHIRAGANA 93 */ + SDL_SCANCODE_UNKNOWN, /* KEY_MUHENKAN 94 */ + SDL_SCANCODE_KP_COMMA, /* KEY_KPJPCOMMA 95 */ + SDL_SCANCODE_KP_ENTER, /* KEY_KPENTER 96 */ + SDL_SCANCODE_RCTRL, /* KEY_RIGHTCTRL 97 */ + SDL_SCANCODE_KP_DIVIDE, /* KEY_KPSLASH 98 */ + SDL_SCANCODE_SYSREQ, /* KEY_SYSRQ 99 */ + SDL_SCANCODE_RALT, /* KEY_RIGHTALT 100 */ + SDL_SCANCODE_UNKNOWN, /* KEY_LINEFEED 101 */ + SDL_SCANCODE_HOME, /* KEY_HOME 102 */ + SDL_SCANCODE_UP, /* KEY_UP 103 */ + SDL_SCANCODE_PAGEUP, /* KEY_PAGEUP 104 */ + SDL_SCANCODE_LEFT, /* KEY_LEFT 105 */ + SDL_SCANCODE_RIGHT, /* KEY_RIGHT 106 */ + SDL_SCANCODE_END, /* KEY_END 107 */ + SDL_SCANCODE_DOWN, /* KEY_DOWN 108 */ + SDL_SCANCODE_PAGEDOWN, /* KEY_PAGEDOWN 109 */ + SDL_SCANCODE_INSERT, /* KEY_INSERT 110 */ + SDL_SCANCODE_DELETE, /* KEY_DELETE 111 */ + SDL_SCANCODE_UNKNOWN, /* KEY_MACRO 112 */ + SDL_SCANCODE_MUTE, /* KEY_MUTE 113 */ + SDL_SCANCODE_VOLUMEDOWN, /* KEY_VOLUMEDOWN 114 */ + SDL_SCANCODE_VOLUMEUP, /* KEY_VOLUMEUP 115 */ + SDL_SCANCODE_POWER, /* KEY_POWER 116 SC System Power Down */ + SDL_SCANCODE_KP_EQUALS, /* KEY_KPEQUAL 117 */ + SDL_SCANCODE_KP_MINUS, /* KEY_KPPLUSMINUS 118 */ + SDL_SCANCODE_PAUSE, /* KEY_PAUSE 119 */ + SDL_SCANCODE_UNKNOWN, /* KEY_SCALE 120 AL Compiz Scale (Expose) */ + SDL_SCANCODE_KP_COMMA, /* KEY_KPCOMMA 121 */ + SDL_SCANCODE_LANG1, /* KEY_HANGEUL,KEY_HANGUEL 122 */ + SDL_SCANCODE_LANG2, /* KEY_HANJA 123 */ + SDL_SCANCODE_INTERNATIONAL3,/* KEY_YEN 124 */ + SDL_SCANCODE_LGUI, /* KEY_LEFTMETA 125 */ + SDL_SCANCODE_RGUI, /* KEY_RIGHTMETA 126 */ + SDL_SCANCODE_APPLICATION, /* KEY_COMPOSE 127 */ + SDL_SCANCODE_STOP, /* KEY_STOP 128 AC Stop */ + SDL_SCANCODE_AGAIN, /* KEY_AGAIN 129 */ + SDL_SCANCODE_UNKNOWN, /* KEY_PROPS 130 AC Properties */ + SDL_SCANCODE_UNDO, /* KEY_UNDO 131 AC Undo */ + SDL_SCANCODE_UNKNOWN, /* KEY_FRONT 132 */ + SDL_SCANCODE_COPY, /* KEY_COPY 133 AC Copy */ + SDL_SCANCODE_UNKNOWN, /* KEY_OPEN 134 AC Open */ + SDL_SCANCODE_PASTE, /* KEY_PASTE 135 AC Paste */ + SDL_SCANCODE_FIND, /* KEY_FIND 136 AC Search */ + SDL_SCANCODE_CUT, /* KEY_CUT 137 AC Cut */ + SDL_SCANCODE_HELP, /* KEY_HELP 138 AL Integrated Help Center */ + SDL_SCANCODE_MENU, /* KEY_MENU 139 Menu (show menu) */ + SDL_SCANCODE_CALCULATOR, /* KEY_CALC 140 AL Calculator */ + SDL_SCANCODE_UNKNOWN, /* KEY_SETUP 141 */ + SDL_SCANCODE_SLEEP, /* KEY_SLEEP 142 SC System Sleep */ + SDL_SCANCODE_UNKNOWN, /* KEY_WAKEUP 143 System Wake Up */ + SDL_SCANCODE_UNKNOWN, /* KEY_FILE 144 AL Local Machine Browser */ + SDL_SCANCODE_UNKNOWN, /* KEY_SENDFILE 145 */ + SDL_SCANCODE_UNKNOWN, /* KEY_DELETEFILE 146 */ + SDL_SCANCODE_UNKNOWN, /* KEY_XFER 147 */ + SDL_SCANCODE_APP1, /* KEY_PROG1 148 */ + SDL_SCANCODE_APP1, /* KEY_PROG2 149 */ + SDL_SCANCODE_WWW, /* KEY_WWW 150 AL Internet Browser */ + SDL_SCANCODE_UNKNOWN, /* KEY_MSDOS 151 */ + SDL_SCANCODE_UNKNOWN, /* KEY_COFFEE,KEY_SCREENLOCK 152 AL Terminal Lock/Screensaver */ + SDL_SCANCODE_UNKNOWN, /* KEY_DIRECTION 153 */ + SDL_SCANCODE_UNKNOWN, /* KEY_CYCLEWINDOWS 154 */ + SDL_SCANCODE_MAIL, /* KEY_MAIL 155 */ + SDL_SCANCODE_AC_BOOKMARKS, /* KEY_BOOKMARKS 156 AC Bookmarks */ + SDL_SCANCODE_COMPUTER, /* KEY_COMPUTER 157 */ + SDL_SCANCODE_AC_BACK, /* KEY_BACK 158 AC Back */ + SDL_SCANCODE_AC_FORWARD, /* KEY_FORWARD 159 AC Forward */ + SDL_SCANCODE_UNKNOWN, /* KEY_CLOSECD 160 */ + SDL_SCANCODE_EJECT, /* KEY_EJECTCD 161 */ + SDL_SCANCODE_UNKNOWN, /* KEY_EJECTCLOSECD 162 */ + SDL_SCANCODE_AUDIONEXT, /* KEY_NEXTSONG 163 */ + SDL_SCANCODE_AUDIOPLAY, /* KEY_PLAYPAUSE 164 */ + SDL_SCANCODE_AUDIOPREV, /* KEY_PREVIOUSSONG 165 */ + SDL_SCANCODE_AUDIOSTOP, /* KEY_STOPCD 166 */ + SDL_SCANCODE_UNKNOWN, /* KEY_RECORD 167 */ + SDL_SCANCODE_UNKNOWN, /* KEY_REWIND 168 */ + SDL_SCANCODE_UNKNOWN, /* KEY_PHONE 169 Media Select Telephone */ + SDL_SCANCODE_UNKNOWN, /* KEY_ISO 170 */ + SDL_SCANCODE_UNKNOWN, /* KEY_CONFIG 171 AL Consumer Control Configuration */ + SDL_SCANCODE_AC_HOME, /* KEY_HOMEPAGE 172 AC Home */ + SDL_SCANCODE_AC_REFRESH, /* KEY_REFRESH 173 AC Refresh */ + SDL_SCANCODE_UNKNOWN, /* KEY_EXIT 174 AC Exit */ + SDL_SCANCODE_UNKNOWN, /* KEY_MOVE 175 */ + SDL_SCANCODE_UNKNOWN, /* KEY_EDIT 176 */ + SDL_SCANCODE_UNKNOWN, /* KEY_SCROLLUP 177 */ + SDL_SCANCODE_UNKNOWN, /* KEY_SCROLLDOWN 178 */ + SDL_SCANCODE_KP_LEFTPAREN, /* KEY_KPLEFTPAREN 179 */ + SDL_SCANCODE_KP_RIGHTPAREN, /* KEY_KPRIGHTPAREN 180 */ + SDL_SCANCODE_UNKNOWN, /* KEY_NEW 181 AC New */ + SDL_SCANCODE_AGAIN, /* KEY_REDO 182 AC Redo/Repeat */ + SDL_SCANCODE_F13, /* KEY_F13 183 */ + SDL_SCANCODE_F14, /* KEY_F14 184 */ + SDL_SCANCODE_F15, /* KEY_F15 185 */ + SDL_SCANCODE_F16, /* KEY_F16 186 */ + SDL_SCANCODE_F17, /* KEY_F17 187 */ + SDL_SCANCODE_F18, /* KEY_F18 188 */ + SDL_SCANCODE_F19, /* KEY_F19 189 */ + SDL_SCANCODE_F20, /* KEY_F20 190 */ + SDL_SCANCODE_F21, /* KEY_F21 191 */ + SDL_SCANCODE_F22, /* KEY_F22 192 */ + SDL_SCANCODE_F23, /* KEY_F23 193 */ + SDL_SCANCODE_F24, /* KEY_F24 194 */ + SDL_SCANCODE_UNKNOWN, /* 195 */ + SDL_SCANCODE_UNKNOWN, /* 196 */ + SDL_SCANCODE_UNKNOWN, /* 197 */ + SDL_SCANCODE_UNKNOWN, /* 198 */ + SDL_SCANCODE_UNKNOWN, /* 199 */ + SDL_SCANCODE_UNKNOWN, /* KEY_PLAYCD 200 */ + SDL_SCANCODE_UNKNOWN, /* KEY_PAUSECD 201 */ + SDL_SCANCODE_UNKNOWN, /* KEY_PROG3 202 */ + SDL_SCANCODE_UNKNOWN, /* KEY_PROG4 203 */ + SDL_SCANCODE_UNKNOWN, /* KEY_DASHBOARD 204 AL Dashboard */ + SDL_SCANCODE_UNKNOWN, /* KEY_SUSPEND 205 */ + SDL_SCANCODE_UNKNOWN, /* KEY_CLOSE 206 AC Close */ + SDL_SCANCODE_UNKNOWN, /* KEY_PLAY 207 */ + SDL_SCANCODE_UNKNOWN, /* KEY_FASTFORWARD 208 */ + SDL_SCANCODE_UNKNOWN, /* KEY_BASSBOOST 209 */ + SDL_SCANCODE_UNKNOWN, /* KEY_PRINT 210 AC Print */ + SDL_SCANCODE_UNKNOWN, /* KEY_HP 211 */ + SDL_SCANCODE_UNKNOWN, /* KEY_CAMERA 212 */ + SDL_SCANCODE_UNKNOWN, /* KEY_SOUND 213 */ + SDL_SCANCODE_UNKNOWN, /* KEY_QUESTION 214 */ + SDL_SCANCODE_UNKNOWN, /* KEY_EMAIL 215 */ + SDL_SCANCODE_UNKNOWN, /* KEY_CHAT 216 */ + SDL_SCANCODE_UNKNOWN, /* KEY_SEARCH 217 */ + SDL_SCANCODE_UNKNOWN, /* KEY_CONNECT 218 */ + SDL_SCANCODE_UNKNOWN, /* KEY_FINANCE 219 AL Checkbook/Finance */ + SDL_SCANCODE_UNKNOWN, /* KEY_SPORT 220 */ + SDL_SCANCODE_UNKNOWN, /* KEY_SHOP 221 */ + SDL_SCANCODE_UNKNOWN, /* KEY_ALTERASE 222 */ + SDL_SCANCODE_UNKNOWN, /* KEY_CANCEL 223 AC Cancel */ + SDL_SCANCODE_UNKNOWN, /* KEY_BRIGHTNESSDOWN 224 */ + SDL_SCANCODE_UNKNOWN, /* KEY_BRIGHTNESSUP 225 */ + SDL_SCANCODE_UNKNOWN, /* KEY_MEDIA 226 */ + SDL_SCANCODE_UNKNOWN, /* KEY_SWITCHVIDEOMODE 227 Cycle between available video outputs (Monitor/LCD/TV-out/etc) */ + SDL_SCANCODE_UNKNOWN, /* KEY_KBDILLUMTOGGLE 228 */ + SDL_SCANCODE_UNKNOWN, /* KEY_KBDILLUMDOWN 229 */ + SDL_SCANCODE_UNKNOWN, /* KEY_KBDILLUMUP 230 */ + SDL_SCANCODE_UNKNOWN, /* KEY_SEND 231 AC Send */ + SDL_SCANCODE_UNKNOWN, /* KEY_REPLY 232 AC Reply */ + SDL_SCANCODE_UNKNOWN, /* KEY_FORWARDMAIL 233 AC Forward Msg */ + SDL_SCANCODE_UNKNOWN, /* KEY_SAVE 234 AC Save */ + SDL_SCANCODE_UNKNOWN, /* KEY_DOCUMENTS 235 */ + SDL_SCANCODE_UNKNOWN, /* KEY_BATTERY 236 */ + SDL_SCANCODE_UNKNOWN, /* KEY_BLUETOOTH 237 */ + SDL_SCANCODE_UNKNOWN, /* KEY_WLAN 238 */ + SDL_SCANCODE_UNKNOWN, /* KEY_UWB 239 */ + SDL_SCANCODE_UNKNOWN, /* KEY_UNKNOWN 240 */ + SDL_SCANCODE_UNKNOWN, /* KEY_VIDEO_NEXT 241 drive next video source */ + SDL_SCANCODE_UNKNOWN, /* KEY_VIDEO_PREV 242 drive previous video source */ + SDL_SCANCODE_UNKNOWN, /* KEY_BRIGHTNESS_CYCLE 243 brightness up, after max is min */ + SDL_SCANCODE_UNKNOWN, /* KEY_BRIGHTNESS_ZERO 244 brightness off, use ambient */ + SDL_SCANCODE_UNKNOWN, /* KEY_DISPLAY_OFF 245 display device to off state */ + SDL_SCANCODE_UNKNOWN, /* KEY_WIMAX 246 */ + SDL_SCANCODE_UNKNOWN, /* KEY_RFKILL 247 Key that controls all radios */ + SDL_SCANCODE_UNKNOWN, /* KEY_MICMUTE 248 Mute / unmute the microphone */ +}; + +static Uint8 EVDEV_MouseButtons[] = { + SDL_BUTTON_LEFT, /* BTN_LEFT 0x110 */ + SDL_BUTTON_RIGHT, /* BTN_RIGHT 0x111 */ + SDL_BUTTON_MIDDLE, /* BTN_MIDDLE 0x112 */ + SDL_BUTTON_X1, /* BTN_SIDE 0x113 */ + SDL_BUTTON_X2, /* BTN_EXTRA 0x114 */ + SDL_BUTTON_X2 + 1, /* BTN_FORWARD 0x115 */ + SDL_BUTTON_X2 + 2, /* BTN_BACK 0x116 */ + SDL_BUTTON_X2 + 3 /* BTN_TASK 0x117 */ +}; + +int +SDL_EVDEV_Init(void) +{ + int retval = 0; + + if (_this == NULL) { + _this = (SDL_EVDEV_PrivateData *) SDL_calloc(1, sizeof(*_this)); + if(_this == NULL) { + return SDL_OutOfMemory(); + } + +#if SDL_USE_LIBUDEV + if (SDL_UDEV_Init() < 0) { + SDL_free(_this); + _this = NULL; + return -1; + } + + /* Set up the udev callback */ + if ( SDL_UDEV_AddCallback(SDL_EVDEV_udev_callback) < 0) { + SDL_EVDEV_Quit(); + return -1; + } + + /* Force a scan to build the initial device list */ + SDL_UDEV_Scan(); +#else + /* TODO: Scan the devices manually, like a caveman */ +#endif /* SDL_USE_LIBUDEV */ + + } + + _this->ref_count += 1; + + return retval; +} + +void +SDL_EVDEV_Quit(void) +{ + if (_this == NULL) { + return; + } + + _this->ref_count -= 1; + + if (_this->ref_count < 1) { + +#if SDL_USE_LIBUDEV + SDL_UDEV_DelCallback(SDL_EVDEV_udev_callback); + SDL_UDEV_Quit(); +#endif /* SDL_USE_LIBUDEV */ + + /* Remove existing devices */ + while(_this->first != NULL) { + SDL_EVDEV_device_removed(_this->first->path); + } + + SDL_assert(_this->first == NULL); + SDL_assert(_this->last == NULL); + SDL_assert(_this->numdevices == 0); + + SDL_free(_this); + _this = NULL; + } +} + +void SDL_EVDEV_udev_callback(SDL_UDEV_deviceevent udev_type, SDL_UDEV_deviceclass udev_class, const char *devpath) +{ + SDL_EVDEV_deviceclass devclass; + + if (devpath == NULL) { + return; + } + + switch( udev_class ) + { + case SDL_UDEV_DEVICE_MOUSE: + devclass = SDL_EVDEV_DEVICE_MOUSE; + break; + + case SDL_UDEV_DEVICE_KEYBOARD: + devclass = SDL_EVDEV_DEVICE_KEYBOARD; + break; + + default: + return; + } + + switch( udev_type ) + { + case SDL_UDEV_DEVICEADDED: + SDL_EVDEV_device_added(devclass, devpath); + break; + + case SDL_UDEV_DEVICEREMOVED: + SDL_EVDEV_device_removed(devpath); + break; + + default: + break; + + } + +} + +void +SDL_EVDEV_Poll(void) +{ + struct input_event events[32]; + int i, len; + SDL_evdevlist_item *item; + SDL_Scancode scan_code; + int mouse_button; + SDL_Mouse *mouse; + +#if SDL_USE_LIBUDEV + SDL_UDEV_Poll(); +#endif + + for (item = _this->first; item != NULL; item = item->next) { + while ((len = read(item->fd, events, (sizeof events))) > 0) { + len /= sizeof(events[0]); + for (i = 0; i < len; ++i) { + switch(item->devclass) { + case SDL_EVDEV_DEVICE_KEYBOARD: + switch (events[i].type) { + case EV_KEY: + scan_code = SDL_EVDEV_translate_keycode(events[i].code); + if (scan_code != SDL_SCANCODE_UNKNOWN) { + if (events[i].value == 0) { + SDL_SendKeyboardKey(SDL_RELEASED, scan_code); + } + else if (events[i].value == 1) { + SDL_SendKeyboardKey(SDL_PRESSED, scan_code); + } + else if (events[i].value == 2) { + /* Key repeated */ + SDL_SendKeyboardKey(SDL_PRESSED, scan_code); + } + } + break; + + default: + break; + } + break; /* SDL_EVDEV_DEVICE_KEYBOARD */ + + case SDL_EVDEV_DEVICE_MOUSE: + mouse = SDL_GetMouse(); + switch (events[i].type) { + case EV_KEY: + mouse_button = events[i].code - BTN_MOUSE; + if (mouse_button >= 0 && mouse_button < SDL_arraysize(EVDEV_MouseButtons)) { + if (events[i].value == 0) { + SDL_SendMouseButton(mouse->focus, mouse->mouseID, SDL_RELEASED, EVDEV_MouseButtons[mouse_button]); + } + else if (events[i].value == 1) { + SDL_SendMouseButton(mouse->focus, mouse->mouseID, SDL_PRESSED, EVDEV_MouseButtons[mouse_button]); + } + } + break; + case EV_ABS: + switch(events[i].code) { + case ABS_X: + SDL_SendMouseMotion(mouse->focus, mouse->mouseID, SDL_FALSE, events[i].value, mouse->y); + break; + case ABS_Y: + SDL_SendMouseMotion(mouse->focus, mouse->mouseID, SDL_FALSE, mouse->x, events[i].value); + break; + default: + break; + } + break; + case EV_REL: + switch(events[i].code) { + case REL_X: + SDL_SendMouseMotion(mouse->focus, mouse->mouseID, SDL_TRUE, events[i].value, 0); + break; + case REL_Y: + SDL_SendMouseMotion(mouse->focus, mouse->mouseID, SDL_TRUE, 0, events[i].value); + break; + case REL_WHEEL: + SDL_SendMouseWheel(mouse->focus, mouse->mouseID, 0, events[i].value); + break; + case REL_HWHEEL: + SDL_SendMouseWheel(mouse->focus, mouse->mouseID, events[i].value, 0); + break; + default: + break; + } + break; + default: + break; + } + break; /* SDL_EVDEV_DEVICE_MOUSE */ + + default: + break; + } + + + /* Handle events not specific to any type of device */ + switch (events[i].type) { + case EV_SYN: + switch (events[i].code) { + case SYN_DROPPED : + SDL_EVDEV_sync_device(item); + break; + default: + break; + } + } + + } + } + } +} + +static SDL_Scancode +SDL_EVDEV_translate_keycode(int keycode) +{ + SDL_Scancode scancode = SDL_SCANCODE_UNKNOWN; + + if (keycode < SDL_arraysize(EVDEV_Keycodes)) { + scancode = EVDEV_Keycodes[keycode]; + } + if (scancode == SDL_SCANCODE_UNKNOWN) { + SDL_Log("The key you just pressed is not recognized by SDL. To help get this fixed, please report this to the SDL mailing list EVDEV KeyCode %d \n", keycode); + } + return scancode; +} + +static void +SDL_EVDEV_sync_device(SDL_evdevlist_item *item) +{ + /* TODO: get full state of device and report whatever is required */ +} + +static int +SDL_EVDEV_device_added(const SDL_UDEV_deviceclass devclass, const char *devpath) +{ + SDL_evdevlist_item *item; + + /* Check to make sure it's not already in list. */ + for (item = _this->first; item != NULL; item = item->next) { + if (strcmp(devpath, item->path) == 0) { + return -1; /* already have this one */ + } + } + + item = (SDL_evdevlist_item *) SDL_calloc(1, sizeof (SDL_evdevlist_item)); + if (item == NULL) { + return SDL_OutOfMemory(); + } + + item->devclass = devclass; + + + item->fd = open(devpath, O_RDONLY, 0); + if (item->fd < 0) { + SDL_free(item); + return SDL_SetError("Unable to open %s", devpath); + } + + item->path = SDL_strdup(devpath); + if (item->path == NULL) { + close(item->fd); + SDL_free(item); + return SDL_OutOfMemory(); + } + + /* Non blocking read mode */ + fcntl(item->fd, F_SETFL, O_NONBLOCK); + + if (_this->last == NULL) { + _this->first = _this->last = item; + } else { + _this->last->next = item; + _this->last = item; + } + + SDL_EVDEV_sync_device(item); + + return _this->numdevices++; +} + + +static int +SDL_EVDEV_device_removed(const char *devpath) +{ + SDL_evdevlist_item *item; + SDL_evdevlist_item *prev = NULL; + + for (item = _this->first; item != NULL; item = item->next) { + /* found it, remove it. */ + if ( strcmp(devpath, item->path) ==0 ) { + if (prev != NULL) { + prev->next = item->next; + } else { + SDL_assert(_this->first == item); + _this->first = item->next; + } + if (item == _this->last) { + _this->last = prev; + } + close(item->fd); + SDL_free(item->path); + SDL_free(item); + _this->numdevices--; + return 0; + } + prev = item; + } + + return -1; +} + +#endif /* SDL_INPUT_LINUXEV */ + +/* vi: set ts=4 sw=4 expandtab: */ diff --git a/src/input/evdev/SDL_evdev.h b/src/input/evdev/SDL_evdev.h new file mode 100644 index 000000000..5a6038f61 --- /dev/null +++ b/src/input/evdev/SDL_evdev.h @@ -0,0 +1,65 @@ +/* + Simple DirectMedia Layer + Copyright (C) 1997-2013 Sam Lantinga + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. +*/ + +#include + +#include "SDL_config.h" + +#ifndef _SDL_evdev_h +#define _SDL_evdev_h + +#ifdef SDL_INPUT_LINUXEV + +#include "SDL_events.h" +#include + +typedef enum +{ + SDL_EVDEV_DEVICE_MOUSE = 0x0001, + SDL_EVDEV_DEVICE_KEYBOARD +} SDL_EVDEV_deviceclass; + +typedef struct SDL_evdevlist_item +{ + char *path; + int fd; + SDL_EVDEV_deviceclass devclass; + struct SDL_evdevlist_item *next; +} SDL_evdevlist_item; + +typedef struct SDL_EVDEV_PrivateData +{ + SDL_evdevlist_item *first; + SDL_evdevlist_item *last; + int numdevices; + int ref_count; +} SDL_EVDEV_PrivateData; + +extern int SDL_EVDEV_Init(void); +extern void SDL_EVDEV_Quit(void); +extern void SDL_EVDEV_Poll(void); + + +#endif /* SDL_INPUT_LINUXEV */ + +#endif /* _SDL_evdev_h */ + +/* vi: set ts=4 sw=4 expandtab: */ diff --git a/src/video/SDL_egl.c b/src/video/SDL_egl.c index 522516572..1501a748a 100644 --- a/src/video/SDL_egl.c +++ b/src/video/SDL_egl.c @@ -25,13 +25,20 @@ #include "SDL_sysvideo.h" #include "SDL_egl.h" -#define DEFAULT_EGL "libEGL.so" -#define DEFAULT_OGL_ES2 "libGLESv2.so" -#define DEFAULT_OGL_ES_PVR "libGLES_CM.so" -#define DEFAULT_OGL_ES "libGLESv1_CM.so" +#if SDL_VIDEO_DRIVER_RPI +#define DEFAULT_EGL "/opt/vc/lib/libEGL.so" +#define DEFAULT_OGL_ES2 "/opt/vc/lib/libGLESv2.so" +#define DEFAULT_OGL_ES_PVR "/opt/vc/lib/libGLES_CM.so" +#define DEFAULT_OGL_ES "/opt/vc/lib/libGLESv1_CM.so" +#else +#define DEFAULT_EGL "libEGL.so.1" +#define DEFAULT_OGL_ES2 "libGLESv2.so.2" +#define DEFAULT_OGL_ES_PVR "libGLES_CM.so.1" +#define DEFAULT_OGL_ES "libGLESv1_CM.so.1" +#endif /* SDL_VIDEO_DRIVER_RPI */ #define LOAD_FUNC(NAME) \ -*((void**)&_this->egl_data->NAME) = dlsym(handle, #NAME); \ +*((void**)&_this->egl_data->NAME) = dlsym(dll_handle, #NAME); \ if (!_this->egl_data->NAME) \ { \ return SDL_SetError("Could not retrieve EGL function " #NAME); \ @@ -88,9 +95,10 @@ SDL_EGL_UnloadLibrary(_THIS) } int -SDL_EGL_LoadLibrary(_THIS, const char *path, NativeDisplayType native_display) +SDL_EGL_LoadLibrary(_THIS, const char *egl_path, NativeDisplayType native_display) { - void *handle; + void *dll_handle, *egl_dll_handle; /* The naming is counter intuitive, but hey, I just work here -- Gabriel */ + char *path; int dlopen_flags; if (_this->egl_data) { @@ -105,22 +113,44 @@ SDL_EGL_LoadLibrary(_THIS, const char *path, NativeDisplayType native_display) #else dlopen_flags = RTLD_LAZY; #endif - handle = dlopen(path, dlopen_flags); + + /* A funny thing, loading EGL.so first does not work on the Raspberry, so we load libGL* first */ + path = getenv("SDL_VIDEO_GL_DRIVER"); + egl_dll_handle = dlopen(path, dlopen_flags); + if ((path == NULL) | (egl_dll_handle == NULL)) { + if (_this->gl_config.major_version > 1) { + path = DEFAULT_OGL_ES2; + egl_dll_handle = dlopen(path, dlopen_flags); + } else { + path = DEFAULT_OGL_ES; + egl_dll_handle = dlopen(path, dlopen_flags); + if (egl_dll_handle == NULL) { + path = DEFAULT_OGL_ES_PVR; + egl_dll_handle = dlopen(path, dlopen_flags); + } + } + } + + if (egl_dll_handle == NULL) { + return SDL_SetError("Could not initialize OpenGL ES library: %s", dlerror()); + } + + /* Loading libGL* in the previous step took care of loading libEGL.so, but we future proof by double checking */ + dll_handle = dlopen(egl_path, dlopen_flags); /* Catch the case where the application isn't linked with EGL */ - if ((dlsym(handle, "eglChooseConfig") == NULL) && (path == NULL)) { - - dlclose(handle); + if ((dlsym(dll_handle, "eglChooseConfig") == NULL) && (egl_path == NULL)) { + dlclose(dll_handle); path = getenv("SDL_VIDEO_EGL_DRIVER"); if (path == NULL) { path = DEFAULT_EGL; } - handle = dlopen(path, dlopen_flags); - } - - if (handle == NULL) { - return SDL_SetError("Could not load OpenGL ES/EGL library"); + dll_handle = dlopen(path, dlopen_flags); } + if (dll_handle == NULL) { + return SDL_SetError("Could not load EGL library: %s", dlerror()); + } + _this->egl_data = (struct SDL_EGL_VideoData *) SDL_calloc(1, sizeof(SDL_EGL_VideoData)); if (!_this->egl_data) { return SDL_OutOfMemory(); @@ -153,36 +183,14 @@ SDL_EGL_LoadLibrary(_THIS, const char *path, NativeDisplayType native_display) return SDL_SetError("Could not initialize EGL"); } - _this->egl_data->egl_dll_handle = handle; - - path = getenv("SDL_VIDEO_GL_DRIVER"); - handle = dlopen(path, dlopen_flags); - if ((path == NULL) | (handle == NULL)) { - if (_this->gl_config.major_version > 1) { - path = DEFAULT_OGL_ES2; - handle = dlopen(path, dlopen_flags); - } else { - path = DEFAULT_OGL_ES; - handle = dlopen(path, dlopen_flags); - if (handle == NULL) { - path = DEFAULT_OGL_ES_PVR; - handle = dlopen(path, dlopen_flags); - } - } - } - - if (handle == NULL) { - return SDL_SetError("Could not initialize OpenGL ES library"); - } - - _this->gl_config.dll_handle = handle; + _this->gl_config.dll_handle = dll_handle; + _this->egl_data->egl_dll_handle = egl_dll_handle; _this->gl_config.driver_loaded = 1; if (path) { - strncpy(_this->gl_config.driver_path, path, - sizeof(_this->gl_config.driver_path) - 1); + strncpy(_this->gl_config.driver_path, path, sizeof(_this->gl_config.driver_path) - 1); } else { - strcpy(_this->gl_config.driver_path, ""); + strcpy(_this->gl_config.driver_path, ""); } /* We need to select a config here to satisfy some video backends such as X11 */ diff --git a/src/video/SDL_sysvideo.h b/src/video/SDL_sysvideo.h index 32966997d..bdb2a3130 100644 --- a/src/video/SDL_sysvideo.h +++ b/src/video/SDL_sysvideo.h @@ -363,6 +363,9 @@ extern VideoBootStrap Android_bootstrap; #if SDL_VIDEO_DRIVER_PSP extern VideoBootStrap PSP_bootstrap; #endif +#if SDL_VIDEO_DRIVER_RPI +extern VideoBootStrap RPI_bootstrap; +#endif #if SDL_VIDEO_DRIVER_DUMMY extern VideoBootStrap DUMMY_bootstrap; #endif diff --git a/src/video/SDL_video.c b/src/video/SDL_video.c index b5c31324d..cd40aeb48 100644 --- a/src/video/SDL_video.c +++ b/src/video/SDL_video.c @@ -80,6 +80,9 @@ static VideoBootStrap *bootstrap[] = { #if SDL_VIDEO_DRIVER_PSP &PSP_bootstrap, #endif +#if SDL_VIDEO_DRIVER_RPI + &RPI_bootstrap, +#endif #if SDL_VIDEO_DRIVER_DUMMY &DUMMY_bootstrap, #endif diff --git a/src/video/raspberry/SDL_rpievents.c b/src/video/raspberry/SDL_rpievents.c new file mode 100644 index 000000000..8c420fe71 --- /dev/null +++ b/src/video/raspberry/SDL_rpievents.c @@ -0,0 +1,45 @@ +/* + Simple DirectMedia Layer + Copyright (C) 1997-2013 Sam Lantinga + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. +*/ + +#include "SDL_config.h" + +#if SDL_VIDEO_DRIVER_RPI + +#include "../../events/SDL_sysevents.h" +#include "../../events/SDL_events_c.h" +#include "../../events/SDL_keyboard_c.h" +#include "SDL_rpivideo.h" +#include "SDL_rpievents_c.h" + +#ifdef SDL_INPUT_LINUXEV +#include "../../input/evdev/SDL_evdev.h" +#endif + +void RPI_PumpEvents(_THIS) +{ +#ifdef SDL_INPUT_LINUXEV + SDL_EVDEV_Poll(); +#endif + +} + +#endif /* SDL_VIDEO_DRIVER_RPI */ + diff --git a/src/video/raspberry/SDL_rpievents_c.h b/src/video/raspberry/SDL_rpievents_c.h new file mode 100644 index 000000000..54d3119d1 --- /dev/null +++ b/src/video/raspberry/SDL_rpievents_c.h @@ -0,0 +1,31 @@ +/* + Simple DirectMedia Layer + Copyright (C) 1997-2013 Sam Lantinga + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef _SDL_rpievents_c_h +#define _SDL_rpievents_c_h + +#include "SDL_rpivideo.h" + +void RPI_PumpEvents(_THIS); +void RPI_EventInit(_THIS); +void RPI_EventQuit(_THIS); + +#endif /* _SDL_rpievents_c_h */ diff --git a/src/video/raspberry/SDL_rpimouse.c b/src/video/raspberry/SDL_rpimouse.c new file mode 100644 index 000000000..429214b91 --- /dev/null +++ b/src/video/raspberry/SDL_rpimouse.c @@ -0,0 +1,277 @@ +/* + Simple DirectMedia Layer + Copyright (C) 1997-2013 Sam Lantinga + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. +*/ +#include "SDL_config.h" + +#if SDL_VIDEO_DRIVER_RPI + +#include "SDL_assert.h" +#include "SDL_surface.h" + +#include "SDL_rpivideo.h" +#include "SDL_rpimouse.h" + +#include "../SDL_sysvideo.h" +#include "../../events/SDL_mouse_c.h" +#include "../../events/default_cursor.h" + +/* Copied from vc_vchi_dispmanx.h which is bugged and tries to include a non existing file */ +/* Attributes changes flag mask */ +#define ELEMENT_CHANGE_LAYER (1<<0) +#define ELEMENT_CHANGE_OPACITY (1<<1) +#define ELEMENT_CHANGE_DEST_RECT (1<<2) +#define ELEMENT_CHANGE_SRC_RECT (1<<3) +#define ELEMENT_CHANGE_MASK_RESOURCE (1<<4) +#define ELEMENT_CHANGE_TRANSFORM (1<<5) +/* End copied from vc_vchi_dispmanx.h */ + +static SDL_Cursor *RPI_CreateDefaultCursor(void); +static SDL_Cursor *RPI_CreateCursor(SDL_Surface * surface, int hot_x, int hot_y); +static int RPI_ShowCursor(SDL_Cursor * cursor); +static void RPI_MoveCursor(SDL_Cursor * cursor); +static void RPI_FreeCursor(SDL_Cursor * cursor); +static void RPI_WarpMouse(SDL_Window * window, int x, int y); + +static SDL_Cursor * +RPI_CreateDefaultCursor(void) +{ + return SDL_CreateCursor(default_cdata, default_cmask, DEFAULT_CWIDTH, DEFAULT_CHEIGHT, DEFAULT_CHOTX, DEFAULT_CHOTY); +} + +/* Create a cursor from a surface */ +static SDL_Cursor * +RPI_CreateCursor(SDL_Surface * surface, int hot_x, int hot_y) +{ + RPI_CursorData *curdata; + SDL_Cursor *cursor; + int ret; + VC_RECT_T dst_rect; + Uint32 dummy; + + SDL_assert(surface->format->format == SDL_PIXELFORMAT_ARGB8888); + SDL_assert(surface->pitch == surface->w * 4); + + cursor = (SDL_Cursor *) SDL_calloc(1, sizeof(*cursor)); + curdata = (RPI_CursorData *) SDL_calloc(1, sizeof(*curdata)); + + curdata->hot_x = hot_x; + curdata->hot_y = hot_y; + curdata->w = surface->w; + curdata->h = surface->h; + + /* This usage is inspired by Wayland/Weston RPI code, how they figured this out is anyone's guess */ + curdata->resource = vc_dispmanx_resource_create( VC_IMAGE_ARGB8888, surface->w | (surface->pitch << 16), surface->h | (surface->h << 16), &dummy ); + SDL_assert(curdata->resource); + vc_dispmanx_rect_set( &dst_rect, 0, 0, curdata->w, curdata->h); + /* A note from Weston: + * vc_dispmanx_resource_write_data() ignores ifmt, + * rect.x, rect.width, and uses stride only for computing + * the size of the transfer as rect.height * stride. + * Therefore we can only write rows starting at x=0. + */ + ret = vc_dispmanx_resource_write_data( curdata->resource, VC_IMAGE_ARGB8888, surface->pitch, surface->pixels, &dst_rect ); + SDL_assert ( ret == DISPMANX_SUCCESS ); + + cursor->driverdata = curdata; + + return cursor; + +} + +/* Show the specified cursor, or hide if cursor is NULL */ +static int +RPI_ShowCursor(SDL_Cursor * cursor) +{ + int ret; + DISPMANX_UPDATE_HANDLE_T update; + RPI_CursorData *curdata; + VC_RECT_T src_rect, dst_rect; + SDL_Mouse *mouse; + SDL_VideoDisplay *display; + SDL_DisplayData *data; + VC_DISPMANX_ALPHA_T alpha = { DISPMANX_FLAGS_ALPHA_FROM_SOURCE /* flags */ , 255 /*opacity 0->255*/, 0 /* mask */ }; + + mouse = SDL_GetMouse(); + if (mouse == NULL) { + return -1; + } + + if (cursor == NULL) { + /* FIXME: We hide the current mouse's cursor, what we actually need is *_HideCursor */ + + if ( mouse->cur_cursor != NULL && mouse->cur_cursor->driverdata != NULL) { + curdata = (RPI_CursorData *) mouse->cur_cursor->driverdata; + if (curdata->element > DISPMANX_NO_HANDLE) { + update = vc_dispmanx_update_start( 10 ); + SDL_assert( update ); + ret = vc_dispmanx_element_remove( update, curdata->element ); + SDL_assert( ret == DISPMANX_SUCCESS ); + ret = vc_dispmanx_update_submit_sync( update ); + SDL_assert( ret == DISPMANX_SUCCESS ); + curdata->element = DISPMANX_NO_HANDLE; + } + } + return 0; + } + + curdata = (RPI_CursorData *) cursor->driverdata; + if (curdata == NULL) { + return -1; + } + + if (mouse->focus == NULL) { + return -1; + } + + display = SDL_GetDisplayForWindow(mouse->focus); + if (display == NULL) { + return -1; + } + + data = (SDL_DisplayData*) display->driverdata; + if (data == NULL) { + return -1; + } + + if (curdata->element == DISPMANX_NO_HANDLE) { + vc_dispmanx_rect_set( &src_rect, 0, 0, curdata->w << 16, curdata->h << 16 ); + vc_dispmanx_rect_set( &dst_rect, 0, 0, curdata->w, curdata->h); + + update = vc_dispmanx_update_start( 10 ); + SDL_assert( update ); + + curdata->element = vc_dispmanx_element_add( update, + data->dispman_display, + SDL_RPI_MOUSELAYER, // layer + &dst_rect, + curdata->resource, + &src_rect, + DISPMANX_PROTECTION_NONE, + &alpha, + DISPMANX_NO_HANDLE, // clamp + VC_IMAGE_ROT0 ); + SDL_assert( curdata->element > DISPMANX_NO_HANDLE); + ret = vc_dispmanx_update_submit_sync( update ); + SDL_assert( ret == DISPMANX_SUCCESS ); + } + + return 0; +} + +/* Free a window manager cursor */ +static void +RPI_FreeCursor(SDL_Cursor * cursor) +{ + int ret; + DISPMANX_UPDATE_HANDLE_T update; + RPI_CursorData *curdata; + + if (cursor != NULL) { + curdata = (RPI_CursorData *) cursor->driverdata; + + if (curdata != NULL) { + if (curdata->element != DISPMANX_NO_HANDLE) { + update = vc_dispmanx_update_start( 10 ); + SDL_assert( update ); + ret = vc_dispmanx_element_remove( update, curdata->element ); + SDL_assert( ret == DISPMANX_SUCCESS ); + ret = vc_dispmanx_update_submit_sync( update ); + SDL_assert( ret == DISPMANX_SUCCESS ); + } + + if (curdata->resource != DISPMANX_NO_HANDLE) { + ret = vc_dispmanx_resource_delete( curdata->resource ); + SDL_assert( ret == DISPMANX_SUCCESS ); + } + + SDL_free(cursor->driverdata); + } + SDL_free(cursor); + } +} + +/* Warp the mouse to (x,y) */ +static void +RPI_WarpMouse(SDL_Window * window, int x, int y) +{ + RPI_CursorData *curdata; + DISPMANX_UPDATE_HANDLE_T update; + int ret; + VC_RECT_T dst_rect; + SDL_Mouse *mouse = SDL_GetMouse(); + + if (mouse != NULL && mouse->cur_cursor != NULL && mouse->cur_cursor->driverdata != NULL) { + curdata = (RPI_CursorData *) mouse->cur_cursor->driverdata; + if (curdata->element != DISPMANX_NO_HANDLE) { + update = vc_dispmanx_update_start( 10 ); + SDL_assert( update ); + vc_dispmanx_rect_set( &dst_rect, x, y, curdata->w, curdata->h); + ret = vc_dispmanx_element_change_attributes( + update, + curdata->element, + ELEMENT_CHANGE_DEST_RECT, + 0, + 0, + &dst_rect, + NULL, + DISPMANX_NO_HANDLE, + DISPMANX_NO_ROTATE); + SDL_assert( ret == DISPMANX_SUCCESS ); + /* Submit asynchronously, otherwise the peformance suffers a lot */ + ret = vc_dispmanx_update_submit( update, 0, NULL ); + SDL_assert( ret == DISPMANX_SUCCESS ); + } + } +} + +void +RPI_InitMouse(_THIS) +{ + /* FIXME: Using UDEV it should be possible to scan all mice + * but there's no point in doing so as there's no multimice support...yet! + */ + SDL_Mouse *mouse = SDL_GetMouse(); + + mouse->CreateCursor = RPI_CreateCursor; + mouse->ShowCursor = RPI_ShowCursor; + mouse->MoveCursor = RPI_MoveCursor; + mouse->FreeCursor = RPI_FreeCursor; + mouse->WarpMouse = RPI_WarpMouse; + + SDL_SetDefaultCursor(RPI_CreateDefaultCursor()); +} + +void +RPI_QuitMouse(_THIS) +{ + +} + +/* This is called when a mouse motion event occurs */ +static void +RPI_MoveCursor(SDL_Cursor * cursor) +{ + SDL_Mouse *mouse = SDL_GetMouse(); + RPI_WarpMouse(mouse->focus, mouse->x, mouse->y); +} + +#endif /* SDL_VIDEO_DRIVER_RPI */ + +/* vi: set ts=4 sw=4 expandtab: */ diff --git a/src/video/raspberry/SDL_rpimouse.h b/src/video/raspberry/SDL_rpimouse.h new file mode 100644 index 000000000..aa8eec9ba --- /dev/null +++ b/src/video/raspberry/SDL_rpimouse.h @@ -0,0 +1,43 @@ +/* + Simple DirectMedia Layer + Copyright (C) 1997-2013 Sam Lantinga + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef _SDL_RPI_mouse_h +#define _SDL_RPI_mouse_h + +#include "../SDL_sysvideo.h" + +typedef struct _RPI_CursorData RPI_CursorData; +struct _RPI_CursorData +{ + DISPMANX_RESOURCE_HANDLE_T resource; + DISPMANX_ELEMENT_HANDLE_T element; + int hot_x, hot_y; + int w, h; +}; + +#define SDL_RPI_CURSORDATA(curs) RPI_CursorData *curdata = (RPI_CursorData *) ((curs) ? (curs)->driverdata : NULL) + +extern void RPI_InitMouse(_THIS); +extern void RPI_QuitMouse(_THIS); + +#endif /* _SDL_RPI_mouse_h */ + +/* vi: set ts=4 sw=4 expandtab: */ diff --git a/src/video/raspberry/SDL_rpiopengles.c b/src/video/raspberry/SDL_rpiopengles.c new file mode 100644 index 000000000..23c89fe0d --- /dev/null +++ b/src/video/raspberry/SDL_rpiopengles.c @@ -0,0 +1,42 @@ +/* + Simple DirectMedia Layer + Copyright (C) 1997-2013 Sam Lantinga + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. +*/ +#include "SDL_config.h" + +#if SDL_VIDEO_DRIVER_RPI && SDL_VIDEO_OPENGL_EGL + +#include "SDL_rpivideo.h" +#include "SDL_rpiopengles.h" + +/* EGL implementation of SDL OpenGL support */ + +int +RPI_GLES_LoadLibrary(_THIS, const char *path) { + return SDL_EGL_LoadLibrary(_this, path, EGL_DEFAULT_DISPLAY); +} + +SDL_EGL_CreateContext_impl(RPI) +SDL_EGL_SwapWindow_impl(RPI) +SDL_EGL_MakeCurrent_impl(RPI) + +#endif /* SDL_VIDEO_DRIVER_RPI && SDL_VIDEO_OPENGL_EGL */ + +/* vi: set ts=4 sw=4 expandtab: */ + diff --git a/src/video/raspberry/SDL_rpiopengles.h b/src/video/raspberry/SDL_rpiopengles.h new file mode 100644 index 000000000..deb4b2f36 --- /dev/null +++ b/src/video/raspberry/SDL_rpiopengles.h @@ -0,0 +1,48 @@ +/* + Simple DirectMedia Layer + Copyright (C) 1997-2013 Sam Lantinga + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. +*/ +#include "SDL_config.h" + +#ifndef _SDL_rpiopengles_h +#define _SDL_rpiopengles_h + +#if SDL_VIDEO_DRIVER_RPI && SDL_VIDEO_OPENGL_EGL + +#include "../SDL_sysvideo.h" +#include "../SDL_egl.h" + +/* OpenGLES functions */ +#define RPI_GLES_GetAttribute SDL_EGL_GetAttribute +#define RPI_GLES_GetProcAddress SDL_EGL_GetProcAddress +#define RPI_GLES_UnloadLibrary SDL_EGL_UnloadLibrary +#define RPI_GLES_SetSwapInterval SDL_EGL_SetSwapInterval +#define RPI_GLES_GetSwapInterval SDL_EGL_GetSwapInterval +#define RPI_GLES_DeleteContext SDL_EGL_DeleteContext + +extern int RPI_GLES_LoadLibrary(_THIS, const char *path); +extern SDL_GLContext RPI_GLES_CreateContext(_THIS, SDL_Window * window); +extern void RPI_GLES_SwapWindow(_THIS, SDL_Window * window); +extern int RPI_GLES_MakeCurrent(_THIS, SDL_Window * window, SDL_GLContext context); + +#endif /* SDL_VIDEO_DRIVER_RPI && SDL_VIDEO_OPENGL_EGL */ + +#endif /* _SDL_rpiopengles_h */ + +/* vi: set ts=4 sw=4 expandtab: */ diff --git a/src/video/raspberry/SDL_rpivideo.c b/src/video/raspberry/SDL_rpivideo.c new file mode 100644 index 000000000..ae9dc7dc4 --- /dev/null +++ b/src/video/raspberry/SDL_rpivideo.c @@ -0,0 +1,361 @@ +/* + Simple DirectMedia Layer + Copyright (C) 1997-2013 Sam Lantinga + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. +*/ + +#include "SDL_config.h" + +#if SDL_VIDEO_DRIVER_RPI + +/* References + * http://elinux.org/RPi_VideoCore_APIs + * https://github.com/raspberrypi/firmware/blob/master/opt/vc/src/hello_pi/hello_triangle/triangle.c + * http://cgit.freedesktop.org/wayland/weston/tree/src/rpi-renderer.c + * http://cgit.freedesktop.org/wayland/weston/tree/src/compositor-rpi.c + */ + +/* SDL internals */ +#include "../SDL_sysvideo.h" +#include "SDL_version.h" +#include "SDL_syswm.h" +#include "SDL_loadso.h" +#include "SDL_events.h" +#include "../../events/SDL_mouse_c.h" +#include "../../events/SDL_keyboard_c.h" + +#ifdef SDL_INPUT_LINUXEV +#include "../../input/evdev/SDL_evdev.h" +#endif + +/* RPI declarations */ +#include "SDL_rpivideo.h" +#include "SDL_rpievents_c.h" +#include "SDL_rpiopengles.h" +#include "SDL_rpimouse.h" + +static int +RPI_Available(void) +{ + return 1; +} + +static void +RPI_Destroy(SDL_VideoDevice * device) +{ + /* SDL_VideoData *phdata = (SDL_VideoData *) device->driverdata; */ + + if (device->driverdata != NULL) { + device->driverdata = NULL; + } +} + +static SDL_VideoDevice * +RPI_Create() +{ + SDL_VideoDevice *device; + SDL_VideoData *phdata; + + /* Initialize SDL_VideoDevice structure */ + device = (SDL_VideoDevice *) SDL_calloc(1, sizeof(SDL_VideoDevice)); + if (device == NULL) { + SDL_OutOfMemory(); + return NULL; + } + + /* Initialize internal data */ + phdata = (SDL_VideoData *) SDL_calloc(1, sizeof(SDL_VideoData)); + if (phdata == NULL) { + SDL_OutOfMemory(); + SDL_free(device); + return NULL; + } + + device->driverdata = phdata; + + /* Setup amount of available displays and current display */ + device->num_displays = 0; + + /* Set device free function */ + device->free = RPI_Destroy; + + /* Setup all functions which we can handle */ + device->VideoInit = RPI_VideoInit; + device->VideoQuit = RPI_VideoQuit; + device->GetDisplayModes = RPI_GetDisplayModes; + device->SetDisplayMode = RPI_SetDisplayMode; + device->CreateWindow = RPI_CreateWindow; + device->CreateWindowFrom = RPI_CreateWindowFrom; + device->SetWindowTitle = RPI_SetWindowTitle; + device->SetWindowIcon = RPI_SetWindowIcon; + device->SetWindowPosition = RPI_SetWindowPosition; + device->SetWindowSize = RPI_SetWindowSize; + device->ShowWindow = RPI_ShowWindow; + device->HideWindow = RPI_HideWindow; + device->RaiseWindow = RPI_RaiseWindow; + device->MaximizeWindow = RPI_MaximizeWindow; + device->MinimizeWindow = RPI_MinimizeWindow; + device->RestoreWindow = RPI_RestoreWindow; + device->SetWindowGrab = RPI_SetWindowGrab; + device->DestroyWindow = RPI_DestroyWindow; + device->GetWindowWMInfo = RPI_GetWindowWMInfo; + device->GL_LoadLibrary = RPI_GLES_LoadLibrary; + device->GL_GetProcAddress = RPI_GLES_GetProcAddress; + device->GL_UnloadLibrary = RPI_GLES_UnloadLibrary; + device->GL_CreateContext = RPI_GLES_CreateContext; + device->GL_MakeCurrent = RPI_GLES_MakeCurrent; + device->GL_SetSwapInterval = RPI_GLES_SetSwapInterval; + device->GL_GetSwapInterval = RPI_GLES_GetSwapInterval; + device->GL_SwapWindow = RPI_GLES_SwapWindow; + device->GL_DeleteContext = RPI_GLES_DeleteContext; + + device->PumpEvents = RPI_PumpEvents; + + return device; +} + +VideoBootStrap RPI_bootstrap = { + "RPI", + "RPI Video Driver", + RPI_Available, + RPI_Create +}; + +/*****************************************************************************/ +/* SDL Video and Display initialization/handling functions */ +/*****************************************************************************/ +int +RPI_VideoInit(_THIS) +{ + SDL_VideoDisplay display; + SDL_DisplayMode current_mode; + uint32_t w,h; + + /* Initialize BCM Host */ + bcm_host_init(); + + SDL_zero(current_mode); + + if (graphics_get_display_size( 0, &w, &h) < 0) { + return -1; + } + + current_mode.w = w; + current_mode.h = h; + /* FIXME: Is there a way to tell the actual refresh rate? */ + current_mode.refresh_rate = 60; + /* 32 bpp for default */ + current_mode.format = SDL_PIXELFORMAT_ABGR8888; + + current_mode.driverdata = NULL; + + SDL_zero(display); + display.desktop_mode = current_mode; + display.current_mode = current_mode; + + SDL_DisplayData *data; + + /* Allocate display internal data */ + data = (SDL_DisplayData *) SDL_calloc(1, sizeof(SDL_DisplayData)); + if (data == NULL) { + return SDL_OutOfMemory(); + } + + data->dispman_display = vc_dispmanx_display_open( 0 /* LCD */); + + display.driverdata = data; + + SDL_AddVideoDisplay(&display); + +#ifdef SDL_INPUT_LINUXEV + SDL_EVDEV_Init(); +#endif + + RPI_InitMouse(_this); + + return 1; +} + +void +RPI_VideoQuit(_THIS) +{ +#ifdef SDL_INPUT_LINUXEV + SDL_EVDEV_Quit(); +#endif +} + +void +RPI_GetDisplayModes(_THIS, SDL_VideoDisplay * display) +{ + /* Only one display mode available, the current one */ + SDL_AddDisplayMode(display, &display->current_mode); +} + +int +RPI_SetDisplayMode(_THIS, SDL_VideoDisplay * display, SDL_DisplayMode * mode) +{ + return 0; +} + +int +RPI_CreateWindow(_THIS, SDL_Window * window) +{ + SDL_WindowData *wdata; + SDL_VideoDisplay *display; + SDL_DisplayData *displaydata; + VC_RECT_T dst_rect; + VC_RECT_T src_rect; + VC_DISPMANX_ALPHA_T dispman_alpha; + DISPMANX_UPDATE_HANDLE_T dispman_update; + + /* Disable alpha, otherwise the app looks composed with whatever dispman is showing (X11, console,etc) */ + dispman_alpha.flags = DISPMANX_FLAGS_ALPHA_FIXED_ALL_PIXELS; + dispman_alpha.opacity = 0xFF; + dispman_alpha.mask = 0; + + /* Allocate window internal data */ + wdata = (SDL_WindowData *) SDL_calloc(1, sizeof(SDL_WindowData)); + if (wdata == NULL) { + return SDL_OutOfMemory(); + } + display = SDL_GetDisplayForWindow(window); + displaydata = (SDL_DisplayData *) display->driverdata; + + /* Windows have one size for now */ + window->w = display->desktop_mode.w; + window->h = display->desktop_mode.h; + + /* OpenGL ES is the law here, buddy */ + window->flags |= SDL_WINDOW_OPENGL; + + /* Create a dispman element and associate a window to it */ + dst_rect.x = 0; + dst_rect.y = 0; + dst_rect.width = window->w; + dst_rect.height = window->h; + + src_rect.x = 0; + src_rect.y = 0; + src_rect.width = window->w << 16; + src_rect.height = window->h << 16; + + dispman_update = vc_dispmanx_update_start( 0 ); + wdata->dispman_window.element = vc_dispmanx_element_add ( dispman_update, displaydata->dispman_display, SDL_RPI_VIDEOLAYER /* layer */, &dst_rect, 0/*src*/, &src_rect, DISPMANX_PROTECTION_NONE, &dispman_alpha /*alpha*/, 0/*clamp*/, 0/*transform*/); + wdata->dispman_window.width = window->w; + wdata->dispman_window.height = window->h; + vc_dispmanx_update_submit_sync( dispman_update ); + + if (!_this->egl_data) { + if (SDL_GL_LoadLibrary(NULL) < 0) { + return -1; + } + } + wdata->egl_surface = SDL_EGL_CreateSurface(_this, (NativeWindowType) &wdata->dispman_window); + + if (wdata->egl_surface == EGL_NO_SURFACE) { + return SDL_SetError("Could not create GLES window surface"); + } + + /* Setup driver data for this window */ + window->driverdata = wdata; + + /* One window, it always has focus */ + SDL_SetMouseFocus(window); + SDL_SetKeyboardFocus(window); + + /* Window has been successfully created */ + return 0; +} + +int +RPI_CreateWindowFrom(_THIS, SDL_Window * window, const void *data) +{ + return -1; +} + +void +RPI_SetWindowTitle(_THIS, SDL_Window * window) +{ +} +void +RPI_SetWindowIcon(_THIS, SDL_Window * window, SDL_Surface * icon) +{ +} +void +RPI_SetWindowPosition(_THIS, SDL_Window * window) +{ +} +void +RPI_SetWindowSize(_THIS, SDL_Window * window) +{ +} +void +RPI_ShowWindow(_THIS, SDL_Window * window) +{ +} +void +RPI_HideWindow(_THIS, SDL_Window * window) +{ +} +void +RPI_RaiseWindow(_THIS, SDL_Window * window) +{ +} +void +RPI_MaximizeWindow(_THIS, SDL_Window * window) +{ +} +void +RPI_MinimizeWindow(_THIS, SDL_Window * window) +{ +} +void +RPI_RestoreWindow(_THIS, SDL_Window * window) +{ +} +void +RPI_SetWindowGrab(_THIS, SDL_Window * window, SDL_bool grabbed) +{ + +} +void +RPI_DestroyWindow(_THIS, SDL_Window * window) +{ +} + +/*****************************************************************************/ +/* SDL Window Manager function */ +/*****************************************************************************/ +SDL_bool +RPI_GetWindowWMInfo(_THIS, SDL_Window * window, struct SDL_SysWMinfo *info) +{ + if (info->version.major <= SDL_MAJOR_VERSION) { + return SDL_TRUE; + } else { + SDL_SetError("application not compiled with SDL %d.%d\n", + SDL_MAJOR_VERSION, SDL_MINOR_VERSION); + return SDL_FALSE; + } + + /* Failed to get window manager information */ + return SDL_FALSE; +} + +#endif /* SDL_VIDEO_DRIVER_RPI */ + +/* vi: set ts=4 sw=4 expandtab: */ diff --git a/src/video/raspberry/SDL_rpivideo.h b/src/video/raspberry/SDL_rpivideo.h new file mode 100644 index 000000000..6359badc9 --- /dev/null +++ b/src/video/raspberry/SDL_rpivideo.h @@ -0,0 +1,98 @@ +/* + Simple DirectMedia Layer + Copyright (C) 1997-2013 Sam Lantinga + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef __SDL_RPIVIDEO_H__ +#define __SDL_RPIVIDEO_H__ + +#include "SDL_config.h" +#include "../SDL_sysvideo.h" + +#include "bcm_host.h" +#include "GLES/gl.h" +#include "EGL/egl.h" +#include "EGL/eglext.h" + +typedef struct SDL_VideoData +{ + uint32_t egl_refcount; /* OpenGL ES reference count */ +} SDL_VideoData; + + +typedef struct SDL_DisplayData +{ + DISPMANX_DISPLAY_HANDLE_T dispman_display; +} SDL_DisplayData; + + +typedef struct SDL_WindowData +{ + EGL_DISPMANX_WINDOW_T dispman_window; +#if SDL_VIDEO_OPENGL_EGL + EGLSurface egl_surface; +#endif +} SDL_WindowData; + +#define SDL_RPI_VIDEOLAYER 10000 /* High enough so to occlude everything */ +#define SDL_RPI_MOUSELAYER SDL_RPI_VIDEOLAYER + 1 + + +/****************************************************************************/ +/* SDL_VideoDevice functions declaration */ +/****************************************************************************/ + +/* Display and window functions */ +int RPI_VideoInit(_THIS); +void RPI_VideoQuit(_THIS); +void RPI_GetDisplayModes(_THIS, SDL_VideoDisplay * display); +int RPI_SetDisplayMode(_THIS, SDL_VideoDisplay * display, SDL_DisplayMode * mode); +int RPI_CreateWindow(_THIS, SDL_Window * window); +int RPI_CreateWindowFrom(_THIS, SDL_Window * window, const void *data); +void RPI_SetWindowTitle(_THIS, SDL_Window * window); +void RPI_SetWindowIcon(_THIS, SDL_Window * window, SDL_Surface * icon); +void RPI_SetWindowPosition(_THIS, SDL_Window * window); +void RPI_SetWindowSize(_THIS, SDL_Window * window); +void RPI_ShowWindow(_THIS, SDL_Window * window); +void RPI_HideWindow(_THIS, SDL_Window * window); +void RPI_RaiseWindow(_THIS, SDL_Window * window); +void RPI_MaximizeWindow(_THIS, SDL_Window * window); +void RPI_MinimizeWindow(_THIS, SDL_Window * window); +void RPI_RestoreWindow(_THIS, SDL_Window * window); +void RPI_SetWindowGrab(_THIS, SDL_Window * window, SDL_bool grabbed); +void RPI_DestroyWindow(_THIS, SDL_Window * window); + +/* Window manager function */ +SDL_bool RPI_GetWindowWMInfo(_THIS, SDL_Window * window, + struct SDL_SysWMinfo *info); + +/* OpenGL/OpenGL ES functions */ +int RPI_GLES_LoadLibrary(_THIS, const char *path); +void *RPI_GLES_GetProcAddress(_THIS, const char *proc); +void RPI_GLES_UnloadLibrary(_THIS); +SDL_GLContext RPI_GLES_CreateContext(_THIS, SDL_Window * window); +int RPI_GLES_MakeCurrent(_THIS, SDL_Window * window, SDL_GLContext context); +int RPI_GLES_SetSwapInterval(_THIS, int interval); +int RPI_GLES_GetSwapInterval(_THIS); +void RPI_GLES_SwapWindow(_THIS, SDL_Window * window); +void RPI_GLES_DeleteContext(_THIS, SDL_GLContext context); + +#endif /* __SDL_RPIVIDEO_H__ */ + +/* vi: set ts=4 sw=4 expandtab: */