Started to merge @ZobyTwo cmake branch

thirdparty/SDL/src/timer/SDL_timer.c

@@ -0,0 +1,385 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2011 Sam Lantinga <slouken@libsdl.org>
+
+  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"
+
+#include "SDL_timer.h"
+#include "SDL_timer_c.h"
+#include "SDL_atomic.h"
+#include "SDL_cpuinfo.h"
+#include "SDL_thread.h"
+
+/* #define DEBUG_TIMERS */
+
+typedef struct _SDL_Timer
+{
+    int timerID;
+    SDL_TimerCallback callback;
+    void *param;
+    Uint32 interval;
+    Uint32 scheduled;
+    volatile SDL_bool canceled;
+    struct _SDL_Timer *next;
+} SDL_Timer;
+
+typedef struct _SDL_TimerMap
+{
+    int timerID;
+    SDL_Timer *timer;
+    struct _SDL_TimerMap *next;
+} SDL_TimerMap;
+
+/* The timers are kept in a sorted list */
+typedef struct {
+    /* Data used by the main thread */
+    SDL_Thread *thread;
+    SDL_atomic_t nextID;
+    SDL_TimerMap *timermap;
+    SDL_mutex *timermap_lock;
+
+    /* Padding to separate cache lines between threads */
+    char cache_pad[SDL_CACHELINE_SIZE];
+
+    /* Data used to communicate with the timer thread */
+    SDL_SpinLock lock;
+    SDL_sem *sem;
+    SDL_Timer * volatile pending;
+    SDL_Timer * volatile freelist;
+    volatile SDL_bool active;
+
+    /* List of timers - this is only touched by the timer thread */
+    SDL_Timer *timers;
+} SDL_TimerData;
+
+static SDL_TimerData SDL_timer_data;
+
+
+/* The idea here is that any thread might add a timer, but a single
+ * thread manages the active timer queue, sorted by scheduling time.
+ *
+ * Timers are removed by simply setting a canceled flag
+ */
+
+static void
+SDL_AddTimerInternal(SDL_TimerData *data, SDL_Timer *timer)
+{
+    SDL_Timer *prev, *curr;
+
+    prev = NULL;
+    for (curr = data->timers; curr; prev = curr, curr = curr->next) {
+        if ((Sint32)(timer->scheduled-curr->scheduled) < 0) {
+            break;
+        }
+    }
+
+    /* Insert the timer here! */
+    if (prev) {
+        prev->next = timer;
+    } else {
+        data->timers = timer;
+    }
+    timer->next = curr;
+}
+
+static int
+SDL_TimerThread(void *_data)
+{
+    SDL_TimerData *data = (SDL_TimerData *)_data;
+    SDL_Timer *pending;
+    SDL_Timer *current;
+    SDL_Timer *freelist_head = NULL;
+    SDL_Timer *freelist_tail = NULL;
+    Uint32 tick, now, interval, delay;
+
+    /* Threaded timer loop:
+     *  1. Queue timers added by other threads
+     *  2. Handle any timers that should dispatch this cycle
+     *  3. Wait until next dispatch time or new timer arrives
+     */
+    for ( ; ; ) {
+        /* Pending and freelist maintenance */
+        SDL_AtomicLock(&data->lock);
+        {
+            /* Get any timers ready to be queued */
+            pending = data->pending;
+            data->pending = NULL;
+
+            /* Make any unused timer structures available */
+            if (freelist_head) {
+                freelist_tail->next = data->freelist;
+                data->freelist = freelist_head;
+            }
+        }
+        SDL_AtomicUnlock(&data->lock);
+
+        /* Sort the pending timers into our list */
+        while (pending) {
+            current = pending;
+            pending = pending->next;
+            SDL_AddTimerInternal(data, current);
+        }
+        freelist_head = NULL;
+        freelist_tail = NULL;
+
+        /* Check to see if we're still running, after maintenance */
+        if (!data->active) {
+            break;
+        }
+
+        /* Initial delay if there are no timers */
+        delay = SDL_MUTEX_MAXWAIT;
+
+        tick = SDL_GetTicks();
+
+        /* Process all the pending timers for this tick */
+        while (data->timers) {
+            current = data->timers;
+
+            if ((Sint32)(tick-current->scheduled) < 0) {
+                /* Scheduled for the future, wait a bit */
+                delay = (current->scheduled - tick);
+                break;
+            }
+
+            /* We're going to do something with this timer */
+            data->timers = current->next;
+
+            if (current->canceled) {
+                interval = 0;
+            } else {
+                interval = current->callback(current->interval, current->param);
+            }
+
+            if (interval > 0) {
+                /* Reschedule this timer */
+                current->scheduled = tick + interval;
+                SDL_AddTimerInternal(data, current);
+            } else {
+                if (!freelist_head) {
+                    freelist_head = current;
+                }
+                if (freelist_tail) {
+                    freelist_tail->next = current;
+                }
+                freelist_tail = current;
+
+                current->canceled = SDL_TRUE;
+            }
+        }
+
+        /* Adjust the delay based on processing time */
+        now = SDL_GetTicks();
+        interval = (now - tick);
+        if (interval > delay) {
+            delay = 0;
+        } else {
+            delay -= interval;
+        }
+
+        /* Note that each time a timer is added, this will return
+           immediately, but we process the timers added all at once.
+           That's okay, it just means we run through the loop a few
+           extra times.
+         */
+        SDL_SemWaitTimeout(data->sem, delay);
+    }
+    return 0;
+}
+
+int
+SDL_TimerInit(void)
+{
+    SDL_TimerData *data = &SDL_timer_data;
+
+    if (!data->active) {
+        data->timermap_lock = SDL_CreateMutex();
+        if (!data->timermap_lock) {
+            return -1;
+        }
+
+        data->sem = SDL_CreateSemaphore(0);
+        if (!data->sem) {
+            SDL_DestroyMutex(data->timermap_lock);
+            return -1;
+        }
+
+        data->active = SDL_TRUE;
+        /* !!! FIXME: this is nasty. */
+#if (defined(__WIN32__) && !defined(_WIN32_WCE)) && !defined(HAVE_LIBC)
+#undef SDL_CreateThread
+        data->thread = SDL_CreateThread(SDL_TimerThread, data, NULL, NULL);
+#else
+        data->thread = SDL_CreateThread(SDL_TimerThread, data);
+#endif
+        if (!data->thread) {
+            SDL_TimerQuit();
+            return -1;
+        }
+
+        SDL_AtomicSet(&data->nextID, 1);
+    }
+    return 0;
+}
+
+void
+SDL_TimerQuit(void)
+{
+    SDL_TimerData *data = &SDL_timer_data;
+    SDL_Timer *timer;
+    SDL_TimerMap *entry;
+
+    if (data->active) {
+        data->active = SDL_FALSE;
+
+        /* Shutdown the timer thread */
+        if (data->thread) {
+            SDL_SemPost(data->sem);
+            SDL_WaitThread(data->thread, NULL);
+            data->thread = NULL;
+        }
+
+        SDL_DestroySemaphore(data->sem);
+        data->sem = NULL;
+
+        /* Clean up the timer entries */
+        while (data->timers) {
+            timer = data->timers;
+            data->timers = timer->next;
+            SDL_free(timer);
+        }
+        while (data->freelist) {
+            timer = data->freelist;
+            data->freelist = timer->next;
+            SDL_free(timer);
+        }
+        while (data->timermap) {
+            entry = data->timermap;
+            data->timermap = entry->next;
+            SDL_free(entry);
+        }
+
+        SDL_DestroyMutex(data->timermap_lock);
+        data->timermap_lock = NULL;
+    }
+}
+
+SDL_TimerID
+SDL_AddTimer(Uint32 interval, SDL_TimerCallback callback, void *param)
+{
+    SDL_TimerData *data = &SDL_timer_data;
+    SDL_Timer *timer;
+    SDL_TimerMap *entry;
+
+    if (!data->active) {
+        int status = 0;
+
+        SDL_AtomicLock(&data->lock);
+        if (!data->active) {
+            status = SDL_TimerInit();
+        }
+        SDL_AtomicUnlock(&data->lock);
+
+        if (status < 0) {
+            return 0;
+        }
+    }
+
+    SDL_AtomicLock(&data->lock);
+    timer = data->freelist;
+    if (timer) {
+        data->freelist = timer->next;
+    }
+    SDL_AtomicUnlock(&data->lock);
+
+    if (timer) {
+        SDL_RemoveTimer(timer->timerID);
+    } else {
+        timer = (SDL_Timer *)SDL_malloc(sizeof(*timer));
+        if (!timer) {
+            SDL_OutOfMemory();
+            return 0;
+        }
+    }
+    timer->timerID = SDL_AtomicIncRef(&data->nextID);
+    timer->callback = callback;
+    timer->param = param;
+    timer->interval = interval;
+    timer->scheduled = SDL_GetTicks() + interval;
+    timer->canceled = SDL_FALSE;
+ 
+    entry = (SDL_TimerMap *)SDL_malloc(sizeof(*entry));
+    if (!entry) {
+        SDL_free(timer);
+        SDL_OutOfMemory();
+        return 0;
+    }
+    entry->timer = timer;
+    entry->timerID = timer->timerID;
+
+    SDL_mutexP(data->timermap_lock);
+    entry->next = data->timermap;
+    data->timermap = entry;
+    SDL_mutexV(data->timermap_lock);
+
+    /* Add the timer to the pending list for the timer thread */
+    SDL_AtomicLock(&data->lock);
+    timer->next = data->pending;
+    data->pending = timer;
+    SDL_AtomicUnlock(&data->lock);
+
+    /* Wake up the timer thread if necessary */
+    SDL_SemPost(data->sem);
+
+    return entry->timerID;
+}
+
+SDL_bool
+SDL_RemoveTimer(SDL_TimerID id)
+{
+    SDL_TimerData *data = &SDL_timer_data;
+    SDL_TimerMap *prev, *entry;
+    SDL_bool canceled = SDL_FALSE;
+
+    /* Find the timer */
+    SDL_mutexP(data->timermap_lock);
+    prev = NULL;
+    for (entry = data->timermap; entry; prev = entry, entry = entry->next) {
+        if (entry->timerID == id) {
+            if (prev) {
+                prev->next = entry->next;
+            } else {
+                data->timermap = entry->next;
+            }
+            break;
+        }
+    }
+    SDL_mutexV(data->timermap_lock);
+
+    if (entry) {
+        if (!entry->timer->canceled) {
+            entry->timer->canceled = SDL_TRUE;
+            canceled = SDL_TRUE;
+        }
+        SDL_free(entry);
+    }
+    return canceled;
+}
+
+/* vi: set ts=4 sw=4 expandtab: */

