#include "ardour/types.h"
#include "ardour/audio_backend.h"
+#include "ardour/dsp_load_calculator.h"
namespace ARDOUR {
+class DummyAudioBackend;
+
+namespace DummyMidiData {
+ typedef struct _MIDISequence {
+ float beat_time;
+ uint8_t size;
+ uint8_t event[3];
+ } MIDISequence;
+};
+
+
class DummyMidiEvent {
public:
DummyMidiEvent (const pframes_t timestamp, const uint8_t* data, size_t size);
class DummyPort {
protected:
- DummyPort (const std::string&, PortFlags);
+ DummyPort (DummyAudioBackend &b, const std::string&, PortFlags);
public:
virtual ~DummyPort ();
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; }
virtual DataType type () const = 0;
bool is_connected (const DummyPort *port) const;
bool is_physically_connected () const;
- const std::vector<DummyPort *>& get_connections () const { return _connections; }
+ const std::set<DummyPort *>& get_connections () const { return _connections; }
int connect (DummyPort *port);
int disconnect (DummyPort *port);
void disconnect_all ();
virtual void* get_buffer (pframes_t nframes) = 0;
+ void next_period () { _gen_cycle = false; }
- const LatencyRange& latency_range (bool for_playback) const
+ const LatencyRange latency_range (bool for_playback) const
{
return for_playback ? _playback_latency_range : _capture_latency_range;
}
}
private:
+ DummyAudioBackend &_dummy_backend;
std::string _name;
+ std::string _pretty_name;
const PortFlags _flags;
LatencyRange _capture_latency_range;
LatencyRange _playback_latency_range;
- std::vector<DummyPort*> _connections;
+ std::set<DummyPort*> _connections;
void _connect (DummyPort* , bool);
void _disconnect (DummyPort* , bool);
+ protected:
+ // random number generator
+ void setup_random_number_generator ();
+ inline float randf ();
+ inline uint32_t randi ();
+ uint32_t _rseed;
+
+ // signal generator
+ volatile bool _gen_cycle;
+ Glib::Threads::Mutex generator_lock;
+
}; // class DummyPort
class DummyAudioPort : public DummyPort {
public:
- DummyAudioPort (const std::string&, PortFlags);
+ DummyAudioPort (DummyAudioBackend &b, const std::string&, PortFlags);
~DummyAudioPort ();
DataType type () const { return DataType::AUDIO; };
const Sample* const_buffer () const { return _buffer; }
void* get_buffer (pframes_t nframes);
+ enum GeneratorType {
+ Silence,
+ DC05,
+ Demolition,
+ UniformWhiteNoise,
+ GaussianWhiteNoise,
+ PinkNoise,
+ PonyNoise,
+ SineWave,
+ SquareWave,
+ KronekerDelta,
+ SineSweep,
+ SineSweepSwell,
+ SquareSweep,
+ SquareSweepSwell,
+ Loopback,
+ };
+ void setup_generator (GeneratorType const, float const);
+ void fill_wavetable (const float* d, size_t n_samples) { assert(_wavetable != 0); memcpy(_wavetable, d, n_samples * sizeof(float)); }
+ void midi_to_wavetable (DummyMidiBuffer const * const src, size_t n_samples);
+
private:
Sample _buffer[8192];
+
+ // signal generator ('fake' physical inputs)
+ void generate (const pframes_t n_samples);
+ GeneratorType _gen_type;
+
+ // generator buffers
+ // pink-noise filters
+ float _b0, _b1, _b2, _b3, _b4, _b5, _b6;
+ // generated sinf() samples
+ Sample * _wavetable;
+ uint32_t _gen_period;
+ uint32_t _gen_offset;
+ uint32_t _gen_perio2;
+ uint32_t _gen_count2;
+
+ // gaussian noise generator
+ float grandf ();
+ bool _pass;
+ float _rn1;
+
}; // class DummyAudioPort
class DummyMidiPort : public DummyPort {
public:
- DummyMidiPort (const std::string&, PortFlags);
+ DummyMidiPort (DummyAudioBackend &b, const std::string&, PortFlags);
~DummyMidiPort ();
DataType type () const { return DataType::MIDI; };
void* get_buffer (pframes_t nframes);
- const DummyMidiBuffer const_buffer () const { return _buffer; }
+ const DummyMidiBuffer * const_buffer () const { return &_buffer; }
+
+ void setup_generator (int, float const);
+ void set_loopback (DummyMidiBuffer const * const src);
private:
DummyMidiBuffer _buffer;
+ DummyMidiBuffer _loopback;
+
+ // midi event generator ('fake' physical inputs)
+ void midi_generate (const pframes_t n_samples);
+ float _midi_seq_spb; // samples per beat
+ int32_t _midi_seq_time;
+ uint32_t _midi_seq_pos;
+ DummyMidiData::MIDISequence const * _midi_seq_dat;
}; // class DummyMidiPort
class DummyAudioBackend : public AudioBackend {
+ friend class DummyPort;
public:
DummyAudioBackend (AudioEngine& e, AudioBackendInfo& info);
~DummyAudioBackend ();
+ bool is_running () const { return _running; }
+
/* AUDIOBACKEND API */
std::string name () const;
bool is_realtime () const;
+ bool requires_driver_selection() const { return true; }
+ std::string driver_name () const;
+ std::vector<std::string> enumerate_drivers () const;
+ int set_driver (const std::string&);
+
std::vector<DeviceStatus> enumerate_devices () const;
std::vector<float> available_sample_rates (const std::string& device) const;
std::vector<uint32_t> available_buffer_sizes (const std::string& device) const;
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;
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; }
/* External control app */
std::string control_app_name () const { return std::string (); }
int set_midi_option (const std::string&);
std::string midi_option () const;
+ std::vector<DeviceStatus> enumerate_midi_devices () const {
+ return std::vector<AudioBackend::DeviceStatus> ();
+ }
+ int set_midi_device_enabled (std::string const, bool) {
+ return 0;
+ }
+ bool midi_device_enabled (std::string const) const {
+ return true;
+ }
+ bool can_set_systemic_midi_latencies () const {
+ return false;
+ }
+
/* State Control */
protected:
int _start (bool for_latency_measurement);
size_t raw_buffer_size (DataType t);
/* Process time */
- pframes_t sample_time ();
- pframes_t sample_time_at_cycle_start ();
+ framepos_t sample_time ();
+ framepos_t sample_time_at_cycle_start ();
pframes_t samples_since_cycle_start ();
int create_process_thread (boost::function<void()> func);
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 set_port_property (PortHandle, const std::string& key, const std::string& value, const std::string& type);
+
int get_ports (const std::string& port_name_pattern, DataType type, PortFlags flags, std::vector<std::string>&) const;
DataType port_data_type (PortHandle) const;
void* main_process_thread ();
+ static size_t max_buffer_size() {return _max_buffer_size;}
+
private:
+ enum MidiPortMode {
+ MidiNoEvents,
+ MidiGenerator,
+ MidiLoopback,
+ MidiToAudio,
+ };
+
+ struct DriverSpeed {
+ std::string name;
+ float speedup;
+ DriverSpeed (const std::string& n, float s) : name (n), speedup (s) {}
+ };
+
std::string _instance_name;
+ static std::vector<std::string> _midi_options;
+ static std::vector<AudioBackend::DeviceStatus> _device_status;
+ static std::vector<DummyAudioBackend::DriverSpeed> _driver_speed;
+
bool _running;
+ bool _freewheel;
bool _freewheeling;
+ float _speedup;
+
+ std::string _device;
float _samplerate;
size_t _samples_per_period;
float _dsp_load;
+ DSPLoadCalculator _dsp_load_calc;
static size_t _max_buffer_size;
uint32_t _n_inputs;
uint32_t _n_outputs;
+ uint32_t _n_midi_inputs;
+ uint32_t _n_midi_outputs;
+ MidiPortMode _midi_mode;
+
uint32_t _systemic_input_latency;
uint32_t _systemic_output_latency;
- uint64_t _processed_samples;
+ framecnt_t _processed_samples;
pthread_t _main_thread;
/* port engine */
PortHandle add_port (const std::string& shortname, ARDOUR::DataType, ARDOUR::PortFlags);
int register_system_ports ();
- void unregister_system_ports ();
+ void unregister_ports (bool system_only = false);
+
+ std::vector<DummyAudioPort *> _system_inputs;
+ std::vector<DummyAudioPort *> _system_outputs;
+ std::vector<DummyMidiPort *> _system_midi_in;
+ std::vector<DummyMidiPort *> _system_midi_out;
- std::vector<DummyPort *> _ports;
+ typedef std::map<std::string, DummyPort *> PortMap; // fast lookup in _ports
+ typedef std::set<DummyPort *> PortIndex; // fast lookup in _ports
+ PortMap _portmap;
+ PortIndex _ports;
+
+ 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<PortConnectData *> _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);
+ }
bool valid_port (PortHandle port) const {
- return std::find (_ports.begin (), _ports.end (), (DummyPort*)port) != _ports.end ();
+ return _ports.find (static_cast<DummyPort*>(port)) != _ports.end ();
}
- DummyPort * find_port (const std::string& port_name) const {
- for (std::vector<DummyPort*>::const_iterator it = _ports.begin (); it != _ports.end (); ++it) {
- if ((*it)->name () == port_name) {
- return *it;
- }
+
+ DummyPort* find_port (const std::string& port_name) const {
+ PortMap::const_iterator it = _portmap.find (port_name);
+ if (it == _portmap.end()) {
+ return NULL;
}
- return NULL;
+ return (*it).second;
}
}; // class DummyAudioBackend
projects / ardour.git / blobdiff