Point Programming 1/PPROG1.ISO/c/pas_sdk1/pas/subs/pcm/pcmioc.c

C/C++ Source or Header | 1992-10-01 | 45.6 KB | 1,724 lines

/*$Author:   DCODY  $*/
/*$Date:   01 Oct 1992 12:05:02  $*/
/*$Header:   X:/sccs/pcm/pcmioc.c_v   1.7   01 Oct 1992 12:05:02   DCODY  $*/
/*$Log:   X:/sccs/pcm/pcmioc.c_v  $
 *
 *    Rev 1.7   01 Oct 1992 12:05:02   DCODY
 * next stage of completion for PlayThisBlock, RecordThisBlock, etc.
 *
 *    Rev 1.6   23 Sep 1992 10:56:34   DCODY
 * more work on playthisblock, continuethisblock...
 *
 *    Rev 1.5   26 Aug 1992 10:57:30   DCODY
 * Added Playthisblock and RecordThisBlock
 *
 *    Rev 1.4   12 Aug 1992 17:10:30   DCODY
 * major change to eliminate the foreground buffers.
 *
 *    Rev 1.3   24 Jul 1992 15:36:14   DCODY
 * changed _fmemcpy to _rfmemcpy
 *
 *    Rev 1.2   17 Jul 1992 14:22:50   DCODY
 * InitMVSound() now performed within OpenPCMBuffering().
 *
 *    Rev 1.1   23 Jun 1992 17:11:42   DCODY
 * PAS2 update
 *
 *    Rev 1.0   15 Jun 1992 09:44:38   BCRANE
 * Initial revision.
*/
/*$Logfile:   X:/sccs/pcm/pcmioc.c_v  $*/
/*$Modtimes$*/
/*$Revision:   1.7  $*/
/*$Workfile:   pcmioc.c  $*/


    /*\
    |*|----====< PCMIOC.C >====----
    |*|
    |*| These routines maintain DMA controlled I/O of the Audio Spectrum
    |*|
    |*| Copyright (c) 1991, Media Vision, Inc. All rights reserved.
    |*|
    \*/

#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>

