#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);
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;
}
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 {
const Sample* const_buffer () const { return _buffer; }
void* get_buffer (pframes_t nframes);
+ enum GeneratorType {
+ Silence,
+ 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 {
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 {
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);
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_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;
-
struct PortConnectData {
std::string a;
std::string b;
projects / ardour.git / blobdiff