apogee/rott
0
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
rott/audiolib/SOURCE/BLASTOLD.C
archive 5b05925be2 as released 2002-12-25
2002-12-25 00:00:00 +00:00

2415 lines
59 KiB
C
Raw Blame History

/*
Copyright (C) 1994-1995 Apogee Software, Ltd.
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
/**********************************************************************
module: BLASTER.C
author: James R. Dose
date: February 4, 1994
Low level routines to support Sound Blaster, Sound Blaster Pro,
Sound Blaster 16, and compatible sound cards.
(c) Copyright 1994 James R. Dose. All Rights Reserved.
**********************************************************************/
#include <dos.h>
#include <conio.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include "dpmi.h"
#include "dma.h"
#include "irq.h"
#include "blaster.h"
#include "_blaster.h"
#define USESTACK
const int BLASTER_Interrupts[ BLASTER_MaxIrq + 1 ] =
{
INVALID, INVALID, 0xa, 0xb,
INVALID, 0xd, INVALID, 0xf,
INVALID, INVALID, 0x72, 0x73,
0x74, INVALID, INVALID, 0x77
};
const int BLASTER_SampleSize[ BLASTER_MaxMixMode + 1 ] =
{
MONO_8BIT_SAMPLE_SIZE, STEREO_8BIT_SAMPLE_SIZE,
MONO_16BIT_SAMPLE_SIZE, STEREO_16BIT_SAMPLE_SIZE
};
const CARD_CAPABILITY BLASTER_CardConfig[ BLASTER_MaxCardType + 1 ] =
{
{ FALSE, INVALID, INVALID, INVALID, INVALID }, // Unsupported
{ TRUE, NO, MONO_8BIT, 4000, 23000 }, // SB 1.0
{ TRUE, YES, STEREO_8BIT, 4000, 44100 }, // SBPro
{ TRUE, NO, MONO_8BIT, 4000, 23000 }, // SB 2.xx
{ TRUE, YES, STEREO_8BIT, 4000, 44100 }, // SBPro 2
{ FALSE, INVALID, INVALID, INVALID, INVALID }, // Unsupported
{ TRUE, YES, STEREO_16BIT, 5000, 44100 }, // SB16
};
static void ( __interrupt __far *BLASTER_OldInt )( void );
BLASTER_CONFIG BLASTER_Config =
{
UNDEFINED, UNDEFINED, UNDEFINED, UNDEFINED, UNDEFINED, UNDEFINED
};
static int BLASTER_Installed = FALSE;
static int BLASTER_Version;
static char *BLASTER_DMABuffer;
static char *BLASTER_DMABufferEnd;
static char *BLASTER_CurrentDMABuffer;
static int BLASTER_TotalDMABufferSize;
static int BLASTER_TransferLength = 0;
static int BLASTER_MixMode = BLASTER_DefaultMixMode;
static int BLASTER_SamplePacketSize = MONO_16BIT_SAMPLE_SIZE;
static unsigned BLASTER_SampleRate = BLASTER_DefaultSampleRate;
static unsigned BLASTER_HaltTransferCommand = DSP_Halt8bitTransfer;
volatile int BLASTER_SoundPlaying;
volatile int BLASTER_SoundRecording;
void ( *BLASTER_CallBack )( void );
static int BLASTER_IntController1Mask;
static int BLASTER_IntController2Mask;
static int BLASTER_MixerAddress = UNDEFINED;
static int BLASTER_MixerType = 0;
static int BLASTER_OriginalMidiVolumeLeft = 255;
static int BLASTER_OriginalMidiVolumeRight = 255;
static int BLASTER_OriginalVoiceVolumeLeft = 255;
static int BLASTER_OriginalVoiceVolumeRight = 255;
static int BLASTER_WaveBlasterPort = UNDEFINED;
static int BLASTER_WaveBlasterState = 0x0F;
// adequate stack size
#define kStackSize 2048
static unsigned short StackSelector = NULL;
static unsigned long StackPointer;
static unsigned short oldStackSelector;
static unsigned long oldStackPointer;
// This is defined because we can't create local variables in a
// function that switches stacks.
static int GlobalStatus;
// These declarations are necessary to use the inline assembly pragmas.
extern void GetStack(unsigned short *selptr,unsigned long *stackptr);
extern void SetStack(unsigned short selector,unsigned long stackptr);
// This function will get the current stack selector and pointer and save
// them off.
#pragma aux GetStack = \
"mov [edi],esp" \
"mov ax,ss" \
"mov [esi],ax" \
parm [esi] [edi] \
modify [eax esi edi];
// This function will set the stack selector and pointer to the specified
// values.
#pragma aux SetStack = \
"mov ss,ax" \
"mov esp,edx" \
parm [ax] [edx] \
modify [eax edx];
int BLASTER_DMAChannel;
int BLASTER_ErrorCode = BLASTER_Ok;
#define BLASTER_SetErrorCode( status ) \
BLASTER_ErrorCode = ( status );
/*---------------------------------------------------------------------
Function: BLASTER_ErrorString
Returns a pointer to the error message associated with an error
number. A -1 returns a pointer the current error.
---------------------------------------------------------------------*/
char *BLASTER_ErrorString
(
int ErrorNumber
)
{
char *ErrorString;
switch( ErrorNumber )
{
case BLASTER_Warning :
case BLASTER_Error :
ErrorString = BLASTER_ErrorString( BLASTER_ErrorCode );
break;
case BLASTER_Ok :
ErrorString = "Sound Blaster ok.";
break;
case BLASTER_EnvNotFound :
ErrorString = "BLASTER environment variable not set.";
break;
case BLASTER_AddrNotSet :
ErrorString = "Missing Sound Blaster address in BLASTER environment variable.";
break;
case BLASTER_IntNotSet :
ErrorString = "Missing Sound Blaster interrupt in BLASTER environment variable.";
break;
case BLASTER_DMANotSet :
ErrorString = "Missing Sound Blaster DMA channel in BLASTER environment variable.";
break;
case BLASTER_DMA16NotSet :
ErrorString = "Missing Sound Blaster 16-bit DMA channel in BLASTER environment variable.";
break;
case BLASTER_MIDINotSet :
ErrorString = "Missing WaveBlaster MIDI port in BLASTER environment variable.";
break;
case BLASTER_CardTypeNotSet :
ErrorString = "Missing Sound Blaster card Type parameter in BLASTER environment variable.";
break;
case BLASTER_InvalidParameter :
ErrorString = "Invalid parameter in BLASTER environment variable.";
break;
case BLASTER_UnsupportedCardType :
ErrorString = "Unsupported card selected in BLASTER environment variable T parameter.";
break;
case BLASTER_CardNotReady :
ErrorString = "Sound Blaster not responding on selected port.";
break;
case BLASTER_NoSoundPlaying :
ErrorString = "No sound playing on Sound Blaster.";
break;
case BLASTER_InvalidIrq :
ErrorString = "Invalid Sound Blaster Irq.";
break;
case BLASTER_UnableToSetIrq :
ErrorString = "Unable to set Sound Blaster IRQ. Try selecting an IRQ of 7 or below.";
break;
case BLASTER_DmaError :
ErrorString = DMA_ErrorString( DMA_Error );
break;
case BLASTER_NoMixer :
ErrorString = "Mixer not available on selected Sound Blaster card.";
break;
case BLASTER_DPMI_Error :
ErrorString = "DPMI Error in Blaster.";
break;
case BLASTER_OutOfMemory :
ErrorString = "Out of conventional memory in Blaster.";
break;
default :
ErrorString = "Unknown Sound Blaster error code.";
break;
}
return( ErrorString );
}
/**********************************************************************
Memory locked functions:
**********************************************************************/
#define BLASTER_LockStart BLASTER_EnableInterrupt
/*---------------------------------------------------------------------
Function: BLASTER_EnableInterrupt
Enables the triggering of the sound card interrupt.
---------------------------------------------------------------------*/
void BLASTER_EnableInterrupt
(
void
)
{
int Irq;
int mask;
// Unmask system interrupt
Irq = BLASTER_Config.Interrupt;
if ( Irq < 8 )
{
mask = inp( 0x21 ) & ~( 1 << Irq );
outp( 0x21, mask );
}
else
{
mask = inp( 0xA1 ) & ~( 1 << ( Irq - 8 ) );
outp( 0xA1, mask );
mask = inp( 0x21 ) & ~( 1 << 2 );
outp( 0x21, mask );
}
}
/*---------------------------------------------------------------------
Function: BLASTER_DisableInterrupt
Disables the triggering of the sound card interrupt.
---------------------------------------------------------------------*/
void BLASTER_DisableInterrupt
(
void
)
{
int Irq;
int mask;
// Restore interrupt mask
Irq = BLASTER_Config.Interrupt;
if ( Irq < 8 )
{
mask = inp( 0x21 ) & ~( 1 << Irq );
mask |= BLASTER_IntController1Mask & ( 1 << Irq );
outp( 0x21, mask );
}
else
{
mask = inp( 0x21 ) & ~( 1 << 2 );
mask |= BLASTER_IntController1Mask & ( 1 << 2 );
outp( 0x21, mask );
mask = inp( 0xA1 ) & ~( 1 << ( Irq - 8 ) );
mask |= BLASTER_IntController2Mask & ( 1 << ( Irq - 8 ) );
outp( 0xA1, mask );
}
}
/*---------------------------------------------------------------------
Function: BLASTER_ServiceInterrupt
Handles interrupt generated by sound card at the end of a voice
transfer. Calls the user supplied callback function.
---------------------------------------------------------------------*/
void __interrupt __far BLASTER_ServiceInterrupt
(
void
)
{
#ifdef USESTACK
// save stack
GetStack( &oldStackSelector, &oldStackPointer );
// set our stack
SetStack( StackSelector, StackPointer );
#endif
// Acknowledge interrupt
// Check if this is this an SB16 or newer
if ( BLASTER_Version >= DSP_Version4xx )
{
outp( BLASTER_Config.Address + BLASTER_MixerAddressPort,
MIXER_DSP4xxISR_Ack );
GlobalStatus = inp( BLASTER_Config.Address + BLASTER_MixerDataPort );
// Check if a 16-bit DMA interrupt occurred
if ( GlobalStatus & MIXER_16BITDMA_INT )
{
// Acknowledge 16-bit transfer interrupt
inp( BLASTER_Config.Address + BLASTER_16BitDMAAck );
}
else if ( GlobalStatus & MIXER_8BITDMA_INT )
{
inp( BLASTER_Config.Address + BLASTER_DataAvailablePort );
}
else
{
#ifdef USESTACK
// restore stack
SetStack( oldStackSelector, oldStackPointer );
#endif
// Wasn't our interrupt. Call the old one.
_chain_intr( BLASTER_OldInt );
}
}
else
{
// Older card - can't detect if an interrupt occurred.
inp( BLASTER_Config.Address + BLASTER_DataAvailablePort );
}
// Keep track of current buffer
BLASTER_CurrentDMABuffer += BLASTER_TransferLength;
if ( BLASTER_CurrentDMABuffer >= BLASTER_DMABufferEnd )
{
BLASTER_CurrentDMABuffer = BLASTER_DMABuffer;
}
// Continue playback on cards without autoinit mode
if ( BLASTER_Version < DSP_Version2xx )
{
if ( BLASTER_SoundPlaying )
{
BLASTER_DSP1xx_BeginPlayback( BLASTER_TransferLength );
}
if ( BLASTER_SoundRecording )
{
BLASTER_DSP1xx_BeginRecord( BLASTER_TransferLength );
}
}
// Call the caller's callback function
if ( BLASTER_CallBack != NULL )
{
BLASTER_CallBack();
}
#ifdef USESTACK
// restore stack
SetStack( oldStackSelector, oldStackPointer );
#endif
// send EOI to Interrupt Controller
if ( BLASTER_Config.Interrupt > 7 )
{
outp( 0xA0, 0x20 );
}
outp( 0x20, 0x20 );
}
/*---------------------------------------------------------------------
Function: BLASTER_WriteDSP
Writes a byte of data to the sound card's DSP.
---------------------------------------------------------------------*/
int BLASTER_WriteDSP
(
unsigned data
)
{
int port;
unsigned count;
int status;
port = BLASTER_Config.Address + BLASTER_WritePort;
status = BLASTER_Error;
count = 0xFFFF;
do
{
if ( ( inp( port ) & 0x80 ) == 0 )
{
outp( port, data );
status = BLASTER_Ok;
break;
}
count--;
}
while( count > 0 );
if ( status != BLASTER_Ok )
{
BLASTER_SetErrorCode( BLASTER_CardNotReady );
}
return( status );
}
/*---------------------------------------------------------------------
Function: BLASTER_ReadDSP
Reads a byte of data from the sound card's DSP.
---------------------------------------------------------------------*/
int BLASTER_ReadDSP
(
void
)
{
int port;
unsigned count;
int status;
port = BLASTER_Config.Address + BLASTER_DataAvailablePort;
status = BLASTER_Error;
count = 0xFFFF;
do
{
if ( inp( port ) & 0x80 )
{
status = inp( BLASTER_Config.Address + BLASTER_ReadPort );
break;
}
count--;
}
while( count > 0 );
if ( status == BLASTER_Error )
{
BLASTER_SetErrorCode( BLASTER_CardNotReady );
}
return( status );
}
/*---------------------------------------------------------------------
Function: BLASTER_ResetDSP
Sends a reset command to the sound card's Digital Signal Processor
(DSP), causing it to perform an initialization.
---------------------------------------------------------------------*/
int BLASTER_ResetDSP
(
void
)
{
volatile int count;
int port;
int status;
port = BLASTER_Config.Address + BLASTER_ResetPort;
status = BLASTER_CardNotReady;
outp( port, 1 );
/* What the hell am I doing here?
count = 100;
do
{
if ( inp( port ) == 255 )
{
break;
}
count--;
}
while( count > 0 );
*/
count = 0x100;
do
{
count--;
}
while( count > 0 );
outp( port, 0 );
count = 100;
do
{
if ( BLASTER_ReadDSP() == BLASTER_Ready )
{
status = BLASTER_Ok;
break;
}
count--;
}
while( count > 0 );
return( status );
}
/*---------------------------------------------------------------------
Function: BLASTER_GetDSPVersion
Returns the version number of the sound card's DSP.
---------------------------------------------------------------------*/
int BLASTER_GetDSPVersion
(
void
)
{
int MajorVersion;
int MinorVersion;
int version;
BLASTER_WriteDSP( DSP_GetVersion );
MajorVersion = BLASTER_ReadDSP();
MinorVersion = BLASTER_ReadDSP();
if ( ( MajorVersion == BLASTER_Error ) ||
( MinorVersion == BLASTER_Error ) )
{
BLASTER_SetErrorCode( BLASTER_CardNotReady );
return( BLASTER_Error );
}
version = ( MajorVersion << 8 ) + MinorVersion;
return( version );
}
/*---------------------------------------------------------------------
Function: BLASTER_SpeakerOn
Enables output from the DAC.
---------------------------------------------------------------------*/
void BLASTER_SpeakerOn
(
void
)
{
BLASTER_WriteDSP( DSP_SpeakerOn );
}
/*---------------------------------------------------------------------
Function: BLASTER_SpeakerOff
Disables output from the DAC.
---------------------------------------------------------------------*/
void BLASTER_SpeakerOff
(
void
)
{
BLASTER_WriteDSP( DSP_SpeakerOff );
}
/*---------------------------------------------------------------------
Function: BLASTER_SetPlaybackRate
Sets the rate at which the digitized sound will be played in
hertz.
---------------------------------------------------------------------*/
void BLASTER_SetPlaybackRate
(
unsigned rate
)
{
int LoByte;
int HiByte;
CARD_CAPABILITY const *card;
card = &BLASTER_CardConfig[ BLASTER_Config.Type ];
if ( BLASTER_Version < DSP_Version4xx )
{
int timeconstant;
long ActualRate;
// Send sampling rate as time constant for older Sound
// Blaster compatible cards.
ActualRate = rate * BLASTER_SamplePacketSize;
if ( ActualRate < card->MinSamplingRate )
{
rate = card->MinSamplingRate / BLASTER_SamplePacketSize;
}
if ( ActualRate > card->MaxSamplingRate )
{
rate = card->MaxSamplingRate / BLASTER_SamplePacketSize;
}
timeconstant = ( int )CalcTimeConstant( rate, BLASTER_SamplePacketSize );
// Keep track of what the actual rate is
BLASTER_SampleRate = ( unsigned )CalcSamplingRate( timeconstant );
BLASTER_SampleRate /= BLASTER_SamplePacketSize;
BLASTER_WriteDSP( DSP_SetTimeConstant );
BLASTER_WriteDSP( timeconstant );
}
else
{
// Send literal sampling rate for cards with DSP version
// 4.xx (Sound Blaster 16)
BLASTER_SampleRate = rate;
if ( BLASTER_SampleRate < card->MinSamplingRate )
{
BLASTER_SampleRate = card->MinSamplingRate;
}
if ( BLASTER_SampleRate > card->MaxSamplingRate )
{
BLASTER_SampleRate = card->MaxSamplingRate;
}
HiByte = hibyte( BLASTER_SampleRate );
LoByte = lobyte( BLASTER_SampleRate );
// Set playback rate
BLASTER_WriteDSP( DSP_Set_DA_Rate );
BLASTER_WriteDSP( HiByte );
BLASTER_WriteDSP( LoByte );
// Set recording rate
BLASTER_WriteDSP( DSP_Set_AD_Rate );
BLASTER_WriteDSP( HiByte );
BLASTER_WriteDSP( LoByte );
}
}
/*---------------------------------------------------------------------
Function: BLASTER_GetPlaybackRate
Returns the rate at which the digitized sound will be played in
hertz.
---------------------------------------------------------------------*/
unsigned BLASTER_GetPlaybackRate
(
void
)
{
return( BLASTER_SampleRate );
}
/*---------------------------------------------------------------------
Function: BLASTER_SetMixMode
Sets the sound card to play samples in mono or stereo.
---------------------------------------------------------------------*/
int BLASTER_SetMixMode
(
int mode
)
{
int port;
int data;
int CardType;
CardType = BLASTER_Config.Type;
mode &= BLASTER_MaxMixMode;
if ( !( BLASTER_CardConfig[ CardType ].MaxMixMode & STEREO ) )
{
mode &= ~STEREO;
}
if ( !( BLASTER_CardConfig[ CardType ].MaxMixMode & SIXTEEN_BIT ) )
{
mode &= ~SIXTEEN_BIT;
}
BLASTER_MixMode = mode;
BLASTER_SamplePacketSize = BLASTER_SampleSize[ mode ];
// For the Sound Blaster Pro, we have to set the mixer chip
// to play mono or stereo samples.
if ( ( CardType == SBPro ) || ( CardType == SBPro2 ) )
{
port = BLASTER_Config.Address + BLASTER_MixerAddressPort;
outp( port, MIXER_SBProOutputSetting );
port = BLASTER_Config.Address + BLASTER_MixerDataPort;
// Get current mode
data = inp( port );
// set stereo mode bit
if ( mode & STEREO )
{
data |= MIXER_SBProStereoFlag;
}
else
{
data &= ~MIXER_SBProStereoFlag;
}
// set the mode
outp( port, data );
BLASTER_SetPlaybackRate( BLASTER_SampleRate );
}
return( mode );
}
/*---------------------------------------------------------------------
Function: BLASTER_StopPlayback
Ends the DMA transfer of digitized sound to the sound card.
---------------------------------------------------------------------*/
void BLASTER_StopPlayback
(
void
)
{
int DmaChannel;
// Don't allow anymore interrupts
BLASTER_DisableInterrupt();
if ( BLASTER_HaltTransferCommand == DSP_Reset )
{
BLASTER_ResetDSP();
}
else
{
BLASTER_WriteDSP( BLASTER_HaltTransferCommand );
}
// Disable the DMA channel
if ( BLASTER_MixMode & SIXTEEN_BIT )
{
DmaChannel = BLASTER_Config.Dma16;
}
else
{
DmaChannel = BLASTER_Config.Dma8;
}
DMA_EndTransfer( DmaChannel );
// Turn off speaker
BLASTER_SpeakerOff();
BLASTER_SoundPlaying = FALSE;
BLASTER_SoundRecording = FALSE;
BLASTER_DMABuffer = NULL;
}
/*---------------------------------------------------------------------
Function: BLASTER_SetupDMABuffer
Programs the DMAC for sound transfer.
---------------------------------------------------------------------*/
int BLASTER_SetupDMABuffer
(
char *BufferPtr,
int BufferSize,
int mode
)
{
int DmaChannel;
int DmaStatus;
int errorcode;
if ( BLASTER_MixMode & SIXTEEN_BIT )
{
DmaChannel = BLASTER_Config.Dma16;
errorcode = BLASTER_DMA16NotSet;
}
else
{
DmaChannel = BLASTER_Config.Dma8;
errorcode = BLASTER_DMANotSet;
}
if ( DmaChannel == UNDEFINED )
{
BLASTER_SetErrorCode( errorcode );
return( BLASTER_Error );
}
DmaStatus = DMA_SetupTransfer( DmaChannel, BufferPtr, BufferSize, mode );
if ( DmaStatus == DMA_Error )
{
BLASTER_SetErrorCode( BLASTER_DmaError );
return( BLASTER_Error );
}
BLASTER_DMAChannel = DmaChannel;
BLASTER_DMABuffer = BufferPtr;
BLASTER_CurrentDMABuffer = BufferPtr;
BLASTER_TotalDMABufferSize = BufferSize;
BLASTER_DMABufferEnd = BufferPtr + BufferSize;
return( BLASTER_Ok );
}
/*---------------------------------------------------------------------
Function: BLASTER_GetCurrentPos
Returns the offset within the current sound being played.
---------------------------------------------------------------------*/
int BLASTER_GetCurrentPos
(
void
)
{
char *CurrentAddr;
int DmaChannel;
int offset;
if ( !BLASTER_SoundPlaying )
{
BLASTER_SetErrorCode( BLASTER_NoSoundPlaying );
return( BLASTER_Error );
}
if ( BLASTER_MixMode & SIXTEEN_BIT )
{
DmaChannel = BLASTER_Config.Dma16;
}
else
{
DmaChannel = BLASTER_Config.Dma8;
}
if ( DmaChannel == UNDEFINED )
{
BLASTER_SetErrorCode( BLASTER_DMANotSet );
return( BLASTER_Error );
}
CurrentAddr = DMA_GetCurrentPos( DmaChannel );
offset = ( int )( ( ( unsigned long )CurrentAddr ) -
( ( unsigned long )BLASTER_CurrentDMABuffer ) );
if ( BLASTER_MixMode & SIXTEEN_BIT )
{
offset >>= 1;
}
if ( BLASTER_MixMode & STEREO )
{
offset >>= 1;
}
return( offset );
}
/*---------------------------------------------------------------------
Function: BLASTER_DSP1xx_BeginPlayback
Starts playback of digitized sound on cards compatible with DSP
version 1.xx.
---------------------------------------------------------------------*/
int BLASTER_DSP1xx_BeginPlayback
(
int length
)
{
int SampleLength;
int LoByte;
int HiByte;
SampleLength = length - 1;
HiByte = hibyte( SampleLength );
LoByte = lobyte( SampleLength );
// Program DSP to play sound
BLASTER_WriteDSP( DSP_Old8BitDAC );
BLASTER_WriteDSP( LoByte );
BLASTER_WriteDSP( HiByte );
BLASTER_HaltTransferCommand = DSP_Halt8bitTransfer;
BLASTER_SoundPlaying = TRUE;
return( BLASTER_Ok );
}
/*---------------------------------------------------------------------
Function: BLASTER_DSP2xx_BeginPlayback
Starts playback of digitized sound on cards compatible with DSP
version 2.xx.
---------------------------------------------------------------------*/
int BLASTER_DSP2xx_BeginPlayback
(
int length
)
{
int SampleLength;
int LoByte;
int HiByte;
SampleLength = length - 1;
HiByte = hibyte( SampleLength );
LoByte = lobyte( SampleLength );
BLASTER_WriteDSP( DSP_SetBlockLength );
BLASTER_WriteDSP( LoByte );
BLASTER_WriteDSP( HiByte );
if ( ( BLASTER_Version >= DSP_Version201 ) && ( DSP_MaxNormalRate <
( BLASTER_SampleRate * BLASTER_SamplePacketSize ) ) )
{
BLASTER_WriteDSP( DSP_8BitHighSpeedAutoInitMode );
BLASTER_HaltTransferCommand = DSP_Reset;
}
else
{
BLASTER_WriteDSP( DSP_8BitAutoInitMode );
BLASTER_HaltTransferCommand = DSP_Halt8bitTransfer;
}
BLASTER_SoundPlaying = TRUE;
return( BLASTER_Ok );
}
/*---------------------------------------------------------------------
Function: BLASTER_DSP4xx_BeginPlayback
Starts playback of digitized sound on cards compatible with DSP
version 4.xx, such as the Sound Blaster 16.
---------------------------------------------------------------------*/
int BLASTER_DSP4xx_BeginPlayback
(
int length
)
{
int TransferCommand;
int TransferMode;
int SampleLength;
int LoByte;
int HiByte;
if ( BLASTER_MixMode & SIXTEEN_BIT )
{
TransferCommand = DSP_16BitDAC;
SampleLength = ( length / 2 ) - 1;
BLASTER_HaltTransferCommand = DSP_Halt16bitTransfer;
if ( BLASTER_MixMode & STEREO )
{
TransferMode = DSP_SignedStereoData;
}
else
{
TransferMode = DSP_SignedMonoData;
}
}
else
{
TransferCommand = DSP_8BitDAC;
SampleLength = length - 1;
BLASTER_HaltTransferCommand = DSP_Halt8bitTransfer;
if ( BLASTER_MixMode & STEREO )
{
TransferMode = DSP_UnsignedStereoData;
}
else
{
TransferMode = DSP_UnsignedMonoData;
}
}
HiByte = hibyte( SampleLength );
LoByte = lobyte( SampleLength );
// Program DSP to play sound
BLASTER_WriteDSP( TransferCommand );
BLASTER_WriteDSP( TransferMode );
BLASTER_WriteDSP( LoByte );
BLASTER_WriteDSP( HiByte );
BLASTER_SoundPlaying = TRUE;
return( BLASTER_Ok );
}
/*---------------------------------------------------------------------
Function: BLASTER_BeginBufferedPlayback
Begins multibuffered playback of digitized sound on the sound card.
---------------------------------------------------------------------*/
int BLASTER_BeginBufferedPlayback
(
char *BufferStart,
int BufferSize,
int NumDivisions,
unsigned SampleRate,
int MixMode,
void ( *CallBackFunc )( void )
)
{
int DmaStatus;
int TransferLength;
//JIM
// if ( BLASTER_SoundPlaying || BLASTER_SoundRecording )
{
BLASTER_StopPlayback();
}
BLASTER_SetMixMode( MixMode );
DmaStatus = BLASTER_SetupDMABuffer( BufferStart, BufferSize, DMA_AutoInitRead );
if ( DmaStatus == BLASTER_Error )
{
return( BLASTER_Error );
}
BLASTER_SetPlaybackRate( SampleRate );
BLASTER_SetCallBack( CallBackFunc );
BLASTER_EnableInterrupt();
// Turn on speaker
BLASTER_SpeakerOn();
TransferLength = BufferSize / NumDivisions;
BLASTER_TransferLength = TransferLength;
// Program the sound card to start the transfer.
if ( BLASTER_Version < DSP_Version2xx )
{
BLASTER_DSP1xx_BeginPlayback( TransferLength );
}
else if ( BLASTER_Version < DSP_Version4xx )
{
BLASTER_DSP2xx_BeginPlayback( TransferLength );
}
else
{
BLASTER_DSP4xx_BeginPlayback( TransferLength );
}
return( BLASTER_Ok );
}
/*---------------------------------------------------------------------
Function: BLASTER_DSP4xx_BeginRecord
Starts recording of digitized sound on cards compatible with DSP
version 4.xx, such as the Sound Blaster 16.
---------------------------------------------------------------------*/
int BLASTER_DSP4xx_BeginRecord
(
int length
)
{
int TransferCommand;
int TransferMode;
int SampleLength;
int LoByte;
int HiByte;
TransferCommand = DSP_8BitADC;
SampleLength = length - 1;
BLASTER_HaltTransferCommand = DSP_Halt8bitTransfer;
TransferMode = DSP_UnsignedMonoData;
HiByte = hibyte( SampleLength );
LoByte = lobyte( SampleLength );
// Program DSP to play sound
BLASTER_WriteDSP( TransferCommand );
BLASTER_WriteDSP( TransferMode );
BLASTER_WriteDSP( LoByte );
BLASTER_WriteDSP( HiByte );
BLASTER_SoundRecording = TRUE;
return( BLASTER_Ok );
}
/*---------------------------------------------------------------------
Function: BLASTER_DSP2xx_BeginRecord
Starts recording of digitized sound on cards compatible with DSP
version 2.xx.
---------------------------------------------------------------------*/
int BLASTER_DSP2xx_BeginRecord
(
int length
)
{
int SampleLength;
int LoByte;
int HiByte;
SampleLength = length - 1;
HiByte = hibyte( SampleLength );
LoByte = lobyte( SampleLength );
BLASTER_WriteDSP( DSP_SetBlockLength );
BLASTER_WriteDSP( LoByte );
BLASTER_WriteDSP( HiByte );
if ( ( BLASTER_Version >= DSP_Version201 ) && ( DSP_MaxNormalRate <
( BLASTER_SampleRate * BLASTER_SamplePacketSize ) ) )
{
BLASTER_WriteDSP( DSP_8BitHighSpeedAutoInitRecord );
BLASTER_HaltTransferCommand = DSP_Reset;
}
else
{
BLASTER_WriteDSP( DSP_8BitAutoInitRecord );
BLASTER_HaltTransferCommand = DSP_Halt8bitTransfer;
}
BLASTER_SoundRecording = TRUE;
return( BLASTER_Ok );
}
/*---------------------------------------------------------------------
Function: BLASTER_DSP1xx_BeginRecord
Starts recording of digitized sound on cards compatible with DSP
version 1.xx.
---------------------------------------------------------------------*/
int BLASTER_DSP1xx_BeginRecord
(
int length
)
{
int SampleLength;
int LoByte;
int HiByte;
SampleLength = length - 1;
HiByte = hibyte( SampleLength );
LoByte = lobyte( SampleLength );
// Program DSP to play sound
BLASTER_WriteDSP( DSP_Old8BitADC );
BLASTER_WriteDSP( LoByte );
BLASTER_WriteDSP( HiByte );
BLASTER_HaltTransferCommand = DSP_Halt8bitTransfer;
BLASTER_SoundRecording = TRUE;
return( BLASTER_Ok );
}
/*---------------------------------------------------------------------
Function: BLASTER_BeginBufferedRecord
Begins multibuffered recording of digitized sound on the sound card.
---------------------------------------------------------------------*/
int BLASTER_BeginBufferedRecord
(
char *BufferStart,
int BufferSize,
int NumDivisions,
unsigned SampleRate,
int MixMode,
void ( *CallBackFunc )( void )
)
{
int DmaStatus;
int TransferLength;
//JIM
// if ( BLASTER_SoundPlaying || BLASTER_SoundRecording )
{
BLASTER_StopPlayback();
}
BLASTER_SetMixMode( MixMode );
DmaStatus = BLASTER_SetupDMABuffer( BufferStart, BufferSize, DMA_AutoInitWrite );
if ( DmaStatus == BLASTER_Error )
{
return( BLASTER_Error );
}
BLASTER_SetPlaybackRate( SampleRate );
BLASTER_SetCallBack( CallBackFunc );
BLASTER_EnableInterrupt();
// Turn off speaker
BLASTER_SpeakerOff();
TransferLength = BufferSize / NumDivisions;
BLASTER_TransferLength = TransferLength;
// Program the sound card to start the transfer.
if ( BLASTER_Version < DSP_Version2xx )
{
BLASTER_DSP1xx_BeginRecord( TransferLength );
}
else if ( BLASTER_Version < DSP_Version4xx )
{
BLASTER_DSP2xx_BeginRecord( TransferLength );
}
else
{
BLASTER_DSP4xx_BeginRecord( TransferLength );
}
return( BLASTER_Ok );
}
/*---------------------------------------------------------------------
Function: BLASTER_WriteMixer
Writes a byte of data to the Sound Blaster's mixer chip.
---------------------------------------------------------------------*/
void BLASTER_WriteMixer
(
int reg,
int data
)
{
outp( BLASTER_MixerAddress + BLASTER_MixerAddressPort, reg );
outp( BLASTER_MixerAddress + BLASTER_MixerDataPort, data );
}
/*---------------------------------------------------------------------
Function: BLASTER_ReadMixer
Reads a byte of data from the Sound Blaster's mixer chip.
---------------------------------------------------------------------*/
int BLASTER_ReadMixer
(
int reg
)
{
int data;
outp( BLASTER_MixerAddress + BLASTER_MixerAddressPort, reg );
data = inp( BLASTER_MixerAddress + BLASTER_MixerDataPort );
return( data );
}
/*---------------------------------------------------------------------
Function: BLASTER_GetVoiceVolume
Reads the average volume of the digitized sound channel from the
Sound Blaster's mixer chip.
---------------------------------------------------------------------*/
int BLASTER_GetVoiceVolume
(
void
)
{
int volume;
int left;
int right;
switch( BLASTER_MixerType )
{
case SBPro :
case SBPro2 :
left = BLASTER_ReadMixer( MIXER_SBProVoice );
right = ( left & 0x0f ) << 4;
left &= 0xf0;
volume = ( left + right ) / 2;
break;
case SB16 :
left = BLASTER_ReadMixer( MIXER_SB16VoiceLeft );
right = BLASTER_ReadMixer( MIXER_SB16VoiceRight );
volume = ( left + right ) / 2;
break;
default :
BLASTER_SetErrorCode( BLASTER_NoMixer );
volume = BLASTER_Error;
}
return( volume );
}
/*---------------------------------------------------------------------
Function: BLASTER_SetVoiceVolume
Sets the volume of the digitized sound channel on the Sound
Blaster's mixer chip.
---------------------------------------------------------------------*/
int BLASTER_SetVoiceVolume
(
int volume
)
{
int data;
int status;
volume = min( 255, volume );
volume = max( 0, volume );
status = BLASTER_Ok;
switch( BLASTER_MixerType )
{
case SBPro :
case SBPro2 :
data = ( volume & 0xf0 ) + ( volume >> 4 );
BLASTER_WriteMixer( MIXER_SBProVoice, data );
break;
case SB16 :
BLASTER_WriteMixer( MIXER_SB16VoiceLeft, volume & 0xf8 );
BLASTER_WriteMixer( MIXER_SB16VoiceRight, volume & 0xf8 );
break;
default :
BLASTER_SetErrorCode( BLASTER_NoMixer );
status = BLASTER_Error;
}
return( status );
}
/*---------------------------------------------------------------------
Function: BLASTER_GetMidiVolume
Reads the average volume of the Midi sound channel from the
Sound Blaster's mixer chip.
---------------------------------------------------------------------*/
int BLASTER_GetMidiVolume
(
void
)
{
int volume;
int left;
int right;
switch( BLASTER_MixerType )
{
case SBPro :
case SBPro2 :
left = BLASTER_ReadMixer( MIXER_SBProMidi );
right = ( left & 0x0f ) << 4;
left &= 0xf0;
volume = ( left + right ) / 2;
break;
case SB16 :
left = BLASTER_ReadMixer( MIXER_SB16MidiLeft );
right = BLASTER_ReadMixer( MIXER_SB16MidiRight );
volume = ( left + right ) / 2;
break;
default :
BLASTER_SetErrorCode( BLASTER_NoMixer );
volume = BLASTER_Error;
}
return( volume );
}
/*---------------------------------------------------------------------
Function: BLASTER_SetMidiVolume
Sets the volume of the Midi sound channel on the Sound
Blaster's mixer chip.
---------------------------------------------------------------------*/
int BLASTER_SetMidiVolume
(
int volume
)
{
int data;
int status;
volume = min( 255, volume );
volume = max( 0, volume );
status = BLASTER_Ok;
switch( BLASTER_MixerType )
{
case SBPro :
case SBPro2 :
data = ( volume & 0xf0 ) + ( volume >> 4 );
BLASTER_WriteMixer( MIXER_SBProMidi, data );
break;
case SB16 :
BLASTER_WriteMixer( MIXER_SB16MidiLeft, volume & 0xf8 );
BLASTER_WriteMixer( MIXER_SB16MidiRight, volume & 0xf8 );
break;
default :
BLASTER_SetErrorCode( BLASTER_NoMixer );
status = BLASTER_Error;
}
return( status );
}
/*---------------------------------------------------------------------
Function: BLASTER_CardHasMixer
Checks if the selected Sound Blaster card has a mixer.
---------------------------------------------------------------------*/
int BLASTER_CardHasMixer
(
void
)
{
BLASTER_CONFIG Blaster;
int status;
if ( BLASTER_MixerAddress == UNDEFINED )
{
status = BLASTER_GetEnv( &Blaster );
if ( status == BLASTER_Ok )
{
BLASTER_MixerAddress = Blaster.Address;
BLASTER_MixerType = 0;
if ( ( Blaster.Type < BLASTER_MinCardType ) ||
( Blaster.Type > BLASTER_MaxCardType ) )
{
BLASTER_MixerType = Blaster.Type;
}
}
}
if ( BLASTER_MixerAddress != UNDEFINED )
{
return( BLASTER_CardConfig[ BLASTER_MixerType ].HasMixer );
}
return( FALSE );
}
/*---------------------------------------------------------------------
Function: BLASTER_SaveVoiceVolume
Saves the user's voice mixer settings.
---------------------------------------------------------------------*/
void BLASTER_SaveVoiceVolume
(
void
)
{
if ( BLASTER_CardHasMixer() )
{
switch( BLASTER_MixerType )
{
case SBPro :
case SBPro2 :
BLASTER_OriginalVoiceVolumeLeft =
BLASTER_ReadMixer( MIXER_SBProVoice );
break;
case SB16 :
BLASTER_OriginalVoiceVolumeLeft =
BLASTER_ReadMixer( MIXER_SB16VoiceLeft );
BLASTER_OriginalVoiceVolumeRight =
BLASTER_ReadMixer( MIXER_SB16VoiceRight );
break;
}
}
}
/*---------------------------------------------------------------------
Function: BLASTER_RestoreVoiceVolume
Restores the user's voice mixer settings.
---------------------------------------------------------------------*/
void BLASTER_RestoreVoiceVolume
(
void
)
{
if ( BLASTER_CardHasMixer() )
{
switch( BLASTER_MixerType )
{
case SBPro :
case SBPro2 :
BLASTER_WriteMixer( MIXER_SBProVoice,
BLASTER_OriginalVoiceVolumeLeft );
break;
case SB16 :
BLASTER_WriteMixer( MIXER_SB16VoiceLeft,
BLASTER_OriginalVoiceVolumeLeft );
BLASTER_WriteMixer( MIXER_SB16VoiceRight,
BLASTER_OriginalVoiceVolumeRight );
break;
}
}
}
/*---------------------------------------------------------------------
Function: BLASTER_SaveMidiVolume
Saves the user's FM mixer settings.
---------------------------------------------------------------------*/
void BLASTER_SaveMidiVolume
(
void
)
{
if ( BLASTER_CardHasMixer() )
{
switch( BLASTER_MixerType )
{
case SBPro :
case SBPro2 :
BLASTER_OriginalMidiVolumeLeft =
BLASTER_ReadMixer( MIXER_SBProMidi );
break;
case SB16 :
BLASTER_OriginalMidiVolumeLeft =
BLASTER_ReadMixer( MIXER_SB16MidiLeft );
BLASTER_OriginalMidiVolumeRight =
BLASTER_ReadMixer( MIXER_SB16MidiRight );
break;
}
}
}
/*---------------------------------------------------------------------
Function: BLASTER_RestoreMidiVolume
Restores the user's FM mixer settings.
---------------------------------------------------------------------*/
void BLASTER_RestoreMidiVolume
(
void
)
{
if ( BLASTER_CardHasMixer() )
{
switch( BLASTER_MixerType )
{
case SBPro :
case SBPro2 :
BLASTER_WriteMixer( MIXER_SBProMidi,
BLASTER_OriginalMidiVolumeLeft );
break;
case SB16 :
BLASTER_WriteMixer( MIXER_SB16MidiLeft,
BLASTER_OriginalMidiVolumeLeft );
BLASTER_WriteMixer( MIXER_SB16MidiRight,
BLASTER_OriginalMidiVolumeRight );
break;
}
}
}
/*---------------------------------------------------------------------
Function: BLASTER_GetEnv
Retrieves the BLASTER environment settings and returns them to
the caller.
---------------------------------------------------------------------*/
int BLASTER_GetEnv
(
BLASTER_CONFIG *Config
)
{
char *Blaster;
char parameter;
int status;
int errorcode;
Config->Address = UNDEFINED;
Config->Type = UNDEFINED;
Config->Interrupt = UNDEFINED;
Config->Dma8 = UNDEFINED;
Config->Dma16 = UNDEFINED;
Config->Midi = UNDEFINED;
Config->Emu = UNDEFINED;
Blaster = getenv( "BLASTER" );
if ( Blaster == NULL )
{
BLASTER_SetErrorCode( BLASTER_EnvNotFound );
return( BLASTER_Error );
}
while( *Blaster != 0 )
{
if ( *Blaster == ' ' )
{
Blaster++;
continue;
}
parameter = toupper( *Blaster );
Blaster++;
if ( !isxdigit( *Blaster ) )
{
BLASTER_SetErrorCode( BLASTER_InvalidParameter );
return( BLASTER_Error );
}
switch( parameter )
{
case BlasterEnv_Address :
sscanf( Blaster, "%x", &Config->Address );
break;
case BlasterEnv_Interrupt :
sscanf( Blaster, "%d", &Config->Interrupt );
break;
case BlasterEnv_8bitDma :
sscanf( Blaster, "%d", &Config->Dma8 );
break;
case BlasterEnv_Type :
sscanf( Blaster, "%d", &Config->Type );
break;
case BlasterEnv_16bitDma :
sscanf( Blaster, "%d", &Config->Dma16 );
break;
case BlasterEnv_Midi :
sscanf( Blaster, "%x", &Config->Midi );
break;
case BlasterEnv_EmuAddress :
sscanf( Blaster, "%x", &Config->Emu );
break;
default :
// Skip the offending data
// sscanf( Blaster, "%*s" );
break;
}
while( isxdigit( *Blaster ) )
{
Blaster++;
}
}
status = BLASTER_Ok;
errorcode = BLASTER_Ok;
if ( Config->Type == UNDEFINED )
{
errorcode = BLASTER_CardTypeNotSet;
}
else if ( ( Config->Type < BLASTER_MinCardType ) ||
( Config->Type > BLASTER_MaxCardType ) ||
( !BLASTER_CardConfig[ Config->Type ].IsSupported ) )
{
errorcode = BLASTER_UnsupportedCardType;
}
if ( Config->Dma8 == UNDEFINED )
{
errorcode = BLASTER_DMANotSet;
}
if ( Config->Interrupt == UNDEFINED )
{
errorcode = BLASTER_IntNotSet;
}
if ( Config->Address == UNDEFINED )
{
errorcode = BLASTER_AddrNotSet;
}
if ( errorcode != BLASTER_Ok )
{
status = BLASTER_Error;
BLASTER_SetErrorCode( errorcode );
}
return( status );
}
/*---------------------------------------------------------------------
Function: BLASTER_SetCardSettings
Sets up the sound card's parameters.
---------------------------------------------------------------------*/
int BLASTER_SetCardSettings
(
BLASTER_CONFIG Config
)
{
if ( BLASTER_Installed )
{
BLASTER_Shutdown();
}
if ( ( Config.Type < BLASTER_MinCardType ) ||
( Config.Type > BLASTER_MaxCardType ) ||
( !BLASTER_CardConfig[ Config.Type ].IsSupported ) )
{
BLASTER_SetErrorCode( BLASTER_UnsupportedCardType );
return( BLASTER_Error );
}
BLASTER_Config.Address = Config.Address;
BLASTER_Config.Type = Config.Type;
BLASTER_Config.Interrupt = Config.Interrupt;
BLASTER_Config.Dma8 = Config.Dma8;
BLASTER_Config.Dma16 = Config.Dma16;
BLASTER_Config.Midi = Config.Midi;
BLASTER_Config.Emu = Config.Emu;
BLASTER_MixerAddress = Config.Address;
BLASTER_MixerType = 0;
BLASTER_MixerType = Config.Type;
return( BLASTER_Ok );
}
/*---------------------------------------------------------------------
Function: BLASTER_GetCardSettings
Sets up the sound card's parameters.
---------------------------------------------------------------------*/
int BLASTER_GetCardSettings
(
BLASTER_CONFIG *Config
)
{
if ( BLASTER_Config.Address == UNDEFINED )
{
return( BLASTER_Warning );
}
else
{
Config->Address = BLASTER_Config.Address;
Config->Type = BLASTER_Config.Type;
Config->Interrupt = BLASTER_Config.Interrupt;
Config->Dma8 = BLASTER_Config.Dma8;
Config->Dma16 = BLASTER_Config.Dma16;
Config->Midi = BLASTER_Config.Midi;
Config->Emu = BLASTER_Config.Emu;
}
return( BLASTER_Ok );
}
/*---------------------------------------------------------------------
Function: BLASTER_GetCardInfo
Returns the maximum number of bits that can represent a sample
(8 or 16) and the number of channels (1 for mono, 2 for stereo).
---------------------------------------------------------------------*/
int BLASTER_GetCardInfo
(
int *MaxSampleBits,
int *MaxChannels
)
{
int CardType;
CardType = BLASTER_Config.Type;
if ( CardType == UNDEFINED )
{
BLASTER_SetErrorCode( BLASTER_CardTypeNotSet );
return( BLASTER_Error );
}
if ( BLASTER_CardConfig[ CardType ].MaxMixMode & STEREO )
{
*MaxChannels = 2;
}
else
{
*MaxChannels = 1;
}
if ( BLASTER_CardConfig[ CardType ].MaxMixMode & SIXTEEN_BIT )
{
*MaxSampleBits = 16;
}
else
{
*MaxSampleBits = 8;
}
return( BLASTER_Ok );
}
/*---------------------------------------------------------------------
Function: BLASTER_SetCallBack
Specifies the user function to call at the end of a sound transfer.
---------------------------------------------------------------------*/
void BLASTER_SetCallBack
(
void ( *func )( void )
)
{
BLASTER_CallBack = func;
}
/*---------------------------------------------------------------------
Function: BLASTER_LockEnd
Used for determining the length of the functions to lock in memory.
---------------------------------------------------------------------*/
static void BLASTER_LockEnd
(
void
)
{
}
/*---------------------------------------------------------------------
Function: BLASTER_UnlockMemory
Unlocks all neccessary data.
---------------------------------------------------------------------*/
void BLASTER_UnlockMemory
(
void
)
{
DPMI_UnlockMemoryRegion( BLASTER_LockStart, BLASTER_LockEnd );
DPMI_Unlock( BLASTER_Interrupts );
DPMI_Unlock( BLASTER_SampleSize );
DPMI_Unlock( BLASTER_CardConfig );
DPMI_Unlock( BLASTER_OldInt );
DPMI_Unlock( BLASTER_Config );
DPMI_Unlock( BLASTER_Installed );
DPMI_Unlock( BLASTER_Version );
DPMI_Unlock( BLASTER_DMABuffer );
DPMI_Unlock( BLASTER_DMABufferEnd );
DPMI_Unlock( BLASTER_CurrentDMABuffer );
DPMI_Unlock( BLASTER_TotalDMABufferSize );
DPMI_Unlock( BLASTER_TransferLength );
DPMI_Unlock( BLASTER_MixMode );
DPMI_Unlock( BLASTER_SamplePacketSize );
DPMI_Unlock( BLASTER_SampleRate );
DPMI_Unlock( BLASTER_HaltTransferCommand );
DPMI_Unlock( BLASTER_SoundPlaying );
DPMI_Unlock( BLASTER_SoundRecording );
DPMI_Unlock( BLASTER_CallBack );
DPMI_Unlock( BLASTER_IntController1Mask );
DPMI_Unlock( BLASTER_IntController2Mask );
DPMI_Unlock( BLASTER_MixerAddress );
DPMI_Unlock( BLASTER_MixerType );
DPMI_Unlock( BLASTER_OriginalMidiVolumeLeft );
DPMI_Unlock( BLASTER_OriginalMidiVolumeRight );
DPMI_Unlock( BLASTER_OriginalVoiceVolumeLeft );
DPMI_Unlock( BLASTER_OriginalVoiceVolumeRight );
DPMI_Unlock( GlobalStatus );
}
/*---------------------------------------------------------------------
Function: BLASTER_LockMemory
Locks all neccessary data.
---------------------------------------------------------------------*/
int BLASTER_LockMemory
(
void
)
{
int status;
status = DPMI_LockMemoryRegion( BLASTER_LockStart, BLASTER_LockEnd );
status |= DPMI_Lock( BLASTER_Interrupts );
status |= DPMI_Lock( BLASTER_SampleSize );
status |= DPMI_Lock( BLASTER_CardConfig );
status |= DPMI_Lock( BLASTER_OldInt );
status |= DPMI_Lock( BLASTER_Config );
status |= DPMI_Lock( BLASTER_Installed );
status |= DPMI_Lock( BLASTER_Version );
status |= DPMI_Lock( BLASTER_DMABuffer );
status |= DPMI_Lock( BLASTER_DMABufferEnd );
status |= DPMI_Lock( BLASTER_CurrentDMABuffer );
status |= DPMI_Lock( BLASTER_TotalDMABufferSize );
status |= DPMI_Lock( BLASTER_TransferLength );
status |= DPMI_Lock( BLASTER_MixMode );
status |= DPMI_Lock( BLASTER_SamplePacketSize );
status |= DPMI_Lock( BLASTER_SampleRate );
status |= DPMI_Lock( BLASTER_HaltTransferCommand );
status |= DPMI_Lock( BLASTER_SoundPlaying );
status |= DPMI_Lock( BLASTER_SoundRecording );
status |= DPMI_Lock( BLASTER_CallBack );
status |= DPMI_Lock( BLASTER_IntController1Mask );
status |= DPMI_Lock( BLASTER_IntController2Mask );
status |= DPMI_Lock( BLASTER_MixerAddress );
status |= DPMI_Lock( BLASTER_MixerType );
status |= DPMI_Lock( BLASTER_OriginalMidiVolumeLeft );
status |= DPMI_Lock( BLASTER_OriginalMidiVolumeRight );
status |= DPMI_Lock( BLASTER_OriginalVoiceVolumeLeft );
status |= DPMI_Lock( BLASTER_OriginalVoiceVolumeRight );
status |= DPMI_Lock( GlobalStatus );
if ( status != DPMI_Ok )
{
BLASTER_UnlockMemory();
BLASTER_SetErrorCode( BLASTER_DPMI_Error );
return( BLASTER_Error );
}
return( BLASTER_Ok );
}
/*---------------------------------------------------------------------
Function: allocateTimerStack
Allocate a block of memory from conventional (low) memory and return
the selector (which can go directly into a segment register) of the
memory block or 0 if an error occured.
---------------------------------------------------------------------*/
static unsigned short allocateTimerStack
(
unsigned short size
)
{
union REGS regs;
// clear all registers
memset( &regs, 0, sizeof( regs ) );
// DPMI allocate conventional memory
regs.w.ax = 0x100;
// size in paragraphs
regs.w.bx = ( size + 15 ) / 16;
int386( 0x31, &regs, &regs );
if (!regs.w.cflag)
{
// DPMI call returns selector in dx
// (ax contains real mode segment
// which is ignored here)
return( regs.w.dx );
}
// Couldn't allocate memory.
return( NULL );
}
/*---------------------------------------------------------------------
Function: deallocateTimerStack
Deallocate a block of conventional (low) memory given a selector to
it. Assumes the block was allocated with DPMI function 0x100.
---------------------------------------------------------------------*/
static void deallocateTimerStack
(
unsigned short selector
)
{
union REGS regs;
if ( selector != NULL )
{
// clear all registers
memset( &regs, 0, sizeof( regs ) );
regs.w.ax = 0x101;
regs.w.dx = selector;
int386( 0x31, &regs, &regs );
}
}
/*---------------------------------------------------------------------
Function: BLASTER_SetupWaveBlaster
Allows the WaveBlaster to play music while the Sound Blaster 16
plays digital sound.
---------------------------------------------------------------------*/
int BLASTER_SetupWaveBlaster
(
int address
)
{
BLASTER_CONFIG Blaster;
int status;
if ( address != UNDEFINED )
{
BLASTER_WaveBlasterPort = address;
}
else
{
if ( BLASTER_Config.Midi == UNDEFINED )
{
status = BLASTER_GetEnv( &Blaster );
if ( status == BLASTER_Ok )
{
if ( Blaster.Midi == UNDEFINED )
{
BLASTER_SetErrorCode( BLASTER_MIDINotSet );
return( BLASTER_Error );
}
BLASTER_WaveBlasterPort = Blaster.Midi;
}
else
{
return( status );
}
}
}
if ( BLASTER_CardHasMixer() )
{
// Disable MPU401 interrupts. If they are not disabled,
// the SB16 will not produce sound or music.
BLASTER_WaveBlasterState = BLASTER_ReadMixer( MIXER_DSP4xxISR_Enable );
BLASTER_WriteMixer( MIXER_DSP4xxISR_Enable, MIXER_DisableMPU401Interrupts );
}
return( BLASTER_WaveBlasterPort );
}
/*---------------------------------------------------------------------
Function: BLASTER_ShutdownWaveBlaster
Restores WaveBlaster mixer to original state.
---------------------------------------------------------------------*/
void BLASTER_ShutdownWaveBlaster
(
void
)
{
if ( BLASTER_CardHasMixer() )
{
// Restore the state of MPU401 interrupts. If they are not disabled,
// the SB16 will not produce sound or music.
BLASTER_WriteMixer( MIXER_DSP4xxISR_Enable, BLASTER_WaveBlasterState );
}
}
/*---------------------------------------------------------------------
Function: BLASTER_Init
Initializes the sound card and prepares the module to play
digitized sounds.
---------------------------------------------------------------------*/
int BLASTER_Init
(
void
)
{
int Irq;
int Interrupt;
int status;
if ( BLASTER_Installed )
{
BLASTER_Shutdown();
}
// Save the interrupt masks
BLASTER_IntController1Mask = inp( 0x21 );
BLASTER_IntController2Mask = inp( 0xA1 );
status = BLASTER_ResetDSP();
if ( status == BLASTER_Ok )
{
BLASTER_SaveVoiceVolume();
BLASTER_SoundPlaying = FALSE;
BLASTER_SetCallBack( NULL );
BLASTER_DMABuffer = NULL;
BLASTER_Version = BLASTER_GetDSPVersion();
BLASTER_SetPlaybackRate( BLASTER_DefaultSampleRate );
BLASTER_SetMixMode( BLASTER_DefaultMixMode );
if ( BLASTER_Config.Dma16 != UNDEFINED )
{
status = DMA_VerifyChannel( BLASTER_Config.Dma16 );
if ( status == DMA_Error )
{
BLASTER_SetErrorCode( BLASTER_DmaError );
return( BLASTER_Error );
}
}
if ( BLASTER_Config.Dma8 != UNDEFINED )
{
status = DMA_VerifyChannel( BLASTER_Config.Dma8 );
if ( status == DMA_Error )
{
BLASTER_SetErrorCode( BLASTER_DmaError );
return( BLASTER_Error );
}
}
// Install our interrupt handler
Irq = BLASTER_Config.Interrupt;
if ( !VALID_IRQ( Irq ) )
{
BLASTER_SetErrorCode( BLASTER_InvalidIrq );
return( BLASTER_Error );
}
Interrupt = BLASTER_Interrupts[ Irq ];
if ( Interrupt == INVALID )
{
BLASTER_SetErrorCode( BLASTER_InvalidIrq );
return( BLASTER_Error );
}
status = BLASTER_LockMemory();
if ( status != BLASTER_Ok )
{
BLASTER_UnlockMemory();
return( status );
}
StackSelector = allocateTimerStack( kStackSize );
if ( StackSelector == NULL )
{
BLASTER_UnlockMemory();
BLASTER_SetErrorCode( BLASTER_OutOfMemory );
return( BLASTER_Error );
}
// Leave a little room at top of stack just for the hell of it...
StackPointer = kStackSize - sizeof( long );
BLASTER_OldInt = _dos_getvect( Interrupt );
if ( Irq < 8 )
{
_dos_setvect( Interrupt, BLASTER_ServiceInterrupt );
}
else
{
status = IRQ_SetVector( Interrupt, BLASTER_ServiceInterrupt );
if ( status != IRQ_Ok )
{
BLASTER_UnlockMemory();
deallocateTimerStack( StackSelector );
StackSelector = NULL;
BLASTER_SetErrorCode( BLASTER_UnableToSetIrq );
return( BLASTER_Error );
}
}
BLASTER_Installed = TRUE;
status = BLASTER_Ok;
}
BLASTER_SetErrorCode( status );
return( status );
}
/*---------------------------------------------------------------------
Function: BLASTER_Shutdown
Ends transfer of sound data to the sound card and restores the
system resources used by the card.
---------------------------------------------------------------------*/
void BLASTER_Shutdown
(
void
)
{
int Irq;
int Interrupt;
// Halt the DMA transfer
BLASTER_StopPlayback();
BLASTER_RestoreVoiceVolume();
// Reset the DSP
BLASTER_ResetDSP();
// Restore the original interrupt
Irq = BLASTER_Config.Interrupt;
Interrupt = BLASTER_Interrupts[ Irq ];
if ( Irq >= 8 )
{
IRQ_RestoreVector( Interrupt );
}
_dos_setvect( Interrupt, BLASTER_OldInt );
BLASTER_SoundPlaying = FALSE;
BLASTER_DMABuffer = NULL;
BLASTER_SetCallBack( NULL );
BLASTER_UnlockMemory();
deallocateTimerStack( StackSelector );
StackSelector = NULL;
BLASTER_Installed = FALSE;
}
Reference in a new issue View git blame Copy permalink