#include "pcmio.h"
#include "common.h"
#include "mvsound.h"


    /*\
    |*|-----------====< T H E O R Y   O F    O P E R A T I O N >====------------
    |*|
    |*| The best DMA controlled PCM output requires a continuous stream of data
    |*| to be available in a real-time environment.
    |*|
    |*| DMA controlled PCM input, with the same real-time requirements, needs
    |*| to be able to keep storing data into memory without pausing.
    |*|
    |*| The following approach is designed to allow the DMA to be setup in
    |*| "auto-initialize" mode, thereby guarenteeing continuous play/record.
    |*|
    |*| To keep the DMA running, multiple divisions of the DMA buffer are
    |*| used to keep the data moving. Due to the fact that DOS is neither
    |*| a real-time, or re-entrant operating system, this code divides up
    |*| the buffer management tasks into a "foreground" and "background" task.
    |*|
    |*| A sample buffer count timer on the Audio Spectrum is used to interrupt
    |*| the CPU when a DMA buffer division has filled or emptied. For our
    |*| purposes here, this amount may be 1/2, 1/4, 1/8th or some smaller
    |*| division of the whole DMA buffer. Note: judgement must be used here
    |*| in selecting the DMA buffer size, and the integral division. Too small
    |*| of an integral may result in broken DMA I/O. A buffer too large never
    |*| hurts anything. (it just reduces the amount of available memory).
    |*|
    |*|                 ----====< PCM OUTPUT >====----
    |*|
    |*| To perform PCM output ("play"), A linked list of buffer pointers is
    |*| used to fill the DMA buffer by the foregound task. As the DMA runs,
    |*| it will send the buffer contents to the audio card. Here is a visual:
    |*|
    |*|                            
    |*|                      Foreground Loads
    |*|                        the Top Level
    |*|                          Buffers
    |*|                            
    |*|                        ┌─┬─┬─┬─┬─┐
    |*|      DMA Level Buffers │ │ │ │ │ │
    |*|                        └─┴─┴─┴─┴─┘
    |*|                            
    |*|                        ┌─────────┐
    |*|                        │hardware │
    |*|                        └╥╥╥──────┘
    |*|
    |*| To actually start the output, the foreground task loads it's
    |*| buffers, then starts the DMA to play the buffer. The background
    |*| task only indicates when each block is played. It will shut down
    |*| the DMA if no more data is present in the buffers.
    |*|
    |*| If the foreground task can keep the linked list of buffers full,
    |*| there should be non-stop PCM output (Good!). If the foreground task
    |*| does not keep up, the background task will be forced to stop the
    |*| the DMA, thereby causing a break in the output (Bad!). Once the DMA
    |*| has stopped, the foreground task will have to restart the DMA a
    |*| second time to continue the flow of data.
    |*|
    |*|                 ----====< PCM INPUT >====----
    |*|
    |*| To perform PCM input ("record"), the same linked list of buffers
    |*| are also used. This buffer is filled with sampled data from the
    |*| hardware. The background process will increment a global variable for
    |*| each buffer filled. The foreground routine must extract each buffer
    |*| and process it (copy to memory, or write it to disk). Here is a visual:
    |*|
    |*|                            
    |*|                      Foreground unloads
    |*|                        the Top Level
    |*|                          Buffers
    |*|                            
    |*|                        ┌─┬─┬─┬─┬─┐
    |*|      DMA Level Buffers │ │ │ │ │ │
    |*|                        └─┴─┴─┴─┴─┘
    |*|                            
    |*|                        ┌─────────┐
    |*|                        │hardware │
    |*|                        └╥╥╥──────┘
    |*|
    |*| To actually start the input, the foreground starts the DMA running to
    |*| begin the transfer. The background task increments the global variable
    |*| as each interrupt occurs. If all the buffers are full, the DMA transfer
    |*| is terminated. The foreground routine must poll this variable to keep
    |*| the data moving out of the DMA buffer.
    |*|
    |*| If the foreground task can keep the linked list of buffers empty,
    |*| there should be non-stop PCM input (Good!). If the foreground task
    |*| does not keep up, the background task will be forced to stop the
    |*| the DMA, thereby causing a break in the input (Bad!). Once the DMA
    |*| has stopped, the foreground task will have to restart the DMA tranfer
    |*| a second time to restart the DMA.
    |*|
    |*|                 ----====< DATA VARIABLES >====----
    |*|
    |*| The following is a description of the variables shared between the
    |*| foreground and background tasks. There are three global variables,
    |*| and a linked list of buffers shared between the two tasks.
    |*|
    |*| The linked list of buffers uses a "header" to each buffer. This
    |*| header holds the information for linking to the next buffer, whether
    |*| the buffer is full or empty, and the count of bytes in the buffer.
    |*|
    |*| typedef struct _buffptr {
    |*|     int status;                 /* 0=empty, 1=full                 * /
    |*|     int count;                    /* # of bytes in the buffer      * /
    |*|     int size;                    /* total size of read data         * /
    |*|     char huge *buffer;            /* pointer to buffer data         * /
    |*|     struct _buffptr *nextptr;    /* pointer to next buffer         * /
    |*|
    |*| } BuffData,*BuffPtr;
    |*|
    |*| BuffPtr HeadOfBuffers;            /* global variable head pointer  * /
    |*| int BufferDataCount;            /* # of full DMA buffers parts     * /
    |*| int DMARunning;                 /* DMA status (0=off,1=running)  * /
    |*| char far *StartOfDMABuffer;     /* start of actual DMA buffer     * /
    |*| int ProcessedBlockCount;        /* # of blocks DMA handled         * /
    |*|
    |*| "HeadOfBuffers" points to the first buffer in the linked list.
    |*|
    |*|       This linked list is made up of structures containing the buffer
    |*|     data and other information. The last entry in the list points
    |*|     back to the first entry, thereby creating a circular linked
    |*|     list.
    |*|       Each buffer has a status word: 0=empty,1=full.
    |*|       The count indicates the # of bytes in the buffer. This count
    |*|     is used to communication between the foreground and background
    |*|     process that data is available. For output, the count tells the
    |*|     background that data is available to be loaded in the DMA buffer.
    |*|     For input, the count tells the foreground process that there is
    |*|     data to be written to disk.
    |*|
    |*| "BufferDataCount" is the key handshaking variable between the
    |*|     foreground and background processes. It indicates how many DMA
    |*|     buffers divisions contain data.
    |*|
    |*|     For output, it holds a count of DMA divisions hold data. This
    |*|     global variable is incremented each time a buffer is loaded by
    |*|     the foreground task, and decremented when a buffer is emptied
    |*|     by the background task.
    |*|
    |*|     For input, it holds the number of buffers with data in the DMA
    |*|     buffer. It is incremented by the background process and
    |*|     decremented by the foreground process.
    |*|
    |*| "DMARunning" is set to true or false depending upon the state
    |*|     of the DMA channel. It is set TRUE when the DMA is running (either
    |*|     playing or recording), and FALSE when the DMA is turned off.
    |*|
    |*| "ProcessedBlockCount" is the running total of blocks the DMA has
    |*|     processed from the last Start I/O call.
    |*|
    |*|     For input, this is the total number of dma divisions filled
    |*|     by the DMA.
    |*|
    |*|     For output, this is the total number of blocks loaded into
    |*|     the DMA buffer.
    |*|
    |*| "StartOfDMABuffer" points to the first byte of the DMA circular buffer.
    |*|
    |*| The following routines provide a high level interface to DMA driven
    |*| PCM output:
    |*|
    |*| int  OpenPCMBuffering  ( int, int, int, int )
    |*|
    |*|         This routine is the first routine to be called. It sets
    |*|         up the DMA channel, IRQ, and allocates memory for the buffers.
    |*|
    |*| int PCMState ( int, int, int, int )
    |*|
    |*|         This routine passes in the sample rate, stereo/mono flag,
    |*|         the compression type (0 for 8 bit, 1 for for 4 bit),
    |*|         and the PCM data sample size (8 or 16).
    |*|
    |*| int  StartFileInput    ( FILE *f )
    |*|
    |*|         This routine begins recording the PCM data to the disk file.
    |*|         The routine returns immediately. The routine,
    |*|         "ContinueFileInput" must be called to continue moving data
    |*|         from the DMA buffer to to the disk.
    |*|
    |*| int  StartBlockInput   (  )
    |*|
    |*|         This routine begins recording the PCM data. The routine
    |*|         returns immediately. Subsequent call must be made to
    |*|         "ContinueBlockInput" to receive data from the DMA buffer.
    |*|
    |*| int  StartFileOutput   ( FILE *f, long )
    |*|
    |*|         This routine begins playing the PCM data from the disk file.
    |*|         The routine returns immediately. The routine,
    |*|         "ContinueFileOutput" must be called to continue moving data
    |*|         from the disk to the DMA buffer. The long variable tells how
    |*|         many bytes to play.
    |*|
    |*| int  StartBlockOutput  ( char far * )
    |*|
    |*|         This routine begins playing the caller's PCM data. The
    |*|         routine returns immediately. The routine, "ContinueBlockOutput"
    |*|         must subsequently be called to continue data output.
    |*|
    |*| int  ContinueFileInput    ( )
    |*|
    |*|         This routine checks to see if new data has been loaded into
    |*|         the linked list of buffers. If so, the data is written to
    |*|         disk, and the buffer is freed up.
    |*|
    |*| int  ContinueBlockInput ( char far * )
    |*|
    |*|         This routine checks to see if new data has been loaded into
    |*|         the linked list of buffers. If so, the data is written to
    |*|         the caller's buffer.
    |*|
    |*| int  ContinueFileOutput  ( )
    |*|
    |*|         This routine checks to see if the PCM hardware is
    |*|         still playing. This routine MUST be called frequently to
    |*|         maintain continuous PCM output.
    |*|
    |*| int  ContinueBlockOutput (char far *)
    |*|
    |*|         This routine checks to see if the PCM hardware is
    |*|         still playing. The caller passes the next block to be
    |*|         played. A non-zero return value indicates the block has
    |*|         been queued up to be played. A zero value means the buffer
    |*|         is currently full, please try again...
    |*|
    |*| void StopDMAIO          ( )
    |*|
    |*|         This routine is used to prematurely terminate PCM I/O.
    |*|
    |*| void ClosePCMBuffering ( )
    |*|
    |*|         This routine is used to close down the whole PCM I/O system.
    |*|         This call MUST be made before the caller's program terminates.
    |*|
    \*/

    /*\
    |*|----====< Code Generation >====----
    \*/

