/*

    SDL - Simple DirectMedia Layer

    Copyright (C) 1997-2006 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 */