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

clean out cruft from CoreAudio Backend

Browse source
This commit is contained in:
Robin Gareus 2015-03-13 14:05:12 +01:00
parent 7a4f1cb98f
commit 5090934a2c
2 changed files with 15 additions and 88 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -39,7 +39,6 @@ static std::string s_instance_name;
size_t CoreAudioBackend::_max_buffer_size = 8192; size_t CoreAudioBackend::_max_buffer_size = 8192;
std::vector<std::string> CoreAudioBackend::_midi_options; 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;
/* static class instance access */ /* static class instance access */
@ -260,24 +259,6 @@ CoreAudioBackend::set_systemic_output_latency (uint32_t sl)
return 0; 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 */ /* Retrieving parameters */
std::string std::string
CoreAudioBackend::device_name () const CoreAudioBackend::device_name () const
@ -327,27 +308,7 @@ CoreAudioBackend::systemic_output_latency () const
return _systemic_audio_output_latency; 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 */ /* MIDI */
struct CoreAudioBackend::CoreMidiDeviceInfo *
CoreAudioBackend::midi_device_info(std::string const name) const {
return 0;
}
std::vector<std::string> std::vector<std::string>
CoreAudioBackend::enumerate_midi_options () const CoreAudioBackend::enumerate_midi_options () const
@ -359,15 +320,6 @@ CoreAudioBackend::enumerate_midi_options () const
return _midi_options; 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 int
CoreAudioBackend::set_midi_option (const std::string& opt) CoreAudioBackend::set_midi_option (const std::string& opt)
{ {
@ -384,23 +336,6 @@ CoreAudioBackend::midi_option () const
return _midi_driver_option; 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 void
CoreAudioBackend::launch_control_app () CoreAudioBackend::launch_control_app ()
{ {
@ -1309,6 +1244,7 @@ CoreAudioBackend::get_latency_range (PortEngine::PortHandle port, bool for_playb
PBD::error << _("CoreBackendPort::get_latency_range (): invalid port.") << endmsg; PBD::error << _("CoreBackendPort::get_latency_range (): invalid port.") << endmsg;
r.min = 0; r.min = 0;
r.max = 0; r.max = 0;
return r;
} }
CoreBackendPort* p = static_cast<CoreBackendPort*>(port); CoreBackendPort* p = static_cast<CoreBackendPort*>(port);
assert(p); assert(p);
@ -1586,7 +1522,7 @@ CoreAudioBackend::process_callback (const uint32_t n_samples, const uint64_t hos
CoreMidiBuffer* mbuf = static_cast<CoreMidiBuffer*>((*it)->get_buffer(0)); CoreMidiBuffer* mbuf = static_cast<CoreMidiBuffer*>((*it)->get_buffer(0));
mbuf->clear(); mbuf->clear();
uint64_t time_ns; 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); size_t size = sizeof(data);
while (_midiio->recv_event (i, nominal_time, time_ns, data, size)) { while (_midiio->recv_event (i, nominal_time, time_ns, data, size)) {
pframes_t time = floor((float) time_ns * _samplerate * 1e-9); pframes_t time = floor((float) time_ns * _samplerate * 1e-9);

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

@ -182,8 +182,8 @@ class CoreAudioBackend : public AudioBackend {
int set_output_channels (uint32_t); int set_output_channels (uint32_t);
int set_systemic_input_latency (uint32_t); int set_systemic_input_latency (uint32_t);
int set_systemic_output_latency (uint32_t); int set_systemic_output_latency (uint32_t);
int set_systemic_midi_input_latency (std::string const, uint32_t); int set_systemic_midi_input_latency (std::string const, uint32_t) { return 0; }
int set_systemic_midi_output_latency (std::string const, uint32_t); int set_systemic_midi_output_latency (std::string const, uint32_t) { return 0; }
int reset_device () { return 0; }; int reset_device () { return 0; };
@ -196,8 +196,8 @@ class CoreAudioBackend : public AudioBackend {
uint32_t output_channels () const; uint32_t output_channels () const;
uint32_t systemic_input_latency () const; uint32_t systemic_input_latency () const;
uint32_t systemic_output_latency () const; uint32_t systemic_output_latency () const;
uint32_t systemic_midi_input_latency (std::string const) const; uint32_t systemic_midi_input_latency (std::string const) const { return 0; }
uint32_t systemic_midi_output_latency (std::string const) const; uint32_t systemic_midi_output_latency (std::string const) const { return 0; }
bool can_set_systemic_midi_latencies () const { return false; /* XXX */} bool can_set_systemic_midi_latencies () const { return false; /* XXX */}
@ -210,9 +210,15 @@ class CoreAudioBackend : public AudioBackend {
int set_midi_option (const std::string&); int set_midi_option (const std::string&);
std::string midi_option () const; std::string midi_option () const;
std::vector<DeviceStatus> enumerate_midi_devices () const; std::vector<DeviceStatus> enumerate_midi_devices () const {
int set_midi_device_enabled (std::string const, bool); return std::vector<AudioBackend::DeviceStatus> ();
bool midi_device_enabled (std::string const) const; }
int set_midi_device_enabled (std::string const, bool) {
return true;
}
bool midi_device_enabled (std::string const) const {
return false;
}
// really private, but needing static access: // really private, but needing static access:
int process_callback(uint32_t, uint64_t); int process_callback(uint32_t, uint64_t);
@ -350,21 +356,6 @@ class CoreAudioBackend : public AudioBackend {
/* coreaudio specific */ /* coreaudio specific */
uint32_t name_to_id(std::string) const; uint32_t name_to_id(std::string) const;
/* midi settings */
struct CoreMidiDeviceInfo {
bool enabled;
uint32_t systemic_input_latency;
uint32_t systemic_output_latency;
CoreMidiDeviceInfo()
: enabled (true)
, systemic_input_latency (0)
, systemic_output_latency (0)
{}
};
mutable std::map<std::string, struct CoreMidiDeviceInfo *> _midi_devices;
struct CoreMidiDeviceInfo * midi_device_info(std::string const) const;
/* processing */ /* processing */
float _dsp_load; float _dsp_load;
uint64_t _processed_samples; uint64_t _processed_samples;