void ann::set_num_outputs(int num_outputs)
{
int curr_num_outputs = 0;
get_num_outputs(curr_num_outputs);
if (num_outputs == curr_num_outputs)
{
return;
}
const data_type data_type = get_data_type();
if (num_outputs < 0)
{
flext::error("number of outputs must be greater than zero");
}
if (data_type == LABELLED_CLASSIFICATION && num_outputs > 1)
{
flext::error("for classification mode, number of outputs must be 1, for multidimensional output switch mode to %d", LABELLED_REGRESSION);
return;
}
if (data_type == LABELLED_REGRESSION)
{
bool success = regression_data.setInputAndTargetDimensions(regression_data.getNumInputDimensions(), num_outputs);
if (success == false)
{
flext::error("unable to set input and target dimensions");
return;
}
}
}
void
fluid_core_audio_driver_settings(fluid_settings_t* settings)
{
int i;
UInt32 size;
AudioObjectPropertyAddress pa;
pa.mSelector = kAudioHardwarePropertyDevices;
pa.mScope = kAudioObjectPropertyScopeWildcard;
pa.mElement = kAudioObjectPropertyElementMaster;
fluid_settings_register_str (settings, "audio.coreaudio.device", "default", 0, NULL, NULL);
fluid_settings_add_option (settings, "audio.coreaudio.device", "default");
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) {
fluid_settings_add_option (settings, "audio.coreaudio.device", name);
}
}
}
}
}
}
t_CKBOOL miniAudicle::set_dac( t_CKUINT dac )
{
#ifndef __CHIP_MODE__
// sanity check
if( dac > interfaces.size() )
return FALSE;
else
vm_options.dac = dac;
// set parameters to a reasonable value, if necessary
set_num_outputs( get_num_outputs() );
#endif // __CHIP_MODE__
return TRUE;
}
/*
* 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;
}