#define BLOCKOUT    0        /* builds block output code only            */
#define BLOCKIN     0        /* builds block input code only             */
#define FILEOUT     0        /* builds file output code only             */
#define FILEIN        0        /* builds file input code only                */
#define COMMDATA    0        /* builds both common code and data         */

#ifdef    BUILDBO
#undef  BLOCKOUT
#define BLOCKOUT    1
#endif

#ifdef    BUILDBI
#undef  BLOCKIN
#define BLOCKIN     1
#endif

#ifdef    BUILDFO
#undef  FILEOUT
#define FILEOUT     1
#endif

#ifdef    BUILDFI
#undef  FILEIN
#define FILEIN        1
#endif

#ifdef    BUILDCO
#undef    COMMDATA
#define COMMDATA    1
#endif

    /*\
    |*|----====< common data for CODE and DATA generation >====----
    \*/

        /* buffer linked list header structures                             */

        typedef struct _buffptr {
            int status;                     /* 0=empty, 1=full                */
            int count;                        /* # of bytes in the buffer     */
            int size;                        /* total size of allocated buff */
            char huge *buffer;                /* pointer to buffer data        */
            struct _buffptr *nextptr;        /* pointer to next buffer hdr    */

        } BuffData,*BuffPtr;

#define NODIRECTION     0                    /* defines for DirectionFlag    */
#define DMAINPUT        1
#define DMAOUTPUT        2


    /*\
    |*|----====< Global Data >====----
    \*/

#define QUEUESIZE    32                        /* 32 entries                    */
#define QUEUEMASK    0x1F                    /* mask to circulate the count    */

#if COMMDATA

        int MaxBuffCount = 0;                /* # of DMA buffer divisions    */
        int BufferSize = 0;                 /* size of each buffer division */

    /* shared global variables between the two tasks (in pcmioa.asm)        */

        BuffPtr HeadOfBuffers = 0;            /* global variable head pointer */
        int BufferDataCount   = 0;            /* # of full buffers (0=done)    */
        int DMARunning          = 0;            /* DMA status (0=off,1=running) */
        char huge *DMABuffPtr = 0;            /* 128k+1 DMA buffer pointer    */
        char far  *StartOfDMABuffer = 0;    /* start of DMA buffer pointer    */
        int ProcessedBlockCount = 0;        /* # of I/O blocks processed    */
        unsigned long _file_data_length = 0;/* size of data output            */
        char __pcmdatasize      = 8;            /* default to 8 bit pcm         */

        FILE *__fptr = 0;                   /* file pointer for disk I/O    */
        char *__LocalBuff = 0;                /* local target buffer            */
        BuffPtr __NextPtr = 0;                /* next buffer pointer            */
        int __DirectionFlag = 0;            /* current I/O direction        */
        char far * __singleblockpointer;    /* single shot users buffer     */

    /* local data for this body of code, but needs to be public             */

        int VoiceActivatedSavedCount = 0;    /* # of I/O blocks saved        */

        int  __queuein      = 0;
        int  __queueincnt = 0;
        int  __queueout   = 0;
        long __queuedata  = 0;

        char far *__queuebuff[QUEUESIZE];    // number of queued blocks
        long __queuelen[QUEUESIZE];         // queued block lengths
        void (far * __queuecb[QUEUESIZE])();// queue of callback routines

        void (far *__synccallback)() = 0;    // callback to user code

#else

        extern int MaxBuffCount;            /* # of DMA buffer divisions    */
        extern int BufferSize;                /* size of each buffer division */

    /* shared global variables between the two tasks (in pcmioa.asm)        */

        extern BuffPtr HeadOfBuffers;        /* global variable head pointer */
        extern int BufferDataCount;         /* # of full buffers (0=done)    */
        extern int DMARunning;                /* DMA status (0=off,1=running) */
        extern char huge *DMABuffPtr;        /* 128k+1 DMA buffer pointer    */
        extern char far *StartOfDMABuffer;    /* start of DMA buffer pointer    */
        extern int ProcessedBlockCount;     /* # of I/O blocks processed    */
        extern unsigned long _file_data_length; /* size of data output        */
        extern char __pcmdatasize;            /* default to 8 bit pcm         */

        extern FILE *__fptr;                /* file pointer for disk I/O    */
        extern char *__LocalBuff;            /* local target buffer            */
        extern BuffPtr __NextPtr;            /* next buffer pointer            */
        extern int __DirectionFlag;         /* current I/O direction        */
        extern char far* __singleblockpointer;/* single shot users buffer  */

        extern int VoiceActivatedSavedCount;/* # of I/O blocks saved        */

        extern int    __queuein;
        extern int    __queueincnt;
        extern int    __queueout;
        extern long __queuedata;

        extern char far *__queuebuff[];     // number of queued blocks
        extern long __queuelen[];            // queued block lengths
        extern void (far * __queuecb[])();    // queue of callback routines

        extern void (far *__synccallback)();// callback to user code

#endif

    /* additional prototypes                                                */

        void far  * _rfmemcpy (void far *, void far *, unsigned int);
        void huge * _rfhmemcpy(void huge *,void huge *,unsigned int);

#if BLOCKOUT
        static int _loadtheblock  ( char far * );
#endif

#if FILEOUT
        static int _loadthebuffer ( FILE * );
#endif



    /*\
    |*|-----------------====================================-----------------
    |*|-----------------====< Start of Executable Code >====-----------------
    |*|-----------------====================================-----------------
    \*/

#if FILEIN
    /*\
    |*|----====< ASpecialContinueFileInput >====----
    |*|
    |*| This is a special adaptation of the standard, "ContinueDMAInput"
    |*| routine. It will check the noise level in each block before writting
    |*| it out to disk. This way, no data is written until a noise level
    |*| is reached.
    |*|
    \*/
