libs/ardour/midi_playlist.cc

   1 /*
   2  * Copyright (C) 2006-2016 David Robillard <d@drobilla.net>
   3  * Copyright (C) 2007-2017 Paul Davis <paul@linuxaudiosystems.com>
   4  * Copyright (C) 2009-2012 Carl Hetherington <carl@carlh.net>
   5  * Copyright (C) 2015-2017 Robin Gareus <robin@gareus.org>
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License along
  18  * with this program; if not, write to the Free Software Foundation, Inc.,
  19  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  20  */
  21
  22 #include <algorithm>
  23 #include <cassert>
  24 #include <cstdlib>
  25 #include <iostream>
  26 #include <utility>
  27
  28 #include "evoral/EventList.hpp"
  29 #include "evoral/Control.hpp"
  30
  31 #include "ardour/beats_samples_converter.h"
  32 #include "ardour/debug.h"
  33 #include "ardour/midi_model.h"
  34 #include "ardour/midi_playlist.h"
  35 #include "ardour/midi_region.h"
  36 #include "ardour/midi_source.h"
  37 #include "ardour/midi_state_tracker.h"
  38 #include "ardour/region_factory.h"
  39 #include "ardour/rt_midibuffer.h"
  40 #include "ardour/session.h"
  41 #include "ardour/tempo.h"
  42 #include "ardour/types.h"
  43
  44 #include "pbd/i18n.h"
  45
  46 using namespace ARDOUR;
  47 using namespace PBD;
  48 using namespace std;
  49
  50 MidiPlaylist::MidiPlaylist (Session& session, const XMLNode& node, bool hidden)
  51         : Playlist (session, node, DataType::MIDI, hidden)
  52         , _note_mode(Sustained)
  53         , _read_end(0)
  54 {
  55 #ifndef NDEBUG
  56         XMLProperty const * prop = node.property("type");
  57         assert(prop && DataType(prop->value()) == DataType::MIDI);
  58 #endif
  59
  60         in_set_state++;
  61         if (set_state (node, Stateful::loading_state_version)) {
  62                 throw failed_constructor ();
  63         }
  64         in_set_state--;
  65
  66         relayer ();
  67 }
  68
  69 MidiPlaylist::MidiPlaylist (Session& session, string name, bool hidden)
  70         : Playlist (session, name, DataType::MIDI, hidden)
  71         , _note_mode(Sustained)
  72         , _read_end(0)
  73 {
  74 }
  75
  76 MidiPlaylist::MidiPlaylist (boost::shared_ptr<const MidiPlaylist> other, string name, bool hidden)
  77         : Playlist (other, name, hidden)
  78         , _note_mode(other->_note_mode)
  79         , _read_end(0)
  80 {
  81 }
  82
  83 MidiPlaylist::MidiPlaylist (boost::shared_ptr<const MidiPlaylist> other,
  84                             samplepos_t                            start,
  85                             samplecnt_t                            dur,
  86                             string                                name,
  87                             bool                                  hidden)
  88         : Playlist (other, start, dur, name, hidden)
  89         , _note_mode(other->_note_mode)
  90         , _read_end(0)
  91 {
  92 }
  93
  94 MidiPlaylist::~MidiPlaylist ()
  95 {
  96 }
  97
  98 template<typename Time>
  99 struct EventsSortByTimeAndType {
 100     bool operator() (const Evoral::Event<Time>* a, const Evoral::Event<Time>* b) {
 101             if (a->time() == b->time()) {
 102                     if (parameter_is_midi ((AutomationType)a->event_type()) &&
 103                         parameter_is_midi ((AutomationType)b->event_type())) {
 104                             /* negate return value since we must return whether
 105                              * or not a should sort before b, not b before a
 106                              */
 107                             return !MidiBuffer::second_simultaneous_midi_byte_is_first (a->buffer()[0], b->buffer()[0]);
 108                     }
 109             }
 110             return a->time() < b->time();
 111     }
 112 };
 113
 114 samplecnt_t
 115 MidiPlaylist::read (Evoral::EventSink<samplepos_t>& dst,
 116                     samplepos_t                     start,
 117                     samplecnt_t                     dur,
 118                     Evoral::Range<samplepos_t>*     loop_range,
 119                     unsigned                       chan_n,
 120                     MidiChannelFilter*             filter)
 121 {
 122         typedef pair<MidiStateTracker*,samplepos_t> TrackerInfo;
 123
 124         Playlist::RegionReadLock rl (this);
 125
 126         DEBUG_TRACE (DEBUG::MidiPlaylistIO, string_compose ("---- MidiPlaylist::read %1 .. %2 ----\n", start, start + dur));
 127
 128         /* Find relevant regions that overlap [start..end] */
 129         const samplepos_t                         end = start + dur - 1;
 130         std::vector< boost::shared_ptr<Region> > regs;
 131         std::vector< boost::shared_ptr<Region> > ended;
 132         for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
 133
 134                 /* check for the case of solo_selection */
 135                 bool force_transparent = ( _session.solo_selection_active() && SoloSelectedActive() && !SoloSelectedListIncludes( (const Region*) &(**i) ) );
 136                 if ( force_transparent )
 137                         continue;
 138
 139                 switch ((*i)->coverage (start, end)) {
 140                 case Evoral::OverlapStart:
 141                 case Evoral::OverlapInternal:
 142                         regs.push_back (*i);
 143                         break;
 144
 145                 case Evoral::OverlapExternal:
 146                         /* this region is entirely contained in the read range */
 147                         regs.push_back (*i);
 148                         ended.push_back (*i);
 149                         break;
 150
 151                 case Evoral::OverlapEnd:
 152                         /* this region ends within the read range */
 153                         regs.push_back (*i);
 154                         ended.push_back (*i);
 155                         break;
 156
 157                 default:
 158                         /* we don't care */
 159                         break;
 160                 }
 161         }
 162
 163         /* If we are reading from a single region, we can read directly into dst.  Otherwise,
 164            we read into a temporarily list, sort it, then write that to dst. */
 165         const bool direct_read = regs.size() == 1 &&
 166                 (ended.empty() || (ended.size() == 1 && ended.front() == regs.front()));
 167
 168         Evoral::EventList<samplepos_t>  evlist;
 169         Evoral::EventSink<samplepos_t>& tgt = direct_read ? dst : evlist;
 170
 171         DEBUG_TRACE (DEBUG::MidiPlaylistIO,
 172                      string_compose ("\t%1 regions to read, direct: %2\n", regs.size(), direct_read));
 173
 174         for (vector<boost::shared_ptr<Region> >::iterator i = regs.begin(); i != regs.end(); ++i) {
 175                 boost::shared_ptr<MidiRegion> mr = boost::dynamic_pointer_cast<MidiRegion>(*i);
 176                 if (!mr) {
 177                         continue;
 178                 }
 179
 180                 MidiCursor cursor; // XXX remove me
 181
 182                 /* Read from region into target. */
 183                 DEBUG_TRACE (DEBUG::MidiPlaylistIO, string_compose ("read from %1 at %2 for %3 LR %4 .. %5\n",
 184                                                                     mr->name(), start, dur,
 185                                                                     (loop_range ? loop_range->from : -1),
 186                                                                     (loop_range ? loop_range->to : -1)));
 187                 mr->read_at (tgt, start, dur, loop_range, cursor, chan_n, _note_mode, 0, filter);
 188
 189                 if (find (ended.begin(), ended.end(), *i) != ended.end()) {
 190                         /* Region ended within the read range, so resolve any active notes
 191                            (either stuck notes in the data, or notes that end after the end
 192                            of the region). */
 193                         DEBUG_TRACE (DEBUG::MidiPlaylistIO, string_compose ("\t%1 ended, resolve notes and delete\n", mr->name()));
 194                 }
 195         }
 196
 197         if (!direct_read && !evlist.empty()) {
 198                 /* We've read from multiple regions, sort the event list by time. */
 199                 EventsSortByTimeAndType<samplepos_t> cmp;
 200                 evlist.sort (cmp);
 201
 202                 /* Copy ordered events from event list to dst. */
 203                 for (Evoral::EventList<samplepos_t>::iterator e = evlist.begin(); e != evlist.end(); ++e) {
 204                         Evoral::Event<samplepos_t>* ev (*e);
 205                         dst.write (ev->time(), ev->event_type(), ev->size(), ev->buffer());
 206                         delete ev;
 207                 }
 208         }
 209
 210         DEBUG_TRACE (DEBUG::MidiPlaylistIO, "---- End MidiPlaylist::read ----\n");
 211         _read_end = start + dur;
 212         return dur;
 213 }
 214
 215 void
 216 MidiPlaylist::reset_note_trackers ()
 217 {
 218 }
 219
 220 void
 221 MidiPlaylist::resolve_note_trackers (Evoral::EventSink<samplepos_t>& dst, samplepos_t time)
 222 {
 223 }
 224
 225 void
 226 MidiPlaylist::remove_dependents (boost::shared_ptr<Region> region)
 227 {
 228 }
 229
 230 void
 231 MidiPlaylist::region_going_away (boost::weak_ptr<Region> region)
 232 {
 233         boost::shared_ptr<Region> r = region.lock();
 234         if (r) {
 235                 remove_dependents(r);
 236         }
 237 }
 238
 239 int
 240 MidiPlaylist::set_state (const XMLNode& node, int version)
 241 {
 242         in_set_state++;
 243         freeze ();
 244
 245         if (Playlist::set_state (node, version)) {
 246                 return -1;
 247         }
 248
 249         thaw();
 250         in_set_state--;
 251
 252         return 0;
 253 }
 254
 255 void
 256 MidiPlaylist::dump () const
 257 {
 258         boost::shared_ptr<Region> r;
 259
 260         cerr << "Playlist \"" << _name << "\" " << endl
 261         << regions.size() << " regions "
 262         << endl;
 263
 264         for (RegionList::const_iterator i = regions.begin(); i != regions.end(); ++i) {
 265                 r = *i;
 266                 cerr << "  " << r->name() << " @ " << r << " ["
 267                 << r->start() << "+" << r->length()
 268                 << "] at "
 269                 << r->position()
 270                 << " on layer "
 271                 << r->layer ()
 272                 << endl;
 273         }
 274 }
 275
 276 bool
 277 MidiPlaylist::destroy_region (boost::shared_ptr<Region> region)
 278 {
 279         boost::shared_ptr<MidiRegion> r = boost::dynamic_pointer_cast<MidiRegion> (region);
 280
 281         if (!r) {
 282                 return false;
 283         }
 284
 285         bool changed = false;
 286
 287         {
 288                 RegionWriteLock rlock (this);
 289                 RegionList::iterator i;
 290                 RegionList::iterator tmp;
 291
 292                 for (i = regions.begin(); i != regions.end(); ) {
 293
 294                         tmp = i;
 295                         ++tmp;
 296
 297                         if ((*i) == region) {
 298                                 regions.erase (i);
 299                                 changed = true;
 300                         }
 301
 302                         i = tmp;
 303                 }
 304         }
 305
 306         if (changed) {
 307                 /* overload this, it normally means "removed", not destroyed */
 308                 notify_region_removed (region);
 309         }
 310
 311         return changed;
 312 }
 313 void
 314 MidiPlaylist::_split_region (boost::shared_ptr<Region> region, const MusicSample& playlist_position)
 315 {
 316         if (!region->covers (playlist_position.sample)) {
 317                 return;
 318         }
 319
 320         if (region->position() == playlist_position.sample ||
 321             region->last_sample() == playlist_position.sample) {
 322                 return;
 323         }
 324
 325         boost::shared_ptr<const MidiRegion> mr = boost::dynamic_pointer_cast<MidiRegion>(region);
 326
 327         if (mr == 0) {
 328                 return;
 329         }
 330
 331         boost::shared_ptr<Region> left;
 332         boost::shared_ptr<Region> right;
 333
 334         string before_name;
 335         string after_name;
 336         const double before_qn = _session.tempo_map().exact_qn_at_sample (playlist_position.sample, playlist_position.division) - region->quarter_note();
 337         const double after_qn = mr->length_beats() - before_qn;
 338         MusicSample before (playlist_position.sample - region->position(), playlist_position.division);
 339         MusicSample after (region->length() - before.sample, playlist_position.division);
 340
 341         /* split doesn't change anything about length, so don't try to splice */
 342         bool old_sp = _splicing;
 343         _splicing = true;
 344
 345         RegionFactory::region_name (before_name, region->name(), false);
 346
 347         {
 348                 PropertyList plist;
 349
 350                 plist.add (Properties::length, before.sample);
 351                 plist.add (Properties::length_beats, before_qn);
 352                 plist.add (Properties::name, before_name);
 353                 plist.add (Properties::left_of_split, true);
 354                 plist.add (Properties::layering_index, region->layering_index ());
 355                 plist.add (Properties::layer, region->layer ());
 356
 357                 /* note: we must use the version of ::create with an offset here,
 358                    since it supplies that offset to the Region constructor, which
 359                    is necessary to get audio region gain envelopes right.
 360                 */
 361                 left = RegionFactory::create (region, MusicSample (0, 0), plist, true);
 362         }
 363
 364         RegionFactory::region_name (after_name, region->name(), false);
 365
 366         {
 367                 PropertyList plist;
 368
 369                 plist.add (Properties::length, after.sample);
 370                 plist.add (Properties::length_beats, after_qn);
 371                 plist.add (Properties::name, after_name);
 372                 plist.add (Properties::right_of_split, true);
 373                 plist.add (Properties::layering_index, region->layering_index ());
 374                 plist.add (Properties::layer, region->layer ());
 375
 376                 /* same note as above */
 377                 right = RegionFactory::create (region, before, plist, true);
 378         }
 379
 380         add_region_internal (left, region->position(), 0, region->quarter_note(), true);
 381         add_region_internal (right, region->position() + before.sample, before.division, region->quarter_note() + before_qn, true);
 382
 383         remove_region_internal (region);
 384
 385         _splicing = old_sp;
 386 }
 387
 388 set<Evoral::Parameter>
 389 MidiPlaylist::contained_automation()
 390 {
 391         /* this function is never called from a realtime thread, so
 392            its OK to block (for short intervals).
 393         */
 394
 395         Playlist::RegionReadLock rl (this);
 396         set<Evoral::Parameter> ret;
 397
 398         for (RegionList::const_iterator r = regions.begin(); r != regions.end(); ++r) {
 399                 boost::shared_ptr<MidiRegion> mr = boost::dynamic_pointer_cast<MidiRegion>(*r);
 400
 401                 for (Automatable::Controls::iterator c = mr->model()->controls().begin();
 402                                 c != mr->model()->controls().end(); ++c) {
 403                         if (c->second->list()->size() > 0) {
 404                                 ret.insert(c->first);
 405                         }
 406                 }
 407         }
 408
 409         return ret;
 410 }
 411
 412 void
 413 MidiPlaylist::render (MidiChannelFilter* filter)
 414 {
 415         typedef pair<MidiStateTracker*,samplepos_t> TrackerInfo;
 416
 417         Playlist::RegionReadLock rl (this);
 418
 419         DEBUG_TRACE (DEBUG::MidiPlaylistIO, "---- MidiPlaylist::dump-----\n");
 420
 421         std::vector< boost::shared_ptr<Region> > regs;
 422
 423         for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
 424
 425                 /* check for the case of solo_selection */
 426
 427                 if (_session.solo_selection_active() && SoloSelectedActive() && !SoloSelectedListIncludes ((const Region*) &(**i))) {
 428                         continue;
 429                 }
 430
 431                 regs.push_back (*i);
 432         }
 433
 434         /* If we are reading from a single region, we can read directly into _rendered.  Otherwise,
 435            we read into a temporarily list, sort it, then write that to _rendered.
 436         */
 437         Evoral::EventList<samplepos_t>  evlist;
 438         Evoral::EventSink<samplepos_t>* tgt;
 439
 440         /* RAII */
 441         RTMidiBuffer::WriteProtectRender wpr (_rendered);
 442
 443         if (regs.size() == 1) {
 444                 tgt = &_rendered;
 445                 wpr.acquire ();
 446                 _rendered.clear ();
 447         } else {
 448                 tgt = &evlist;
 449         }
 450
 451         DEBUG_TRACE (DEBUG::MidiPlaylistIO, string_compose ("\t%1 regions to read, direct: %2\n", regs.size(), (regs.size() == 1)));
 452
 453         for (vector<boost::shared_ptr<Region> >::iterator i = regs.begin(); i != regs.end(); ++i) {
 454
 455                 boost::shared_ptr<MidiRegion> mr = boost::dynamic_pointer_cast<MidiRegion>(*i);
 456
 457                 if (!mr) {
 458                         continue;
 459                 }
 460
 461                 DEBUG_TRACE (DEBUG::MidiPlaylistIO, string_compose ("dump from %1 at %2\n", mr->name()));
 462                 mr->render (*tgt, 0, _note_mode, filter);
 463         }
 464
 465         if (!evlist.empty()) {
 466                 /* We've read from multiple regions into evlist, sort the event list by time. */
 467                 EventsSortByTimeAndType<samplepos_t> cmp;
 468                 evlist.sort (cmp);
 469
 470                 /* Copy ordered events from event list to _rendered. */
 471
 472                 wpr.acquire ();
 473                 _rendered.clear ();
 474
 475                 for (Evoral::EventList<samplepos_t>::iterator e = evlist.begin(); e != evlist.end(); ++e) {
 476                         Evoral::Event<samplepos_t>* ev (*e);
 477                         _rendered.write (ev->time(), ev->event_type(), ev->size(), ev->buffer());
 478                         delete ev;
 479                 }
 480         }
 481
 482
 483         /* no need to release - RAII with WriteProtectRender takes care of it */
 484
 485         DEBUG_TRACE (DEBUG::MidiPlaylistIO, string_compose ("---- End MidiPlaylist::render, events: %1\n", _rendered.size()));
 486 }
 487
 488 RTMidiBuffer*
 489 MidiPlaylist::rendered ()
 490 {
 491         return &_rendered;
 492 }