X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fardour%2Fmidi_track.h;h=9c1d21a3e4e9106ea02274728a30ce58ddac9789;hb=848e75aaeaa04a81883ed30bcd04abd862f9d1fd;hp=0399492a0252ff6e5fcace4b4144690bcf6843f6;hpb=061a85191c301ac18f2e8ca59d43127a4499ba96;p=ardour.git diff --git a/libs/ardour/ardour/midi_track.h b/libs/ardour/ardour/midi_track.h index 0399492a02..9c1d21a3e4 100644 --- a/libs/ardour/ardour/midi_track.h +++ b/libs/ardour/ardour/midi_track.h @@ -1,6 +1,6 @@ /* Copyright (C) 2006 Paul Davis - Written by Dave Robillard + Author: David Robillard This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -20,18 +20,20 @@ #ifndef __ardour_midi_track_h__ #define __ardour_midi_track_h__ +#include "pbd/ffs.h" + #include "ardour/track.h" #include "ardour/midi_ring_buffer.h" -#include "ardour/midi_state_tracker.h" namespace ARDOUR { -class Session; +class InterThreadInfo; class MidiDiskstream; class MidiPlaylist; class RouteGroup; -class SMFSource; +class SMFSource; +class Session; class MidiTrack : public Track { @@ -39,28 +41,40 @@ public: MidiTrack (Session&, string name, Route::Flag f = Route::Flag (0), TrackMode m = Normal); ~MidiTrack (); - int roll (nframes_t nframes, framepos_t start_frame, framepos_t end_frame, - int declick, bool can_record, bool rec_monitors_input, bool& need_butler); - - void handle_transport_stopped (bool abort, bool did_locate, bool flush_processors); + int init (); - boost::shared_ptr midi_diskstream() const; + int roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, int declick, bool& need_butler); - void use_new_diskstream (); - void set_diskstream (boost::shared_ptr); + void realtime_handle_transport_stopped (); + void realtime_locate (); - void set_latency_delay (nframes_t); + boost::shared_ptr create_diskstream (); + void set_diskstream (boost::shared_ptr); + void set_record_enabled (bool yn, void *src); - int export_stuff (BufferSet& bufs, nframes_t nframes, sframes_t end_frame); + DataType data_type () const { + return DataType::MIDI; + } void freeze_me (InterThreadInfo&); void unfreeze (); + bool bounceable (boost::shared_ptr, bool) const { return false; } boost::shared_ptr bounce (InterThreadInfo&); - boost::shared_ptr bounce_range ( - nframes_t start, nframes_t end, InterThreadInfo&, bool enable_processing); + boost::shared_ptr bounce_range (framepos_t start, + framepos_t end, + InterThreadInfo& iti, + boost::shared_ptr endpoint, + bool include_endpoint); - int set_state(const XMLNode&, int version); + int export_stuff (BufferSet& bufs, + framepos_t start_frame, + framecnt_t end_frame, + boost::shared_ptr endpoint, + bool include_endpoint, + bool for_export); + + int set_state (const XMLNode&, int version); void midi_panic(void); bool write_immediate_event(size_t size, const uint8_t* buf); @@ -68,12 +82,12 @@ public: /** A control that will send "immediate" events to a MIDI track when twiddled */ struct MidiControl : public AutomationControl { MidiControl(MidiTrack* route, const Evoral::Parameter& param, - boost::shared_ptr al = boost::shared_ptr()) + boost::shared_ptr al = boost::shared_ptr()) : AutomationControl (route->session(), param, al) , _route (route) {} - void set_value (float val); + void set_value (double val); MidiTrack* _route; }; @@ -81,39 +95,116 @@ public: NoteMode note_mode() const { return _note_mode; } void set_note_mode (NoteMode m); + std::string describe_parameter (Evoral::Parameter param); + bool step_editing() const { return _step_editing; } void set_step_editing (bool yn); - MidiRingBuffer& step_edit_ring_buffer() { return _step_edit_ring_buffer; } - - uint8_t default_channel() const { return _default_channel; } - void set_default_channel (uint8_t chn); + MidiRingBuffer& step_edit_ring_buffer() { return _step_edit_ring_buffer; } - bool midi_thru() const { return _midi_thru; } - void set_midi_thru (bool yn); + PBD::Signal1 StepEditStatusChange; boost::shared_ptr write_source (uint32_t n = 0); - + + /** Channel filtering mode. + * @param mask If mode is FilterChannels, each bit represents a midi channel: + * bit 0 = channel 0, bit 1 = channel 1 etc. the read and write methods will only + * process events whose channel bit is 1. + * If mode is ForceChannel, mask is simply a channel number which all events will + * be forced to while reading. + */ + 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 static_cast((g_atomic_int_get(&_playback_channel_mask) & 0xffff0000) >> 16); + } + uint16_t get_playback_channel_mask() const { + return g_atomic_int_get(&_playback_channel_mask) & 0x0000ffff; + } + ChannelMode get_capture_channel_mode() const { + return static_cast((g_atomic_int_get(&_capture_channel_mask) & 0xffff0000) >> 16); + } + uint16_t get_capture_channel_mask() const { + return g_atomic_int_get(&_capture_channel_mask) & 0x0000ffff; + } + + boost::shared_ptr midi_playlist (); + + PBD::Signal0 PlaybackChannelMaskChanged; + PBD::Signal0 PlaybackChannelModeChanged; + PBD::Signal0 CaptureChannelMaskChanged; + PBD::Signal0 CaptureChannelModeChanged; + + PBD::Signal1 > DataRecorded; + boost::shared_ptr get_gui_feed_buffer () const; + + void set_monitoring (MonitorChoice); + MonitorState monitoring_state () const; + + void set_input_active (bool); + bool input_active () const; + PBD::Signal0 InputActiveChanged; + protected: XMLNode& state (bool full); - - int _set_state (const XMLNode&, int, bool call_base); + + void act_on_mute (); private: - void write_out_of_band_data (BufferSet& bufs, sframes_t start_frame, sframes_t end_frame, nframes_t nframes); + MidiRingBuffer _immediate_events; + MidiRingBuffer _step_edit_ring_buffer; + NoteMode _note_mode; + bool _step_editing; + bool _input_active; + uint32_t _playback_channel_mask; // 16 bits mode, 16 bits mask + uint32_t _capture_channel_mask; // 16 bits mode, 16 bits mask + + virtual boost::shared_ptr diskstream_factory (XMLNode const &); + + boost::shared_ptr midi_diskstream () const; + + void write_out_of_band_data (BufferSet& bufs, framepos_t start_frame, framepos_t end_frame, framecnt_t nframes); void set_state_part_two (); void set_state_part_three (); - MidiRingBuffer _immediate_events; - MidiRingBuffer _step_edit_ring_buffer; - NoteMode _note_mode; - bool _step_editing; - uint8_t _default_channel; - bool _midi_thru; - int no_roll (nframes_t nframes, sframes_t start_frame, sframes_t end_frame, - bool state_changing, bool can_record, bool rec_monitors_input); - void push_midi_input_to_step_edit_ringbuffer (nframes_t nframes); + 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); + + void diskstream_data_recorded (boost::weak_ptr); + PBD::ScopedConnection _diskstream_data_recorded_connection; + + void track_input_active (IOChange, void*); + void map_input_active (bool); + + void filter_channels (BufferSet& bufs, ChannelMode mode, uint32_t mask); + +/* if mode is ForceChannel, force mask to the lowest set channel or 1 if no + * channels are set. + */ +#define force_mask(mode,mask) (((mode) == ForceChannel) ? (((mask) ? (1<<(PBD::ffs((mask))-1)) : 1)) : mask) + + void _set_playback_channel_mode(ChannelMode mode, uint16_t mask) { + mask = force_mask (mode, mask); + g_atomic_int_set(&_playback_channel_mask, (uint32_t(mode) << 16) | uint32_t(mask)); + } + void _set_playback_channel_mask (uint16_t mask) { + mask = force_mask (get_playback_channel_mode(), mask); + g_atomic_int_set(&_playback_channel_mask, (uint32_t(get_playback_channel_mode()) << 16) | uint32_t(mask)); + } + void _set_capture_channel_mode(ChannelMode mode, uint16_t mask) { + mask = force_mask (mode, mask); + g_atomic_int_set(&_capture_channel_mask, (uint32_t(mode) << 16) | uint32_t(mask)); + } + void _set_capture_channel_mask (uint16_t mask) { + mask = force_mask (get_capture_channel_mode(), mask); + g_atomic_int_set(&_capture_channel_mask, (uint32_t(get_capture_channel_mode()) << 16) | uint32_t(mask)); + } + +#undef force_mask }; } /* namespace ARDOUR*/