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