/*      dostimer.c
 *
 * MIDAS Sound System timer for MS-DOS
 *
 * $Id: dostimer.c,v 1.6 1997/01/16 18:41:59 pekangas Exp $
 *
 * Copyright 1996,1997 Housemarque Inc.
 *
 * This file is part of the MIDAS Sound System, and may only be
 * used, modified and distributed under the terms of the MIDAS
 * Sound System license, LICENSE.TXT. By continuing to use,
 * modify or distribute this file you indicate that you have
 * read the license and understand and accept it fully.
*/

#include <dos.h>
#include "lang.h"
#include "mtypes.h"
#include "errors.h"
#include "sdevice.h"
#include "timer.h"
#include "mglobals.h"

RCSID(const char *dostimer_rcsid = "$Id: dostimer.c,v 1.6 1997/01/16 18:41:59 pekangas Exp $";)

//#define TIMERBORDERS

/* Time between to screen interrupts is 96.5% of total frame time - the
   interrupt comes somewhat before the Vertical Retrace actually starts: */
#define FRAMETIME 965

/* Timer mode: */
#define TIMERMODE 0x30

/* Maximum # of music players: */
#define MAXPLAYERS 16


static void (__interrupt __far *oldTimer)();
static volatile int tmrState;
static volatile int playSD;

static volatile long sysTmrCount;       /* system timer counter */
static volatile long playTmrCount;      /* initial player timer count */
static volatile long playCount;         /* player timer count */
static volatile SoundDevice *sdev;      /* current SD */

static int CALLING (*musicPlayers[MAXPLAYERS])(void);    /* music players */

static volatile int playSD;             /* 1 if sound should be played */
static volatile int plTimer;            /* 1 if player-timer is active */
static volatile int plError;            /* music playing error code */

static volatile long scrCount;          /* screen timer counter */
static volatile long scrTmrCount;       /* initial value for screen timer */
static volatile long scrPVCount;        /* count before retrace */

static void CALLING (*preVR)();         /* pre-VR function */
static void CALLING (*immVR)();         /* immVR() */
static void CALLING (*inVR)();          /* inVR() */

static volatile int scrSync;            /* is timer synchronized to screen? */
static volatile int scrTimer;           /* 1 if screen-timer is active */
static volatile int scrPlayer;          /* synchronize player to screen? */

static volatile int tmrState;           /* timer state */




/****************************************************************************\
*       enum tmrStates
*       --------------
* Description:  Possible timer states
\****************************************************************************/

enum tmrStates
{
    tmrSystem = 0,                      /* system timer */
    tmrPlayer,                          /* music player */
    tmrScreen                           /* display synchronized timer */
};



void outp(unsigned port, unsigned value);
#pragma aux outp = \
    "out    dx,al" \
    parm [edx] [eax] \
    modify exact [];

unsigned inp(unsigned port);
#pragma aux inp = \
    "xor    eax,eax" \
    "in     al,dx" \
    parm [edx] \
    value [eax] \
    modify exact [eax];

void DoSTI(void);
#pragma aux DoSTI = "sti" modify exact[];

void DoCLI(void);
#pragma aux DoCLI = "cli" modify exact[];

void SendEOI(void);
#pragma aux SendEOI = \
    "   mov     al,20h" \
    "   out     20h,al" \
    modify exact[eax];


/* Set border color: */
#ifdef TIMERBORDERS
void SetBorder(int color);
#pragma aux SetBorder = \
    "   mov     dx,03DAh" \
    "   in      al,dx" \
    "   mov     dx,03C0h" \
    "   mov     al,31h" \
    "   out     dx,al" \
    "   mov     al,bl" \
    "   out     dx,al" \
    parm [ebx] \
    modify exact [eax edx];
#else
#define SetBorder(x)
#endif


/* Wait for next Vertical Retrace: */
void WaitNextVR(void);
#pragma aux WaitNextVR = \
    "   mov     dx,03DAh" \
    "n: in      al,dx" \
    "   test    al,8" \
    "   jnz     n" \
    "v: in      al,dx" \
    "   test    al,8" \
    "   jz      v" \
    modify exact [eax edx];

/* Wait for Vertical Retrace: */
void WaitVR(void);
#pragma aux WaitVR = \
    "   mov     dx,03DAh" \
    "w: in      al,dx" \
    "   test    al,8" \
    "   jz      w" \
    modify exact [eax edx];

