Support LV2 log trace messages

[ardour.git] / libs / ardour / ardour / midi_track.h

diff --git a/libs/ardour/ardour/midi_track.h b/libs/ardour/ardour/midi_track.h
index c5f3bb977b85767c7cbfd2a9453e4989bf6907f9..f756812e7142433f4c0a5e1d73ba42720ea22961 100644 (file)
--- a/libs/ardour/ardour/midi_track.h
+++ b/libs/ardour/ardour/midi_track.h
@@ -20,24 +20,24 @@
 #ifndef __ardour_midi_track_h__
 #define __ardour_midi_track_h__
 
-#include "ardour/interthread_info.h"
-#include "ardour/track.h"
+#include "ardour/midi_channel_filter.h"
 #include "ardour/midi_ring_buffer.h"
-#include "ardour/midi_state_tracker.h"
+#include "ardour/track.h"
 
 namespace ARDOUR
 {
 
-class Session;
+class InterThreadInfo;
 class MidiDiskstream;
 class MidiPlaylist;
 class RouteGroup;
 class SMFSource;
+class Session;
 
-class MidiTrack : public Track
+class LIBARDOUR_API MidiTrack : public Track
 {
 public:
-       MidiTrack (Session&, string name, Route::Flag f = Route::Flag (0), TrackMode m = Normal);
+       MidiTrack (Session&, std::string name, TrackMode m = Normal);
        ~MidiTrack ();
 
        int init ();
@@ -46,10 +46,13 @@ public:
 
        void realtime_handle_transport_stopped ();
        void realtime_locate ();
+       void non_realtime_locate (framepos_t);
 
        boost::shared_ptr<Diskstream> create_diskstream ();
        void set_diskstream (boost::shared_ptr<Diskstream>);
-       void set_record_enabled (bool yn, void *src);
+
+       bool can_be_record_enabled ();
+       bool can_be_record_safe ();
 
        DataType data_type () const {
                return DataType::MIDI;
@@ -71,7 +74,8 @@ public:
                          framecnt_t                   end_frame,
                          boost::shared_ptr<Processor> endpoint,
                          bool                         include_endpoint,
-                         bool                         for_export);
+                         bool                         for_export,
+                         bool                         for_freeze);
 
        int set_state (const XMLNode&, int version);
 
@@ -82,15 +86,20 @@ public:
        struct MidiControl : public AutomationControl {
                MidiControl(MidiTrack* route, const Evoral::Parameter& param,
                            boost::shared_ptr<AutomationList> al = boost::shared_ptr<AutomationList>())
-                       : AutomationControl (route->session(), param, al)
+                       : AutomationControl (route->session(), param, ParameterDescriptor(param), al)
                        , _route (route)
                {}
 
-               void set_value (double val);
+               bool writable() const { return true; }
 
                MidiTrack* _route;
+
+       private:
+               void actually_set_value (double val, PBD::Controllable::GroupControlDisposition group_override);
        };
 
+       virtual void set_parameter_automation_state (Evoral::Parameter param, AutoState);
+
        NoteMode note_mode() const { return _note_mode; }
        void set_note_mode (NoteMode m);
 
@@ -103,15 +112,26 @@ public:
        PBD::Signal1<void,bool> StepEditStatusChange;
 
        boost::shared_ptr<SMFSource> write_source (uint32_t n = 0);
-       void set_channel_mode (ChannelMode, uint16_t);
-       ChannelMode get_channel_mode ();
-       uint16_t get_channel_mask ();
+
+       /* Configure capture/playback channels (see MidiChannelFilter). */
+       void set_capture_channel_mode (ChannelMode mode, uint16_t mask);
+       void set_playback_channel_mode (ChannelMode mode, uint16_t mask);
+       void set_playback_channel_mask (uint16_t mask);
+       void set_capture_channel_mask (uint16_t mask);
+
+       ChannelMode get_playback_channel_mode() const { return _playback_filter.get_channel_mode(); }
+       ChannelMode get_capture_channel_mode()  const { return _capture_filter.get_channel_mode(); }
+       uint16_t    get_playback_channel_mask() const { return _playback_filter.get_channel_mask(); }
+       uint16_t    get_capture_channel_mask()  const { return _capture_filter.get_channel_mask(); }
+
+       MidiChannelFilter& playback_filter() { return _playback_filter; }
+       MidiChannelFilter& capture_filter()  { return _capture_filter; }
+
        boost::shared_ptr<MidiPlaylist> midi_playlist ();
 
        PBD::Signal1<void, boost::weak_ptr<MidiSource> > DataRecorded;
        boost::shared_ptr<MidiBuffer> get_gui_feed_buffer () const;
 
-       void set_monitoring (MonitorChoice);
        MonitorState monitoring_state () const;
 
        void set_input_active (bool);
@@ -122,11 +142,19 @@ protected:
        XMLNode& state (bool full);
 
        void act_on_mute ();
+       void monitoring_changed (bool, PBD::Controllable::GroupControlDisposition);
 
 private:
+       MidiRingBuffer<framepos_t> _immediate_events;
+       MidiRingBuffer<framepos_t> _step_edit_ring_buffer;
+       NoteMode                   _note_mode;
+       bool                       _step_editing;
+       bool                       _input_active;
+       MidiChannelFilter          _playback_filter;
+       MidiChannelFilter          _capture_filter;
 
        virtual boost::shared_ptr<Diskstream> diskstream_factory (XMLNode const &);
-       
+
        boost::shared_ptr<MidiDiskstream> midi_diskstream () const;
 
        void write_out_of_band_data (BufferSet& bufs, framepos_t start_frame, framepos_t end_frame, framecnt_t nframes);
@@ -134,11 +162,6 @@ private:
        void set_state_part_two ();
        void set_state_part_three ();
 
-       MidiRingBuffer<framepos_t> _immediate_events;
-       MidiRingBuffer<framepos_t> _step_edit_ring_buffer;
-       NoteMode                  _note_mode;
-       bool                      _step_editing;
-       bool                      _input_active;
 
        int no_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, bool state_changing);
        void push_midi_input_to_step_edit_ringbuffer (framecnt_t nframes);
@@ -148,6 +171,9 @@ private:
 
        void track_input_active (IOChange, void*);
        void map_input_active (bool);
+
+       /** Update automation controls to reflect any changes in buffers. */
+       void update_controls (const BufferSet& bufs);
 };
 
 } /* namespace ARDOUR*/