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