/* Wait for no Vertical Retrace: */
void WaitNoVR(void);
#pragma aux WaitNoVR = \
    "   mov     dx,03DAh" \
    "w: in      al,dx" \
    "   test    al,8" \
    "   jnz     w" \
    modify exact [eax edx];

/* Set DS to ES: */
void SetDStoES(void);
#pragma aux SetDStoES = \
    "   mov     ax,ds" \
    "   mov     es,ax" \
    modify exact [eax];



/****************************************************************************\
*
* Function:     void SetCount(unsigned count)
*
* Description:  Sets new timer count
*
* Input:        unsigned count          new timer count
*
\****************************************************************************/

static void SetCount(unsigned count)
{
    outp(0x43, TIMERMODE);
    outp(0x40, count & 0xFF);
    outp(0x40, (count >> 8) & 0xFF);
}



/****************************************************************************\
*
* Function:     void NextTimer(void)
*
* Description:  Sets everything up for the next timer interrupt
*
\****************************************************************************/

static void NextTimer(void)
{
    if ( scrSync )
    {
        /* Timer is synchronized to screen: */
        if ( playSD && mSyncScreen )
        {
            if ( playCount < scrCount )
            {
                if ( playCount < 10 )
                    playCount = 10;

                /* Player interrupt, please */
                tmrState = tmrPlayer;
                SetCount(playCount);
                return;
            }
        }

        if ( scrCount < 10 )
            scrCount = 10;

        /* Screen interrupt, please: */
        tmrState = tmrScreen;
        SetCount(scrCount);
        return;
    }

    if ( playSD )
    {
        if ( playCount < 10 )
            playCount = 10;

        /* Player interrupt: */
        tmrState = tmrPlayer;
        SetCount(playCount);
        return;
    }

    /* System timer: */
    tmrState = tmrSystem;
    SetCount(0);
}


void CallDOSInt(void);
#pragma aux CallDOSInt = \
    "pushfd" \
    "call fword oldTimer" \
    modify exact [];


/****************************************************************************\
*
* Function:     void CheckSystemTimer(void)
*
* Description:  Calls the system timer if necessary, send EOI otherwise
*
\****************************************************************************/

void CheckSystemTimer(void)
{
    DoSTI();

    if ( sysTmrCount < 0x10000 )
    {
        SendEOI();
        return;
    }

    while ( sysTmrCount >= 0x10000 )
    {
        sysTmrCount -= 0x10000;
        CallDOSInt();
    }
}




/****************************************************************************\
*
* Function:     void PollMIDAS(void)
*
* Description:  Polls MIDAS
*
\****************************************************************************/

void PollMIDAS(void)
{
    static int callMP;
    int         i;

    if ( (playSD) && (plError == OK) )
    {
        /* Prepare SD for playing: */
        if ( (plError = sdev->StartPlay()) != OK )
        {
            plTimer = 0;
            return;
        }

        do
        {
            /* Poll Sound Device: */
            if ( (plError = sdev->Play(&callMP)) != OK )
            {
                plTimer = 0;
                return;
            }

            if ( callMP )
            {
                /* Call all music players: */
                for ( i = 0; i < MAXPLAYERS; i++ )
                {
                    if ( musicPlayers[i] != NULL )
                    {
                        if ( (plError = (*musicPlayers[i])()) != OK )
                        {
                            plTimer = 0;
                            return;
                        }
                    }
                }
            }
        } while ( callMP && (sdev->tempoPoll == 0) );
    }
}


/****************************************************************************\
*
* Function:     void __interrupt __far tmrISR(void)
*
* Description:  The timer ISR
*
\****************************************************************************/

