bool init(MidiFormat format, const char* patchLoc)
{
free();
s_mutex = Mutex::create();
s_midiFormat = format;
if (s_midiFormat == MFMT_GUS_PATCH)
{
s_volume = c_volumeScale[0];
s_sampleRate = 32072.0;
if (WildMidi_Init(patchLoc, 32072, WM_MO_ENHANCED_RESAMPLING) >= 0)
{
s_initialized = true;
WildMidi_MasterVolume(100);
return true;
}
}
else if (s_midiFormat == MFMT_SOUND_FONT)
{
s_volume = c_volumeScale[1];
if (!loadFluidsythDLL())
{
LOG( LOG_ERROR, "cannot find or load the \"libfluidsynth\" dynamic library." );
return false;
}
s_fluidSettings = new_fluid_settings();
fluid_settings_setstr(s_fluidSettings, "player.timing-source", "sample");
fluid_settings_setstr(s_fluidSettings, "synth.lock-memory", 0);
fluid_settings_setstr(s_fluidSettings, "synth.chorus-active", "0");
s_fluidSynth = new_fluid_synth(s_fluidSettings);
if (fluid_synth_sfload(s_fluidSynth, patchLoc, 1) < 0)
{
LOG( LOG_ERROR, "cannot load sound font \"%s\"", patchLoc );
unloadFluidsynthDLL();
return false;
}
s_fluidSeq = new_fluid_sequencer2(false);
fluid_sequencer_register_fluidsynth(s_fluidSeq, s_fluidSynth);
fluid_settings_getnum(s_fluidSettings, "synth.sample-rate", &s_sampleRate);
s_initialized = true;
s_fluidPlayer = new_fluid_player(s_fluidSynth);
return true;
}
return false;
}
void init_midi() {
if (synth) {
return;
}
settings.reset(new_fluid_settings(), &delete_fluid_settings);
fluid_settings_setstr(settings.get(), "player.timing-source", "sample");
fluid_settings_setint(settings.get(), "synth.lock-memory", 0);
synth.reset(new_fluid_synth(settings.get()), &delete_fluid_synth);
BOOST_VERIFY(fluid_synth_sfload(synth.get(), getenv("DEFAULT_SOUNDFONT"), 1) !=
FLUID_FAILED);
double sample_rate = 0;
fluid_settings_getnum(settings.get(), "synth.sample-rate", &sample_rate);
BOOST_ASSERT(sample_rate != 0);
this->sample_rate = sample_rate;
seq.reset(new_fluid_sequencer2(false), &delete_fluid_sequencer);
BOOST_VERIFY(fluid_sequencer_register_fluidsynth(seq.get(), synth.get()) != FLUID_FAILED);
}
fluid_audio_driver_t*
new_fluid_file_audio_driver(fluid_settings_t* settings,
fluid_synth_t* synth)
{
fluid_file_audio_driver_t* dev;
int msec;
dev = FLUID_NEW(fluid_file_audio_driver_t);
if (dev == NULL) {
FLUID_LOG(FLUID_ERR, "Out of memory");
return NULL;
}
FLUID_MEMSET(dev, 0, sizeof(fluid_file_audio_driver_t));
fluid_settings_getint(settings, "audio.period-size", &dev->period_size);
fluid_settings_getnum(settings, "synth.sample-rate", &dev->sample_rate);
dev->data = synth;
dev->callback = (fluid_audio_func_t) fluid_synth_process;
dev->samples = 0;
dev->renderer = new_fluid_file_renderer(synth);
if (dev->renderer == NULL)
goto error_recovery;
msec = (int) (0.5 + dev->period_size / dev->sample_rate * 1000.0);
dev->timer = new_fluid_timer(msec, fluid_file_audio_run_s16, (void*) dev, TRUE, FALSE, TRUE);
if (dev->timer == NULL) {
FLUID_LOG(FLUID_PANIC, "Couldn't create the audio thread.");
goto error_recovery;
}
return (fluid_audio_driver_t*) dev;
error_recovery:
delete_fluid_file_audio_driver((fluid_audio_driver_t*) dev);
return NULL;
}
void init_midi() {
if (synth) {
return;
}
settings.reset(new_fluid_settings(), &delete_fluid_settings);
fluid_settings_setstr(settings.get(), "player.timing-source", "sample");
fluid_settings_setint(settings.get(), "synth.lock-memory", 0);
synth.reset(new_fluid_synth(settings.get()), &delete_fluid_synth);
if (fluid_synth_sfload(synth.get(), getenv("DEFAULT_SOUNDFONT"), 1) == FLUID_FAILED)
Output::Error("Couldn't load soundfont\n%s.", getenv("DEFAULT_SOUNDFONT"));
double sample_rate = 0;
fluid_settings_getnum(settings.get(), "synth.sample-rate", &sample_rate);
assert(sample_rate != 0);
this->sample_rate = sample_rate;
seq.reset(new_fluid_sequencer2(false), &delete_fluid_sequencer);
if (fluid_sequencer_register_fluidsynth(seq.get(), synth.get()) == FLUID_FAILED)
Output::Error("Couldn't initialize MIDI playback.");
}
void sf2Instrument::updateSampleRate()
{
double tempRate;
// Set & get, returns the true sample rate
fluid_settings_setnum( m_settings, (char *) "synth.sample-rate", engine::mixer()->processingSampleRate() );
fluid_settings_getnum( m_settings, (char *) "synth.sample-rate", &tempRate );
m_internalSampleRate = static_cast<int>( tempRate );
if( m_font )
{
// Now, delete the old one and replace
m_synthMutex.lock();
fluid_synth_remove_sfont( m_synth, m_font->fluidFont );
delete_fluid_synth( m_synth );
// New synth
m_synth = new_fluid_synth( m_settings );
m_fontId = fluid_synth_add_sfont( m_synth, m_font->fluidFont );
m_synthMutex.unlock();
// synth program change (set bank and patch)
updatePatch();
updateGain();
}
else
{
// Recreate synth with no soundfonts
m_synthMutex.lock();
delete_fluid_synth( m_synth );
m_synth = new_fluid_synth( m_settings );
m_synthMutex.unlock();
}
m_synthMutex.lock();
if( engine::mixer()->currentQualitySettings().interpolation >=
Mixer::qualitySettings::Interpolation_SincFastest )
{
fluid_synth_set_interp_method( m_synth, -1, FLUID_INTERP_7THORDER );
}
else
{
fluid_synth_set_interp_method( m_synth, -1, FLUID_INTERP_DEFAULT );
}
m_synthMutex.unlock();
if( m_internalSampleRate < engine::mixer()->processingSampleRate() )
{
m_synthMutex.lock();
if( m_srcState != NULL )
{
src_delete( m_srcState );
}
int error;
m_srcState = src_new( engine::mixer()->currentQualitySettings().libsrcInterpolation(), DEFAULT_CHANNELS, &error );
if( m_srcState == NULL || error )
{
qCritical( "error while creating libsamplerate data structure in Sf2Instrument::updateSampleRate()" );
}
m_synthMutex.unlock();
}
updateReverb();
updateChorus();
}
/*
* new_fluid_core_audio_driver2
*/
fluid_audio_driver_t*
new_fluid_core_audio_driver2(fluid_settings_t* settings, fluid_audio_func_t func, void* data)
{
char* devname = NULL;
fluid_core_audio_driver_t* dev = NULL;
int period_size, periods;
double sample_rate;
OSStatus status;
UInt32 size;
int i;
dev = FLUID_NEW(fluid_core_audio_driver_t);
if (dev == NULL) {
FLUID_LOG(FLUID_ERR, "Out of memory");
return NULL;
}
FLUID_MEMSET(dev, 0, sizeof(fluid_core_audio_driver_t));
dev->callback = func;
dev->data = data;
// Open the default output unit
ComponentDescription desc;
desc.componentType = kAudioUnitType_Output;
desc.componentSubType = kAudioUnitSubType_HALOutput; //kAudioUnitSubType_DefaultOutput;
desc.componentManufacturer = kAudioUnitManufacturer_Apple;
desc.componentFlags = 0;
desc.componentFlagsMask = 0;
Component comp = FindNextComponent(NULL, &desc);
if (comp == NULL) {
FLUID_LOG(FLUID_ERR, "Failed to get the default audio device");
goto error_recovery;
}
status = OpenAComponent(comp, &dev->outputUnit);
if (status != noErr) {
FLUID_LOG(FLUID_ERR, "Failed to open the default audio device. Status=%ld\n", (long int)status);
goto error_recovery;
}
// Set up a callback function to generate output
AURenderCallbackStruct render;
render.inputProc = fluid_core_audio_callback;
render.inputProcRefCon = (void *) dev;
status = AudioUnitSetProperty (dev->outputUnit,
kAudioUnitProperty_SetRenderCallback,
kAudioUnitScope_Input,
0,
&render,
sizeof(render));
if (status != noErr) {
FLUID_LOG (FLUID_ERR, "Error setting the audio callback. Status=%ld\n", (long int)status);
goto error_recovery;
}
fluid_settings_getnum(settings, "synth.sample-rate", &sample_rate);
fluid_settings_getint(settings, "audio.periods", &periods);
fluid_settings_getint(settings, "audio.period-size", &period_size);
/* get the selected device name. if none is specified, use NULL for the default device. */
if (fluid_settings_dupstr(settings, "audio.coreaudio.device", &devname) /* alloc device name */
&& devname && strlen (devname) > 0) {
AudioObjectPropertyAddress pa;
pa.mSelector = kAudioHardwarePropertyDevices;
pa.mScope = kAudioObjectPropertyScopeWildcard;
pa.mElement = kAudioObjectPropertyElementMaster;
if (OK (AudioObjectGetPropertyDataSize (kAudioObjectSystemObject, &pa, 0, 0, &size))) {
int num = size / (int) sizeof (AudioDeviceID);
AudioDeviceID devs [num];
if (OK (AudioObjectGetPropertyData (kAudioObjectSystemObject, &pa, 0, 0, &size, devs))) {
for (i = 0; i < num; ++i) {
char name [1024];
size = sizeof (name);
pa.mSelector = kAudioDevicePropertyDeviceName;
if (OK (AudioObjectGetPropertyData (devs[i], &pa, 0, 0, &size, name))) {
if (get_num_outputs (devs[i]) > 0 && strcasecmp(devname, name) == 0) {
AudioDeviceID selectedID = devs[i];
status = AudioUnitSetProperty (dev->outputUnit,
kAudioOutputUnitProperty_CurrentDevice,
kAudioUnitScope_Global,
0,
&selectedID,
sizeof(AudioDeviceID));
if (status != noErr) {
FLUID_LOG (FLUID_ERR, "Error setting the selected output device. Status=%ld\n", (long int)status);
goto error_recovery;
}
}
}
}
}
}
}
if (devname)
FLUID_FREE (devname); /* free device name */
dev->buffer_size = period_size * periods;
// The DefaultOutputUnit should do any format conversions
// necessary from our format to the device's format.
dev->format.mSampleRate = sample_rate; // sample rate of the audio stream
dev->format.mFormatID = kAudioFormatLinearPCM; // encoding type of the audio stream
dev->format.mFormatFlags = kLinearPCMFormatFlagIsFloat;
dev->format.mBytesPerPacket = 2*sizeof(float);
dev->format.mFramesPerPacket = 1;
dev->format.mBytesPerFrame = 2*sizeof(float);
dev->format.mChannelsPerFrame = 2;
dev->format.mBitsPerChannel = 8*sizeof(float);
FLUID_LOG (FLUID_DBG, "mSampleRate %g", dev->format.mSampleRate);
FLUID_LOG (FLUID_DBG, "mFormatFlags %08X", dev->format.mFormatFlags);
FLUID_LOG (FLUID_DBG, "mBytesPerPacket %d", dev->format.mBytesPerPacket);
FLUID_LOG (FLUID_DBG, "mFramesPerPacket %d", dev->format.mFramesPerPacket);
FLUID_LOG (FLUID_DBG, "mChannelsPerFrame %d", dev->format.mChannelsPerFrame);
FLUID_LOG (FLUID_DBG, "mBytesPerFrame %d", dev->format.mBytesPerFrame);
FLUID_LOG (FLUID_DBG, "mBitsPerChannel %d", dev->format.mBitsPerChannel);
status = AudioUnitSetProperty (dev->outputUnit,
kAudioUnitProperty_StreamFormat,
kAudioUnitScope_Input,
0,
&dev->format,
sizeof(AudioStreamBasicDescription));
if (status != noErr) {
FLUID_LOG (FLUID_ERR, "Error setting the audio format. Status=%ld\n", (long int)status);
goto error_recovery;
}
status = AudioUnitSetProperty (dev->outputUnit,
kAudioUnitProperty_MaximumFramesPerSlice,
kAudioUnitScope_Input,
0,
&dev->buffer_size,
sizeof(unsigned int));
if (status != noErr) {
FLUID_LOG (FLUID_ERR, "Failed to set the MaximumFramesPerSlice. Status=%ld\n", (long int)status);
goto error_recovery;
}
FLUID_LOG (FLUID_DBG, "MaximumFramesPerSlice = %d", dev->buffer_size);
dev->buffers[0] = FLUID_ARRAY(float, dev->buffer_size);
dev->buffers[1] = FLUID_ARRAY(float, dev->buffer_size);
// Initialize the audio unit
status = AudioUnitInitialize(dev->outputUnit);
if (status != noErr) {
FLUID_LOG (FLUID_ERR, "Error calling AudioUnitInitialize(). Status=%ld\n", (long int)status);
goto error_recovery;
}
// Start the rendering
status = AudioOutputUnitStart (dev->outputUnit);
if (status != noErr) {
FLUID_LOG (FLUID_ERR, "Error calling AudioOutputUnitStart(). Status=%ld\n", (long int)status);
goto error_recovery;
}
return (fluid_audio_driver_t*) dev;
error_recovery:
delete_fluid_core_audio_driver((fluid_audio_driver_t*) dev);
return NULL;
}
fluid_audio_driver_t *
new_fluid_portaudio_driver (fluid_settings_t *settings, fluid_synth_t *synth)
{
fluid_portaudio_driver_t *dev = NULL;
PaStreamParameters outputParams;
char *device = NULL;
double sample_rate;
int period_size;
PaError err;
dev = FLUID_NEW (fluid_portaudio_driver_t);
if (dev == NULL)
{
FLUID_LOG (FLUID_ERR, "Out of memory");
return NULL;
}
err = Pa_Initialize ();
if (err != paNoError)
{
FLUID_LOG (FLUID_ERR, "Error initializing PortAudio driver: %s",
Pa_GetErrorText (err));
FLUID_FREE (dev);
return NULL;
}
FLUID_MEMSET (dev, 0, sizeof (fluid_portaudio_driver_t));
dev->synth = synth;
fluid_settings_getint (settings, "audio.period-size", &period_size);
fluid_settings_getnum (settings, "synth.sample-rate", &sample_rate);
fluid_settings_dupstr(settings, "audio.portaudio.device", &device); /* ++ alloc device name */
bzero (&outputParams, sizeof (outputParams));
outputParams.channelCount = 2;
outputParams.suggestedLatency = (PaTime)period_size / sample_rate;
/* Locate the device if specified */
if (strcmp (device, PORTAUDIO_DEFAULT_DEVICE) != 0)
{
const PaDeviceInfo *deviceInfo;
int numDevices;
int i;
numDevices = Pa_GetDeviceCount ();
if (numDevices < 0)
{
FLUID_LOG (FLUID_ERR, "PortAudio returned unexpected device count %d", numDevices);
goto error_recovery;
}
for (i = 0; i < numDevices; i++)
{
deviceInfo = Pa_GetDeviceInfo (i);
if (strcmp (device, deviceInfo->name) == 0)
{
outputParams.device = i;
break;
}
}
if (i == numDevices)
{
FLUID_LOG (FLUID_ERR, "PortAudio device '%s' was not found", device);
goto error_recovery;
}
}
else outputParams.device = Pa_GetDefaultOutputDevice();
if (fluid_settings_str_equal (settings, "audio.sample-format", "16bits"))
{
outputParams.sampleFormat = paInt16;
dev->read = fluid_synth_write_s16;
}
else if (fluid_settings_str_equal (settings, "audio.sample-format", "float"))
{
outputParams.sampleFormat = paFloat32;
dev->read = fluid_synth_write_float;
}
else
{
FLUID_LOG (FLUID_ERR, "Unknown sample format");
goto error_recovery;
}
/* PortAudio section */
/* Open an audio I/O stream. */
err = Pa_OpenStream (&dev->stream,
NULL, /* Input parameters */
&outputParams,
sample_rate,
period_size,
paNoFlag,
fluid_portaudio_run,
dev);
if (err != paNoError)
{
FLUID_LOG (FLUID_ERR, "Error opening PortAudio stream: %s",
Pa_GetErrorText (err));
goto error_recovery;
}
err = Pa_StartStream (dev->stream);
if (err != paNoError)
{
FLUID_LOG (FLUID_ERR, "Error starting PortAudio stream: %s",
Pa_GetErrorText (err));
goto error_recovery;
}
if (device) FLUID_FREE (device); /* -- free device name */
return (fluid_audio_driver_t *)dev;
error_recovery:
if (device) FLUID_FREE (device); /* -- free device name */
delete_fluid_portaudio_driver ((fluid_audio_driver_t *)dev);
return NULL;
}
fluid_audio_driver_t*
new_fluid_dart_audio_driver(fluid_settings_t* settings, fluid_synth_t* synth)
{
fluid_dart_audio_driver_t* dev;
double sample_rate;
int periods, period_size;
UCHAR szFailedName[ 256 ];
MCI_AMP_OPEN_PARMS AmpOpenParms;
int i;
ULONG rc;
dev = FLUID_NEW(fluid_dart_audio_driver_t);
if (dev == NULL) {
FLUID_LOG(FLUID_ERR, "Out of memory");
return NULL;
}
FLUID_MEMSET(dev, 0, sizeof(fluid_dart_audio_driver_t));
fluid_settings_getnum(settings, "synth.sample-rate", &sample_rate);
fluid_settings_getint(settings, "audio.periods", &periods);
fluid_settings_getint(settings, "audio.period-size", &period_size);
/* check the format */
if (!fluid_settings_str_equal(settings, "audio.sample-format", "16bits")) {
FLUID_LOG(FLUID_ERR, "Unhandled sample format");
goto error_recovery;
}
dev->synth = synth;
dev->frame_size = 2 * sizeof(short);
/* Load only once
*/
if( m_hmodMDM == NULLHANDLE )
{
rc = DosLoadModule(szFailedName, sizeof(szFailedName), "MDM", &m_hmodMDM);
if (rc != 0 ) {
FLUID_LOG(FLUID_ERR, "Cannot load MDM.DLL for DART due to %s", szFailedName);
goto error_recovery;
}
rc = DosQueryProcAddr(m_hmodMDM, 1, NULL, (PFN *)&m_pfnmciSendCommand);
if (rc != 0 ) {
FLUID_LOG(FLUID_ERR, "Cannot find mciSendCommand() in MDM.DLL");
DosFreeModule(m_hmodMDM);
m_hmodMDM = NULLHANDLE;
goto error_recovery;
}
}
/* open the mixer device
*/
FLUID_MEMSET(&AmpOpenParms, 0, sizeof(MCI_AMP_OPEN_PARMS));
AmpOpenParms.usDeviceID = (USHORT)0;
AmpOpenParms.pszDeviceType = (PSZ)MCI_DEVTYPE_AUDIO_AMPMIX;
rc = m_pfnmciSendCommand(0, MCI_OPEN,
MCI_WAIT | MCI_OPEN_TYPE_ID | MCI_OPEN_SHAREABLE,
(PVOID)&AmpOpenParms, 0);
if (rc != MCIERR_SUCCESS) {
FLUID_LOG(FLUID_ERR, "Cannot open DART, rc = %lu", rc);
goto error_recovery;
}
dev->usDeviceID = AmpOpenParms.usDeviceID;
/* Set the MixSetupParms data structure to match the requirements.
* This is a global that is used to setup the mixer.
*/
dev->MixSetupParms.ulBitsPerSample = BPS_16;
dev->MixSetupParms.ulFormatTag = MCI_WAVE_FORMAT_PCM;
dev->MixSetupParms.ulSamplesPerSec = sample_rate;
dev->MixSetupParms.ulChannels = 2;
/* Setup the mixer for playback of wave data
*/
dev->MixSetupParms.ulFormatMode = MCI_PLAY;
dev->MixSetupParms.ulDeviceType = MCI_DEVTYPE_WAVEFORM_AUDIO;
dev->MixSetupParms.pmixEvent = fluid_dart_audio_run;
rc = m_pfnmciSendCommand(dev->usDeviceID, MCI_MIXSETUP,
MCI_WAIT | MCI_MIXSETUP_INIT,
(PVOID)&dev->MixSetupParms, 0);
if (rc != MCIERR_SUCCESS) {
FLUID_LOG(FLUID_ERR, "Cannot setup DART, rc = %lu", rc);
goto error_recovery;
}
/* Set up the BufferParms data structure and allocate
* device buffers from the Amp-Mixer
*/
dev->BufferParms.ulNumBuffers = NUM_MIX_BUFS;
dev->BufferParms.ulBufferSize = periods * period_size * dev->frame_size;
dev->BufferParms.pBufList = dev->MixBuffers;
rc = m_pfnmciSendCommand(dev->usDeviceID, MCI_BUFFER,
MCI_WAIT | MCI_ALLOCATE_MEMORY,
(PVOID)&dev->BufferParms, 0);
if ((USHORT)rc != MCIERR_SUCCESS) {
FLUID_LOG(FLUID_ERR, "Cannot allocate memory for DART, rc = %lu", rc);
goto error_recovery;
}
/* Initialize all device buffers.
*/
for (i = 0; i < NUM_MIX_BUFS; i++) {
FLUID_MEMSET(dev->MixBuffers[i].pBuffer, 0, dev->BufferParms.ulBufferSize);
dev->MixBuffers[i].ulBufferLength = dev->BufferParms.ulBufferSize;
dev->MixBuffers[i].ulFlags = 0;
dev->MixBuffers[i].ulUserParm = (ULONG)dev;
fluid_synth_write_s16(dev->synth, dev->MixBuffers[i].ulBufferLength / dev->frame_size,
dev->MixBuffers[i].pBuffer, 0, 2, dev->MixBuffers[i].pBuffer, 1, 2 );
}
/* Write buffers to kick off the amp mixer.
*/
dev->MixSetupParms.pmixWrite(dev->MixSetupParms.ulMixHandle,
dev->MixBuffers,
NUM_MIX_BUFS);
return (fluid_audio_driver_t*) dev;
error_recovery:
delete_fluid_dart_audio_driver((fluid_audio_driver_t*) dev);
return NULL;
}
/*
* 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;
}
fluid_audio_driver_t *
new_fluid_portaudio_driver2 (fluid_settings_t *settings, fluid_audio_func_t func, void* data)
{
fluid_portaudio_driver_t *dev = NULL;
PaStreamParameters outputParams;
char *device = NULL;
double sample_rate;
int period_size;
PaError err;
int numOutputs = 2;
dev = FLUID_NEW (fluid_portaudio_driver_t);
if (dev == NULL)
{
FLUID_LOG (FLUID_ERR, "Out of memory");
return NULL;
}
err = Pa_Initialize ();
if (err != paNoError)
{
FLUID_LOG (FLUID_ERR, "Error initializing PortAudio driver: %s",
Pa_GetErrorText (err));
FLUID_FREE (dev);
return NULL;
}
FLUID_MEMSET (dev, 0, sizeof (fluid_portaudio_driver_t));
dev->data = data;
dev->callback = func;
bzero (&outputParams, sizeof (outputParams));
fluid_settings_getint (settings, "audio.period-size", &period_size);
fluid_settings_getnum (settings, "synth.sample-rate", &sample_rate);
fluid_settings_dupstr(settings, "audio.portaudio.device", &device); /* ++ alloc device name */
/* Locate the device if specified */
if (strcmp (device, PORTAUDIO_DEFAULT_DEVICE) != 0)
{
const PaDeviceInfo *deviceInfo;
int numDevices;
int i;
numDevices = Pa_GetDeviceCount ();
if (numDevices < 0)
{
FLUID_LOG (FLUID_ERR, "PortAudio returned unexpected device count %d", numDevices);
goto error_recovery;
}
for (i = 0; i < numDevices; i++)
{
deviceInfo = Pa_GetDeviceInfo (i);
if (strcmp (device, deviceInfo->name) == 0)
{
outputParams.device = i;
numOutputs = deviceInfo->maxOutputChannels;
break;
}
}
if (i == numDevices)
{
FLUID_LOG (FLUID_ERR, "PortAudio device '%s' was not found", device);
goto error_recovery;
}
}
else outputParams.device = Pa_GetDefaultOutputDevice();
fluid_settings_getint(settings, "audio.portaudio.channelL", &(dev->chanL));
fluid_settings_getint(settings, "audio.portaudio.channelR", &(dev->chanR));
dev->chansOpen = 1 + ((dev->chanL > dev->chanR) ? dev->chanL : dev->chanR);
if (dev->chansOpen > numOutputs) {
// error
FLUID_LOG (FLUID_ERR, "One specified channel is greater than the maximum number of channels: L=%d, R=%d, max=%d\n", dev->chanL, dev->chanR, numOutputs-1);
goto error_recovery;
}
dev->buffer_size = period_size;
dev->buffers[0] = FLUID_ARRAY(float, dev->buffer_size);
dev->buffers[1] = FLUID_ARRAY(float, dev->buffer_size);
outputParams.channelCount = dev->chansOpen;
outputParams.suggestedLatency = (PaTime)period_size / sample_rate;
// force float format
outputParams.sampleFormat = paFloat32;
/* PortAudio section */
/* Open an audio I/O stream. */
err = Pa_OpenStream (&dev->stream,
NULL, /* Input parameters */
&outputParams,
sample_rate,
period_size,
paNoFlag,
fluid_portaudio_run,
dev);
if (err != paNoError)
{
FLUID_LOG (FLUID_ERR, "Error opening PortAudio stream: %s",
Pa_GetErrorText (err));
goto error_recovery;
}
err = Pa_StartStream (dev->stream);
if (err != paNoError)
{
FLUID_LOG (FLUID_ERR, "Error starting PortAudio stream: %s",
Pa_GetErrorText (err));
goto error_recovery;
}
if (device) FLUID_FREE (device); /* -- free device name */
return (fluid_audio_driver_t *)dev;
error_recovery:
if (device) FLUID_FREE (device); /* -- free device name */
delete_fluid_portaudio_driver ((fluid_audio_driver_t *)dev);
return NULL;
}
/*
* new_fluid_sndio_audio_driver
*/
fluid_audio_driver_t*
new_fluid_sndio_audio_driver(fluid_settings_t* settings, fluid_synth_t* synth)
{
fluid_sndio_audio_driver_t* dev = NULL;
double sample_rate;
int periods, period_size;
char* devname;
pthread_attr_t attr;
int err;
dev = FLUID_NEW(fluid_sndio_audio_driver_t);
if (dev == NULL) {
FLUID_LOG(FLUID_ERR, "Out of memory");
return NULL;
}
FLUID_MEMSET(dev, 0, sizeof(fluid_sndio_audio_driver_t));
fluid_settings_getint(settings, "audio.periods", &periods);
fluid_settings_getint(settings, "audio.period-size", &period_size);
fluid_settings_getnum(settings, "synth.sample-rate", &sample_rate);
dev->hdl = NULL;
dev->synth = synth;
dev->callback = NULL;
dev->data = NULL;
dev->cont = 1;
if (!fluid_settings_dupstr(settings, "audio.sndio.device", &devname)) {
devname = NULL;
}
dev->hdl = sio_open(devname, SIO_PLAY, 0);
if (dev->hdl == NULL) {
FLUID_LOG(FLUID_ERR, "sndio could not be opened for writing");
goto error_recovery;
}
sio_initpar(&dev->par);
if (fluid_settings_str_equal(settings, "audio.sample-format", "16bits")) {
dev->par.bits = 16;
dev->par.le = SIO_LE_NATIVE;
dev->read = fluid_synth_write_s16;
} else {
FLUID_LOG(FLUID_ERR, "Unknown sample format");
goto error_recovery;
}
dev->par.appbufsz = period_size * periods;
dev->par.round = period_size;
dev->par.pchan = 2;
dev->par.rate = sample_rate;
if (!sio_setpar(dev->hdl, &dev->par)) {
FLUID_LOG(FLUID_ERR, "Couldn't set sndio audio parameters");
goto error_recovery;
}
if (!sio_getpar(dev->hdl, &dev->par)) {
FLUID_LOG(FLUID_ERR, "Couldn't get sndio audio parameters");
goto error_recovery;
} else if (dev->par.pchan != 2 || dev->par.rate != sample_rate ||
dev->par.bits != 16) {
FLUID_LOG(FLUID_ERR, "Couldn't set sndio audio parameters as desired");
goto error_recovery;
}
dev->buffer_size = dev->par.round;
dev->buffer_byte_size = dev->par.round * dev->par.bps * dev->par.pchan;
dev->buffer = FLUID_MALLOC(dev->buffer_byte_size);
if (dev->buffer == NULL) {
FLUID_LOG(FLUID_ERR, "Out of memory");
goto error_recovery;
}
if (!sio_start(dev->hdl)) {
FLUID_LOG(FLUID_ERR, "Couldn't start sndio");
goto error_recovery;
}
if (pthread_attr_init(&attr)) {
FLUID_LOG(FLUID_ERR, "Couldn't initialize audio thread attributes");
goto error_recovery;
}
err = pthread_create(&dev->thread, &attr, fluid_sndio_audio_run, (void*) dev);
if (err) {
FLUID_LOG(FLUID_ERR, "Couldn't create audio thread");
goto error_recovery;
}
return (fluid_audio_driver_t*) dev;
error_recovery:
delete_fluid_sndio_audio_driver((fluid_audio_driver_t*) dev);
return NULL;
}
fluid_audio_driver_t*
new_fluid_sndio_audio_driver2(fluid_settings_t* settings, fluid_audio_func_t func, void* data)
{
fluid_sndio_audio_driver_t* dev = NULL;
double sample_rate;
int periods, period_size;
char* devname;
pthread_attr_t attr;
int err;
dev = FLUID_NEW(fluid_sndio_audio_driver_t);
if (dev == NULL) {
FLUID_LOG(FLUID_ERR, "Out of memory");
return NULL;
}
FLUID_MEMSET(dev, 0, sizeof(fluid_sndio_audio_driver_t));
fluid_settings_getint(settings, "audio.periods", &periods);
fluid_settings_getint(settings, "audio.period-size", &period_size);
fluid_settings_getnum(settings, "synth.sample-rate", &sample_rate);
dev->hdl = NULL;
dev->synth = NULL;
dev->read = NULL;
dev->callback = func;
dev->data = data;
dev->cont = 1;
if (!fluid_settings_dupstr(settings, "audio.sndio.device", &devname)) {
devname = NULL;
}
dev->hdl = sio_open(devname, SIO_PLAY, 0);
if (dev->hdl == NULL) {
FLUID_LOG(FLUID_ERR, "sndio could not be opened for writing");
goto error_recovery;
}
sio_initpar(&dev->par);
dev->par.appbufsz = period_size * periods;
dev->par.round = period_size;
dev->par.bits = 16;
dev->par.le = SIO_LE_NATIVE;
dev->par.pchan = 2;
dev->par.rate = sample_rate;
if (!sio_setpar(dev->hdl, &dev->par)){
FLUID_LOG(FLUID_ERR, "Can't configure sndio parameters");
goto error_recovery;
}
if (!sio_getpar(dev->hdl, &dev->par)) {
FLUID_LOG(FLUID_ERR, "Couldn't get sndio audio parameters");
goto error_recovery;
} else if (dev->par.pchan != 2 || dev->par.rate != sample_rate ||
dev->par.bits != 16) {
FLUID_LOG(FLUID_ERR, "Couldn't set sndio audio parameters as desired");
goto error_recovery;
}
dev->buffer_size = dev->par.round;
dev->buffer_byte_size = dev->par.round * dev->par.bps * dev->par.pchan;
/* allocate the buffers. FIXME!!! don't use interleaved samples */
dev->buffer = FLUID_MALLOC(dev->buffer_byte_size);
if (dev->buffer == NULL) {
FLUID_LOG(FLUID_ERR, "Out of memory");
goto error_recovery;
}
dev->buffers[0] = FLUID_ARRAY(float, dev->buffer_size);
dev->buffers[1] = FLUID_ARRAY(float, dev->buffer_size);
if ((dev->buffer == NULL) || (dev->buffers[0] == NULL) || (dev->buffers[1] == NULL)) {
FLUID_LOG(FLUID_ERR, "Out of memory");
goto error_recovery;
}
if (!sio_start(dev->hdl)) {
FLUID_LOG(FLUID_ERR, "Couldn't start sndio");
goto error_recovery;
}
if (pthread_attr_init(&attr)) {
FLUID_LOG(FLUID_ERR, "Couldn't initialize audio thread attributes");
goto error_recovery;
}
err = pthread_create(&dev->thread, &attr, fluid_sndio_audio_run2, (void*) dev);
if (err) {
FLUID_LOG(FLUID_ERR, "Couldn't create audio2 thread");
goto error_recovery;
}
return (fluid_audio_driver_t*) dev;
error_recovery:
delete_fluid_sndio_audio_driver((fluid_audio_driver_t*) dev);
return NULL;
}
static int midoflus_init(void *arg)
{
int ret;
char *sfont;
char *def_sfonts[] = {
"/usr/share/soundfonts/default.sf2", // fedora
"/usr/share/soundfonts/FluidR3_GM.sf2", // fedora
"/usr/share/sounds/sf2/FluidR3_GM.sf2.flac", // ubuntu
"/usr/share/sounds/sf2/FluidR3_GM.sf2", // debian
NULL };
int use_defsf = 0;
settings = new_fluid_settings();
fluid_settings_setint(settings, "synth.lock-memory", 0);
fluid_settings_setnum(settings, "synth.gain", flus_gain);
ret = fluid_settings_setint(settings, "synth.threadsafe-api", 1);
if (ret == 0) {
warn("fluidsynth: no threadsafe API\n");
goto err1;
}
ret = fluid_settings_getnum(settings, "synth.sample-rate", &flus_srate);
if (ret == 0) {
warn("fluidsynth: cannot get samplerate\n");
goto err1;
}
ret = fluid_settings_getstr(settings, "synth.default-soundfont", &sfont);
if (ret == 0) {
int i = 0;
warn("Your fluidsynth is too old\n");
while (def_sfonts[i]) {
if (access(def_sfonts[i], R_OK) == 0) {
sfont = def_sfonts[i];
use_defsf = 1;
break;
}
i++;
}
if (!use_defsf) {
error("Your fluidsynth is too old and soundfonts not found\n");
goto err1;
}
}
synth = new_fluid_synth(settings);
ret = fluid_synth_sfload(synth, sfont, TRUE);
if (ret == FLUID_FAILED) {
warn("fluidsynth: cannot load soundfont %s\n", sfont);
if (use_defsf)
error("Your fluidsynth is too old\n");
goto err2;
}
fluid_settings_setstr(settings, "synth.midi-bank-select", "gm");
S_printf("fluidsynth: loaded soundfont %s ID=%i\n", sfont, ret);
sequencer = new_fluid_sequencer2(0);
synthSeqID = fluid_sequencer_register_fluidsynth2(sequencer, synth);
sem_init(&syn_sem, 0, 0);
pthread_create(&syn_thr, NULL, synth_thread, NULL);
#ifdef HAVE_PTHREAD_SETNAME_NP
pthread_setname_np(syn_thr, "dosemu: fluid");
#endif
pcm_stream = pcm_allocate_stream(FLUS_CHANNELS, "MIDI",
(void*)MC_MIDI);
return 1;
err2:
delete_fluid_synth(synth);
err1:
delete_fluid_settings(settings);
return 0;
}
/*
* new_fluid_dsound_audio_driver
*/
fluid_audio_driver_t*
new_fluid_dsound_audio_driver(fluid_settings_t* settings, fluid_synth_t* synth)
{
HRESULT hr;
DSBUFFERDESC desc;
fluid_dsound_audio_driver_t* dev = NULL;
DSCAPS caps;
char *buf1;
DWORD bytes1;
double sample_rate;
int periods, period_size;
fluid_dsound_devsel_t devsel;
/* check if the globals are initialized */
if (FLUID_HINSTANCE == NULL) {
FLUID_LOG(FLUID_ERR, "FluidSynth hinstance not set, which is needed for DirectSound");
return NULL;
}
/*
if (fluid_wnd == NULL) {
if (fluid_win32_create_window() != 0) {
FLUID_LOG(FLUID_ERR, "Couldn't create window needed for DirectSound");
return NULL;
}
}
*/
/* create and clear the driver data */
dev = FLUID_NEW(fluid_dsound_audio_driver_t);
if (dev == NULL) {
FLUID_LOG(FLUID_ERR, "Out of memory");
return NULL;
}
FLUID_MEMSET(dev, 0, sizeof(fluid_dsound_audio_driver_t));
dev->synth = synth;
dev->cont = 1;
fluid_settings_getnum(settings, "synth.sample-rate", &sample_rate);
fluid_settings_getint(settings, "audio.periods", &periods);
fluid_settings_getint(settings, "audio.period-size", &period_size);
/* check the format */
if (!fluid_settings_str_equal(settings, "audio.sample-format", "16bits")) {
FLUID_LOG(FLUID_ERR, "Unhandled sample format");
goto error_recovery;
}
dev->frame_size = 2 * sizeof(short);
dev->buffer_byte_size = period_size * dev->frame_size;
dev->queue_byte_size = periods * dev->buffer_byte_size;
dev->write = fluid_synth_write_s16;
/* create and initialize the buffer format */
dev->format = (WAVEFORMATEX*) FLUID_MALLOC(sizeof(WAVEFORMATEX));
if (dev->format == NULL) {
FLUID_LOG(FLUID_ERR, "Out of memory");
goto error_recovery;
}
ZeroMemory(dev->format, sizeof(WAVEFORMATEX));
dev->format->wFormatTag = WAVE_FORMAT_PCM;
dev->format->nChannels = 2;
dev->format->wBitsPerSample = 16;
dev->format->nSamplesPerSec = (DWORD) sample_rate;
dev->format->nBlockAlign = (WORD) dev->frame_size;
dev->format->nAvgBytesPerSec = dev->format->nSamplesPerSec * dev->frame_size;
dev->format->cbSize = 0;
devsel.devGUID = NULL;
/* get the selected device name. if none is specified, use NULL for the default device. */
if(fluid_settings_dupstr(settings, "audio.dsound.device", &devsel.devname) == FLUID_OK /* ++ alloc device name */
&& devsel.devname && strlen (devsel.devname) > 0) {
/* look for the GUID of the selected device */
DirectSoundEnumerate((LPDSENUMCALLBACK) fluid_dsound_enum_callback2, (void *)&devsel);
}
if (devsel.devname) FLUID_FREE (devsel.devname); /* -- free device name */
/* open DirectSound */
hr = DirectSoundCreate(devsel.devGUID, &dev->direct_sound, NULL);
if (hr != DS_OK) {
FLUID_LOG(FLUID_ERR, "Failed to create the DirectSound object");
goto error_recovery;
}
hr = IDirectSound_SetCooperativeLevel(dev->direct_sound, fluid_win32_get_window(), DSSCL_PRIORITY);
if (hr != DS_OK) {
FLUID_LOG(FLUID_ERR, "Failed to set the cooperative level");
goto error_recovery;
}
caps.dwSize = sizeof(caps);
hr = IDirectSound_GetCaps(dev->direct_sound, &caps);
if (hr != DS_OK) {
FLUID_LOG(FLUID_ERR, "Failed to query the device capacities");
goto error_recovery;
}
/* create primary buffer */
ZeroMemory(&desc, sizeof(DSBUFFERDESC));
desc.dwSize = sizeof(DSBUFFERDESC);
desc.dwFlags = DSBCAPS_PRIMARYBUFFER;
if (caps.dwFreeHwMixingStreamingBuffers > 0) {
desc.dwFlags |= DSBCAPS_LOCHARDWARE;
}
hr = IDirectSound_CreateSoundBuffer(dev->direct_sound, &desc, &dev->prim_buffer, NULL);
if (hr != DS_OK) {
FLUID_LOG(FLUID_ERR, "Failed to allocate the primary buffer");
goto error_recovery;
}
/* set the primary sound buffer to this format. if it fails, just
print a warning. */
hr = IDirectSoundBuffer_SetFormat(dev->prim_buffer, dev->format);
if (hr != DS_OK) {
FLUID_LOG(FLUID_WARN, "Can't set format of primary sound buffer", fluid_win32_error(hr));
}
/* initialize the buffer description */
ZeroMemory(&desc, sizeof(DSBUFFERDESC));
desc.dwSize = sizeof(DSBUFFERDESC);
desc.dwFlags = DSBCAPS_GLOBALFOCUS | DSBCAPS_GETCURRENTPOSITION2;
desc.lpwfxFormat = dev->format;
desc.dwBufferBytes = dev->queue_byte_size;
desc.dwReserved = 0;
if (caps.dwFreeHwMixingStreamingBuffers > 0) {
desc.dwFlags |= DSBCAPS_LOCHARDWARE;
}
/* create the secondary sound buffer */
hr = IDirectSound_CreateSoundBuffer(dev->direct_sound, &desc, &dev->sec_buffer, NULL);
if (hr != DS_OK) {
FLUID_LOG(FLUID_ERR, "dsound: Can't create sound buffer: %s", fluid_win32_error(hr));
goto error_recovery;
}
/* Lock */
hr = IDirectSoundBuffer_Lock(dev->sec_buffer, 0, 0, (void*) &buf1, &bytes1, 0, 0, DSBLOCK_ENTIREBUFFER);
if ((hr != DS_OK) || (buf1 == NULL)) {
FLUID_LOG(FLUID_PANIC, "Failed to lock the audio buffer. Exiting.");
goto error_recovery;
}
/* fill the buffer with silence */
memset(buf1, 0, bytes1);
/* Unlock */
IDirectSoundBuffer_Unlock(dev->sec_buffer, buf1, bytes1, 0, 0);
/* start the audio thread */
dev->thread = CreateThread(NULL, 0, &fluid_dsound_audio_run, (LPVOID) dev, 0, &dev->threadID);
if (dev->thread == NULL) {
goto error_recovery;
}
return (fluid_audio_driver_t*) dev;
error_recovery:
delete_fluid_dsound_audio_driver((fluid_audio_driver_t*) dev);
return NULL;
}