don't take temporary copy of MIDI sequence

[ardour.git] / libs / backends / dummy / dummy_audiobackend.h

diff --git a/libs/backends/dummy/dummy_audiobackend.h b/libs/backends/dummy/dummy_audiobackend.h
index 638bb9f312bf4cdfdc3d1b1690b5c8c0cda20a6a..56929d939c3de4e1be9b3f69e6493a63475ce36e 100644 (file)
--- a/libs/backends/dummy/dummy_audiobackend.h
+++ b/libs/backends/dummy/dummy_audiobackend.h
@@ -37,6 +37,14 @@ 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);
@@ -83,6 +91,7 @@ class DummyPort {
                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
                {
@@ -112,6 +121,17 @@ class DummyPort {
                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 {
@@ -125,8 +145,44 @@ 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,
+                       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)); }
+
        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 {
@@ -137,10 +193,21 @@ 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 {
@@ -149,6 +216,8 @@ class DummyAudioBackend : public AudioBackend {
                 DummyAudioBackend (AudioEngine& e, AudioBackendInfo& info);
                ~DummyAudioBackend ();
 
+               bool is_running () const { return _running; }
+
                /* AUDIOBACKEND API */
 
                std::string name () const;
@@ -174,6 +243,8 @@ class DummyAudioBackend : public AudioBackend {
                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;
                float        sample_rate () const;
@@ -290,13 +361,24 @@ class DummyAudioBackend : public AudioBackend {
 
                void* main_process_thread ();
 
+               static size_t max_buffer_size() {return _max_buffer_size;}
+
        private:
+               enum MidiPortMode {
+                       MidiNoEvents,
+                       MidiGenerator,
+                       MidiLoopback,
+               };
+
                std::string _instance_name;
                static std::vector<std::string> _midi_options;
+               static std::vector<AudioBackend::DeviceStatus> _device_status;
 
                bool  _running;
                bool  _freewheeling;
 
+               std::string _device;
+
                float  _samplerate;
                size_t _samples_per_period;
                float  _dsp_load;
@@ -307,6 +389,7 @@ class DummyAudioBackend : public AudioBackend {
 
                uint32_t _n_midi_inputs;
                uint32_t _n_midi_outputs;
+               MidiPortMode _midi_mode;
 
                uint32_t _systemic_input_latency;
                uint32_t _systemic_output_latency;
@@ -331,11 +414,14 @@ class DummyAudioBackend : public AudioBackend {
                /* 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;