libs/ardour/midi_diskstream.cc

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