/*

    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_RISCOS

#include <stdio.h>

#include <time.h>

#include <sys/time.h>

#include <unistd.h>

#include <string.h>

#include <errno.h>

#include "SDL_timer.h"

#include "../SDL_timer_c.h"

#if SDL_THREADS_DISABLED

/* Timer  SDL_arraysize(Timer ),start/reset time */

static Uint32 timerStart;

/* Timer running function */

#else

#include <pthread.h>

extern Uint32 riscos_main_thread;

extern int riscos_using_threads;

#endif

/* The first ticks value of the application */

clock_t start;

void

{

    /* Set first ticks value */

}

Uint32

{

    clock_t ticks;

#if CLOCKS_PER_SEC == 1000

    return (ticks);

#elif CLOCKS_PER_SEC == 100

    return (ticks * 10);

#else

    return ticks * (1000 / CLOCKS_PER_SEC);

#endif

}

void

{

    Uint32 now, then, elapsed;

#if !SDL_THREADS_DISABLED

    int is_event_thread;

    if (riscos_using_threads) {

        is_event_thread = 0;

                is_event_thread = 1;

            is_event_thread = 1;

    } else

        is_event_thread = 1;

#endif

    /*TODO: Next version of Unixlib may allow us to use usleep here */

    /*      for non event threads */

    /* Set the timeout interval - Linux only needs to do this once */

    do {

        /* Do background tasks required while sleeping as we are not multithreaded */

#if SDL_THREADS_DISABLED

#else

        /* For threaded build only run background tasks in event thread */

        if (is_event_thread)

#endif

        /* Calculate the time interval left (in case of interrupt) */

        elapsed = (now - then);

        then = now;

        if (elapsed >= ms) {

            break;

        }

        ms -= elapsed;

#if !SDL_THREADS_DISABLED

        /* Need to yield to let other threads have a go */

        if (riscos_using_threads)

#endif

    }

    while (1);

}

#if SDL_THREADS_DISABLED

/* Non-threaded version of timer */

int

{

    return (0);

}

void

{

}

int

{

    return (0);

}

void

{

    /* Don't need to do anything as we use SDL_timer_running

       to detect if we need to check the timer */

}

void

{

    if (SDL_timer_running

        Uint32 ms;

        if (ms != SDL_alarm_interval) {

            if (ms) {

            } else {

                SDL_alarm_interval = 0;

                SDL_timer_running = 0;

            }

        }

        if (SDL_alarm_interval)

    }

}

#else

/* Threaded version of timer - based on code for linux */

#include "SDL_thread.h"

/* Data to handle a single periodic alarm */

static int timer_alive = 0;

static SDL_Thread *timer = NULL;

static int

{

    while (timer_alive) {

        if (SDL_timer_running) {

        }

    }

    return (0);

}

/* This is only called if the event thread is not running */

int

{

    timer_alive = 1;

    if (timer == NULL)

        return (-1);

}

void

{

    timer_alive = 0;

    if (timer) {

        timer = NULL;

    }

}

int

{

    return (-1);

}

void

{

    return;

}

#endif /* SDL_THREADS_DISABLED */

#endif /* SDL_TIMER_RISCOS */

/* vi: set ts=4 sw=4 expandtab: */