libs/ardour/midi_model.cc

   1 /*
   2     Copyright (C) 2007 Paul Davis
   3         Written by Dave Robillard, 2007
   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 #include <iostream>
  22 #include <algorithm>
  23 #include <pbd/enumwriter.h>
  24 #include <ardour/midi_model.h>
  25 #include <ardour/midi_events.h>
  26 #include <ardour/midi_source.h>
  27 #include <ardour/types.h>
  28 #include <ardour/session.h>
  29
  30 using namespace std;
  31 using namespace ARDOUR;
  32
  33 // Note
  34
  35 MidiModel::Note::Note(double t, double d, uint8_t n, uint8_t v)
  36         : _on_event(t, 3, NULL, true)
  37         , _off_event(t + d, 3, NULL, true)
  38 {
  39         _on_event.buffer()[0] = MIDI_CMD_NOTE_ON;
  40         _on_event.buffer()[1] = n;
  41         _on_event.buffer()[2] = v;
  42
  43         _off_event.buffer()[0] = MIDI_CMD_NOTE_OFF;
  44         _off_event.buffer()[1] = n;
  45         _off_event.buffer()[2] = 0x40;
  46
  47         assert(time() == t);
  48         assert(duration() == d);
  49         assert(note() == n);
  50         assert(velocity() == v);
  51 }
  52
  53
  54 MidiModel::Note::Note(const Note& copy)
  55         : _on_event(copy._on_event, true)
  56         , _off_event(copy._off_event, true)
  57 {
  58         /*
  59         assert(copy._on_event.size == 3);
  60         _on_event.buffer = _on_event_buffer;
  61         memcpy(_on_event_buffer, copy._on_event_buffer, 3);
  62
  63         assert(copy._off_event.size == 3);
  64         _off_event.buffer = _off_event_buffer;
  65         memcpy(_off_event_buffer, copy._off_event_buffer, 3);
  66         */
  67
  68         assert(time() == copy.time());
  69         assert(end_time() == copy.end_time());
  70         assert(note() == copy.note());
  71         assert(velocity() == copy.velocity());
  72         assert(duration() == copy.duration());
  73 }
  74
  75
  76 const MidiModel::Note&
  77 MidiModel::Note::operator=(const Note& copy)
  78 {
  79         _on_event = copy._on_event;
  80         _off_event = copy._off_event;
  81         /*_on_event.time = copy._on_event.time;
  82         assert(copy._on_event.size == 3);
  83         memcpy(_on_event_buffer, copy._on_event_buffer, 3);
  84
  85         _off_event.time = copy._off_event.time;
  86         assert(copy._off_event.size == 3);
  87         memcpy(_off_event_buffer, copy._off_event_buffer, 3);
  88         */
  89
  90         assert(time() == copy.time());
  91         assert(end_time() == copy.end_time());
  92         assert(note() == copy.note());
  93         assert(velocity() == copy.velocity());
  94         assert(duration() == copy.duration());
  95
  96         return *this;
  97 }
  98
  99 // MidiModel
 100
 101 MidiModel::MidiModel(Session& s, size_t size)
 102         : _session(s)
 103         , _notes(size)
 104         , _note_mode(Sustained)
 105         , _writing(false)
 106         , _edited(false)
 107         , _active_notes(LaterNoteEndComparator())
 108 {
 109 }
 110
 111
 112 /** Read events in frame range \a start .. \a start+cnt into \a dst,
 113  * adding \a stamp_offset to each event's timestamp.
 114  * \return number of events written to \a dst
 115  */
 116 size_t
 117 MidiModel::read (MidiRingBuffer& dst, nframes_t start, nframes_t nframes, nframes_t stamp_offset) const
 118 {
 119         size_t read_events = 0;
 120
 121         /* FIXME: cache last lookup value to avoid O(n) search every time */
 122
 123         if (_note_mode == Sustained) {
 124
 125                 for (Notes::const_iterator n = _notes.begin(); n != _notes.end(); ++n) {
 126
 127                         while ( ! _active_notes.empty() ) {
 128                                 const Note* const earliest_off = _active_notes.top();
 129                                 const MidiEvent&  off_ev       = earliest_off->off_event();
 130                                 if (off_ev.time() < start + nframes && off_ev.time() <= n->time()) {
 131                                         dst.write(off_ev.time() + stamp_offset, off_ev.size(), off_ev.buffer());
 132                                         _active_notes.pop();
 133                                         ++read_events;
 134                                 } else {
 135                                         break;
 136                                 }
 137                         }
 138
 139                         if (n->time() >= start + nframes)
 140                                 break;
 141
 142                         // Note on
 143                         if (n->time() >= start) {
 144                                 const MidiEvent& on_ev = n->on_event();
 145                                 dst.write(on_ev.time() + stamp_offset, on_ev.size(), on_ev.buffer());
 146                                 _active_notes.push(&(*n));
 147                                 ++read_events;
 148                         }
 149
 150                 }
 151
 152                 // Write any trailing note offs
 153                 while ( ! _active_notes.empty() ) {
 154                         const Note* const earliest_off = _active_notes.top();
 155                         const MidiEvent&  off_ev       = earliest_off->off_event();
 156                         if (off_ev.time() < start + nframes) {
 157                                 dst.write(off_ev.time() + stamp_offset, off_ev.size(), off_ev.buffer());
 158                                 _active_notes.pop();
 159                                 ++read_events;
 160                         } else {
 161                                 break;
 162                         }
 163                 }
 164
 165         // Percussive
 166         } else {
 167                 for (Notes::const_iterator n = _notes.begin(); n != _notes.end(); ++n) {
 168                         // Note on
 169                         if (n->time() >= start) {
 170                                 if (n->time() < start + nframes) {
 171                                         const MidiEvent& ev = n->on_event();
 172                                         dst.write(ev.time() + stamp_offset, ev.size(), ev.buffer());
 173                                         ++read_events;
 174                                 } else {
 175                                         break;
 176                                 }
 177                         }
 178                 }
 179         }
 180
 181         return read_events;
 182 }
 183
 184
 185 /** Begin a write of events to the model.
 186  *
 187  * If \a mode is Sustained, complete notes with duration are constructed as note
 188  * on/off events are received.  Otherwise (Percussive), only note on events are
 189  * stored; note off events are discarded entirely and all contained notes will
 190  * have duration 0.
 191  */
 192 void
 193 MidiModel::start_write()
 194 {
 195         //cerr << "MM START WRITE, MODE = " << enum_2_string(_note_mode) << endl;
 196         _write_notes.clear();
 197         _writing = true;
 198 }
 199
 200
 201
 202 /** Finish a write of events to the model.
 203  *
 204  * If \a delete_stuck is true and the current mode is Sustained, note on events
 205  * that were never resolved with a corresonding note off will be deleted.
 206  * Otherwise they will remain as notes with duration 0.
 207  */
 208 void
 209 MidiModel::end_write(bool delete_stuck)
 210 {
 211         assert(_writing);
 212
 213         //cerr << "MM END WRITE: " << _notes.size() << " STUCK NOTES\n";
 214
 215         if (_note_mode == Sustained && delete_stuck) {
 216                 for (Notes::iterator n = _notes.begin(); n != _notes.end() ; ) {
 217                         if (n->duration() == 0) {
 218                                 cerr << "WARNING: Stuck note lost: " << n->note() << endl;
 219                                 n = _notes.erase(n);
 220                         } else {
 221                                 ++n;
 222                         }
 223                 }
 224         }
 225
 226         _write_notes.clear();
 227         _writing = false;
 228 }
 229
 230
 231 /** Append contents of \a buf to model.  NOT realtime safe.
 232  *
 233  * Timestamps of events in \a buf are expected to be relative to
 234  * the start of this model (t=0) and MUST be monotonically increasing
 235  * and MUST be >= the latest event currently in the model.
 236  *
 237  * Events in buf are deep copied.
 238  */
 239 void
 240 MidiModel::append(const MidiBuffer& buf)
 241 {
 242         assert(_writing);
 243
 244         _lock.writer_lock();
 245
 246         for (MidiBuffer::const_iterator i = buf.begin(); i != buf.end(); ++i) {
 247                 const MidiEvent& ev = *i;
 248
 249                 assert(_notes.empty() || ev.time() >= _notes.back().time());
 250
 251                 if (ev.type() == MIDI_CMD_NOTE_ON)
 252                         append_note_on(ev.time(), ev.note(), ev.velocity());
 253                 else if (ev.type() == MIDI_CMD_NOTE_OFF)
 254                         append_note_off(ev.time(), ev.note());
 255         }
 256
 257         _lock.writer_unlock();
 258 }
 259
 260
 261 /** Append \a in_event to model.  NOT realtime safe.
 262  *
 263  * Timestamps of events in \a buf are expected to be relative to
 264  * the start of this model (t=0) and MUST be monotonically increasing
 265  * and MUST be >= the latest event currently in the model.
 266  */
 267 void
 268 MidiModel::append(double time, size_t size, const Byte* buf)
 269 {
 270         assert(_notes.empty() || time >= _notes.back().time());
 271         assert(_writing);
 272
 273         if ((buf[0] & 0xF0) == MIDI_CMD_NOTE_ON)
 274                 append_note_on(time, buf[1], buf[2]);
 275         else if ((buf[0] & 0xF0) == MIDI_CMD_NOTE_OFF)
 276                 append_note_off(time, buf[1]);
 277 }
 278
 279
 280 void
 281 MidiModel::append_note_on(double time, uint8_t note_num, uint8_t velocity)
 282 {
 283         assert(_writing);
 284         _notes.push_back(Note(time, 0, note_num, velocity));
 285         if (_note_mode == Sustained) {
 286                 //cerr << "MM Sustained: Appending active note on " << (unsigned)(uint8_t)note_num << endl;
 287                 _write_notes.push_back(_notes.size() - 1);
 288         } else {
 289                 //cerr << "MM Percussive: NOT appending active note on" << endl;
 290         }
 291 }
 292
 293
 294 void
 295 MidiModel::append_note_off(double time, uint8_t note_num)
 296 {
 297         assert(_writing);
 298         if (_note_mode == Percussive) {
 299                 //cerr << "MM Ignoring note off (percussive mode)" << endl;
 300                 return;
 301         } else {
 302                 //cerr << "MM Attempting to resolve note off " << (unsigned)(uint8_t)note_num << endl;
 303         }
 304
 305         /* FIXME: make _write_notes fixed size (127 noted) for speed */
 306
 307         /* FIXME: note off velocity for that one guy out there who actually has
 308          * keys that send it */
 309
 310         for (WriteNotes::iterator n = _write_notes.begin(); n != _write_notes.end(); ++n) {
 311                 Note& note = _notes[*n];
 312                 //cerr << (unsigned)(uint8_t)note.note() << " ? " << (unsigned)note_num << endl;
 313                 if (note.note() == note_num) {
 314                         assert(time > note.time());
 315                         note.set_duration(time - note.time());
 316                         _write_notes.erase(n);
 317                         //cerr << "MM resolved note, duration: " << note.duration() << endl;
 318                         break;
 319                 }
 320         }
 321 }
 322
 323
 324 void
 325 MidiModel::add_note_unlocked(const Note& note)
 326 {
 327         //cerr << "MidiModel " << this << " add note " << (int)note.note() << " @ " << note.time() << endl;
 328         Notes::iterator i = upper_bound(_notes.begin(), _notes.end(), note, note_time_comparator);
 329         _notes.insert(i, note);
 330 }
 331
 332
 333 void
 334 MidiModel::remove_note_unlocked(const Note& note)
 335 {
 336         //cerr << "MidiModel " << this << " remove note " << (int)note.note() << " @ " << note.time() << endl;
 337         Notes::iterator n = find(_notes.begin(), _notes.end(), note);
 338         if (n != _notes.end())
 339                 _notes.erase(n);
 340 }
 341
 342 /** Slow!  for debugging only. */
 343 bool
 344 MidiModel::is_sorted() const
 345 {
 346         bool t = 0;
 347         for (Notes::const_iterator n = _notes.begin(); n != _notes.end(); ++n)
 348                 if (n->time() < t)
 349                         return false;
 350                 else
 351                         t = n->time();
 352
 353         return true;
 354 }
 355
 356
 357 /** Start a new command.
 358  *
 359  * This has no side-effects on the model or Session, the returned command
 360  * can be held on to for as long as the caller wishes, or discarded without
 361  * formality, until apply_command is called and ownership is taken.
 362  */
 363 MidiModel::DeltaCommand*
 364 MidiModel::new_delta_command(const string name)
 365 {
 366         DeltaCommand* cmd =  new DeltaCommand(*this, name);
 367         return cmd;
 368 }
 369
 370
 371 /** Apply a command.
 372  *
 373  * Ownership of cmd is taken, it must not be deleted by the caller.
 374  * The command will constitute one item on the undo stack.
 375  */
 376 void
 377 MidiModel::apply_command(Command* cmd)
 378 {
 379         _session.begin_reversible_command(cmd->name());
 380         (*cmd)();
 381         assert(is_sorted());
 382         _session.commit_reversible_command(cmd);
 383         _edited = true;
 384 }
 385
 386
 387 // MidiEditCommand
 388
 389
 390 void
 391 MidiModel::DeltaCommand::add(const Note& note)
 392 {
 393         //cerr << "MEC: apply" << endl;
 394
 395         _removed_notes.remove(note);
 396         _added_notes.push_back(note);
 397 }
 398
 399
 400 void
 401 MidiModel::DeltaCommand::remove(const Note& note)
 402 {
 403         //cerr << "MEC: remove" << endl;
 404
 405         _added_notes.remove(note);
 406         _removed_notes.push_back(note);
 407 }
 408
 409
 410 void
 411 MidiModel::DeltaCommand::operator()()
 412 {
 413         // This could be made much faster by using a priority_queue for added and
 414         // removed notes (or sort here), and doing a single iteration over _model
 415
 416         _model._lock.writer_lock();
 417
 418         for (std::list<Note>::iterator i = _added_notes.begin(); i != _added_notes.end(); ++i)
 419                 _model.add_note_unlocked(*i);
 420
 421         for (std::list<Note>::iterator i = _removed_notes.begin(); i != _removed_notes.end(); ++i)
 422                 _model.remove_note_unlocked(*i);
 423
 424         _model._lock.writer_unlock();
 425
 426         _model.ContentsChanged(); /* EMIT SIGNAL */
 427 }
 428
 429
 430 void
 431 MidiModel::DeltaCommand::undo()
 432 {
 433         // This could be made much faster by using a priority_queue for added and
 434         // removed notes (or sort here), and doing a single iteration over _model
 435
 436         _model._lock.writer_lock();
 437
 438         for (std::list<Note>::iterator i = _added_notes.begin(); i != _added_notes.end(); ++i)
 439                 _model.remove_note_unlocked(*i);
 440
 441         for (std::list<Note>::iterator i = _removed_notes.begin(); i != _removed_notes.end(); ++i)
 442                 _model.add_note_unlocked(*i);
 443
 444         _model._lock.writer_unlock();
 445
 446         _model.ContentsChanged(); /* EMIT SIGNAL */
 447 }
 448
 449
 450 bool
 451 MidiModel::write_to(boost::shared_ptr<MidiSource> source)
 452 {
 453         //cerr << "Writing model to " << source->name() << endl;
 454
 455         /* This could be done using a temporary MidiRingBuffer and using
 456          * MidiModel::read and MidiSource::write, but this is more efficient
 457          * and doesn't require any buffer size assumptions (ie it's worth
 458          * the code duplication).
 459          *
 460          * This is also different from read in that note off events are written
 461          * regardless of the track mode.  This is so the user can switch a
 462          * recorded track (with note durations from some instrument) to percussive,
 463          * save, reload, then switch it back to sustained preserving the original
 464          * note durations.
 465          */
 466
 467         /* Percussive
 468         for (Notes::const_iterator n = _notes.begin(); n != _notes.end(); ++n) {
 469                 const MidiEvent& ev = n->on_event();
 470                 source->append_event_unlocked(ev);
 471         }*/
 472
 473         _lock.reader_lock();
 474
 475         LaterNoteEndComparator cmp;
 476         ActiveNotes active_notes(cmp);
 477
 478         // Foreach note
 479         for (Notes::const_iterator n = _notes.begin(); n != _notes.end(); ++n) {
 480
 481                 // Write any pending note offs earlier than this note on
 482                 while ( ! active_notes.empty() ) {
 483                         const Note* const earliest_off = active_notes.top();
 484                         const MidiEvent&  off_ev       = earliest_off->off_event();
 485                         if (off_ev.time() <= n->time()) {
 486                                 source->append_event_unlocked(off_ev);
 487                                 active_notes.pop();
 488                         } else {
 489                                 break;
 490                         }
 491                 }
 492
 493                 // Write this note on
 494                 source->append_event_unlocked(n->on_event());
 495                 if (n->duration() > 0)
 496                         active_notes.push(&(*n));
 497         }
 498
 499         // Write any trailing note offs
 500         while ( ! active_notes.empty() ) {
 501                 source->append_event_unlocked(active_notes.top()->off_event());
 502                 active_notes.pop();
 503         }
 504
 505         _edited = false;
 506
 507         _lock.reader_unlock();
 508
 509         return true;
 510 }
 511