Import SDL release-1.2.15

Change-Id: I505c4aea24325cad475f217db5589814b4c75dbf

1 files changed, 227 insertions, 0 deletions

diff --git a/distrib/sdl-1.2.15/src/timer/os2/SDL_systimer.c b/distrib/sdl-1.2.15/src/timer/os2/SDL_systimer.c
new file mode 100644
index 0000000..c82d531
--- /dev/null
+++ b/distrib/sdl-1.2.15/src/timer/os2/SDL_systimer.c
@@ -0,0 +1,227 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2012 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+#ifdef SDL_TIMER_OS2
+
+#define INCL_DOSMISC
+#define INCL_DOSERRORS
+#define INCL_DOSSEMAPHORES
+#define INCL_DOSDATETIME
+#define INCL_DOSPROCESS
+#define INCL_DOSPROFILE
+#define INCL_DOSEXCEPTIONS
+#include <os2.h>
+
+#include "SDL_thread.h"
+#include "SDL_timer.h"
+#include "../SDL_timer_c.h"
+
+
+#define TIME_WRAP_VALUE (~(DWORD)0)
+
+/* The first high-resolution ticks value of the application */
+static long long hires_start_ticks;
+/* The number of ticks per second of the high-resolution performance counter */
+static ULONG hires_ticks_per_second;
+
+void SDL_StartTicks(void)
+{
+        DosTmrQueryFreq(&hires_ticks_per_second);
+        DosTmrQueryTime((PQWORD)&hires_start_ticks);
+}
+
+DECLSPEC Uint32 SDLCALL SDL_GetTicks(void)
+{
+        long long hires_now;
+        ULONG ticks = ticks;
+
+        DosTmrQueryTime((PQWORD)&hires_now);
+/*
+        hires_now -= hires_start_ticks;
+        hires_now *= 1000;
+        hires_now /= hires_ticks_per_second;
+*/
+        /* inline asm to avoid runtime inclusion */
+        _asm {
+           push edx
+           push eax
+           mov eax, dword ptr hires_now
+           mov edx, dword ptr hires_now+4
+           sub eax, dword ptr hires_start_ticks
+           sbb edx, dword ptr hires_start_ticks+4
+           mov ebx,1000
+           mov ecx,edx
+           mul ebx
+           push eax
+           push edx
+           mov eax,ecx
+           mul ebx
+           pop eax
+           add edx,eax
+           pop eax
+           mov ebx, dword ptr hires_ticks_per_second
+           div ebx
+           mov dword ptr ticks, eax
+           pop edx
+           pop eax
+        }
+
+        return ticks;
+
+}
+
+/* High resolution sleep, originally made by Ilya Zakharevich */
+DECLSPEC void SDLCALL SDL_Delay(Uint32 ms)
+{
+  /* This is similar to DosSleep(), but has 8ms granularity in time-critical
+     threads even on Warp3. */
+  HEV     hevEvent1     = 0;   /* Event semaphore handle    */
+  HTIMER  htimerEvent1  = 0;   /* Timer handle              */
+  APIRET  rc            = NO_ERROR;  /* Return code               */
+  int ret = 1;
+  ULONG priority = 0, nesting;   /* Shut down the warnings */
+  PPIB pib;
+  PTIB tib;
+  char *e = NULL;
+  APIRET badrc;
+  int switch_priority = 50;
+
+  DosCreateEventSem(NULL,      /* Unnamed */
+                    &hevEvent1,  /* Handle of semaphore returned */
+                    DC_SEM_SHARED, /* Shared needed for DosAsyncTimer */
+                    FALSE);      /* Semaphore is in RESET state  */
+
+  if (ms >= switch_priority)
+    switch_priority = 0;
+  if (switch_priority)
+  {
+    if (DosGetInfoBlocks(&tib, &pib)!=NO_ERROR)
+      switch_priority = 0;
+    else
+    {
+ /* In Warp3, to switch scheduling to 8ms step, one needs to do 
+    DosAsyncTimer() in time-critical thread.  On laters versions,
+    more and more cases of wait-for-something are covered.
+
+    It turns out that on Warp3fp42 it is the priority at the time
+    of DosAsyncTimer() which matters.  Let's hope that this works
+    with later versions too...  XXXX
+  */
+      priority = (tib->tib_ptib2->tib2_ulpri);
+      if ((priority & 0xFF00) == 0x0300) /* already time-critical */
+        switch_priority = 0;
+ /* Make us time-critical.  Just modifying TIB is not enough... */
+ /* tib->tib_ptib2->tib2_ulpri = 0x0300;*/
+ /* We do not want to run at high priority if a signal causes us
+    to longjmp() out of this section... */
+      if (DosEnterMustComplete(&nesting))
+        switch_priority = 0;
+      else
+        DosSetPriority(PRTYS_THREAD, PRTYC_TIMECRITICAL, 0, 0);
+    }
+  }
+
+  if ((badrc = DosAsyncTimer(ms,
+        (HSEM) hevEvent1, /* Semaphore to post        */
+        &htimerEvent1))) /* Timer handler (returned) */
+    e = "DosAsyncTimer";
+
+  if (switch_priority && tib->tib_ptib2->tib2_ulpri == 0x0300)
+  {
+ /* Nobody switched priority while we slept...  Ignore errors... */
+ /* tib->tib_ptib2->tib2_ulpri = priority; */ /* Get back... */
+    if (!(rc = DosSetPriority(PRTYS_THREAD, (priority>>8) & 0xFF, 0, 0)))
+      rc = DosSetPriority(PRTYS_THREAD, 0, priority & 0xFF, 0);
+  }
+  if (switch_priority)
+    rc = DosExitMustComplete(&nesting); /* Ignore errors */
+
+  /* The actual blocking call is made with "normal" priority.  This way we
+     should not bother with DosSleep(0) etc. to compensate for us interrupting
+     higher-priority threads.  The goal is to prohibit the system spending too
+     much time halt()ing, not to run us "no matter what". */
+  if (!e)     /* Wait for AsyncTimer event */
+    badrc = DosWaitEventSem(hevEvent1, SEM_INDEFINITE_WAIT);
+
+  if (e) ;    /* Do nothing */
+  else if (badrc == ERROR_INTERRUPT)
+    ret = 0;
+  else if (badrc)
+    e = "DosWaitEventSem";
+  if ((rc = DosCloseEventSem(hevEvent1)) && !e) { /* Get rid of semaphore */
+    e = "DosCloseEventSem";
+    badrc = rc;
+  }
+  if (e)
+  {
+    SDL_SetError("[SDL_Delay] : Had error in %s(), rc is 0x%x\n", e, badrc);
+  }
+}
+
+/* Data to handle a single periodic alarm */
+static int timer_alive = 0;
+static SDL_Thread *timer = NULL;
+
+static int SDLCALL RunTimer(void *unused)
+{
+        DosSetPriority(PRTYS_THREAD, PRTYC_TIMECRITICAL, 0, 0);
+        while ( timer_alive ) {
+                if ( SDL_timer_running ) {
+                        SDL_ThreadedTimerCheck();
+                }
+                SDL_Delay(10);
+        }
+        return(0);
+}
+
+/* This is only called if the event thread is not running */
+int SDL_SYS_TimerInit(void)
+{
+        timer_alive = 1;
+        timer = SDL_CreateThread(RunTimer, NULL);
+        if ( timer == NULL )
+                return(-1);
+        return(SDL_SetTimerThreaded(1));
+}
+
+void SDL_SYS_TimerQuit(void)
+{
+        timer_alive = 0;
+        if ( timer ) {
+                SDL_WaitThread(timer, NULL);
+                timer = NULL;
+        }
+}
+
+int SDL_SYS_StartTimer(void)
+{
+        SDL_SetError("Internal logic error: OS/2 uses threaded timer");
+        return(-1);
+}
+
+void SDL_SYS_StopTimer(void)
+{
+        return;
+}
+
+#endif /* SDL_TIMER_OS2 */