thirdparty/SDL/src/timer/SDL_timer_c.h

@@ -0,0 +1,32 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2011 Sam Lantinga <slouken@libsdl.org>
+
+  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"
+
+/* Useful functions and variables from SDL_timer.c */
+#include "SDL_timer.h"
+
+#define ROUND_RESOLUTION(X)	\
+	(((X+TIMER_RESOLUTION-1)/TIMER_RESOLUTION)*TIMER_RESOLUTION)
+
+extern int SDL_TimerInit(void);
+extern void SDL_TimerQuit(void);
+
+/* vi: set ts=4 sw=4 expandtab: */

thirdparty/SDL/src/timer/beos/SDL_systimer.c

@@ -0,0 +1,64 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2011 Sam Lantinga <slouken@libsdl.org>
+
+  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_TIMER_BEOS
+
+#include <be/kernel/OS.h>
+
+#include "SDL_timer.h"
+
+static bigtime_t start;
+
+void
+SDL_StartTicks(void)
+{
+    /* Set first ticks value */
+    start = system_time();
+}
+
+Uint32
+SDL_GetTicks(void)
+{
+    return ((system_time() - start) / 1000);
+}
+
+Uint64
+SDL_GetPerformanceCounter(void)
+{
+    return system_time();
+}
+
+Uint64
+SDL_GetPerformanceFrequency(void)
+{
+    return 1000000;
+}
+
+void
+SDL_Delay(Uint32 ms)
+{
+    snooze(ms * 1000);
+}
+
+#endif /* SDL_TIMER_BEOS */
+
+/* vi: set ts=4 sw=4 expandtab: */

