libs/ardour/ardour/audio_backend.h

   1 /*
   2     Copyright (C) 2013 Paul Davis
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18 */
  19
  20 #ifndef __libardour_audiobackend_h__
  21 #define __libardour_audiobackend_h__
  22
  23 #include <string>
  24 #include <vector>
  25
  26 #include <stdint.h>
  27 #include <stdlib.h>
  28
  29 #include <boost/function.hpp>
  30
  31 #include "ardour/libardour_visibility.h"
  32 #include "ardour/types.h"
  33 #include "ardour/audioengine.h"
  34 #include "ardour/port_engine.h"
  35
  36 #ifdef ARDOURBACKEND_DLL_EXPORTS // defined if we are building the ARDOUR Panners DLLs (instead of using them)
  37     #define ARDOURBACKEND_API LIBARDOUR_DLL_EXPORT
  38 #else
  39     #define ARDOURBACKEND_API LIBARDOUR_DLL_IMPORT
  40 #endif
  41 #define ARDOURBACKEND_LOCAL LIBARDOUR_DLL_LOCAL
  42
  43 namespace ARDOUR {
  44
  45 struct LIBARDOUR_API AudioBackendInfo {
  46     const char* name;
  47
  48     /** Using arg1 and arg2, initialize this audiobackend.
  49      *
  50      * Returns zero on success, non-zero otherwise.
  51      */
  52     int (*instantiate) (const std::string& arg1, const std::string& arg2);
  53
  54     /** Release all resources associated with this audiobackend
  55      */
  56     int (*deinstantiate) (void);
  57
  58     /** Factory method to create an AudioBackend-derived class.
  59      *
  60      * Returns a valid shared_ptr to the object if successfull,
  61      * or a "null" shared_ptr otherwise.
  62      */
  63     boost::shared_ptr<AudioBackend> (*factory) (AudioEngine&);
  64
  65     /** Return true if the underlying mechanism/API has been
  66      * configured and does not need (re)configuration in order
  67      * to be usable. Return false otherwise.
  68      *
  69      * Note that this may return true if (re)configuration, even though
  70      * not currently required, is still possible.
  71      */
  72     bool (*already_configured)();
  73
  74     /** Return true if the underlying mechanism/API can be
  75      * used on the given system.
  76      *
  77      * If this function returns false, the backend is not
  78      * listed in the engine dialog.
  79      */
  80     bool (*available)();
  81 };
  82
  83 class LIBARDOUR_API AudioBackend : public PortEngine {
  84   public:
  85
  86     AudioBackend (AudioEngine& e, AudioBackendInfo& i) : PortEngine (e), _info (i), engine (e) {}
  87     virtual ~AudioBackend () {}
  88
  89     /** Return the AudioBackendInfo object from which this backend
  90         was constructed.
  91     */
  92     AudioBackendInfo& info() const { return _info; }
  93
  94     /** Return the name of this backend.
  95      *
  96      * Should use a well-known, unique term. Expected examples
  97      * might include "JACK", "CoreAudio", "ASIO" etc.
  98      */
  99     virtual std::string name() const = 0;
 100
 101     /** Return true if the callback from the underlying mechanism/API
 102      * (CoreAudio, JACK, ASIO etc.) occurs in a thread subject to realtime
 103      * constraints. Return false otherwise.
 104     */
 105     virtual bool is_realtime () const = 0;
 106
 107     /* Discovering devices and parameters */
 108
 109     /** Return true if this backend requires the selection of a "driver"
 110      * before any device can be selected. Return false otherwise.
 111      *
 112      * Intended mainly to differentiate between meta-APIs like JACK
 113      * which can still expose different backends (such as ALSA or CoreAudio
 114      * or FFADO or netjack) and those like ASIO or CoreAudio which
 115      * do not.
 116      */
 117     virtual bool requires_driver_selection() const { return false; }
 118
 119     /** If the return value of requires_driver_selection() is true,
 120      * then this function can return the list of known driver names.
 121      *
 122      * If the return value of requires_driver_selection() is false,
 123      * then this function should not be called. If it is called
 124      * its return value is an empty vector of strings.
 125      */
 126     virtual std::vector<std::string> enumerate_drivers() const { return std::vector<std::string>(); }
 127
 128     /** Returns zero if the backend can successfully use @param name as the
 129      * driver, non-zero otherwise.
 130      *
 131      * Should not be used unless the backend returns true from
 132      * requires_driver_selection()
 133      */
 134     virtual int set_driver (const std::string& /*drivername*/) { return 0; }
 135
 136     /** used to list device names along with whether or not they are currently
 137      *  available.
 138     */
 139     struct DeviceStatus {
 140         std::string name;
 141         bool        available;
 142
 143         DeviceStatus (const std::string& s, bool avail) : name (s), available (avail) {}
 144     };
 145
 146     /** An optional alternate interface for backends to provide a facility to
 147      * select separate input and output devices.
 148      *
 149      * If a backend returns true then enumerate_input_devices() and
 150      * enumerate_output_devices() will be used instead of enumerate_devices()
 151      * to enumerate devices. Similarly set_input/output_device_name() should
 152      * be used to set devices instead of set_device_name().
 153      */
 154     virtual bool use_separate_input_and_output_devices () const { return false; }
 155
 156     /** Returns a collection of DeviceStatuses identifying devices discovered
 157      * by this backend since the start of the process.
 158      *
 159      * Any of the names in each DeviceStatus may be used to identify a
 160      * device in other calls to the backend, though any of them may become
 161      * invalid at any time.
 162      */
 163     virtual std::vector<DeviceStatus> enumerate_devices () const = 0;
 164
 165     /** Returns a collection of DeviceStatuses identifying input devices
 166      * discovered by this backend since the start of the process.
 167      *
 168      * Any of the names in each DeviceStatus may be used to identify a
 169      * device in other calls to the backend, though any of them may become
 170      * invalid at any time.
 171      */
 172     virtual std::vector<DeviceStatus> enumerate_input_devices () const
 173     { return std::vector<DeviceStatus>(); }
 174
 175     /** Returns a collection of DeviceStatuses identifying output devices
 176      * discovered by this backend since the start of the process.
 177      *
 178      * Any of the names in each DeviceStatus may be used to identify a
 179      * device in other calls to the backend, though any of them may become
 180      * invalid at any time.
 181      */
 182     virtual std::vector<DeviceStatus> enumerate_output_devices () const
 183     { return std::vector<DeviceStatus>(); }
 184
 185     /** Returns a collection of float identifying sample rates that are
 186      * potentially usable with the hardware identified by @param device.
 187      * Any of these values may be supplied in other calls to this backend
 188      * as the desired sample rate to use with the name device, but the
 189      * requested sample rate may turn out to be unavailable, or become invalid
 190      * at any time.
 191      */
 192     virtual std::vector<float> available_sample_rates (const std::string& device) const = 0;
 193
 194     /* backends that support separate input and output devices should
 195      * implement this function and return an intersection (not union) of available
 196      * sample rates valid for the given input + output device combination.
 197      */
 198     virtual std::vector<float> available_sample_rates (const std::string& input_device, const std::string& output_device) const {
 199             std::vector<float> input_sizes  = available_sample_rates (input_device);
 200             std::vector<float> output_sizes = available_sample_rates (output_device);
 201             std::vector<float> rv;
 202             std::set_union (input_sizes.begin (), input_sizes.end (),
 203                             output_sizes.begin (), output_sizes.end (),
 204                             std::back_inserter (rv));
 205             return rv;
 206     }
 207
 208     /* Returns the default sample rate that will be shown to the user when
 209      * configuration options are first presented. If the derived class
 210      * needs or wants to override this, it can. It also MUST override this
 211      * if there is any chance that an SR of 44.1kHz is not in the list
 212      * returned by available_sample_rates()
 213      */
 214     virtual float default_sample_rate () const {
 215             return 44100.0;
 216     }
 217
 218     /** Returns a collection of uint32 identifying buffer sizes that are
 219      * potentially usable with the hardware identified by @param device.
 220      * Any of these values may be supplied in other calls to this backend
 221      * as the desired buffer size to use with the name device, but the
 222      * requested buffer size may turn out to be unavailable, or become invalid
 223      * at any time.
 224      */
 225     virtual std::vector<uint32_t> available_buffer_sizes (const std::string& device) const = 0;
 226
 227     /* backends that support separate input and output devices should
 228      * implement this function and return an intersection (not union) of available
 229      * buffer sizes valid for the given input + output device combination.
 230      */
 231     virtual std::vector<uint32_t> available_buffer_sizes (const std::string& input_device, const std::string& output_device) const {
 232             std::vector<uint32_t> input_rates  = available_buffer_sizes (input_device);
 233             std::vector<uint32_t> output_rates = available_buffer_sizes (output_device);
 234             std::vector<uint32_t> rv;
 235             std::set_union (input_rates.begin (), input_rates.end (),
 236                             output_rates.begin (), output_rates.end (),
 237                             std::back_inserter (rv));
 238             return rv;
 239     }
 240     /* Returns the default buffer size that will be shown to the user when
 241      * configuration options are first presented. If the derived class
 242      * needs or wants to override this, it can. It also MUST override this
 243      * if there is any chance that a buffer size of 1024 is not in the list
 244      * returned by available_buffer_sizes()
 245      */
 246     virtual uint32_t default_buffer_size (const std::string& device) const {
 247             return 1024;
 248     }
 249
 250     /** Returns the maximum number of input channels that are potentially
 251      * usable with the hardware identified by @param device.  Any number from 1
 252      * to the value returned may be supplied in other calls to this backend as
 253      * the input channel count to use with the name device, but the requested
 254      * count may turn out to be unavailable, or become invalid at any time.
 255      */
 256     virtual uint32_t available_input_channel_count (const std::string& device) const = 0;
 257
 258     /** Returns the maximum number of output channels that are potentially
 259      * usable with the hardware identified by @param device.  Any number from 1
 260      * to the value returned may be supplied in other calls to this backend as
 261      * the output channel count to use with the name device, but the requested
 262      * count may turn out to be unavailable, or become invalid at any time.
 263      */
 264     virtual uint32_t available_output_channel_count (const std::string& device) const = 0;
 265
 266     /* Return true if the derived class can change the sample rate of the
 267      * device in use while the device is already being used. Return false
 268      * otherwise. (example: JACK cannot do this as of September 2013)
 269      */
 270     virtual bool can_change_sample_rate_when_running () const = 0;
 271     /* Return true if the derived class can change the buffer size of the
 272      * device in use while the device is already being used. Return false
 273      * otherwise.
 274      */
 275     virtual bool can_change_buffer_size_when_running () const = 0;
 276
 277     /* Set the hardware parameters.
 278      *
 279      * If called when the current state is stopped or paused,
 280      * the changes will not take effect until the state changes to running.
 281      *
 282      * If called while running, the state will change as fast as the
 283      * implementation allows.
 284      *
 285      * All set_*() methods return zero on success, non-zero otherwise.
 286      */
 287
 288     /** Set the name of the device to be used
 289      */
 290     virtual int set_device_name (const std::string&) = 0;
 291
 292     /** Set the name of the input device to be used if using separate
 293      * input/output devices.
 294      *
 295      * @see use_separate_input_and_output_devices()
 296      */
 297     virtual int set_input_device_name (const std::string&) { return 0;}
 298
 299     /** Set the name of the output device to be used if using separate
 300      * input/output devices.
 301      *
 302      * @see use_separate_input_and_output_devices()
 303      */
 304     virtual int set_output_device_name (const std::string&) { return 0;}
 305
 306     /** Deinitialize and destroy current device
 307      */
 308         virtual int drop_device() {return 0;};
 309     /** Set the sample rate to be used
 310      */
 311     virtual int set_sample_rate (float) = 0;
 312     /** Set the buffer size to be used.
 313      *
 314      * The device is assumed to use a double buffering scheme, so that one
 315      * buffer's worth of data can be processed by hardware while software works
 316      * on the other buffer. All known suitable audio APIs support this model
 317      * (though ALSA allows for alternate numbers of buffers, and CoreAudio
 318      * doesn't directly expose the concept).
 319      */
 320     virtual int set_buffer_size (uint32_t) = 0;
 321     /** Set the preferred underlying hardware data layout.
 322      * If @param yn is true, then the hardware will interleave
 323      * samples for successive channels; otherwise, the hardware will store
 324      * samples for a single channel contiguously.
 325      *
 326      * Setting this does not change the fact that all data streams
 327      * to and from Ports are mono (essentially, non-interleaved)
 328      */
 329     virtual int set_interleaved (bool yn) = 0;
 330     /** Set the number of input channels that should be used
 331      */
 332     virtual int set_input_channels (uint32_t) = 0;
 333     /** Set the number of output channels that should be used
 334      */
 335     virtual int set_output_channels (uint32_t) = 0;
 336     /** Set the (additional) input latency that cannot be determined via
 337      * the implementation's underlying code (e.g. latency from
 338      * external D-A/D-A converters. Units are samples.
 339      */
 340     virtual int set_systemic_input_latency (uint32_t) = 0;
 341     /** Set the (additional) output latency that cannot be determined via
 342      * the implementation's underlying code (e.g. latency from
 343      * external D-A/D-A converters. Units are samples.
 344      */
 345     virtual int set_systemic_output_latency (uint32_t) = 0;
 346     /** Set the (additional) input latency for a specific midi device,
 347      * or if the identifier is empty, apply to all midi devices.
 348      */
 349     virtual int set_systemic_midi_input_latency (std::string const, uint32_t) = 0;
 350     /** Set the (additional) output latency for a specific midi device,
 351      * or if the identifier is empty, apply to all midi devices.
 352      */
 353     virtual int set_systemic_midi_output_latency (std::string const, uint32_t) = 0;
 354
 355     /* Retrieving parameters */
 356
 357     virtual std::string  device_name () const = 0;
 358     virtual std::string  input_device_name () const { return std::string(); }
 359     virtual std::string  output_device_name () const { return std::string(); }
 360     virtual float        sample_rate () const = 0;
 361     virtual uint32_t     buffer_size () const = 0;
 362     virtual bool         interleaved () const = 0;
 363     virtual uint32_t     input_channels () const = 0;
 364     virtual uint32_t     output_channels () const = 0;
 365     virtual uint32_t     systemic_input_latency () const = 0;
 366     virtual uint32_t     systemic_output_latency () const = 0;
 367     virtual uint32_t     systemic_midi_input_latency (std::string const) const = 0;
 368     virtual uint32_t     systemic_midi_output_latency (std::string const) const = 0;
 369
 370     /** override this if this implementation returns true from
 371      * requires_driver_selection()
 372      */
 373     virtual std::string  driver_name() const { return std::string(); }
 374
 375     /** Return the name of a control application for the
 376      * selected/in-use device. If no such application exists,
 377      * or if no device has been selected or is in-use,
 378      * return an empty string.
 379      */
 380     virtual std::string control_app_name() const = 0;
 381     /** Launch the control app for the currently in-use or
 382      * selected device. May do nothing if the control
 383      * app is undefined or cannot be launched.
 384      */
 385     virtual void launch_control_app () = 0;
 386
 387     /* @return a vector of strings that describe the available
 388      * MIDI options.
 389      *
 390      * These can be presented to the user to decide which
 391      * MIDI drivers, options etc. can be used. The returned strings
 392      * should be thought of as the key to a map of possible
 393      * approaches to handling MIDI within the backend. Ensure that
 394      * the strings will make sense to the user.
 395      */
 396     virtual std::vector<std::string> enumerate_midi_options () const = 0;
 397
 398     /* Request the use of the MIDI option named @param option, which
 399      * should be one of the strings returned by enumerate_midi_options()
 400      *
 401      * @return zero if successful, non-zero otherwise
 402      */
 403     virtual int set_midi_option (const std::string& option) = 0;
 404
 405     virtual std::string midi_option () const = 0;
 406
 407     /** Detailed MIDI device list - if available */
 408     virtual std::vector<DeviceStatus> enumerate_midi_devices () const = 0;
 409
 410     /** mark a midi-devices as enabled */
 411     virtual int set_midi_device_enabled (std::string const, bool) = 0;
 412
 413     /** query if a midi-device is enabled */
 414     virtual bool midi_device_enabled (std::string const) const = 0;
 415
 416     /** if backend supports systemic_midi_[in|ou]tput_latency() */
 417     virtual bool can_set_systemic_midi_latencies () const = 0;
 418
 419     /* State Control */
 420
 421     /** Start using the device named in the most recent call
 422      * to set_device(), with the parameters set by various
 423      * the most recent calls to set_sample_rate() etc. etc.
 424      *
 425      * At some undetermined time after this function is successfully called,
 426      * the backend will start calling the ::process_callback() method of
 427      * the AudioEngine referenced by @param engine. These calls will
 428      * occur in a thread created by and/or under the control of the backend.
 429      *
 430      * @param for_latency_measurement if true, the device is being started
 431      *        to carry out latency measurements and the backend should this
 432      *        take care to return latency numbers that do not reflect
 433      *        any existing systemic latency settings.
 434      *
 435      * Return zero if successful, negative values otherwise.
 436      *
 437      *
 438      *
 439      *
 440      * Why is this non-virtual but ::_start() is virtual ?
 441      * Virtual methods with default parameters create possible ambiguity
 442      * because a derived class may implement the same method with a different
 443      * type or value of default parameter.
 444      *
 445      * So we make this non-virtual method to avoid possible overrides of
 446      * default parameters. See Scott Meyers or other books on C++ to understand
 447      * this pattern, or possibly just this:
 448      *
 449      * http://stackoverflow.com/questions/12139786/good-pratice-default-arguments-for-pure-virtual-method
 450      */
 451     int start (bool for_latency_measurement=false) {
 452             return _start (for_latency_measurement);
 453     }
 454
 455     /** Stop using the device currently in use.
 456      *
 457      * If the function is successfully called, no subsequent calls to the
 458      * process_callback() of @param engine will be made after the function
 459      * returns, until parameters are reset and start() are called again.
 460      *
 461      * The backend is considered to be un-configured after a successful
 462      * return, and requires calls to set hardware parameters before it can be
 463      * start()-ed again. See pause() for a way to avoid this. stop() should
 464      * only be used when reconfiguration is required OR when there are no
 465      * plans to use the backend in the future with a reconfiguration.
 466      *
 467      * Return zero if successful, 1 if the device is not in use, negative values on error
 468      */
 469     virtual int stop () = 0;
 470
 471          /** Reset device.
 472      *
 473      * Return zero if successful, negative values on error
 474      */
 475         virtual int reset_device() = 0;
 476
 477     /** While remaining connected to the device, and without changing its
 478      * configuration, start (or stop) calling the process_callback() of @param engine
 479      * without waiting for the device. Once process_callback() has returned, it
 480      * will be called again immediately, thus allowing for faster-than-realtime
 481      * processing.
 482      *
 483      * All registered ports remain in existence and all connections remain
 484      * unaltered. However, any physical ports should NOT be used by the
 485      * process_callback() during freewheeling - the data behaviour is undefined.
 486      *
 487      * If @param start_stop is true, begin this behaviour; otherwise cease this
 488      * behaviour if it currently occuring, and return to calling
 489      * process_callback() of @param engine by waiting for the device.
 490      *
 491      * Return zero on success, non-zero otherwise.
 492      */
 493     virtual int freewheel (bool start_stop) = 0;
 494
 495     /** return the fraction of the time represented by the current buffer
 496      * size that is being used for each buffer process cycle, as a value
 497      * from 0.0 to 1.0
 498      *
 499      * E.g. if the buffer size represents 5msec and current processing
 500      * takes 1msec, the returned value should be 0.2.
 501      *
 502      * Implementations can feel free to smooth the values returned over
 503      * time (e.g. high pass filtering, or its equivalent).
 504      */
 505     virtual float dsp_load() const  = 0;
 506
 507     /* Transport Control (JACK is the only audio API that currently offers
 508        the concept of shared transport control)
 509     */
 510
 511     /** Attempt to change the transport state to TransportRolling.
 512      */
 513     virtual void transport_start () {}
 514     /** Attempt to change the transport state to TransportStopped.
 515      */
 516     virtual void transport_stop () {}
 517     /** return the current transport state
 518      */
 519     virtual TransportState transport_state () const { return TransportStopped; }
 520     /** Attempt to locate the transport to @param pos
 521      */
 522     virtual void transport_locate (framepos_t /*pos*/) {}
 523     /** Return the current transport location, in samples measured
 524      * from the origin (defined by the transport time master)
 525      */
 526     virtual framepos_t transport_frame() const { return 0; }
 527
 528     /** If @param yn is true, become the time master for any inter-application transport
 529      * timebase, otherwise cease to be the time master for the same.
 530      *
 531      * Return zero on success, non-zero otherwise
 532      *
 533      * JACK is the only currently known audio API with the concept of a shared
 534      * transport timebase.
 535      */
 536     virtual int set_time_master (bool /*yn*/) { return 0; }
 537
 538     virtual int        usecs_per_cycle () const { return 1000000 * (buffer_size() / sample_rate()); }
 539     virtual size_t     raw_buffer_size (DataType t) = 0;
 540
 541     /* Process time */
 542
 543     /** return the time according to the sample clock in use, measured in
 544      * samples since an arbitrary zero time in the past. The value should
 545      * increase monotonically and linearly, without interruption from any
 546      * source (including CPU frequency scaling).
 547      *
 548      * It is extremely likely that any implementation will use a DLL, since
 549      * this function can be called from any thread, at any time, and must be
 550      * able to accurately determine the correct sample time.
 551      *
 552      * Can be called from any thread.
 553      */
 554     virtual framepos_t sample_time () = 0;
 555
 556     /** Return the time according to the sample clock in use when the most
 557      * recent buffer process cycle began. Can be called from any thread.
 558      */
 559     virtual framepos_t sample_time_at_cycle_start () = 0;
 560
 561     /** Return the time since the current buffer process cycle started,
 562      * in samples, according to the sample clock in use.
 563      *
 564      * Can ONLY be called from within a process() callback tree (which
 565      * implies that it can only be called by a process thread)
 566      */
 567     virtual pframes_t samples_since_cycle_start () = 0;
 568
 569     /** Return true if it possible to determine the offset in samples of the
 570      * first video frame that starts within the current buffer process cycle,
 571      * measured from the first sample of the cycle. If returning true,
 572      * set @param offset to that offset.
 573      *
 574      * Eg. if it can be determined that the first video frame within the cycle
 575      * starts 28 samples after the first sample of the cycle, then this method
 576      * should return true and set @param offset to 28.
 577      *
 578      * May be impossible to support outside of JACK, which has specific support
 579      * (in some cases, hardware support) for this feature.
 580      *
 581      * Can ONLY be called from within a process() callback tree (which implies
 582      * that it can only be called by a process thread)
 583      */
 584     virtual bool get_sync_offset (pframes_t& /*offset*/) const { return false; }
 585
 586     /** Create a new thread suitable for running part of the buffer process
 587      * cycle (i.e. Realtime scheduling, memory allocation, etc. etc are all
 588      * correctly setup), with a stack size given in bytes by specified @param
 589      * stacksize. The thread will begin executing @param func, and will exit
 590      * when that function returns.
 591      */
 592     virtual int create_process_thread (boost::function<void()> func) = 0;
 593
 594     /** Wait for all processing threads to exit.
 595      *
 596      * Return zero on success, non-zero on failure.
 597      */
 598     virtual int join_process_threads () = 0;
 599
 600     /** Return true if execution context is in a backend thread
 601      */
 602     virtual bool in_process_thread () = 0;
 603
 604     /** Return the minimum stack size of audio threads in bytes
 605      */
 606     static size_t thread_stack_size () { return 100000; }
 607
 608     /** Return number of processing threads
 609      */
 610     virtual uint32_t process_thread_count () = 0;
 611
 612     virtual void update_latencies () = 0;
 613
 614     /** Set @param speed and @param position to the current speed and position
 615      * indicated by some transport sync signal.  Return whether the current
 616      * transport state is pending, or finalized.
 617      *
 618      * Derived classes only need implement this if they provide some way to
 619      * sync to a transport sync signal (e.g. Sony 9 Pin) that is not
 620      * handled by Ardour itself (LTC and MTC are both handled by Ardour).
 621      * The canonical example is JACK Transport.
 622      */
 623      virtual bool speed_and_position (double& speed, framepos_t& position) {
 624              speed = 0.0;
 625              position = 0;
 626              return false;
 627      }
 628
 629   protected:
 630      AudioBackendInfo&  _info;
 631      AudioEngine&        engine;
 632
 633      virtual int _start (bool for_latency_measurement) = 0;
 634 };
 635
 636 } // namespace
 637
 638 #endif /* __libardour_audiobackend_h__ */
 639