int ASpecialContinueFileInput(noise,goflag)
    int noise;    /* offset from silence                                    */
    int goflag; /* record all after first block                         */
{
int temp;

    /* if BufferDataCount is non-zero, we must process the DMA data     */

        while (BufferDataCount) {

            /* data is available, move it out to memory                 */

                _rfmemcpy (__LocalBuff,__NextPtr->buffer,BufferSize);

            /* validate the level of noise before writing  it to disk    */

                if (MakeHalfHistoGram(__LocalBuff,BufferSize,noise) ||
                    (VoiceActivatedSavedCount && goflag) ) {

                    /* if not all data is written, return in error        */

#if LARGEDATA
                    if (fwrite (__NextPtr->buffer,1,BufferSize,__fptr) != BufferSize) {
                        StopDMAIO();
                        return (0);
                    }
#else
                    if (fwrite (__LocalBuff,1,BufferSize,__fptr) != BufferSize) {
                        StopDMAIO();
                        return (0);
                    }
#endif
                    VoiceActivatedSavedCount++;
                }
                else
                    ProcessedBlockCount--;

            /* move to the next buffer                                    */

                __NextPtr->count = __NextPtr->status = 0;
                __NextPtr = __NextPtr->nextptr;
                BufferDataCount--;
        }
        return (DMARunning);
}
#endif


#if COMMDATA
    /*\
    |*|----====< ClosePCMBuffering >====----
    |*|
    |*| Removes the PCM system & deallocates the buffer memory. There is
    |*| no return value.
    |*|
    \*/
void ClosePCMBuffering()
{
BuffPtr p,op;

    /* we will kill the DMA low level processing                        */

        StopDMAIO();
        _unloadirqvector();

    /* Free up the linked list of buffers                                */

        if ((p = HeadOfBuffers) != 0) {

            do {
                op    = p;                /* save the old ptr             */
                p    = p->nextptr;        /* point to the next buffer     */
                free  (op);             /* free up the old header        */

            } while ( (p != HeadOfBuffers) && p );
       }

    /* free up the DMA buffer                                            */

        if (DMABuffPtr)
            hfree (DMABuffPtr);

    /* null it all out...                                                */

        DMABuffPtr         = 0;
        HeadOfBuffers     = 0;
        StartOfDMABuffer = 0;
        BufferDataCount  = BufferSize = DMARunning = 0;

}
#endif


#if BLOCKIN
    /*\
    |*|----====< ContinueBlockInput >====----
    |*|
    |*| This routine checks to see if another buffer can be stored in memory.
    |*| if so, it will load copy the DMA buffer to the caller's local buffer,
    |*| A return value of 0 indicates the caller's buffer is empty.
    |*|
    \*/
int ContinueBlockInput(buff)
    char far *buff;
{

    /* if BufferDataCount is non-zero, we must move the data to memory    */

        if (BufferDataCount) {

            /* data is available, just move it out                        */

                _rfmemcpy (buff,__NextPtr->buffer,BufferSize);

            /* move to the next buffer                                    */

                __NextPtr->count = __NextPtr->status = 0;
                __NextPtr = __NextPtr->nextptr;
                BufferDataCount--;

            /* returns the fact that the data has been loaded            */

                return(1);
        }
        return (0);
}


    /*\
    |*|----====< ContinueThisBlockInput >====----
    |*|
    |*| This routine extracts a DMA buffer into one or
    |*| more target user buffers.
    |*|
    |*| Returns:
    |*|    Nonzero for running & processing, else 0 for dead.
    |*|
    \*/
int  ContinueThisBlockInput()
{
int n,          // working integer
    loop,        // loop flag to keep loading blocks
    bcount;     // increments the BufferDataCount
int result = 0; // holds the final count

static int TargetSize;     // remaining size of the target dma buffer
static char far *dmaptr; // pointer to this DMA block

    // if the DMA is dead, give it a jump start. Bad thing, it flushes all...

        if (DMARunning == 0) {

            // blow off anything that is saved locally

                dmaptr = 0;
                TargetSize = 0;

            // reset and restart the low level stuff...

                _resetbuffers();
                StartTheDMAInput(ContinueThisBlockInput);

            // we have no more data, just return now

                return(DMARunning);
        }

    // if the current remaining length is null, prime for the next block

        if (_file_data_length == 0) {

            // bomb out if no data buffers queued up

            if (__queueincnt == 0)
                return(1);

            // get the next block from the queue

            _file_data_length     = __queuelen [__queueout];
            __singleblockpointer = __queuebuff[__queueout];
        }

    // loop here to stuff as many blocks as possible into the DMA buffer

    nextblock:

    // move up to one buffer division worth of data

        if (!TargetSize) {

            dmaptr = __NextPtr->buffer;
            TargetSize = BufferSize;
        }

        loop = TRUE;
        bcount = 1;

    // move as many blocks as possible into the DMA buffer

        while (loop) {

            // Get the block length, up to the division size

                if (_file_data_length <= TargetSize) {

                    n = _file_data_length;    // full target size
                    _file_data_length = 0;

                }
                else                        // partial target size

                    _file_data_length -= (n = TargetSize);

            // copy the data to the buffer, and advance the buffer that far

                if (n) {

                    // move the recorded data into the buffer

                    __singleblockpointer
                        = _rfmemcpy(__singleblockpointer,dmaptr,n);
                    dmaptr += n;                // move the dma pointer
                    result += n;                // more for the return value

                    __queuedata -= (n &0xffff); // less queued up
                    BufferDataCount -= bcount;    // increment buffer count once
                    bcount = 0;

                }

            // if the length is zero, this buffer is done, let the caller know

                if (!_file_data_length) {

                    // let the app. know we are done with this buffer

                        if (__queuecb[__queueout])
                            (*__queuecb[__queueout])(__queuebuff[__queueout],__queuelen[__queueout]);

                        __queueincnt--;
                        __queueout = ++__queueout & QUEUEMASK;

                    // Now, try to get the next available block out of the list

                    if (__queuein != __queueout) {

                        _file_data_length     = __queuelen[__queueout];
                        __singleblockpointer = __queuebuff[__queueout];
                    }
                    else
                        loop = FALSE;
                }

            // we are now done with this much of the buffer, stop if zero

                if (!(TargetSize -= n))
                    loop = FALSE;

        }

    // advance the list to the next DMA buffer and count one more...

        __NextPtr = __NextPtr->nextptr;

    // if we can do more, then DO IT!!!

        if (BufferDataCount > 0) {                // if there is data in the DMA...
            if (__queueincnt)                    // if we have buffers...
                    goto nextblock;             // then go load it...
        }

    // return the number of bytes loaded

        return(result);

}

