+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);
+ DummyMidiEvent (const DummyMidiEvent& other);
+ ~DummyMidiEvent ();
+ size_t size () const { return _size; };
+ pframes_t timestamp () const { return _timestamp; };
+ const unsigned char* const_data () const { return _data; };
+ unsigned char* data () { return _data; };
+ bool operator< (const DummyMidiEvent &other) const { return timestamp () < other.timestamp (); };
+ private:
+ size_t _size;
+ pframes_t _timestamp;
+ uint8_t *_data;
+};
+
+typedef std::vector<boost::shared_ptr<DummyMidiEvent> > DummyMidiBuffer;
+
+class DummyPort {
+ protected:
+ DummyPort (DummyAudioBackend &b, const std::string&, PortFlags);
+ public:
+ virtual ~DummyPort ();
+
+ const std::string& name () const { return _name; }
+ PortFlags flags () const { return _flags; }
+
+ int set_name (const std::string &name) { _name = name; return 0; }
+
+ virtual DataType type () const = 0;
+
+ bool is_input () const { return flags () & IsInput; }
+ bool is_output () const { return flags () & IsOutput; }
+ bool is_physical () const { return flags () & IsPhysical; }
+ bool is_terminal () const { return flags () & IsTerminal; }
+ bool is_connected () const { return _connections.size () != 0; }
+ bool is_connected (const DummyPort *port) const;
+ bool is_physically_connected () const;
+
+ const std::vector<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
+ {
+ return for_playback ? _playback_latency_range : _capture_latency_range;
+ }
+
+ void set_latency_range (const LatencyRange &latency_range, bool for_playback)
+ {
+ if (for_playback)
+ {
+ _playback_latency_range = latency_range;
+ }
+ else
+ {
+ _capture_latency_range = latency_range;
+ }
+ }
+
+ private:
+ DummyAudioBackend &_dummy_backend;
+ std::string _name;
+ const PortFlags _flags;
+ LatencyRange _capture_latency_range;
+ LatencyRange _playback_latency_range;
+ std::vector<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 (DummyAudioBackend &b, const std::string&, PortFlags);
+ ~DummyAudioPort ();
+
+ DataType type () const { return DataType::AUDIO; };
+
+ Sample* buffer () { return _buffer; }
+ 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 {
+ public:
+ 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; }
+
+ 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
+