PRELOAD
// // 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 #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); }