From cae2f8227850547dcf83c270cc15000a0c50871d Mon Sep 17 00:00:00 2001 From: Paul Davis Date: Fri, 8 Jan 2016 09:39:00 -0500 Subject: NOOP: fix whitespace/indendentation in coreaudio backend code --- libs/backends/coreaudio/coreaudio_backend.cc | 398 ++++++++-------- libs/backends/coreaudio/coreaudio_backend.h | 684 +++++++++++++-------------- 2 files changed, 541 insertions(+), 541 deletions(-) (limited to 'libs/backends') diff --git a/libs/backends/coreaudio/coreaudio_backend.cc b/libs/backends/coreaudio/coreaudio_backend.cc index ebe8d62880..48250b2666 100644 --- a/libs/backends/coreaudio/coreaudio_backend.cc +++ b/libs/backends/coreaudio/coreaudio_backend.cc @@ -525,60 +525,60 @@ CoreAudioBackend::_start (bool for_latency_measurement) printf("STATE: %d\n", _pcmio->state ()); #endif switch (_pcmio->state ()) { - case 0: /* OK */ - break; - case -1: - PBD::error << _("CoreAudioBackend: Invalid Device ID.") << endmsg; - error_code = AudioDeviceInvalidError; - break; - case -2: - PBD::error << _("CoreAudioBackend: Failed to resolve Device-Component by ID.") << endmsg; - error_code = AudioDeviceNotAvailableError; - break; - case -3: - PBD::error << _("CoreAudioBackend: failed to open device.") << endmsg; - error_code = AudioDeviceOpenError; - break; - case -4: - PBD::error << _("CoreAudioBackend: cannot set requested sample rate.") << endmsg; - error_code = SampleRateNotSupportedError; - break; - case -5: - PBD::error << _("CoreAudioBackend: cannot configure requested buffer size.") << endmsg; - error_code = PeriodSizeNotSupportedError; - break; - case -6: - PBD::error << _("CoreAudioBackend: unsupported sample format.") << endmsg; - error_code = SampleFormatNotSupportedError; - break; - case -7: - PBD::error << _("CoreAudioBackend: Failed to enable Device.") << endmsg; - error_code = BackendInitializationError; // XXX - break; - case -8: - PBD::error << _("CoreAudioBackend: Cannot allocate buffers, out-of-memory.") << endmsg; - error_code = OutOfMemoryError; - break; - case -9: - PBD::error << _("CoreAudioBackend: Failed to set device-property listeners.") << endmsg; - error_code = BackendInitializationError; // XXX - break; - case -10: - PBD::error << _("CoreAudioBackend: Setting Process Callback failed.") << endmsg; - error_code = AudioDeviceIOError; - break; - case -11: - PBD::error << _("CoreAudioBackend: cannot use requested period size.") << endmsg; - error_code = PeriodSizeNotSupportedError; - break; - case -12: - PBD::error << _("CoreAudioBackend: cannot create aggregate device.") << endmsg; - error_code = DeviceConfigurationNotSupportedError; - break; - default: - PBD::error << _("CoreAudioBackend: initialization failure.") << endmsg; - error_code = BackendInitializationError; - break; + case 0: /* OK */ + break; + case -1: + PBD::error << _("CoreAudioBackend: Invalid Device ID.") << endmsg; + error_code = AudioDeviceInvalidError; + break; + case -2: + PBD::error << _("CoreAudioBackend: Failed to resolve Device-Component by ID.") << endmsg; + error_code = AudioDeviceNotAvailableError; + break; + case -3: + PBD::error << _("CoreAudioBackend: failed to open device.") << endmsg; + error_code = AudioDeviceOpenError; + break; + case -4: + PBD::error << _("CoreAudioBackend: cannot set requested sample rate.") << endmsg; + error_code = SampleRateNotSupportedError; + break; + case -5: + PBD::error << _("CoreAudioBackend: cannot configure requested buffer size.") << endmsg; + error_code = PeriodSizeNotSupportedError; + break; + case -6: + PBD::error << _("CoreAudioBackend: unsupported sample format.") << endmsg; + error_code = SampleFormatNotSupportedError; + break; + case -7: + PBD::error << _("CoreAudioBackend: Failed to enable Device.") << endmsg; + error_code = BackendInitializationError; // XXX + break; + case -8: + PBD::error << _("CoreAudioBackend: Cannot allocate buffers, out-of-memory.") << endmsg; + error_code = OutOfMemoryError; + break; + case -9: + PBD::error << _("CoreAudioBackend: Failed to set device-property listeners.") << endmsg; + error_code = BackendInitializationError; // XXX + break; + case -10: + PBD::error << _("CoreAudioBackend: Setting Process Callback failed.") << endmsg; + error_code = AudioDeviceIOError; + break; + case -11: + PBD::error << _("CoreAudioBackend: cannot use requested period size.") << endmsg; + error_code = PeriodSizeNotSupportedError; + break; + case -12: + PBD::error << _("CoreAudioBackend: cannot create aggregate device.") << endmsg; + error_code = DeviceConfigurationNotSupportedError; + break; + default: + PBD::error << _("CoreAudioBackend: initialization failure.") << endmsg; + error_code = BackendInitializationError; + break; } if (_pcmio->state ()) { return error_code; @@ -586,18 +586,18 @@ CoreAudioBackend::_start (bool for_latency_measurement) if (_n_outputs != _pcmio->n_playback_channels ()) { if (_n_outputs == 0) { - _n_outputs = _pcmio->n_playback_channels (); + _n_outputs = _pcmio->n_playback_channels (); } else { - _n_outputs = std::min (_n_outputs, _pcmio->n_playback_channels ()); + _n_outputs = std::min (_n_outputs, _pcmio->n_playback_channels ()); } PBD::info << _("CoreAudioBackend: adjusted output channel count to match device.") << endmsg; } if (_n_inputs != _pcmio->n_capture_channels ()) { if (_n_inputs == 0) { - _n_inputs = _pcmio->n_capture_channels (); + _n_inputs = _pcmio->n_capture_channels (); } else { - _n_inputs = std::min (_n_inputs, _pcmio->n_capture_channels ()); + _n_inputs = std::min (_n_inputs, _pcmio->n_capture_channels ()); } PBD::info << _("CoreAudioBackend: adjusted input channel count to match device.") << endmsg; } @@ -740,10 +740,10 @@ size_t CoreAudioBackend::raw_buffer_size (DataType t) { switch (t) { - case DataType::AUDIO: - return _samples_per_period * sizeof(Sample); - case DataType::MIDI: - return _max_buffer_size; // XXX not really limited + case DataType::AUDIO: + return _samples_per_period * sizeof(Sample); + case DataType::MIDI: + return _max_buffer_size; // XXX not really limited } return 0; } @@ -811,7 +811,7 @@ CoreAudioBackend::create_process_thread (boost::function func) ThreadData* td = new ThreadData (this, func, stacksize); if (_realtime_pthread_create (SCHED_FIFO, -21, stacksize, - &thread_id, coreaudio_process_thread, td)) { + &thread_id, coreaudio_process_thread, td)) { pthread_attr_init (&attr); pthread_attr_setstacksize (&attr, stacksize); if (pthread_create (&thread_id, &attr, coreaudio_process_thread, td)) { @@ -944,9 +944,9 @@ CoreAudioBackend::get_port_by_name (const std::string& name) const int CoreAudioBackend::get_ports ( - const std::string& port_name_pattern, - DataType type, PortFlags flags, - std::vector& port_names) const + const std::string& port_name_pattern, + DataType type, PortFlags flags, + std::vector& port_names) const { int rv = 0; regex_t port_regex; @@ -982,9 +982,9 @@ CoreAudioBackend::port_data_type (PortEngine::PortHandle port) const PortEngine::PortHandle CoreAudioBackend::register_port ( - const std::string& name, - ARDOUR::DataType type, - ARDOUR::PortFlags flags) + const std::string& name, + ARDOUR::DataType type, + ARDOUR::PortFlags flags) { if (name.size () == 0) { return 0; } if (flags & IsPhysical) { return 0; } @@ -993,27 +993,27 @@ CoreAudioBackend::register_port ( PortEngine::PortHandle CoreAudioBackend::add_port ( - const std::string& name, - ARDOUR::DataType type, - ARDOUR::PortFlags flags) + const std::string& name, + ARDOUR::DataType type, + ARDOUR::PortFlags flags) { assert(name.size ()); if (find_port (name)) { PBD::warning << _("CoreAudioBackend::register_port: Port already exists:") - << " (" << name << ")" << endmsg; + << " (" << name << ")" << endmsg; return 0; } CoreBackendPort* port = NULL; switch (type) { - case DataType::AUDIO: - port = new CoreAudioPort (*this, name, flags); - break; - case DataType::MIDI: - port = new CoreMidiPort (*this, name, flags); - break; - default: - PBD::error << _("CoreAudioBackend::register_port: Invalid Data Type.") << endmsg; - return 0; + case DataType::AUDIO: + port = new CoreAudioPort (*this, name, flags); + break; + case DataType::MIDI: + port = new CoreMidiPort (*this, name, flags); + break; + default: + PBD::error << _("CoreAudioBackend::register_port: Invalid Data Type.") << endmsg; + return 0; } _ports.push_back (port); @@ -1051,8 +1051,8 @@ CoreAudioBackend::register_system_audio_ports() #ifndef NDEBUG printf("COREAUDIO LATENCY: i:%d, o:%d\n", - coreaudio_reported_input_latency, - coreaudio_reported_output_latency); + coreaudio_reported_input_latency, + coreaudio_reported_output_latency); #endif /* audio ports */ @@ -1211,12 +1211,12 @@ CoreAudioBackend::connect (const std::string& src, const std::string& dst) if (!src_port) { PBD::warning << _("CoreAudioBackend::connect: Invalid Source port:") - << " (" << src <<")" << endmsg; + << " (" << src <<")" << endmsg; return -1; } if (!dst_port) { PBD::warning << _("CoreAudioBackend::connect: Invalid Destination port:") - << " (" << dst <<")" << endmsg; + << " (" << dst <<")" << endmsg; return -1; } return src_port->connect (dst_port); @@ -1245,7 +1245,7 @@ CoreAudioBackend::connect (PortEngine::PortHandle src, const std::string& dst) } if (!dst_port) { PBD::warning << _("CoreAudioBackend::connect: Invalid Destination Port") - << " (" << dst << ")" << endmsg; + << " (" << dst << ")" << endmsg; return -1; } return static_cast(src)->connect (dst_port); @@ -1326,9 +1326,9 @@ CoreAudioBackend::get_connections (PortEngine::PortHandle port, std::vector(port_buffer); @@ -1345,9 +1345,9 @@ CoreAudioBackend::midi_event_get ( int CoreAudioBackend::_midi_event_put ( - void* port_buffer, - pframes_t timestamp, - const uint8_t* buffer, size_t size) + void* port_buffer, + pframes_t timestamp, + const uint8_t* buffer, size_t size) { if (!buffer || !port_buffer) return -1; CoreMidiBuffer& dst = * static_cast(port_buffer); @@ -1355,7 +1355,7 @@ CoreAudioBackend::_midi_event_put ( #ifndef NDEBUG // nevermind, ::get_buffer() sorts events fprintf (stderr, "CoreMidiBuffer: unordered event: %d > %d\n", - (pframes_t)dst.back ()->timestamp (), timestamp); + (pframes_t)dst.back ()->timestamp (), timestamp); #endif } dst.push_back (boost::shared_ptr(new CoreMidiEvent (timestamp, buffer, size))); @@ -1487,9 +1487,9 @@ CoreAudioBackend::n_physical_outputs () const CoreBackendPort* port = _ports[i]; if (port->is_output () && port->is_physical ()) { switch (port->type ()) { - case DataType::AUDIO: ++n_audio; break; - case DataType::MIDI: ++n_midi; break; - default: break; + case DataType::AUDIO: ++n_audio; break; + case DataType::MIDI: ++n_midi; break; + default: break; } } } @@ -1508,9 +1508,9 @@ CoreAudioBackend::n_physical_inputs () const CoreBackendPort* port = _ports[i]; if (port->is_input () && port->is_physical ()) { switch (port->type ()) { - case DataType::AUDIO: ++n_audio; break; - case DataType::MIDI: ++n_midi; break; - default: break; + case DataType::AUDIO: ++n_audio; break; + case DataType::MIDI: ++n_midi; break; + default: break; } } } @@ -1565,12 +1565,12 @@ CoreAudioBackend::pre_process () void CoreAudioBackend::reset_midi_parsers () { - for (std::vector::const_iterator it = _system_midi_in.begin (); it != _system_midi_in.end (); ++it) { - CoreMidiPort* port = dynamic_cast(*it); - if (port) { - port->reset_parser (); - } - } + for (std::vector::const_iterator it = _system_midi_in.begin (); it != _system_midi_in.end (); ++it) { + CoreMidiPort* port = dynamic_cast(*it); + if (port) { + port->reset_parser (); + } + } } void * @@ -1598,7 +1598,7 @@ CoreAudioBackend::freewheel_thread () _freewheel = false; // first mark as disabled _reinit_thread_callback = true; // hand over _main_thread _freewheel_ack = false; // prepare next handshake - reset_midi_parsers (); + reset_midi_parsers (); _midiio->set_enabled(true); engine.freewheel_callback (_freewheeling); } else { @@ -1626,7 +1626,7 @@ CoreAudioBackend::freewheel_thread () _main_thread = pthread_self(); AudioEngine::thread_init_callback (this); _midiio->set_enabled(false); - reset_midi_parsers (); + reset_midi_parsers (); } // process port updates first in every cycle. @@ -1713,22 +1713,22 @@ CoreAudioBackend::process_callback (const uint32_t n_samples, const uint64_t hos /* get midi */ i=0; for (std::vector::const_iterator it = _system_midi_in.begin (); it != _system_midi_in.end (); ++it, ++i) { - CoreMidiPort* port = dynamic_cast (*it); - if (!port) { - continue; - } - uint64_t time_ns; - uint8_t data[128]; // matches CoreMidi's MIDIPacket - size_t size = sizeof(data); + CoreMidiPort* port = dynamic_cast (*it); + if (!port) { + continue; + } + uint64_t time_ns; + uint8_t data[128]; // matches CoreMidi's MIDIPacket + size_t size = sizeof(data); - port->clear_events (); + port->clear_events (); - while (_midiio->recv_event (i, nominal_time, time_ns, data, size)) { - pframes_t time = floor((float) time_ns * _samplerate * 1e-9); - assert (time < n_samples); - port->parse_events (time, data, size); - size = sizeof(data); /* prepare for next call to recv_event */ - } + while (_midiio->recv_event (i, nominal_time, time_ns, data, size)) { + pframes_t time = floor((float) time_ns * _samplerate * 1e-9); + assert (time < n_samples); + port->parse_events (time, data, size); + size = sizeof(data); /* prepare for next call to recv_event */ + } } /* get audio */ @@ -1949,8 +1949,8 @@ int CoreBackendPort::connect (CoreBackendPort *port) if (is_connected (port)) { #if 0 // don't bother to warn about this for now. just ignore it PBD::info << _("CoreBackendPort::connect (): ports are already connected:") - << " (" << name () << ") -> (" << port->name () << ")" - << endmsg; + << " (" << name () << ") -> (" << port->name () << ")" + << endmsg; #endif return -1; } @@ -1978,8 +1978,8 @@ int CoreBackendPort::disconnect (CoreBackendPort *port) if (!is_connected (port)) { PBD::warning << _("CoreBackendPort::disconnect (): ports are not connected:") - << " (" << name () << ") -> (" << port->name () << ")" - << endmsg; + << " (" << name () << ") -> (" << port->name () << ")" + << endmsg; return -1; } _disconnect (port, true); @@ -2066,12 +2066,12 @@ CoreMidiPort::CoreMidiPort (CoreAudioBackend &b, const std::string& name, PortFl : CoreBackendPort (b, name, flags) , _n_periods (1) , _bufperiod (0) - , _event (0, 0) - , _first_time(true) - , _unbuffered_bytes(0) - , _total_bytes(0) - , _expected_bytes(0) - , _status_byte(0) + , _event (0, 0) + , _first_time(true) + , _unbuffered_bytes(0) + , _total_bytes(0) + , _expected_bytes(0) + , _status_byte(0) { _buffer[0].clear (); @@ -2091,58 +2091,58 @@ void* CoreMidiPort::get_buffer (pframes_t /* nframes */) if (is_input ()) { (_buffer[_bufperiod]).clear (); for (std::vector::const_iterator i = get_connections ().begin (); - i != get_connections ().end (); - ++i) { + i != get_connections ().end (); + ++i) { const CoreMidiBuffer * src = static_cast(*i)->const_buffer (); - if (!src->empty()) { - fprintf (stderr, "Copying %d events from %s\n", src->size(), (*i)->name().c_str()); - } + if (!src->empty()) { + fprintf (stderr, "Copying %d events from %s\n", src->size(), (*i)->name().c_str()); + } for (CoreMidiBuffer::const_iterator it = src->begin (); it != src->end (); ++it) { (_buffer[_bufperiod]).push_back (boost::shared_ptr(new CoreMidiEvent (**it))); } } std::sort ((_buffer[_bufperiod]).begin (), (_buffer[_bufperiod]).end (), MidiEventSorter()); } - if (!_buffer[_bufperiod].empty()) { - fprintf (stderr, "COREMIDI: %s have data in buffer (%d events)\n", name().c_str(), _buffer[_bufperiod].size()); - } + if (!_buffer[_bufperiod].empty()) { + fprintf (stderr, "COREMIDI: %s have data in buffer (%d events)\n", name().c_str(), _buffer[_bufperiod].size()); + } return &(_buffer[_bufperiod]); } int CoreMidiPort::queue_event ( - void* port_buffer, - pframes_t timestamp, - const uint8_t* buffer, size_t size) + void* port_buffer, + pframes_t timestamp, + const uint8_t* buffer, size_t size) { - return CoreAudioBackend::_midi_event_put (port_buffer, timestamp, buffer, size); + return CoreAudioBackend::_midi_event_put (port_buffer, timestamp, buffer, size); } void CoreMidiPort::reset_parser () { - _event._pending = false; - _first_time = true; - _unbuffered_bytes = 0; - _total_bytes = 0; - _expected_bytes = 0; - _status_byte = 0; + _event._pending = false; + _first_time = true; + _unbuffered_bytes = 0; + _total_bytes = 0; + _expected_bytes = 0; + _status_byte = 0; } void CoreMidiPort::clear_events () { - CoreMidiBuffer* mbuf = static_cast(get_buffer(0)); - mbuf->clear(); -} + CoreMidiBuffer* mbuf = static_cast(get_buffer(0)); + mbuf->clear(); +} void -CoreMidiPort::parse_events (const uint64_t time, const uint8_t *data, const size_t size) +CoreMidiPort::parse_events (const uint64_t time, const uint8_t *data, const size_t size) { - CoreMidiBuffer* mbuf = static_cast(get_buffer(0)); + CoreMidiBuffer* mbuf = static_cast(get_buffer(0)); + + mbuf->clear(); - mbuf->clear(); - if (_event._pending) { if (queue_event (mbuf, _event._time, _parser_buffer, _event._size)) { return; @@ -2154,8 +2154,8 @@ CoreMidiPort::parse_events (const uint64_t time, const uint8_t *data, const size continue; } - _first_time = false; - + _first_time = false; + if (process_byte(time, data[i])) { if (queue_event (mbuf, _event._time, _parser_buffer, _event._size)) { return; @@ -2183,8 +2183,8 @@ CoreMidiPort::process_byte(const uint64_t time, const uint8_t byte) record_byte(byte); return prepare_buffered_event(time); } - _total_bytes = 0; - _unbuffered_bytes = 0; + _total_bytes = 0; + _unbuffered_bytes = 0; _expected_bytes = 0; _status_byte = 0; return false; @@ -2204,47 +2204,47 @@ CoreMidiPort::process_byte(const uint64_t time, const uint8_t byte) } _status_byte = byte; switch (byte & 0xf0) { - case 0x80: - case 0x90: - case 0xa0: - case 0xb0: - case 0xe0: - // Note On, Note Off, Aftertouch, Control Change, Pitch Wheel - _expected_bytes = 3; + case 0x80: + case 0x90: + case 0xa0: + case 0xb0: + case 0xe0: + // Note On, Note Off, Aftertouch, Control Change, Pitch Wheel + _expected_bytes = 3; + break; + case 0xc0: + case 0xd0: + // Program Change, Channel Pressure + _expected_bytes = 2; + break; + case 0xf0: + switch (byte) { + case 0xf0: + // Sysex + _expected_bytes = 0; break; - case 0xc0: - case 0xd0: - // Program Change, Channel Pressure + case 0xf1: + case 0xf3: + // MTC Quarter Frame, Song Select _expected_bytes = 2; break; - case 0xf0: - switch (byte) { - case 0xf0: - // Sysex - _expected_bytes = 0; - break; - case 0xf1: - case 0xf3: - // MTC Quarter Frame, Song Select - _expected_bytes = 2; - break; - case 0xf2: - // Song Position - _expected_bytes = 3; - break; - case 0xf4: - case 0xf5: - // Undefined - _expected_bytes = 0; - _status_byte = 0; - return false; - case 0xf6: - // Tune Request - prepare_byte_event(time, byte); - _expected_bytes = 0; - _status_byte = 0; - return true; - } + case 0xf2: + // Song Position + _expected_bytes = 3; + break; + case 0xf4: + case 0xf5: + // Undefined + _expected_bytes = 0; + _status_byte = 0; + return false; + case 0xf6: + // Tune Request + prepare_byte_event(time, byte); + _expected_bytes = 0; + _status_byte = 0; + return true; + } } record_byte(byte); return false; diff --git a/libs/backends/coreaudio/coreaudio_backend.h b/libs/backends/coreaudio/coreaudio_backend.h index 7b42bfe653..e36e936918 100644 --- a/libs/backends/coreaudio/coreaudio_backend.h +++ b/libs/backends/coreaudio/coreaudio_backend.h @@ -42,125 +42,125 @@ namespace ARDOUR { class CoreAudioBackend; class CoreMidiEvent { - public: - CoreMidiEvent (const pframes_t timestamp, const uint8_t* data, size_t size); - CoreMidiEvent (const CoreMidiEvent& other); - ~CoreMidiEvent (); - size_t size () const { return _size; }; - pframes_t timestamp () const { return _timestamp; }; - const unsigned char* const_data () const { return _data; }; - unsigned char* data () { return _data; }; - bool operator< (const CoreMidiEvent &other) const { return timestamp () < other.timestamp (); }; - private: - size_t _size; - pframes_t _timestamp; - uint8_t *_data; + public: + CoreMidiEvent (const pframes_t timestamp, const uint8_t* data, size_t size); + CoreMidiEvent (const CoreMidiEvent& other); + ~CoreMidiEvent (); + size_t size () const { return _size; }; + pframes_t timestamp () const { return _timestamp; }; + const unsigned char* const_data () const { return _data; }; + unsigned char* data () { return _data; }; + bool operator< (const CoreMidiEvent &other) const { return timestamp () < other.timestamp (); }; + private: + size_t _size; + pframes_t _timestamp; + uint8_t *_data; }; typedef std::vector > CoreMidiBuffer; class CoreBackendPort { - protected: - CoreBackendPort (CoreAudioBackend &b, const std::string&, PortFlags); - public: - virtual ~CoreBackendPort (); + protected: + CoreBackendPort (CoreAudioBackend &b, const std::string&, PortFlags); + public: + virtual ~CoreBackendPort (); + + const std::string& name () const { return _name; } + const std::string& pretty_name () const { return _pretty_name; } + PortFlags flags () const { return _flags; } - const std::string& name () const { return _name; } - const std::string& pretty_name () const { return _pretty_name; } - PortFlags flags () const { return _flags; } + int set_name (const std::string &name) { _name = name; return 0; } + int set_pretty_name (const std::string &name) { _pretty_name = name; return 0; } - int set_name (const std::string &name) { _name = name; return 0; } - int set_pretty_name (const std::string &name) { _pretty_name = name; return 0; } + virtual DataType type () const = 0; - virtual DataType type () const = 0; + bool is_input () const { return flags () & IsInput; } + bool is_output () const { return flags () & IsOutput; } + bool is_physical () const { return flags () & IsPhysical; } + bool is_terminal () const { return flags () & IsTerminal; } + bool is_connected () const { return _connections.size () != 0; } + bool is_connected (const CoreBackendPort *port) const; + bool is_physically_connected () const; - bool is_input () const { return flags () & IsInput; } - bool is_output () const { return flags () & IsOutput; } - bool is_physical () const { return flags () & IsPhysical; } - bool is_terminal () const { return flags () & IsTerminal; } - bool is_connected () const { return _connections.size () != 0; } - bool is_connected (const CoreBackendPort *port) const; - bool is_physically_connected () const; + const std::vector& get_connections () const { return _connections; } - const std::vector& get_connections () const { return _connections; } + int connect (CoreBackendPort *port); + int disconnect (CoreBackendPort *port); + void disconnect_all (); - int connect (CoreBackendPort *port); - int disconnect (CoreBackendPort *port); - void disconnect_all (); + virtual void* get_buffer (pframes_t nframes) = 0; - virtual void* get_buffer (pframes_t nframes) = 0; + const LatencyRange latency_range (bool for_playback) const + { + return for_playback ? _playback_latency_range : _capture_latency_range; + } - const LatencyRange latency_range (bool for_playback) const + void set_latency_range (const LatencyRange &latency_range, bool for_playback) + { + if (for_playback) { - return for_playback ? _playback_latency_range : _capture_latency_range; + _playback_latency_range = latency_range; } - - void set_latency_range (const LatencyRange &latency_range, bool for_playback) + else { - if (for_playback) - { - _playback_latency_range = latency_range; - } - else - { - _capture_latency_range = latency_range; - } + _capture_latency_range = latency_range; } + } - private: - CoreAudioBackend &_osx_backend; - std::string _name; - std::string _pretty_name; - const PortFlags _flags; - LatencyRange _capture_latency_range; - LatencyRange _playback_latency_range; - std::vector _connections; + private: + CoreAudioBackend &_osx_backend; + std::string _name; + std::string _pretty_name; + const PortFlags _flags; + LatencyRange _capture_latency_range; + LatencyRange _playback_latency_range; + std::vector _connections; - void _connect (CoreBackendPort* , bool); - void _disconnect (CoreBackendPort* , bool); + void _connect (CoreBackendPort* , bool); + void _disconnect (CoreBackendPort* , bool); }; // class CoreBackendPort class CoreAudioPort : public CoreBackendPort { - public: - CoreAudioPort (CoreAudioBackend &b, const std::string&, PortFlags); - ~CoreAudioPort (); + public: + CoreAudioPort (CoreAudioBackend &b, const std::string&, PortFlags); + ~CoreAudioPort (); - DataType type () const { return DataType::AUDIO; }; + DataType type () const { return DataType::AUDIO; }; - Sample* buffer () { return _buffer; } - const Sample* const_buffer () const { return _buffer; } - void* get_buffer (pframes_t nframes); + Sample* buffer () { return _buffer; } + const Sample* const_buffer () const { return _buffer; } + void* get_buffer (pframes_t nframes); - private: - Sample _buffer[8192]; + private: + Sample _buffer[8192]; }; // class CoreAudioPort class CoreMidiPort : public CoreBackendPort { - public: - CoreMidiPort (CoreAudioBackend &b, const std::string&, PortFlags); - ~CoreMidiPort (); + public: + CoreMidiPort (CoreAudioBackend &b, const std::string&, PortFlags); + ~CoreMidiPort (); - DataType type () const { return DataType::MIDI; }; + DataType type () const { return DataType::MIDI; }; - void* get_buffer (pframes_t nframes); - const CoreMidiBuffer * const_buffer () const { return & _buffer[_bufperiod]; } + void* get_buffer (pframes_t nframes); + const CoreMidiBuffer * const_buffer () const { return & _buffer[_bufperiod]; } - void next_period() { if (_n_periods > 1) { get_buffer(0); _bufperiod = (_bufperiod + 1) % _n_periods; } } - void set_n_periods(int n) { if (n > 0 && n < 3) { _n_periods = n; } } + void next_period() { if (_n_periods > 1) { get_buffer(0); _bufperiod = (_bufperiod + 1) % _n_periods; } } + void set_n_periods(int n) { if (n > 0 && n < 3) { _n_periods = n; } } - void parse_events (const uint64_t time, const uint8_t *data, const size_t size); - void clear_events (); - void reset_parser (); + void parse_events (const uint64_t time, const uint8_t *data, const size_t size); + void clear_events (); + void reset_parser (); - private: - CoreMidiBuffer _buffer[2]; - int _n_periods; - int _bufperiod; + private: + CoreMidiBuffer _buffer[2]; + int _n_periods; + int _bufperiod; - int queue_event (void* port_buffer, pframes_t timestamp, const uint8_t* buffer, size_t size); + int queue_event (void* port_buffer, pframes_t timestamp, const uint8_t* buffer, size_t size); bool process_byte (const uint64_t, const uint8_t); - + void record_byte(uint8_t byte) { if (_total_bytes < sizeof(_parser_buffer)) { _parser_buffer[_total_bytes] = byte; @@ -216,304 +216,304 @@ class CoreMidiPort : public CoreBackendPort { class CoreAudioBackend : public AudioBackend { friend class CoreBackendPort; - public: - CoreAudioBackend (AudioEngine& e, AudioBackendInfo& info); - ~CoreAudioBackend (); - - /* AUDIOBACKEND API */ - - std::string name () const; - bool is_realtime () const; - - bool use_separate_input_and_output_devices () const { return true; } - std::vector enumerate_devices () const; - std::vector enumerate_input_devices () const; - std::vector enumerate_output_devices () const; - - std::vector available_sample_rates (const std::string& device) const; - std::vector available_sample_rates2 (const std::string&, const std::string&) const; - std::vector available_buffer_sizes (const std::string& device) const; - std::vector available_buffer_sizes2 (const std::string&, const std::string&) const; - uint32_t available_input_channel_count (const std::string& device) const; - uint32_t available_output_channel_count (const std::string& device) const; - - bool can_change_sample_rate_when_running () const; - bool can_change_buffer_size_when_running () const; - - int set_device_name (const std::string&); - int set_input_device_name (const std::string&); - int set_output_device_name (const std::string&); - int set_sample_rate (float); - int set_buffer_size (uint32_t); - int set_interleaved (bool yn); - int set_input_channels (uint32_t); - int set_output_channels (uint32_t); - int set_systemic_input_latency (uint32_t); - int set_systemic_output_latency (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) { return 0; } - - int reset_device () { return 0; }; - - /* Retrieving parameters */ - std::string device_name () const; - std::string input_device_name () const; - std::string output_device_name () const; - float sample_rate () const; - uint32_t buffer_size () const; - bool interleaved () const; - uint32_t input_channels () const; - uint32_t output_channels () const; - uint32_t systemic_input_latency () const; - uint32_t systemic_output_latency () const; - uint32_t systemic_midi_input_latency (std::string const) const { return 0; } - uint32_t systemic_midi_output_latency (std::string const) const { return 0; } - - bool can_set_systemic_midi_latencies () const { return false; /* XXX */} - - /* External control app */ - std::string control_app_name () const { return std::string ("Apple"); } - void launch_control_app (); - - /* MIDI */ - std::vector enumerate_midi_options () const; - int set_midi_option (const std::string&); - std::string midi_option () const; - - std::vector enumerate_midi_devices () const { - return std::vector (); - } - 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: - int process_callback(uint32_t, uint64_t); - void error_callback(); - void xrun_callback(); - void buffer_size_callback(); - void sample_rate_callback(); - void hw_changed_callback(); - - protected: - /* State Control */ - int _start (bool for_latency_measurement); - public: - int stop (); - int freewheel (bool); - float dsp_load () const; - size_t raw_buffer_size (DataType t); - - /* Process time */ - framepos_t sample_time (); - framepos_t sample_time_at_cycle_start (); - pframes_t samples_since_cycle_start (); - - int create_process_thread (boost::function func); - int join_process_threads (); - bool in_process_thread (); - uint32_t process_thread_count (); - - void update_latencies (); + public: + CoreAudioBackend (AudioEngine& e, AudioBackendInfo& info); + ~CoreAudioBackend (); + + /* AUDIOBACKEND API */ + + std::string name () const; + bool is_realtime () const; + + bool use_separate_input_and_output_devices () const { return true; } + std::vector enumerate_devices () const; + std::vector enumerate_input_devices () const; + std::vector enumerate_output_devices () const; + + std::vector available_sample_rates (const std::string& device) const; + std::vector available_sample_rates2 (const std::string&, const std::string&) const; + std::vector available_buffer_sizes (const std::string& device) const; + std::vector available_buffer_sizes2 (const std::string&, const std::string&) const; + uint32_t available_input_channel_count (const std::string& device) const; + uint32_t available_output_channel_count (const std::string& device) const; + + bool can_change_sample_rate_when_running () const; + bool can_change_buffer_size_when_running () const; + + int set_device_name (const std::string&); + int set_input_device_name (const std::string&); + int set_output_device_name (const std::string&); + int set_sample_rate (float); + int set_buffer_size (uint32_t); + int set_interleaved (bool yn); + int set_input_channels (uint32_t); + int set_output_channels (uint32_t); + int set_systemic_input_latency (uint32_t); + int set_systemic_output_latency (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) { return 0; } + + int reset_device () { return 0; }; + + /* Retrieving parameters */ + std::string device_name () const; + std::string input_device_name () const; + std::string output_device_name () const; + float sample_rate () const; + uint32_t buffer_size () const; + bool interleaved () const; + uint32_t input_channels () const; + uint32_t output_channels () const; + uint32_t systemic_input_latency () const; + uint32_t systemic_output_latency () const; + uint32_t systemic_midi_input_latency (std::string const) const { return 0; } + uint32_t systemic_midi_output_latency (std::string const) const { return 0; } + + bool can_set_systemic_midi_latencies () const { return false; /* XXX */} + + /* External control app */ + std::string control_app_name () const { return std::string ("Apple"); } + void launch_control_app (); + + /* MIDI */ + std::vector enumerate_midi_options () const; + int set_midi_option (const std::string&); + std::string midi_option () const; + + std::vector enumerate_midi_devices () const { + return std::vector (); + } + int set_midi_device_enabled (std::string const, bool) { + return true; + } + bool midi_device_enabled (std::string const) const { + return false; + } - /* PORTENGINE API */ + // really private, but needing static access: + int process_callback(uint32_t, uint64_t); + void error_callback(); + void xrun_callback(); + void buffer_size_callback(); + void sample_rate_callback(); + void hw_changed_callback(); + + protected: + /* State Control */ + int _start (bool for_latency_measurement); + public: + int stop (); + int freewheel (bool); + float dsp_load () const; + size_t raw_buffer_size (DataType t); + + /* Process time */ + framepos_t sample_time (); + framepos_t sample_time_at_cycle_start (); + pframes_t samples_since_cycle_start (); + + int create_process_thread (boost::function func); + int join_process_threads (); + bool in_process_thread (); + uint32_t process_thread_count (); + + void update_latencies (); + + /* PORTENGINE API */ + + void* private_handle () const; + const std::string& my_name () const; + bool available () const; + uint32_t port_name_size () const; + + int set_port_name (PortHandle, const std::string&); + std::string get_port_name (PortHandle) const; + PortHandle get_port_by_name (const std::string&) const; + int get_port_property (PortHandle, const std::string& key, std::string& value, std::string& type) const; + + int get_ports (const std::string& port_name_pattern, DataType type, PortFlags flags, std::vector&) const; + + DataType port_data_type (PortHandle) const; + + PortHandle register_port (const std::string& shortname, ARDOUR::DataType, ARDOUR::PortFlags); + void unregister_port (PortHandle); + + int connect (const std::string& src, const std::string& dst); + int disconnect (const std::string& src, const std::string& dst); + int connect (PortHandle, const std::string&); + int disconnect (PortHandle, const std::string&); + int disconnect_all (PortHandle); + + bool connected (PortHandle, bool process_callback_safe); + bool connected_to (PortHandle, const std::string&, bool process_callback_safe); + bool physically_connected (PortHandle, bool process_callback_safe); + int get_connections (PortHandle, std::vector&, bool process_callback_safe); + + /* MIDI */ + int midi_event_get (pframes_t& timestamp, size_t& size, uint8_t** buf, void* port_buffer, uint32_t event_index); + int midi_event_put (void* port_buffer, pframes_t timestamp, const uint8_t* buffer, size_t size) { + return _midi_event_put (port_buffer, timestamp, buffer, size); + } - void* private_handle () const; - const std::string& my_name () const; - bool available () const; - uint32_t port_name_size () const; + uint32_t get_midi_event_count (void* port_buffer); + void midi_clear (void* port_buffer); - int set_port_name (PortHandle, const std::string&); - std::string get_port_name (PortHandle) const; - PortHandle get_port_by_name (const std::string&) const; - int get_port_property (PortHandle, const std::string& key, std::string& value, std::string& type) const; + /* Monitoring */ - int get_ports (const std::string& port_name_pattern, DataType type, PortFlags flags, std::vector&) const; + bool can_monitor_input () const; + int request_input_monitoring (PortHandle, bool); + int ensure_input_monitoring (PortHandle, bool); + bool monitoring_input (PortHandle); - DataType port_data_type (PortHandle) const; + /* Latency management */ - PortHandle register_port (const std::string& shortname, ARDOUR::DataType, ARDOUR::PortFlags); - void unregister_port (PortHandle); + void set_latency_range (PortHandle, bool for_playback, LatencyRange); + LatencyRange get_latency_range (PortHandle, bool for_playback); - int connect (const std::string& src, const std::string& dst); - int disconnect (const std::string& src, const std::string& dst); - int connect (PortHandle, const std::string&); - int disconnect (PortHandle, const std::string&); - int disconnect_all (PortHandle); + /* Discovering physical ports */ - bool connected (PortHandle, bool process_callback_safe); - bool connected_to (PortHandle, const std::string&, bool process_callback_safe); - bool physically_connected (PortHandle, bool process_callback_safe); - int get_connections (PortHandle, std::vector&, bool process_callback_safe); + bool port_is_physical (PortHandle) const; + void get_physical_outputs (DataType type, std::vector&); + void get_physical_inputs (DataType type, std::vector&); + ChanCount n_physical_outputs () const; + ChanCount n_physical_inputs () const; - /* MIDI */ - int midi_event_get (pframes_t& timestamp, size_t& size, uint8_t** buf, void* port_buffer, uint32_t event_index); - int midi_event_put (void* port_buffer, pframes_t timestamp, const uint8_t* buffer, size_t size) { - return _midi_event_put (port_buffer, timestamp, buffer, size); - } + /* Getting access to the data buffer for a port */ - uint32_t get_midi_event_count (void* port_buffer); - void midi_clear (void* port_buffer); + void* get_buffer (PortHandle, pframes_t); - /* Monitoring */ + void* freewheel_thread (); + void pre_process (); + void coremidi_rediscover (); - bool can_monitor_input () const; - int request_input_monitoring (PortHandle, bool); - int ensure_input_monitoring (PortHandle, bool); - bool monitoring_input (PortHandle); - - /* Latency management */ + static int _midi_event_put (void* port_buffer, pframes_t timestamp, const uint8_t* buffer, size_t size); - void set_latency_range (PortHandle, bool for_playback, LatencyRange); - LatencyRange get_latency_range (PortHandle, bool for_playback); - - /* Discovering physical ports */ + private: + std::string _instance_name; + CoreAudioPCM *_pcmio; + CoreMidiIo *_midiio; - bool port_is_physical (PortHandle) const; - void get_physical_outputs (DataType type, std::vector&); - void get_physical_inputs (DataType type, std::vector&); - ChanCount n_physical_outputs () const; - ChanCount n_physical_inputs () const; - - /* Getting access to the data buffer for a port */ + bool _run; /* keep going or stop, ardour thread */ + bool _active_ca; /* is running, process thread */ + bool _active_fw; /* is running, process thread */ + bool _preinit; + bool _freewheeling; + bool _freewheel; + bool _freewheel_ack; + bool _reinit_thread_callback; + bool _measure_latency; - void* get_buffer (PortHandle, pframes_t); - - void* freewheel_thread (); - void pre_process (); - void coremidi_rediscover (); - - static int _midi_event_put (void* port_buffer, pframes_t timestamp, const uint8_t* buffer, size_t size); - - private: - std::string _instance_name; - CoreAudioPCM *_pcmio; - CoreMidiIo *_midiio; - - bool _run; /* keep going or stop, ardour thread */ - bool _active_ca; /* is running, process thread */ - bool _active_fw; /* is running, process thread */ - bool _preinit; - bool _freewheeling; - bool _freewheel; - bool _freewheel_ack; - bool _reinit_thread_callback; - bool _measure_latency; + uint64_t _last_process_start; - uint64_t _last_process_start; + pthread_mutex_t _process_callback_mutex; - pthread_mutex_t _process_callback_mutex; + pthread_mutex_t _freewheel_mutex; + pthread_cond_t _freewheel_signal; - pthread_mutex_t _freewheel_mutex; - pthread_cond_t _freewheel_signal; + static std::vector _midi_options; + static std::vector _input_audio_device_status; + static std::vector _output_audio_device_status; + static std::vector _duplex_audio_device_status; + static std::vector _midi_device_status; - static std::vector _midi_options; - static std::vector _input_audio_device_status; - static std::vector _output_audio_device_status; - static std::vector _duplex_audio_device_status; - static std::vector _midi_device_status; + mutable std::string _input_audio_device; + mutable std::string _output_audio_device; + std::string _midi_driver_option; - mutable std::string _input_audio_device; - mutable std::string _output_audio_device; - std::string _midi_driver_option; + /* audio settings */ + float _samplerate; + size_t _samples_per_period; + static size_t _max_buffer_size; - /* audio settings */ - float _samplerate; - size_t _samples_per_period; - static size_t _max_buffer_size; + uint32_t _n_inputs; + uint32_t _n_outputs; - uint32_t _n_inputs; - uint32_t _n_outputs; + uint32_t _systemic_audio_input_latency; + uint32_t _systemic_audio_output_latency; - uint32_t _systemic_audio_input_latency; - uint32_t _systemic_audio_output_latency; + /* coreaudio specific */ + uint32_t name_to_id(std::string) const; - /* coreaudio specific */ - uint32_t name_to_id(std::string) const; + /* processing */ + float _dsp_load; + ARDOUR::DSPLoadCalculator _dsp_load_calc; + uint64_t _processed_samples; - /* processing */ - float _dsp_load; - ARDOUR::DSPLoadCalculator _dsp_load_calc; - uint64_t _processed_samples; - - pthread_t _main_thread; - pthread_t _freeewheel_thread; + pthread_t _main_thread; + pthread_t _freeewheel_thread; - /* process threads */ - static void* coreaudio_process_thread (void *); - std::vector _threads; + /* process threads */ + static void* coreaudio_process_thread (void *); + std::vector _threads; - struct ThreadData { - CoreAudioBackend* engine; - boost::function f; - size_t stacksize; + struct ThreadData { + CoreAudioBackend* engine; + boost::function f; + size_t stacksize; - ThreadData (CoreAudioBackend* e, boost::function fp, size_t stacksz) - : engine (e) , f (fp) , stacksize (stacksz) {} - }; + ThreadData (CoreAudioBackend* e, boost::function fp, size_t stacksz) + : engine (e) , f (fp) , stacksize (stacksz) {} + }; - /* port engine */ - PortHandle add_port (const std::string& shortname, ARDOUR::DataType, ARDOUR::PortFlags); - int register_system_audio_ports (); - void unregister_ports (bool system_only = false); + /* port engine */ + PortHandle add_port (const std::string& shortname, ARDOUR::DataType, ARDOUR::PortFlags); + int register_system_audio_ports (); + void unregister_ports (bool system_only = false); - std::vector _ports; - std::vector _system_inputs; - std::vector _system_outputs; - std::vector _system_midi_in; - std::vector _system_midi_out; + std::vector _ports; + std::vector _system_inputs; + std::vector _system_outputs; + std::vector _system_midi_in; + std::vector _system_midi_out; - struct PortConnectData { - std::string a; - std::string b; - bool c; - - PortConnectData (const std::string& a, const std::string& b, bool c) - : a (a) , b (b) , c (c) {} - }; - - std::vector _port_connection_queue; - pthread_mutex_t _port_callback_mutex; - bool _port_change_flag; - - void port_connect_callback (const std::string& a, const std::string& b, bool conn) { - pthread_mutex_lock (&_port_callback_mutex); - _port_connection_queue.push_back(new PortConnectData(a, b, conn)); - pthread_mutex_unlock (&_port_callback_mutex); - } + struct PortConnectData { + std::string a; + std::string b; + bool c; + + PortConnectData (const std::string& a, const std::string& b, bool c) + : a (a) , b (b) , c (c) {} + }; + + std::vector _port_connection_queue; + pthread_mutex_t _port_callback_mutex; + bool _port_change_flag; + + void port_connect_callback (const std::string& a, const std::string& b, bool conn) { + pthread_mutex_lock (&_port_callback_mutex); + _port_connection_queue.push_back(new PortConnectData(a, b, conn)); + pthread_mutex_unlock (&_port_callback_mutex); + } - void port_connect_add_remove_callback () { - pthread_mutex_lock (&_port_callback_mutex); - _port_change_flag = true; - pthread_mutex_unlock (&_port_callback_mutex); - } + void port_connect_add_remove_callback () { + pthread_mutex_lock (&_port_callback_mutex); + _port_change_flag = true; + pthread_mutex_unlock (&_port_callback_mutex); + } - bool valid_port (PortHandle port) const { - return std::find (_ports.begin (), _ports.end (), (CoreBackendPort*)port) != _ports.end (); - } + bool valid_port (PortHandle port) const { + return std::find (_ports.begin (), _ports.end (), (CoreBackendPort*)port) != _ports.end (); + } - CoreBackendPort * find_port (const std::string& port_name) const { - for (std::vector::const_iterator it = _ports.begin (); it != _ports.end (); ++it) { - if ((*it)->name () == port_name) { - return *it; - } + CoreBackendPort * find_port (const std::string& port_name) const { + for (std::vector::const_iterator it = _ports.begin (); it != _ports.end (); ++it) { + if ((*it)->name () == port_name) { + return *it; } - return NULL; } + return NULL; + } - CoreBackendPort * find_port_in (std::vector plist, const std::string& port_name) const { - for (std::vector::const_iterator it = plist.begin (); it != plist.end (); ++it) { - if ((*it)->name () == port_name) { - return *it; - } + CoreBackendPort * find_port_in (std::vector plist, const std::string& port_name) const { + for (std::vector::const_iterator it = plist.begin (); it != plist.end (); ++it) { + if ((*it)->name () == port_name) { + return *it; } - return NULL; } - - void reset_midi_parsers (); + return NULL; + } + + void reset_midi_parsers (); }; // class CoreAudioBackend -- cgit v1.2.3