libs/ardour/midi_diskstream.cc

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