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                 Evoral::OverlapType ot = Evoral::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         /*
 459           cerr << name() << " MDS written: " << frames_written << " - read: " << frames_read <<
 460           " = " << frames_written - frames_read
 461           << " + " << playback_distance << " < " << midi_readahead << " = " << need_butler << ")" << endl;
 462         */
 463
 464         /* frames_read will generally be less than frames_written, but
 465          * immediately after an overwrite, we can end up having read some data
 466          * before we've written any. we don't need to trip an assert() on this,
 467          * but we do need to check so that the decision on whether or not we
 468          * need the butler is done correctly.
 469          */
 470
 471         if (frames_read <= frames_written) {
 472                 if ((frames_written - frames_read) + playback_distance < midi_readahead) {
 473                         need_butler = true;
 474                 }
 475         }
 476
 477
 478         return need_butler;
 479 }
 480
 481 void
 482 MidiDiskstream::set_pending_overwrite (bool yn)
 483 {
 484         /* called from audio thread, so we can use the read ptr and playback sample as we wish */
 485
 486         _pending_overwrite = yn;
 487         overwrite_frame = playback_sample;
 488 }
 489
 490 int
 491 MidiDiskstream::overwrite_existing_buffers ()
 492 {
 493         /* This is safe as long as the butler thread is suspended, which it should be */
 494         _playback_buf->reset ();
 495
 496         g_atomic_int_set (&_frames_read_from_ringbuffer, 0);
 497         g_atomic_int_set (&_frames_written_to_ringbuffer, 0);
 498
 499         read (overwrite_frame, disk_io_chunk_frames, false);
 500         file_frame = overwrite_frame; // it was adjusted by ::read()
 501         overwrite_queued = false;
 502         _pending_overwrite = false;
 503
 504         return 0;
 505 }
 506
 507 int
 508 MidiDiskstream::seek (framepos_t frame, bool complete_refill)
 509 {
 510         Glib::Mutex::Lock lm (state_lock);
 511         int ret = -1;
 512
 513         _playback_buf->reset();
 514         _capture_buf->reset();
 515         g_atomic_int_set(&_frames_read_from_ringbuffer, 0);
 516         g_atomic_int_set(&_frames_written_to_ringbuffer, 0);
 517
 518         playback_sample = frame;
 519         file_frame = frame;
 520
 521         if (complete_refill) {
 522                 while ((ret = do_refill_with_alloc ()) > 0) ;
 523         } else {
 524                 ret = do_refill_with_alloc ();
 525         }
 526
 527         return ret;
 528 }
 529
 530 int
 531 MidiDiskstream::can_internal_playback_seek (framecnt_t distance)
 532 {
 533         uint32_t frames_read    = g_atomic_int_get(&_frames_read_from_ringbuffer);
 534         uint32_t frames_written = g_atomic_int_get(&_frames_written_to_ringbuffer);
 535         return ((frames_written - frames_read) < distance);
 536 }
 537
 538 int
 539 MidiDiskstream::internal_playback_seek (framecnt_t distance)
 540 {
 541         first_recordable_frame += distance;
 542         playback_sample += distance;
 543
 544         return 0;
 545 }
 546
 547 /** @a start is set to the new frame position (TIME) read up to */
 548 int
 549 MidiDiskstream::read (framepos_t& start, framecnt_t dur, bool reversed)
 550 {
 551         framecnt_t this_read = 0;
 552         bool reloop = false;
 553         framepos_t loop_end = 0;
 554         framepos_t loop_start = 0;
 555         Location *loc = 0;
 556
 557         if (!reversed) {
 558
 559                 framecnt_t loop_length = 0;
 560
 561                 /* Make the use of a Location atomic for this read operation.
 562
 563                    Note: Locations don't get deleted, so all we care about
 564                    when I say "atomic" is that we are always pointing to
 565                    the same one and using a start/length values obtained
 566                    just once.
 567                 */
 568
 569                 if ((loc = loop_location) != 0) {
 570                         loop_start = loc->start();
 571                         loop_end = loc->end();
 572                         loop_length = loop_end - loop_start;
 573                 }
 574
 575                 /* if we are looping, ensure that the first frame we read is at the correct
 576                    position within the loop.
 577                 */
 578
 579                 if (loc && (start >= loop_end)) {
 580                         //cerr << "start adjusted from " << start;
 581                         start = loop_start + ((start - loop_start) % loop_length);
 582                         //cerr << "to " << start << endl;
 583                 }
 584                 // cerr << "start is " << start << " end " << start+dur << "  loopstart: " << loop_start << "  loopend: " << loop_end << endl;
 585         }
 586
 587         while (dur) {
 588
 589                 /* take any loop into account. we can't read past the end of the loop. */
 590
 591                 if (loc && (loop_end - start <= dur)) {
 592                         this_read = loop_end - start;
 593                         // cerr << "reloop true: thisread: " << this_read << "  dur: " << dur << endl;
 594                         reloop = true;
 595                 } else {
 596                         reloop = false;
 597                         this_read = dur;
 598                 }
 599
 600                 if (this_read == 0) {
 601                         break;
 602                 }
 603
 604                 this_read = min(dur,this_read);
 605
 606                 if (midi_playlist()->read (*_playback_buf, start, this_read) != this_read) {
 607                         error << string_compose(
 608                                         _("MidiDiskstream %1: cannot read %2 from playlist at frame %3"),
 609                                         id(), this_read, start) << endmsg;
 610                         return -1;
 611                 }
 612
 613                 g_atomic_int_add (&_frames_written_to_ringbuffer, this_read);
 614
 615                 if (reversed) {
 616
 617                         // Swap note ons with note offs here.  etc?
 618                         // Fully reversing MIDI requires look-ahead (well, behind) to find previous
 619                         // CC values etc.  hard.
 620
 621                 } else {
 622
 623                         /* if we read to the end of the loop, go back to the beginning */
 624
 625                         if (reloop) {
 626                                 // Synthesize LoopEvent here, because the next events
 627                                 // written will have non-monotonic timestamps.
 628                                 _playback_buf->write(loop_end - 1, LoopEventType, sizeof (framepos_t), (uint8_t *) &loop_start);
 629                                 start = loop_start;
 630                         } else {
 631                                 start += this_read;
 632                         }
 633                 }
 634
 635                 dur -= this_read;
 636                 //offset += this_read;
 637         }
 638
 639         return 0;
 640 }
 641
 642 int
 643 MidiDiskstream::do_refill_with_alloc ()
 644 {
 645         return do_refill();
 646 }
 647
 648 int
 649 MidiDiskstream::do_refill ()
 650 {
 651         int     ret         = 0;
 652         size_t  write_space = _playback_buf->write_space();
 653         bool    reversed    = (_visible_speed * _session.transport_speed()) < 0.0f;
 654
 655         if (write_space == 0) {
 656                 return 0;
 657         }
 658
 659         if (reversed) {
 660                 return 0;
 661         }
 662
 663         /* at end: nothing to do */
 664         if (file_frame == max_framepos) {
 665                 return 0;
 666         }
 667
 668         // At this point we...
 669         assert(_playback_buf->write_space() > 0); // ... have something to write to, and
 670         assert(file_frame <= max_framepos); // ... something to write
 671
 672         // now calculate how much time is in the ringbuffer.
 673         // and lets write as much as we need to get this to be midi_readahead;
 674         uint32_t frames_read = g_atomic_int_get(&_frames_read_from_ringbuffer);
 675         uint32_t frames_written = g_atomic_int_get(&_frames_written_to_ringbuffer);
 676         if ((frames_written - frames_read) >= midi_readahead) {
 677                 return 0;
 678         }
 679
 680         framecnt_t to_read = midi_readahead - (frames_written - frames_read);
 681
 682         //cout << "MDS read for midi_readahead " << to_read << "  rb_contains: "
 683         //      << frames_written - frames_read << endl;
 684
 685         to_read = (framecnt_t) min ((framecnt_t) to_read, (framecnt_t) (max_framepos - file_frame));
 686
 687         if (read (file_frame, to_read, reversed)) {
 688                 ret = -1;
 689         }
 690
 691         return ret;
 692 }
 693
 694 /** Flush pending data to disk.
 695  *
 696  * Important note: this function will write *AT MOST* disk_io_chunk_frames
 697  * of data to disk. it will never write more than that.  If it writes that
 698  * much and there is more than that waiting to be written, it will return 1,
 699  * otherwise 0 on success or -1 on failure.
 700  *
 701  * If there is less than disk_io_chunk_frames to be written, no data will be
 702  * written at all unless @a force_flush is true.
 703  */
 704 int
 705 MidiDiskstream::do_flush (RunContext /*context*/, bool force_flush)
 706 {
 707         framecnt_t to_write;
 708         framecnt_t total;
 709         int32_t ret = 0;
 710
 711         if (!_write_source) {
 712                 return 0;
 713         }
 714
 715         assert (!destructive());
 716
 717         total = _session.transport_frame() - _write_source->last_write_end();
 718
 719         if (total == 0 ||
 720             _capture_buf->read_space() == 0 ||
 721             (!force_flush && (total < disk_io_chunk_frames) && was_recording)) {
 722                 goto out;
 723         }
 724
 725         /* if there are 2+ chunks of disk i/o possible for
 726            this track, let the caller know so that it can arrange
 727            for us to be called again, ASAP.
 728
 729            if we are forcing a flush, then if there is* any* extra
 730            work, let the caller know.
 731
 732            if we are no longer recording and there is any extra work,
 733            let the caller know too.
 734            */
 735
 736         if (total >= 2 * disk_io_chunk_frames || ((force_flush || !was_recording) && total > disk_io_chunk_frames)) {
 737                 ret = 1;
 738         }
 739
 740         if (force_flush) {
 741                 /* push out everything we have, right now */
 742                 to_write = max_framecnt;
 743         } else {
 744                 to_write = disk_io_chunk_frames;
 745         }
 746
 747         if (record_enabled() && ((total > disk_io_chunk_frames) || force_flush)) {
 748                 if (_write_source->midi_write (*_capture_buf, get_capture_start_frame (0), to_write) != to_write) {
 749                         error << string_compose(_("MidiDiskstream %1: cannot write to disk"), id()) << endmsg;
 750                         return -1;
 751                 }
 752         }
 753
 754 out:
 755         return ret;
 756 }
 757
 758 void
 759 MidiDiskstream::transport_stopped_wallclock (struct tm& /*when*/, time_t /*twhen*/, bool abort_capture)
 760 {
 761         bool more_work = true;
 762         int err = 0;
 763         boost::shared_ptr<MidiRegion> region;
 764         MidiRegion::SourceList srcs;
 765         MidiRegion::SourceList::iterator src;
 766         vector<CaptureInfo*>::iterator ci;
 767
 768         finish_capture ();
 769
 770         /* butler is already stopped, but there may be work to do
 771            to flush remaining data to disk.
 772            */
 773
 774         while (more_work && !err) {
 775                 switch (do_flush (TransportContext, true)) {
 776                 case 0:
 777                         more_work = false;
 778                         break;
 779                 case 1:
 780                         break;
 781                 case -1:
 782                         error << string_compose(_("MidiDiskstream \"%1\": cannot flush captured data to disk!"), _name) << endmsg;
 783                         err++;
 784                 }
 785         }
 786
 787         /* XXX is there anything we can do if err != 0 ? */
 788         Glib::Mutex::Lock lm (capture_info_lock);
 789
 790         if (capture_info.empty()) {
 791                 goto no_capture_stuff_to_do;
 792         }
 793
 794         if (abort_capture) {
 795
 796                 if (_write_source) {
 797                         _write_source->mark_for_remove ();
 798                         _write_source->drop_references ();
 799                         _write_source.reset();
 800                 }
 801
 802                 /* new source set up in "out" below */
 803
 804         } else {
 805
 806                 assert(_write_source);
 807
 808                 framecnt_t total_capture = 0;
 809                 for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
 810                         total_capture += (*ci)->frames;
 811                 }
 812
 813                 if (_write_source->length (capture_info.front()->start) != 0) {
 814
 815                         /* phew, we have data */
 816
 817                         /* figure out the name for this take */
 818
 819                         srcs.push_back (_write_source);
 820
 821                         _write_source->set_timeline_position (capture_info.front()->start);
 822                         _write_source->set_captured_for (_name);
 823
 824                         /* set length in beats to entire capture length */
 825
 826                         BeatsFramesConverter converter (_session.tempo_map(), capture_info.front()->start);
 827                         const double total_capture_beats = converter.from (total_capture);
 828                         _write_source->set_length_beats (total_capture_beats);
 829
 830                         /* flush to disk: this step differs from the audio path,
 831                            where all the data is already on disk.
 832                         */
 833
 834                         _write_source->mark_midi_streaming_write_completed (Evoral::Sequence<Evoral::MusicalTime>::ResolveStuckNotes, total_capture_beats);
 835
 836                         /* we will want to be able to keep (over)writing the source
 837                            but we don't want it to be removable. this also differs
 838                            from the audio situation, where the source at this point
 839                            must be considered immutable. luckily, we can rely on
 840                            MidiSource::mark_streaming_write_completed() to have
 841                            already done the necessary work for that.
 842                         */
 843
 844                         string whole_file_region_name;
 845                         whole_file_region_name = region_name_from_path (_write_source->name(), true);
 846
 847                         /* Register a new region with the Session that
 848                            describes the entire source. Do this first
 849                            so that any sub-regions will obviously be
 850                            children of this one (later!)
 851                         */
 852
 853                         try {
 854                                 PropertyList plist;
 855
 856                                 plist.add (Properties::name, whole_file_region_name);
 857                                 plist.add (Properties::whole_file, true);
 858                                 plist.add (Properties::automatic, true);
 859                                 plist.add (Properties::start, 0);
 860                                 plist.add (Properties::length, total_capture);
 861                                 plist.add (Properties::layer, 0);
 862
 863                                 boost::shared_ptr<Region> rx (RegionFactory::create (srcs, plist));
 864
 865                                 region = boost::dynamic_pointer_cast<MidiRegion> (rx);
 866                                 region->special_set_position (capture_info.front()->start);
 867                         }
 868
 869
 870                         catch (failed_constructor& err) {
 871                                 error << string_compose(_("%1: could not create region for complete midi file"), _name) << endmsg;
 872                                 /* XXX what now? */
 873                         }
 874
 875                         _last_capture_sources.insert (_last_capture_sources.end(), srcs.begin(), srcs.end());
 876
 877                         _playlist->clear_changes ();
 878                         _playlist->freeze ();
 879
 880                         /* Session frame time of the initial capture in this pass, which is where the source starts */
 881                         framepos_t initial_capture = 0;
 882                         if (!capture_info.empty()) {
 883                                 initial_capture = capture_info.front()->start;
 884                         }
 885
 886                         for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
 887
 888                                 string region_name;
 889
 890                                 RegionFactory::region_name (region_name, _write_source->name(), false);
 891
 892                                 // cerr << _name << ": based on ci of " << (*ci)->start << " for " << (*ci)->frames << " add a region\n";
 893
 894                                 try {
 895                                         PropertyList plist;
 896
 897                                         /* start of this region is the offset between the start of its capture and the start of the whole pass */
 898                                         plist.add (Properties::start, (*ci)->start - initial_capture);
 899                                         plist.add (Properties::length, (*ci)->frames);
 900                                         plist.add (Properties::length_beats, converter.from((*ci)->frames));
 901                                         plist.add (Properties::name, region_name);
 902
 903                                         boost::shared_ptr<Region> rx (RegionFactory::create (srcs, plist));
 904                                         region = boost::dynamic_pointer_cast<MidiRegion> (rx);
 905                                 }
 906
 907                                 catch (failed_constructor& err) {
 908                                         error << _("MidiDiskstream: could not create region for captured midi!") << endmsg;
 909                                         continue; /* XXX is this OK? */
 910                                 }
 911
 912                                 // cerr << "add new region, buffer position = " << buffer_position << " @ " << (*ci)->start << endl;
 913
 914                                 i_am_the_modifier++;
 915                                 _playlist->add_region (region, (*ci)->start);
 916                                 i_am_the_modifier--;
 917                         }
 918
 919                         _playlist->thaw ();
 920                         _session.add_command (new StatefulDiffCommand(_playlist));
 921
 922                 } else {
 923
 924                         /* No data was recorded, so this capture will
 925                            effectively be aborted; do the same as we
 926                            do for an explicit abort.
 927                         */
 928
 929                         if (_write_source) {
 930                                 _write_source->mark_for_remove ();
 931                                 _write_source->drop_references ();
 932                                 _write_source.reset();
 933                         }
 934                 }
 935
 936         }
 937
 938         use_new_write_source (0);
 939
 940         for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
 941                 delete *ci;
 942         }
 943
 944         capture_info.clear ();
 945         capture_start_frame = 0;
 946
 947   no_capture_stuff_to_do:
 948
 949         reset_tracker ();
 950 }
 951
 952 void
 953 MidiDiskstream::transport_looped (framepos_t transport_frame)
 954 {
 955         if (was_recording) {
 956
 957                 // adjust the capture length knowing that the data will be recorded to disk
 958                 // only necessary after the first loop where we're recording
 959                 if (capture_info.size() == 0) {
 960                         capture_captured += _capture_offset;
 961
 962                         if (_alignment_style == ExistingMaterial) {
 963                                 capture_captured += _session.worst_output_latency();
 964                         } else {
 965                                 capture_captured += _roll_delay;
 966                         }
 967                 }
 968
 969                 finish_capture ();
 970
 971                 // the next region will start recording via the normal mechanism
 972                 // we'll set the start position to the current transport pos
 973                 // no latency adjustment or capture offset needs to be made, as that already happened the first time
 974                 capture_start_frame = transport_frame;
 975                 first_recordable_frame = transport_frame; // mild lie
 976                 last_recordable_frame = max_framepos;
 977                 was_recording = true;
 978         }
 979
 980         if (!Config->get_seamless_loop()) {
 981                 reset_tracker ();
 982         }
 983 }
 984
 985 void
 986 MidiDiskstream::finish_capture ()
 987 {
 988         was_recording = false;
 989
 990         if (capture_captured == 0) {
 991                 return;
 992         }
 993
 994         // Why must we destroy?
 995         assert(!destructive());
 996
 997         CaptureInfo* ci = new CaptureInfo;
 998
 999         ci->start  = capture_start_frame;
1000         ci->frames = capture_captured;
1001
1002         /* XXX theoretical race condition here. Need atomic exchange ?
1003            However, the circumstances when this is called right
1004            now (either on record-disable or transport_stopped)
1005            mean that no actual race exists. I think ...
1006            We now have a capture_info_lock, but it is only to be used
1007            to synchronize in the transport_stop and the capture info
1008            accessors, so that invalidation will not occur (both non-realtime).
1009         */
1010
1011         // cerr << "Finish capture, add new CI, " << ci->start << '+' << ci->frames << endl;
1012
1013         capture_info.push_back (ci);
1014         capture_captured = 0;
1015 }
1016
1017 void
1018 MidiDiskstream::set_record_enabled (bool yn)
1019 {
1020         if (!recordable() || !_session.record_enabling_legal()) {
1021                 return;
1022         }
1023
1024         assert(!destructive());
1025
1026         /* yes, i know that this not proof against race conditions, but its
1027            good enough. i think.
1028         */
1029
1030         if (record_enabled() != yn) {
1031                 if (yn) {
1032                         engage_record_enable ();
1033                 } else {
1034                         disengage_record_enable ();
1035                 }
1036         }
1037 }
1038
1039 void
1040 MidiDiskstream::engage_record_enable ()
1041 {
1042         bool const rolling = _session.transport_speed() != 0.0f;
1043
1044         g_atomic_int_set (&_record_enabled, 1);
1045
1046         boost::shared_ptr<MidiPort> sp = _source_port.lock ();
1047
1048         if (sp && Config->get_monitoring_model() == HardwareMonitoring) {
1049                 sp->request_jack_monitors_input (!(_session.config.get_auto_input() && rolling));
1050         }
1051
1052         RecordEnableChanged (); /* EMIT SIGNAL */
1053 }
1054
1055 void
1056 MidiDiskstream::disengage_record_enable ()
1057 {
1058         g_atomic_int_set (&_record_enabled, 0);
1059         RecordEnableChanged (); /* EMIT SIGNAL */
1060 }
1061
1062 XMLNode&
1063 MidiDiskstream::get_state ()
1064 {
1065         XMLNode& node (Diskstream::get_state());
1066         char buf[64];
1067         LocaleGuard lg (X_("POSIX"));
1068
1069         node.add_property("channel-mode", enum_2_string(get_channel_mode()));
1070         snprintf (buf, sizeof(buf), "0x%x", get_channel_mask());
1071         node.add_property("channel-mask", buf);
1072
1073         if (_write_source && _session.get_record_enabled()) {
1074
1075                 XMLNode* cs_child = new XMLNode (X_("CapturingSources"));
1076                 XMLNode* cs_grandchild;
1077
1078                 cs_grandchild = new XMLNode (X_("file"));
1079                 cs_grandchild->add_property (X_("path"), _write_source->path());
1080                 cs_child->add_child_nocopy (*cs_grandchild);
1081
1082                 /* store the location where capture will start */
1083
1084                 Location* pi;
1085
1086                 if (_session.config.get_punch_in() && ((pi = _session.locations()->auto_punch_location()) != 0)) {
1087                         snprintf (buf, sizeof (buf), "%" PRId64, pi->start());
1088                 } else {
1089                         snprintf (buf, sizeof (buf), "%" PRId64, _session.transport_frame());
1090                 }
1091
1092                 cs_child->add_property (X_("at"), buf);
1093                 node.add_child_nocopy (*cs_child);
1094         }
1095
1096         return node;
1097 }
1098
1099 int
1100 MidiDiskstream::set_state (const XMLNode& node, int version)
1101 {
1102         const XMLProperty* prop;
1103         XMLNodeList nlist = node.children();
1104         XMLNodeIterator niter;
1105         XMLNode* capture_pending_node = 0;
1106         LocaleGuard lg (X_("POSIX"));
1107
1108         /* prevent write sources from being created */
1109
1110         in_set_state = true;
1111
1112         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1113                 assert ((*niter)->name() != IO::state_node_name);
1114
1115                 if ((*niter)->name() == X_("CapturingSources")) {
1116                         capture_pending_node = *niter;
1117                 }
1118         }
1119
1120         if (Diskstream::set_state (node, version)) {
1121                 return -1;
1122         }
1123
1124         ChannelMode channel_mode = AllChannels;
1125         if ((prop = node.property ("channel-mode")) != 0) {
1126                 channel_mode = ChannelMode (string_2_enum(prop->value(), channel_mode));
1127         }
1128
1129         unsigned int channel_mask = 0xFFFF;
1130         if ((prop = node.property ("channel-mask")) != 0) {
1131                 sscanf (prop->value().c_str(), "0x%x", &channel_mask);
1132                 if (channel_mask & (~0xFFFF)) {
1133                         warning << _("MidiDiskstream: XML property channel-mask out of range") << endmsg;
1134                 }
1135         }
1136
1137
1138         if (capture_pending_node) {
1139                 use_pending_capture_data (*capture_pending_node);
1140         }
1141
1142         set_channel_mode (channel_mode, channel_mask);
1143
1144         in_set_state = false;
1145
1146         return 0;
1147 }
1148
1149 int
1150 MidiDiskstream::use_new_write_source (uint32_t n)
1151 {
1152         if (!_session.writable() || !recordable()) {
1153                 return 1;
1154         }
1155
1156         assert(n == 0);
1157
1158         _write_source.reset();
1159
1160         try {
1161                 _write_source = boost::dynamic_pointer_cast<SMFSource>(
1162                         _session.create_midi_source_for_session (0, name ()));
1163
1164                 if (!_write_source) {
1165                         throw failed_constructor();
1166                 }
1167         }
1168
1169         catch (failed_constructor &err) {
1170                 error << string_compose (_("%1:%2 new capture file not initialized correctly"), _name, n) << endmsg;
1171                 _write_source.reset();
1172                 return -1;
1173         }
1174
1175         return 0;
1176 }
1177
1178 list<boost::shared_ptr<Source> >
1179 MidiDiskstream::steal_write_sources()
1180 {
1181         list<boost::shared_ptr<Source> > ret;
1182
1183         /* put some data on the disk, even if its just a header for an empty file */
1184         boost::dynamic_pointer_cast<SMFSource> (_write_source)->ensure_disk_file ();
1185
1186         /* never let it go away */
1187         _write_source->mark_nonremovable ();
1188
1189         ret.push_back (_write_source);
1190
1191         /* get a new one */
1192
1193         use_new_write_source (0);
1194
1195         return ret;
1196 }
1197
1198 void
1199 MidiDiskstream::reset_write_sources (bool mark_write_complete, bool /*force*/)
1200 {
1201         if (!_session.writable() || !recordable()) {
1202                 return;
1203         }
1204
1205         if (_write_source && mark_write_complete) {
1206                 _write_source->mark_streaming_write_completed ();
1207         }
1208         use_new_write_source (0);
1209 }
1210
1211 void
1212 MidiDiskstream::set_block_size (pframes_t /*nframes*/)
1213 {
1214 }
1215
1216 void
1217 MidiDiskstream::allocate_temporary_buffers ()
1218 {
1219 }
1220
1221 void
1222 MidiDiskstream::ensure_jack_monitors_input (bool yn)
1223 {
1224         boost::shared_ptr<MidiPort> sp = _source_port.lock ();
1225
1226         if (sp) {
1227                 sp->ensure_jack_monitors_input (yn);
1228         }
1229 }
1230
1231 void
1232 MidiDiskstream::set_align_style_from_io ()
1233 {
1234         if (_alignment_choice != Automatic) {
1235                 return;
1236         }
1237
1238         /* XXX Not sure what, if anything we can do with MIDI
1239            as far as capture alignment etc.
1240         */
1241
1242         set_align_style (ExistingMaterial);
1243 }
1244
1245
1246 float
1247 MidiDiskstream::playback_buffer_load () const
1248 {
1249         /* For MIDI it's not trivial to differentiate the following two cases:
1250
1251            1.  The playback buffer is empty because the system has run out of time to fill it.
1252            2.  The playback buffer is empty because there is no more data on the playlist.
1253
1254            If we use a simple buffer load computation, we will report that the MIDI diskstream
1255            cannot keep up when #2 happens, when in fact it can.  Since MIDI data rates
1256            are so low compared to audio, just give a pretend answer here.
1257         */
1258
1259         return 1;
1260 }
1261
1262 float
1263 MidiDiskstream::capture_buffer_load () const
1264 {
1265         /* We don't report playback buffer load, so don't report capture load either */
1266
1267         return 1;
1268 }
1269
1270 int
1271 MidiDiskstream::use_pending_capture_data (XMLNode& /*node*/)
1272 {
1273         return 0;
1274 }
1275
1276 /** Writes playback events from playback_sample for nframes to dst, translating time stamps
1277  *  so that an event at playback_sample has time = 0
1278  */
1279 void
1280 MidiDiskstream::get_playback (MidiBuffer& dst, framecnt_t nframes)
1281 {
1282         dst.clear();
1283         assert(dst.size() == 0);
1284
1285 #ifndef NDEBUG
1286         DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose (
1287                              "%1 MDS pre-read read %4..%5 from %2 write to %3\n", _name,
1288                              _playback_buf->get_read_ptr(), _playback_buf->get_write_ptr(), playback_sample, playback_sample + nframes));
1289 //        cerr << "================\n";
1290 //        _playback_buf->dump (cerr);
1291 //        cerr << "----------------\n";
1292
1293         const size_t events_read = _playback_buf->read (dst, playback_sample, playback_sample + nframes);
1294         DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose (
1295                              "%1 MDS events read %2 range %3 .. %4 rspace %5 wspace %6 r@%7 w@%8\n",
1296                              _name, events_read, playback_sample, playback_sample + nframes,
1297                              _playback_buf->read_space(), _playback_buf->write_space(),
1298                              _playback_buf->get_read_ptr(), _playback_buf->get_write_ptr()));
1299 #else
1300         _playback_buf->read (dst, playback_sample, playback_sample + nframes);
1301 #endif
1302
1303         g_atomic_int_add (&_frames_read_from_ringbuffer, nframes);
1304 }
1305
1306 bool
1307 MidiDiskstream::set_name (string const & name)
1308 {
1309         Diskstream::set_name (name);
1310
1311         /* get a new write source so that its name reflects the new diskstream name */
1312         use_new_write_source (0);
1313
1314         return true;
1315 }
1316
1317 boost::shared_ptr<MidiBuffer>
1318 MidiDiskstream::get_gui_feed_buffer () const
1319 {
1320         boost::shared_ptr<MidiBuffer> b (new MidiBuffer (AudioEngine::instance()->raw_buffer_size (DataType::MIDI)));
1321
1322         Glib::Mutex::Lock lm (_gui_feed_buffer_mutex);
1323         b->copy (_gui_feed_buffer);
1324         return b;
1325 }
1326
1327 void
1328 MidiDiskstream::reset_tracker ()
1329 {
1330         _playback_buf->reset_tracker ();
1331
1332         boost::shared_ptr<MidiPlaylist> mp (midi_playlist());
1333
1334         if (mp) {
1335                 mp->clear_note_trackers ();
1336         }
1337 }