thirdparty/SDL/src/timer/dummy/SDL_systimer.c

@@ -0,0 +1,59 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2011 Sam Lantinga <slouken@libsdl.org>
+
+  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 defined(SDL_TIMER_DUMMY) || defined(SDL_TIMERS_DISABLED)
+
+#include "SDL_timer.h"
+
+void
+SDL_StartTicks(void)
+{
+}
+
+Uint32
+SDL_GetTicks(void)
+{
+    SDL_Unsupported();
+    return 0;
+}
+
+Uint64
+SDL_GetPerformanceCounter(void)
+{
+    return SDL_GetTicks();
+}
+
+Uint64
+SDL_GetPerformanceFrequency(void)
+{
+    return 1000;
+}
+
+void
+SDL_Delay(Uint32 ms)
+{
+    SDL_Unsupported();
+}
+
+#endif /* SDL_TIMER_DUMMY || SDL_TIMERS_DISABLED */
+
+/* vi: set ts=4 sw=4 expandtab: */

thirdparty/SDL/src/timer/nds/SDL_systimer.c

@@ -0,0 +1,78 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2011 Sam Lantinga <slouken@libsdl.org>
+
+  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_TIMER_NDS
+
+#include <nds.h>
+#include <nds/timers.h>
+
+#include "SDL_timer.h"
+
+/* Will wrap after 49 days. Shouldn't be an issue. */
+static volatile Uint32 timer_ticks;
+
+static void
+NDS_TimerInterrupt(void)
+{
+    timer_ticks++;
+}
+
+void
+SDL_StartTicks(void)
+{
+    timer_ticks = 0;
+
+	/* Set timer 2 to fire every ms. */
+	timerStart(2, ClockDivider_1024, TIMER_FREQ_1024(1000), NDS_TimerInterrupt);
+}
+
+Uint32
+SDL_GetTicks(void)
+{
+    return timer_ticks;
+}
+
+Uint64
+SDL_GetPerformanceCounter(void)
+{
+    return SDL_GetTicks();
+}
+
+Uint64
+SDL_GetPerformanceFrequency(void)
+{
+    return 1000;
+}
+
+void
+SDL_Delay(Uint32 ms)
+{
+    Uint32 start = SDL_GetTicks();
+    while (1) {
+        if ((SDL_GetTicks() - start) >= ms)
+            break;
+    }
+}
+
+#endif /* SDL_TIMER_NDS */
+
+/* vi: set ts=4 sw=4 expandtab: */

