libs/ardour/midi_diskstream.cc

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