void __interrupt __far tmrISR(void)
{
    int         chainDOS = 1;
    long        oldPlayCount;

    /* Set DS to ES as well: (stupid Watcom doesn't to this, and then assumes
       ES is valid) */
    SetDStoES();

    SetBorder(9);

    switch ( tmrState )
    {
        case tmrScreen:
            SetBorder(15);
            DoCLI();                    /* Disable interrupts here */

            if ( scrTimer )
            {
                /* PANIC, screen timer still active! */
                playCount -= scrCount + scrPVCount;
                sysTmrCount += scrCount + scrPVCount;
                scrCount = scrTmrCount;
                NextTimer();
                SendEOI();
                DoSTI();
                chainDOS = 0;
                break;
            }

            if ( scrSync )
            {
                SetBorder(14);

                scrTimer = 1;

                if ( mSyncScreen )
                    WaitNoVR();

                if ( preVR != NULL )
                    (*preVR)();

                /* Update timer counters: */
                sysTmrCount += scrCount + scrPVCount;
                if ( scrPlayer )
                    playCount = playTmrCount;
                else
                    playCount -= scrCount + scrPVCount;
                scrCount = scrTmrCount;

                if ( mSyncScreen )
                    WaitVR();

                if ( immVR != NULL )
                    (*immVR)();

                NextTimer();
                CheckSystemTimer();
                scrTimer = 0;

                /* If not synchronizing to screen we need to poll MIDAS
                   here: */
                if ( (!mSyncScreen) && playSD )
                {
                    if ( sdev->tempoPoll )
                    {
                        while ( playCount < 0 )
                        {
                            PollMIDAS();
                            playCount += playTmrCount;
                        }
                    }
                    else
                        PollMIDAS();
                }

                if ( inVR != NULL )
                    (*inVR)();
                chainDOS = 0;
                break;
            }
            else
            {
                /* We shouldn't really be here - check system timer and
                   exit */
                CheckSystemTimer();
                chainDOS = 0;
                break;
            }
            break;

        case tmrPlayer:
            if ( plTimer )
            {
                /* Player timer active - panic! */
                scrCount -= playCount;
                sysTmrCount += playCount;
                playCount = playTmrCount;
                NextTimer();
                SendEOI();
                DoSTI();
                chainDOS = 0;
                break;
            }

            plTimer = 1;
            scrCount -= playCount;
            sysTmrCount += playCount;

            if ( scrPlayer )
                playCount = 0xFFFF;
            else
                playCount = playTmrCount;
            NextTimer();

            CheckSystemTimer();
            chainDOS = 0;

            oldPlayCount = playTmrCount;

            PollMIDAS();

            /* Check if player timer rate has been updated: */
            if ( (sdev->tempoPoll == 1) && (playTmrCount != oldPlayCount))
            {
                playCount = playTmrCount;
                if ( tmrState == tmrPlayer )
                    NextTimer();
            }

            plTimer = 0;
            chainDOS = 0;
            break;

        case tmrSystem:
        default:
            /* The system timer - set rate to 18.2Hz and chain to DOS: */
            SetCount(0);
            chainDOS = 1;
            break;
    }

    SetBorder(0);

    if ( chainDOS )
        _chain_intr(oldTimer);
}



/****************************************************************************\
*
* Function:     int tmrInit(void);
*
* Description:  Initializes the timer
*
* Returns:      MIDAS error code
*
\****************************************************************************/

int CALLING tmrInit(void)
{
    tmrState = tmrSystem;               /* system timer only */
    playSD = 0;

    /* Get old timer interrupt and set our own: */
    oldTimer = _dos_getvect(8);
    _dos_setvect(8, tmrISR);

    /* Restart timer at 18.2Hz: */
//    SetCount(0);

    return OK;
}




/****************************************************************************\
*
* Function:     int tmrClose(void);
*
* Description:  Uninitializes the timer.
*
* Returns:      MIDAS error code
*
\****************************************************************************/

int CALLING tmrClose(void)
{
    /* Set DOS default timer mode and 18.2Hz rate: */
    outp(0x43, 0x36);
    outp(0x40, 0);
    outp(0x40, 0);

    /* Restore old interrupt vector: */
    _dos_setvect(8, oldTimer);

    /* Set DOS default timer mode and 18.2Hz rate: */
    outp(0x43, 0x36);
    outp(0x40, 0);
    outp(0x40, 0);

    return OK;
}




/****************************************************************************\
*
* Function:     int tmrGetScrSync(unsigned *scrSync);
*
* Description:  Calculates the screen synchronization value for timer
*
* Input:        unsigned *scrSync       pointer to screen synchronization
*                                       value
*
* Returns:      MIDAS error code.
*               Screen syncronization value used with tmrSyncScr() is stored
*               in *scrSync.
*
\****************************************************************************/