#if 0

    //////////////// Original ContinueThisBlockInpu ///////////////


    /* if there is no more data, just exit                                    */

        if (!_file_data_length)
            return(0);

    /* move as much as possible...                                            */


        if (_file_data_length <= BufferSize) {
            n = _file_data_length;
            _file_data_length = 0;
        }
        else {
            _file_data_length -= (n = (BufferSize & 0xffff));
        }

        __singleblockpointer =
            _rfmemcpy(__singleblockpointer,__NextPtr->buffer,n);

        BufferDataCount--;



        __NextPtr         = __NextPtr->nextptr; /* advance the list     */

        return(n);
#endif


#endif


#if FILEIN
    /*\
    |*|----====< ContinueFileInput >====----
    |*|
    |*| This routine checks to see if another buffer can be written to disk.
    |*| if so, it will load copy the buffer to a local buffer, then write it
    |*| out to disk. A return value of 0 indicates recording has stopped,
    |*| which could mean that the disk file is full, so the DMA had to be
    |*| stopped prematurely.
    |*|
    \*/
int ContinueFileInput()
{

    /* if BufferDataCount is non-zero, we must write out the data        */

        while (BufferDataCount) {

            /* data is available, move it out to disk                    */

#if LARGEDATA

            /* if not all data is written, return in error                */

                if (fwrite (__NextPtr->buffer,1,BufferSize,__fptr) != BufferSize) {
                    StopDMAIO();
                    return (0);
                }
#else
            /* if not all data is written, return in error                */

                _rfmemcpy  (__LocalBuff,__NextPtr->buffer,BufferSize);
                if (fwrite (__LocalBuff,1,BufferSize,__fptr) != BufferSize) {
                    StopDMAIO();
                    return (0);
                }
#endif
            /* move to the next buffer                                  */

                __NextPtr->status = 0;
                __NextPtr = __NextPtr->nextptr;
                BufferDataCount--;
        }
        return (DMARunning);
}
#endif


#if BLOCKOUT
    /*\
    |*|----====< ContinueBlockOutput >====----
    |*|
    |*| This routine checks to see if another DMA buffer can be loaded.
    |*| If so, it will load the user's block data into an empty buffer.
    |*| A return value of 1 indicates the buffer has been loaded, else
    |*| it must be sent in again until it is loaded.
    |*|
    \*/
int ContinueBlockOutput(buff)
    char far *buff;
{

    /* if the internal count is not max-ed out, try to load the next buffer */

        if (BufferDataCount < MaxBuffCount ) {

            _loadtheblock (buff);

            if (DMARunning == 0) {        /* yuck! a DMA break!            */
                _resetbuffers();
                StartTheDMAOutput(0);
            }

            return (1);                 /* return running                */
        }
        else
            return(0);
}


    /*\
    |*|----====< ContinueThisBlockOutput >====----
    |*|
    |*| This routine checks to see if another DMA buffer can be loaded.
    |*| If so, it will load the user's block data into an empty buffer.
    |*| A return value of ~0 indicates the buffer has been loaded.
    |*|
    |*| The foreground routine will call this when DMARunning == 0. The
    |*| background routine will call this at every interrupt to keep the
    |*| buffers loaded
    |*|
    \*/
int ContinueThisBlockOutput()
{

int n,          // working integer
    TargetSize, // size of the target dma buffer
    loop,        // loop flag to keep loading blocks
    bcount;     // increments the BufferDataCount
int result = 0; // holds the final count
char far *s;

    // If no more data to load in the buffer, flush the next DMA & return

        if (__queueincnt == 0) {
            FlushBuffer (__NextPtr->buffer,BufferSize);
            __NextPtr = __NextPtr->nextptr;
            return(0);
        }

    // if there is little data, but a lot in the DMA, just return

        if ((__queuedata < BufferSize) && BufferDataCount > 2)
            return(0);

    // if the DMA has been turned off, re-sync the buffers

        if (DMARunning == 0)
            _resetbuffers();

    // if the current remaining length is null, prime for the next block

        if (_file_data_length == 0) {
            _file_data_length     = __queuelen [__queueout];
            __singleblockpointer = __queuebuff[__queueout];
        }

    // loop here to stuff as many blocks as possible into the DMA buffer

    nextblock:

    // move up to one buffer division worth of data

        TargetSize = BufferSize;
        s = __NextPtr->buffer;
        loop = TRUE;
        bcount = 1;

    // move as many blocks as possible into the DMA buffer

        while (loop) {

            // Get the block length, up to the division size

                if (_file_data_length <= TargetSize) {

                    n = _file_data_length;    // full target size
                    _file_data_length = 0;

                }
                else                        // partial target size

                    _file_data_length -= (n = TargetSize);

            // copy the data to the buffer, and advance the buffer that far

                if (n) {

                    s = _rfmemcpy(s, __singleblockpointer, n );

                    result += n;                // more for the return value
                    __singleblockpointer += n;    // advance the pointer
                    __queuedata -= (n &0xffff); // less queued up

                    BufferDataCount += bcount;  // increment buffer count once
                    bcount = 0;

                }
                else
                    s = __NextPtr->buffer;        // no data, but do point here

            // if the length is zero, this buffer is done, let the caller know

                if (!_file_data_length) {

                    // if this old block was valid, send a DONE msg.

                    if(__queueincnt) {

                        // let the app. know we are done with this buffer

                        if (__queuecb[__queueout])
                            (*__queuecb[__queueout])(__queuebuff[__queueout],FALSE);

                        __queueincnt--;
                        __queueout = ++__queueout & QUEUEMASK;
                    }

                    // Now, try to get the next available block out of the list

                    if (__queuein == __queueout) {

                        FlushBuffer (s,TargetSize-n);
                        loop = FALSE;

                    }
                    else {

                        _file_data_length     = __queuelen[__queueout];
                        __singleblockpointer = __queuebuff[__queueout];

                    }
                }

            // we are now done with this much of the buffer, stop if zero

                if (!(TargetSize -= n))
                    loop = FALSE;
        }

    // advance the list to the next DMA buffer and count one more...

        __NextPtr = __NextPtr->nextptr;

    // if we can do more, then DO IT!!!

        if (BufferDataCount < MaxBuffCount) {    // if there is room in the DMA
            if (__queueincnt) {                 // if we have pcm data
                if (__queuedata >= BufferSize)    // and its GE a buffer division,
                    goto nextblock;             // then go load it...
            }
        }

        if (DMARunning == 0)
            StartTheDMAOutput(ContinueThisBlockOutput);

    // return the number of bytes loaded

        return(result);

}
#endif


