libs/ardour/midi_playlist.cc

   1 /*
   2     Copyright (C) 2006 Paul Davis
   3     Written by Dave Robillard, 2006
   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 #include <cassert>
  21
  22 #include <algorithm>
  23 #include <iostream>
  24
  25 #include <stdlib.h>
  26
  27 #include "evoral/EventList.hpp"
  28
  29 #include "ardour/debug.h"
  30 #include "ardour/types.h"
  31 #include "ardour/configuration.h"
  32 #include "ardour/midi_playlist.h"
  33 #include "ardour/midi_region.h"
  34 #include "ardour/session.h"
  35 #include "ardour/midi_ring_buffer.h"
  36
  37 #include "pbd/error.h"
  38
  39 #include "i18n.h"
  40
  41 using namespace ARDOUR;
  42 using namespace std;
  43
  44 MidiPlaylist::MidiPlaylist (Session& session, const XMLNode& node, bool hidden)
  45         : Playlist (session, node, DataType::MIDI, hidden)
  46         , _note_mode(Sustained)
  47 {
  48         const XMLProperty* prop = node.property("type");
  49         assert(prop && DataType(prop->value()) == DataType::MIDI);
  50
  51         in_set_state++;
  52         set_state (node, Stateful::loading_state_version);
  53         in_set_state--;
  54 }
  55
  56 MidiPlaylist::MidiPlaylist (Session& session, string name, bool hidden)
  57         : Playlist (session, name, DataType::MIDI, hidden)
  58 {
  59 }
  60
  61 MidiPlaylist::MidiPlaylist (boost::shared_ptr<const MidiPlaylist> other, string name, bool hidden)
  62         : Playlist (other, name, hidden)
  63 {
  64 }
  65
  66 MidiPlaylist::MidiPlaylist (boost::shared_ptr<const MidiPlaylist> other, nframes_t start, nframes_t dur, string name, bool hidden)
  67                 : Playlist (other, start, dur, name, hidden)
  68 {
  69         /* this constructor does NOT notify others (session) */
  70 }
  71
  72 MidiPlaylist::~MidiPlaylist ()
  73 {
  74 }
  75
  76 template<typename Time>
  77 struct EventsSortByTime {
  78     bool operator() (Evoral::Event<Time>* a, Evoral::Event<Time>* b) {
  79             return a->time() < b->time();
  80     }
  81 };
  82
  83 /** Returns the number of frames in time duration read (eg could be large when 0 events are read) */
  84 nframes_t
  85 MidiPlaylist::read (MidiRingBuffer<nframes_t>& dst, nframes_t start, nframes_t dur, unsigned chan_n)
  86 {
  87         /* this function is never called from a realtime thread, so
  88            its OK to block (for short intervals).
  89         */
  90
  91         Glib::RecMutex::Lock rm (region_lock);
  92         DEBUG_TRACE (DEBUG::MidiPlaylistIO, string_compose ("++++++ %1 .. %2  +++++++++++++++++++++++++++++++++++++++++++++++\n", start, start + dur));
  93
  94         nframes_t end = start + dur - 1;
  95
  96         _read_data_count = 0;
  97
  98         // relevent regions overlapping start <--> end
  99         vector< boost::shared_ptr<Region> > regs;
 100         typedef pair<MidiStateTracker*,nframes64_t> TrackerInfo;
 101         vector<TrackerInfo> tracker_info;
 102         uint32_t note_cnt = 0;
 103
 104         for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
 105                 if ((*i)->coverage (start, end) != OverlapNone) {
 106                         regs.push_back(*i);
 107                 } else {
 108                         NoteTrackers::iterator t = _note_trackers.find ((*i).get());
 109                         if (t != _note_trackers.end()) {
 110
 111                                 /* add it the set of trackers we will do note resolution
 112                                    on, and remove it from the list we are keeping
 113                                    around, because we don't need it anymore.
 114
 115                                    if the end of the region (where we want to theoretically resolve notes)
 116                                    is outside the current read range, then just do it at the start
 117                                    of this read range.
 118                                 */
 119
 120                                 nframes64_t resolve_at = (*i)->last_frame();
 121                                 if (resolve_at >= end) {
 122                                         resolve_at = start;
 123                                 }
 124
 125                                 tracker_info.push_back (TrackerInfo (t->second, resolve_at));
 126                                 DEBUG_TRACE (DEBUG::MidiPlaylistIO, string_compose ("time to resolve & remove tracker for %1 @ %2\n", (*i)->name(), resolve_at));
 127                                 note_cnt += (t->second->on());
 128                                 _note_trackers.erase (t);
 129                         }
 130                 }
 131         }
 132
 133         if (note_cnt == 0 && !tracker_info.empty()) {
 134                 /* trackers to dispose of, but they have no notes in them */
 135                 DEBUG_TRACE (DEBUG::MidiPlaylistIO, string_compose ("Clearing %1 empty trackers\n", tracker_info.size()));
 136                 for (vector<TrackerInfo>::iterator t = tracker_info.begin(); t != tracker_info.end(); ++t) {
 137                         delete (*t).first;
 138                 }
 139                 tracker_info.clear ();
 140         }
 141
 142         if (regs.size() == 1 && tracker_info.empty()) {
 143
 144                 /* just a single region - read directly into dst */
 145
 146                 DEBUG_TRACE (DEBUG::MidiPlaylistIO, string_compose ("Single region (%1) read, no out-of-bound region tracking info\n", regs.front()->name()));
 147
 148                 boost::shared_ptr<MidiRegion> mr = boost::dynamic_pointer_cast<MidiRegion>(regs.front());
 149
 150                 if (mr) {
 151
 152                         NoteTrackers::iterator t = _note_trackers.find (mr.get());
 153                         MidiStateTracker* tracker;
 154                         bool new_tracker = false;
 155
 156                         if (t == _note_trackers.end()) {
 157                                 tracker = new MidiStateTracker;
 158                                 new_tracker = true;
 159                                 DEBUG_TRACE (DEBUG::MidiPlaylistIO, "\tBEFORE: new tracker\n");
 160                         } else {
 161                                 tracker = t->second;
 162                                 DEBUG_TRACE (DEBUG::MidiPlaylistIO, string_compose ("\tBEFORE: tracker says there are %1 on notes", tracker->on()));
 163                         }
 164
 165                         mr->read_at (dst, start, dur, chan_n, _note_mode, tracker);
 166                         DEBUG_TRACE (DEBUG::MidiPlaylistIO, string_compose ("\tAFTER: tracker says there are %1 on notes", tracker->on()));
 167
 168                         if (new_tracker) {
 169                                 pair<Region*,MidiStateTracker*> newpair;
 170                                 newpair.first = mr.get();
 171                                 newpair.second = tracker;
 172                                 _note_trackers.insert (newpair);
 173                                 DEBUG_TRACE (DEBUG::MidiPlaylistIO, "\tadded tracker to trackers\n");
 174                         }
 175
 176                         _read_data_count += mr->read_data_count();
 177                 }
 178
 179         } else {
 180
 181                 /* multiple regions and/or note resolution: sort by layer, read into a temporary non-monotonically
 182                    sorted EventSink, sort and then insert into dst.
 183                 */
 184
 185                 DEBUG_TRACE (DEBUG::MidiPlaylistIO, string_compose ("%1 regions to read, plus %2 trackers\n", regs.size(), tracker_info.size()));
 186
 187                 Evoral::EventList<nframes_t> evlist;
 188
 189                 for (vector<TrackerInfo>::iterator t = tracker_info.begin(); t != tracker_info.end(); ++t) {
 190                         DEBUG_TRACE (DEBUG::MidiPlaylistIO, string_compose ("Resolve %1 notes\n", (*t).first->on()));
 191                         (*t).first->resolve_notes (evlist, (*t).second);
 192                         delete (*t).first;
 193                 }
 194
 195 #ifndef NDEBUG
 196                 DEBUG_TRACE (DEBUG::MidiPlaylistIO, string_compose ("After resolution we now have %1 events\n",  evlist.size()));
 197                 for (Evoral::EventList<nframes_t>::iterator x = evlist.begin(); x != evlist.end(); ++x) {
 198                         DEBUG_TRACE (DEBUG::MidiPlaylistIO, string_compose ("\t%1\n", **x));
 199                 }
 200 #endif
 201
 202                 DEBUG_TRACE (DEBUG::MidiPlaylistIO, string_compose ("for %1 .. %2 we have %3 to consider\n", start, start+dur-1, regs.size()));
 203
 204                 for (vector<boost::shared_ptr<Region> >::iterator i = regs.begin(); i != regs.end(); ++i) {
 205                         boost::shared_ptr<MidiRegion> mr = boost::dynamic_pointer_cast<MidiRegion>(*i);
 206                         if (!mr) {
 207                                 continue;
 208                         }
 209
 210                         NoteTrackers::iterator t = _note_trackers.find (mr.get());
 211                         MidiStateTracker* tracker;
 212                         bool new_tracker = false;
 213
 214
 215                         DEBUG_TRACE (DEBUG::MidiPlaylistIO, string_compose ("Before %1 (%2 .. %3) we now have %4 events\n", mr->name(), mr->position(), mr->last_frame(), evlist.size()));
 216
 217                         if (t == _note_trackers.end()) {
 218                                 tracker = new MidiStateTracker;
 219                                 new_tracker = true;
 220                                 DEBUG_TRACE (DEBUG::MidiPlaylistIO, "\tBEFORE: new tracker\n");
 221                         } else {
 222                                 tracker = t->second;
 223                                 DEBUG_TRACE (DEBUG::MidiPlaylistIO, string_compose ("\tBEFORE: tracker says there are %1 on notes\n", tracker->on()));
 224                         }
 225
 226
 227                         mr->read_at (evlist, start, dur, chan_n, _note_mode, tracker);
 228                         _read_data_count += mr->read_data_count();
 229
 230 #ifndef NDEBUG
 231                         DEBUG_TRACE (DEBUG::MidiPlaylistIO, string_compose ("After %1 (%2 .. %3) we now have %4\n", mr->name(), mr->position(), mr->last_frame(), evlist.size()));
 232                         for (Evoral::EventList<nframes_t>::iterator x = evlist.begin(); x != evlist.end(); ++x) {
 233                                 DEBUG_TRACE (DEBUG::MidiPlaylistIO, string_compose ("\t%1\n", **x));
 234                         }
 235                         DEBUG_TRACE (DEBUG::MidiPlaylistIO, string_compose ("\tAFTER: tracker says there are %1 on notes\n", tracker->on()));
 236 #endif
 237
 238                         if (new_tracker) {
 239                                 pair<Region*,MidiStateTracker*> newpair;
 240                                 newpair.first = mr.get();
 241                                 newpair.second = tracker;
 242                                 _note_trackers.insert (newpair);
 243                                 DEBUG_TRACE (DEBUG::MidiPlaylistIO, "\tadded tracker to trackers\n");
 244                         }
 245                 }
 246
 247                 if (!evlist.empty()) {
 248
 249                         /* sort the event list */
 250                         EventsSortByTime<nframes_t> time_cmp;
 251                         evlist.sort (time_cmp);
 252
 253 #ifndef NDEBUG
 254                         DEBUG_TRACE (DEBUG::MidiPlaylistIO, string_compose ("Final we now have %1 events\n",  evlist.size()));
 255                         for (Evoral::EventList<nframes_t>::iterator x = evlist.begin(); x != evlist.end(); ++x) {
 256                                 DEBUG_TRACE (DEBUG::MidiPlaylistIO, string_compose ("\t%1\n", **x));
 257                         }
 258 #endif
 259                         /* write into dst */
 260                         for (Evoral::EventList<nframes_t>::iterator e = evlist.begin(); e != evlist.end(); ++e) {
 261                                 Evoral::Event<nframes_t>* ev (*e);
 262                                 dst.write (ev->time(), ev->event_type(), ev->size(), ev->buffer());
 263                                 delete ev;
 264                         }
 265
 266                 }
 267         }
 268
 269         DEBUG_TRACE (DEBUG::MidiPlaylistIO, "-------------------------------------------------------------\n");
 270         return dur;
 271 }
 272
 273 void
 274 MidiPlaylist::clear_note_trackers ()
 275 {
 276         Glib::RecMutex::Lock rm (region_lock);
 277         for (NoteTrackers::iterator n = _note_trackers.begin(); n != _note_trackers.end(); ++n) {
 278                 delete n->second;
 279         }
 280         _note_trackers.clear ();
 281 }
 282
 283 void
 284 MidiPlaylist::remove_dependents (boost::shared_ptr<Region> region)
 285 {
 286         /* MIDI regions have no dependents (crossfades) but we might be tracking notes */
 287         NoteTrackers::iterator t = _note_trackers.find (region.get());
 288
 289         /* GACK! THREAD SAFETY! */
 290
 291         if (t != _note_trackers.end()) {
 292                 delete t->second;
 293                 _note_trackers.erase (t);
 294         }
 295 }
 296
 297
 298 void
 299 MidiPlaylist::refresh_dependents (boost::shared_ptr<Region> /*r*/)
 300 {
 301         /* MIDI regions have no dependents (crossfades) */
 302 }
 303
 304 void
 305 MidiPlaylist::finalize_split_region (boost::shared_ptr<Region> /*original*/, boost::shared_ptr<Region> /*left*/, boost::shared_ptr<Region> /*right*/)
 306 {
 307         /* No MIDI crossfading (yet?), so nothing to do here */
 308 }
 309
 310 void
 311 MidiPlaylist::check_dependents (boost::shared_ptr<Region> /*r*/, bool /*norefresh*/)
 312 {
 313         /* MIDI regions have no dependents (crossfades) */
 314 }
 315
 316
 317 int
 318 MidiPlaylist::set_state (const XMLNode& node, int version)
 319 {
 320         in_set_state++;
 321         freeze ();
 322
 323         Playlist::set_state (node, version);
 324
 325         thaw();
 326         in_set_state--;
 327
 328         return 0;
 329 }
 330
 331 void
 332 MidiPlaylist::dump () const
 333 {
 334         boost::shared_ptr<Region> r;
 335
 336         cerr << "Playlist \"" << _name << "\" " << endl
 337         << regions.size() << " regions "
 338         << endl;
 339
 340         for (RegionList::const_iterator i = regions.begin(); i != regions.end(); ++i) {
 341                 r = *i;
 342                 cerr << "  " << r->name() << " @ " << r << " ["
 343                 << r->start() << "+" << r->length()
 344                 << "] at "
 345                 << r->position()
 346                 << " on layer "
 347                 << r->layer ()
 348                 << endl;
 349         }
 350 }
 351
 352 bool
 353 MidiPlaylist::destroy_region (boost::shared_ptr<Region> region)
 354 {
 355         boost::shared_ptr<MidiRegion> r = boost::dynamic_pointer_cast<MidiRegion> (region);
 356         bool changed = false;
 357
 358         if (r == 0) {
 359                 PBD::fatal << _("programming error: non-midi Region passed to remove_overlap in midi playlist")
 360                 << endmsg;
 361                 /*NOTREACHED*/
 362                 return false;
 363         }
 364
 365         {
 366                 RegionLock rlock (this);
 367                 RegionList::iterator i;
 368                 RegionList::iterator tmp;
 369
 370                 for (i = regions.begin(); i != regions.end(); ) {
 371
 372                         tmp = i;
 373                         ++tmp;
 374
 375                         if ((*i) == region) {
 376                                 regions.erase (i);
 377                                 changed = true;
 378                         }
 379
 380                         i = tmp;
 381                 }
 382         }
 383
 384
 385         if (changed) {
 386                 /* overload this, it normally means "removed", not destroyed */
 387                 notify_region_removed (region);
 388         }
 389
 390         return changed;
 391 }
 392
 393 set<Evoral::Parameter>
 394 MidiPlaylist::contained_automation()
 395 {
 396         /* this function is never called from a realtime thread, so
 397            its OK to block (for short intervals).
 398         */
 399
 400         Glib::RecMutex::Lock rm (region_lock);
 401
 402         set<Evoral::Parameter> ret;
 403
 404         for (RegionList::const_iterator r = regions.begin(); r != regions.end(); ++r) {
 405                 boost::shared_ptr<MidiRegion> mr = boost::dynamic_pointer_cast<MidiRegion>(*r);
 406
 407                 for (Automatable::Controls::iterator c = mr->model()->controls().begin();
 408                                 c != mr->model()->controls().end(); ++c) {
 409                         ret.insert(c->first);
 410                 }
 411         }
 412
 413         return ret;
 414 }
 415
 416
 417 bool
 418 MidiPlaylist::region_changed (Change what_changed, boost::shared_ptr<Region> region)
 419 {
 420         if (in_flush || in_set_state) {
 421                 return false;
 422         }
 423
 424         // Feeling rather uninterested today, but thanks for the heads up anyway!
 425
 426         Change our_interests = Change (/*MidiRegion::FadeInChanged|
 427                                        MidiRegion::FadeOutChanged|
 428                                        MidiRegion::FadeInActiveChanged|
 429                                        MidiRegion::FadeOutActiveChanged|
 430                                        MidiRegion::EnvelopeActiveChanged|
 431                                        MidiRegion::ScaleAmplitudeChanged|
 432                                        MidiRegion::EnvelopeChanged*/);
 433         bool parent_wants_notify;
 434
 435         parent_wants_notify = Playlist::region_changed (what_changed, region);
 436
 437         if ((parent_wants_notify || (what_changed & our_interests))) {
 438                 notify_contents_changed ();
 439         }
 440
 441         return true;
 442 }
 443