thirdparty/SDL/src/timer/unix/SDL_systimer.c

@@ -0,0 +1,163 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2011 Sam Lantinga <slouken@libsdl.org>
+
+  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_TIMER_UNIX
+
+#include <stdio.h>
+#include <sys/time.h>
+#include <unistd.h>
+#include <errno.h>
+
+#include "SDL_timer.h"
+
+/* The clock_gettime provides monotonous time, so we should use it if
+   it's available. The clock_gettime function is behind ifdef
+   for __USE_POSIX199309
+   Tommi Kyntola (tommi.kyntola@ray.fi) 27/09/2005
+*/
+#if HAVE_NANOSLEEP || HAVE_CLOCK_GETTIME
+#include <time.h>
+#endif
+
+/* The first ticks value of the application */
+#ifdef HAVE_CLOCK_GETTIME
+static struct timespec start;
+#else
+static struct timeval start;
+#endif /* HAVE_CLOCK_GETTIME */
+
+
+void
+SDL_StartTicks(void)
+{
+    /* Set first ticks value */
+#if HAVE_CLOCK_GETTIME
+    clock_gettime(CLOCK_MONOTONIC, &start);
+#else
+    gettimeofday(&start, NULL);
+#endif
+}
+
+Uint32
+SDL_GetTicks(void)
+{
+#if HAVE_CLOCK_GETTIME
+    Uint32 ticks;
+    struct timespec now;
+
+    clock_gettime(CLOCK_MONOTONIC, &now);
+    ticks =
+        (now.tv_sec - start.tv_sec) * 1000 + (now.tv_nsec -
+                                              start.tv_nsec) / 1000000;
+    return (ticks);
+#else
+    Uint32 ticks;
+    struct timeval now;
+
+    gettimeofday(&now, NULL);
+    ticks =
+        (now.tv_sec - start.tv_sec) * 1000 + (now.tv_usec -
+                                              start.tv_usec) / 1000;
+    return (ticks);
+#endif
+}
+
+Uint64
+SDL_GetPerformanceCounter(void)
+{
+#if HAVE_CLOCK_GETTIME
+    Uint64 ticks;
+    struct timespec now;
+
+    clock_gettime(CLOCK_MONOTONIC, &now);
+    ticks = now.tv_sec;
+    ticks *= 1000000000;
+    ticks += now.tv_nsec;
+    return (ticks);
+#else
+    Uint64 ticks;
+    struct timeval now;
+
+    gettimeofday(&now, NULL);
+    ticks = now.tv_sec;
+    ticks *= 1000000;
+    ticks += now.tv_usec;
+    return (ticks);
+#endif
+}
+
+Uint64
+SDL_GetPerformanceFrequency(void)
+{
+#if HAVE_CLOCK_GETTIME
+    return 1000000000;
+#else
+    return 1000000;
+#endif
+}
+
+void
+SDL_Delay(Uint32 ms)
+{
+    int was_error;
+
+#if HAVE_NANOSLEEP
+    struct timespec elapsed, tv;
+#else
+    struct timeval tv;
+    Uint32 then, now, elapsed;
+#endif
+
+    /* Set the timeout interval */
+#if HAVE_NANOSLEEP
+    elapsed.tv_sec = ms / 1000;
+    elapsed.tv_nsec = (ms % 1000) * 1000000;
+#else
+    then = SDL_GetTicks();
+#endif
+    do {
+        errno = 0;
+
+#if HAVE_NANOSLEEP
+        tv.tv_sec = elapsed.tv_sec;
+        tv.tv_nsec = elapsed.tv_nsec;
+        was_error = nanosleep(&tv, &elapsed);
+#else
+        /* Calculate the time interval left (in case of interrupt) */
+        now = SDL_GetTicks();
+        elapsed = (now - then);
+        then = now;
+        if (elapsed >= ms) {
+            break;
+        }
+        ms -= elapsed;
+        tv.tv_sec = ms / 1000;
+        tv.tv_usec = (ms % 1000) * 1000;
+
+        was_error = select(0, NULL, NULL, NULL, &tv);
+#endif /* HAVE_NANOSLEEP */
+    } while (was_error && (errno == EINTR));
+}
+
+#endif /* SDL_TIMER_UNIX */
+
+/* vi: set ts=4 sw=4 expandtab: */