#if FILEOUT
    /*\
    |*|----====< ContinueFileOutput >====----
    |*|
    |*| This routine checks to see if another buffer can be loaded. If so, it
    |*| will load the data into an empty buffer. All empty buffers will be
    |*| loaded. A return value of 0 indicates playing has finished.
    |*|
    \*/
int ContinueFileOutput()
{

    /* if BufferDataCount is not max-ed out, try to load the next buffer*/

        if (BufferDataCount < MaxBuffCount ) {

            if (_loadthebuffer (__fptr)) {

                if (DMARunning == 0) {     /* yuck! a DMA break!            */
                    _resetbuffers();
                    if (StartTheDMAOutput(0))
                        return(0);
                }
            }
        }
        return (DMARunning);            /* return the DMA state         */
}
#endif


#if COMMDATA
    /*\
    |*|----====< OpenPCMBuffering >====----
    |*|
    |*|  This routine is the first-call routine. It initializes the buffers
    |*|  needed for the PCM play/record system. A return value of non-zero
    |*|  indicates a failure to initialize the system.
    |*|
    |*|  Entry Conditions:
    |*|
    |*|         dma -- New DMA #. (1-3, or -1 for no changes)
    |*|         irq -- New IRQ #. (3,5,6,7, or -1 for no changes)
    |*|
    |*|  Exit Conditions:
    |*|
    |*|         non-zero return indicates an error
    |*|
    \*/
int OpenPCMBuffering(dma,irq,dmasize,divisions)
   int dma;         /* DMA channel # (-1 for no changes)    */
   int irq;         /* IRQ channel # (-1 for no changes)    */
   int dmasize;     /* requested DMA size (4/8/16/32/64)    */
   int divisions;    /* # of divisions in the DMA buffer     */
{
BuffPtr op,p;
long l;
int n;
char far *db;

    /* setup the globa variables & a local buffer                        */

        MaxBuffCount = divisions;
        BufferSize     = LONG(dmasize) * 1024L / LONG(MaxBuffCount);

    /* Setup the lowlevel routines                                        */

        InitMVSound();

    /* flush any background task setup                                  */

        BackgroundInit( BufferSize, MaxBuffCount );

        if ((__LocalBuff=(char*)malloc(BufferSize)) == 0)
             return (PCMIOERR_OPENFILE);

    /* Allocate twice the size for background DMA buffer                */

        l = LONG(dmasize) * 1024 * 2;

        if ((DMABuffPtr = (char huge *) halloc (l,1)) == 0)
            return(PCMIOERR_NOMEM);

        if ((db=StartOfDMABuffer=FindDMABuffer(DMABuffPtr,dmasize)) == 0)
            return (PCMIOERR_OPENPCM);

    /* if the low level code doesn't like it, bomb out                  */

        if (!DMABuffer ( StartOfDMABuffer, dmasize, MaxBuffCount ))
            return(PCMIOERR_OPENPCM);

    /* Attempt to allocate each foreground buffer                        */

        op = 0;
        for (n=0;n<divisions;n++) {

            /* allocate the linked list header for each buffer            */

                if ((p = (BuffPtr) malloc (sizeof(BuffData))) == 0)
                    return(PCMIOERR_NOMEM);

            /* reset the pointer in case of other failures during init    */

                p->nextptr = 0;

            /* if first block, save as the head of the list             */

                if (!HeadOfBuffers)
                    HeadOfBuffers = p;

            /* if we have already allocated a block, setup the fwd ptr    */

                if (op)
                    op->nextptr = p;

                p->buffer = db;
                p->size   = BufferSize;
                db          += BufferSize;

            /* save as the old pointer for linking purposes             */

                op = p;
        }

    /* link the last buffer back to the first                            */

        p->nextptr = HeadOfBuffers;

    /* Possibly select new DMA & IRQ channels                            */

        if (dma != -1)
            if (SelectDMA(dma))
                return(PCMIOERR_BADDMA);

        if (irq != -1)
            if (SelectIRQ(irq))
                return(PCMIOERR_BADIRQ);

    /* well, it looks good so far, flush any variables                    */

        BufferDataCount   = ProcessedBlockCount =
        _file_data_length = __queuedata         =
        VoiceActivatedSavedCount = __queueincnt =
        __queuein  = __queueout = 0;

    /* and return good!                                                 */

        return (0);
}
#endif


#if COMMDATA
    /*\
    |*|----====< PCMState >====----
    |*|
    |*| This routine passes in the sample rate, stereo/mono flag, and any
    |*| other miscellaneous data (to be determined later...)
    |*|
    |*| Exit Conditions:
    |*|    Non-zero means the sample rate was in error.
    |*|    Zero means the sample rate was okay error.
    |*|
    \*/
int PCMState(sr,sm,cp,sz)
    long sr;    /* sample rate    */
    int  sm;    /* stereo/mono    */
    int  cp;    /* compression    */
    int  sz;    /* size(8/16)    */
{

    /* just pass them on...                                             */

        __pcmdatasize = sz;                     /* pcm data size        */
        return (!PCMInfo (sr,sm,cp,sz));

}
#endif


#if COMMDATA
    /*\
    |*|----====< StopDMAIO >====----
    |*|
    |*| This routine forceably kills the PCM I/O. All buffers will be
    |*| reset, the current position of the input file is not altered. There
    |*| is no return value.
    |*|
    \*/
