namespace ARDOUR {
+struct LIBARDOUR_API AudioBackendInfo {
+ const char* name;
+
+ /** Using arg1 and arg2, initialize this audiobackend.
+ *
+ * Returns zero on success, non-zero otherwise.
+ */
+ int (*instantiate) (const std::string& arg1, const std::string& arg2);
+
+ /** Release all resources associated with this audiobackend
+ */
+ int (*deinstantiate) (void);
+
+ /** Factory method to create an AudioBackend-derived class.
+ *
+ * Returns a valid shared_ptr to the object if successfull,
+ * or a "null" shared_ptr otherwise.
+ */
+ boost::shared_ptr<AudioBackend> (*factory) (AudioEngine&);
+
+ /** Return true if the underlying mechanism/API has been
+ * configured and does not need (re)configuration in order
+ * to be usable. Return false otherwise.
+ *
+ * Note that this may return true if (re)configuration, even though
+ * not currently required, is still possible.
+ */
+ bool (*already_configured)();
+
+ /** Return true if the underlying mechanism/API can be
+ * used on the given system.
+ *
+ * If this function returns false, the backend is not
+ * listed in the engine dialog.
+ */
+ bool (*available)();
+};
+
class LIBARDOUR_API AudioBackend : public PortEngine {
public:
- AudioBackend (AudioEngine& e) : PortEngine (e), engine (e) {}
+ AudioBackend (AudioEngine& e, AudioBackendInfo& i) : PortEngine (e), _info (i), engine (e) {}
virtual ~AudioBackend () {}
+
+ /** Return the AudioBackendInfo object from which this backend
+ was constructed.
+ */
+ AudioBackendInfo& info() const { return _info; }
/** Return the name of this backend.
*
* if there is any chance that a buffer size of 1024 is not in the list
* returned by available_buffer_sizes()
*/
- virtual uint32_t default_buffer_size () const {
+ virtual uint32_t default_buffer_size (const std::string& device) const {
return 1024;
}
/** Set the name of the device to be used
*/
virtual int set_device_name (const std::string&) = 0;
+ /** Deinitialize and destroy current device
+ */
+ virtual int drop_device() {return 0;};
/** Set the sample rate to be used
*/
virtual int set_sample_rate (float) = 0;
* external D-A/D-A converters. Units are samples.
*/
virtual int set_systemic_output_latency (uint32_t) = 0;
+ /** Set the (additional) input latency for a specific midi device,
+ * or if the identifier is empty, apply to all midi devices.
+ */
+ virtual int set_systemic_midi_input_latency (std::string const, uint32_t) = 0;
+ /** Set the (additional) output latency for a specific midi device,
+ * or if the identifier is empty, apply to all midi devices.
+ */
+ virtual int set_systemic_midi_output_latency (std::string const, uint32_t) = 0;
/* Retrieving parameters */
virtual uint32_t output_channels () const = 0;
virtual uint32_t systemic_input_latency () const = 0;
virtual uint32_t systemic_output_latency () const = 0;
+ virtual uint32_t systemic_midi_input_latency (std::string const) const = 0;
+ virtual uint32_t systemic_midi_output_latency (std::string const) const = 0;
/** override this if this implementation returns true from
* requires_driver_selection()
virtual int set_midi_option (const std::string& option) = 0;
virtual std::string midi_option () const = 0;
-
+
+ /** Detailed MIDI device list - if available */
+ virtual std::vector<DeviceStatus> enumerate_midi_devices () const = 0;
+
+ /** mark a midi-devices as enabled */
+ virtual int set_midi_device_enabled (std::string const, bool) = 0;
+
+ /** query if a midi-device is enabled */
+ virtual bool midi_device_enabled (std::string const) const = 0;
+
+ /** if backend supports systemic_midi_[in|ou]tput_latency() */
+ virtual bool can_set_systemic_midi_latencies () const = 0;
+
/* State Control */
/** Start using the device named in the most recent call
*/
virtual int stop () = 0;
+ /** Reset device.
+ *
+ * Return zero if successful, negative values on error
+ */
+ virtual int reset_device() = 0;
+
/** While remaining connected to the device, and without changing its
* configuration, start (or stop) calling the process_callback() of @param engine
* without waiting for the device. Once process_callback() has returned, it
*
* Can be called from any thread.
*/
- virtual pframes_t sample_time () = 0;
+ virtual framepos_t sample_time () = 0;
/** Return the time according to the sample clock in use when the most
* recent buffer process cycle began. Can be called from any thread.
*/
- virtual pframes_t sample_time_at_cycle_start () = 0;
+ virtual framepos_t sample_time_at_cycle_start () = 0;
/** Return the time since the current buffer process cycle started,
* in samples, according to the sample clock in use.
}
protected:
- AudioEngine& engine;
-
- virtual int _start (bool for_latency_measurement) = 0;
-};
-
-struct LIBARDOUR_API AudioBackendInfo {
- const char* name;
-
- /** Using arg1 and arg2, initialize this audiobackend.
- *
- * Returns zero on success, non-zero otherwise.
- */
- int (*instantiate) (const std::string& arg1, const std::string& arg2);
+ AudioBackendInfo& _info;
+ AudioEngine& engine;
- /** Release all resources associated with this audiobackend
- */
- int (*deinstantiate) (void);
-
- /** Factory method to create an AudioBackend-derived class.
- *
- * Returns a valid shared_ptr to the object if successfull,
- * or a "null" shared_ptr otherwise.
- */
- boost::shared_ptr<AudioBackend> (*factory) (AudioEngine&);
-
- /** Return true if the underlying mechanism/API has been
- * configured and does not need (re)configuration in order
- * to be usable. Return false otherwise.
- *
- * Note that this may return true if (re)configuration, even though
- * not currently required, is still possible.
- */
- bool (*already_configured)();
+ virtual int _start (bool for_latency_measurement) = 0;
};
} // namespace
projects / ardour.git / blobdiff