wolf3d

ID_SD.C (48057B)

---

 //
 //	ID Engine
 //	ID_SD.c - Sound Manager for Wolfenstein 3D
 //	v1.2
 //	By Jason Blochowiak
 //
 
 //
 //	This module handles dealing with generating sound on the appropriate
 //		hardware
 //
 //	Depends on: User Mgr (for parm checking)
 //
 //	Globals:
 //		For User Mgr:
 //			SoundSourcePresent - Sound Source thingie present?
 //			SoundBlasterPresent - SoundBlaster card present?
 //			AdLibPresent - AdLib card present?
 //			SoundMode - What device is used for sound effects
 //				(Use SM_SetSoundMode() to set)
 //			MusicMode - What device is used for music
 //				(Use SM_SetMusicMode() to set)
 //			DigiMode - What device is used for digitized sound effects
 //				(Use SM_SetDigiDevice() to set)
 //
 //		For Cache Mgr:
 //			NeedsDigitized - load digitized sounds?
 //			NeedsMusic - load music?
 //
 
 #pragma hdrstop		// Wierdo thing with MUSE
 
 #include <dos.h>
 
 #ifdef	_MUSE_      // Will be defined in ID_Types.h
 #include "ID_SD.h"
 #else
 #include "ID_HEADS.H"
 #endif
 #pragma	hdrstop
 #pragma	warn	-pia
 
 #ifdef	nil
 #undef	nil
 #endif
 #define	nil	0
 
 #define	SDL_SoundFinished()	{SoundNumber = SoundPriority = 0;}
 
 // Macros for SoundBlaster stuff
 #define	sbOut(n,b)	outportb((n) + sbLocation,b)
 #define	sbIn(n)		inportb((n) + sbLocation)
 #define	sbWriteDelay()	while (sbIn(sbWriteStat) & 0x80);
 #define	sbReadDelay()	while (sbIn(sbDataAvail) & 0x80);
 
 // Macros for AdLib stuff
 #define	selreg(n)	outportb(alFMAddr,n)
 #define	writereg(n)	outportb(alFMData,n)
 #define	readstat()	inportb(alFMStatus)
 
 //	Imports from ID_SD_A.ASM
 extern	void			SDL_SetDS(void),
 						SDL_IndicatePC(boolean on);
 extern	void interrupt	SDL_t0ExtremeAsmService(void),
 						SDL_t0FastAsmService(void),
 						SDL_t0SlowAsmService(void);
 
 //	Global variables
 	boolean		SoundSourcePresent,
 				AdLibPresent,
 				SoundBlasterPresent,SBProPresent,
 				NeedsDigitized,NeedsMusic,
 				SoundPositioned;
 	SDMode		SoundMode;
 	SMMode		MusicMode;
 	SDSMode		DigiMode;
 	longword	TimeCount;
 	word		HackCount;
 	word		*SoundTable;	// Really * _seg *SoundTable, but that don't work
 	boolean		ssIsTandy;
 	word		ssPort = 2;
 	int			DigiMap[LASTSOUND];
 
 //	Internal variables
 static	boolean			SD_Started;
 		boolean			nextsoundpos;
 		longword		TimerDivisor,TimerCount;
 static	char			*ParmStrings[] =
 						{
 							"noal",
 							"nosb",
 							"nopro",
 							"noss",
 							"sst",
 							"ss1",
 							"ss2",
 							"ss3",
 							nil
 						};
 static	void			(*SoundUserHook)(void);
 		soundnames		SoundNumber,DigiNumber;
 		word			SoundPriority,DigiPriority;
 		int				LeftPosition,RightPosition;
 		void interrupt	(*t0OldService)(void);
 		long			LocalTime;
 		word			TimerRate;
 
 		word			NumDigi,DigiLeft,DigiPage;
 		word			_seg *DigiList;
 		word			DigiLastStart,DigiLastEnd;
 		boolean			DigiPlaying;
 static	boolean			DigiMissed,DigiLastSegment;
 static	memptr			DigiNextAddr;
 static	word			DigiNextLen;
 
 //	SoundBlaster variables
 static	boolean					sbNoCheck,sbNoProCheck;
 static	volatile boolean		sbSamplePlaying;
 static	byte					sbOldIntMask = -1;
 static	volatile byte			huge *sbNextSegPtr;
 static	byte					sbDMA = 1,
 								sbDMAa1 = 0x83,sbDMAa2 = 2,sbDMAa3 = 3,
 								sba1Vals[] = {0x87,0x83,0,0x82},
 								sba2Vals[] = {0,2,0,6},
 								sba3Vals[] = {1,3,0,7};
 static	int						sbLocation = -1,sbInterrupt = 7,sbIntVec = 0xf,
 								sbIntVectors[] = {-1,-1,0xa,0xb,-1,0xd,-1,0xf,-1,-1,-1};
 static	volatile longword		sbNextSegLen;
 static	volatile SampledSound	huge *sbSamples;
 static	void interrupt			(*sbOldIntHand)(void);
 static	byte					sbpOldFMMix,sbpOldVOCMix;
 
 //	SoundSource variables
 		boolean				ssNoCheck;
 		boolean				ssActive;
 		word				ssControl,ssStatus,ssData;
 		byte				ssOn,ssOff;
 		volatile byte		far *ssSample;
 		volatile longword	ssLengthLeft;
 
 //	PC Sound variables
 		volatile byte	pcLastSample,far *pcSound;
 		longword		pcLengthLeft;
 		word			pcSoundLookup[255];
 
 //	AdLib variables
 		boolean			alNoCheck;
 		byte			far *alSound;
 		word			alBlock;
 		longword		alLengthLeft;
 		longword		alTimeCount;
 		Instrument		alZeroInst;
 
 // This table maps channel numbers to carrier and modulator op cells
 static	byte			carriers[9] =  { 3, 4, 5,11,12,13,19,20,21},
 						modifiers[9] = { 0, 1, 2, 8, 9,10,16,17,18},
 // This table maps percussive voice numbers to op cells
 						pcarriers[5] = {19,0xff,0xff,0xff,0xff},
 						pmodifiers[5] = {16,17,18,20,21};
 
 //	Sequencer variables
 		boolean			sqActive;
 static	word			alFXReg;
 static	ActiveTrack		*tracks[sqMaxTracks],
 						mytracks[sqMaxTracks];
 static	word			sqMode,sqFadeStep;
 		word			far *sqHack,far *sqHackPtr,sqHackLen,sqHackSeqLen;
 		long			sqHackTime;
 
 //	Internal routines
 		void			SDL_DigitizedDone(void);
 
 ///////////////////////////////////////////////////////////////////////////
 //
 //	SDL_SetTimer0() - Sets system timer 0 to the specified speed
 //
 ///////////////////////////////////////////////////////////////////////////
 #pragma	argsused
 static void
 SDL_SetTimer0(word speed)
 {
 #ifndef TPROF	// If using Borland's profiling, don't screw with the timer
 asm	pushf
 asm	cli
 
 	outportb(0x43,0x36);				// Change timer 0
 	outportb(0x40,speed);
 	outportb(0x40,speed >> 8);
 	// Kludge to handle special case for digitized PC sounds
 	if (TimerDivisor == (1192030 / (TickBase * 100)))
 		TimerDivisor = (1192030 / (TickBase * 10));
 	else
 		TimerDivisor = speed;
 
 asm	popf
 #else
 	TimerDivisor = 0x10000;
 #endif
 }
 
 ///////////////////////////////////////////////////////////////////////////
 //
 //	SDL_SetIntsPerSec() - Uses SDL_SetTimer0() to set the number of
 //		interrupts generated by system timer 0 per second
 //
 ///////////////////////////////////////////////////////////////////////////
 static void
 SDL_SetIntsPerSec(word ints)
 {
 	TimerRate = ints;
 	SDL_SetTimer0(1192030 / ints);
 }
 
 static void
 SDL_SetTimerSpeed(void)
 {
 	word	rate;
 	void interrupt	(*isr)(void);
 
 	if ((DigiMode == sds_PC) && DigiPlaying)
 	{
 		rate = TickBase * 100;
 		isr = SDL_t0ExtremeAsmService;
 	}
 	else if
 	(
 		(MusicMode == smm_AdLib)
 	||	((DigiMode == sds_SoundSource) && DigiPlaying)
 	)
 	{
 		rate = TickBase * 10;
 		isr = SDL_t0FastAsmService;
 	}
 	else
 	{
 		rate = TickBase * 2;
 		isr = SDL_t0SlowAsmService;
 	}
 
 	if (rate != TimerRate)
 	{
 		setvect(8,isr);
 		SDL_SetIntsPerSec(rate);
 		TimerRate = rate;
 	}
 }
 
 //
 //	SoundBlaster code
 //
 
 ///////////////////////////////////////////////////////////////////////////
 //
 //	SDL_SBStopSample() - Stops any active sampled sound and causes DMA
 //		requests from the SoundBlaster to cease
 //
 ///////////////////////////////////////////////////////////////////////////
 #ifdef	_MUSE_
 void
 #else
 static void
 #endif
 SDL_SBStopSample(void)
 {
 	byte	is;
 
 asm	pushf
 asm	cli
 
 	if (sbSamplePlaying)
 	{
 		sbSamplePlaying = false;
 
 		sbWriteDelay();
 		sbOut(sbWriteCmd,0xd0);	// Turn off DSP DMA
 
 		is = inportb(0x21);	// Restore interrupt mask bit
 		if (sbOldIntMask & (1 << sbInterrupt))
 			is |= (1 << sbInterrupt);
 		else
 			is &= ~(1 << sbInterrupt);
 		outportb(0x21,is);
 	}
 
 asm	popf
 }
 
 ///////////////////////////////////////////////////////////////////////////
 //
 //	SDL_SBPlaySeg() - Plays a chunk of sampled sound on the SoundBlaster
 //	Insures that the chunk doesn't cross a bank boundary, programs the DMA
 //	 controller, and tells the SB to start doing DMA requests for DAC
 //
 ///////////////////////////////////////////////////////////////////////////
 static longword
 SDL_SBPlaySeg(volatile byte huge *data,longword length)
 {
 	unsigned		datapage;
 	longword		dataofs,uselen;
 
 	uselen = length;
 	datapage = FP_SEG(data) >> 12;
 	dataofs = ((FP_SEG(data) & 0xfff) << 4) + FP_OFF(data);
 	if (dataofs >= 0x10000)
 	{
 		datapage++;
 		dataofs -= 0x10000;
 	}
 
 	if (dataofs + uselen > 0x10000)
 		uselen = 0x10000 - dataofs;
 
 	uselen--;
 
 	// Program the DMA controller
 asm	pushf
 asm	cli
 	outportb(0x0a,sbDMA | 4);					// Mask off DMA on channel sbDMA
 	outportb(0x0c,0);							// Clear byte ptr flip-flop to lower byte
 	outportb(0x0b,0x49);						// Set transfer mode for D/A conv
 	outportb(sbDMAa2,(byte)dataofs);			// Give LSB of address
 	outportb(sbDMAa2,(byte)(dataofs >> 8));		// Give MSB of address
 	outportb(sbDMAa1,(byte)datapage);			// Give page of address
 	outportb(sbDMAa3,(byte)uselen);				// Give LSB of length
 	outportb(sbDMAa3,(byte)(uselen >> 8));		// Give MSB of length
 	outportb(0x0a,sbDMA);						// Re-enable DMA on channel sbDMA
 
 	// Start playing the thing
 	sbWriteDelay();
 	sbOut(sbWriteCmd,0x14);
 	sbWriteDelay();
 	sbOut(sbWriteData,(byte)uselen);
 	sbWriteDelay();
 	sbOut(sbWriteData,(byte)(uselen >> 8));
 asm	popf
 
 	return(uselen + 1);
 }
 
 ///////////////////////////////////////////////////////////////////////////
 //
 //	SDL_SBService() - Services the SoundBlaster DMA interrupt
 //
 ///////////////////////////////////////////////////////////////////////////
 static void interrupt
 SDL_SBService(void)
 {
 	longword	used;
 
 	sbIn(sbDataAvail);	// Ack interrupt to SB
 
 	if (sbNextSegPtr)
 	{
 		used = SDL_SBPlaySeg(sbNextSegPtr,sbNextSegLen);
 		if (sbNextSegLen <= used)
 			sbNextSegPtr = nil;
 		else
 		{
 			sbNextSegPtr += used;
 			sbNextSegLen -= used;
 		}
 	}
 	else
 	{
 		SDL_SBStopSample();
 		SDL_DigitizedDone();
 	}
 
 	outportb(0x20,0x20);	// Ack interrupt
 }
 
 ///////////////////////////////////////////////////////////////////////////
 //
 //	SDL_SBPlaySample() - Plays a sampled sound on the SoundBlaster. Sets up
 //		DMA to play the sound
 //
 ///////////////////////////////////////////////////////////////////////////
 #ifdef	_MUSE_
 void
 #else
 static void
 #endif
 SDL_SBPlaySample(byte huge *data,longword len)
 {
 	longword	used;
 
 	SDL_SBStopSample();
 
 asm	pushf
 asm	cli
 
 	used = SDL_SBPlaySeg(data,len);
 	if (len <= used)
 		sbNextSegPtr = nil;
 	else
 	{
 		sbNextSegPtr = data + used;
 		sbNextSegLen = len - used;
 	}
 
 	// Save old interrupt status and unmask ours
 	sbOldIntMask = inportb(0x21);
 	outportb(0x21,sbOldIntMask & ~(1 << sbInterrupt));
 
 	sbWriteDelay();
 	sbOut(sbWriteCmd,0xd4);						// Make sure DSP DMA is enabled
 
 	sbSamplePlaying = true;
 
 asm	popf
 }
 
 ///////////////////////////////////////////////////////////////////////////
 //
 //	SDL_PositionSBP() - Sets the attenuation levels for the left and right
 //		channels by using the mixer chip on the SB Pro. This hits a hole in
 //		the address map for normal SBs.
 //
 ///////////////////////////////////////////////////////////////////////////
 static void
 SDL_PositionSBP(int leftpos,int rightpos)
 {
 	byte	v;
 
 	if (!SBProPresent)
 		return;
 
 	leftpos = 15 - leftpos;
 	rightpos = 15 - rightpos;
 	v = ((leftpos & 0x0f) << 4) | (rightpos & 0x0f);
 
 asm	pushf
 asm	cli
 
 	sbOut(sbpMixerAddr,sbpmVoiceVol);
 	sbOut(sbpMixerData,v);
 
 asm	popf
 }
 
 ///////////////////////////////////////////////////////////////////////////
 //
 //	SDL_CheckSB() - Checks to see if a SoundBlaster resides at a
 //		particular I/O location
 //
 ///////////////////////////////////////////////////////////////////////////
 static boolean
 SDL_CheckSB(int port)
 {
 	int	i;
 
 	sbLocation = port << 4;		// Initialize stuff for later use
 
 	sbOut(sbReset,true);		// Reset the SoundBlaster DSP
 asm	mov	dx,0x388				// Wait >4usec
 asm	in	al, dx
 asm	in	al, dx
 asm	in	al, dx
 asm	in	al, dx
 asm	in	al, dx
 asm	in	al, dx
 asm	in	al, dx
 asm	in	al, dx
 asm	in	al, dx
 
 	sbOut(sbReset,false);		// Turn off sb DSP reset
 asm	mov	dx,0x388				// Wait >100usec
 asm	mov	cx,100
 usecloop:
 asm	in	al,dx
 asm	loop usecloop
 
 	for (i = 0;i < 100;i++)
 	{
 		if (sbIn(sbDataAvail) & 0x80)		// If data is available...
 		{
 			if (sbIn(sbReadData) == 0xaa)	// If it matches correct value
 				return(true);
 			else
 			{
 				sbLocation = -1;			// Otherwise not a SoundBlaster
 				return(false);
 			}
 		}
 	}
 	sbLocation = -1;						// Retry count exceeded - fail
 	return(false);
 }
 
 ///////////////////////////////////////////////////////////////////////////
 //
 //	Checks to see if a SoundBlaster is in the system. If the port passed is
 //		-1, then it scans through all possible I/O locations. If the port
 //		passed is 0, then it uses the default (2). If the port is >0, then
 //		it just passes it directly to SDL_CheckSB()
 //
 ///////////////////////////////////////////////////////////////////////////
 static boolean
 SDL_DetectSoundBlaster(int port)
 {
 	int	i;
 
 	if (port == 0)					// If user specifies default, use 2
 		port = 2;
 	if (port == -1)
 	{
 		if (SDL_CheckSB(2))			// Check default before scanning
 			return(true);
 
 		if (SDL_CheckSB(4))			// Check other SB Pro location before scan
 			return(true);
 
 		for (i = 1;i <= 6;i++)		// Scan through possible SB locations
 		{
 			if ((i == 2) || (i == 4))
 				continue;
 
 			if (SDL_CheckSB(i))		// If found at this address,
 				return(true);		//	return success
 		}
 		return(false);				// All addresses failed, return failure
 	}
 	else
 		return(SDL_CheckSB(port));	// User specified address or default
 }
 
 ///////////////////////////////////////////////////////////////////////////
 //
 //	SDL_SBSetDMA() - Sets the DMA channel to be used by the SoundBlaster
 //		code. Sets up sbDMA, and sbDMAa1-sbDMAa3 (used by SDL_SBPlaySeg()).
 //
 ///////////////////////////////////////////////////////////////////////////
 void
 SDL_SBSetDMA(byte channel)
 {
 	if (channel > 3)
 		Quit("SDL_SBSetDMA() - invalid SoundBlaster DMA channel");
 
 	sbDMA = channel;
 	sbDMAa1 = sba1Vals[channel];
 	sbDMAa2 = sba2Vals[channel];
 	sbDMAa3 = sba3Vals[channel];
 }
 
 ///////////////////////////////////////////////////////////////////////////
 //
 //	SDL_StartSB() - Turns on the SoundBlaster
 //
 ///////////////////////////////////////////////////////////////////////////
 static void
 SDL_StartSB(void)
 {
 	byte	timevalue,test;
 
 	sbIntVec = sbIntVectors[sbInterrupt];
 	if (sbIntVec < 0)
 		Quit("SDL_StartSB: Illegal or unsupported interrupt number for SoundBlaster");
 
 	sbOldIntHand = getvect(sbIntVec);	// Get old interrupt handler
 	setvect(sbIntVec,SDL_SBService);	// Set mine
 
 	sbWriteDelay();
 	sbOut(sbWriteCmd,0xd1);				// Turn on DSP speaker
 
 	// Set the SoundBlaster DAC time constant for 7KHz
 	timevalue = 256 - (1000000 / 7000);
 	sbWriteDelay();
 	sbOut(sbWriteCmd,0x40);
 	sbWriteDelay();
 	sbOut(sbWriteData,timevalue);
 
 	SBProPresent = false;
 	if (sbNoProCheck)
 		return;
 
 	// Check to see if this is a SB Pro
 	sbOut(sbpMixerAddr,sbpmFMVol);
 	sbpOldFMMix = sbIn(sbpMixerData);
 	sbOut(sbpMixerData,0xbb);
 	test = sbIn(sbpMixerData);
 	if (test == 0xbb)
 	{
 		// Boost FM output levels to be equivilent with digitized output
 		sbOut(sbpMixerData,0xff);
 		test = sbIn(sbpMixerData);
 		if (test == 0xff)
 		{
 			SBProPresent = true;
 
 			// Save old Voice output levels (SB Pro)
 			sbOut(sbpMixerAddr,sbpmVoiceVol);
 			sbpOldVOCMix = sbIn(sbpMixerData);
 
 			// Turn SB Pro stereo DAC off
 			sbOut(sbpMixerAddr,sbpmControl);
 			sbOut(sbpMixerData,0);				// 0=off,2=on
 		}
 	}
 }
 
 ///////////////////////////////////////////////////////////////////////////
 //
 //	SDL_ShutSB() - Turns off the SoundBlaster
 //
 ///////////////////////////////////////////////////////////////////////////
 static void
 SDL_ShutSB(void)
 {
 	SDL_SBStopSample();
 
 	if (SBProPresent)
 	{
 		// Restore FM output levels (SB Pro)
 		sbOut(sbpMixerAddr,sbpmFMVol);
 		sbOut(sbpMixerData,sbpOldFMMix);
 
 		// Restore Voice output levels (SB Pro)
 		sbOut(sbpMixerAddr,sbpmVoiceVol);
 		sbOut(sbpMixerData,sbpOldVOCMix);
 	}
 
 	setvect(sbIntVec,sbOldIntHand);		// Set vector back
 }
 
 //	Sound Source Code
 
 ///////////////////////////////////////////////////////////////////////////
 //
 //	SDL_SSStopSample() - Stops a sample playing on the Sound Source
 //
 ///////////////////////////////////////////////////////////////////////////
 #ifdef	_MUSE_
 void
 #else
 static void
 #endif
 SDL_SSStopSample(void)
 {
 asm	pushf
 asm	cli
 
 	(long)ssSample = 0;
 
 asm	popf
 }
 
 ///////////////////////////////////////////////////////////////////////////
 //
 //	SDL_SSService() - Handles playing the next sample on the Sound Source
 //
 ///////////////////////////////////////////////////////////////////////////
 static void
 SDL_SSService(void)
 {
 	boolean	gotit;
 	byte	v;
 
 	while (ssSample)
 	{
 	asm	mov		dx,[ssStatus]	// Check to see if FIFO is currently empty
 	asm	in		al,dx
 	asm	test	al,0x40
 	asm	jnz		done			// Nope - don't push any more data out
 
 		v = *ssSample++;
 		if (!(--ssLengthLeft))
 		{
 			(long)ssSample = 0;
 			SDL_DigitizedDone();
 		}
 
 	asm	mov		dx,[ssData]		// Pump the value out
 	asm	mov		al,[v]
 	asm	out		dx,al
 
 	asm	mov		dx,[ssControl]	// Pulse printer select
 	asm	mov		al,[ssOff]
 	asm	out		dx,al
 	asm	push	ax
 	asm	pop		ax
 	asm	mov		al,[ssOn]
 	asm	out		dx,al
 
 	asm	push	ax				// Delay a short while
 	asm	pop		ax
 	asm	push	ax
 	asm	pop		ax
 	}
 done:;
 }
 
 ///////////////////////////////////////////////////////////////////////////
 //
 //	SDL_SSPlaySample() - Plays the specified sample on the Sound Source
 //
 ///////////////////////////////////////////////////////////////////////////
 #ifdef	_MUSE_
 void
 #else
 static void
 #endif
 SDL_SSPlaySample(byte huge *data,longword len)
 {
 asm	pushf
 asm	cli
 
 	ssLengthLeft = len;
 	ssSample = (volatile byte far *)data;
 
 asm	popf
 }
 
 ///////////////////////////////////////////////////////////////////////////
 //
 //	SDL_StartSS() - Sets up for and turns on the Sound Source
 //
 ///////////////////////////////////////////////////////////////////////////
 static void
 SDL_StartSS(void)
 {
 	if (ssPort == 3)
 		ssControl = 0x27a;	// If using LPT3
 	else if (ssPort == 2)
 		ssControl = 0x37a;	// If using LPT2
 	else
 		ssControl = 0x3be;	// If using LPT1
 	ssStatus = ssControl - 1;
 	ssData = ssStatus - 1;
 
 	ssOn = 0x04;
 	if (ssIsTandy)
 		ssOff = 0x0e;				// Tandy wierdness
 	else
 		ssOff = 0x0c;				// For normal machines
 
 	outportb(ssControl,ssOn);		// Enable SS
 }
 
 ///////////////////////////////////////////////////////////////////////////
 //
 //	SDL_ShutSS() - Turns off the Sound Source
 //
 ///////////////////////////////////////////////////////////////////////////
 static void
 SDL_ShutSS(void)
 {
 	outportb(ssControl,ssOff);
 }
 
 ///////////////////////////////////////////////////////////////////////////
 //
 //	SDL_CheckSS() - Checks to see if a Sound Source is present at the
 //		location specified by the sound source variables
 //
 ///////////////////////////////////////////////////////////////////////////
 static boolean
 SDL_CheckSS(void)
 {
 	boolean		present = false;
 	longword	lasttime;
 
 	// Turn the Sound Source on and wait awhile (4 ticks)
 	SDL_StartSS();
 
 	lasttime = TimeCount;
 	while (TimeCount < lasttime + 4)
 		;
 
 asm	mov		dx,[ssStatus]	// Check to see if FIFO is currently empty
 asm	in		al,dx
 asm	test	al,0x40
 asm	jnz		checkdone		// Nope - Sound Source not here
 
 asm	mov		cx,32			// Force FIFO overflow (FIFO is 16 bytes)
 outloop:
 asm	mov		dx,[ssData]		// Pump a neutral value out
 asm	mov		al,0x80
 asm	out		dx,al
 
 asm	mov		dx,[ssControl]	// Pulse printer select
 asm	mov		al,[ssOff]
 asm	out		dx,al
 asm	push	ax
 asm	pop		ax
 asm	mov		al,[ssOn]
 asm	out		dx,al
 
 asm	push	ax				// Delay a short while before we do this again
 asm	pop		ax
 asm	push	ax
 asm	pop		ax
 
 asm	loop	outloop
 
 asm	mov		dx,[ssStatus]	// Is FIFO overflowed now?
 asm	in		al,dx
 asm	test	al,0x40
 asm	jz		checkdone		// Nope, still not - Sound Source not here
 
 	present = true;			// Yes - it's here!
 
 checkdone:
 	SDL_ShutSS();
 	return(present);
 }
 
 static boolean
 SDL_DetectSoundSource(void)
 {
 	for (ssPort = 1;ssPort <= 3;ssPort++)
 		if (SDL_CheckSS())
 			return(true);
 	return(false);
 }
 
 //
 //	PC Sound code
 //
 
 ///////////////////////////////////////////////////////////////////////////
 //
 //	SDL_PCPlaySample() - Plays the specified sample on the PC speaker
 //
 ///////////////////////////////////////////////////////////////////////////
 #ifdef	_MUSE_
 void
 #else
 static void
 #endif
 SDL_PCPlaySample(byte huge *data,longword len)
 {
 asm	pushf
 asm	cli
 
 	SDL_IndicatePC(true);
 
 	pcLengthLeft = len;
 	pcSound = (volatile byte far *)data;
 
 asm	popf
 }
 
 ///////////////////////////////////////////////////////////////////////////
 //
 //	SDL_PCStopSample() - Stops a sample playing on the PC speaker
 //
 ///////////////////////////////////////////////////////////////////////////
 #ifdef	_MUSE_
 void
 #else
 static void
 #endif
 SDL_PCStopSample(void)
 {
 asm	pushf
 asm	cli
 
 	(long)pcSound = 0;
 
 	SDL_IndicatePC(false);
 
 asm	in	al,0x61		  	// Turn the speaker off
 asm	and	al,0xfd			// ~2
 asm	out	0x61,al
 
 asm	popf
 }
 
 ///////////////////////////////////////////////////////////////////////////
 //
 //	SDL_PCPlaySound() - Plays the specified sound on the PC speaker
 //
 ///////////////////////////////////////////////////////////////////////////
 #ifdef	_MUSE_
 void
 #else
 static void
 #endif
 SDL_PCPlaySound(PCSound far *sound)
 {
 asm	pushf
 asm	cli
 
 	pcLastSample = -1;
 	pcLengthLeft = sound->common.length;
 	pcSound = sound->data;
 
 asm	popf
 }
 
 ///////////////////////////////////////////////////////////////////////////
 //
 //	SDL_PCStopSound() - Stops the current sound playing on the PC Speaker
 //
 ///////////////////////////////////////////////////////////////////////////
 #ifdef	_MUSE_
 void
 #else
 static void
 #endif
 SDL_PCStopSound(void)
 {
 asm	pushf
 asm	cli
 
 	(long)pcSound = 0;
 
 asm	in	al,0x61		  	// Turn the speaker off
 asm	and	al,0xfd			// ~2
 asm	out	0x61,al
 
 asm	popf
 }
 
 #if 0
 ///////////////////////////////////////////////////////////////////////////
 //
 //	SDL_PCService() - Handles playing the next sample in a PC sound
 //
 ///////////////////////////////////////////////////////////////////////////
 static void
 SDL_PCService(void)
 {
 	byte	s;
 	word	t;
 
 	if (pcSound)
 	{
 		s = *pcSound++;
 		if (s != pcLastSample)
 		{
 		asm	pushf
 		asm	cli
 
 			pcLastSample = s;
 			if (s)					// We have a frequency!
 			{
 				t = pcSoundLookup[s];
 			asm	mov	bx,[t]
 
 			asm	mov	al,0xb6			// Write to channel 2 (speaker) timer
 			asm	out	43h,al
 			asm	mov	al,bl
 			asm	out	42h,al			// Low byte
 			asm	mov	al,bh
 			asm	out	42h,al			// High byte
 
 			asm	in	al,0x61			// Turn the speaker & gate on
 			asm	or	al,3
 			asm	out	0x61,al
 			}
 			else					// Time for some silence
 			{
 			asm	in	al,0x61		  	// Turn the speaker & gate off
 			asm	and	al,0xfc			// ~3
 			asm	out	0x61,al
 			}
 
 		asm	popf
 		}
 
 		if (!(--pcLengthLeft))
 		{
 			SDL_PCStopSound();
 			SDL_SoundFinished();
 		}
 	}
 }
 #endif
 
 ///////////////////////////////////////////////////////////////////////////
 //
 //	SDL_ShutPC() - Turns off the pc speaker
 //
 ///////////////////////////////////////////////////////////////////////////
 static void
 SDL_ShutPC(void)
 {
 asm	pushf
 asm	cli
 
 	pcSound = 0;
 
 asm	in	al,0x61		  	// Turn the speaker & gate off
 asm	and	al,0xfc			// ~3
 asm	out	0x61,al
 
 asm	popf
 }
 
 //
 //	Stuff for digitized sounds
 //
 memptr
 SDL_LoadDigiSegment(word page)
 {
 	memptr	addr;
 
 #if 0	// for debugging
 asm	mov	dx,STATUS_REGISTER_1
 asm	in	al,dx
 asm	mov	dx,ATR_INDEX
 asm	mov	al,ATR_OVERSCAN
 asm	out	dx,al
 asm	mov	al,10	// bright green
 asm	out	dx,al
 #endif
 
 	addr = PM_GetSoundPage(page);
 	PM_SetPageLock(PMSoundStart + page,pml_Locked);
 
 #if 0	// for debugging
 asm	mov	dx,STATUS_REGISTER_1
 asm	in	al,dx
 asm	mov	dx,ATR_INDEX
 asm	mov	al,ATR_OVERSCAN
 asm	out	dx,al
 asm	mov	al,3	// blue
 asm	out	dx,al
 asm	mov	al,0x20	// normal
 asm	out	dx,al
 #endif
 
 	return(addr);
 }
 
 void
 SDL_PlayDigiSegment(memptr addr,word len)
 {
 	switch (DigiMode)
 	{
 	case sds_PC:
     	SDL_PCPlaySample(addr,len);
 		break;
 	case sds_SoundSource:
 		SDL_SSPlaySample(addr,len);
 		break;
 	case sds_SoundBlaster:
 		SDL_SBPlaySample(addr,len);
 		break;
 	}
 }
 
 void
 SD_StopDigitized(void)
 {
 	int	i;
 
 asm	pushf
 asm	cli
 
 	DigiLeft = 0;
 	DigiNextAddr = nil;
 	DigiNextLen = 0;
 	DigiMissed = false;
 	DigiPlaying = false;
 	DigiNumber = DigiPriority = 0;
 	SoundPositioned = false;
 	if ((DigiMode == sds_PC) && (SoundMode == sdm_PC))
 		SDL_SoundFinished();
 
 	switch (DigiMode)
 	{
 	case sds_PC:
 		SDL_PCStopSample();
 		break;
 	case sds_SoundSource:
 		SDL_SSStopSample();
 		break;
 	case sds_SoundBlaster:
 		SDL_SBStopSample();
 		break;
 	}
 
 asm	popf
 
 	for (i = DigiLastStart;i < DigiLastEnd;i++)
 		PM_SetPageLock(i + PMSoundStart,pml_Unlocked);
 	DigiLastStart = 1;
 	DigiLastEnd = 0;
 }
 
 void
 SD_Poll(void)
 {
 	if (DigiLeft && !DigiNextAddr)
 	{
 		DigiNextLen = (DigiLeft >= PMPageSize)? PMPageSize : (DigiLeft % PMPageSize);
 		DigiLeft -= DigiNextLen;
 		if (!DigiLeft)
 			DigiLastSegment = true;
 		DigiNextAddr = SDL_LoadDigiSegment(DigiPage++);
 	}
 	if (DigiMissed && DigiNextAddr)
 	{
 		SDL_PlayDigiSegment(DigiNextAddr,DigiNextLen);
 		DigiNextAddr = nil;
 		DigiMissed = false;
 		if (DigiLastSegment)
 		{
 			DigiPlaying = false;
 			DigiLastSegment = false;
 		}
 	}
 	SDL_SetTimerSpeed();
 }
 
 void
 SD_SetPosition(int leftpos,int rightpos)
 {
 	if
 	(
 		(leftpos < 0)
 	||	(leftpos > 15)
 	||	(rightpos < 0)
 	||	(rightpos > 15)
 	||	((leftpos == 15) && (rightpos == 15))
 	)
 		Quit("SD_SetPosition: Illegal position");
 
 	switch (DigiMode)
 	{
 	case sds_SoundBlaster:
 		SDL_PositionSBP(leftpos,rightpos);
 		break;
 	}
 }
 
 void
 SD_PlayDigitized(word which,int leftpos,int rightpos)
 {
 	word	len;
 	memptr	addr;
 
 	if (!DigiMode)
 		return;
 
 	SD_StopDigitized();
 	if (which >= NumDigi)
 		Quit("SD_PlayDigitized: bad sound number");
 
 	SD_SetPosition(leftpos,rightpos);
 
 	DigiPage = DigiList[(which * 2) + 0];
 	DigiLeft = DigiList[(which * 2) + 1];
 
 	DigiLastStart = DigiPage;
 	DigiLastEnd = DigiPage + ((DigiLeft + (PMPageSize - 1)) / PMPageSize);
 
 	len = (DigiLeft >= PMPageSize)? PMPageSize : (DigiLeft % PMPageSize);
 	addr = SDL_LoadDigiSegment(DigiPage++);
 
 	DigiPlaying = true;
 	DigiLastSegment = false;
 
 	SDL_PlayDigiSegment(addr,len);
 	DigiLeft -= len;
 	if (!DigiLeft)
 		DigiLastSegment = true;
 
 	SD_Poll();
 }
 
 void
 SDL_DigitizedDone(void)
 {
 	if (DigiNextAddr)
 	{
 		SDL_PlayDigiSegment(DigiNextAddr,DigiNextLen);
 		DigiNextAddr = nil;
 		DigiMissed = false;
 	}
 	else
 	{
 		if (DigiLastSegment)
 		{
 			DigiPlaying = false;
 			DigiLastSegment = false;
 			if ((DigiMode == sds_PC) && (SoundMode == sdm_PC))
 			{
 				SDL_SoundFinished();
 			}
 			else
 				DigiNumber = DigiPriority = 0;
 			SoundPositioned = false;
 		}
 		else
 			DigiMissed = true;
 	}
 }
 
 void
 SD_SetDigiDevice(SDSMode mode)
 {
 	boolean	devicenotpresent;
 
 	if (mode == DigiMode)
 		return;
 
 	SD_StopDigitized();
 
 	devicenotpresent = false;
 	switch (mode)
 	{
 	case sds_SoundBlaster:
 		if (!SoundBlasterPresent)
 		{
 			if (SoundSourcePresent)
 				mode = sds_SoundSource;
 			else
 				devicenotpresent = true;
 		}
 		break;
 	case sds_SoundSource:
 		if (!SoundSourcePresent)
 			devicenotpresent = true;
 		break;
 	}
 
 	if (!devicenotpresent)
 	{
 		if (DigiMode == sds_SoundSource)
 			SDL_ShutSS();
 
 		DigiMode = mode;
 
 		if (mode == sds_SoundSource)
 			SDL_StartSS();
 
 		SDL_SetTimerSpeed();
 	}
 }
 
 void
 SDL_SetupDigi(void)
 {
 	memptr	list;
 	word	far *p,
 			pg;
 	int		i;
 
 	PM_UnlockMainMem();
 	MM_GetPtr(&list,PMPageSize);
 	PM_CheckMainMem();
 	p = (word far *)MK_FP(PM_GetPage(ChunksInFile - 1),0);
 	_fmemcpy((void far *)list,(void far *)p,PMPageSize);
 	pg = PMSoundStart;
 	for (i = 0;i < PMPageSize / (sizeof(word) * 2);i++,p += 2)
 	{
 		if (pg >= ChunksInFile - 1)
 			break;
 		pg += (p[1] + (PMPageSize - 1)) / PMPageSize;
 	}
 	PM_UnlockMainMem();
 	MM_GetPtr((memptr *)&DigiList,i * sizeof(word) * 2);
 	_fmemcpy((void far *)DigiList,(void far *)list,i * sizeof(word) * 2);
 	MM_FreePtr(&list);
 	NumDigi = i;
 
 	for (i = 0;i < LASTSOUND;i++)
 		DigiMap[i] = -1;
 }
 
 // 	AdLib Code
 
 ///////////////////////////////////////////////////////////////////////////
 //
 //	alOut(n,b) - Puts b in AdLib card register n
 //
 ///////////////////////////////////////////////////////////////////////////
 void
 alOut(byte n,byte b)
 {
 asm	pushf
 asm	cli
 
 asm	mov	dx,0x388
 asm	mov	al,[n]
 asm	out	dx,al
 asm	in	al,dx
 asm	in	al,dx
 asm	in	al,dx
 asm	in	al,dx
 asm	in	al,dx
 asm	in	al,dx
 asm	inc	dx
 asm	mov	al,[b]
 asm	out	dx,al
 
 asm	popf
 
 asm	dec	dx
 asm	in	al,dx
 asm	in	al,dx
 asm	in	al,dx
 asm	in	al,dx
 asm	in	al,dx
 asm	in	al,dx
 asm	in	al,dx
 asm	in	al,dx
 asm	in	al,dx
 asm	in	al,dx
 
 asm	in	al,dx
 asm	in	al,dx
 asm	in	al,dx
 asm	in	al,dx
 asm	in	al,dx
 asm	in	al,dx
 asm	in	al,dx
 asm	in	al,dx
 asm	in	al,dx
 asm	in	al,dx
 
 asm	in	al,dx
 asm	in	al,dx
 asm	in	al,dx
 asm	in	al,dx
 asm	in	al,dx
 asm	in	al,dx
 asm	in	al,dx
 asm	in	al,dx
 asm	in	al,dx
 asm	in	al,dx
 
 asm	in	al,dx
 asm	in	al,dx
 asm	in	al,dx
 asm	in	al,dx
 asm	in	al,dx
 }
 
 #if 0
 ///////////////////////////////////////////////////////////////////////////
 //
 //	SDL_SetInstrument() - Puts an instrument into a generator
 //
 ///////////////////////////////////////////////////////////////////////////
 static void
 SDL_SetInstrument(int track,int which,Instrument far *inst,boolean percussive)
 {
 	byte		c,m;
 
 	if (percussive)
 	{
 		c = pcarriers[which];
 		m = pmodifiers[which];
 	}
 	else
 	{
 		c = carriers[which];
 		m = modifiers[which];
 	}
 
 	tracks[track - 1]->inst = *inst;
 	tracks[track - 1]->percussive = percussive;
 
 	alOut(m + alChar,inst->mChar);
 	alOut(m + alScale,inst->mScale);
 	alOut(m + alAttack,inst->mAttack);
 	alOut(m + alSus,inst->mSus);
 	alOut(m + alWave,inst->mWave);
 
 	// Most percussive instruments only use one cell
 	if (c != 0xff)
 	{
 		alOut(c + alChar,inst->cChar);
 		alOut(c + alScale,inst->cScale);
 		alOut(c + alAttack,inst->cAttack);
 		alOut(c + alSus,inst->cSus);
 		alOut(c + alWave,inst->cWave);
 	}
 
 	alOut(which + alFeedCon,inst->nConn);	// DEBUG - I think this is right
 }
 #endif
 
 ///////////////////////////////////////////////////////////////////////////
 //
 //	SDL_ALStopSound() - Turns off any sound effects playing through the
 //		AdLib card
 //
 ///////////////////////////////////////////////////////////////////////////
 #ifdef	_MUSE_
 void
 #else
 static void
 #endif
 SDL_ALStopSound(void)
 {
 asm	pushf
 asm	cli
 
 	(long)alSound = 0;
 	alOut(alFreqH + 0,0);
 
 asm	popf
 }
 
 static void
 SDL_AlSetFXInst(Instrument far *inst)
 {
 	byte		c,m;
 
 	m = modifiers[0];
 	c = carriers[0];
 	alOut(m + alChar,inst->mChar);
 	alOut(m + alScale,inst->mScale);
 	alOut(m + alAttack,inst->mAttack);
 	alOut(m + alSus,inst->mSus);
 	alOut(m + alWave,inst->mWave);
 	alOut(c + alChar,inst->cChar);
 	alOut(c + alScale,inst->cScale);
 	alOut(c + alAttack,inst->cAttack);
 	alOut(c + alSus,inst->cSus);
 	alOut(c + alWave,inst->cWave);
 
 	// Note: Switch commenting on these lines for old MUSE compatibility
 //	alOut(alFeedCon,inst->nConn);
 	alOut(alFeedCon,0);
 }
 
 ///////////////////////////////////////////////////////////////////////////
 //
 //	SDL_ALPlaySound() - Plays the specified sound on the AdLib card
 //
 ///////////////////////////////////////////////////////////////////////////
 #ifdef	_MUSE_
 void
 #else
 static void
 #endif
 SDL_ALPlaySound(AdLibSound far *sound)
 {
 	Instrument	far *inst;
 	byte		huge *data;
 
 	SDL_ALStopSound();
 
 asm	pushf
 asm	cli
 
 	alLengthLeft = sound->common.length;
 	data = sound->data;
 	data++;
 	data--;
 	alSound = (byte far *)data;
 	alBlock = ((sound->block & 7) << 2) | 0x20;
 	inst = &sound->inst;
 
 	if (!(inst->mSus | inst->cSus))
 	{
 	asm	popf
 		Quit("SDL_ALPlaySound() - Bad instrument");
 	}
 
 	SDL_AlSetFXInst(&alZeroInst);	// DEBUG
 	SDL_AlSetFXInst(inst);
 
 asm	popf
 }
 
 #if 0
 ///////////////////////////////////////////////////////////////////////////
 //
 // 	SDL_ALSoundService() - Plays the next sample out through the AdLib card
 //
 ///////////////////////////////////////////////////////////////////////////
 //static void
 void
 SDL_ALSoundService(void)
 {
 	byte	s;
 
 	if (alSound)
 	{
 		s = *alSound++;
 		if (!s)
 			alOut(alFreqH + 0,0);
 		else
 		{
 			alOut(alFreqL + 0,s);
 			alOut(alFreqH + 0,alBlock);
 		}
 
 		if (!(--alLengthLeft))
 		{
 			(long)alSound = 0;
 			alOut(alFreqH + 0,0);
 			SDL_SoundFinished();
 		}
 	}
 }
 #endif
 
 #if 0
 void
 SDL_ALService(void)
 {
 	byte	a,v;
 	word	w;
 
 	if (!sqActive)
 		return;
 
 	while (sqHackLen && (sqHackTime <= alTimeCount))
 	{
 		w = *sqHackPtr++;
 		sqHackTime = alTimeCount + *sqHackPtr++;
 	asm	mov	dx,[w]
 	asm	mov	[a],dl
 	asm	mov	[v],dh
 		alOut(a,v);
 		sqHackLen -= 4;
 	}
 	alTimeCount++;
 	if (!sqHackLen)
 	{
 		sqHackPtr = (word far *)sqHack;
 		sqHackLen = sqHackSeqLen;
 		alTimeCount = sqHackTime = 0;
 	}
 }
 #endif
 
 ///////////////////////////////////////////////////////////////////////////
 //
 //	SDL_ShutAL() - Shuts down the AdLib card for sound effects
 //
 ///////////////////////////////////////////////////////////////////////////
 static void
 SDL_ShutAL(void)
 {
 asm	pushf
 asm	cli
 
 	alOut(alEffects,0);
 	alOut(alFreqH + 0,0);
 	SDL_AlSetFXInst(&alZeroInst);
 	alSound = 0;
 
 asm	popf
 }
 
 ///////////////////////////////////////////////////////////////////////////
 //
 //	SDL_CleanAL() - Totally shuts down the AdLib card
 //
 ///////////////////////////////////////////////////////////////////////////
 static void
 SDL_CleanAL(void)
 {
 	int	i;
 
 asm	pushf
 asm	cli
 
 	alOut(alEffects,0);
 	for (i = 1;i < 0xf5;i++)
 		alOut(i,0);
 
 asm	popf
 }
 
 ///////////////////////////////////////////////////////////////////////////
 //
 //	SDL_StartAL() - Starts up the AdLib card for sound effects
 //
 ///////////////////////////////////////////////////////////////////////////
 static void
 SDL_StartAL(void)
 {
 	alFXReg = 0;
 	alOut(alEffects,alFXReg);
 	SDL_AlSetFXInst(&alZeroInst);
 }
 
 ///////////////////////////////////////////////////////////////////////////
 //
 //	SDL_DetectAdLib() - Determines if there's an AdLib (or SoundBlaster
 //		emulating an AdLib) present
 //
 ///////////////////////////////////////////////////////////////////////////
 static boolean
 SDL_DetectAdLib(void)
 {
 	byte	status1,status2;
 	int		i;
 
 	alOut(4,0x60);	// Reset T1 & T2
 	alOut(4,0x80);	// Reset IRQ
 	status1 = readstat();
 	alOut(2,0xff);	// Set timer 1
 	alOut(4,0x21);	// Start timer 1
 #if 0
 	SDL_Delay(TimerDelay100);
 #else
 asm	mov	dx,0x388
 asm	mov	cx,100
 usecloop:
 asm	in	al,dx
 asm	loop usecloop
 #endif
 
 	status2 = readstat();
 	alOut(4,0x60);
 	alOut(4,0x80);
 
 	if (((status1 & 0xe0) == 0x00) && ((status2 & 0xe0) == 0xc0))
 	{
 		for (i = 1;i <= 0xf5;i++)	// Zero all the registers
 			alOut(i,0);
 
 		alOut(1,0x20);	// Set WSE=1
 		alOut(8,0);		// Set CSM=0 & SEL=0
 
 		return(true);
 	}
 	else
 		return(false);
 }
 
 #if 0
 ///////////////////////////////////////////////////////////////////////////
 //
 //	SDL_t0Service() - My timer 0 ISR which handles the different timings and
 //		dispatches to whatever other routines are appropriate
 //
 ///////////////////////////////////////////////////////////////////////////
 static void interrupt
 SDL_t0Service(void)
 {
 static	word	count = 1;
 
 #if 1	// for debugging
 asm	mov	dx,STATUS_REGISTER_1
 asm	in	al,dx
 asm	mov	dx,ATR_INDEX
 asm	mov	al,ATR_OVERSCAN
 asm	out	dx,al
 asm	mov	al,4	// red
 asm	out	dx,al
 #endif
 
 	HackCount++;
 
 	if ((MusicMode == smm_AdLib) || (DigiMode == sds_SoundSource))
 	{
 		SDL_ALService();
 		SDL_SSService();
 //		if (!(++count & 7))
 		if (!(++count % 10))
 		{
 			LocalTime++;
 			TimeCount++;
 			if (SoundUserHook)
 				SoundUserHook();
 		}
 //		if (!(count & 3))
 		if (!(count % 5))
 		{
 			switch (SoundMode)
 			{
 			case sdm_PC:
 				SDL_PCService();
 				break;
 			case sdm_AdLib:
 				SDL_ALSoundService();
 				break;
 			}
 		}
 	}
 	else
 	{
 		if (!(++count & 1))
 		{
 			LocalTime++;
 			TimeCount++;
 			if (SoundUserHook)
 				SoundUserHook();
 		}
 		switch (SoundMode)
 		{
 		case sdm_PC:
 			SDL_PCService();
 			break;
 		case sdm_AdLib:
 			SDL_ALSoundService();
 			break;
 		}
 	}
 
 asm	mov	ax,[WORD PTR TimerCount]
 asm	add	ax,[WORD PTR TimerDivisor]
 asm	mov	[WORD PTR TimerCount],ax
 asm	jnc	myack
 	t0OldService();			// If we overflow a word, time to call old int handler
 asm	jmp	olddone
 myack:;
 	outportb(0x20,0x20);	// Ack the interrupt
 olddone:;
 
 #if 1	// for debugging
 asm	mov	dx,STATUS_REGISTER_1
 asm	in	al,dx
 asm	mov	dx,ATR_INDEX
 asm	mov	al,ATR_OVERSCAN
 asm	out	dx,al
 asm	mov	al,3	// blue
 asm	out	dx,al
 asm	mov	al,0x20	// normal
 asm	out	dx,al
 #endif
 }
 #endif
 
 ////////////////////////////////////////////////////////////////////////////
 //
 //	SDL_ShutDevice() - turns off whatever device was being used for sound fx
 //
 ////////////////////////////////////////////////////////////////////////////
 static void
 SDL_ShutDevice(void)
 {
 	switch (SoundMode)
 	{
 	case sdm_PC:
 		SDL_ShutPC();
 		break;
 	case sdm_AdLib:
 		SDL_ShutAL();
 		break;
 	}
 	SoundMode = sdm_Off;
 }
 
 ///////////////////////////////////////////////////////////////////////////
 //
 //	SDL_CleanDevice() - totally shuts down all sound devices
 //
 ///////////////////////////////////////////////////////////////////////////
 static void
 SDL_CleanDevice(void)
 {
 	if ((SoundMode == sdm_AdLib) || (MusicMode == smm_AdLib))
 		SDL_CleanAL();
 }
 
 ///////////////////////////////////////////////////////////////////////////
 //
 //	SDL_StartDevice() - turns on whatever device is to be used for sound fx
 //
 ///////////////////////////////////////////////////////////////////////////
 static void
 SDL_StartDevice(void)
 {
 	switch (SoundMode)
 	{
 	case sdm_AdLib:
 		SDL_StartAL();
 		break;
 	}
 	SoundNumber = SoundPriority = 0;
 }
 
 //	Public routines
 
 ///////////////////////////////////////////////////////////////////////////
 //
 //	SD_SetSoundMode() - Sets which sound hardware to use for sound effects
 //
 ///////////////////////////////////////////////////////////////////////////
 boolean
 SD_SetSoundMode(SDMode mode)
 {
 	boolean	result = false;
 	word	tableoffset;
 
 	SD_StopSound();
 
 #ifndef	_MUSE_
 	if ((mode == sdm_AdLib) && !AdLibPresent)
 		mode = sdm_PC;
 
 	switch (mode)
 	{
 	case sdm_Off:
 		NeedsDigitized = false;
 		result = true;
 		break;
 	case sdm_PC:
 		tableoffset = STARTPCSOUNDS;
 		NeedsDigitized = false;
 		result = true;
 		break;
 	case sdm_AdLib:
 		if (AdLibPresent)
 		{
 			tableoffset = STARTADLIBSOUNDS;
 			NeedsDigitized = false;
 			result = true;
 		}
 		break;
 	}
 #else
 	result = true;
 #endif
 
 	if (result && (mode != SoundMode))
 	{
 		SDL_ShutDevice();
 		SoundMode = mode;
 #ifndef	_MUSE_
 		SoundTable = (word *)(&audiosegs[tableoffset]);
 #endif
 		SDL_StartDevice();
 	}
 
 	SDL_SetTimerSpeed();
 
 	return(result);
 }
 
 ///////////////////////////////////////////////////////////////////////////
 //
 //	SD_SetMusicMode() - sets the device to use for background music
 //
 ///////////////////////////////////////////////////////////////////////////
 boolean
 SD_SetMusicMode(SMMode mode)
 {
 	boolean	result = false;
 
 	SD_FadeOutMusic();
 	while (SD_MusicPlaying())
 		;
 
 	switch (mode)
 	{
 	case smm_Off:
 		NeedsMusic = false;
 		result = true;
 		break;
 	case smm_AdLib:
 		if (AdLibPresent)
 		{
 			NeedsMusic = true;
 			result = true;
 		}
 		break;
 	}
 
 	if (result)
 		MusicMode = mode;
 
 	SDL_SetTimerSpeed();
 
 	return(result);
 }
 
 ///////////////////////////////////////////////////////////////////////////
 //
 //	SD_Startup() - starts up the Sound Mgr
 //		Detects all additional sound hardware and installs my ISR
 //
 ///////////////////////////////////////////////////////////////////////////
 void
 SD_Startup(void)
 {
 	int	i;
 
 	if (SD_Started)
 		return;
 
 	SDL_SetDS();
 
 	ssIsTandy = false;
 	ssNoCheck = false;
 	alNoCheck = false;
 	sbNoCheck = false;
 	sbNoProCheck = false;
 #ifndef	_MUSE_
 	for (i = 1;i < _argc;i++)
 	{
 		switch (US_CheckParm(_argv[i],ParmStrings))
 		{
 		case 0:						// No AdLib detection
 			alNoCheck = true;
 			break;
 		case 1:						// No SoundBlaster detection
 			sbNoCheck = true;
 			break;
 		case 2:						// No SoundBlaster Pro detection
 			sbNoProCheck = true;
 			break;
 		case 3:
 			ssNoCheck = true;		// No Sound Source detection
 			break;
 		case 4:						// Tandy Sound Source handling
 			ssIsTandy = true;
 			break;
 		case 5:						// Sound Source present at LPT1
 			ssPort = 1;
 			ssNoCheck = SoundSourcePresent = true;
 			break;
 		case 6:                     // Sound Source present at LPT2
 			ssPort = 2;
 			ssNoCheck = SoundSourcePresent = true;
 			break;
 		case 7:                     // Sound Source present at LPT3
 			ssPort = 3;
 			ssNoCheck = SoundSourcePresent = true;
 			break;
 		}
 	}
 #endif
 
 	SoundUserHook = 0;
 
 	t0OldService = getvect(8);	// Get old timer 0 ISR
 
 	LocalTime = TimeCount = alTimeCount = 0;
 
 	SD_SetSoundMode(sdm_Off);
 	SD_SetMusicMode(smm_Off);
 
 	if (!ssNoCheck)
 		SoundSourcePresent = SDL_DetectSoundSource();
 
 	if (!alNoCheck)
 	{
 		AdLibPresent = SDL_DetectAdLib();
 		if (AdLibPresent && !sbNoCheck)
 		{
 			int port = -1;
 			char *env = getenv("BLASTER");
 			if (env)
 			{
 				long temp;
 				while (*env)
 				{
 					while (isspace(*env))
 						env++;
 
 					switch (toupper(*env))
 					{
 					case 'A':
 						temp = strtol(env + 1,&env,16);
 						if
 						(
 							(temp >= 0x210)
 						&&	(temp <= 0x260)
 						&&	(!(temp & 0x00f))
 						)
 							port = (temp - 0x200) >> 4;
 						else
 							Quit("SD_Startup: Unsupported address value in BLASTER");
 						break;
 					case 'I':
 						temp = strtol(env + 1,&env,10);
 						if
 						(
 							(temp >= 0)
 						&&	(temp <= 10)
 						&&	(sbIntVectors[temp] != -1)
 						)
 						{
 							sbInterrupt = temp;
 							sbIntVec = sbIntVectors[sbInterrupt];
 						}
 						else
 							Quit("SD_Startup: Unsupported interrupt value in BLASTER");
 						break;
 					case 'D':
 						temp = strtol(env + 1,&env,10);
 						if ((temp == 0) || (temp == 1) || (temp == 3))
 							SDL_SBSetDMA(temp);
 						else
 							Quit("SD_Startup: Unsupported DMA value in BLASTER");
 						break;
 					default:
 						while (isspace(*env))
 							env++;
 						while (*env && !isspace(*env))
 							env++;
 						break;
 					}
 				}
 			}
 			SoundBlasterPresent = SDL_DetectSoundBlaster(port);
 		}
 	}
 
 	for (i = 0;i < 255;i++)
 		pcSoundLookup[i] = i * 60;
 
 	if (SoundBlasterPresent)
 		SDL_StartSB();
 
 	SDL_SetupDigi();
 
 	SD_Started = true;
 }
 
 ///////////////////////////////////////////////////////////////////////////
 //
 //	SD_Default() - Sets up the default behaviour for the Sound Mgr whether
 //		the config file was present or not.
 //
 ///////////////////////////////////////////////////////////////////////////
 void
 SD_Default(boolean gotit,SDMode sd,SMMode sm)
 {
 	boolean	gotsd,gotsm;
 
 	gotsd = gotsm = gotit;
 
 	if (gotsd)	// Make sure requested sound hardware is available
 	{
 		switch (sd)
 		{
 		case sdm_AdLib:
 			gotsd = AdLibPresent;
 			break;
 		}
 	}
 	if (!gotsd)
 	{
 		if (AdLibPresent)
 			sd = sdm_AdLib;
 		else
 			sd = sdm_PC;
 	}
 	if (sd != SoundMode)
 		SD_SetSoundMode(sd);
 
 
 	if (gotsm)	// Make sure requested music hardware is available
 	{
 		switch (sm)
 		{
 		case sdm_AdLib:
 			gotsm = AdLibPresent;
 			break;
 		}
 	}
 	if (!gotsm)
 	{
 		if (AdLibPresent)
 			sm = smm_AdLib;
 	}
 	if (sm != MusicMode)
 		SD_SetMusicMode(sm);
 }
 
 ///////////////////////////////////////////////////////////////////////////
 //
 //	SD_Shutdown() - shuts down the Sound Mgr
 //		Removes sound ISR and turns off whatever sound hardware was active
 //
 ///////////////////////////////////////////////////////////////////////////
 void
 SD_Shutdown(void)
 {
 	if (!SD_Started)
 		return;
 
 	SD_MusicOff();
 	SD_StopSound();
 	SDL_ShutDevice();
 	SDL_CleanDevice();
 
 	if (SoundBlasterPresent)
 		SDL_ShutSB();
 
 	if (SoundSourcePresent)
 		SDL_ShutSS();
 
 	asm	pushf
 	asm	cli
 
 	SDL_SetTimer0(0);
 
 	setvect(8,t0OldService);
 
 	asm	popf
 
 	SD_Started = false;
 }
 
 ///////////////////////////////////////////////////////////////////////////
 //
 //	SD_SetUserHook() - sets the routine that the Sound Mgr calls every 1/70th
 //		of a second from its timer 0 ISR
 //
 ///////////////////////////////////////////////////////////////////////////
 void
 SD_SetUserHook(void (* hook)(void))
 {
 	SoundUserHook = hook;
 }
 
 ///////////////////////////////////////////////////////////////////////////
 //
 //	SD_PositionSound() - Sets up a stereo imaging location for the next
 //		sound to be played. Each channel ranges from 0 to 15.
 //
 ///////////////////////////////////////////////////////////////////////////
 void
 SD_PositionSound(int leftvol,int rightvol)
 {
 	LeftPosition = leftvol;
 	RightPosition = rightvol;
 	nextsoundpos = true;
 }
 
 ///////////////////////////////////////////////////////////////////////////
 //
 //	SD_PlaySound() - plays the specified sound on the appropriate hardware
 //
 ///////////////////////////////////////////////////////////////////////////
 boolean
 SD_PlaySound(soundnames sound)
 {
 	boolean		ispos;
 	SoundCommon	far *s;
 	int	lp,rp;
 
 	lp = LeftPosition;
 	rp = RightPosition;
 	LeftPosition = 0;
 	RightPosition = 0;
 
 	ispos = nextsoundpos;
 	nextsoundpos = false;
 
 	if (sound == -1)
 		return(false);
 
 	s = MK_FP(SoundTable[sound],0);
 	if ((SoundMode != sdm_Off) && !s)
 		Quit("SD_PlaySound() - Uncached sound");
 
 	if ((DigiMode != sds_Off) && (DigiMap[sound] != -1))
 	{
 		if ((DigiMode == sds_PC) && (SoundMode == sdm_PC))
 		{
 			if (s->priority < SoundPriority)
 				return(false);
 
 			SDL_PCStopSound();
 
 			SD_PlayDigitized(DigiMap[sound],lp,rp);
 			SoundPositioned = ispos;
 			SoundNumber = sound;
 			SoundPriority = s->priority;
 		}
 		else
 		{
 		asm	pushf
 		asm	cli
 			if (DigiPriority && !DigiNumber)
 			{
 			asm	popf
 				Quit("SD_PlaySound: Priority without a sound");
 			}
 		asm	popf
 
 			if (s->priority < DigiPriority)
 				return(false);
 
 			SD_PlayDigitized(DigiMap[sound],lp,rp);
 			SoundPositioned = ispos;
 			DigiNumber = sound;
 			DigiPriority = s->priority;
 		}
 
 		return(true);
 	}
 
 	if (SoundMode == sdm_Off)
 		return(false);
 	if (!s->length)
 		Quit("SD_PlaySound() - Zero length sound");
 	if (s->priority < SoundPriority)
 		return(false);
 
 	switch (SoundMode)
 	{
 	case sdm_PC:
 		SDL_PCPlaySound((void far *)s);
 		break;
 	case sdm_AdLib:
 		SDL_ALPlaySound((void far *)s);
 		break;
 	}
 
 	SoundNumber = sound;
 	SoundPriority = s->priority;
 
 	return(false);
 }
 
 ///////////////////////////////////////////////////////////////////////////
 //
 //	SD_SoundPlaying() - returns the sound number that's playing, or 0 if
 //		no sound is playing
 //
 ///////////////////////////////////////////////////////////////////////////
 word
 SD_SoundPlaying(void)
 {
 	boolean	result = false;
 
 	switch (SoundMode)
 	{
 	case sdm_PC:
 		result = pcSound? true : false;
 		break;
 	case sdm_AdLib:
 		result = alSound? true : false;
 		break;
 	}
 
 	if (result)
 		return(SoundNumber);
 	else
 		return(false);
 }
 
 ///////////////////////////////////////////////////////////////////////////
 //
 //	SD_StopSound() - if a sound is playing, stops it
 //
 ///////////////////////////////////////////////////////////////////////////
 void
 SD_StopSound(void)
 {
 	if (DigiPlaying)
 		SD_StopDigitized();
 
 	switch (SoundMode)
 	{
 	case sdm_PC:
 		SDL_PCStopSound();
 		break;
 	case sdm_AdLib:
 		SDL_ALStopSound();
 		break;
 	}
 
 	SoundPositioned = false;
 
 	SDL_SoundFinished();
 }
 
 ///////////////////////////////////////////////////////////////////////////
 //
 //	SD_WaitSoundDone() - waits until the current sound is done playing
 //
 ///////////////////////////////////////////////////////////////////////////
 void
 SD_WaitSoundDone(void)
 {
 	while (SD_SoundPlaying())
 		;
 }
 
 ///////////////////////////////////////////////////////////////////////////
 //
 //	SD_MusicOn() - turns on the sequencer
 //
 ///////////////////////////////////////////////////////////////////////////
 void
 SD_MusicOn(void)
 {
 	sqActive = true;
 }
 
 ///////////////////////////////////////////////////////////////////////////
 //
 //	SD_MusicOff() - turns off the sequencer and any playing notes
 //
 ///////////////////////////////////////////////////////////////////////////
 void
 SD_MusicOff(void)
 {
 	word	i;
 
 
 	switch (MusicMode)
 	{
 	case smm_AdLib:
 		alFXReg = 0;
 		alOut(alEffects,0);
 		for (i = 0;i < sqMaxTracks;i++)
 			alOut(alFreqH + i + 1,0);
 		break;
 	}
 	sqActive = false;
 }
 
 ///////////////////////////////////////////////////////////////////////////
 //
 //	SD_StartMusic() - starts playing the music pointed to
 //
 ///////////////////////////////////////////////////////////////////////////
 void
 SD_StartMusic(MusicGroup far *music)
 {
 	SD_MusicOff();
 asm	pushf
 asm	cli
 
 	if (MusicMode == smm_AdLib)
 	{
 		sqHackPtr = sqHack = music->values;
 		sqHackSeqLen = sqHackLen = music->length;
 		sqHackTime = 0;
 		alTimeCount = 0;
 		SD_MusicOn();
 	}
 
 asm	popf
 }
 
 ///////////////////////////////////////////////////////////////////////////
 //
 //	SD_FadeOutMusic() - starts fading out the music. Call SD_MusicPlaying()
 //		to see if the fadeout is complete
 //
 ///////////////////////////////////////////////////////////////////////////
 void
 SD_FadeOutMusic(void)
 {
 	switch (MusicMode)
 	{
 	case smm_AdLib:
 		// DEBUG - quick hack to turn the music off
 		SD_MusicOff();
 		break;
 	}
 }
 
 ///////////////////////////////////////////////////////////////////////////
 //
 //	SD_MusicPlaying() - returns true if music is currently playing, false if
 //		not
 //
 ///////////////////////////////////////////////////////////////////////////
 boolean
 SD_MusicPlaying(void)
 {
 	boolean	result;
 
 	switch (MusicMode)
 	{
 	case smm_AdLib:
 		result = false;
 		// DEBUG - not written
 		break;
 	default:
 		result = false;
 	}
 
 	return(result);
 }