libs/ardour/midi_diskstream.cc

   1 /*
   2     Copyright (C) 2000-2003 Paul Davis
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17 */
  18
  19 #include <fstream>
  20 #include <cstdio>
  21 #include <unistd.h>
  22 #include <cmath>
  23 #include <cerrno>
  24 #include <string>
  25 #include <climits>
  26 #include <fcntl.h>
  27 #include <cstdlib>
  28 #include <ctime>
  29 #include <strings.h> // for ffs(3)
  30 #include <sys/stat.h>
  31 #include <sys/mman.h>
  32
  33 #include "pbd/error.h"
  34 #include "pbd/basename.h"
  35 #include <glibmm/threads.h>
  36 #include "pbd/xml++.h"
  37 #include "pbd/memento_command.h"
  38 #include "pbd/enumwriter.h"
  39 #include "pbd/stateful_diff_command.h"
  40 #include "pbd/stacktrace.h"
  41
  42 #include "ardour/audioengine.h"
  43 #include "ardour/butler.h"
  44 #include "ardour/debug.h"
  45 #include "ardour/io.h"
  46 #include "ardour/midi_diskstream.h"
  47 #include "ardour/midi_model.h"
  48 #include "ardour/midi_playlist.h"
  49 #include "ardour/midi_port.h"
  50 #include "ardour/midi_region.h"
  51 #include "ardour/playlist_factory.h"
  52 #include "ardour/region_factory.h"
  53 #include "ardour/session.h"
  54 #include "ardour/session_playlists.h"
  55 #include "ardour/smf_source.h"
  56 #include "ardour/types.h"
  57 #include "ardour/utils.h"
  58
  59 #include "midi++/types.h"
  60
  61 #include "i18n.h"
  62 #include <locale.h>
  63
  64 using namespace std;
  65 using namespace ARDOUR;
  66 using namespace PBD;
  67
  68 framecnt_t MidiDiskstream::midi_readahead = 4096;
  69
  70 MidiDiskstream::MidiDiskstream (Session &sess, const string &name, Diskstream::Flag flag)
  71         : Diskstream(sess, name, flag)
  72         , _playback_buf(0)
  73         , _capture_buf(0)
  74         , _note_mode(Sustained)
  75         , _frames_written_to_ringbuffer(0)
  76         , _frames_read_from_ringbuffer(0)
  77         , _frames_pending_write(0)
  78         , _num_captured_loops(0)
  79         , _gui_feed_buffer(AudioEngine::instance()->raw_buffer_size (DataType::MIDI))
  80 {
  81         in_set_state = true;
  82
  83         init ();
  84         use_new_playlist ();
  85         use_new_write_source (0);
  86
  87         in_set_state = false;
  88
  89         if (destructive()) {
  90                 throw failed_constructor();
  91         }
  92 }
  93
  94 MidiDiskstream::MidiDiskstream (Session& sess, const XMLNode& node)
  95         : Diskstream(sess, node)
  96         , _playback_buf(0)
  97         , _capture_buf(0)
  98         , _note_mode(Sustained)
  99         , _frames_written_to_ringbuffer(0)
 100         , _frames_read_from_ringbuffer(0)
 101         , _frames_pending_write(0)
 102         , _num_captured_loops(0)
 103         , _gui_feed_buffer(AudioEngine::instance()->raw_buffer_size (DataType::MIDI))
 104 {
 105         in_set_state = true;
 106
 107         init ();
 108
 109         if (set_state (node, Stateful::loading_state_version)) {
 110                 in_set_state = false;
 111                 throw failed_constructor();
 112         }
 113
 114         use_new_write_source (0);
 115
 116         in_set_state = false;
 117 }
 118
 119 void
 120 MidiDiskstream::init ()
 121 {
 122         /* there are no channels at this point, so these
 123            two calls just get speed_buffer_size and wrap_buffer
 124            size setup without duplicating their code.
 125         */
 126
 127         set_block_size (_session.get_block_size());
 128         allocate_temporary_buffers ();
 129
 130         const size_t size = _session.butler()->midi_diskstream_buffer_size();
 131         _playback_buf = new MidiRingBuffer<framepos_t>(size);
 132         _capture_buf = new MidiRingBuffer<framepos_t>(size);
 133
 134         _n_channels = ChanCount(DataType::MIDI, 1);
 135 }
 136
 137 MidiDiskstream::~MidiDiskstream ()
 138 {
 139         Glib::Threads::Mutex::Lock lm (state_lock);
 140 }
 141
 142
 143 void
 144 MidiDiskstream::non_realtime_locate (framepos_t position)
 145 {
 146         if (_write_source) {
 147                 _write_source->set_timeline_position (position);
 148         }
 149         seek (position, false);
 150 }
 151
 152
 153 void
 154 MidiDiskstream::non_realtime_input_change ()
 155 {
 156         {
 157                 Glib::Threads::Mutex::Lock lm (state_lock);
 158
 159                 if (input_change_pending.type == IOChange::NoChange) {
 160                         return;
 161                 }
 162
 163                 if (input_change_pending.type & IOChange::ConfigurationChanged) {
 164                         uint32_t ni = _io->n_ports().n_midi();
 165
 166                         if (ni != _n_channels.n_midi()) {
 167                                 error << string_compose (_("%1: I/O configuration change %4 requested to use %2, but channel setup is %3"),
 168                                                          name(),
 169                                                          _io->n_ports(),
 170                                                          _n_channels, input_change_pending.type)
 171                                       << endmsg;
 172                         }
 173
 174                         if (ni == 0) {
 175                                 _source_port.reset ();
 176                         } else {
 177                                 _source_port = _io->midi(0);
 178                         }
 179                 }
 180
 181                 if (input_change_pending.type & IOChange::ConnectionsChanged) {
 182                         set_capture_offset ();
 183                         set_align_style_from_io ();
 184                 }
 185
 186                 input_change_pending.type = IOChange::NoChange;
 187
 188                 /* implicit unlock */
 189         }
 190
 191         /* unlike with audio, there is never any need to reset write sources
 192            based on input configuration changes because ... a MIDI track
 193            has just 1 MIDI port as input, always.
 194         */
 195
 196         /* now refill channel buffers */
 197
 198         if (speed() != 1.0f || speed() != -1.0f) {
 199                 seek ((framepos_t) (_session.transport_frame() * (double) speed()));
 200         }
 201         else {
 202                 seek (_session.transport_frame());
 203         }
 204
 205         g_atomic_int_set(const_cast<gint*> (&_frames_pending_write), 0);
 206         g_atomic_int_set(const_cast<gint*> (&_num_captured_loops), 0);
 207 }
 208
 209 int
 210 MidiDiskstream::find_and_use_playlist (const string& name)
 211 {
 212         boost::shared_ptr<MidiPlaylist> playlist;
 213
 214         if ((playlist = boost::dynamic_pointer_cast<MidiPlaylist> (_session.playlists->by_name (name))) == 0) {
 215                 playlist = boost::dynamic_pointer_cast<MidiPlaylist> (PlaylistFactory::create (DataType::MIDI, _session, name));
 216         }
 217
 218         if (!playlist) {
 219                 error << string_compose(_("MidiDiskstream: Playlist \"%1\" isn't a midi playlist"), name) << endmsg;
 220                 return -1;
 221         }
 222
 223         return use_playlist (playlist);
 224 }
 225
 226 int
 227 MidiDiskstream::use_playlist (boost::shared_ptr<Playlist> playlist)
 228 {
 229         if (boost::dynamic_pointer_cast<MidiPlaylist>(playlist)) {
 230                 Diskstream::use_playlist(playlist);
 231         }
 232
 233         return 0;
 234 }
 235
 236 int
 237 MidiDiskstream::use_new_playlist ()
 238 {
 239         string newname;
 240         boost::shared_ptr<MidiPlaylist> playlist;
 241
 242         if (!in_set_state && destructive()) {
 243                 return 0;
 244         }
 245
 246         if (_playlist) {
 247                 newname = Playlist::bump_name (_playlist->name(), _session);
 248         } else {
 249                 newname = Playlist::bump_name (_name, _session);
 250         }
 251
 252         if ((playlist = boost::dynamic_pointer_cast<MidiPlaylist> (PlaylistFactory::create (
 253                         DataType::MIDI, _session, newname, hidden()))) != 0) {
 254
 255                 return use_playlist (playlist);
 256
 257         } else {
 258                 return -1;
 259         }
 260 }
 261
 262 int
 263 MidiDiskstream::use_copy_playlist ()
 264 {
 265         if (destructive()) {
 266                 return 0;
 267         }
 268
 269         if (_playlist == 0) {
 270                 error << string_compose(_("MidiDiskstream %1: there is no existing playlist to make a copy of!"), _name) << endmsg;
 271                 return -1;
 272         }
 273
 274         string newname;
 275         boost::shared_ptr<MidiPlaylist> playlist;
 276
 277         newname = Playlist::bump_name (_playlist->name(), _session);
 278
 279         if ((playlist  = boost::dynamic_pointer_cast<MidiPlaylist>(PlaylistFactory::create (midi_playlist(), newname))) != 0) {
 280                 return use_playlist (playlist);
 281         } else {
 282                 return -1;
 283         }
 284 }
 285
 286 /** Overloaded from parent to die horribly
 287  */
 288 int
 289 MidiDiskstream::set_destructive (bool yn)
 290 {
 291         return yn ? -1 : 0;
 292 }
 293
 294 void
 295 MidiDiskstream::set_note_mode (NoteMode m)
 296 {
 297         _note_mode = m;
 298         midi_playlist()->set_note_mode(m);
 299         if (_write_source && _write_source->model())
 300                 _write_source->model()->set_note_mode(m);
 301 }
 302
 303 /** Get the start, end, and length of a location "atomically".
 304  *
 305  * Note: Locations don't get deleted, so all we care about when I say "atomic"
 306  * is that we are always pointing to the same one and using start/length values
 307  * obtained just once.  Use this function to achieve this since location being
 308  * a parameter achieves this.
 309  */
 310 static void
 311 get_location_times(const Location* location,
 312                    framepos_t*     start,
 313                    framepos_t*     end,
 314                    framepos_t*     length)
 315 {
 316         if (location) {
 317                 *start  = location->start();
 318                 *end    = location->end();
 319                 *length = *end - *start;
 320         }
 321 }
 322
 323 int
 324 MidiDiskstream::process (BufferSet& bufs, framepos_t transport_frame, pframes_t nframes, framecnt_t& playback_distance, bool need_disk_signal)
 325 {
 326         framecnt_t rec_offset = 0;
 327         framecnt_t rec_nframes = 0;
 328         bool      nominally_recording;
 329         bool      re = record_enabled ();
 330         bool      can_record = _session.actively_recording ();
 331
 332         playback_distance = 0;
 333
 334         check_record_status (transport_frame, can_record);
 335
 336         nominally_recording = (can_record && re);
 337
 338         if (nframes == 0) {
 339                 return 0;
 340         }
 341
 342         boost::shared_ptr<MidiPort> sp = _source_port.lock ();
 343
 344         if (sp == 0) {
 345                 return 1;
 346         }
 347
 348         Glib::Threads::Mutex::Lock sm (state_lock, Glib::Threads::TRY_LOCK);
 349
 350         if (!sm.locked()) {
 351                 return 1;
 352         }
 353
 354         const Location* const loop_loc    = loop_location;
 355         framepos_t            loop_start  = 0;
 356         framepos_t            loop_end    = 0;
 357         framepos_t            loop_length = 0;
 358         get_location_times(loop_loc, &loop_start, &loop_end, &loop_length);
 359
 360         adjust_capture_position = 0;
 361
 362         if (nominally_recording || (re && was_recording && _session.get_record_enabled() && _session.config.get_punch_in())) {
 363                 Evoral::OverlapType ot = Evoral::coverage (first_recordable_frame, last_recordable_frame, transport_frame, transport_frame + nframes);
 364
 365                 calculate_record_range(ot, transport_frame, nframes, rec_nframes, rec_offset);
 366
 367                 if (rec_nframes && !was_recording) {
 368                         if (loop_loc) {
 369                                 /* Loop recording, so pretend the capture started at the loop
 370                                    start rgardless of what time it is now, so the source starts
 371                                    at the loop start and can handle time wrapping around.
 372                                    Otherwise, start the source right now as usual.
 373                                 */
 374                                 capture_captured    = transport_frame - loop_start;
 375                                 capture_start_frame = loop_start;
 376                         }
 377                         _write_source->mark_write_starting_now(
 378                                 capture_start_frame, capture_captured, loop_length);
 379                         g_atomic_int_set(const_cast<gint*> (&_frames_pending_write), 0);
 380                         g_atomic_int_set(const_cast<gint*> (&_num_captured_loops), 0);
 381                         was_recording = true;
 382                 }
 383         }
 384
 385         if (can_record && !_last_capture_sources.empty()) {
 386                 _last_capture_sources.clear ();
 387         }
 388
 389         if (nominally_recording || rec_nframes) {
 390
 391                 // Pump entire port buffer into the ring buffer (FIXME: split cycles?)
 392                 MidiBuffer& buf = sp->get_midi_buffer(nframes);
 393                 ChannelMode mode = AllChannels; // _track->get_capture_channel_mode ();
 394                 uint32_t mask = 0xffff; // _track->get_capture_channel_mask ();
 395
 396                 for (MidiBuffer::iterator i = buf.begin(); i != buf.end(); ++i) {
 397                         Evoral::MIDIEvent<MidiBuffer::TimeType> ev(*i, false);
 398 #ifndef NDEBUG
 399                         if (DEBUG::MidiIO & PBD::debug_bits) {
 400                                 const uint8_t* __data = ev.buffer();
 401                                 DEBUG_STR_DECL(a);
 402                                 DEBUG_STR_APPEND(a, string_compose ("mididiskstream %1 capture event @ %2 + %3 sz %4 ", this, ev.time(), transport_frame, ev.size()));
 403                                 for (size_t i=0; i < ev.size(); ++i) {
 404                                         DEBUG_STR_APPEND(a,hex);
 405                                         DEBUG_STR_APPEND(a,"0x");
 406                                         DEBUG_STR_APPEND(a,(int)__data[i]);
 407                                         DEBUG_STR_APPEND(a,' ');
 408                                 }
 409                                 DEBUG_STR_APPEND(a,'\n');
 410                                 DEBUG_TRACE (DEBUG::MidiIO, DEBUG_STR(a).str());
 411                         }
 412 #endif
 413                         /* Write events to the capture buffer in frames from session start,
 414                            but ignoring looping so event time progresses monotonically.
 415                            The source knows the loop length so it knows exactly where the
 416                            event occurs in the series of recorded loops and can implement
 417                            any desirable behaviour.  We don't want to send event with
 418                            transport time here since that way the source can not
 419                            reconstruct their actual time; future clever MIDI looping should
 420                            probabl be implemented in the source instead of here.
 421                         */
 422                         const framecnt_t loop_offset = _num_captured_loops * loop_length;
 423
 424                         switch (mode) {
 425                         case AllChannels:
 426                                 _capture_buf->write(transport_frame + loop_offset + ev.time(),
 427                                                     ev.type(), ev.size(), ev.buffer());
 428                                 break;
 429                         case FilterChannels:
 430                                 if (ev.is_channel_event()) {
 431                                         if ((1<<ev.channel()) & mask) {
 432                                                 _capture_buf->write(transport_frame + loop_offset + ev.time(),
 433                                                                     ev.type(), ev.size(), ev.buffer());
 434                                         }
 435                                 } else {
 436                                         _capture_buf->write(transport_frame + loop_offset + ev.time(),
 437                                                             ev.type(), ev.size(), ev.buffer());
 438                                 }
 439                                 break;
 440                         case ForceChannel:
 441                                 if (ev.is_channel_event()) {
 442                                         ev.set_channel (ffs(mask) - 1);
 443                                 }
 444                                 _capture_buf->write(transport_frame + loop_offset + ev.time(),
 445                                                     ev.type(), ev.size(), ev.buffer());
 446                                 break;
 447                         }
 448                 }
 449                 g_atomic_int_add(const_cast<gint*>(&_frames_pending_write), nframes);
 450
 451                 if (buf.size() != 0) {
 452                         Glib::Threads::Mutex::Lock lm (_gui_feed_buffer_mutex, Glib::Threads::TRY_LOCK);
 453
 454                         if (lm.locked ()) {
 455                                 /* Copy this data into our GUI feed buffer and tell the GUI
 456                                    that it can read it if it likes.
 457                                 */
 458                                 _gui_feed_buffer.clear ();
 459
 460                                 for (MidiBuffer::iterator i = buf.begin(); i != buf.end(); ++i) {
 461                                         /* This may fail if buf is larger than _gui_feed_buffer, but it's not really
 462                                            the end of the world if it does.
 463                                         */
 464                                         _gui_feed_buffer.push_back ((*i).time() + transport_frame, (*i).size(), (*i).buffer());
 465                                 }
 466                         }
 467
 468                         DataRecorded (_write_source); /* EMIT SIGNAL */
 469                 }
 470
 471         } else {
 472
 473                 if (was_recording) {
 474                         finish_capture ();
 475                 }
 476
 477         }
 478
 479         if (rec_nframes) {
 480
 481                 /* data will be written to disk */
 482
 483                 if (rec_nframes == nframes && rec_offset == 0) {
 484                         playback_distance = nframes;
 485                 }
 486
 487                 adjust_capture_position = rec_nframes;
 488
 489         } else if (nominally_recording) {
 490
 491                 /* XXXX do this for MIDI !!!
 492                    can't do actual capture yet - waiting for latency effects to finish before we start
 493                    */
 494
 495                 playback_distance = nframes;
 496
 497         } else {
 498
 499                 /* XXX: should be doing varispeed stuff here, similar to the code in AudioDiskstream::process */
 500
 501                 playback_distance = nframes;
 502
 503         }
 504
 505         if (need_disk_signal) {
 506                 /* copy the diskstream data to all output buffers */
 507
 508                 MidiBuffer& mbuf (bufs.get_midi (0));
 509                 get_playback (mbuf, nframes);
 510
 511                 /* leave the audio count alone */
 512                 ChanCount cnt (DataType::MIDI, 1);
 513                 cnt.set (DataType::AUDIO, bufs.count().n_audio());
 514                 bufs.set_count (cnt);
 515         }
 516
 517         return 0;
 518 }
 519
 520 frameoffset_t
 521 MidiDiskstream::calculate_playback_distance (pframes_t nframes)
 522 {
 523         frameoffset_t playback_distance = nframes;
 524
 525         /* XXX: should be doing varispeed stuff once it's implemented in ::process() above */
 526
 527         if (_actual_speed < 0.0) {
 528                 return -playback_distance;
 529         } else {
 530                 return playback_distance;
 531         }
 532 }
 533
 534 bool
 535 MidiDiskstream::commit (framecnt_t playback_distance)
 536 {
 537         bool need_butler = false;
 538
 539         if (_actual_speed < 0.0) {
 540                 playback_sample -= playback_distance;
 541         } else {
 542                 playback_sample += playback_distance;
 543         }
 544
 545         if (adjust_capture_position != 0) {
 546                 capture_captured += adjust_capture_position;
 547                 adjust_capture_position = 0;
 548         }
 549
 550         uint32_t frames_read = g_atomic_int_get(const_cast<gint*>(&_frames_read_from_ringbuffer));
 551         uint32_t frames_written = g_atomic_int_get(const_cast<gint*>(&_frames_written_to_ringbuffer));
 552
 553         /*
 554           cerr << name() << " MDS written: " << frames_written << " - read: " << frames_read <<
 555           " = " << frames_written - frames_read
 556           << " + " << playback_distance << " < " << midi_readahead << " = " << need_butler << ")" << endl;
 557         */
 558
 559         /* frames_read will generally be less than frames_written, but
 560          * immediately after an overwrite, we can end up having read some data
 561          * before we've written any. we don't need to trip an assert() on this,
 562          * but we do need to check so that the decision on whether or not we
 563          * need the butler is done correctly.
 564          */
 565
 566         if (frames_read <= frames_written) {
 567                 if ((frames_written - frames_read) + playback_distance < midi_readahead) {
 568                         need_butler = true;
 569                 }
 570         }
 571
 572
 573         return need_butler;
 574 }
 575
 576 void
 577 MidiDiskstream::set_pending_overwrite (bool yn)
 578 {
 579         /* called from audio thread, so we can use the read ptr and playback sample as we wish */
 580
 581         _pending_overwrite = yn;
 582         overwrite_frame = playback_sample;
 583 }
 584
 585 int
 586 MidiDiskstream::overwrite_existing_buffers ()
 587 {
 588         /* This is safe as long as the butler thread is suspended, which it should be */
 589         _playback_buf->reset ();
 590
 591         g_atomic_int_set (&_frames_read_from_ringbuffer, 0);
 592         g_atomic_int_set (&_frames_written_to_ringbuffer, 0);
 593
 594         read (overwrite_frame, disk_io_chunk_frames, false);
 595         file_frame = overwrite_frame; // it was adjusted by ::read()
 596         overwrite_queued = false;
 597         _pending_overwrite = false;
 598
 599         return 0;
 600 }
 601
 602 int
 603 MidiDiskstream::seek (framepos_t frame, bool complete_refill)
 604 {
 605         Glib::Threads::Mutex::Lock lm (state_lock);
 606         int ret = -1;
 607
 608         if (g_atomic_int_get (&_frames_read_from_ringbuffer) == 0) {
 609                 /* we haven't read anything since the last seek,
 610                    so flush all note trackers to prevent
 611                    wierdness
 612                 */
 613                 reset_tracker ();
 614         }
 615
 616         _playback_buf->reset();
 617         _capture_buf->reset();
 618         g_atomic_int_set(&_frames_read_from_ringbuffer, 0);
 619         g_atomic_int_set(&_frames_written_to_ringbuffer, 0);
 620
 621         playback_sample = frame;
 622         file_frame = frame;
 623
 624         if (complete_refill) {
 625                 while ((ret = do_refill_with_alloc ()) > 0) ;
 626         } else {
 627                 ret = do_refill_with_alloc ();
 628         }
 629
 630         return ret;
 631 }
 632
 633 int
 634 MidiDiskstream::can_internal_playback_seek (framecnt_t distance)
 635 {
 636         uint32_t frames_read    = g_atomic_int_get(&_frames_read_from_ringbuffer);
 637         uint32_t frames_written = g_atomic_int_get(&_frames_written_to_ringbuffer);
 638         return ((frames_written - frames_read) < distance);
 639 }
 640
 641 int
 642 MidiDiskstream::internal_playback_seek (framecnt_t distance)
 643 {
 644         first_recordable_frame += distance;
 645         playback_sample += distance;
 646
 647         return 0;
 648 }
 649
 650 /** @a start is set to the new frame position (TIME) read up to */
 651 int
 652 MidiDiskstream::read (framepos_t& start, framecnt_t dur, bool reversed)
 653 {
 654         framecnt_t this_read   = 0;
 655         bool       reloop      = false;
 656         framepos_t loop_end    = 0;
 657         framepos_t loop_start  = 0;
 658         framecnt_t loop_length = 0;
 659         Location*  loc         = 0;
 660
 661         if (!reversed) {
 662
 663                 loc = loop_location;
 664                 get_location_times(loc, &loop_start, &loop_end, &loop_length);
 665
 666                 /* if we are looping, ensure that the first frame we read is at the correct
 667                    position within the loop.
 668                 */
 669
 670                 if (loc && (start >= loop_end)) {
 671                         //cerr << "start adjusted from " << start;
 672                         start = loop_start + ((start - loop_start) % loop_length);
 673                         //cerr << "to " << start << endl;
 674                 }
 675                 // cerr << "start is " << start << " end " << start+dur << "  loopstart: " << loop_start << "  loopend: " << loop_end << endl;
 676         }
 677
 678         while (dur) {
 679
 680                 /* take any loop into account. we can't read past the end of the loop. */
 681
 682                 if (loc && (loop_end - start <= dur)) {
 683                         this_read = loop_end - start;
 684                         // cerr << "reloop true: thisread: " << this_read << "  dur: " << dur << endl;
 685                         reloop = true;
 686                 } else {
 687                         reloop = false;
 688                         this_read = dur;
 689                 }
 690
 691                 if (this_read == 0) {
 692                         break;
 693                 }
 694
 695                 this_read = min(dur,this_read);
 696
 697                 if (midi_playlist()->read (*_playback_buf, start, this_read) != this_read) {
 698                         error << string_compose(
 699                                         _("MidiDiskstream %1: cannot read %2 from playlist at frame %3"),
 700                                         id(), this_read, start) << endmsg;
 701                         return -1;
 702                 }
 703
 704                 g_atomic_int_add (&_frames_written_to_ringbuffer, this_read);
 705
 706                 if (reversed) {
 707
 708                         // Swap note ons with note offs here.  etc?
 709                         // Fully reversing MIDI requires look-ahead (well, behind) to find previous
 710                         // CC values etc.  hard.
 711
 712                 } else {
 713
 714                         /* if we read to the end of the loop, go back to the beginning */
 715                         if (reloop) {
 716                                 // Synthesize LoopEvent here, because the next events
 717                                 // written will have non-monotonic timestamps.
 718                                 start = loop_start;
 719                         } else {
 720                                 start += this_read;
 721                         }
 722                 }
 723
 724                 dur -= this_read;
 725                 //offset += this_read;
 726         }
 727
 728         return 0;
 729 }
 730
 731 int
 732 MidiDiskstream::do_refill_with_alloc ()
 733 {
 734         return do_refill();
 735 }
 736
 737 int
 738 MidiDiskstream::do_refill ()
 739 {
 740         int     ret         = 0;
 741         size_t  write_space = _playback_buf->write_space();
 742         bool    reversed    = (_visible_speed * _session.transport_speed()) < 0.0f;
 743
 744         if (write_space == 0) {
 745                 return 0;
 746         }
 747
 748         if (reversed) {
 749                 return 0;
 750         }
 751
 752         /* at end: nothing to do */
 753         if (file_frame == max_framepos) {
 754                 return 0;
 755         }
 756
 757         /* no space to write */
 758         if (_playback_buf->write_space() == 0) {
 759                 return 0;
 760         }
 761
 762         uint32_t frames_read = g_atomic_int_get(&_frames_read_from_ringbuffer);
 763         uint32_t frames_written = g_atomic_int_get(&_frames_written_to_ringbuffer);
 764         if ((frames_written - frames_read) >= midi_readahead) {
 765                 return 0;
 766         }
 767
 768         framecnt_t to_read = midi_readahead - (frames_written - frames_read);
 769
 770         //cout << "MDS read for midi_readahead " << to_read << "  rb_contains: "
 771         //      << frames_written - frames_read << endl;
 772
 773         to_read = (framecnt_t) min ((framecnt_t) to_read, (framecnt_t) (max_framepos - file_frame));
 774
 775         if (read (file_frame, to_read, reversed)) {
 776                 ret = -1;
 777         }
 778
 779         return ret;
 780 }
 781
 782 /** Flush pending data to disk.
 783  *
 784  * Important note: this function will write *AT MOST* disk_io_chunk_frames
 785  * of data to disk. it will never write more than that.  If it writes that
 786  * much and there is more than that waiting to be written, it will return 1,
 787  * otherwise 0 on success or -1 on failure.
 788  *
 789  * If there is less than disk_io_chunk_frames to be written, no data will be
 790  * written at all unless @a force_flush is true.
 791  */
 792 int
 793 MidiDiskstream::do_flush (RunContext /*context*/, bool force_flush)
 794 {
 795         framecnt_t to_write;
 796         int32_t ret = 0;
 797
 798         if (!_write_source) {
 799                 return 0;
 800         }
 801
 802         const framecnt_t total = g_atomic_int_get(const_cast<gint*> (&_frames_pending_write));
 803
 804         if (total == 0 ||
 805             _capture_buf->read_space() == 0 ||
 806             (!force_flush && (total < disk_io_chunk_frames) && was_recording)) {
 807                 goto out;
 808         }
 809
 810         /* if there are 2+ chunks of disk i/o possible for
 811            this track), let the caller know so that it can arrange
 812            for us to be called again, ASAP.
 813
 814            if we are forcing a flush, then if there is* any* extra
 815            work, let the caller know.
 816
 817            if we are no longer recording and there is any extra work,
 818            let the caller know too.
 819            */
 820
 821         if (total >= 2 * disk_io_chunk_frames || ((force_flush || !was_recording) && total > disk_io_chunk_frames)) {
 822                 ret = 1;
 823         }
 824
 825         if (force_flush) {
 826                 /* push out everything we have, right now */
 827                 to_write = max_framecnt;
 828         } else {
 829                 to_write = disk_io_chunk_frames;
 830         }
 831
 832         if (record_enabled() && ((total > disk_io_chunk_frames) || force_flush)) {
 833                 if (_write_source->midi_write (*_capture_buf, get_capture_start_frame (0), to_write) != to_write) {
 834                         error << string_compose(_("MidiDiskstream %1: cannot write to disk"), id()) << endmsg;
 835                         return -1;
 836                 }
 837                 g_atomic_int_add(const_cast<gint*> (&_frames_pending_write), -to_write);
 838         }
 839
 840 out:
 841         return ret;
 842 }
 843
 844 void
 845 MidiDiskstream::transport_stopped_wallclock (struct tm& /*when*/, time_t /*twhen*/, bool abort_capture)
 846 {
 847         bool more_work = true;
 848         int err = 0;
 849         boost::shared_ptr<MidiRegion> region;
 850         MidiRegion::SourceList srcs;
 851         MidiRegion::SourceList::iterator src;
 852         vector<CaptureInfo*>::iterator ci;
 853
 854         finish_capture ();
 855
 856         /* butler is already stopped, but there may be work to do
 857            to flush remaining data to disk.
 858            */
 859
 860         while (more_work && !err) {
 861                 switch (do_flush (TransportContext, true)) {
 862                 case 0:
 863                         more_work = false;
 864                         break;
 865                 case 1:
 866                         break;
 867                 case -1:
 868                         error << string_compose(_("MidiDiskstream \"%1\": cannot flush captured data to disk!"), _name) << endmsg;
 869                         err++;
 870                 }
 871         }
 872
 873         /* XXX is there anything we can do if err != 0 ? */
 874         Glib::Threads::Mutex::Lock lm (capture_info_lock);
 875
 876         if (capture_info.empty()) {
 877                 goto no_capture_stuff_to_do;
 878         }
 879
 880         if (abort_capture) {
 881
 882                 if (_write_source) {
 883                         _write_source->mark_for_remove ();
 884                         _write_source->drop_references ();
 885                         _write_source.reset();
 886                 }
 887
 888                 /* new source set up in "out" below */
 889
 890         } else {
 891
 892                 framecnt_t total_capture = 0;
 893                 for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
 894                         total_capture += (*ci)->frames;
 895                 }
 896
 897                 if (_write_source->length (capture_info.front()->start) != 0) {
 898
 899                         /* phew, we have data */
 900
 901                         /* figure out the name for this take */
 902
 903                         srcs.push_back (_write_source);
 904
 905                         _write_source->set_timeline_position (capture_info.front()->start);
 906                         _write_source->set_captured_for (_name);
 907
 908                         /* set length in beats to entire capture length */
 909
 910                         BeatsFramesConverter converter (_session.tempo_map(), capture_info.front()->start);
 911                         const double total_capture_beats = converter.from (total_capture);
 912                         _write_source->set_length_beats (total_capture_beats);
 913
 914                         /* flush to disk: this step differs from the audio path,
 915                            where all the data is already on disk.
 916                         */
 917
 918                         _write_source->mark_midi_streaming_write_completed (Evoral::Sequence<Evoral::MusicalTime>::ResolveStuckNotes, total_capture_beats);
 919
 920                         /* we will want to be able to keep (over)writing the source
 921                            but we don't want it to be removable. this also differs
 922                            from the audio situation, where the source at this point
 923                            must be considered immutable. luckily, we can rely on
 924                            MidiSource::mark_streaming_write_completed() to have
 925                            already done the necessary work for that.
 926                         */
 927
 928                         string whole_file_region_name;
 929                         whole_file_region_name = region_name_from_path (_write_source->name(), true);
 930
 931                         /* Register a new region with the Session that
 932                            describes the entire source. Do this first
 933                            so that any sub-regions will obviously be
 934                            children of this one (later!)
 935                         */
 936
 937                         try {
 938                                 PropertyList plist;
 939
 940                                 plist.add (Properties::name, whole_file_region_name);
 941                                 plist.add (Properties::whole_file, true);
 942                                 plist.add (Properties::automatic, true);
 943                                 plist.add (Properties::start, 0);
 944                                 plist.add (Properties::length, total_capture);
 945                                 plist.add (Properties::layer, 0);
 946
 947                                 boost::shared_ptr<Region> rx (RegionFactory::create (srcs, plist));
 948
 949                                 region = boost::dynamic_pointer_cast<MidiRegion> (rx);
 950                                 region->special_set_position (capture_info.front()->start);
 951                         }
 952
 953
 954                         catch (failed_constructor& err) {
 955                                 error << string_compose(_("%1: could not create region for complete midi file"), _name) << endmsg;
 956                                 /* XXX what now? */
 957                         }
 958
 959                         _last_capture_sources.insert (_last_capture_sources.end(), srcs.begin(), srcs.end());
 960
 961                         _playlist->clear_changes ();
 962                         _playlist->freeze ();
 963
 964                         /* Session frame time of the initial capture in this pass, which is where the source starts */
 965                         framepos_t initial_capture = 0;
 966                         if (!capture_info.empty()) {
 967                                 initial_capture = capture_info.front()->start;
 968                         }
 969
 970                         for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
 971
 972                                 string region_name;
 973
 974                                 RegionFactory::region_name (region_name, _write_source->name(), false);
 975
 976                                 // cerr << _name << ": based on ci of " << (*ci)->start << " for " << (*ci)->frames << " add a region\n";
 977
 978                                 try {
 979                                         PropertyList plist;
 980
 981                                         /* start of this region is the offset between the start of its capture and the start of the whole pass */
 982                                         plist.add (Properties::start, (*ci)->start - initial_capture);
 983                                         plist.add (Properties::length, (*ci)->frames);
 984                                         plist.add (Properties::length_beats, converter.from((*ci)->frames));
 985                                         plist.add (Properties::name, region_name);
 986
 987                                         boost::shared_ptr<Region> rx (RegionFactory::create (srcs, plist));
 988                                         region = boost::dynamic_pointer_cast<MidiRegion> (rx);
 989                                 }
 990
 991                                 catch (failed_constructor& err) {
 992                                         error << _("MidiDiskstream: could not create region for captured midi!") << endmsg;
 993                                         continue; /* XXX is this OK? */
 994                                 }
 995
 996                                 // cerr << "add new region, buffer position = " << buffer_position << " @ " << (*ci)->start << endl;
 997
 998                                 i_am_the_modifier++;
 999                                 _playlist->add_region (region, (*ci)->start);
1000                                 i_am_the_modifier--;
1001                         }
1002
1003                         _playlist->thaw ();
1004                         _session.add_command (new StatefulDiffCommand(_playlist));
1005
1006                 } else {
1007
1008                         /* No data was recorded, so this capture will
1009                            effectively be aborted; do the same as we
1010                            do for an explicit abort.
1011                         */
1012
1013                         if (_write_source) {
1014                                 _write_source->mark_for_remove ();
1015                                 _write_source->drop_references ();
1016                                 _write_source.reset();
1017                         }
1018                 }
1019
1020         }
1021
1022         use_new_write_source (0);
1023
1024         for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1025                 delete *ci;
1026         }
1027
1028         capture_info.clear ();
1029         capture_start_frame = 0;
1030
1031   no_capture_stuff_to_do:
1032
1033         reset_tracker ();
1034 }
1035
1036 void
1037 MidiDiskstream::transport_looped (framepos_t)
1038 {
1039         /* Here we only keep track of the number of captured loops so monotonic
1040            event times can be delivered to the write source in process().  Trying
1041            to be clever here is a world of trouble, it is better to simply record
1042            the input in a straightforward non-destructive way.  In the future when
1043            we want to implement more clever MIDI looping modes it should be done in
1044            the Source and/or entirely after the capture is finished.
1045         */
1046         if (was_recording) {
1047                 g_atomic_int_add(const_cast<gint*> (&_num_captured_loops), 1);
1048         }
1049 }
1050
1051 void
1052 MidiDiskstream::finish_capture ()
1053 {
1054         was_recording = false;
1055
1056         if (capture_captured == 0) {
1057                 return;
1058         }
1059
1060         CaptureInfo* ci = new CaptureInfo;
1061
1062         ci->start  = capture_start_frame;
1063         ci->frames = capture_captured;
1064
1065         /* XXX theoretical race condition here. Need atomic exchange ?
1066            However, the circumstances when this is called right
1067            now (either on record-disable or transport_stopped)
1068            mean that no actual race exists. I think ...
1069            We now have a capture_info_lock, but it is only to be used
1070            to synchronize in the transport_stop and the capture info
1071            accessors, so that invalidation will not occur (both non-realtime).
1072         */
1073
1074         // cerr << "Finish capture, add new CI, " << ci->start << '+' << ci->frames << endl;
1075
1076         capture_info.push_back (ci);
1077         capture_captured = 0;
1078 }
1079
1080 void
1081 MidiDiskstream::set_record_enabled (bool yn)
1082 {
1083         if (!recordable() || !_session.record_enabling_legal() || _io->n_ports().n_midi() == 0) {
1084                 return;
1085         }
1086
1087         /* yes, i know that this not proof against race conditions, but its
1088            good enough. i think.
1089         */
1090
1091         if (record_enabled() != yn) {
1092                 if (yn) {
1093                         engage_record_enable ();
1094                 } else {
1095                         disengage_record_enable ();
1096                 }
1097
1098                 RecordEnableChanged (); /* EMIT SIGNAL */
1099         }
1100 }
1101
1102 bool
1103 MidiDiskstream::prep_record_enable ()
1104 {
1105         if (!recordable() || !_session.record_enabling_legal() || _io->n_ports().n_midi() == 0) {
1106                 return false;
1107         }
1108
1109         bool const rolling = _session.transport_speed() != 0.0f;
1110
1111         boost::shared_ptr<MidiPort> sp = _source_port.lock ();
1112
1113         if (sp && Config->get_monitoring_model() == HardwareMonitoring) {
1114                 sp->request_input_monitoring (!(_session.config.get_auto_input() && rolling));
1115         }
1116
1117         return true;
1118 }
1119
1120 bool
1121 MidiDiskstream::prep_record_disable ()
1122 {
1123
1124         return true;
1125 }
1126
1127 XMLNode&
1128 MidiDiskstream::get_state ()
1129 {
1130         XMLNode& node (Diskstream::get_state());
1131         char buf[64];
1132         LocaleGuard lg (X_("POSIX"));
1133
1134         if (_write_source && _session.get_record_enabled()) {
1135
1136                 XMLNode* cs_child = new XMLNode (X_("CapturingSources"));
1137                 XMLNode* cs_grandchild;
1138
1139                 cs_grandchild = new XMLNode (X_("file"));
1140                 cs_grandchild->add_property (X_("path"), _write_source->path());
1141                 cs_child->add_child_nocopy (*cs_grandchild);
1142
1143                 /* store the location where capture will start */
1144
1145                 Location* pi;
1146
1147                 if (_session.config.get_punch_in() && ((pi = _session.locations()->auto_punch_location()) != 0)) {
1148                         snprintf (buf, sizeof (buf), "%" PRId64, pi->start());
1149                 } else {
1150                         snprintf (buf, sizeof (buf), "%" PRId64, _session.transport_frame());
1151                 }
1152
1153                 cs_child->add_property (X_("at"), buf);
1154                 node.add_child_nocopy (*cs_child);
1155         }
1156
1157         return node;
1158 }
1159
1160 int
1161 MidiDiskstream::set_state (const XMLNode& node, int version)
1162 {
1163         XMLNodeList nlist = node.children();
1164         XMLNodeIterator niter;
1165         XMLNode* capture_pending_node = 0;
1166         LocaleGuard lg (X_("POSIX"));
1167
1168         /* prevent write sources from being created */
1169
1170         in_set_state = true;
1171
1172         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1173                 if ((*niter)->name() == X_("CapturingSources")) {
1174                         capture_pending_node = *niter;
1175                 }
1176         }
1177
1178         if (Diskstream::set_state (node, version)) {
1179                 return -1;
1180         }
1181
1182         if (capture_pending_node) {
1183                 use_pending_capture_data (*capture_pending_node);
1184         }
1185
1186         in_set_state = false;
1187
1188         return 0;
1189 }
1190
1191 int
1192 MidiDiskstream::use_new_write_source (uint32_t n)
1193 {
1194         if (!_session.writable() || !recordable()) {
1195                 return 1;
1196         }
1197
1198         _write_source.reset();
1199
1200         try {
1201                 _write_source = boost::dynamic_pointer_cast<SMFSource>(
1202                         _session.create_midi_source_for_session (0, name ()));
1203
1204                 if (!_write_source) {
1205                         throw failed_constructor();
1206                 }
1207         }
1208
1209         catch (failed_constructor &err) {
1210                 error << string_compose (_("%1:%2 new capture file not initialized correctly"), _name, n) << endmsg;
1211                 _write_source.reset();
1212                 return -1;
1213         }
1214
1215         return 0;
1216 }
1217
1218 list<boost::shared_ptr<Source> >
1219 MidiDiskstream::steal_write_sources()
1220 {
1221         list<boost::shared_ptr<Source> > ret;
1222
1223         /* put some data on the disk, even if its just a header for an empty file */
1224         boost::dynamic_pointer_cast<SMFSource> (_write_source)->ensure_disk_file ();
1225
1226         /* never let it go away */
1227         _write_source->mark_nonremovable ();
1228
1229         ret.push_back (_write_source);
1230
1231         /* get a new one */
1232
1233         use_new_write_source (0);
1234
1235         return ret;
1236 }
1237
1238 void
1239 MidiDiskstream::reset_write_sources (bool mark_write_complete, bool /*force*/)
1240 {
1241         if (!_session.writable() || !recordable()) {
1242                 return;
1243         }
1244
1245         if (_write_source && mark_write_complete) {
1246                 _write_source->mark_streaming_write_completed ();
1247         }
1248         use_new_write_source (0);
1249 }
1250
1251 void
1252 MidiDiskstream::set_block_size (pframes_t /*nframes*/)
1253 {
1254 }
1255
1256 void
1257 MidiDiskstream::allocate_temporary_buffers ()
1258 {
1259 }
1260
1261 void
1262 MidiDiskstream::ensure_input_monitoring (bool yn)
1263 {
1264         boost::shared_ptr<MidiPort> sp = _source_port.lock ();
1265
1266         if (sp) {
1267                 sp->ensure_input_monitoring (yn);
1268         }
1269 }
1270
1271 void
1272 MidiDiskstream::set_align_style_from_io ()
1273 {
1274         if (_alignment_choice != Automatic) {
1275                 return;
1276         }
1277
1278         /* XXX Not sure what, if anything we can do with MIDI
1279            as far as capture alignment etc.
1280         */
1281
1282         set_align_style (ExistingMaterial);
1283 }
1284
1285
1286 float
1287 MidiDiskstream::playback_buffer_load () const
1288 {
1289         /* For MIDI it's not trivial to differentiate the following two cases:
1290
1291            1.  The playback buffer is empty because the system has run out of time to fill it.
1292            2.  The playback buffer is empty because there is no more data on the playlist.
1293
1294            If we use a simple buffer load computation, we will report that the MIDI diskstream
1295            cannot keep up when #2 happens, when in fact it can.  Since MIDI data rates
1296            are so low compared to audio, just give a pretend answer here.
1297         */
1298
1299         return 1;
1300 }
1301
1302 float
1303 MidiDiskstream::capture_buffer_load () const
1304 {
1305         /* We don't report playback buffer load, so don't report capture load either */
1306
1307         return 1;
1308 }
1309
1310 int
1311 MidiDiskstream::use_pending_capture_data (XMLNode& /*node*/)
1312 {
1313         return 0;
1314 }
1315
1316 void
1317 MidiDiskstream::flush_playback (framepos_t start, framepos_t end)
1318 {
1319         _playback_buf->flush (start, end);
1320         g_atomic_int_add (&_frames_read_from_ringbuffer, end - start);
1321 }
1322
1323 /** Writes playback events from playback_sample for nframes to dst, translating time stamps
1324  *  so that an event at playback_sample has time = 0
1325  */
1326 void
1327 MidiDiskstream::get_playback (MidiBuffer& dst, framecnt_t nframes)
1328 {
1329         dst.clear();
1330
1331         Location* loc = loop_location;
1332
1333         DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose (
1334                              "%1 MDS pre-read read %8 @ %4..%5 from %2 write to %3, LOOPED ? %6-%7\n", _name,
1335                              _playback_buf->get_read_ptr(), _playback_buf->get_write_ptr(), playback_sample, playback_sample + nframes,
1336                              (loc ? loc->start() : -1), (loc ? loc->end() : -1), nframes));
1337
1338         // cerr << "================\n";
1339         // _playback_buf->dump (cerr);
1340         // cerr << "----------------\n";
1341
1342         size_t events_read = 0;
1343
1344         if (loc) {
1345                 framepos_t effective_start;
1346
1347                 if (playback_sample >= loc->end()) {
1348                         effective_start = loc->start() + ((playback_sample - loc->end()) % loc->length());
1349                 } else {
1350                         effective_start = playback_sample;
1351                 }
1352
1353                 DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("looped, effective start adjusted to %1\n", effective_start));
1354
1355                 if (effective_start == loc->start()) {
1356                         /* We need to turn off notes that may extend
1357                            beyond the loop end.
1358                         */
1359
1360                         _playback_buf->loop_resolve (dst, 0);
1361                 }
1362
1363                 if (loc->end() >= effective_start && loc->end() < effective_start + nframes) {
1364                         /* end of loop is within the range we are reading, so
1365                            split the read in two, and lie about the location
1366                            for the 2nd read
1367                         */
1368                         framecnt_t first, second;
1369
1370                         first = loc->end() - effective_start;
1371                         second = nframes - first;
1372
1373                         DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("loop read for eff %1 end %2: %3 and %4\n",
1374                                                                               effective_start, loc->end(), first, second));
1375
1376                         if (first) {
1377                                 DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("loop read #1, from %1 for %2\n",
1378                                                                                       effective_start, first));
1379                                 events_read = _playback_buf->read (dst, effective_start, first);
1380                         }
1381
1382                         if (second) {
1383                                 DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("loop read #2, from %1 for %2\n",
1384                                                                                       loc->start(), second));
1385                                 events_read += _playback_buf->read (dst, loc->start(), second);
1386                         }
1387
1388                 } else {
1389                         DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("loop read #3, adjusted start as %1 for %2\n",
1390                                                                               effective_start, nframes));
1391                         events_read = _playback_buf->read (dst, effective_start, effective_start + nframes);
1392                 }
1393         } else {
1394                 events_read = _playback_buf->read (dst, playback_sample, playback_sample + nframes);
1395         }
1396
1397         DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose (
1398                              "%1 MDS events read %2 range %3 .. %4 rspace %5 wspace %6 r@%7 w@%8\n",
1399                              _name, events_read, playback_sample, playback_sample + nframes,
1400                              _playback_buf->read_space(), _playback_buf->write_space(),
1401                              _playback_buf->get_read_ptr(), _playback_buf->get_write_ptr()));
1402
1403         g_atomic_int_add (&_frames_read_from_ringbuffer, nframes);
1404 }
1405
1406 bool
1407 MidiDiskstream::set_name (string const & name)
1408 {
1409         Diskstream::set_name (name);
1410
1411         /* get a new write source so that its name reflects the new diskstream name */
1412         use_new_write_source (0);
1413
1414         return true;
1415 }
1416
1417 boost::shared_ptr<MidiBuffer>
1418 MidiDiskstream::get_gui_feed_buffer () const
1419 {
1420         boost::shared_ptr<MidiBuffer> b (new MidiBuffer (AudioEngine::instance()->raw_buffer_size (DataType::MIDI)));
1421
1422         Glib::Threads::Mutex::Lock lm (_gui_feed_buffer_mutex);
1423         b->copy (_gui_feed_buffer);
1424         return b;
1425 }
1426
1427 void
1428 MidiDiskstream::reset_tracker ()
1429 {
1430         _playback_buf->reset_tracker ();
1431
1432         boost::shared_ptr<MidiPlaylist> mp (midi_playlist());
1433
1434         if (mp) {
1435                 mp->clear_note_trackers ();
1436         }
1437 }