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