int CALLING tmrGetScrSync(unsigned *scrSync)
{
    int         failCount = 0, success = 0;
    long        count1, count2, prevCount = 0, count;

    if ( !mSyncScreen )
    {
        /* No sync - just return the default frame rate: */
        *scrSync = 119318000 / mDefaultFramerate;
        return OK;
    }

    DoCLI();

    while ( (failCount < 4) && (success != 1) )
    {
        WaitNextVR();
        outp(0x43, 0x36);
        outp(0x40, 0);
        outp(0x40, 0);
        WaitNextVR();
        outp(0x43, 0);
        count1 = inp(0x40);
        count1 |= (inp(0x40)) << 8;
        count1 = 0x10000-count1;

        WaitNextVR();
        outp(0x43, 0x36);
        outp(0x40, 0);
        outp(0x40, 0);
        WaitNextVR();
        outp(0x43, 0);
        count2 = inp(0x40);
        count2 |= (inp(0x40)) << 8;
        count2 = 0x10000-count2;

        if ( ((count2 - count1) > 2) || ((count2 - count1) < -2) )
        {
            failCount++;
        }
        else
        {
            count = count1 >> 1;
            if ( ((prevCount - count) <= 2) && ((prevCount - count) >= -2) )
                success = 1;
            else
            {
                prevCount = count;
                failCount++;
            }
        }
    }

    if ( success )
    {
        /* We got the synchronization value! */
        *scrSync = count;
    }
    else
    {
        /* Couldn't synchronize - turn sync off and return default
           frame rate: */
        mSyncScreen = 0;
        *scrSync = 119318000 / mDefaultFramerate;
    }

    DoSTI();

    return OK;
}




/****************************************************************************\
*
* Function:     int tmrPlaySD(SoundDevice *SD);
*
* Description:  Starts playing sound with a Sound Device ie. calling its
*               Play() function in the update rate, which is set to
*               50Hz.
*
* Input:        SoundDevice *SD         Sound Device that will be used
*
* Returns:      MIDAS error code.
*
\****************************************************************************/

int CALLING tmrPlaySD(SoundDevice *SD)
{
    int         i;

    sdev = SD;

    /* Reset all music player pointers to NULL: */
    for ( i = 0; i < MAXPLAYERS; i++ )
        musicPlayers[i] = NULL;

    if ( !sdev->tempoPoll )
    {
        if ( scrSync && mSyncScreen )
        {
            /* We are synchronizing to screen and have a non-tempoPoll SD -
               call the music player a 1/4th of a frame after the retrace: */
            scrPlayer = 1;
            playTmrCount = playCount = scrTmrCount / 4;
        }
        else
        {
            /* No tempo-polling and no screen-sync - poll at 100Hz: */
            playTmrCount = playCount = 1193180 / 100;
            scrPlayer = 0;
        }
    }
    else
    {
        /* Tempo-polling Sound Device - set initially to 50Hz: */
        playTmrCount = playCount = 1193180 / 50;
        scrPlayer = 0;
    }

    plTimer = 0;
    plError = 0;

    /* Start playing: */
    DoCLI();

    if ( tmrState == tmrSystem )
    {
        tmrState = tmrPlayer;
        SetCount(playCount);
        sysTmrCount = 0;
    }

    playSD = 1;

    DoSTI();

    return OK;
}




/****************************************************************************\
*
* Function:     int tmrStopSD(void);
*
* Description:  Stops playing sound with the Sound Device.
*
* Returns:      MIDAS error code.
*
\****************************************************************************/

int CALLING tmrStopSD(void)
{
    DoCLI();

    playSD = 0;

    if ( !scrSync )
    {
        /* No screen sync - only system timer now: */
        tmrState = tmrSystem;
        SetCount(0);
    }

    DoSTI();

    return OK;
}




/****************************************************************************\
*
* Function:     int tmrPlayMusic(void *play, int *playerNum);
*
* Description:  Starts playing music with the timer.
*
* Input:        void *play              Pointer to music playing function,
*                                       must return MIDAS error codes
*               int *playerNum          Pointer to player number, used
*                                       for stopping music
*
* Returns:      MIDAS error code. Player number is written to *playerNum.
*
* Notes:        There can be a maximum of 16 music players active at the
*               same time.
*
\****************************************************************************/

int CALLING tmrPlayMusic(int CALLING (*play)(), int *playerNum)
{
    int         i;


    /* Try to find a free music player: */
    for ( i = 0; i < MAXPLAYERS; i++ )
    {
        if ( musicPlayers[i] == NULL )
            break;
    }

    if ( i >= MAXPLAYERS )
    {
        /* No free player found: */
        ERROR(errOutOfResources, ID_tmrPlayMusic);
        return errOutOfResources;
    }

    /* Free player found - store the pointer and return player ID: */
    musicPlayers[i] = play;
    *playerNum = i;

    return OK;
}