void StopDMAIO()
{

    /* if this code has not already been setup, exit now                */

        if (!HeadOfBuffers)
            return;

    /* stop the hardware...                                             */

        StopPCM( );

        __queuein    = __queueincnt = __queueout = DMARunning = 0;
        __queuedata = _file_data_length = 0;

    /* flush any prior background task setup                            */

        if (__DirectionFlag == DMAOUTPUT) {
            if (__fptr)
                rewind    (__fptr);
        }

    /* reset the linked list of buffers                                 */

        _resetbuffers();

    /* setup our internal direction flag                                */

        __DirectionFlag = NODIRECTION;
}
#endif


#if BLOCKIN
    /*\
    |*|----====< StartBlockInput >====----
    |*|
    |*| This routine resets the buffer pointers, then starts up
    |*| the DMA PCM input. Nothing else needs to be done. A return
    |*| value of 0 indicates the DMA failed to startup; No input
    |*| is occuring.
    |*|
    \*/
int StartBlockInput()
{

    /* setup our internal direction flag                                */

        __DirectionFlag = DMAINPUT;

    /* Reset the # of blocks seen during I/O processing                 */

        ProcessedBlockCount = 0;

    /* Flush all buffers                                                */

        _resetbuffers();

    /* if the hardware level code isn't gonna work, then return a failure. */

        return (!StartTheDMAInput(0));
}


    /*\
    |*|----====< RecordThisBlock >====----
    |*|
    |*| This routine offers the caller a simplified recording of one
    |*| variable length block of data. The call just needs to call
    |*| OpenPCMBuffering, then RecordThisBlock. The caller just has
    |*| to poll DMARunning to see if the block has completed. Calling
    |*| StopDMAIO will stop the process, if need be.
    |*|
    \*/
int RecordThisBlock(p,len,cb)
    char far *p;
    unsigned long len;
    void (far *cb)();
{
int n;

        ///////////////////// under construction! /////////////////////////

    // if the pointer is valid, then queue it up

        if (p) {

            // return if already full

            if (__queuein == QUEUESIZE)
                return(2);

            // extract the 1st entry from the queue

            __queuebuff[__queuein] = p;
            __queuedata += (__queuelen [__queuein] = len);
            __queuecb  [__queuein] = cb;
            __queuein  = ++__queuein & QUEUEMASK;
            __queueincnt++;

        }

    // if the blocks are not recording , the let'er rip...

        if ((DMARunning == 0) && __queueincnt ) {

            // setup the direction flag

                __DirectionFlag = DMAINPUT;

            /* reset the DMA block pointers                             */

                _resetbuffers();

            /* return good or bad if the PCM engine is running            */

                return (ContinueThisBlockInput() ? 1 : 0 );

        }

    // assume the block is now recording

        return(0);

}
#endif


#if FILEIN
    /*\
    |*|----====< StartFileInput >====----
    |*|
    |*| This routine resets the buffer pointers, then starts up the DMA PCM
    |*| input. Nothing else needs to be done.
    |*|
    \*/
int StartFileInput(f)
   FILE *f;
{

    /* save our local file handle                                        */

        __fptr      = f;

    /* setup our internal direction flag                                */

        __DirectionFlag = DMAINPUT;

    /* Reset the # of blocks seen during I/O processing                 */

        ProcessedBlockCount = 0;

    /* Flush all buffers and other stuff..                                */

        _resetbuffers();
        VoiceActivatedSavedCount = 0;

    /* start the DMA engine                                             */

        return (!StartTheDMAInput(0));
}
#endif


#if BLOCKOUT
    /*\
    |*|----====< StartBlockOutput >====----
    |*|
    |*| This routine allocates and loads the necessary buffers with data from
    |*| the PCM disk file. Upon return, if there is data available, the
    |*| background task will be called to start the DMA. The file handle will
    |*| be saved in a global variable to be access from other foreground
    |*| routines. a non-zero return value indicates PCM output is playing.
    |*|
    \*/
int StartBlockOutput(buff)
    char far *buff;
{

    /* setup our internal direction flag                                */

        __DirectionFlag = DMAOUTPUT;

    /* Reset the # of blocks seen during I/O processing                 */

        ProcessedBlockCount = 0;

    /* load the DMA buffers                                             */

        _resetbuffers();
        _loadtheblock (buff);

    /* return good or bad if the engine is started                        */

        return (!StartTheDMAOutput(0));
}


    /*\
    |*|----====< PlayThisBlock >====----
    |*|
    |*| This routine offers the caller a simplified playback of one
    |*| variable length block of data. The call just needs to call
    |*| OpenPCMBuffering, then PlayThisBlock. The caller just has
    |*| to poll DMARunning to see if the block has completed. Calling
    |*| StopDMAIO will stop the process, if need be.
    |*|
    |*| Also see QueueThisBlock.
    |*|
    |*| Entry:
    |*|    p   is the far pointer to a block of data (64k max size). If
    |*|        the pointer is null, the block will not be queued.
    |*|    len is the length of the block in bytes (one based count).
    |*|    cb  is the callback routine to call when the block is empty.
    |*|
    |*| Returns:
    |*|    0 - block is queued and playing
    |*|    1 - Block failed to start
    |*|    2 - queue is full, try later
    |*|
    \*/
int PlayThisBlock(p,len,cb)
    char far *p;
    unsigned long len;
    void (far *cb)();
{
int n;

    // if the pointer is valid, then queue it up

        if (p) {

            // return if already full

            if (__queuein == QUEUESIZE)
                return(2);

            // extract the 1st entry from the queue

            __queuebuff[__queuein] = p;
            __queuedata += (__queuelen [__queuein] = len);
            __queuecb  [__queuein] = cb;
            __queuein  = ++__queuein & QUEUEMASK;
            __queueincnt++;

        }

    // if the blocks are not playing, the let'er rip...

        if ((DMARunning == 0) && __queueincnt ) {

            // setup to transfer this block

                __DirectionFlag = DMAOUTPUT;

            // start the process by loading the DMA buffers

                return (ContinueThisBlockOutput() ? 0 : 1 );

        }

    // Indicate this has been queued up

        return(0);
}


    /*\
    |*|----====< QueueThisBlock >====----
    |*|
    |*| This routine will queue up one block, but not start the PCM
    |*| transfers. Once X number of blocks are queued up, then the caller
    |*| can call PlayThisBlock/RecordThisBlock to start the process.
    |*|
    |*| Also see PlayThisBlock/RecordThisBlock.
    |*|
    |*| Entry:
    |*|    p   is the far pointer to a block of data (64k max size).
    |*|        All pointers are assumed to be valid.
    |*|    len is the length of the block in bytes (one based count).
    |*|    cb  is the callback routine to call when the block is empty.
    |*|
    |*| Returns:
    |*|    0 - block is queued and playing
    |*|    2 - queue is full, try later
    |*|
    \*/
