/*$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
	\*/