/*
* Initialize the audio hardware.
*/
int sfxInit(char *audioDir, int numPorts) {
int idx;
char *str;
if (audioDir != NULL) {
str = strdup(audioDir);
if (str)
sfxAudioDir = str;
}
if (numPorts < 1)
return SFX_ERR_NO_PORTS_AVAIL;
if (numPorts > MAX_AUDIO_PORTS)
numPorts = MAX_AUDIO_PORTS;
(void) ALseterrorhandler(sfxSoundErrFunc);
nAudioPorts = sfxOpenAudioPorts(audioPort, numPorts);
if (nAudioPorts == 0)
return SFX_ERR_NO_PORTS_AVAIL;
if (nAudioPorts < 0)
return SFX_ERR_NO_AUDIO_HW;
(void) signal(SIGCHLD, sfxSoundDied);
if (pipe(spigot) < 0 || (soundChild = sproc(sfxSoundHandler, PR_SADDR, audioPort)) < 0) {
for (idx=0; idx < nAudioPorts; idx++)
ALcloseport(audioPort[idx]);
return SFX_ERR_NO_SPROC;
}
return nAudioPorts;
}
int sound_init()
{
long pvbuf[2];
pvbuf[0] = AL_OUTPUT_COUNT;
pvbuf[2] = AL_MONITOR_CTL;
if (ALgetparams(AL_DEFAULT_DEVICE, pvbuf, 4) < 0)
{
fprintf(stderr,"sound driver : No audio hardware\n");
return 0;
}
pvbuf[0] = AL_OUTPUT_RATE;
pvbuf[1] = 11025;
if (ALsetparams(AL_DEFAULT_DEVICE,pvbuf,4) < 0)
{
fprintf(stderr,"sound driver : Could not set sample rate\n");
return 0;
}
ALseterrorhandler(0);
audioconfig = ALnewconfig();
if (!audioconfig)
{
fprintf(stderr,"failed to create audio config\n");
return 0;
}
else if (ALsetchannels(audioconfig,AL_MONO))
{ fprintf(stderr,"sound driver : could not set audio channels\n");
return 0;
}
else if (ALsetqueuesize(audioconfig,BUF_SIZE))
{
fprintf(stderr,"sound driver : could not set audio que size\n");
ALfreeconfig(audioconfig);
return 0;
} else if (ALsetwidth (audioconfig, AL_SAMPLE_8))
{
fprintf(stderr,"sound driver :could not set 8 bit samples\n");
ALfreeconfig(audioconfig);
return 0;
}
audioport=ALopenport("Abuse sound driver","w",audioconfig);
if (!audioport)
{
fprintf(stderr,"sound driver : could not open audio port\n");
ALfreeconfig(audioconfig);
return 0;
}
int i=0,j;
uchar *vd=volume_table;
for (;i<32;i++)
{
for (j=0;j<256;j++,vd++)
*vd=(j-128)*i/31+128;
}
return 1;
}
/* Tries to set various rates and formats and fill in the device info structure. */
static PaError Pa_sgiQueryDevice(long ALdev, /* (AL_DEFAULT_DEVICE) */
PaDeviceID id, /* (DefaultI|ODeviceID()) */
char* name, /* (for example "SGI AL") */
internalPortAudioDevice* pad) /* Result written to pad. */
{
int format;
long min, max; /* To catch hardware characteristics. */
ALseterrorhandler(0); /* 0 = turn off the default error handler. */
/*--------------------------------------------------------------------------------------*/
pad->pad_ALdevice = ALdev; /* Set the AL device number. */
pad->pad_DeviceID = id; /* Set the PA device number. */
if (strlen(name) > MAX_CHARS_DEVNAME) /* MAX_CHARS defined above. */
{
ERR_RPT(("Pa_QueryDevice(): name too long (%s).\n", name));
return paHostError;
}
strcpy(pad->pad_DeviceName, name); /* Write name-string. */
pad->pad_Info.name = pad->pad_DeviceName; /* Set pointer,..hmmm. */
/*--------------------------------- natively supported sample formats: -----------------*/
pad->pad_Info.nativeSampleFormats = paInt16; /* Later also include paFloat32 | ..| etc. */
/* Then also choose other CallConvertXX()! */
/*--------------------------------- number of available i/o channels: ------------------*/
if (ALgetminmax(ALdev, AL_INPUT_COUNT, &min, &max))
return translateSGIerror();
pad->pad_Info.maxInputChannels = max;
DBUG(("Pa_QueryDevice: maxInputChannels = %d\n", pad->pad_Info.maxInputChannels))
if (ALgetminmax(ALdev, AL_OUTPUT_COUNT, &min, &max))
return translateSGIerror();
pad->pad_Info.maxOutputChannels = max;
DBUG(("Pa_QueryDevice: maxOutputChannels = %d\n", pad->pad_Info.maxOutputChannels))
/*--------------------------------- supported samplerates: ----------------------*/
pad->pad_Info.numSampleRates = 7;
pad->pad_Info.sampleRates = pad->pad_SampleRates;
pad->pad_SampleRates[0] = (double)AL_RATE_8000; /* long -> double. */
pad->pad_SampleRates[1] = (double)AL_RATE_11025;
pad->pad_SampleRates[2] = (double)AL_RATE_16000;
pad->pad_SampleRates[3] = (double)AL_RATE_22050;
pad->pad_SampleRates[4] = (double)AL_RATE_32000;
pad->pad_SampleRates[5] = (double)AL_RATE_44100;
pad->pad_SampleRates[6] = (double)AL_RATE_48000;
if (ALgetminmax(ALdev, AL_INPUT_RATE, &min, &max)) /* Ask INPUT rate-max. */
return translateSGIerror(); /* double -> long. */
if (max != (long)(0.5 + pad->pad_SampleRates[6])) /* FP-compare not recommndd. */
goto weird;
if (ALgetminmax(ALdev, AL_OUTPUT_RATE, &min, &max)) /* Ask OUTPUT rate-max. */
return translateSGIerror();
if (max != (long)(0.5 + pad->pad_SampleRates[6]))
{
weird: ERR_RPT(("Pa_sgiQueryDevice() did not confirm max samplerate (%ld)\n",max));
return paHostError; /* Or make it a warning and just carry on... */
}
/*-------------------------------------------------------------------------------*/
return paNoError;
}
static int sgi_init(const char *param, int *speed, int *fragsize, int *fragnr, int *channels)
{
long chpars[] = { AL_OUTPUT_RATE, 0 };
int st;
/* No stereo capability. */
*channels = 1;
ALseterrorhandler(sgi_errorhandler);
chpars[1] = *speed;
st = ALsetparams(AL_DEFAULT_DEVICE, chpars, 2);
if (st < 0) {
return 1;
}
st = ALgetparams(AL_DEFAULT_DEVICE, chpars, 2);
if (st < 0) {
return 1;
}
*speed = chpars[1];
sgi_audioconfig = ALnewconfig();
if (!sgi_audioconfig) {
return 1;
}
st = ALsetchannels(sgi_audioconfig, AL_MONO);
if (st < 0) {
goto fail;
}
st = ALsetwidth(sgi_audioconfig, AL_SAMPLE_16);
if (st < 0) {
goto fail;
}
st = ALsetqueuesize(sgi_audioconfig, *fragsize * *fragnr);
if (st < 0) {
goto fail;
}
sgi_audioport = ALopenport("outport", "w", sgi_audioconfig);
if (!sgi_audioport) {
goto fail;
}
return 0;
fail:
ALfreeconfig(sgi_audioconfig);
sgi_audioconfig = NULL;
return 1;
}
/*--------------------------------------------------------------------------------------*/
PaError PaHost_OpenStream(internalPortAudioStream *past)
{
PaError result = paNoError;
PaHostSoundControl *pahsc;
unsigned int minNumBuffers;
internalPortAudioDevice *padIN, *padOUT; /* For looking up native AL-numbers. */
ALconfig sgiALconfig = NULL; /* IRIX-datatype. */
long pvbuf[8]; /* To get/set hardware configs. */
long sr, ALqsize;
DBUG(("PaHost_OpenStream() called.\n")); /* Alloc FASTMEM and init host data. */
if (!past)
{
ERR_RPT(("Streampointer NULL!\n"));
result = paBadStreamPtr; goto done;
}
pahsc = (PaHostSoundControl*)PaHost_AllocateFastMemory(sizeof(PaHostSoundControl));
if (pahsc == NULL)
{
ERR_RPT(("FAST Memory allocation failed.\n")); /* Pass trough some ERR_RPT-exit- */
result = paInsufficientMemory; goto done; /* code (nothing will be freed). */
}
memset(pahsc, 0, sizeof(PaHostSoundControl));
/* pahsc->pahsc_threadPID = -1; Should pahsc_threadPID be inited to */
past->past_DeviceData = (void*)pahsc; /* -1 instead of 0 ?? */
/*--------------------------------------------------- Allocate native buffers: --------*/
pahsc->pahsc_SamplesPerInputBuffer = past->past_FramesPerUserBuffer * /* Needed by the */
past->past_NumInputChannels; /* audio-thread. */
pahsc->pahsc_BytesPerInputBuffer = pahsc->pahsc_SamplesPerInputBuffer * sizeof(short);
if (past->past_NumInputChannels > 0) /* Assumes short = 16 bits! */
{
pahsc->pahsc_NativeInputBuffer = (short*)PaHost_AllocateFastMemory(pahsc->pahsc_BytesPerInputBuffer);
if( pahsc->pahsc_NativeInputBuffer == NULL )
{
ERR_RPT(("Fast memory allocation for input-buffer failed.\n"));
result = paInsufficientMemory; goto done;
}
}
pahsc->pahsc_SamplesPerOutputBuffer = past->past_FramesPerUserBuffer * /* Needed by the */
past->past_NumOutputChannels; /* audio-thread. */
pahsc->pahsc_BytesPerOutputBuffer = pahsc->pahsc_SamplesPerOutputBuffer * sizeof(short);
if (past->past_NumOutputChannels > 0) /* Assumes short = 16 bits! */
{
pahsc->pahsc_NativeOutputBuffer = (short*)PaHost_AllocateFastMemory(pahsc->pahsc_BytesPerOutputBuffer);
if (pahsc->pahsc_NativeOutputBuffer == NULL)
{
ERR_RPT(("Fast memory allocation for output-buffer failed.\n"));
result = paInsufficientMemory; goto done;
}
}
/*------------------------------------------ Manipulate hardware if necessary and allowed: --*/
ALseterrorhandler(0); /* 0 = turn off the default error handler. */
pvbuf[0] = AL_INPUT_RATE;
pvbuf[2] = AL_INPUT_COUNT;
pvbuf[4] = AL_OUTPUT_RATE; /* TO FIX: rates may be logically, not always in Hz! */
pvbuf[6] = AL_OUTPUT_COUNT;
sr = (long)(past->past_SampleRate + 0.5); /* Common for input and output :-) */
if (past->past_NumInputChannels > 0) /* We need to lookup the corre- */
{ /* sponding native AL-number(s). */
padIN = Pa_GetInternalDevice(past->past_InputDeviceID);
if (!padIN)
{
ERR_RPT(("Pa_GetInternalDevice() for input failed.\n"));
result = paHostError; goto done;
}
if (ALgetparams(padIN->pad_ALdevice, &pvbuf[0], 4)) /* Although input and output will both be on */
goto sgiError; /* the same AL-device, the AL-library might */
if (pvbuf[1] != sr) /* contain more than AL_DEFAULT_DEVICE in */
{ /* Rate different from current harware-rate? the future. Therefore 2 seperate queries. */
if (pvbuf[3] > 0) /* Means, there's other clients using AL-input-ports */
{
ERR_RPT(("Sorry, not allowed to switch input-hardware to %ld Hz because \
another process is currently using input at %ld kHz.\n", sr, pvbuf[1]));
result = paHostError; goto done;
}
pvbuf[1] = sr; /* Then set input-rate. */
if (ALsetparams(padIN->pad_ALdevice, &pvbuf[0], 2))
goto sgiError; /* WHETHER THIS SAMPLERATE WAS REALLY PRESENT IN OUR ARRAY OF RATES, */
} /* IS NOT CHECKED, AT LEAST NOT BY ME, WITHIN THIS FILE! Does PA do? */
static BOOL SGI_Init(void)
{
long chpars[] = { AL_OUTPUT_RATE, AL_RATE_22050 };
switch(md_mixfreq) {
case 8000:
chpars[1] = AL_RATE_8000;
break;
case 11025:
chpars[1] = AL_RATE_11025;
break;
case 16000:
chpars[1] = AL_RATE_16000;
break;
case 22050:
chpars[1] = AL_RATE_22050;
break;
case 32000:
chpars[1] = AL_RATE_32000;
break;
case 44100:
chpars[1] = AL_RATE_44100;
break;
case 48000:
chpars[1] = AL_RATE_48000;
break;
default:
_mm_errno=MMERR_SGI_SPEED;
return 1;
}
ALseterrorhandler(0);
ALsetparams(AL_DEFAULT_DEVICE, chpars, 2);
if (!(sgi_config=ALnewconfig())) {
_mm_errno=MMERR_OPENING_AUDIO;
return 1;
}
if (md_mode&DMODE_16BITS) {
if (ALsetwidth(sgi_config,AL_SAMPLE_16)<0) {
_mm_errno=MMERR_SGI_16BIT;
return 1;
}
sample_factor = 1;
} else {
if (ALsetwidth(sgi_config,AL_SAMPLE_8)<0) {
_mm_errno=MMERR_SGI_8BIT;
return 1;
}
sample_factor = 0;
}
if (md_mode&DMODE_STEREO) {
if (ALsetchannels(sgi_config,AL_STEREO)<0) {
_mm_errno=MMERR_SGI_STEREO;
return 1;
}
} else {
if (ALsetchannels(sgi_config,AL_MONO)<0) {
_mm_errno=MMERR_SGI_MONO;
return 1;
}
}
if ((getenv("MM_SGI_FRAGSIZE"))&&(sgi_fragsize!=DEFAULT_SGI_FRAGSIZE))
sgi_fragsize=atol(getenv("MM_SGI_FRAGSIZE"));
if (!sgi_fragsize) sgi_fragsize=DEFAULT_SGI_FRAGSIZE;
if ((getenv("MM_SGI_BUFSIZE"))&&(sgi_bufsize!=DEFAULT_SGI_BUFSIZE))
sgi_bufsize=atol(getenv("MM_SGI_BUFSIZE"));
if (!sgi_bufsize) sgi_fragsize=DEFAULT_SGI_BUFSIZE;
ALsetqueuesize(sgi_config, sgi_bufsize);
if (!(sgi_port=ALopenport("libmikmod","w",sgi_config))) {
_mm_errno=MMERR_OPENING_AUDIO;
return 1;
}
if(!(audiobuffer=(SBYTE*)_mm_malloc(sgi_fragsize))) return 1;
return VC_Init();
}
static BOOL SGI_IsThere(void)
{
ALseterrorhandler(0);
return(ALqueryparams(AL_DEFAULT_DEVICE,0,0))?1:0;
}
