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