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