void
child_sound_init_mac()
{
OSStatus err;
mac_printf("In mac child\n");
fflush(stdout);
mac_printf("pid: %d\n", getpid());
fflush(stdout);
//return;
//g_snd_channel_ptr = 0;
err = SndNewChannel(&g_snd_channel_ptr, sampledSynth, initStereo,
NewSndCallBackUPP(mac_snd_callback));
mac_printf("SndNewChannel ret: %d\n", (int)err);
fflush(stdout);
memset(&g_snd_hdr, 0, sizeof(g_snd_hdr));
g_snd_hdr.sampleSize = 16;
g_snd_hdr.numChannels = 2;
g_audio_rate = 44100;
g_snd_hdr.sampleRate = g_audio_rate << 16;
g_snd_hdr.numFrames = 0; // will be set in mac_send_audio
g_snd_hdr.encode = extSH;
g_snd_hdr.baseFrequency = 0;
g_snd_hdr.samplePtr = 0;
set_audio_rate(g_audio_rate);
mac_printf("End of child_sound_init_mac\n");
fflush(stdout);
}
static
int init(struct audio_init *init)
{
int i;
channel = 0;
if (SndNewChannel(&channel, sampledSynth, 0, callback) != noErr) {
audio_error = _("SndNewChannel() failed");
return -1;
}
for (i = 0; i < NBUFFERS; ++i) {
if (MPCreateBinarySemaphore(&output[i].semaphore) != noErr) {
while (i--)
MPDeleteSemaphore(output[i].semaphore);
audio_error = _("failed to create synchronization object");
return -1;
}
output[i].pcm_nsamples = 0;
output[i].pcm_length = 0;
}
bindex = 0;
return 0;
}
static PyObject *Snd_SndNewChannel(PyObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
OSErr _err;
SndChannelPtr chan = 0;
short synth;
long init;
PyObject* userRoutine;
if (!PyArg_ParseTuple(_args, "hlO",
&synth,
&init,
&userRoutine))
return NULL;
if (userRoutine != Py_None && !PyCallable_Check(userRoutine))
{
PyErr_SetString(PyExc_TypeError, "callback must be callable");
goto userRoutine__error__;
}
_err = SndNewChannel(&chan,
synth,
init,
NewSndCallBackUPP(SndCh_UserRoutine));
if (_err != noErr) return PyMac_Error(_err);
_res = Py_BuildValue("O&",
SndCh_New, chan);
if (_res != NULL && userRoutine != Py_None)
{
SndChannelObject *p = (SndChannelObject *)_res;
p->ob_itself->userInfo = (long)p;
Py_INCREF(userRoutine);
p->ob_callback = userRoutine;
}
userRoutine__error__: ;
return _res;
}
bool wxOSXSoundManagerSoundData::Play(unsigned flags)
{
Stop();
m_flags = flags;
SoundComponentData data;
unsigned long numframes, offset;
ParseSndHeader((SndListHandle)m_hSnd, &data, &numframes, &offset);
SndNewChannel(&m_pSndChannel, sampledSynth,
initNoInterp
+ (data.numChannels == 1 ? initMono : initStereo), NULL);
if(SndPlay(m_pSndChannel, (SndListHandle) m_hSnd, flags & wxSOUND_ASYNC ? 1 : 0) != noErr)
return false;
if (flags & wxSOUND_ASYNC)
CreateAndStartTimer();
else
DoStop();
return true;
}
int init_sound (void)
{
if (SndNewChannel(&newChannel, sampledSynth, initMono, NULL))
return 0;
sndbufsize = 44100;
init_sound_table8 ();
sndbufpt = buffer0;
sound_available = 1;
return 1;
}
static void allocate_music_channel(
void)
{
if(music_state && music_state->initialized)
{
OSErr error;
assert(!music_state->channel);
error= SndNewChannel(&music_state->channel, sampledSynth, initStereo,
NULL);
// vwarn(error==noErr, csprintf(temporary, "SndNewChannel returned %d;g", error));
// warn(music_state->channel);
}
}
void init_snd_tool(){
short i,t;
SndCallBackUPP callback;
for (i = 0; i < NUM_SOUNDS; i++) {
if (!load_when_play[i]) {
sound_handles[i] = GetResource('snd ', 20000 + i);
}
}
callback = NewSndCallBackUPP(snd_channel_callback);
for(t=0;t<4;t++){ // setup 4 sound channels
SndNewChannel(&chan[t], sampledSynth, initMono + initNoDrop, callback);
chan[t]->qLength = 128;
}
}
static BOOL SoundChannel_Init(void) {
volatile QSOUND qs;
qs = &QSound;
ZeroMemory(qs, sizeof(QSOUND));
#if TARGET_API_MAC_CARBON
qs->cb = NewSndCallBackUPP(QSoundCallback);
#else
qs->cb = NewSndCallBackProc(QSoundCallback);
#endif
if (SndNewChannel(&qs->hdl, sampledSynth,
initStereo + initNoInterp + initNoDrop, qs->cb) != noErr) {
return(FAILURE);
}
return(SUCCESS);
}
static int macos_init_sound (SINT16 *b)
{
SndCallBackUPP cb;
SndCommand cmd;
report ("sound_macos: written by [email protected]\n");
sarienbuf = b;
header.numChannels = 1;
header.sampleSize = 16;
header.sampleRate = rate22khz;
header.numFrames = BUFFER_SIZE;
header.encode = cmpSH;
buffer[0] = malloc (BUFFER_SIZE << 1);
buffer[1] = malloc (BUFFER_SIZE << 1);
if (!buffer[0] || !buffer[1]) {
report ("sound_macos: Out of memory allocating %d bytes\n",
BUFFER_SIZE << 1);
return -1;
}
cb = NewSndCallBackUPP (fill_sound);
if (SndNewChannel (&channel, sampledSynth, initMono, cb) != noErr) {
report ("sound_macos: Unable to create channel");
return -1;
}
cmd.cmd = callBackCmd;
cmd.param2 = 0;
SndDoCommand (channel, &cmd, 0);
return 0;
}
/*
===============
SNDDMA_Init
===============
*/
qboolean SNDDMA_Init(void) {
int err;
// create a sound channel
s_sndChan = NULL;
err = SndNewChannel( &s_sndChan, sampledSynth, initStereo, NewSndCallBackProc(S_Callback) );
if ( err ) {
return false;
}
dma.channels = 2;
dma.samples = MAX_MIXED_SAMPLES;
dma.submission_chunk = SUBMISSION_CHUNK;
dma.samplebits = 16;
dma.speed = 22050;
dma.buffer = (byte *)s_mixedSamples;
// que up the first submission-chunk sized buffer
s_chunkCount = 0;
S_Callback( s_sndChan, NULL );
return qtrue;
}
int BURGERCALL MADSndOpen( MADDriverRec *inMADDriver)
{
int err;
SndChannelPtr mySndChan; // pointer to a sound channel
SndCallBackUPP CallBack;
CallBack = NewSndCallBackUPP(MyDoubleBackProc);
err=-1;
if (CallBack) {
mySndChan = 0L;
err = SndNewChannel(&mySndChan, sampledSynth, 0, CallBack);
if (!err) {
if (mySndChan) { /* Failsafe */
inMADDriver->CallBackUPP = CallBack;
inMADDriver->MusicChannelPP = mySndChan;
mySndChan->userInfo = (long)inMADDriver;
return DBSndPlay(inMADDriver, inMADDriver->MusicChannelPP);
}
err = MADSoundManagerErr;
}
DisposeSndCallBackUPP(CallBack); /* Kill the callback */
}
return err;
}
OSErr open_network_speaker()
{
short block_size = kBlockSize;
short connection_threshold = kConnectionThreshhold;
OSErr error;
assert(!speaker);
assert(block_size>0&&block_size<=MAXIMUM_DOUBLE_BUFFER_SIZE);
assert(connection_threshold>1&&connection_threshold<16);
/* install our atexit cleanup procedure and build a routine descriptor */
{
static bool initialization= true;
if (initialization) {
// ZZZ: Sorry, it looks like the CarbonSndPlayDoubleBuffer stuff really wants a plain C function
// pointer, sitting in the structure typed as a SndDoubleBackUPP. (Don't ask me!)
#if defined(TARGET_API_MAC_CARBON)
doubleback_routine_descriptor=
(SndDoubleBackUPP)network_speaker_doubleback_procedure;
#else
// Thomas Herzog fix
#if UNIVERSAL_INTERFACES_VERSION < 0x0340
doubleback_routine_descriptor= NewSndDoubleBackProc(
(ProcPtr)network_speaker_doubleback_procedure);
#else
doubleback_routine_descriptor= NewSndDoubleBackUPP(
network_speaker_doubleback_procedure);
#endif
// doubleback_routine_descriptor= NewSndDoubleBackProc((ProcPtr)network_speaker_doubleback_procedure);
#endif
assert(doubleback_routine_descriptor);
atexit(close_network_speaker);
}
}
speaker=
(struct speaker_definition *) NewPtr(sizeof(struct speaker_definition));
if ((error= MemError())==noErr) {
speaker->random_seed= 1;
speaker->block_size= block_size;
speaker->connection_threshold= connection_threshold;
speaker->channel= (SndChannelPtr) NewPtrClear(sizeof(SndChannel));
speaker->header=
(SndDoubleBufferHeaderPtr) NewPtrClear(sizeof(SndDoubleBufferHeader));
speaker->queue= NewPtr(sizeof(byte)*MAXIMUM_QUEUE_SIZE);
if ((error= MemError())==noErr) {
SndDoubleBufferHeaderPtr header= speaker->header;
header->dbhNumChannels= 1;
header->dbhSampleSize= 8;
header->dbhCompressionID= 0;
header->dbhPacketSize= 0;
header->dbhSampleRate= rate11025hz;
header->dbhDoubleBack= doubleback_routine_descriptor;
header->dbhBufferPtr[0]=
(SndDoubleBufferPtr) NewPtrClear(
sizeof(SndDoubleBuffer)+MAXIMUM_DOUBLE_BUFFER_SIZE);
header->dbhBufferPtr[1]=
(SndDoubleBufferPtr) NewPtrClear(
sizeof(SndDoubleBuffer)+MAXIMUM_DOUBLE_BUFFER_SIZE);
if ((error= MemError())==noErr) {
speaker->channel->qLength= stdQLength;
#ifdef env68k
speaker->channel->userInfo= (long) get_a5();
#endif
error=
SndNewChannel(&speaker->channel, sampledSynth, initMono|initMACE6,
NULL);
if (error==noErr) {
quiet_network_speaker(); /* to set defaults */
}
}
}
}
#ifdef SPEEX
init_speex_decoder();
#endif
/* if something went wrong, zero the speaker definition (without freeing any of our memory
like we should) */
if (error!=noErr) {
speaker= (struct speaker_definition *) NULL;
}
return error;
}
bool wxSound::DoPlay(unsigned flags) const
{
Stop();
Movie movie;
switch(m_type)
{
case wxSound_MEMORY:
{
if (!wxInitQT())
return false;
Handle myHandle, dataRef = nil;
MovieImportComponent miComponent;
Track targetTrack = nil;
TimeValue addedDuration = 0;
long outFlags = 0;
OSErr err;
ComponentResult result;
myHandle = NewHandleClear((Size)m_waveLength);
BlockMove(m_hSnd, *myHandle, m_waveLength);
err = PtrToHand(&myHandle, &dataRef, sizeof(Handle));
if (memcmp(&m_hSnd[8], "WAVE", 4) == 0)
miComponent = OpenDefaultComponent(MovieImportType, kQTFileTypeWave);
else if (memcmp(&m_hSnd[8], "AIFF", 4) == 0)
miComponent = OpenDefaultComponent(MovieImportType, kQTFileTypeAIFF);
else if (memcmp(&m_hSnd[8], "AIFC", 4) == 0)
miComponent = OpenDefaultComponent(MovieImportType, kQTFileTypeAIFC);
else
{
wxLogSysError(wxT("wxSound - Location in memory does not contain valid data"));
return false;
}
movie = NewMovie(0);
result = MovieImportDataRef(miComponent, dataRef,
HandleDataHandlerSubType, movie,
nil, &targetTrack,
nil, &addedDuration,
movieImportCreateTrack, &outFlags);
if (result != noErr)
{
wxLogSysError(wxString::Format(wxT("Couldn't import movie data\nError:%i"), (int)result));
}
SetMovieVolume(movie, kFullVolume);
GoToBeginningOfMovie(movie);
DisposeHandle(myHandle);
}
break;
case wxSound_RESOURCE:
{
SoundComponentData data;
unsigned long numframes, offset;
ParseSndHeader((SndListHandle)m_hSnd, &data, &numframes, &offset);
//m_waveLength = numFrames * data.numChannels;
SndChannelPtr pSndChannel;
SndNewChannel(&pSndChannel, sampledSynth,
initNoInterp
+ (data.numChannels == 1 ? initMono : initStereo), NULL);
if(SndPlay(pSndChannel, (SndListHandle) m_hSnd, flags & wxSOUND_ASYNC ? 1 : 0) != noErr)
return false;
if (flags & wxSOUND_ASYNC)
{
lastSoundTimer = ((wxSMTimer*&)m_pTimer)
= new wxSMTimer(pSndChannel, m_hSnd, flags & wxSOUND_LOOP ? 1 : 0,
&lastSoundIsPlaying);
lastSoundIsPlaying = true;
((wxTimer*)m_pTimer)->Start(MOVIE_DELAY, wxTIMER_CONTINUOUS);
}
else
SndDisposeChannel(pSndChannel, TRUE);
return true;
}
break;
case wxSound_FILE:
{
if (!wxInitQT())
return false;
OSErr err = noErr ;
Handle dataRef = NULL;
OSType dataRefType;
err = QTNewDataReferenceFromFullPathCFString(wxMacCFStringHolder(m_sndname,wxLocale::GetSystemEncoding()),
(UInt32)kQTNativeDefaultPathStyle, 0, &dataRef, &dataRefType);
wxASSERT(err == noErr);
if (NULL != dataRef || err != noErr)
{
err = NewMovieFromDataRef( &movie, newMovieDontAskUnresolvedDataRefs , NULL, dataRef, dataRefType );
wxASSERT(err == noErr);
DisposeHandle(dataRef);
}
if (err != noErr)
{
wxLogSysError(
wxString::Format(wxT("wxSound - Could not open file: %s\nError:%i"), m_sndname.c_str(), err )
);
return false;
}
}
break;
default:
return false;
}//end switch(m_type)
//Start the movie!
StartMovie(movie);
if (flags & wxSOUND_ASYNC)
{
//Start timer and play movie asyncronously
lastSoundTimer = ((wxQTTimer*&)m_pTimer) =
new wxQTTimer(movie, flags & wxSOUND_LOOP ? 1 : 0,
&lastSoundIsPlaying);
lastSoundIsPlaying = true;
((wxQTTimer*)m_pTimer)->Start(MOVIE_DELAY, wxTIMER_CONTINUOUS);
}
else
{
wxASSERT_MSG(!(flags & wxSOUND_LOOP), wxT("Can't loop and play syncronously at the same time"));
//Play movie until it ends, then exit
//Note that due to quicktime caching this may not always
//work 100% correctly
while (!IsMovieDone(movie))
MoviesTask(movie, 1);
DisposeMovie(movie);
}
return true;
}
static int Mac_OpenAudio(_THIS, SDL_AudioSpec *spec)
{
SndDoubleBufferHeader2 audio_dbh;
int i;
long initOptions;
int sample_bits;
SndDoubleBackUPP doubleBackProc;
/* Check to make sure double-buffered audio is available */
if ( ! DoubleBufferAudio_Available() ) {
SDL_SetError("Sound manager doesn't support double-buffering");
return(-1);
}
/* Very few conversions are required, but... */
switch (spec->format) {
case AUDIO_S8:
spec->format = AUDIO_U8;
break;
case AUDIO_U16LSB:
spec->format = AUDIO_S16LSB;
break;
case AUDIO_U16MSB:
spec->format = AUDIO_S16MSB;
break;
}
SDL_CalculateAudioSpec(spec);
/* initialize the double-back header */
memset(&audio_dbh, 0, sizeof(audio_dbh));
doubleBackProc = NewSndDoubleBackProc (sndDoubleBackProc);
sample_bits = spec->size / spec->samples / spec->channels * 8;
audio_dbh.dbhNumChannels = spec->channels;
audio_dbh.dbhSampleSize = sample_bits;
audio_dbh.dbhCompressionID = 0;
audio_dbh.dbhPacketSize = 0;
audio_dbh.dbhSampleRate = spec->freq << 16;
audio_dbh.dbhDoubleBack = doubleBackProc;
audio_dbh.dbhFormat = 0;
/* Note that we install the 16bitLittleEndian Converter if needed. */
if ( spec->format == 0x8010 ) {
audio_dbh.dbhCompressionID = fixedCompression;
audio_dbh.dbhFormat = k16BitLittleEndianFormat;
}
/* allocate the 2 double-back buffers */
for ( i=0; i<2; ++i ) {
audio_buf[i] = calloc(1, sizeof(SndDoubleBuffer)+spec->size);
if ( audio_buf[i] == NULL ) {
SDL_OutOfMemory();
return(-1);
}
audio_buf[i]->dbNumFrames = spec->samples;
audio_buf[i]->dbFlags = dbBufferReady;
audio_buf[i]->dbUserInfo[0] = (long)this;
audio_dbh.dbhBufferPtr[i] = audio_buf[i];
}
/* Create the sound manager channel */
channel = (SndChannelPtr)malloc(sizeof(*channel));
if ( channel == NULL ) {
SDL_OutOfMemory();
return(-1);
}
if ( spec->channels >= 2 ) {
initOptions = initStereo;
} else {
initOptions = initMono;
}
channel->userInfo = 0;
channel->qLength = 128;
if ( SndNewChannel(&channel, sampledSynth, initOptions, 0L) != noErr ) {
SDL_SetError("Unable to create audio channel");
free(channel);
channel = NULL;
return(-1);
}
/* Start playback */
if ( SndPlayDoubleBuffer(channel, (SndDoubleBufferHeaderPtr)&audio_dbh)
!= noErr ) {
SDL_SetError("Unable to play double buffered audio");
return(-1);
}
return 1;
}
static int Mac_OpenAudio(_THIS, SDL_AudioSpec *spec) {
SndCallBackUPP callback;
int sample_bits;
int i;
long initOptions;
/* Very few conversions are required, but... */
switch (spec->format) {
case AUDIO_S8:
spec->format = AUDIO_U8;
break;
case AUDIO_U16LSB:
spec->format = AUDIO_S16LSB;
break;
case AUDIO_U16MSB:
spec->format = AUDIO_S16MSB;
break;
}
SDL_CalculateAudioSpec(spec);
/* initialize bufferCmd header */
memset (&header, 0, sizeof(header));
callback = NewSndCallBackUPP (callBackProc);
sample_bits = spec->size / spec->samples / spec->channels * 8;
#ifdef DEBUG_AUDIO
fprintf(stderr,
"Audio format 0x%x, channels = %d, sample_bits = %d, frequency = %d\n",
spec->format, spec->channels, sample_bits, spec->freq);
#endif /* DEBUG_AUDIO */
header.numChannels = spec->channels;
header.sampleSize = sample_bits;
header.sampleRate = spec->freq << 16;
header.numFrames = spec->samples;
header.encode = cmpSH;
/* Note that we install the 16bitLittleEndian Converter if needed. */
if ( spec->format == 0x8010 ) {
header.compressionID = fixedCompression;
header.format = k16BitLittleEndianFormat;
}
/* allocate 2 buffers */
for (i=0; i<2; i++) {
buffer[i] = (UInt8*)malloc (sizeof(UInt8) * spec->size);
if (buffer[i] == NULL) {
SDL_OutOfMemory();
return (-1);
}
memset (buffer[i], 0, spec->size);
}
/* Create the sound manager channel */
channel = (SndChannelPtr)malloc(sizeof(*channel));
if ( channel == NULL ) {
SDL_OutOfMemory();
return(-1);
}
if ( spec->channels >= 2 ) {
initOptions = initStereo;
} else {
initOptions = initMono;
}
channel->userInfo = (long)this;
channel->qLength = 128;
if ( SndNewChannel(&channel, sampledSynth, initOptions, callback) != noErr ) {
SDL_SetError("Unable to create audio channel");
free(channel);
channel = NULL;
return(-1);
}
/* start playback */
{
SndCommand cmd;
cmd.cmd = callBackCmd;
cmd.param2 = 0;
running = 1;
SndDoCommand (channel, &cmd, 0);
}
return 1;
}
int audio_open(snd_node *n, long *f)
{
buffer_state *data = (buffer_state *)malloc(sizeof(buffer_state));
n->u.audio.descriptor = (void *)data;
OSErr err;
Fixed sampleRateFixed;
data->frameSize = snd_bytes_per_frame(n);
data->bufferSize = (int) (n->format.srate * (double)data->frameSize);
if (n->u.audio.latency > 0.0)
data->bufferSize = (int)(n->format.srate * n->u.audio.latency) * data->frameSize;
/* Calculate sample rate as an unsigned fixed-point number */
if (n->format.srate > 65535.0 ||
n->format.srate < 1.0)
sampleRateFixed = 0xAC440000; /* Fixed for 44100 */
else {
unsigned short numerator = (unsigned short)n->format.srate;
unsigned short denominator = (unsigned short)(65536.0*(n->format.srate - numerator));
sampleRateFixed = (numerator << 16) | denominator;
}
/* Open device for recording or playback, depending on mode selected */
if (n->write_flag == SND_READ) {
/* recording */
short gainControl = 0; /* off */
short numChannels = n->format.channels;
short continuousRecording = 1; /* on */
short playthroughVolume = 0; /* off */
OSType quality = 'cd ';
short sampleSize = 16;
short twos = 0; /* i.e. signed */
OSType compression = 'NONE';
SoundInfoList infoList;
int len, i, x, y, z;
short selected = 0;
char *device;
char *input;
char **buffer;
char oneInput[256];
char *deviceData;
data->recording = 1;
len = strlen(n->u.audio.devicename);
device = new char[len+1];
input = new char[len+1];
strcpy(device, n->u.audio.devicename);
input[0] = 0;
for(i=0; i<len; i++) {
if (device[i] == '\n') {
device[i] = 0;
strcpy(input, &device[i+1]);
i = len;
}
}
err = SPBOpenDevice(c2pstr(device), siWritePermission, &data->refnum);
if (err)
return !SND_SUCCESS;
SPBGetDeviceInfo (data->refnum, siInputAvailable, &infoList);
SPBGetDeviceInfo (data->refnum, siInputSourceNames, &buffer);
deviceData = buffer[0] + 2;
for(int x=0; x<infoList.count; x++) {
int y = *deviceData++;
z = 0;
while(y) {
oneInput[z++] = *deviceData++;
y--;
}
oneInput[z] = 0;
if (!strcmp(oneInput, input))
selected = x;
}
selected++;
SPBSetDeviceInfo (data->refnum, siInputSource, &selected);
SPBSetDeviceInfo(data->refnum, 'qual', &quality);
SPBSetDeviceInfo(data->refnum, 'agc ', &gainControl);
SPBSetDeviceInfo(data->refnum, 'srat', &sampleRateFixed);
SPBSetDeviceInfo(data->refnum, 'plth', &playthroughVolume);
err = SPBSetDeviceInfo(data->refnum, 'ssiz', &sampleSize);
if (err)
return !SND_SUCCESS;
err = SPBSetDeviceInfo(data->refnum, 'chan', &numChannels);
if (err)
return !SND_SUCCESS;
err = SPBSetDeviceInfo(data->refnum, 'cont', &continuousRecording);
if (err)
return !SND_SUCCESS;
err = SPBSetDeviceInfo(data->refnum, 'twos', &twos);
if (err)
return !SND_SUCCESS;
err = SPBSetDeviceInfo(data->refnum, 'comp', &compression);
if (err)
return !SND_SUCCESS;
data->recBuffer = (char *)malloc(data->bufferSize);
data->recqStart = 0;
data->recqEnd = 0;
data->starved = 0;
data->params.inRefNum = data->refnum;
data->params.count = 0; /* data->bufferSize; /* bytes to record */
data->params.milliseconds = 0; /* param will be ignored; use count */
data->params.bufferLength = 0; /* ignore buffer */
data->params.bufferPtr = NULL; /* ignore buffer */
data->params.completionRoutine = NULL;
data->params.userLong = (long)data;
data->params.unused1 = 0;
data->params.interruptRoutine = NewSIInterruptUPP(recordingCallback);
err = SPBRecord(&data->params, true);
if (err)
return !SND_SUCCESS;
}
else {
/* playback */
data->recording = 0;
data->chan = NULL;
////////////////////////
err = SndNewChannel(&data->chan, sampledSynth, 0, NULL);
if (err)
return !SND_SUCCESS;
data->buffer = (char *)malloc(data->bufferSize);
data->nextBufferSize = data->bufferSize * 3;
data->nextBuffer = (char *)malloc(data->nextBufferSize);
if (!data->buffer || !data->nextBuffer)
return !SND_SUCCESS;
data->chan->callBack = NewSndCallBackUPP(playbackCallback);
data->header.samplePtr = data->buffer;
data->header.numChannels = n->format.channels;
data->header.sampleRate = sampleRateFixed;
data->header.loopStart = 0;
data->header.loopEnd = 0;
data->header.encode = cmpSH;
data->header.baseFrequency = kMiddleC;
// data->header.AIFFSampleRate = 0; -- this parameter is unused
data->header.markerChunk = NULL;
data->header.format = kSoundNotCompressed;
data->header.futureUse2 = NULL;
data->header.stateVars = NULL;
data->header.leftOverSamples = NULL;
data->header.compressionID = 0;
data->header.packetSize = 0;
data->header.snthID = 0;
data->header.sampleSize = 16;
data->header.sampleArea[0] = 0;
data->playCmd.cmd = bufferCmd;
data->playCmd.param1 = 0; //unused
data->playCmd.param2 = (long)&data->header;
data->callCmd.cmd = callBackCmd;
data->callCmd.param1 = 0;
data->callCmd.param2 = (long)data;
data->curBuffer = 0;
data->curSize = 0;
data->firstTime = 1;
data->finished = 0;
data->busy = 0;
data->flushing = 0;
}
return SND_SUCCESS;
}
void
mac_speaker (struct obj *instr, char *melody) {
SndChannelPtr theChannel = (SndChannelPtr) 0;
SndCommand theCmd;
Handle theSound;
unsigned char theName [32];
char *n = (char *) &theName [1];
int typ = instr->otyp;
const char *actualn = OBJ_NAME (objects [typ]);
/*
* First: are we in the library ?
*/
if (flags.silent) {
return;
}
/*
* Is this a known instrument ?
*/
strcpy (n, actualn);
theName [0] = strlen (n);
theSound = GetNamedResource ('snd ', theName);
if (! theSound) {
return;
}
HLock (theSound);
/*
* Set up the synth
*/
if (SndNewChannel(&theChannel, sampledSynth, initMono +
initNoInterp, (void *) 0) == noErr) {
char midi_note [] = {57, 59, 60, 62, 64, 65, 67};
short err;
short snd_len = SND_LEN (theSound) / 18;
theCmd.cmd = soundCmd;
theCmd.param1 = 0;
theCmd.param2 = (long) SND_BUFFER (theSound);
err = SndDoCommand (theChannel, &theCmd, false);
/*
* We rack 'em up all in a row
* The mac will play them correctly and then end, since
* we do a sync close below.
*
*/
while (*melody && ! err) {
while (*melody > 'G') {
*melody -= 8;
}
while (*melody < 'A') {
*melody += 8;
}
theCmd.cmd = freqDurationCmd;
theCmd.param1 = snd_len;
theCmd.param2 = midi_note [*melody - 'A'];
err = SndDoCommand (theChannel, &theCmd, false);
melody ++;
}
SndDisposeChannel (theChannel, false); /* Sync wait for completion */
ReleaseResource (theSound);
}
}
GBSoundChannel::GBSoundChannel()
: channel(nil), priority(0)
{
if ( SndNewChannel(&channel, sampledSynth, initMono, nil) )
throw GBGenericError("couldn't make sound channel");
}
/*
* generic new : returns error
*/
int
start_fluid_sndmgr_audio_driver(fluid_settings_t* settings,
fluid_sndmgr_audio_driver_t* dev,
int buffer_size)
{
int i;
SndDoubleBufferHeader2* doubleHeader = NULL;
SndDoubleBufferPtr doubleBuffer = NULL;
OSErr err;
SndChannelPtr channel = NULL;
double sample_rate;
fluid_settings_getnum(settings, "synth.sample-rate", &sample_rate);
dev->doubleCallbackProc = NewSndDoubleBackProc(fluid_sndmgr_callback);
/* the channel */
FLUID_LOG(FLUID_DBG, "FLUID-SndManager@2");
err = SndNewChannel(&channel, sampledSynth, initStereo, NULL);
if ((err != noErr) || (channel == NULL)) {
FLUID_LOG(FLUID_ERR, "Failed to allocate a sound channel (error %i)", err);
return err;
}
/* the double buffer struct */
FLUID_LOG(FLUID_DBG, "FLUID-SndManager@3");
doubleHeader = FLUID_NEW(SndDoubleBufferHeader2);
if (doubleHeader == NULL) {
FLUID_LOG(FLUID_PANIC, "Out of memory");
return -1;
}
doubleHeader->dbhBufferPtr[0] = NULL;
doubleHeader->dbhBufferPtr[1] = NULL;
doubleHeader->dbhNumChannels = 2;
doubleHeader->dbhSampleSize = 16;
doubleHeader->dbhCompressionID = 0;
doubleHeader->dbhPacketSize = 0;
doubleHeader->dbhSampleRate = fluid_sndmgr_double_to_fix((long double) sample_rate);
doubleHeader->dbhDoubleBack = dev->doubleCallbackProc;
doubleHeader->dbhFormat = 0;
/* prepare dev */
FLUID_LOG(FLUID_DBG, "FLUID-SndManager@4");
dev->doubleHeader = doubleHeader;
dev->channel = channel;
dev->bufferFrameSize = buffer_size;
dev->bufferByteSize = buffer_size * 2 * 2;
/* the 2 doublebuffers */
FLUID_LOG(FLUID_DBG, "FLUID-SndManager@5");
for (i = 0; i < 2; i++) {
doubleBuffer = (SndDoubleBufferPtr) FLUID_MALLOC(sizeof(SndDoubleBuffer)
+ dev->bufferByteSize);
if (doubleBuffer == NULL) {
FLUID_LOG(FLUID_PANIC, "Out of memory");
return -1;
}
doubleBuffer->dbNumFrames = 0;
doubleBuffer->dbFlags = 0;
doubleBuffer->dbUserInfo[0] = (long) dev;
doubleHeader->dbhBufferPtr[i] = doubleBuffer;
CallSndDoubleBackProc(doubleHeader->dbhDoubleBack, channel, doubleBuffer);
}
/* start */
FLUID_LOG(FLUID_DBG, "FLUID-SndManager@6");
err = SndPlayDoubleBuffer(channel, (SndDoubleBufferHeader *)doubleHeader);
if (err != noErr) {
FLUID_LOG(FLUID_ERR, "Failed to start the sound driver (error %i)", err);
return err;
}
FLUID_LOG(FLUID_DBG, "FLUID-SndManager@7");
return 0;
}
static int
SNDMGR_OpenDevice(_THIS, const char *devname, int iscapture)
{
SDL_AudioSpec *spec = &this->spec;
SndChannelPtr channel = NULL;
SndCallBackUPP callback;
int sample_bits;
int i;
long initOptions;
/* Initialize all variables that we clean on shutdown */
this->hidden = (struct SDL_PrivateAudioData *)
SDL_malloc((sizeof *this->hidden));
if (this->hidden == NULL) {
SDL_OutOfMemory();
return 0;
}
SDL_memset(this->hidden, 0, (sizeof *this->hidden));
/* !!! FIXME: iterate through format matrix... */
/* Very few conversions are required, but... */
switch (spec->format) {
case AUDIO_S8:
spec->format = AUDIO_U8;
break;
case AUDIO_U16LSB:
spec->format = AUDIO_S16LSB;
break;
case AUDIO_U16MSB:
spec->format = AUDIO_S16MSB;
break;
case AUDIO_F32LSB:
spec->format = AUDIO_F32MSB;
break;
}
SDL_CalculateAudioSpec(&this->spec);
/* initialize bufferCmd header */
SDL_memset(&header, 0, sizeof(header));
callback = (SndCallBackUPP) NewSndCallBackUPP(callBackProc);
sample_bits = spec->size / spec->samples / spec->channels * 8;
#ifdef DEBUG_AUDIO
fprintf(stderr,
"Audio format 0x%x, channels = %d, sample_bits = %d, frequency = %d\n",
spec->format, spec->channels, sample_bits, spec->freq);
#endif /* DEBUG_AUDIO */
header.numChannels = spec->channels;
header.sampleSize = sample_bits;
header.sampleRate = spec->freq << 16;
header.numFrames = spec->samples;
header.encode = cmpSH;
/* Note that we install the 16bitLittleEndian Converter if needed. */
if (spec->format == AUDIO_S16LSB) {
header.compressionID = fixedCompression;
header.format = k16BitLittleEndianFormat;
} else if (spec->format == AUDIO_S32MSB) {
header.compressionID = fixedCompression;
header.format = k32BitFormat;
} else if (spec->format == AUDIO_S32LSB) {
header.compressionID = fixedCompression;
header.format = k32BitLittleEndianFormat;
} else if (spec->format == AUDIO_F32MSB) {
header.compressionID = fixedCompression;
header.format = kFloat32Format;
}
/* allocate 2 buffers */
for (i = 0; i < 2; i++) {
buffer[i] = (UInt8 *) SDL_malloc(sizeof(UInt8) * spec->size);
if (buffer[i] == NULL) {
SNDMGR_CloseDevice(this);
SDL_OutOfMemory();
return 0;
}
SDL_memset(buffer[i], 0, spec->size);
}
/* Create the sound manager channel */
channel = (SndChannelPtr) SDL_malloc(sizeof(*channel));
if (channel == NULL) {
SNDMGR_CloseDevice(this);
SDL_OutOfMemory();
return 0;
}
this->hidden->channel = channel;
if (spec->channels >= 2) {
initOptions = initStereo;
} else {
initOptions = initMono;
}
channel->userInfo = (long) this;
channel->qLength = 128;
if (SndNewChannel(&channel, sampledSynth, initOptions, callback) != noErr) {
SNDMGR_CloseDevice(this);
SDL_SetError("Unable to create audio channel");
return 0;
}
/* start playback */
{
SndCommand cmd;
cmd.cmd = callBackCmd;
cmd.param2 = 0;
running = 1;
SndDoCommand(channel, &cmd, 0);
}
return 1;
}
NAudioUnit::NAudioUnit()
{
int i;
OSStatus err;
_bInitialized = _bRunning = false;
_iLastFrameNr = _iFrameRepeat = 0;
_pBuffers[0] = _pBuffers[1] = NULL;
_pTempBuf = NULL;
// setup sound manager structures
SndCallBackUPP callBackUPP = NewSndCallBackUPP(SMCallBackFunc);
_sndChannel = NULL;
err = SndNewChannel(&_sndChannel, sampledSynth, initMono, callBackUPP);
if(err != noErr)
{
_sndChannel = NULL;
NotifyUser(kSoundErrStringNr, kSoundErrStringNr + 1, kOKButtonStringNr);
}
memset(&_eshHeader, 0, sizeof(_eshHeader));
_eshHeader.numChannels = 1;
_eshHeader.encode = extSH;
_eshHeader.baseFrequency = kMiddleC;
_eshHeader.sampleSize = 16;
// allocate sample memory
for(i=0; i<4; i++)
_pSquares[i] = new double[kSampleSize];
_pTriangle = new double[kSampleSize];
_pNoise = new double[kNoiseSampleSize];
// generate default samples
GenSquare16(_pSquares[0], 87.5);
GenSquare16(_pSquares[1], 75.0);
GenSquare16(_pSquares[2], 50.0);
GenSquare16(_pSquares[3], 25.0);
GenTriangle16(_pTriangle);
GenNoise16(_pNoise);
// setup tables
_iDMCMaxAmp = 4; _iDMCMinAmp = -4;
_fNoiseStepTab[ 0] = 1.0/1.0001831390;
_fNoiseStepTab[ 1] = 1.0/1.0001526112;
_fNoiseStepTab[ 2] = 1.0/1.0002075626;
_fNoiseStepTab[ 3] = 1.0/1.0002197749;
_fNoiseStepTab[ 4] = 1.0/1.5772803851;
_fNoiseStepTab[ 5] = 1.0/2.3661293817;
_fNoiseStepTab[ 6] = 1.0/3.1545304016;
_fNoiseStepTab[ 7] = 1.0/3.9398821691;
_fNoiseStepTab[ 8] = 1.0/4.9777777778;
_fNoiseStepTab[ 9] = 1.0/6.2596469779;
_fNoiseStepTab[10] = 1.0/9.3610970036;
_fNoiseStepTab[11] = 1.0/12.5176200936;
_fNoiseStepTab[12] = 1.0/18.7746371276;
_fNoiseStepTab[13] = 1.0/25.0328495034;
_fNoiseStepTab[14] = 1.0/50.0529531568;
_fNoiseStepTab[15] = 1.0/50.4640657084;
_iTimeConvTab[ 0] = 5; _iTimeConvTab[ 1] = 127;
_iTimeConvTab[ 2] = 10; _iTimeConvTab[ 3] = 1;
_iTimeConvTab[ 4] = 20; _iTimeConvTab[ 5] = 2;
_iTimeConvTab[ 6] = 40; _iTimeConvTab[ 7] = 3;
_iTimeConvTab[ 8] = 80; _iTimeConvTab[ 9] = 4;
_iTimeConvTab[10] = 30; _iTimeConvTab[11] = 5;
_iTimeConvTab[12] = 7; _iTimeConvTab[13] = 6;
_iTimeConvTab[14] = 14; _iTimeConvTab[15] = 7;
_iTimeConvTab[16] = 6; _iTimeConvTab[17] = 8;
_iTimeConvTab[18] = 12; _iTimeConvTab[19] = 9;
_iTimeConvTab[20] = 24; _iTimeConvTab[21] = 10;
_iTimeConvTab[22] = 48; _iTimeConvTab[23] = 11;
_iTimeConvTab[24] = 96; _iTimeConvTab[25] = 12;
_iTimeConvTab[26] = 36; _iTimeConvTab[27] = 13;
_iTimeConvTab[28] = 8; _iTimeConvTab[29] = 14;
_iTimeConvTab[30] = 16; _iTimeConvTab[31] = 15;
for(i=0; i<16; i++)
_fVolTab[i] = sin((1.5707963435/15.0)*((double)i));
// get volume from prefs
UpdateVolume();
// initialize playback
Initialize(kAPU_44kHz, 1);
}
