/*
GUS.C
Michael Chen
mchen@cs.psu.edu
4/18/1993
See the included .TXT file for terms and other information.
Note that when playing back 16-bit samples, the start and end positions
are measured in 16-bit words, not bytes!
*/
#include "gus.h"
#include <stdio.h>
#include <dos.h>
int GUSBase;
int GUSMixer;
int GUSStatus;
int GUSTimerControl;
int GUSTimerData;
int GUSIRQDMAControl;
int GUSMIDIControl;
int GUSMIDIData;
int GUSVoice;
int GUSCommand;
int GUSDataLo;
int GUSDataHi;
int GUSDRAMIO;
int GUSCurrentVoice = -1;
int GUSVoices = MINVOICES;
byte GUSFreqDivisorTable[MAXVOICES+1] =
/*
Divisor table when setting voice frequency, based on number of voices.
Remember, minimum of 14 active voices (though divisors given for 8 and up).
*/
{ -1, -1, -1, -1, -1, -1, -1, -1, 74, 66, 60, 54, 50, 46, 43, 40, 37,
35, 33, 31, 30, 28, 27, 26, 25, 24, 23, 22, 21, 20, 20, 19, 18 };
void GUSDelay()
/*
Waits for GUS. (from Ultradox 2.0)
*/
{
int i;
for (i=0; i<7; i++)
inportb(0x300);
}
void GUSReset()
/*
Resets GUS. (from Ultradox 2.0)
*/
{
int i;
/* Force routines to select voice explicitly first time */
GUSCurrentVoice = -1;
/* Put GUS in initialization mode */
GUS_SetCommand(G_Initialize);
outportb(GUSDataHi,0);
GUSDelay();
GUSDelay();
/* Take GUS out of initialization mode */
GUS_SetCommand(G_Initialize);
outportb(GUSDataHi,1);
GUSDelay();
GUSDelay();
/* Ramp voices to 0 --- doesn't work yet */
/*
GUSShutUp();
*/
/* Clear DMA control */
GUS_SetCommand(G_DMAControl);
outportb(GUSDataHi,0);
/* Clear timer control */
GUS_SetCommand(G_TimerControl);
outportb(GUSDataHi,0);
/* Clear sample control */
GUS_SetCommand(G_SampleControl);
outportb(GUSDataHi,0);
/* Set number of voices to minimum. */
GUSSetVoices(MINVOICES);
/* Clear pending DMA control */
GUS_SetCommand(G_DMAControl);
inportb(GUSDataHi);
/* Clear pending timer control */
GUS_SetCommand(G_TimerControl);
inportb(GUSDataHi);
/* Clear pending sample control */
GUS_SetCommand(G_SampleControl);
inportb(GUSDataHi);
/* Reset voices */
for (i=0; i<MAXVOICES; i++)
{
/* Select voice */
GUSSelectVoice(i);
/* Stop voice */
GUSStopVoice(i);
/* Turn off volume ramp */
GUSStopRamp(i);
/* Set to zero volume */
GUSSetVolume(i,0);
/* Set to center pan */
GUSSetVoiceBalance(0,P_Center);
}
/* Clear pending DMA control */
GUS_SetCommand(G_DMAControl);
inportb(GUSDataHi);
/* Clear pending sample control */
GUS_SetCommand(G_SampleControl);
inportb(GUSDataHi);
/* Unknown read from IRQ status (?) */
GUS_SetCommand(G_IRQStatus);
inportb(GUSDataHi);
/* Do something to initialization register (?) */
GUS_SetCommand(G_Initialize);
outportb(GUSDataHi,7);
/* Set mixer to default (line-in and output on, mic-in off) */
GUSSetMixer(M_OutputOn|M_LineInOn|M_MicInOff);
}
byte GUSPeek(longword addr)
/*
Peeks at value from GUS DRAM (long address).
*/
{
return GUS_Peek(addr >> 16,addr & 0xFFFF);
}
void GUSPoke(longword addr, byte val)
/*
Pokes value to GUS DRAM (long address).
*/
{
GUS_Poke(addr >> 16,addr & 0xFFFF,val);
}
byte GUSPokePeek(longword addr, byte val)
/*
Pokes value to GUS DRAM (long address), then immediately peeks same.
*/
{
return GUS_PokePeek(addr >> 16,addr & 0xFFFF,val);
}
static byte GUS_Peek(byte addrhi, word addrlo)
/*
Peeks at value from GUS DRAM.
*/
{
GUS_SetCommand(G_SetDRAMLo);
outport(GUSDataLo,addrlo);
GUS_SetCommand(G_SetDRAMHi);
outportb(GUSDataHi,addrhi);
return GUS_ReadDRAMIO();
}
static void GUS_Poke(byte addrhi, word addrlo, byte val)
/*
Pokes value to GUS DRAM.
*/
{
GUS_SetCommand(G_SetDRAMLo);
outport(GUSDataLo,addrlo);
GUS_SetCommand(G_SetDRAMHi);
outportb(GUSDataHi,addrhi);
GUS_SetDRAMIO(val);
}
static byte GUS_PokePeek(byte addrhi, word addrlo, byte val)
/*
Pokes value to GUS DRAM, then immediately peek from same location.
*/
{
GUS_SetCommand(G_SetDRAMLo);
outport(GUSDataLo,addrlo);
GUS_SetCommand(G_SetDRAMHi);
outportb(GUSDataHi,addrhi);
outportb(GUSDRAMIO,val);
return GUS_ReadDRAMIO();
}
int ProbeGUS()
/*
Probes to see if GUS exists at current base address. (from Ultradox 2.0)
*/
{
byte testbyte = 0xAA;
byte test1;
GUS_SetCommand(G_Initialize);
outportb(GUSDataHi,0);
GUSDelay();
GUSDelay();
GUS_SetCommand(G_Initialize);
outportb(GUSDataHi,1);
GUSDelay();
GUSDelay();
GUSPoke(0,testbyte);
GUSPoke(1,0xFF - testbyte);
test1 = GUSPeek(0);
GUS_SetCommand(G_Initialize);
outportb(GUSDataHi,0);
return (test1 == testbyte);
}
int DetectGUS()
/*
Returns base address of GUS ports, or 0 if no GUS detected.
*/
{
for (GUSBase = 0x210; (GUSBase < 0x270); GUSBase += 0x10)
{
GUSMixer = GUSBase;
GUSStatus = GUSBase + 6;
GUSTimerControl = GUSBase + 8;
GUSTimerData = GUSBase + 9;
GUSIRQDMAControl = GUSBase + 0xB;
GUSMIDIControl = GUSBase + 0x100;
GUSMIDIData = GUSBase + 0x101;
GUSVoice = GUSBase + 0x102;
GUSCommand = GUSBase + 0x103;
GUSDataLo = GUSBase + 0x104;
GUSDataHi = GUSBase + 0x105;
GUSDRAMIO = GUSBase + 0x107;
if (ProbeGUS()) break;
}
if (GUSBase < 0x270)
return GUSBase;
else
return 0;
}
static void GUS_SelectVoice(byte voice)
/*
Selects current GUS voice for subsequent commands.
*/
{
GUS_SetVoice(voice);
GUSCurrentVoice = voice;
}
void GUSSelectVoice(byte voice)
/*
Changes current GUS voice for subsequent commands if necessary.
*/
{
if (GUSCurrentVoice != voice)
GUS_SelectVoice(voice);
}
void GUSStopVoice(byte voice)
/*
Stops GUS voice.
*/
{
byte b;
GUSSelectVoice(voice);
b = GUSReadVoiceMode(voice);
if (!(b & V_VoiceStopped))
{
b |= 3;
GUS_SetCommand(G_SetVoiceMode);
outportb(GUSDataHi,b);
}
}
void GUSStartVoice(byte voice)
/*
Starts GUS voice.
*/
{
byte b;
GUSSelectVoice(voice);
b = GUSReadVoiceMode(voice);
if (b & V_VoiceStopped)
{
b &= 0xFC;
GUS_SetCommand(G_SetVoiceMode);
outportb(GUSDataHi,b);
}
}
void GUSSetVoiceMode(byte voice, byte mode)
/*
Sets GUS voice mode (not start/stop, though) directly.
*/
{
byte b;
GUSSelectVoice(voice);
GUS_SetCommand(G_ReadVoiceMode);
b = inportb(GUSDataHi);
b &= 3;
b |= (mode & 0xFC);
GUS_SetCommand(G_SetVoiceMode);
outportb(GUSDataHi,b);
}
void GUSSetVoices(byte voices)
/*
Sets number of voices for GUS.
*/
{
GUS_SetCommand(G_SetMaxVoice);
outportb(GUSDataHi,((voices-1) | G_VoiceMask));
GUSVoices = voices;
}
void GUSSetVoiceFreq(byte voice, word freq)
/*
Sets GUS voice frequency, taking into account number of voices.
*/
{
GUSSelectVoice(voice);
GUS_SetCommand(G_SetVoiceFreq);
outport(GUSDataLo,freq/GUSFreqDivisorTable[GUSVoices]);
}
static void GUS_SetLoopStart(byte voice, word hi, word lo)
{
GUSSelectVoice(voice);
GUS_SetCommand(G_SetLoopStartLo);
outport(GUSDataLo,lo);
GUS_SetCommand(G_SetLoopStartHi);
outport(GUSDataLo,hi);
}
static void GUS_SetLoopEnd(byte voice, word hi, word lo)
{
GUSSelectVoice(voice);
GUS_SetCommand(G_SetLoopEndLo);
outport(GUSDataLo,lo);
GUS_SetCommand(G_SetLoopEndHi);
outport(GUSDataLo,hi);
}
static void GUS_SetPosition(byte voice, word hi, word lo)
{
GUSSelectVoice(voice);
GUS_SetCommand(G_SetPositionLo);
outport(GUSDataLo,lo);
GUS_SetCommand(G_SetPositionHi);
outport(GUSDataLo,hi);
}
void GUSSetLoopStart(byte voice, longword addr)
/*
Sets loop start of voice.
*/
{
GUS_SetLoopStart(voice,addr << 9, addr >> 7);
}
void GUSSetLoopEnd(byte voice, longword addr)
/*
Sets loop (sample) end of voice.
*/
{
GUS_SetLoopEnd(voice,addr << 9, addr >> 7);
}
void GUSSetPosition(byte voice, longword addr)
/*
Sets position (sample begin) of voice.
*/
{
GUS_SetPosition(voice,addr << 9, addr >> 7);
}
longword GUSReadLoopEnd(byte voice)
/*
Reads loop (sample) end of voice.
*/
{
longword l;
GUSSelectVoice(voice);
GUS_SetCommand(G_ReadLoopEndLo);
l = ((longword)((word)inport(GUSDataLo)) & 0x1FFF) << 7;
GUS_SetCommand(G_ReadLoopEndHi);
l |= ((word)inport(GUSDataLo)) >> 9;
return l;
}
longword GUSReadLoopStart(byte voice)
/*
Reads loop start of voice.
*/
{
longword l;
GUSSelectVoice(voice);
GUS_SetCommand(G_ReadLoopStartLo);
l = ((longword)((word)inport(GUSDataLo)) & 0x1FFF) << 7;
GUS_SetCommand(G_ReadLoopStartHi);
l |= ((word)inport(GUSDataLo)) >> 9;
return l;
}
longword GUSReadPosition(byte voice)
/*
Reads position (sample begin) of voice.
*/
{
longword l;
GUSSelectVoice(voice);
GUS_SetCommand(G_ReadPositionLo);
l = ((longword)((word)inport(GUSDataLo)) & 0x1FFF) << 7;
GUS_SetCommand(G_ReadPositionHi);
l |= ((word)inport(GUSDataLo)) >> 9;
return l;
}
byte GUSReadVoiceMode(byte voice)
/*
Reads mode of voice.
*/
{
GUSSelectVoice(voice);
GUS_SetCommand(G_ReadVoiceMode);
return inportb(GUSDataHi);
}
word GUSReadVoiceFreq(byte voice)
/*
Reads frequency of voice.
*/
{
GUSSelectVoice(voice);
GUS_SetCommand(G_ReadVoiceFreq);
return inport(GUSDataLo) * GUSFreqDivisorTable[GUSVoices];
}
void GUSSetVolume(byte voice, word vol)
/*
Sets volume of voice.
*/
{
GUSSelectVoice(voice);
GUS_SetCommand(G_SetVolume);
outport(GUSDataLo,vol);
}
word GUSReadVolume(byte voice)
/*
Reads volume of voice.
*/
{
GUSSelectVoice(voice);
GUS_SetCommand(G_ReadVolume);
return (word)inport(GUSDataLo);
}
void GUSSetVoiceBalance(byte voice, byte pan)
/*
Sets pan of voice.
*/
{
GUSSelectVoice(voice);
GUS_SetCommand(G_SetVoiceBalance);
outportb(GUSDataHi,pan);
}
byte GUSReadVoiceBalance(byte voice)
/*
Reads pan of voice.
*/
{
GUSSelectVoice(voice);
GUS_SetCommand(G_ReadVoiceBalance);
return inportb(GUSDataHi);
}
/*
void GUSSetDRAM(longword addr, void* buf, longword len)
Set region of GUS DRAM starting at addr, len bytes long to buf.
Not yet optimized for speed.
{
byte* bp;
bp = buf;
while (len-- > 0)
{
GUSPoke(addr++,*bp++);
}
}
*/
void GUSSetDRAM(longword addr, void* buf, longword len)
/*
Set region of GUS DRAM starting at addr, len bytes long to buf.
(Supposedly) partially optimized for speed.
*/
{
byte* bp;
byte addrhi;
word addrlo;
bp = buf;
addrhi = addr >> 16;
addrlo = addr & 0xFFFF;
GUS_SetCommand(G_SetDRAMHi);
outportb(GUSDataHi,addrhi);
GUS_SetCommand(G_SetDRAMLo);
while (len-- > 0)
{
outport(GUSDataLo,addrlo++);
GUS_SetDRAMIO(*bp++);
if (!addrlo)
{
GUS_SetCommand(G_SetDRAMHi);
outportb(GUSDataHi,addrhi);
GUS_SetCommand(G_SetDRAMLo);
}
}
}
/*
void GUSReadDRAM(longword addr, void* buf, longword len)
Read region of GUS DRAM starting at addr, len bytes long to buf.
Not yet optimized for speed.
{
byte* bp;
bp = buf;
while (len-- > 0)
{
*bp++ = GUSPeek(addr++);
}
}
*/
void GUSReadDRAM(longword addr, void* buf, longword len)
/*
Read region of GUS DRAM starting at addr, len bytes long to buf.
(Supposedly) partially optimized for speed.
*/
{
byte* bp;
byte addrhi;
word addrlo;
bp = buf;
addrhi = addr >> 16;
addrlo = addr & 0xFFFF;
GUS_SetCommand(G_SetDRAMHi);
outportb(GUSDataHi,addrhi);
GUS_SetCommand(G_SetDRAMLo);
while (len-- > 0)
{
outport(GUSDataLo,addrlo++);
*bp++ = GUS_ReadDRAMIO();
if (!addrlo)
{
GUS_SetCommand(G_SetDRAMHi);
outportb(GUSDataHi,addrhi);
GUS_SetCommand(G_SetDRAMLo);
}
}
}
void GUSFillDRAM(longword addr, byte b, longword len)
/*
Set region of GUS DRAM starting at addr, len bytes long to b.
(Supposedly) partially optimized for speed.
*/
{
byte addrhi;
word addrlo;
addrhi = addr >> 16;
addrlo = addr & 0xFFFF;
GUS_SetCommand(G_SetDRAMHi);
outportb(GUSDataHi,addrhi);
GUS_SetCommand(G_SetDRAMLo);
while (len-- > 0)
{
outport(GUSDataLo,addrlo++);
GUS_SetDRAMIO(b);
if (!addrlo)
{
GUS_SetCommand(G_SetDRAMHi);
outportb(GUSDataHi,addrhi);
GUS_SetCommand(G_SetDRAMLo);
}
}
}
void GUSSetVolumeRampRate(byte voice, byte incr, byte scale)
/*
Set voice's volume ramp rate. Scale updates as follows:
00 - every access
01 - every 8th access
10 - every 64th access
11 - every 512th access
Advice from Ultradox 2.0: use increments of 8 or less; don't ramp to either
extreme (below 636, above 4032)
*/
{
GUSSelectVoice(voice);
GUS_SetCommand(G_SetVolumeRampRate);
outportb(GUSDataHi,(incr & 0x3f) | ((scale & 3) << 6));
}
byte GUSReadVolumeRampRate(byte voice)
{
GUSSelectVoice(voice);
GUS_SetCommand(G_SetVolumeRampRate);
return inportb(GUSDataHi);
}
void GUSSetVolumeRampStart(byte voice, word vol)
{
GUSSelectVoice(voice);
GUS_SetCommand(G_SetVolumeRampStart);
outportb(GUSDataHi,(vol >> 8));
}
void GUSSetVolumeRampEnd(byte voice, word vol)
{
GUSSelectVoice(voice);
GUS_SetCommand(G_SetVolumeRampEnd);
outportb(GUSDataHi,(vol >> 8));
}
word GUSReadVolumeRampStart(byte voice)
{
GUSSelectVoice(voice);
GUS_SetCommand(G_ReadVolumeRampStart);
return ((word)inportb(GUSDataHi)) << 8;
}
word GUSReadVolumeRampEnd(byte voice)
{
GUSSelectVoice(voice);
GUS_SetCommand(G_ReadVolumeRampEnd);
return ((word)inportb(GUSDataHi)) << 8;
}
void GUSSetVolumeControl(byte voice, byte mode)
{
GUSSelectVoice(voice);
GUS_SetCommand(G_SetVolumeControl);
outportb(GUSDataHi,mode);
}
byte GUSReadVolumeControl(byte voice)
{
GUSSelectVoice(voice);
GUS_SetCommand(G_ReadVolumeControl);
return inportb(GUSDataHi);
}
static int GUSMixerState = 0;
void GUSSetMixer(byte mode)
{
GUSMixerState = mode;
GUS_SetMixer(mode);
}
byte GUSReadMixer()
{
return GUSMixerState;
}
void GUSStopRamp(byte voice)
/*
Stops GUS voice ramp.
*/
{
byte b;
GUSSelectVoice(voice);
b = GUSReadVolumeControl(voice);
if (!(b & V_RampStopped))
{
b |= 3;
GUS_SetCommand(G_SetVolumeControl);
outportb(GUSDataHi,b);
}
}
void GUSStartRamp(byte voice)
/*
Starts GUS voice ramp.
*/
{
byte b;
GUSSelectVoice(voice);
b = GUSReadVolumeControl(voice);
if (b & V_RampStopped)
{
b &= 0xFC;
GUS_SetCommand(G_SetVolumeControl);
outportb(GUSDataHi,b);
}
}
void GUSShutUp()
{
int i;
word vol;
byte incr;
for (i = 0; i < MAXVOICES; i++)
{
GUSSelectVoice(i);
vol = GUSReadVolume(i);
if (vol > 0)
{
GUSSetVolumeRampStart(i,vol);
GUSSetVolumeRampEnd(i,0);
GUSSetVolumeRampRate(i,1,R_Every1);
GUSSetVolumeControl(i,V_StartRamp|V_Decreasing);
GUSStartRamp(i);
/* code for ramps seems not to work; no change in volume */
while ((incr = GUSReadVolumeControl(i) & V_RampStopped)
!= V_RampStopped)
{
vol = GUSReadVolume(i);
if (vol >> 12 == 0) break; /* quiet enough */
printf("vol 0x%04x mode 0x%02x\r",vol,incr);
}
}
}
}
