diff options
author | Paul Davis <paul@linuxaudiosystems.com> | 2013-07-24 19:29:45 -0400 |
---|---|---|
committer | Paul Davis <paul@linuxaudiosystems.com> | 2013-07-24 19:29:45 -0400 |
commit | 9ac6bb9befa047a6c349bed02d40da84600b67cc (patch) | |
tree | 5b88f453b8f43d2a43b31cb15b0b50acd6f9eb4a /libs/ardour/ardour/port_engine.h | |
parent | 3d95822716d2e52b54a5bdbe7be4478ab034f8db (diff) |
part-way through getting the audioengine changes to compile
Diffstat (limited to 'libs/ardour/ardour/port_engine.h')
-rw-r--r-- | libs/ardour/ardour/port_engine.h | 139 |
1 files changed, 139 insertions, 0 deletions
diff --git a/libs/ardour/ardour/port_engine.h b/libs/ardour/ardour/port_engine.h new file mode 100644 index 0000000000..3bea32620e --- /dev/null +++ b/libs/ardour/ardour/port_engine.h @@ -0,0 +1,139 @@ +/* + Copyright (C) 2013 Paul Davis + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + +*/ + +#ifndef __libardour_port_engine_h__ +#define __libardour_port_engine_h__ + +#include <vector> +#include <string> + +#include <stdint.h> + +#include "ardour/data_type.h" +#include "ardour/types.h" + +namespace ARDOUR { + +/** PortEngine is an abstract base class that defines the functionality + * required by Ardour. + * + * A Port is basically an endpoint for a datastream (which can either be + * continuous, like audio, or event-based, like MIDI). Ports have buffers + * associated with them into which data can be written (if they are output + * ports) and from which data can be read (if they input ports). Ports can be + * connected together so that data written to an output port can be read from + * an input port. These connections can be 1:1, 1:N OR N:1. + * + * Ports may be associated with software only, or with hardware. Hardware + * related ports are often referred to as physical, and correspond to some + * relevant physical entity on a hardware device, such as an audio jack or a + * MIDI connector. Physical ports may be potentially asked to monitor their + * inputs, though some implementations may not support this. + * + * Most physical ports will also be considered "terminal", which means that + * data delivered there or read from there will go to or comes from a system + * outside of the PortEngine implementation's control (e.g. the analog domain + * for audio, or external MIDI devices for MIDI). Non-physical ports can also + * be considered "terminal". For example, the output port of a software + * synthesizer is a terminal port, because the data contained in its buffer + * does not and cannot be considered to come from any other port - it is + * synthesized by its owner. + * + * Ports also have latency associated with them. Each port has a playback + * latency and a capture latency: + * + * <b>capture latency</b>: how long since the data read from the buffer of a + * port arrived at at a terminal port. The data will have + * come from the "outside world" if the terminal port is also + * physical, or will have been synthesized by the entity that + * owns the terminal port. + * + * <b>playback latency</b>: how long until the data written to the buffer of + * port will reach a terminal port. + * + * + * For more detailed questions about the PortEngine API, consult the JACK API + * documentation, on which this entire object is based. + */ + +class PortEngine { + public: + PortEngine() {} + virtual ~PortEngine(); + + /* We use void* here so that the API can be defined for any implementation. + * + * We could theoretically use a template (PortEngine<T>) and define + * PortHandle as T, but this complicates the desired inheritance + * pattern in which FooPortEngine handles things for the Foo API, + * rather than being a derivative of PortEngine<Foo>. + */ + + typedef void* PortHandle; + + virtual bool connected() const = 0; + + virtual int set_port_name (PortHandle, const std::string&) = 0; + virtual std::string get_port_name (PortHandle) const = 0; + virtual PortHandle* get_port_by_name (const std::string&) const = 0; + + virtual PortHandle register_port (const std::string&, DataType::Symbol, ARDOUR::PortFlags) = 0; + virtual void unregister_port (PortHandle) = 0; + virtual bool connected (PortHandle) = 0; + virtual int disconnect_all (PortHandle) = 0; + virtual bool connected_to (PortHandle, const std::string&) = 0; + virtual int get_connections (PortHandle, std::vector<std::string>&) = 0; + virtual bool physically_connected (PortHandle) = 0; + virtual int connect (PortHandle, const std::string&) = 0; + virtual int disconnect (PortHandle, const std::string&) = 0; + + /* MIDI */ + + virtual void midi_event_get (pframes_t& timestamp, size_t& size, uint8_t** buf, void* port_buffer, uint32_t event_index) = 0; + virtual int midi_event_put (void* port_buffer, pframes_t timestamp, const uint8_t* buffer, size_t size) = 0; + virtual uint32_t get_midi_event_count (void* port_buffer); + virtual void midi_clear (void* port_buffer); + + /* Monitoring */ + + virtual bool can_monitor_input() const = 0; + virtual int request_input_monitoring (PortHandle, bool) = 0; + virtual int ensure_input_monitoring (PortHandle, bool) = 0; + virtual bool monitoring_input (PortHandle) = 0; + + /* Latency management + */ + + struct LatencyRange { + uint32_t min; + uint32_t max; + }; + + virtual void set_latency_range (PortHandle, int dir, LatencyRange) = 0; + virtual LatencyRange get_latency_range (PortHandle, int dir) = 0; + virtual LatencyRange get_connected_latency_range (PortHandle, int dir) = 0; + + virtual void* get_buffer (PortHandle, pframes_t) = 0; + + virtual pframes_t last_frame_time () const = 0; +}; + +} + +#endif /* __libardour_port_engine_h__ */ |