/****************************************************************************\
*
* Function:     int tmrStopMusic(int playerNum);
*
* Description:  Stops playing music with the timer.
*
* Input:        int playerNum           Number of player to be stopped.
*
* Returns:      MIDAS error code
*
\****************************************************************************/

int CALLING tmrStopMusic(int playerNum)
{
    musicPlayers[playerNum] = NULL;

    return OK;
}




/****************************************************************************\
*
* Function:     int tmrSyncScr(unsigned sync, void (*preVR)(),
*                   void (*immVR)(), void (*inVR)());
*
* Description:  Synchronizes the timer to screen refresh.
*
* Input:        unsigned sync           Screen synchronization value returned
*                                       by tmrGetScrSync().
*               void (*preVR)()         Pointer to the routine that will be
*                                       called BEFORE Vertical Retrace
*               void (*immVR)()         Pointer to the routine that will be
*                                       called immediately after Vertical
*                                       Retrace starts
*               void (*inVR)()          Pointer to the routine that will be
*                                       called some time during Vertical
*                                       Retrace
*
* Returns:      MIDAS error code
*
* Notes:        preVR() and immVR() functions must be as short as possible
*               and do nothing else than update counters or set some VGA
*               registers to avoid timer synchronization problems. inVR()
*               can take a longer time and can be used for, for example,
*               setting the palette.
*
*               Remember to use the correct calling convention for the xxVR()
*               routines! (pascal for Pascal programs, cdecl otherwise).
*
\****************************************************************************/

int CALLING tmrSyncScr(unsigned sync, void CALLING (*_preVR)(),
    void CALLING (*_immVR)(), void CALLING (*_inVR)())
{
    /* We don't want to get disturbed right now: */
    DoCLI();

    /* Save the function pointers: */
    preVR = _preVR;
    immVR = _immVR;
    inVR = _inVR;

    if ( mSyncScreen )
    {
        scrTmrCount = FRAMETIME * sync / 1000;
        scrPVCount = sync - scrTmrCount;
    }
    else
    {
        scrTmrCount = sync;
        scrPVCount = 0;
    }

    /* Next interrupt will be screen - synchronize to screen and start: */
    scrCount = scrTmrCount;
    tmrState = tmrScreen;
    scrSync = 1;
    WaitNextVR();
    SetCount(scrCount);

    /* If we are synchronizing to the screen fully and the card is not
       tempopolling, start screen sync playing: */
    if ( mSyncScreen && (!sdev->tempoPoll) )
    {
        playCount = playTmrCount = scrTmrCount / 4;
        scrPlayer = 1;
    }

    DoSTI();

    return OK;
}




/****************************************************************************\
*
* Function:     int tmrStopScrSync(void);
*
* Description:  Stops synchronizing the timer to the screen.
*
* Returns:      MIDAS error code
*
\****************************************************************************/

int CALLING tmrStopScrSync(void)
{
    DoCLI();

    if ( scrPlayer )
    {
        /* Player was synchronized to screen - restart at 100Hz: */
        playCount = playTmrCount = 1193180/100;
        scrPlayer = 0;
    }

    scrSync = 0;
    scrTimer = 0;
    NextTimer();

    DoSTI();

    return OK;
}




/****************************************************************************\
*
* Function:     int tmrSetUpdRate(unsigned updRate);
*
* Description:  Sets the timer update rate, ie. the rate at which the music
*               playing routines are called
*
* Input:        unsigned updRate        updating rate, in 100*Hz (5000=50Hz)
*
* Returns:      MIDAS error code
*
\****************************************************************************/

int CALLING tmrSetUpdRate(unsigned updRate)
{
    /* Only change if tempopolling: */
    if ( sdev->tempoPoll )
    {
        playTmrCount = 119318000 / updRate;
    }

    return OK;
}









/*
 * $Log: dostimer.c,v $
 * Revision 1.6  1997/01/16 18:41:59  pekangas
 * Changed copyright messages to Housemarque
 *
 * Revision 1.5  1996/10/13 16:53:07  pekangas
 * The timer ISR now sets ES to DS
 *
 * Revision 1.4  1996/08/06 18:46:09  pekangas
 * Removed border colors
 *
 * Revision 1.3  1996/08/06 16:51:36  pekangas
 * Fixed SB and timer conflicts
 *
 * Revision 1.2  1996/08/04 18:08:21  pekangas
 * Fixed a nasty bug in tmrGetScrSync - interrupts were left disabled
 *
 * Revision 1.1  1996/06/06 19:28:17  pekangas
 * Initial revision
 *
*/