Skip to content
This repository has been archived by the owner. It is now read-only.
Permalink
Browse files

Removed completely non-portable event thread hack.

Next I'll be working on generalizing the event sources and making the event queue lock-free. :)
  • Loading branch information
slouken committed Jan 28, 2011
1 parent 8429907 commit 58af89008562c33ba221f0ee9451ca1ae71445d9
@@ -116,7 +116,6 @@ extern "C" {
#define SDL_INIT_JOYSTICK 0x00000200
#define SDL_INIT_HAPTIC 0x00001000
#define SDL_INIT_NOPARACHUTE 0x00100000 /**< Don't catch fatal signals */
#define SDL_INIT_EVENTTHREAD 0x01000000 /**< Not supported on all OS's */
#define SDL_INIT_EVERYTHING 0x0000FFFF
/*@}*/

@@ -278,8 +278,6 @@ extern DECLSPEC const char *SDLCALL SDL_GetVideoDriver(int index);
* \param driver_name Initialize a specific driver by name, or NULL for the
* default video driver.
*
* \param flags FIXME: Still needed?
*
* \return 0 on success, -1 on error
*
* This function initializes the video subsystem; setting up a connection
@@ -288,8 +286,7 @@ extern DECLSPEC const char *SDLCALL SDL_GetVideoDriver(int index);
*
* \sa SDL_VideoQuit()
*/
extern DECLSPEC int SDLCALL SDL_VideoInit(const char *driver_name,
Uint32 flags);
extern DECLSPEC int SDLCALL SDL_VideoInit(const char *driver_name);

/**
* \brief Shuts down the video subsystem.
@@ -59,7 +59,7 @@ SDL_InitSubSystem(Uint32 flags)
#if !SDL_VIDEO_DISABLED
/* Initialize the video/event subsystem */
if ((flags & SDL_INIT_VIDEO) && !(SDL_initialized & SDL_INIT_VIDEO)) {
if (SDL_VideoInit(NULL, (flags & SDL_INIT_EVENTTHREAD)) < 0) {
if (SDL_VideoInit(NULL) < 0) {
return (-1);
}
SDL_initialized |= SDL_INIT_VIDEO;
@@ -27,12 +27,12 @@
#include "SDL_events.h"
#include "SDL_syswm.h"
#include "SDL_thread.h"
#include "SDL_sysevents.h"
#include "SDL_events_c.h"
#include "../timer/SDL_timer_c.h"
#if !SDL_JOYSTICK_DISABLED
#include "../joystick/SDL_joystick_c.h"
#endif
#include "../video/SDL_sysvideo.h"

/* Public data -- the event filter */
SDL_EventFilter SDL_EventOK = NULL;
@@ -58,36 +58,6 @@ static struct
struct SDL_SysWMmsg wmmsg[MAXEVENTS];
} SDL_EventQ;

/* Private data -- event locking structure */
static struct
{
SDL_mutex *lock;
int safe;
} SDL_EventLock;

/* Thread functions */
static SDL_Thread *SDL_EventThread = NULL; /* Thread handle */
static SDL_threadID event_thread; /* The event thread id */

void
SDL_Lock_EventThread(void)
{
if (SDL_EventThread && (SDL_ThreadID() != event_thread)) {
/* Grab lock and spin until we're sure event thread stopped */
SDL_mutexP(SDL_EventLock.lock);
while (!SDL_EventLock.safe) {
SDL_Delay(1);
}
}
}

void
SDL_Unlock_EventThread(void)
{
if (SDL_EventThread && (SDL_ThreadID() != event_thread)) {
SDL_mutexV(SDL_EventLock.lock);
}
}

static __inline__ SDL_bool
SDL_ShouldPollJoystick()
@@ -102,120 +72,17 @@ SDL_ShouldPollJoystick()
return SDL_FALSE;
}

static int SDLCALL
SDL_GobbleEvents(void *unused)
{
event_thread = SDL_ThreadID();

while (SDL_EventQ.active) {
SDL_VideoDevice *_this = SDL_GetVideoDevice();

/* Get events from the video subsystem */
if (_this) {
_this->PumpEvents(_this);
}
#if !SDL_JOYSTICK_DISABLED
/* Check for joystick state change */
if (SDL_ShouldPollJoystick()) {
SDL_JoystickUpdate();
}
#endif

/* Give up the CPU for the rest of our timeslice */
SDL_EventLock.safe = 1;
SDL_Delay(1);

/* Check for event locking.
On the P of the lock mutex, if the lock is held, this thread
will wait until the lock is released before continuing. The
safe flag will be set, meaning that the other thread can go
about it's business. The safe flag is reset before the V,
so as soon as the mutex is free, other threads can see that
it's not safe to interfere with the event thread.
*/
SDL_mutexP(SDL_EventLock.lock);
SDL_EventLock.safe = 0;
SDL_mutexV(SDL_EventLock.lock);
}
event_thread = 0;
return (0);
}

static int
SDL_StartEventThread(Uint32 flags)
{
/* Reset everything to zero */
SDL_EventThread = NULL;
SDL_memset(&SDL_EventLock, 0, sizeof(SDL_EventLock));

/* Create the lock and set ourselves active */
#if !SDL_THREADS_DISABLED
SDL_EventQ.lock = SDL_CreateMutex();
if (SDL_EventQ.lock == NULL) {
return (-1);
}
#endif /* !SDL_THREADS_DISABLED */
SDL_EventQ.active = 1;

if ((flags & SDL_INIT_EVENTTHREAD) == SDL_INIT_EVENTTHREAD) {
SDL_EventLock.lock = SDL_CreateMutex();
if (SDL_EventLock.lock == NULL) {
return (-1);
}
SDL_EventLock.safe = 0;

#if (defined(__WIN32__) && !defined(_WIN32_WCE)) && !defined(HAVE_LIBC)
#undef SDL_CreateThread
SDL_EventThread =
SDL_CreateThread(SDL_GobbleEvents, NULL, NULL, NULL);
#else
SDL_EventThread = SDL_CreateThread(SDL_GobbleEvents, NULL);
#endif
if (SDL_EventThread == NULL) {
return (-1);
}
} else {
event_thread = 0;
}
return (0);
}

static void
SDL_StopEventThread(void)
{
SDL_EventQ.active = 0;
if (SDL_EventThread) {
SDL_WaitThread(SDL_EventThread, NULL);
SDL_EventThread = NULL;
SDL_DestroyMutex(SDL_EventLock.lock);
SDL_EventLock.lock = NULL;
}
if (SDL_EventQ.lock) {
SDL_DestroyMutex(SDL_EventQ.lock);
SDL_EventQ.lock = NULL;
}
}

SDL_threadID
SDL_EventThreadID(void)
{
return (event_thread);
}

/* Public functions */

void
SDL_StopEventLoop(void)
{
int i;

/* Halt the event thread, if running */
SDL_StopEventThread();

/* Shutdown event handlers */
SDL_KeyboardQuit();
SDL_MouseQuit();
SDL_QuitQuit();
if (SDL_EventQ.lock) {
SDL_DestroyMutex(SDL_EventQ.lock);
SDL_EventQ.lock = NULL;
}

/* Clean out EventQ */
SDL_EventQ.head = 0;
@@ -233,35 +100,27 @@ SDL_StopEventLoop(void)

/* This function (and associated calls) may be called more than once */
int
SDL_StartEventLoop(Uint32 flags)
SDL_StartEventLoop(void)
{
int retcode;

/* Clean out the event queue */
SDL_EventThread = NULL;
SDL_EventQ.lock = NULL;
SDL_StopEventLoop();

/* No filter to start with, process most event types */
SDL_EventOK = NULL;
SDL_EventState(SDL_SYSWMEVENT, SDL_DISABLE);

/* Initialize event handlers */
retcode = 0;
retcode += SDL_KeyboardInit();
retcode += SDL_MouseInit();
retcode += SDL_TouchInit();
retcode += SDL_QuitInit();
if (retcode < 0) {
/* We don't expect them to fail, but... */
/* Create the lock and set ourselves active */
#if !SDL_THREADS_DISABLED
SDL_EventQ.lock = SDL_CreateMutex();
if (SDL_EventQ.lock == NULL) {
return (-1);
}
#endif /* !SDL_THREADS_DISABLED */
SDL_EventQ.active = 1;

/* Create the lock and event thread */
if (SDL_StartEventThread(flags) < 0) {
SDL_StopEventLoop();
return (-1);
}
return (0);
}

@@ -420,20 +279,18 @@ SDL_FlushEvents(Uint32 minType, Uint32 maxType)
void
SDL_PumpEvents(void)
{
if (!SDL_EventThread) {
SDL_VideoDevice *_this = SDL_GetVideoDevice();
SDL_VideoDevice *_this = SDL_GetVideoDevice();

/* Get events from the video subsystem */
if (_this) {
_this->PumpEvents(_this);
}
/* Get events from the video subsystem */
if (_this) {
_this->PumpEvents(_this);
}
#if !SDL_JOYSTICK_DISABLED
/* Check for joystick state change */
if (SDL_ShouldPollJoystick()) {
SDL_JoystickUpdate();
}
#endif
/* Check for joystick state change */
if (SDL_ShouldPollJoystick()) {
SDL_JoystickUpdate();
}
#endif
}

/* Public functions */
@@ -29,15 +29,12 @@
#include "SDL_touch_c.h"
#include "SDL_windowevents_c.h"
#include "SDL_gesture_c.h"

/* Start and stop the event processing loop */
extern int SDL_StartEventLoop(Uint32 flags);
extern int SDL_StartEventLoop(void);
extern void SDL_StopEventLoop(void);
extern void SDL_QuitInterrupt(void);

extern void SDL_Lock_EventThread(void);
extern void SDL_Unlock_EventThread(void);
extern SDL_threadID SDL_EventThreadID(void);

extern int SDL_SendSysWMEvent(SDL_SysWMmsg * message);

extern int SDL_QuitInit(void);
@@ -26,7 +26,7 @@
#include "SDL_timer.h"
#include "SDL_events.h"
#include "SDL_events_c.h"
#include "SDL_sysevents.h"
#include "../video/SDL_sysvideo.h"


/* Global keyboard information */
@@ -30,12 +30,6 @@
#include "../events/SDL_events_c.h"
#endif

/* This is used for Quake III Arena */
#if SDL_EVENTS_DISABLED
#define SDL_Lock_EventThread()
#define SDL_Unlock_EventThread()
#endif

Uint8 SDL_numjoysticks = 0;
SDL_Joystick **SDL_joysticks = NULL;
static SDL_Joystick *default_joystick = NULL;
@@ -165,11 +159,9 @@ SDL_JoystickOpen(int device_index)

/* Add joystick to list */
++joystick->ref_count;
SDL_Lock_EventThread();
for (i = 0; SDL_joysticks[i]; ++i)
/* Skip to next joystick */ ;
SDL_joysticks[i] = joystick;
SDL_Unlock_EventThread();

return (joystick);
}
@@ -379,9 +371,6 @@ SDL_JoystickClose(SDL_Joystick * joystick)
return;
}

/* Lock the event queue - prevent joystick polling */
SDL_Lock_EventThread();

if (joystick == default_joystick) {
default_joystick = NULL;
}
@@ -396,9 +385,6 @@ SDL_JoystickClose(SDL_Joystick * joystick)
}
}

/* Let the event thread keep running */
SDL_Unlock_EventThread();

/* Free the data associated with this joystick */
if (joystick->axes) {
SDL_free(joystick->axes);
@@ -419,9 +405,7 @@ void
SDL_JoystickQuit(void)
{
/* Stop the event polling */
SDL_Lock_EventThread();
SDL_numjoysticks = 0;
SDL_Unlock_EventThread();

/* Quit the joystick setup */
SDL_SYS_JoystickQuit();

0 comments on commit 58af890

Please sign in to comment.