static pascal void SMCallBackFunc(SndChannelPtr chan, SndCommand *cmd)
{
ExtSoundHeader *theHeader = NULL;
NAudioUnit* pAPU = (NAudioUnit*)cmd->param2;
// check if we should stop
if(!pAPU->IsRunning())
{
SndCommand flush = {flushCmd, 0, 0};
SndDoImmediate(chan, &flush);
SndCommand quiet = {quietCmd, 0, 0};
SndDoImmediate(chan, &quiet);
return;
}
// render audio, update sound header
pAPU->RenderFrame();
theHeader = pAPU->GetNextSoundHeaderPtr();
// issue next set of commands
SndCommand buffer = {bufferCmd, 0, (long)theHeader};
SndDoImmediate(chan, &buffer);
SndCommand callback = {callBackCmd, 0, (long)pAPU};
SndDoCommand(chan, &callback, true);
}
void GBSoundChannel::StopSound() {
SndCommand cmd;
cmd.cmd = flushCmd;
if ( SndDoImmediate(channel, &cmd) )
throw GBGenericError("couldn't stop sound");
cmd.cmd = quietCmd;
if ( SndDoImmediate(channel, &cmd) )
throw GBGenericError("couldn't stop sound");
priority = 0;
}
void BURGERCALL MADStopDriver( MADDriverRec *MDriver)
{
SndCommand cmd;
MDriver->MADPlay = FALSE;
cmd.cmd = quietCmd;
cmd.param1 = 0;
cmd.param2 = 0;
SndDoImmediate( MDriver->MusicChannelPP,&cmd);
cmd.cmd = flushCmd;
cmd.param1 = 0;
cmd.param2 = 0;
SndDoImmediate( MDriver->MusicChannelPP,&cmd);
MADCleanDriver( MDriver);
}
static
int soundcmd(enum mode mode, unsigned short cmd, short param1, long param2)
{
SndCommand command;
command.cmd = cmd;
command.param1 = param1;
command.param2 = param2;
switch (mode) {
case IMMEDIATE:
if (SndDoImmediate(channel, &command) != noErr) {
audio_error = _("SndDoImmediate() failed");
return -1;
}
break;
case QUEUE:
if (SndDoCommand(channel, &command, FALSE) != noErr) {
audio_error = _("SndDoCommand() failed");
return -1;
}
break;
}
return 0;
}
void mac_setVolume(short amplitude)
{
SndCommand theCmd;
if( amplitude<0 ) amplitude=0;
if( amplitude>255 ) amplitude=255;
theCmd.cmd=ampCmd;
theCmd.param1=amplitude;
SndDoImmediate(gSndCannel, &theCmd);
}
static void
silence_network_speaker() {
if (speaker) {
SndCommand command;
OSErr error;
command.cmd= flushCmd;
command.param1= 0;
command.param2= 0;
error= SndDoImmediate(speaker->channel, &command);
assert(error==noErr);
command.cmd= quietCmd;
command.param1= 0;
command.param2= 0;
error= SndDoImmediate(speaker->channel, &command);
assert(error==noErr);
speaker->header->dbhBufferPtr[0]->dbFlags= 0;
speaker->header->dbhBufferPtr[1]->dbFlags= 0;
}
}
static PyObject *SndCh_SndDoImmediate(SndChannelObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
OSErr _err;
SndCommand cmd;
if (!PyArg_ParseTuple(_args, "O&",
SndCmd_Convert, &cmd))
return NULL;
_err = SndDoImmediate(_self->ob_itself,
&cmd);
if (_err != noErr) return PyMac_Error(_err);
Py_INCREF(Py_None);
_res = Py_None;
return _res;
}
void
mac_snd_callback(SndChannelPtr snd_chan_ptr, SndCommand *in_sndcmd)
{
OSStatus err;
int samps;
// This is an interrupt routine--no printf, etc!
samps = g_macsnd_rebuf_ptr - g_macsnd_rebuf_cur;
if(samps < 0) {
samps += MACSND_REBUF_SIZE;
}
samps = samps & -(MACSND_QUANTA); // quantize to 1024 samples
if(g_macsnd_rebuf_cur + samps > &(g_macsnd_rebuf[MACSND_REBUF_SIZE])) {
samps = &(g_macsnd_rebuf[MACSND_REBUF_SIZE]) -
g_macsnd_rebuf_cur;
}
if(samps > 0) {
g_macsnd_playing = 1;
g_snd_hdr.numFrames = samps;
g_snd_hdr.loopEnd = samps;
g_snd_hdr.samplePtr = (byte *)g_macsnd_rebuf_cur;
g_snd_cmd.cmd = bufferCmd;
g_snd_cmd.param1 = 0;
g_snd_cmd.param2 = (long) &g_snd_hdr;
g_macsnd_rebuf_cur += samps;
if(g_macsnd_rebuf_cur >= &(g_macsnd_rebuf[MACSND_REBUF_SIZE])) {
g_macsnd_rebuf_cur -= MACSND_REBUF_SIZE;
}
err = SndDoImmediate(g_snd_channel_ptr, &g_snd_cmd);
// And set-up callback
g_snd_cmd.cmd = callBackCmd;
g_snd_cmd.param1 = 0;
g_snd_cmd.param2 = 0;
err = SndDoCommand(g_snd_channel_ptr, &g_snd_cmd, TRUE);
} else {
g_macsnd_playing = 0;
}
}
void music_idle_proc(
void)
{
if(music_state && music_state->initialized && music_state->state != _no_song_playing)
{
short ticks_elapsed= TickCount()-music_state->ticks_at_last_update;
switch(music_state->state)
{
case _delaying_for_loop:
if((music_state->phase-=ticks_elapsed)<=0)
{
/* Start playing.. */
OSErr error;
music_state->sound_buffer_size= kDefaultSoundBufferSize;
music_state->sound_buffer= (Ptr)malloc(music_state->sound_buffer_size);
if (music_state->sound_buffer)
{
assert(music_state->channel);
error= SndStartFilePlay(music_state->channel, // channel
music_state->song_file_refnum, // Not from an AIFF file.
0, // our resource id.
music_state->sound_buffer_size, // Buffer size
music_state->sound_buffer, // Let it allocate a buffer for us.
NULL, // Audio selection ptr.
music_state->completion_proc, // Completion proc
TRUE); // Async.
vwarn(error==noErr, csprintf(temporary, "SndStartFilePlay returned %d;g", error));
if (!error)
{
music_state->state= _playing_introduction;
}
else
{
music_state->state= _no_song_playing;
}
}
}
break;
case _music_fading:
if (ticks_elapsed>0)
{
if((music_state->phase-=ticks_elapsed)<=0 || (music_state->flags & _song_completed))
{
/* oops. we are done.. */
stop_music();
music_state->state= _no_song_playing;
if(music_state->song_index != NONE)
{
/* Start the new song playing.. */
queue_song(music_state->song_index);
}
} else {
if(--music_state->fade_interval_ticks<=0)
{
short new_volume;
SndCommand command;
OSErr error;
/* Only do this a few times.. */
music_state->fade_interval_ticks= music_state->fade_interval_duration;
/* Set the sound volume */
new_volume= (0x100*music_state->phase)/music_state->fade_duration;
/* set the sound volume */
command.cmd= volumeCmd;
command.param1= 0;
command.param2= BUILD_STEREO_VOLUME(new_volume, new_volume);
error= SndDoImmediate(music_state->channel, &command);
vwarn(error==noErr, csprintf(temporary, "SndDoImmediate returned %d;g", error));
}
}
}
break;
default:
/* Don't change states until song_completed flag is set. */
if(music_state->flags & _song_completed)
{
struct song_definition *song= get_song_definition(music_state->song_index);
if(song->flags & _song_automatically_loops)
{
music_state->state= _delaying_for_loop;
music_state->phase= song->restart_delay;
} else {
music_state->state= _no_song_playing;
}
music_state->flags &= ~_song_completed;
}
break;
}
music_state->ticks_at_last_update= TickCount();
}
return;
}