thirdparty/SDL/src/timer/wince/SDL_systimer.c

@@ -0,0 +1,110 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2011 Sam Lantinga <slouken@libsdl.org>
+
+  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_TIMER_WINCE
+
+#include "../../core/windows/SDL_windows.h"
+
+#include "SDL_timer.h"
+
+static Uint64 start_date;
+static Uint64 start_ticks;
+
+static Uint64
+wce_ticks(void)
+{
+    return ((Uint64) GetTickCount());
+}
+
+static Uint64
+wce_date(void)
+{
+    union
+    {
+        FILETIME ftime;
+        Uint64 itime;
+    } ftime;
+    SYSTEMTIME stime;
+
+    GetSystemTime(&stime);
+    SystemTimeToFileTime(&stime, &ftime.ftime);
+    ftime.itime /= 10000;       // Convert 100ns intervals to 1ms intervals
+    // Remove ms portion, which can't be relied on
+    ftime.itime -= (ftime.itime % 1000);
+    return (ftime.itime);
+}
+
+static Sint32
+wce_rel_ticks(void)
+{
+    return ((Sint32) (wce_ticks() - start_ticks));
+}
+
+static Sint32
+wce_rel_date(void)
+{
+    return ((Sint32) (wce_date() - start_date));
+}
+
+/* Recard start-time of application for reference */
+void
+SDL_StartTicks(void)
+{
+    start_date = wce_date();
+    start_ticks = wce_ticks();
+}
+
+/* Return time in ms relative to when SDL was started */
+Uint32
+SDL_GetTicks()
+{
+    Sint32 offset = wce_rel_date() - wce_rel_ticks();
+    if ((offset < -1000) || (offset > 1000)) {
+//    fprintf(stderr,"Time desync(%+d), resyncing\n",offset/1000);
+        start_ticks -= offset;
+    }
+
+    return ((Uint32) wce_rel_ticks());
+}
+
+Uint64
+SDL_GetPerformanceCounter(void)
+{
+    return SDL_GetTicks();
+}
+
+Uint64
+SDL_GetPerformanceFrequency(void)
+{
+    return 1000;
+}
+
+/* Give up approx. givem milliseconds to the OS. */
+void
+SDL_Delay(Uint32 ms)
+{
+    Sleep(ms);
+}
+
+#endif /* SDL_TIMER_WINCE */
+
+/* vi: set ts=4 sw=4 expandtab: */

