libs/ardour/ardour/midi_model.h

   1 /*
   2     Copyright (C) 2007 Paul Davis
   3     Author: Dave Robillard
   4
   5     This program is free software; you can redistribute it and/or modify
   6     it under the terms of the GNU General Public License as published by
   7     the Free Software Foundation; either version 2 of the License, or
   8     (at your option) any later version.
   9
  10     This program is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13     GNU General Public License for more details.
  14
  15     You should have received a copy of the GNU General Public License
  16     along with this program; if not, write to the Free Software
  17     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18
  19 */
  20
  21 #ifndef __ardour_midi_model_h__
  22 #define __ardour_midi_model_h__
  23
  24 #include <queue>
  25 #include <deque>
  26 #include <utility>
  27 #include <boost/utility.hpp>
  28 #include <glibmm/thread.h>
  29 #include "pbd/command.h"
  30 #include "ardour/types.h"
  31 #include "ardour/midi_buffer.h"
  32 #include "ardour/midi_ring_buffer.h"
  33 #include "ardour/automatable_sequence.h"
  34 #include "ardour/types.h"
  35 #include "evoral/Note.hpp"
  36 #include "evoral/Sequence.hpp"
  37
  38 namespace ARDOUR {
  39
  40 class Session;
  41 class MidiSource;
  42
  43 /** This is a higher level (than MidiBuffer) model of MIDI data, with separate
  44  * representations for notes (instead of just unassociated note on/off events)
  45  * and controller data.  Controller data is represented as part of the
  46  * Automatable base (i.e. in a map of AutomationList, keyed by Parameter).
  47  * Because of this MIDI controllers and automatable controllers/widgets/etc
  48  * are easily interchangeable.
  49  */
  50 class MidiModel : public AutomatableSequence<Evoral::MusicalTime> {
  51 public:
  52         typedef Evoral::MusicalTime TimeType;
  53
  54         MidiModel (boost::shared_ptr<MidiSource>);
  55
  56         NoteMode note_mode() const { return (percussive() ? Percussive : Sustained); }
  57         void set_note_mode(NoteMode mode) { set_percussive(mode == Percussive); };
  58
  59         class DiffCommand : public Command {
  60         public:
  61
  62                 DiffCommand (boost::shared_ptr<MidiModel> m, const std::string& name);
  63
  64                 const std::string& name () const { return _name; }
  65
  66                 virtual void operator() () = 0;
  67                 virtual void undo () = 0;
  68
  69                 virtual int set_state (const XMLNode&, int version) = 0;
  70                 virtual XMLNode & get_state () = 0;
  71
  72                 boost::shared_ptr<MidiModel> model() const { return _model; }
  73
  74         protected:
  75                 boost::shared_ptr<MidiModel> _model;
  76                 const std::string            _name;
  77
  78         };
  79
  80         class NoteDiffCommand : public DiffCommand {
  81         public:
  82
  83                 NoteDiffCommand (boost::shared_ptr<MidiModel> m, const std::string& name) : DiffCommand (m, name) {}
  84                 NoteDiffCommand (boost::shared_ptr<MidiModel> m, const XMLNode& node);
  85
  86                 enum Property {
  87                         NoteNumber,
  88                         Velocity,
  89                         StartTime,
  90                         Length,
  91                         Channel
  92                 };
  93
  94                 void operator() ();
  95                 void undo ();
  96
  97                 int set_state (const XMLNode&, int version);
  98                 XMLNode & get_state ();
  99
 100                 void add (const NotePtr note);
 101                 void remove (const NotePtr note);
 102                 void side_effect_remove (const NotePtr note);
 103
 104                 void change (const NotePtr note, Property prop, uint8_t new_value);
 105                 void change (const NotePtr note, Property prop, TimeType new_time);
 106
 107                 bool adds_or_removes() const {
 108                         return !_added_notes.empty() || !_removed_notes.empty();
 109                 }
 110
 111                 NoteDiffCommand& operator+= (const NoteDiffCommand& other);
 112
 113           private:
 114                 struct NoteChange {
 115                         NoteDiffCommand::Property property;
 116                         NotePtr note;
 117                         union {
 118                                 uint8_t  old_value;
 119                                 TimeType old_time;
 120                         };
 121                         union {
 122                                 uint8_t  new_value;
 123                                 TimeType new_time;
 124                         };
 125                 };
 126
 127                 typedef std::list<NoteChange> ChangeList;
 128                 ChangeList _changes;
 129
 130                 typedef std::list< boost::shared_ptr< Evoral::Note<TimeType> > > NoteList;
 131                 NoteList _added_notes;
 132                 NoteList _removed_notes;
 133
 134                 std::set<NotePtr> side_effect_removals;
 135
 136                 XMLNode &marshal_change(const NoteChange&);
 137                 NoteChange unmarshal_change(XMLNode *xml_note);
 138
 139                 XMLNode &marshal_note(const NotePtr note);
 140                 NotePtr unmarshal_note(XMLNode *xml_note);
 141         };
 142
 143         /* Currently this class only supports changes of sys-ex time, but could be expanded */
 144         class SysexDiffCommand : public DiffCommand {
 145         public:
 146                 SysexDiffCommand (boost::shared_ptr<MidiModel> m, const XMLNode& node);
 147
 148                 enum Property {
 149                         Time,
 150                 };
 151
 152                 int set_state (const XMLNode&, int version);
 153                 XMLNode & get_state ();
 154
 155                 void operator() ();
 156                 void undo ();
 157
 158                 void change (boost::shared_ptr<Evoral::Event<TimeType> >, TimeType);
 159
 160         private:
 161                 struct Change {
 162                         boost::shared_ptr<Evoral::Event<TimeType> > sysex;
 163                         SysexDiffCommand::Property property;
 164                         TimeType old_time;
 165                         TimeType new_time;
 166                 };
 167
 168                 typedef std::list<Change> ChangeList;
 169                 ChangeList _changes;
 170
 171                 XMLNode & marshal_change (const Change &);
 172                 Change unmarshal_change (XMLNode *);
 173         };
 174
 175         MidiModel::NoteDiffCommand* new_note_diff_command (const std::string name="midi edit");
 176         void apply_command (Session& session, Command* cmd);
 177         void apply_command_as_subcommand (Session& session, Command* cmd);
 178
 179         bool sync_to_source ();
 180         bool write_to(boost::shared_ptr<MidiSource> source);
 181         bool write_section_to (boost::shared_ptr<MidiSource> source, Evoral::MusicalTime begin = Evoral::MinMusicalTime,
 182                                Evoral::MusicalTime end = Evoral::MaxMusicalTime);
 183
 184         // MidiModel doesn't use the normal AutomationList serialisation code
 185         // since controller data is stored in the .mid
 186         XMLNode& get_state();
 187         int set_state(const XMLNode&) { return 0; }
 188
 189         PBD::Signal0<void> ContentsChanged;
 190
 191         boost::shared_ptr<const MidiSource> midi_source ();
 192         void set_midi_source (boost::shared_ptr<MidiSource>);
 193
 194         boost::shared_ptr<Evoral::Note<TimeType> > find_note (NotePtr);
 195         boost::shared_ptr<Evoral::Note<TimeType> > find_note (gint note_id);
 196         boost::shared_ptr<Evoral::Event<TimeType> > find_sysex (gint);
 197
 198         InsertMergePolicy insert_merge_policy () const;
 199         void set_insert_merge_policy (InsertMergePolicy);
 200
 201         boost::shared_ptr<Evoral::Control> control_factory(const Evoral::Parameter& id);
 202
 203         void insert_silence_at_start (TimeType);
 204
 205 protected:
 206         int resolve_overlaps_unlocked (const NotePtr, void* arg = 0);
 207
 208 private:
 209         struct WriteLockImpl : public AutomatableSequence<TimeType>::WriteLockImpl {
 210                 WriteLockImpl(Glib::Mutex::Lock* source_lock, Glib::RWLock& s, Glib::Mutex& c)
 211                         : AutomatableSequence<TimeType>::WriteLockImpl(s, c)
 212                         , source_lock(source_lock)
 213                 {}
 214                 ~WriteLockImpl() {
 215                         delete source_lock;
 216                 }
 217                 Glib::Mutex::Lock* source_lock;
 218         };
 219
 220 public:
 221         virtual WriteLock edit_lock();
 222         virtual WriteLock write_lock();
 223
 224 private:
 225         friend class DeltaCommand;
 226
 227         void source_interpolation_changed (Evoral::Parameter, Evoral::ControlList::InterpolationStyle);
 228         void source_automation_state_changed (Evoral::Parameter, AutoState);
 229         void control_list_interpolation_changed (Evoral::Parameter, Evoral::ControlList::InterpolationStyle);
 230         void automation_list_automation_state_changed (Evoral::Parameter, AutoState);
 231
 232         PBD::ScopedConnectionList _midi_source_connections;
 233
 234         // We cannot use a boost::shared_ptr here to avoid a retain cycle
 235         boost::weak_ptr<MidiSource> _midi_source;
 236         InsertMergePolicy _insert_merge_policy;
 237 };
 238
 239 } /* namespace ARDOUR */
 240
 241 #endif /* __ardour_midi_model_h__ */
 242