proper port unregistration (just some refactoring, noop)

[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 f1e9deae0a82ade23ad8190319106c4aed5ea9c0..226018d58444dc51315b5ed33c027e76b5a0ab15 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,8 +91,9 @@ 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
+               const LatencyRange latency_range (bool for_playback) const
                {
                        return for_playback ? _playback_latency_range : _capture_latency_range;
                }
@@ -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 {
@@ -127,13 +147,22 @@ class DummyAudioPort : public DummyPort {
 
                enum GeneratorType {
                        Silence,
-                       WhiteNoise,
+                       UniformWhiteNoise,
+                       GaussianWhiteNoise,
                        PinkNoise,
                        PonyNoise,
                        SineWave,
+                       SquareWave,
+                       KronekerDelta,
+                       SineSweep,
+                       SineSweepSwell,
+                       SquareSweep,
+                       SquareSweepSwell,
+                       Loopback,
                };
-               void next_period () { _gen_cycle = false; }
                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];
@@ -141,21 +170,16 @@ class DummyAudioPort : public DummyPort {
                // signal generator ('fake' physical inputs)
                void generate (const pframes_t n_samples);
                GeneratorType _gen_type;
-               Glib::Threads::Mutex generator_lock;
-               volatile bool _gen_cycle;
 
                // generator buffers
                // pink-noise filters
                float _b0, _b1, _b2, _b3, _b4, _b5, _b6;
                // generated sinf() samples
                Sample * _wavetable;
-               uint32_t _tbl_length;
-               uint32_t _tbl_offset;
-
-               // random number generator
-               inline float    randf ();
-               inline uint32_t randi ();
-               uint32_t _rseed;
+               uint32_t _gen_period;
+               uint32_t _gen_offset;
+               uint32_t _gen_perio2;
+               uint32_t _gen_count2;
 
                // gaussian noise generator
                float grandf ();
@@ -172,10 +196,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 {
@@ -184,6 +219,8 @@ class DummyAudioBackend : public AudioBackend {
                 DummyAudioBackend (AudioEngine& e, AudioBackendInfo& info);
                ~DummyAudioBackend ();
 
+               bool is_running () const { return _running; }
+
                /* AUDIOBACKEND API */
 
                std::string name () const;
@@ -209,6 +246,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;
@@ -253,8 +292,8 @@ class DummyAudioBackend : public AudioBackend {
                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);
@@ -325,12 +364,22 @@ class DummyAudioBackend : public AudioBackend {
 
                void* main_process_thread ();
 
+               static size_t max_buffer_size() {return _max_buffer_size;}
+
        private:
+               enum MidiPortMode {
+                       MidiNoEvents,
+                       MidiGenerator,
+                       MidiLoopback,
+                       MidiToAudio,
+               };
+
                std::string _instance_name;
                static std::vector<std::string> _midi_options;
                static std::vector<AudioBackend::DeviceStatus> _device_status;
 
                bool  _running;
+               bool  _freewheel;
                bool  _freewheeling;
 
                std::string _device;
@@ -345,11 +394,12 @@ 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;
 
-               uint64_t _processed_samples;
+               framecnt_t _processed_samples;
 
                pthread_t _main_thread;
 
@@ -369,12 +419,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;