size_t CoreAudioBackend::_max_buffer_size = 8192;
std::vector<std::string> CoreAudioBackend::_midi_options;
std::vector<AudioBackend::DeviceStatus> CoreAudioBackend::_audio_device_status;
-std::vector<AudioBackend::DeviceStatus> CoreAudioBackend::_midi_device_status;
/* static class instance access */
, _freewheel_ack (false)
, _reinit_thread_callback (false)
, _measure_latency (false)
+ , _last_process_start (0)
, _audio_device("")
, _midi_driver_option(_("None"))
, _samplerate (48000)
return 0;
}
-int
-CoreAudioBackend::set_systemic_midi_input_latency (std::string const device, uint32_t sl)
-{
- struct CoreMidiDeviceInfo * nfo = midi_device_info(device);
- if (!nfo) return -1;
- nfo->systemic_input_latency = sl;
- return 0;
-}
-
-int
-CoreAudioBackend::set_systemic_midi_output_latency (std::string const device, uint32_t sl)
-{
- struct CoreMidiDeviceInfo * nfo = midi_device_info(device);
- if (!nfo) return -1;
- nfo->systemic_output_latency = sl;
- return 0;
-}
-
/* Retrieving parameters */
std::string
CoreAudioBackend::device_name () const
return _systemic_audio_output_latency;
}
-uint32_t
-CoreAudioBackend::systemic_midi_input_latency (std::string const device) const
-{
- struct CoreMidiDeviceInfo * nfo = midi_device_info(device);
- if (!nfo) return 0;
- return nfo->systemic_input_latency;
-}
-
-uint32_t
-CoreAudioBackend::systemic_midi_output_latency (std::string const device) const
-{
- struct CoreMidiDeviceInfo * nfo = midi_device_info(device);
- if (!nfo) return 0;
- return nfo->systemic_output_latency;
-}
-
/* MIDI */
-struct CoreAudioBackend::CoreMidiDeviceInfo *
-CoreAudioBackend::midi_device_info(std::string const name) const {
- return 0;
-}
std::vector<std::string>
CoreAudioBackend::enumerate_midi_options () const
return _midi_options;
}
-std::vector<AudioBackend::DeviceStatus>
-CoreAudioBackend::enumerate_midi_devices () const
-{
- _midi_device_status.clear();
- std::map<std::string, std::string> devices;
- //_midi_device_status.push_back (DeviceStatus (_("CoreMidi"), true));
- return _midi_device_status;
-}
-
int
CoreAudioBackend::set_midi_option (const std::string& opt)
{
return _midi_driver_option;
}
-int
-CoreAudioBackend::set_midi_device_enabled (std::string const device, bool enable)
-{
- struct CoreMidiDeviceInfo * nfo = midi_device_info(device);
- if (!nfo) return -1;
- nfo->enabled = enable;
- return 0;
-}
-
-bool
-CoreAudioBackend::midi_device_enabled (std::string const device) const
-{
- struct CoreMidiDeviceInfo * nfo = midi_device_info(device);
- if (!nfo) return false;
- return nfo->enabled;
-}
-
void
CoreAudioBackend::launch_control_app ()
{
return 0;
}
-static int process_callback_ptr (void *arg)
+static int process_callback_ptr (void *arg, const uint32_t n_samples, const uint64_t host_time)
{
CoreAudioBackend *d = static_cast<CoreAudioBackend*> (arg);
- return d->process_callback();
+ return d->process_callback(n_samples, host_time);
}
int
_freewheel_ack = false;
_reinit_thread_callback = true;
+ _last_process_start = 0;
_pcmio->set_error_callback (error_callback_ptr, this);
_pcmio->set_buffer_size_callback (buffer_size_callback_ptr, this);
pframes_t
CoreAudioBackend::samples_since_cycle_start ()
{
- return 0;
+ if (!_active_ca || !_run || _freewheeling || _freewheel) {
+ return 0;
+ }
+ if (_last_process_start == 0) {
+ return 0;
+ }
+
+ const uint64_t now = AudioGetCurrentHostTime ();
+ const int64_t elapsed_time_ns = AudioConvertHostTimeToNanos(now - _last_process_start);
+ return std::max((pframes_t)0, (pframes_t)rint(1e-9 * elapsed_time_ns * _samplerate));
}
uint32_t
PBD::error << _("CoreBackendPort::get_latency_range (): invalid port.") << endmsg;
r.min = 0;
r.max = 0;
+ return r;
}
CoreBackendPort* p = static_cast<CoreBackendPort*>(port);
assert(p);
static_cast<CoreMidiBuffer*>((*it)->get_buffer(0))->clear ();
}
+ _last_process_start = 0;
if (engine.process_callback (_samples_per_period)) {
pthread_mutex_unlock (&_process_callback_mutex);
break;
}
int
-CoreAudioBackend::process_callback ()
+CoreAudioBackend::process_callback (const uint32_t n_samples, const uint64_t host_time)
{
uint32_t i = 0;
uint64_t clock1, clock2;
return 1;
}
- if (pthread_mutex_trylock (&_process_callback_mutex)) {
- // block while devices are added/removed
- return 1;
- }
-
if (_reinit_thread_callback || _main_thread != pthread_self()) {
_reinit_thread_callback = false;
_main_thread = pthread_self();
AudioEngine::thread_init_callback (this);
}
+ if (pthread_mutex_trylock (&_process_callback_mutex)) {
+ // block while devices are added/removed
+#ifndef NDEBUG
+ printf("Xrun due to device change\n");
+#endif
+ engine.Xrun();
+ return 1;
+ }
/* port-connection change */
pre_process();
- const uint32_t n_samples = _pcmio->n_samples();
-
// cycle-length in usec
- const int64_t nominal_time = 1e6 * n_samples / _samplerate;
+ const double nominal_time = 1e6 * n_samples / _samplerate;
clock1 = g_get_monotonic_time();
CoreMidiBuffer* mbuf = static_cast<CoreMidiBuffer*>((*it)->get_buffer(0));
mbuf->clear();
uint64_t time_ns;
- uint8_t data[64]; // match MaxAlsaEventSize in alsa_rawmidi.cc
+ uint8_t data[128]; // matches CoreMidi's MIDIPacket
size_t size = sizeof(data);
while (_midiio->recv_event (i, nominal_time, time_ns, data, size)) {
pframes_t time = floor((float) time_ns * _samplerate * 1e-9);
}
_midiio->start_cycle();
+ _last_process_start = host_time;
if (engine.process_callback (n_samples)) {
fprintf(stderr, "ENGINE PROCESS ERROR\n");
/* queue outgoing midi */
i = 0;
for (std::vector<CoreBackendPort*>::const_iterator it = _system_midi_out.begin (); it != _system_midi_out.end (); ++it, ++i) {
+#if 0 // something's still b0rked with CoreMidiIo::send_events()
+ const CoreMidiBuffer *src = static_cast<const CoreMidiPort*>(*it)->const_buffer();
+ _midiio->send_events (i, nominal_time, (void*)src);
+#else // works..
const CoreMidiBuffer *src = static_cast<const CoreMidiPort*>(*it)->const_buffer();
for (CoreMidiBuffer::const_iterator mit = src->begin (); mit != src->end (); ++mit) {
_midiio->send_event (i, (*mit)->timestamp() / nominal_time, (*mit)->data(), (*mit)->size());
}
+#endif
}
/* write back audio */
/* calc DSP load. */
clock2 = g_get_monotonic_time();
const int64_t elapsed_time = clock2 - clock1;
- _dsp_load = elapsed_time / (float) nominal_time;
+ _dsp_load = elapsed_time / nominal_time;
pthread_mutex_unlock (&_process_callback_mutex);
return 0;