smokephil/ardour
1
0
Fork 0
mirror of https://github.com/Ardour/ardour.git synced 2025-12-08 15:54:57 +01:00
Code Issues Projects Releases Wiki Activity

cont’d work on the coreaudio backend & cleanup

Browse source
This commit is contained in:
Robin Gareus 2015-03-06 03:21:47 +01:00
parent 408090adce
commit 6b87e706eb
7 changed files with 854 additions and 319 deletions
Download patch file Download diff file Expand all files Collapse all files

121
libs/backends/coreaudio/coreaudio_backend.cc
View file

@ -41,6 +41,13 @@ std::vector<std::string> CoreAudioBackend::_midi_options;
std::vector<AudioBackend::DeviceStatus> CoreAudioBackend::_audio_device_status; std::vector<AudioBackend::DeviceStatus> CoreAudioBackend::_audio_device_status;
std::vector<AudioBackend::DeviceStatus> CoreAudioBackend::_midi_device_status; std::vector<AudioBackend::DeviceStatus> CoreAudioBackend::_midi_device_status;
static void hw_changed_callback_ptr (void *arg)
{
CoreAudioBackend *d = static_cast<CoreAudioBackend*> (arg);
d->hw_changed_callback();
}
CoreAudioBackend::CoreAudioBackend (AudioEngine& e, AudioBackendInfo& info) CoreAudioBackend::CoreAudioBackend (AudioEngine& e, AudioBackendInfo& info)
: AudioBackend (e, info) : AudioBackend (e, info)
, _run (false) , _run (false)
@ -70,6 +77,7 @@ CoreAudioBackend::CoreAudioBackend (AudioEngine& e, AudioBackendInfo& info)
_pcmio = new CoreAudioPCM (); _pcmio = new CoreAudioPCM ();
_midiio = new CoreMidiIo (); _midiio = new CoreMidiIo ();
_pcmio->set_hw_changed_callback (hw_changed_callback_ptr, this);
_pcmio->discover(); _pcmio->discover();
_midiio->discover(); _midiio->discover();
} }
@ -114,25 +122,16 @@ CoreAudioBackend::enumerate_devices () const
std::vector<float> std::vector<float>
CoreAudioBackend::available_sample_rates (const std::string&) const CoreAudioBackend::available_sample_rates (const std::string&) const
{ {
// TODO ask _pcmio for available rates
std::vector<float> sr; std::vector<float> sr;
sr.push_back (44100.0); _pcmio->available_sample_rates(name_to_id(_audio_device), sr);
sr.push_back (48000.0);
return sr; return sr;
} }
std::vector<uint32_t> std::vector<uint32_t>
CoreAudioBackend::available_buffer_sizes (const std::string&) const CoreAudioBackend::available_buffer_sizes (const std::string&) const
{ {
// TODO ask _pcmio for available rates
std::vector<uint32_t> bs; std::vector<uint32_t> bs;
bs.push_back (64); _pcmio->available_buffer_sizes(name_to_id(_audio_device), bs);
bs.push_back (128);
bs.push_back (256);
bs.push_back (512);
bs.push_back (1024);
bs.push_back (2048);
bs.push_back (4096);
return bs; return bs;
} }
@ -164,6 +163,8 @@ int
CoreAudioBackend::set_device_name (const std::string& d) CoreAudioBackend::set_device_name (const std::string& d)
{ {
_audio_device = d; _audio_device = d;
const float sr = _pcmio->current_sample_rate(name_to_id(_audio_device));
if (sr > 0) { set_sample_rate(sr); }
return 0; return 0;
} }
@ -171,6 +172,7 @@ int
CoreAudioBackend::set_sample_rate (float sr) CoreAudioBackend::set_sample_rate (float sr)
{ {
if (sr <= 0) { return -1; } if (sr <= 0) { return -1; }
// TODO check if it's in the list of valid SR
_samplerate = sr; _samplerate = sr;
engine.sample_rate_change (sr); engine.sample_rate_change (sr);
return 0; return 0;
@ -363,6 +365,12 @@ CoreAudioBackend::midi_device_enabled (std::string const device) const
return nfo->enabled; return nfo->enabled;
} }
void
CoreAudioBackend::launch_control_app ()
{
_pcmio->launch_control_app(name_to_id(_audio_device));
}
/* State Control */ /* State Control */
static void * pthread_freewheel (void *arg) static void * pthread_freewheel (void *arg)
@ -391,7 +399,6 @@ static void midi_port_change (void *arg)
d->coremidi_rediscover (); d->coremidi_rediscover ();
} }
int int
CoreAudioBackend::_start (bool for_latency_measurement) CoreAudioBackend::_start (bool for_latency_measurement)
{ {
@ -414,21 +421,7 @@ CoreAudioBackend::_start (bool for_latency_measurement)
_ports.clear(); _ports.clear();
} }
#if 0 uint32_t device_id = name_to_id(_audio_device);
assert(_rmidi_in.size() == 0);
assert(_rmidi_out.size() == 0);
#endif
uint32_t device_id = UINT32_MAX;
std::map<size_t, std::string> devices;
_pcmio->device_list(devices);
for (std::map<size_t, std::string>::const_iterator i = devices.begin (); i != devices.end(); ++i) {
if (i->second == _audio_device) {
device_id = i->first;
break;
}
}
assert(_active_ca == false); assert(_active_ca == false);
assert(_active_fw == false); assert(_active_fw == false);
@ -485,11 +478,8 @@ CoreAudioBackend::_start (bool for_latency_measurement)
_run = true; _run = true;
_port_change_flag = false; _port_change_flag = false;
printf("MIDI: %s\n", _midi_driver_option.c_str());
if (_midi_driver_option == _("CoreMidi")) { if (_midi_driver_option == _("CoreMidi")) {
//register_system_midi_ports(); _midiio->set_port_changed_callback(midi_port_change, this);
_midiio->setPortChangedCallback(midi_port_change, this);
_midiio->discover(); _midiio->discover();
} }
@ -510,7 +500,6 @@ CoreAudioBackend::_start (bool for_latency_measurement)
engine.reconnect_ports (); engine.reconnect_ports ();
if (pthread_create (&_freeewheel_thread, NULL, pthread_freewheel, this)) if (pthread_create (&_freeewheel_thread, NULL, pthread_freewheel, this))
{ {
PBD::error << _("CoreAudioBackend: failed to create process thread.") << endmsg; PBD::error << _("CoreAudioBackend: failed to create process thread.") << endmsg;
@ -523,13 +512,11 @@ CoreAudioBackend::_start (bool for_latency_measurement)
while ((!_active_ca || !_active_fw) && --timeout > 0) { Glib::usleep (1000); } while ((!_active_ca || !_active_fw) && --timeout > 0) { Glib::usleep (1000); }
if (timeout == 0) { if (timeout == 0) {
printf("CoreAudioBackend: failed to start.");
PBD::error << _("CoreAudioBackend: failed to start.") << endmsg; PBD::error << _("CoreAudioBackend: failed to start.") << endmsg;
} }
if (!_active_fw) { if (!_active_fw) {
PBD::error << _("CoreAudioBackend: failed to start freewheeling thread.") << endmsg; PBD::error << _("CoreAudioBackend: failed to start freewheeling thread.") << endmsg;
printf("CoreAudioBackend: fw .\n");
_run = false; _run = false;
_pcmio->pcm_stop(); _pcmio->pcm_stop();
unregister_ports(); unregister_ports();
@ -539,7 +526,6 @@ CoreAudioBackend::_start (bool for_latency_measurement)
} }
if (!_active_ca) { if (!_active_ca) {
printf("CoreAudioBackend: ca .\n");
PBD::error << _("CoreAudioBackend: failed to start coreaudio.") << endmsg; PBD::error << _("CoreAudioBackend: failed to start coreaudio.") << endmsg;
stop(); stop();
_run = false; _run = false;
@ -560,28 +546,13 @@ CoreAudioBackend::stop ()
_run = false; _run = false;
_pcmio->pcm_stop(); _pcmio->pcm_stop();
_midiio->setPortChangedCallback(NULL, NULL); _midiio->set_port_changed_callback(NULL, NULL);
if (pthread_join (_freeewheel_thread, &status)) { if (pthread_join (_freeewheel_thread, &status)) {
PBD::error << _("CoreAudioBackend: failed to terminate.") << endmsg; PBD::error << _("CoreAudioBackend: failed to terminate.") << endmsg;
return -1; return -1;
} }
#if 0
while (!_rmidi_out.empty ()) {
CoreMidiIO *m = _rmidi_out.back ();
m->stop();
_rmidi_out.pop_back ();
delete m;
}
while (!_rmidi_in.empty ()) {
CoreMidiIO *m = _rmidi_in.back ();
m->stop();
_rmidi_in.pop_back ();
delete m;
}
#endif
unregister_ports(); unregister_ports();
_active_ca = false; _active_ca = false;
@ -637,6 +608,20 @@ CoreAudioBackend::samples_since_cycle_start ()
return 0; return 0;
} }
uint32_t
CoreAudioBackend::name_to_id(std::string device_name) const {
uint32_t device_id = UINT32_MAX;
std::map<size_t, std::string> devices;
_pcmio->device_list(devices);
for (std::map<size_t, std::string>::const_iterator i = devices.begin (); i != devices.end(); ++i) {
if (i->second == device_name) {
device_id = i->first;
break;
}
}
return device_id;
}
void * void *
CoreAudioBackend::coreaudio_process_thread (void *arg) CoreAudioBackend::coreaudio_process_thread (void *arg)
@ -872,8 +857,12 @@ int
CoreAudioBackend::register_system_audio_ports() CoreAudioBackend::register_system_audio_ports()
{ {
LatencyRange lr; LatencyRange lr;
printf("COREAUDIO LATENCY: i:%d, o:%d\n",
_pcmio->get_latency(name_to_id(_audio_device), true),
_pcmio->get_latency(name_to_id(_audio_device), false));
// TODO ask _pcmio for port latencies //TODO set latencies
//TODO query port names
const int a_ins = _n_inputs > 0 ? _n_inputs : 2; const int a_ins = _n_inputs > 0 ? _n_inputs : 2;
const int a_out = _n_outputs > 0 ? _n_outputs : 2; const int a_out = _n_outputs > 0 ? _n_outputs : 2;
@ -907,6 +896,7 @@ CoreAudioBackend::register_system_midi_ports()
int midi_ins = _system_midi_out.size(); int midi_ins = _system_midi_out.size();
int midi_outs = _system_midi_in.size(); int midi_outs = _system_midi_in.size();
//TODO query port names
for (uint32_t i = midi_ins; i < _midiio->n_midi_outputs(); ++i) { for (uint32_t i = midi_ins; i < _midiio->n_midi_outputs(); ++i) {
char tmp[64]; char tmp[64];
snprintf(tmp, sizeof(tmp), "system:midi_playback_%d", ++midi_ins); snprintf(tmp, sizeof(tmp), "system:midi_playback_%d", ++midi_ins);
@ -917,7 +907,6 @@ CoreAudioBackend::register_system_midi_ports()
LatencyRange lr; LatencyRange lr;
lr.min = lr.max = _samples_per_period; // TODO add per-port midi-systemic latency lr.min = lr.max = _samples_per_period; // TODO add per-port midi-systemic latency
set_latency_range (p, false, lr); set_latency_range (p, false, lr);
//static_cast<CoreMidiPort*>(p)->set_n_periods(2);
_system_midi_out.push_back(static_cast<CoreBackendPort*>(p)); _system_midi_out.push_back(static_cast<CoreBackendPort*>(p));
} }
@ -931,7 +920,6 @@ CoreAudioBackend::register_system_midi_ports()
LatencyRange lr; LatencyRange lr;
lr.min = lr.max = _samples_per_period; // TODO add per-port midi-systemic latency lr.min = lr.max = _samples_per_period; // TODO add per-port midi-systemic latency
set_latency_range (p, false, lr); set_latency_range (p, false, lr);
//static_cast<CoreMidiPort*>(p)->set_n_periods(2);
_system_midi_in.push_back(static_cast<CoreBackendPort*>(p)); _system_midi_in.push_back(static_cast<CoreBackendPort*>(p));
} }
@ -946,6 +934,8 @@ CoreAudioBackend::coremidi_rediscover()
pthread_mutex_lock (&_process_callback_mutex); pthread_mutex_lock (&_process_callback_mutex);
// TODO maintain device-specific connections, rather
// than re-map.
while (_system_midi_out.size() > _midiio->n_midi_outputs()) { while (_system_midi_out.size() > _midiio->n_midi_outputs()) {
CoreBackendPort* p = _system_midi_out.back(); CoreBackendPort* p = _system_midi_out.back();
_system_midi_out.pop_back(); _system_midi_out.pop_back();
@ -961,7 +951,6 @@ CoreAudioBackend::coremidi_rediscover()
register_system_midi_ports(); register_system_midi_ports();
_port_change_flag = true; _port_change_flag = true;
_reinit_thread_callback = true; // XXX, rather hook into _pcmio's hardwarePropertyChangeCallback
pthread_mutex_unlock (&_process_callback_mutex); pthread_mutex_unlock (&_process_callback_mutex);
} }
@ -1404,7 +1393,6 @@ CoreAudioBackend::process_callback ()
} }
if (_reinit_thread_callback || _main_thread != pthread_self()) { if (_reinit_thread_callback || _main_thread != pthread_self()) {
printf("REINIT THREAD\n");
_reinit_thread_callback = false; _reinit_thread_callback = false;
_main_thread = pthread_self(); _main_thread = pthread_self();
AudioEngine::thread_init_callback (this); AudioEngine::thread_init_callback (this);
@ -1417,6 +1405,7 @@ CoreAudioBackend::process_callback ()
#if 0 // here in RT callback ?? XXX #if 0 // here in RT callback ?? XXX
if (_samples_per_period != n_samples) { if (_samples_per_period != n_samples) {
printf("CoreAudio Adjust SPP %zu -> %d\n", _samples_per_period, n_samples);
_samples_per_period = n_samples; _samples_per_period = n_samples;
engine.buffer_size_change (_samples_per_period); engine.buffer_size_change (_samples_per_period);
// TODO update latencies // TODO update latencies
@ -1428,7 +1417,7 @@ CoreAudioBackend::process_callback ()
clock1 = g_get_monotonic_time(); clock1 = g_get_monotonic_time();
// TODO get midi /* get midi */
i=0; i=0;
for (std::vector<CoreBackendPort*>::const_iterator it = _system_midi_in.begin (); it != _system_midi_in.end (); ++it, ++i) { for (std::vector<CoreBackendPort*>::const_iterator it = _system_midi_in.begin (); it != _system_midi_in.end (); ++it, ++i) {
CoreMidiBuffer* mbuf = static_cast<CoreMidiBuffer*>((*it)->get_buffer(0)); CoreMidiBuffer* mbuf = static_cast<CoreMidiBuffer*>((*it)->get_buffer(0));
@ -1465,12 +1454,12 @@ CoreAudioBackend::process_callback ()
return -1; return -1;
} }
// mixdown midi /* mixdown midi */
for (std::vector<CoreBackendPort*>::const_iterator it = _system_midi_out.begin (); it != _system_midi_out.end (); ++it) { for (std::vector<CoreBackendPort*>::const_iterator it = _system_midi_out.begin (); it != _system_midi_out.end (); ++it) {
//static_cast<CoreMidiPort*>(*it)->next_period();
static_cast<CoreMidiPort*>(*it)->get_buffer(0); static_cast<CoreMidiPort*>(*it)->get_buffer(0);
} }
// queue outgoing midi
/* queue outgoing midi */
i = 0; i = 0;
for (std::vector<CoreBackendPort*>::const_iterator it = _system_midi_out.begin (); it != _system_midi_out.end (); ++it, ++i) { for (std::vector<CoreBackendPort*>::const_iterator it = _system_midi_out.begin (); it != _system_midi_out.end (); ++it, ++i) {
const CoreMidiBuffer *src = static_cast<const CoreMidiPort*>(*it)->const_buffer(); const CoreMidiBuffer *src = static_cast<const CoreMidiPort*>(*it)->const_buffer();
@ -1487,15 +1476,14 @@ CoreAudioBackend::process_callback ()
_processed_samples += n_samples; _processed_samples += n_samples;
// calc DSP load. /* calc DSP load. */
clock2 = g_get_monotonic_time(); clock2 = g_get_monotonic_time();
const int64_t elapsed_time = clock2 - clock1; const int64_t elapsed_time = clock2 - clock1;
_dsp_load = elapsed_time / (float) nominal_time; _dsp_load = elapsed_time / (float) nominal_time;
//engine.Xrun (); // TODO, if any //engine.Xrun (); // TODO, if any
// port-connection change /* port-connection change */
post_process(); post_process();
pthread_mutex_unlock (&_process_callback_mutex); pthread_mutex_unlock (&_process_callback_mutex);
return 0; return 0;
@ -1504,11 +1492,16 @@ CoreAudioBackend::process_callback ()
void void
CoreAudioBackend::error_callback () CoreAudioBackend::error_callback ()
{ {
printf("ERROR CALLBACK\n");
_pcmio->set_error_callback (NULL, NULL); _pcmio->set_error_callback (NULL, NULL);
engine.halted_callback("CoreAudio Process aborted."); engine.halted_callback("CoreAudio Process aborted.");
} }
void
CoreAudioBackend::hw_changed_callback ()
{
_reinit_thread_callback = true;
engine.request_device_list_update();
}
/******************************************************************************/ /******************************************************************************/

11
libs/backends/coreaudio/coreaudio_backend.h
View file

@ -199,8 +199,8 @@ class CoreAudioBackend : public AudioBackend {
bool can_set_systemic_midi_latencies () const { return false; /* XXX */} bool can_set_systemic_midi_latencies () const { return false; /* XXX */}
/* External control app */ /* External control app */
std::string control_app_name () const { return std::string (); } std::string control_app_name () const { return std::string ("Apple"); }
void launch_control_app () {} void launch_control_app ();
/* MIDI */ /* MIDI */
std::vector<std::string> enumerate_midi_options () const; std::vector<std::string> enumerate_midi_options () const;
@ -214,6 +214,7 @@ class CoreAudioBackend : public AudioBackend {
// really private, but needing static access: // really private, but needing static access:
int process_callback(); int process_callback();
void error_callback(); void error_callback();
void hw_changed_callback();
protected: protected:
/* State Control */ /* State Control */
@ -333,6 +334,9 @@ class CoreAudioBackend : public AudioBackend {
uint32_t _systemic_audio_input_latency; uint32_t _systemic_audio_input_latency;
uint32_t _systemic_audio_output_latency; uint32_t _systemic_audio_output_latency;
/* coreaudio specific */
uint32_t name_to_id(std::string) const;
/* midi settings */ /* midi settings */
struct CoreMidiDeviceInfo { struct CoreMidiDeviceInfo {
bool enabled; bool enabled;
@ -380,9 +384,6 @@ class CoreAudioBackend : public AudioBackend {
std::vector<CoreBackendPort *> _system_midi_in; std::vector<CoreBackendPort *> _system_midi_in;
std::vector<CoreBackendPort *> _system_midi_out; std::vector<CoreBackendPort *> _system_midi_out;
//std::vector<CoreMidiOut *> _rmidi_out;
//std::vector<CoreMidiIn *> _rmidi_in;
struct PortConnectData { struct PortConnectData {
std::string a; std::string a;
std::string b; std::string b;

847
libs/backends/coreaudio/coreaudio_pcmio.cc
View file

File diff suppressed because it is too large Load diff

40
libs/backends/coreaudio/coreaudio_pcmio.h
View file

@ -24,6 +24,7 @@
#include <AudioToolbox/AudioToolbox.h> #include <AudioToolbox/AudioToolbox.h>
#include <map> #include <map>
#include <vector>
#include <string> #include <string>
#define AUHAL_OUTPUT_ELEMENT 0 #define AUHAL_OUTPUT_ELEMENT 0
@ -43,6 +44,16 @@ public:
void discover(); void discover();
void device_list(std::map<size_t, std::string> &devices) const { devices = _devices;} void device_list(std::map<size_t, std::string> &devices) const { devices = _devices;}
int available_sample_rates (uint32_t device_id, std::vector<float>& sampleRates);
int available_buffer_sizes (uint32_t device_id, std::vector<uint32_t>& sampleRates);
uint32_t available_channels (uint32_t device_id, bool input);
float current_sample_rate(uint32 device_id, bool input = false);
uint32_t get_latency(uint32 device_id, bool input);
std::string cached_port_name(uint32_t portnum, bool input) const;
void launch_control_app (uint32_t device_id);
void pcm_stop (void); void pcm_stop (void);
int pcm_start ( int pcm_start (
uint32_t input_device, uint32_t input_device,
@ -53,6 +64,7 @@ public:
void * process_arg void * process_arg
); );
// TODO: combine callbacks below, add a enum type
void set_error_callback ( void set_error_callback (
void ( error_callback (void*)), void ( error_callback (void*)),
void * error_arg void * error_arg
@ -61,6 +73,14 @@ public:
_error_arg = error_arg; _error_arg = error_arg;
} }
void set_hw_changed_callback (
void ( callback (void*)),
void * arg
) {
_hw_changed_callback = callback;
_hw_changed_arg = arg;
}
// must be called from process_callback; // must be called from process_callback;
int get_capture_channel (uint32_t chn, float *input, uint32_t n_samples); int get_capture_channel (uint32_t chn, float *input, uint32_t n_samples);
int set_playback_channel (uint32_t chn, const float *input, uint32_t n_samples); int set_playback_channel (uint32_t chn, const float *input, uint32_t n_samples);
@ -77,10 +97,14 @@ public:
void hwPropertyChange(); void hwPropertyChange();
private: private:
int set_device_sample_rate (uint32 device_id, float rate, bool input);
void get_stream_latencies(uint32 device_id, bool input, std::vector<uint32>& latencies);
void cache_port_names(uint32 device_id, bool input);
AudioUnit _auhal; AudioUnit _auhal;
AudioDeviceID* _deviceIDs; AudioDeviceID* _device_ids;
AudioBufferList* _inputAudioBufferList; AudioBufferList* _input_audio_buffer_list;
AudioBufferList* _outputAudioBufferList; AudioBufferList* _output_audio_buffer_list;
int _state; int _state;
@ -89,7 +113,7 @@ private:
uint32_t _capture_channels; uint32_t _capture_channels;
uint32_t _playback_channels; uint32_t _playback_channels;
bool _in_process; bool _in_process;
size_t _numDevices; size_t _n_devices;
int (* _process_callback) (void*); int (* _process_callback) (void*);
void * _process_arg; void * _process_arg;
@ -97,9 +121,15 @@ private:
void (* _error_callback) (void*); void (* _error_callback) (void*);
void * _error_arg; void * _error_arg;
std::map<size_t, std::string> _devices; void (* _hw_changed_callback) (void*);
void * _hw_changed_arg;
// TODO proper device info struct // TODO proper device info struct
std::map<size_t, std::string> _devices;
uint32_t * _device_ins; uint32_t * _device_ins;
uint32_t * _device_outs; uint32_t * _device_outs;
std::vector<std::string> _input_names;
std::vector<std::string> _output_names;
pthread_mutex_t _discovery_lock;
}; };

94
libs/backends/coreaudio/coremidi_io.cc
View file

@ -40,12 +40,12 @@ static void midiInputCallback(const MIDIPacketList *list, void *procRef, void *s
CoreMidiIo::CoreMidiIo() CoreMidiIo::CoreMidiIo()
: _midiClient (0) : _midi_client (0)
, _inputEndPoints (0) , _input_endpoints (0)
, _outputEndPoints (0) , _output_endpoints (0)
, _inputPorts (0) , _input_ports (0)
, _outputPorts (0) , _output_ports (0)
, _inputQueue (0) , _input_queue (0)
, _rb (0) , _rb (0)
, _n_midi_in (0) , _n_midi_in (0)
, _n_midi_out (0) , _n_midi_out (0)
@ -55,7 +55,7 @@ CoreMidiIo::CoreMidiIo()
, _changed_arg (0) , _changed_arg (0)
{ {
OSStatus err; OSStatus err;
err = MIDIClientCreate(CFSTR("Ardour"), &notifyProc, this, &_midiClient); err = MIDIClientCreate(CFSTR("Ardour"), &notifyProc, this, &_midi_client);
if (noErr != err) { if (noErr != err) {
fprintf(stderr, "Creating Midi Client failed\n"); fprintf(stderr, "Creating Midi Client failed\n");
} }
@ -65,7 +65,7 @@ CoreMidiIo::CoreMidiIo()
CoreMidiIo::~CoreMidiIo() CoreMidiIo::~CoreMidiIo()
{ {
cleanup(); cleanup();
MIDIClientDispose(_midiClient); _midiClient = 0; MIDIClientDispose(_midi_client); _midi_client = 0;
} }
void void
@ -73,19 +73,19 @@ CoreMidiIo::cleanup()
{ {
_active = false; _active = false;
for (uint32_t i = 0 ; i < _n_midi_in ; ++i) { for (uint32_t i = 0 ; i < _n_midi_in ; ++i) {
MIDIPortDispose(_inputPorts[i]); MIDIPortDispose(_input_ports[i]);
_inputQueue[i].clear(); _input_queue[i].clear();
delete _rb[i]; delete _rb[i];
} }
for (uint32_t i = 0 ; i < _n_midi_out ; ++i) { for (uint32_t i = 0 ; i < _n_midi_out ; ++i) {
MIDIPortDispose(_outputPorts[i]); MIDIPortDispose(_output_ports[i]);
} }
free(_inputPorts); _inputPorts = 0; free(_input_ports); _input_ports = 0;
free(_inputEndPoints); _inputEndPoints = 0; free(_input_endpoints); _input_endpoints = 0;
free(_inputQueue); _inputQueue = 0; free(_input_queue); _input_queue = 0;
free(_outputPorts); _outputPorts = 0; free(_output_ports); _output_ports = 0;
free(_outputEndPoints); _outputEndPoints = 0; free(_output_endpoints); _output_endpoints = 0;
free(_rb); _rb = 0; free(_rb); _rb = 0;
_n_midi_in = 0; _n_midi_in = 0;
@ -103,37 +103,37 @@ CoreMidiIo::notify_proc(const MIDINotification *message)
{ {
switch(message->messageID) { switch(message->messageID) {
case kMIDIMsgSetupChanged: case kMIDIMsgSetupChanged:
printf("kMIDIMsgSetupChanged\n"); /* this one catches all of the added/removed/changed below */
//printf("kMIDIMsgSetupChanged\n");
discover(); discover();
break; break;
case kMIDIMsgObjectAdded: case kMIDIMsgObjectAdded:
{ {
const MIDIObjectAddRemoveNotification *n = (const MIDIObjectAddRemoveNotification*) message; //const MIDIObjectAddRemoveNotification *n = (const MIDIObjectAddRemoveNotification*) message;
printf("kMIDIMsgObjectAdded\n"); //printf("kMIDIMsgObjectAdded\n");
} }
break; break;
case kMIDIMsgObjectRemoved: case kMIDIMsgObjectRemoved:
{ {
const MIDIObjectAddRemoveNotification *n = (const MIDIObjectAddRemoveNotification*) message; //const MIDIObjectAddRemoveNotification *n = (const MIDIObjectAddRemoveNotification*) message;
printf("kMIDIMsgObjectRemoved\n"); //printf("kMIDIMsgObjectRemoved\n");
} }
break; break;
case kMIDIMsgPropertyChanged: case kMIDIMsgPropertyChanged:
{ {
const MIDIObjectPropertyChangeNotification *n = (const MIDIObjectPropertyChangeNotification*) message; //const MIDIObjectPropertyChangeNotification *n = (const MIDIObjectPropertyChangeNotification*) message;
printf("kMIDIMsgObjectRemoved\n"); //printf("kMIDIMsgObjectRemoved\n");
} }
break; break;
case kMIDIMsgThruConnectionsChanged: case kMIDIMsgThruConnectionsChanged:
printf("kMIDIMsgThruConnectionsChanged\n"); //printf("kMIDIMsgThruConnectionsChanged\n");
break; break;
case kMIDIMsgSerialPortOwnerChanged: case kMIDIMsgSerialPortOwnerChanged:
printf("kMIDIMsgSerialPortOwnerChanged\n"); //printf("kMIDIMsgSerialPortOwnerChanged\n");
break; break;
case kMIDIMsgIOError: case kMIDIMsgIOError:
printf("kMIDIMsgIOError\n"); fprintf(stderr, "kMIDIMsgIOError\n");
cleanup(); discover();
//discover();
break; break;
} }
} }
@ -150,19 +150,19 @@ CoreMidiIo::recv_event (uint32_t port, double cycle_time_us, uint64_t &time, uin
MIDIPacket packet; MIDIPacket packet;
size_t rv = _rb[port]->read((uint8_t*)&packet, sizeof(MIDIPacket)); size_t rv = _rb[port]->read((uint8_t*)&packet, sizeof(MIDIPacket));
assert(rv == sizeof(MIDIPacket)); assert(rv == sizeof(MIDIPacket));
_inputQueue[port].push_back(boost::shared_ptr<CoreMIDIPacket>(new _CoreMIDIPacket (&packet))); _input_queue[port].push_back(boost::shared_ptr<CoreMIDIPacket>(new _CoreMIDIPacket (&packet)));
} }
UInt64 start = _time_at_cycle_start; UInt64 start = _time_at_cycle_start;
UInt64 end = AudioConvertNanosToHostTime(AudioConvertHostTimeToNanos(_time_at_cycle_start) + cycle_time_us * 1e3); UInt64 end = AudioConvertNanosToHostTime(AudioConvertHostTimeToNanos(_time_at_cycle_start) + cycle_time_us * 1e3);
for (CoreMIDIQueue::iterator it = _inputQueue[port].begin (); it != _inputQueue[port].end (); ) { for (CoreMIDIQueue::iterator it = _input_queue[port].begin (); it != _input_queue[port].end (); ) {
if ((*it)->timeStamp < end) { if ((*it)->timeStamp < end) {
if ((*it)->timeStamp < start) { if ((*it)->timeStamp < start) {
uint64_t dt = AudioConvertHostTimeToNanos(start - (*it)->timeStamp); uint64_t dt = AudioConvertHostTimeToNanos(start - (*it)->timeStamp);
//printf("Stale Midi Event dt:%.2fms\n", dt * 1e-6); //printf("Stale Midi Event dt:%.2fms\n", dt * 1e-6);
if (dt > 1e-4) { // 100ms, maybe too large if (dt > 1e-4) { // 100ms, maybe too large
it = _inputQueue[port].erase(it); it = _input_queue[port].erase(it);
continue; continue;
} }
time = 0; time = 0;
@ -173,7 +173,7 @@ CoreMidiIo::recv_event (uint32_t port, double cycle_time_us, uint64_t &time, uin
if (s > 0) { if (s > 0) {
memcpy(d, (*it)->data, s); memcpy(d, (*it)->data, s);
} }
_inputQueue[port].erase(it); _input_queue[port].erase(it);
return s; return s;
} }
++it; ++it;
@ -204,7 +204,7 @@ CoreMidiIo::send_event (uint32_t port, double reltime_us, const uint8_t *d, cons
assert(s < 256); assert(s < 256);
memcpy(mp->data, d, s); memcpy(mp->data, d, s);
MIDISend(_outputPorts[port], _outputEndPoints[port], &pl); MIDISend(_output_ports[port], _output_endpoints[port], &pl);
return 0; return 0;
} }
@ -213,20 +213,20 @@ CoreMidiIo::discover()
{ {
cleanup(); cleanup();
assert(!_active && _midiClient); assert(!_active && _midi_client);
ItemCount srcCount = MIDIGetNumberOfSources(); ItemCount srcCount = MIDIGetNumberOfSources();
ItemCount dstCount = MIDIGetNumberOfDestinations(); ItemCount dstCount = MIDIGetNumberOfDestinations();
if (srcCount > 0) { if (srcCount > 0) {
_inputPorts = (MIDIPortRef *) malloc (srcCount * sizeof(MIDIPortRef)); _input_ports = (MIDIPortRef *) malloc (srcCount * sizeof(MIDIPortRef));
_inputEndPoints = (MIDIEndpointRef*) malloc (srcCount * sizeof(MIDIEndpointRef)); _input_endpoints = (MIDIEndpointRef*) malloc (srcCount * sizeof(MIDIEndpointRef));
_inputQueue = (CoreMIDIQueue*) calloc (srcCount, sizeof(CoreMIDIQueue)); _input_queue = (CoreMIDIQueue*) calloc (srcCount, sizeof(CoreMIDIQueue));
_rb = (RingBuffer<uint8_t> **) malloc (srcCount * sizeof(RingBuffer<uint8_t>*)); _rb = (RingBuffer<uint8_t> **) malloc (srcCount * sizeof(RingBuffer<uint8_t>*));
} }
if (dstCount > 0) { if (dstCount > 0) {
_outputPorts = (MIDIPortRef *) malloc (dstCount * sizeof(MIDIPortRef)); _output_ports = (MIDIPortRef *) malloc (dstCount * sizeof(MIDIPortRef));
_outputEndPoints = (MIDIEndpointRef*) malloc (dstCount * sizeof(MIDIEndpointRef)); _output_endpoints = (MIDIEndpointRef*) malloc (dstCount * sizeof(MIDIEndpointRef));
} }
for (ItemCount i = 0; i < srcCount; i++) { for (ItemCount i = 0; i < srcCount; i++) {
@ -235,17 +235,18 @@ CoreMidiIo::discover()
CFStringRef port_name; CFStringRef port_name;
port_name = CFStringCreateWithFormat(NULL, NULL, CFSTR("midi_capture_%lu"), i); port_name = CFStringCreateWithFormat(NULL, NULL, CFSTR("midi_capture_%lu"), i);
err = MIDIInputPortCreate (_midiClient, port_name, midiInputCallback, this, &_inputPorts[_n_midi_in]); err = MIDIInputPortCreate (_midi_client, port_name, midiInputCallback, this, &_input_ports[_n_midi_in]);
if (noErr != err) { if (noErr != err) {
fprintf(stderr, "Cannot create Midi Output\n"); fprintf(stderr, "Cannot create Midi Output\n");
// TODO handle errors // TODO handle errors
continue; continue;
} }
// TODO get device name/ID
_rb[_n_midi_in] = new RingBuffer<uint8_t>(1024 * sizeof(MIDIPacket)); _rb[_n_midi_in] = new RingBuffer<uint8_t>(1024 * sizeof(MIDIPacket));
_inputQueue[_n_midi_in] = CoreMIDIQueue(); _input_queue[_n_midi_in] = CoreMIDIQueue();
MIDIPortConnectSource(_inputPorts[_n_midi_in], src, (void*) _rb[_n_midi_in]); MIDIPortConnectSource(_input_ports[_n_midi_in], src, (void*) _rb[_n_midi_in]);
CFRelease(port_name); CFRelease(port_name);
_inputEndPoints[_n_midi_in] = src; _input_endpoints[_n_midi_in] = src;
++_n_midi_in; ++_n_midi_in;
} }
@ -255,15 +256,16 @@ CoreMidiIo::discover()
port_name = CFStringCreateWithFormat(NULL, NULL, CFSTR("midi_playback_%lu"), i); port_name = CFStringCreateWithFormat(NULL, NULL, CFSTR("midi_playback_%lu"), i);
OSStatus err; OSStatus err;
err = MIDIOutputPortCreate (_midiClient, port_name, &_outputPorts[_n_midi_out]); err = MIDIOutputPortCreate (_midi_client, port_name, &_output_ports[_n_midi_out]);
if (noErr != err) { if (noErr != err) {
fprintf(stderr, "Cannot create Midi Output\n"); fprintf(stderr, "Cannot create Midi Output\n");
// TODO handle errors // TODO handle errors
continue; continue;
} }
MIDIPortConnectSource(_outputPorts[_n_midi_out], dst, NULL); // TODO get device name/ID
MIDIPortConnectSource(_output_ports[_n_midi_out], dst, NULL);
CFRelease(port_name); CFRelease(port_name);
_outputEndPoints[_n_midi_out] = dst; _output_endpoints[_n_midi_out] = dst;
++_n_midi_out; ++_n_midi_out;
} }

15
libs/backends/coreaudio/coremidi_io.h
View file

@ -76,7 +76,7 @@ public:
void notify_proc (const MIDINotification *message); void notify_proc (const MIDINotification *message);
void setPortChangedCallback (void (changed_callback (void*)), void *arg) { void set_port_changed_callback (void (changed_callback (void*)), void *arg) {
_changed_callback = changed_callback; _changed_callback = changed_callback;
_changed_arg = arg; _changed_arg = arg;
} }
@ -84,12 +84,13 @@ public:
private: private:
void cleanup (); void cleanup ();
MIDIClientRef _midiClient; MIDIClientRef _midi_client;
MIDIEndpointRef * _inputEndPoints; MIDIEndpointRef * _input_endpoints;
MIDIEndpointRef * _outputEndPoints; MIDIEndpointRef * _output_endpoints;
MIDIPortRef * _inputPorts; MIDIPortRef * _input_ports;
MIDIPortRef * _outputPorts; MIDIPortRef * _output_ports;
CoreMIDIQueue * _inputQueue; CoreMIDIQueue * _input_queue;
RingBuffer<uint8_t> ** _rb; RingBuffer<uint8_t> ** _rb;
uint32_t _n_midi_in; uint32_t _n_midi_in;

3
libs/backends/coreaudio/wscript
View file

@ -31,3 +31,6 @@ def build(bld):
obj.defines = ['PACKAGE="' + I18N_PACKAGE + '"', obj.defines = ['PACKAGE="' + I18N_PACKAGE + '"',
'ARDOURBACKEND_DLL_EXPORTS', 'COREAUDIO_108' 'ARDOURBACKEND_DLL_EXPORTS', 'COREAUDIO_108'
] ]
# OSX 10.6 or later
obj.defines += ['COREAUDIO_108']