int QueueThisBlock(p,len,cb)
    char far *p;
    unsigned long len;
    void (far *cb)();
{
int n;

    // return if already full

        if (__queuein == QUEUESIZE)
            return(2);

    // if idle, setup our internal direction flag, and the desired length

        __queuebuff[__queuein] = p;
        __queuedata += (__queuelen [__queuein] = len);
        __queuecb  [__queuein] = cb;
        __queuein  = ++__queuein & QUEUEMASK;
        __queueincnt++;

    // return all queued up

        return(0);

}


    /*\
    |*|----====< SyncCallBack >====----
    |*|
    |*| This routine will setup a callback to the caller's routine
    |*| at the end of every DMA block interrupt
    |*|
    |*| Returns:
    |*|
    \*/
int SyncCallBack(cb)
    void (far *cb)();
{
int n;

        ///////////////////// under construction! /////////////////////////

    // just save for a later call...

        __synccallback = cb;

}

#endif


#if FILEOUT
    /*\
    |*|----====< StartFileOutput >====----
    |*|
    |*| This routine allocates and loads the necessary buffers with data from
    |*| the PCM disk file. Upon return, if there is data available, the
    |*| background task will be called to start the DMA. The file handle will
    |*| be saved in a global variable to be access from other foreground
    |*| routines. a non-zero return value indicates PCM output is playing.
    |*|
    \*/
int StartFileOutput(f,len)
    FILE *f;
    long len;
{

    /* save our local file handle                                        */

        __fptr = f;

    /* setup our internal direction flag, and the desired length        */

        __DirectionFlag   = DMAOUTPUT;
        _file_data_length = len;

    /* Reset the # of blocks seen during I/O processing                 */

        ProcessedBlockCount = 0;

    /* if any data is loaded into the buffer, start the DMA & return    */

        _resetbuffers();

        do {

            /* get the next buffer full & exit if done                    */

            if (!_loadthebuffer (f))
                break;

        } while (__NextPtr != HeadOfBuffers);

    /* return good or bad if the engine is running                        */

        return (!StartTheDMAOutput(0));

}
#endif


#if BLOCKOUT
    /*\
    |*|----====< _loadtheblock >====----
    |*|
    |*| This routine loads the block into the DMA buffer.
    |*|
    \*/
static int _loadtheblock(buff)
    char far *buff;
{

    /* load the block of data into the DMA buffer                        */

        _rfmemcpy(__NextPtr->buffer, buff, BufferSize );

    /* now that the data is secure, fill out the rest of the header to    */
    /* allow the background process to "see" this new data              */

        __NextPtr->status = 1;
        __NextPtr->count  = BufferSize;
        __NextPtr          = __NextPtr->nextptr; /* advance the list     */
        BufferDataCount++;

    /* we have data, return the size                                    */

       return (BufferSize);
}
#endif


#if FILEOUT
    /*\
    |*|----====< _loadthebuffer >====----
    |*|
    |*| This routine loads the disk contents into an available buffer.
    |*| A return value of 0 indicates no more data has been loaded.
    |*|
    \*/
static int _loadthebuffer(f)
    FILE *f;
{
char huge *s;
register int n;
long l;

    /* reset the header data                                            */

        __NextPtr->count = __NextPtr->status = 0;

    /* exit if there is no data to be read                                */

        if (feof (f) || (!_file_data_length))
            return (0);

    /* adjust the max count we want to process from the file            */

        if (_file_data_length <= BufferSize) {
            l = _file_data_length;
            _file_data_length = 0;
        }
        else {
            _file_data_length -= (l = (BufferSize & 0xffff));
        }

    /* read the data from the file                                        */

#if LARGEDATA
        if((n = fread (__NextPtr->buffer, 1,((unsigned int)(l & 0xffff)), f)) == 0)
            return(0);

        s = __NextPtr->buffer+n; // point to the end of the block
#else
        if((n = fread (__LocalBuff, 1,((unsigned int)(l & 0xffff)), f)) == 0)
            return(0);

    /* move the data to the linked list. Yuck! double handling of data    */
    /* because fread won't take a far pointer in small model!           */

        s = _rfmemcpy(__NextPtr->buffer, __LocalBuff, n ); // s points to eob
#endif

    // flush to the end if not a full buffer worth of data

        if (n < BufferSize)
            FlushBuffer (s,BufferSize-n);

    /* now that the data is secure, fill out the rest of the header to    */
    /* allow the background process to "see" this new data              */

        __NextPtr->status = 1;
        __NextPtr->count  = BufferSize;
        __NextPtr          = __NextPtr->nextptr; /* advance the list     */
        BufferDataCount++;

    /* we have data, return the size                                    */

       return (n);
}
#endif


#if COMMDATA
    /*\
    |*|----====< _resetbuffers >====----
    |*|
    |*| This routine flushes the contents of the top level buffers
    |*|
    \*/
_resetbuffers()
{

    /* flush the count and status of every linked list block            */

        if ((__NextPtr = HeadOfBuffers)) {

            /* if there are buffers, reset them all                     */

            do {

                /* get the next buffer full & exit if done                */

                    __NextPtr->count = __NextPtr->status = 0;

                /* break when we reach the top                            */

                    if ((__NextPtr = __NextPtr->nextptr) == 0)
                            break;

            } while (__NextPtr != HeadOfBuffers);

        }

    /* reset the global hand shake count.                                */

        BufferDataCount = 0;
}
#endif


    /*\
    |*| end of PCMIOC.C
    \*/