/* Build and write one tick (one PAL frame or 1/50 s in standard vblank
* timed mods) of audio data to the output device.
*
* Apparently ALwritesamps requires the number of samples instead of
* the number of bytes, which is what I assume i is. This was a
* trial-and-error fix, but it appears to work. - 19990706 bdowning
*/
static void bufdump(struct xmp_context *ctx, int i)
{
if (al_sample_16)
ALwritesamps(audio_port, xmp_smix_buffer(ctx), i / 2);
else
ALwritesamps(audio_port, xmp_smix_buffer(ctx), i);
}
static int sgi_write(SWORD *pbuf, size_t nr)
{
int i;
i = ALwritesamps(sgi_audioport, pbuf, nr);
if (i < 0) {
return 1;
}
return 0;
}
int esd_audio_write(void *buffer, int buf_size)
{
ALsetparams(AL_DEFAULT_DEVICE, rate_params, 2);
if (ALwritesamps(outaudioport, buffer, buf_size / 2) == 0) {
ALsetfillpoint(outaudioport, ESD_BUF_SIZE);
return buf_size;
}
else
return 0;
}
void *Audio_Irix::write ()
{
if (_audio != NULL)
{
ALwritesamps(_audio, (char*)_sampleBuffer, _settings.bufSize);
return _sampleBuffer;
}
_errorString = "ERROR: Device not open.";
return 0;
}
static void
write_linear_chunk (void *data, void *limit, AudioContext ac)
{
unsigned n_samples;
switch (ac->ac_format)
{
case AFlinear16: n_samples = (short *) limit - (short *) data; break;
case AFlinear8: n_samples = (char *) limit - (char *) data; break;
default: n_samples = (long *) limit - (long *) data; break;
}
ALwritesamps (ac->ac_port, data, (long) n_samples);
}
void Synthesize(ALport alp, SynthState *v1, SynthState *v2) {
short samplebuffer[VSIZE];
int i;
for (i = 0; i < VSIZE; ++i) {
/* appropriately scaled sine wave */
samplebuffer[i] = 32767.0f * GAIN *
(v1->g * sin(2.0 * PI * v1->f * v1->t) +
v2->g * sin(2.0 * PI * v2->f * v2->t));
v1->t += 1.0 / SRATE; /* the march of time */
v2->t += 1.0 / SRATE; /* the march of time */
}
/* send samples out the door */
ALwritesamps(alp, samplebuffer, VSIZE);
}
static void write_mulaw_8_chunk(void *buffer, void *chunklimit, AudioContext ac)
{
unsigned char *data = (unsigned char *)buffer;
unsigned char *limit = (unsigned char *)chunklimit;
short *obuf, *bufp;
long n_samples = limit - data;
obuf = alloca_array(short, n_samples);
bufp = &obuf[0];
while (data < limit)
*bufp++ = st_ulaw_to_linear(*data++);
ALwritesamps(ac->ac_port, obuf, n_samples);
}
static void
write_linear_32_chunk (void *buffer, void *chunklimit, AudioContext ac)
{
long * data = (long *) buffer;
long * limit = (long *) chunklimit;
long * obuf, * bufp;
long n_samples = limit-data;
obuf = alloca_array (long, n_samples);
bufp = &obuf[0];
while (data < limit)
*bufp++ = *data++ >> 8;
ALwritesamps (ac->ac_port, obuf, n_samples);
}
int
sgi_audio_write(audio_desc_t ad, u_char *buf, int buf_bytes)
{
long samples;
UNUSED(ad); assert(audio_fd > 0);
samples = buf_bytes / BYTES_PER_SAMPLE;
if (samples > QSIZE) {
fprintf(stderr, "audio_write: too big!\n");
samples = QSIZE;
}
/* Will block */
ALwritesamps(wp, buf, samples);
return buf_bytes;
}
/*
* Sound handler.
*/
static void sfxSoundHandler(void *arg) {
ALport *ap = (ALport *)arg;
Sample samp[MAX_AUDIO_PORTS];
int idx, nap;
int treated;
int nSounds = 1;
int nextPort = 0;
long maxSampsPerPass;
long sampCount;
long pvbuf[2];
struct _sfx ss;
struct pollfd pf;
prctl(PR_TERMCHILD, 0);
(void) signal(SIGHUP, sfxDieGracefully);
maxSampsPerPass = 1600;
for (idx=0; idx < nAudioPorts; idx++) {
samp[idx].id = -1;
samp[idx].sample = NULL;
samp[idx].sampsToPlay = 0;
samp[idx].repeat = 0;
}
/*
* Set sample rate for output device.
*/
pvbuf[0] = AL_OUTPUT_RATE;
pvbuf[1] = AL_RATE_16000;
(void) ALsetparams(AL_DEFAULT_DEVICE, pvbuf, 2L);
/*
* Prepare to read from pipe.
*/
pf.fd = spigot[0];
pf.events = POLLIN | POLLRDNORM | POLLRDBAND;
#define EVER ;;
for (EVER) {
if (nSounds == 0 || (idx=poll(&pf, 1, 0)) > 0) {
(void) read(spigot[0], &ss, sizeof(ss));
treated = 0;
if (ss.loop == 1 && ss.repeat == 0) {
treated = 1;
for (idx=0; idx < nAudioPorts; idx++) {
if (samp[idx].id == ss.id) {
samp[idx].id = -1;
samp[idx].repeat = 0;
samp[idx].sampsToPlay = 0;
samp[idx].sample = NULL;
}
}
} else if (ss.loop == 1 && ss.count > 1) {
for (idx=0; idx < nAudioPorts; idx++) {
if (samp[idx].id == ss.id) {
treated = 1;
samp[idx].repeat = ss.repeat;
samp[idx].sampsToPlay = (long)ss.soundSize[ss.pitch];
samp[idx].sampsPlayed = 0;
samp[idx].sample = ss.soundData[ss.pitch];
}
}
}
if (!treated) {
for (idx=0; idx < nAudioPorts; idx++) {
nextPort = (nextPort+1) % nAudioPorts;
if (samp[nextPort].repeat == 0)
break;
}
samp[nextPort].sample = ss.soundData[ss.pitch];
samp[nextPort].sampsToPlay = (long)ss.soundSize[ss.pitch];
samp[nextPort].sampsPlayed = 0;
samp[nextPort].repeat = ss.repeat;
samp[nextPort].id = ss.id;
}
} else if (idx < 0)
(void) fprintf(stderr, "panic: input poll failed: %s\n", strerror(errno));
nSounds = 0;
nap = 0;
for (idx=0; idx < nAudioPorts; idx++) {
if (samp[idx].sampsToPlay > 0) {
nSounds++;
if (ALgetfilled(ap[idx]) > 4000) {
nap++;
continue;
}
}
if (samp[idx].sampsToPlay >= maxSampsPerPass) {
(void) ALwritesamps(ap[idx],
samp[idx].sample + samp[idx].sampsPlayed, maxSampsPerPass);
samp[idx].sampsPlayed += maxSampsPerPass;
samp[idx].sampsToPlay -= maxSampsPerPass;
} else if (samp[idx].sampsToPlay > 0) {
if ((samp[idx].sampsToPlay%2) == 1) {
samp[idx].sampsToPlay -= 1;
samp[idx].sampsPlayed += 1;
}
if (samp[idx].sampsToPlay > 0)
(void) ALwritesamps(ap[idx],
samp[idx].sample+samp[idx].sampsPlayed, samp[idx].sampsToPlay);
if (samp[idx].repeat) {
sampCount = maxSampsPerPass - samp[idx].sampsToPlay;
samp[idx].sampsToPlay += samp[idx].sampsPlayed - sampCount;
samp[idx].sampsPlayed = sampCount;
(void) ALwritesamps(ap[idx], samp[idx].sample, sampCount);
} else
samp[idx].sampsToPlay = 0;
}
}
if (nap == nSounds)
sginap(1);
}
return;
}
/*---------------------------------------------------------------------------------------------------*/
static PaError Pa_SgiAudioProcess(internalPortAudioStream *past) /* Spawned by PaHost_StartEngine(). */
{
PaError result = paNoError;
PaHostSoundControl *pahsc;
if (!past)
return paBadStreamPtr;
pahsc = (PaHostSoundControl*)past->past_DeviceData;
if (!pahsc)
return paInternalError;
past->past_IsActive = 1; /* Wasn't this already done by the calling parent?! */
DBUG(("entering thread.\n"));
while (!past->past_StopSoon) /* OR-ing StopSoon and StopNow here gives problems! */
{
/*---------------------------------------- INPUT: ------------------------------------*/
if (pahsc->pahsc_NativeInputBuffer) /* Then pahsc_ALportIN should also be there! */
{
while (ALgetfilled(pahsc->pahsc_ALportIN) < pahsc->pahsc_SamplesPerInputBuffer)
{
/* Trying sginap(1); and usleep(); here... things get blocked under IRIX6.2. */
if (past->past_StopNow) /* Don't let ALreadsamps() block */
goto done;
}
if (ALreadsamps(pahsc->pahsc_ALportIN, (void*)pahsc->pahsc_NativeInputBuffer,
pahsc->pahsc_SamplesPerInputBuffer)) /* Number of samples instead */
{ /* of number of frames. */
ERR_RPT(("ALreadsamps() failed.\n"));
result = paInternalError;
goto done;
}
}
/*---------------------------------------------------- USER CALLBACK ROUTINE: ----------*/
/* DBUG(("Calling Pa_CallConvertInt16()...\n")); */
Pa_StartUsageCalculation(past); /* Convert 16 bit native data to */
result = Pa_CallConvertInt16(past, /* user data and call user routine. */
pahsc->pahsc_NativeInputBuffer, pahsc->pahsc_NativeOutputBuffer);
Pa_EndUsageCalculation(past);
if (result)
{
DBUG(("Pa_CallConvertInt16() returned %d, stopping...\n", result));
goto done; /* This is apparently NOT an error! */
} /* Just letting the userCallBack stop us. */
/*---------------------------------------- OUTPUT: ------------------------------------*/
if (pahsc->pahsc_NativeOutputBuffer) /* Then pahsc_ALportOUT should also be there! */
{
while (ALgetfillable(pahsc->pahsc_ALportOUT) < pahsc->pahsc_SamplesPerOutputBuffer)
{
/* Trying sginap(1); and usleep(); here... things get blocked under IRIX6.2. */
if (past->past_StopNow) /* Don't let ALwritesamps() block */
goto done;
}
if (ALwritesamps(pahsc->pahsc_ALportOUT, (void*)pahsc->pahsc_NativeOutputBuffer,
pahsc->pahsc_SamplesPerOutputBuffer))
{
ERR_RPT(("ALwritesamps() failed.\n"));
result = paInternalError;
goto done;
}
}
/*-------------------------------------------------------------------------------------*/
}
done:
/* pahsc->pahsc_ThreadPID = -1; Hu? doesn't help!! (added by Pieter) */
past->past_IsActive = 0;
DBUG(("leaving thread.\n"));
return result;
}
void output_samples(unsigned char *buf, int size)
{
ALwritesamps(audioport,buf,size);
}
void playaudio(void *arg, CDDATATYPES type, short *audio)
{
if (audio_mode) ALwritesamps(audioport, audio, CDDA_NUMSAMPLES);
if (!dump_mode) AFwriteframes(aiffoutfile,AF_DEFAULT_TRACK,audio,
CDDA_NUMSAMPLES/2);
}
void SoundCardPMO::WorkerThread(void)
{
void *pBuffer;
Error eErr;
size_t iRet;
Event *pEvent;
audio_buf_info info;
bool bPerfWarn = false;
// Don't do anything until resume is called.
m_pPauseSem->Wait();
//CheckForBufferUp();
// Wait a specified prebuffer time...
PreBuffer();
for(; !m_bExit;)
{
if (m_bPause)
{
m_pPauseSem->Wait();
continue;
}
// Loop until we get an Init event from the LMC
if (!m_properlyInitialized)
{
pEvent = ((EventBuffer *)m_pInputBuffer)->GetEvent();
if (pEvent == NULL)
{
m_pLmc->Wake();
WasteTime();
continue;
}
if (pEvent->Type() == PMO_Init)
{
if (IsError(Init(((PMOInitEvent *)pEvent)->GetInfo())))
{
delete pEvent;
break;
}
}
delete pEvent;
continue;
}
// Set up reading a block from the buffer. If not enough bytes are
// available, sleep for a little while and try again.
for(;;)
{
eErr = ((EventBuffer *)m_pInputBuffer)->BeginRead(pBuffer,
m_iDataSize);
if (eErr == kError_EndOfStream || eErr == kError_Interrupt)
break;
if (eErr == kError_NoDataAvail)
{
m_pLmc->Wake();
CheckForBufferUp();
if (!bPerfWarn)
{
time_t t;
time(&t);
m_pContext->log->Log(LogPerf, "Output buffer underflow: %s",
ctime(&t));
bPerfWarn = true;
}
WasteTime();
continue;
}
// Is there an event pending that we need to take care of
// before we play this block of samples?
if (eErr == kError_EventPending)
{
pEvent = ((EventBuffer *)m_pInputBuffer)->PeekEvent();
if (pEvent == NULL)
continue;
if (pEvent->Type() == PMO_Quit &&
((EventBuffer *)m_pInputBuffer)->GetNumBytesInBuffer() > 0)
{
if (WaitForDrain())
{
m_pTarget->AcceptEvent(new Event(INFO_DoneOutputting));
return;
}
continue;
}
pEvent = ((EventBuffer *)m_pInputBuffer)->GetEvent();
if (pEvent->Type() == PMO_Init)
Init(((PMOInitEvent *)pEvent)->GetInfo());
if (pEvent->Type() == PMO_Reset)
Reset(false);
if (pEvent->Type() == PMO_Info)
HandleTimeInfoEvent((PMOTimeInfoEvent *)pEvent);
if (pEvent->Type() == PMO_Quit)
{
delete pEvent;
m_pTarget->AcceptEvent(new Event(INFO_DoneOutputting));
return;
}
delete pEvent;
continue;
}
if (IsError(eErr))
{
ReportError("Internal error occured.");
m_pContext->log->Error("Cannot read from buffer in PMO "
"worker tread: %d\n", eErr);
break;
}
bPerfWarn = false;
break;
}
if (m_bExit || m_bPause)
{
m_pInputBuffer->EndRead(0);
continue;
}
iRet = ALwritesamps(outaudioport, pBuffer, m_iDataSize);
if ((int)iRet < 0)
{
m_pInputBuffer->EndRead(0);
ReportError("Could not write sound data to the soundcard.");
m_pContext->log->Error("Failed to write to the soundcard: %s\n",
strerror(errno));
break;
}
m_iTotalBytesWritten += iRet;
m_pInputBuffer->EndRead(iRet);
m_pLmc->Wake();
UpdateBufferStatus();
}
}