thirdparty/SDL/src/timer/windows/SDL_systimer.c

@@ -0,0 +1,131 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2011 Sam Lantinga <slouken@libsdl.org>
+
+  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_TIMER_WINDOWS
+
+#include "../../core/windows/SDL_windows.h"
+#include <mmsystem.h>
+
+#include "SDL_timer.h"
+
+#ifdef _WIN32_WCE
+#error This is WinCE. Please use src/timer/wince/SDL_systimer.c instead.
+#endif
+
+#define TIME_WRAP_VALUE	(~(DWORD)0)
+
+/* The first (low-resolution) ticks value of the application */
+static DWORD start;
+
+#ifndef USE_GETTICKCOUNT
+/* Store if a high-resolution performance counter exists on the system */
+static BOOL hires_timer_available;
+/* The first high-resolution ticks value of the application */
+static LARGE_INTEGER hires_start_ticks;
+/* The number of ticks per second of the high-resolution performance counter */
+static LARGE_INTEGER hires_ticks_per_second;
+#endif
+
+void
+SDL_StartTicks(void)
+{
+    /* Set first ticks value */
+#ifdef USE_GETTICKCOUNT
+    start = GetTickCount();
+#else
+#if 0                           /* Apparently there are problems with QPC on Win2K */
+    if (QueryPerformanceFrequency(&hires_ticks_per_second) == TRUE) {
+        hires_timer_available = TRUE;
+        QueryPerformanceCounter(&hires_start_ticks);
+    } else
+#endif
+    {
+        hires_timer_available = FALSE;
+        timeBeginPeriod(1);     /* use 1 ms timer precision */
+        start = timeGetTime();
+    }
+#endif
+}
+
+Uint32
+SDL_GetTicks(void)
+{
+    DWORD now, ticks;
+#ifndef USE_GETTICKCOUNT
+    LARGE_INTEGER hires_now;
+#endif
+
+#ifdef USE_GETTICKCOUNT
+    now = GetTickCount();
+#else
+    if (hires_timer_available) {
+        QueryPerformanceCounter(&hires_now);
+
+        hires_now.QuadPart -= hires_start_ticks.QuadPart;
+        hires_now.QuadPart *= 1000;
+        hires_now.QuadPart /= hires_ticks_per_second.QuadPart;
+
+        return (DWORD) hires_now.QuadPart;
+    } else {
+        now = timeGetTime();
+    }
+#endif
+
+    if (now < start) {
+        ticks = (TIME_WRAP_VALUE - start) + now;
+    } else {
+        ticks = (now - start);
+    }
+    return (ticks);
+}
+
+Uint64
+SDL_GetPerformanceCounter(void)
+{
+    LARGE_INTEGER counter;
+
+    if (!QueryPerformanceCounter(&counter)) {
+        return SDL_GetTicks();
+    }
+    return counter.QuadPart;
+}
+
+Uint64
+SDL_GetPerformanceFrequency(void)
+{
+    LARGE_INTEGER frequency;
+
+    if (!QueryPerformanceFrequency(&frequency)) {
+        return 1000;
+    }
+    return frequency.QuadPart;
+}
+
+void
+SDL_Delay(Uint32 ms)
+{
+    Sleep(ms);
+}
+
+#endif /* SDL_TIMER_WINDOWS */
+
+/* vi: set ts=4 sw=4 expandtab: */