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.reset();
 947                 }
 948
 949                 /* new source set up in "out" below */
 950
 951         } else {
 952
 953                 assert(_write_source);
 954
 955                 framecnt_t total_capture = 0;
 956                 for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
 957                         total_capture += (*ci)->frames;
 958                 }
 959
 960                 if (_write_source->length (capture_info.front()->start) != 0) {
 961
 962                         /* phew, we have data */
 963
 964                         /* figure out the name for this take */
 965
 966                         srcs.push_back (_write_source);
 967
 968                         _write_source->set_timeline_position (capture_info.front()->start);
 969                         _write_source->set_captured_for (_name);
 970
 971                         /* flush to disk: this step differs from the audio path,
 972                            where all the data is already on disk.
 973                         */
 974
 975                         _write_source->mark_streaming_write_completed ();
 976
 977                         /* set length in beats to entire capture length */
 978
 979                         BeatsFramesConverter converter (_session.tempo_map(), capture_info.front()->start);
 980                         const double total_capture_beats = converter.from(total_capture);
 981                         _write_source->set_length_beats(total_capture_beats);
 982
 983                         /* make it not a stub anymore */
 984
 985                         _write_source->unstubify ();
 986
 987                         /* we will want to be able to keep (over)writing the source
 988                            but we don't want it to be removable. this also differs
 989                            from the audio situation, where the source at this point
 990                            must be considered immutable. luckily, we can rely on
 991                            MidiSource::mark_streaming_write_completed() to have
 992                            already done the necessary work for that.
 993                         */
 994
 995                         string whole_file_region_name;
 996                         whole_file_region_name = region_name_from_path (_write_source->name(), true);
 997
 998                         /* Register a new region with the Session that
 999                            describes the entire source. Do this first
1000                            so that any sub-regions will obviously be
1001                            children of this one (later!)
1002                         */
1003
1004                         try {
1005                                 PropertyList plist;
1006
1007                                 plist.add (Properties::name, whole_file_region_name);
1008                                 plist.add (Properties::whole_file, true);
1009                                 plist.add (Properties::automatic, true);
1010                                 plist.add (Properties::start, 0);
1011                                 plist.add (Properties::length, total_capture);
1012                                 plist.add (Properties::layer, 0);
1013
1014                                 boost::shared_ptr<Region> rx (RegionFactory::create (srcs, plist));
1015
1016                                 region = boost::dynamic_pointer_cast<MidiRegion> (rx);
1017                                 region->special_set_position (capture_info.front()->start);
1018                         }
1019
1020
1021                         catch (failed_constructor& err) {
1022                                 error << string_compose(_("%1: could not create region for complete midi file"), _name) << endmsg;
1023                                 /* XXX what now? */
1024                         }
1025
1026                         _last_capture_sources.insert (_last_capture_sources.end(), srcs.begin(), srcs.end());
1027
1028                         _playlist->clear_changes ();
1029                         _playlist->freeze ();
1030
1031                         /* Session frame time of the initial capture in this pass, which is where the source starts */
1032                         framepos_t initial_capture = 0;
1033                         if (!capture_info.empty()) {
1034                                 initial_capture = capture_info.front()->start;
1035                         }
1036
1037                         for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1038
1039                                 string region_name;
1040
1041                                 RegionFactory::region_name (region_name, _write_source->name(), false);
1042
1043                                 // cerr << _name << ": based on ci of " << (*ci)->start << " for " << (*ci)->frames << " add a region\n";
1044
1045                                 try {
1046                                         PropertyList plist;
1047
1048                                         /* start of this region is the offset between the start of its capture and the start of the whole pass */
1049                                         plist.add (Properties::start, (*ci)->start - initial_capture);
1050                                         plist.add (Properties::length, (*ci)->frames);
1051                                         plist.add (Properties::length_beats, converter.from((*ci)->frames));
1052                                         plist.add (Properties::name, region_name);
1053
1054                                         boost::shared_ptr<Region> rx (RegionFactory::create (srcs, plist));
1055                                         region = boost::dynamic_pointer_cast<MidiRegion> (rx);
1056                                 }
1057
1058                                 catch (failed_constructor& err) {
1059                                         error << _("MidiDiskstream: could not create region for captured midi!") << endmsg;
1060                                         continue; /* XXX is this OK? */
1061                                 }
1062
1063                                 // cerr << "add new region, buffer position = " << buffer_position << " @ " << (*ci)->start << endl;
1064
1065                                 i_am_the_modifier++;
1066                                 _playlist->add_region (region, (*ci)->start);
1067                                 i_am_the_modifier--;
1068                         }
1069
1070                         _playlist->thaw ();
1071                         _session.add_command (new StatefulDiffCommand(_playlist));
1072                 }
1073
1074                 mark_write_completed = true;
1075         }
1076
1077         use_new_write_source (0);
1078
1079         for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1080                 delete *ci;
1081         }
1082
1083         if (_playlist) {
1084                 midi_playlist()->clear_note_trackers ();
1085         }
1086
1087         capture_info.clear ();
1088         capture_start_frame = 0;
1089 }
1090
1091 void
1092 MidiDiskstream::transport_looped (framepos_t transport_frame)
1093 {
1094         if (was_recording) {
1095
1096                 // adjust the capture length knowing that the data will be recorded to disk
1097                 // only necessary after the first loop where we're recording
1098                 if (capture_info.size() == 0) {
1099                         capture_captured += _capture_offset;
1100
1101                         if (_alignment_style == ExistingMaterial) {
1102                                 capture_captured += _session.worst_output_latency();
1103                         } else {
1104                                 capture_captured += _roll_delay;
1105                         }
1106                 }
1107
1108                 finish_capture (true);
1109
1110                 // the next region will start recording via the normal mechanism
1111                 // we'll set the start position to the current transport pos
1112                 // no latency adjustment or capture offset needs to be made, as that already happened the first time
1113                 capture_start_frame = transport_frame;
1114                 first_recordable_frame = transport_frame; // mild lie
1115                 last_recordable_frame = max_framepos;
1116                 was_recording = true;
1117         }
1118 }
1119
1120 void
1121 MidiDiskstream::finish_capture (bool /*rec_monitors_input*/)
1122 {
1123         was_recording = false;
1124
1125         if (capture_captured == 0) {
1126                 return;
1127         }
1128
1129         // Why must we destroy?
1130         assert(!destructive());
1131
1132         CaptureInfo* ci = new CaptureInfo;
1133
1134         ci->start  = capture_start_frame;
1135         ci->frames = capture_captured;
1136
1137         /* XXX theoretical race condition here. Need atomic exchange ?
1138            However, the circumstances when this is called right
1139            now (either on record-disable or transport_stopped)
1140            mean that no actual race exists. I think ...
1141            We now have a capture_info_lock, but it is only to be used
1142            to synchronize in the transport_stop and the capture info
1143            accessors, so that invalidation will not occur (both non-realtime).
1144         */
1145
1146         // cerr << "Finish capture, add new CI, " << ci->start << '+' << ci->frames << endl;
1147
1148         capture_info.push_back (ci);
1149         capture_captured = 0;
1150 }
1151
1152 void
1153 MidiDiskstream::set_record_enabled (bool yn)
1154 {
1155         if (!recordable() || !_session.record_enabling_legal()) {
1156                 return;
1157         }
1158
1159         assert(!destructive());
1160
1161         /* yes, i know that this not proof against race conditions, but its
1162            good enough. i think.
1163         */
1164
1165         if (record_enabled() != yn) {
1166                 if (yn) {
1167                         engage_record_enable ();
1168                 } else {
1169                         disengage_record_enable ();
1170                 }
1171         }
1172 }
1173
1174 void
1175 MidiDiskstream::engage_record_enable ()
1176 {
1177         bool const rolling = _session.transport_speed() != 0.0f;
1178
1179         g_atomic_int_set (&_record_enabled, 1);
1180
1181         if (_source_port && Config->get_monitoring_model() == HardwareMonitoring) {
1182                 _source_port->request_monitor_input (!(_session.config.get_auto_input() && rolling));
1183         }
1184
1185         RecordEnableChanged (); /* EMIT SIGNAL */
1186 }
1187
1188 void
1189 MidiDiskstream::disengage_record_enable ()
1190 {
1191         g_atomic_int_set (&_record_enabled, 0);
1192         if (_source_port && Config->get_monitoring_model() == HardwareMonitoring) {
1193                 if (_source_port) {
1194                         _source_port->request_monitor_input (false);
1195                 }
1196         }
1197
1198         RecordEnableChanged (); /* EMIT SIGNAL */
1199 }
1200
1201 XMLNode&
1202 MidiDiskstream::get_state ()
1203 {
1204         XMLNode* node = new XMLNode ("Diskstream");
1205         char buf[64];
1206         LocaleGuard lg (X_("POSIX"));
1207
1208         snprintf (buf, sizeof(buf), "0x%x", _flags);
1209         node->add_property ("flags", buf);
1210
1211         node->add_property("channel-mode", enum_2_string(get_channel_mode()));
1212
1213         snprintf (buf, sizeof(buf), "0x%x", get_channel_mask());
1214         node->add_property("channel-mask", buf);
1215
1216         node->add_property ("playlist", _playlist->name());
1217
1218         snprintf (buf, sizeof(buf), "%f", _visible_speed);
1219         node->add_property ("speed", buf);
1220
1221         node->add_property("name", _name);
1222         id().print(buf, sizeof(buf));
1223         node->add_property("id", buf);
1224
1225         if (_write_source && _session.get_record_enabled()) {
1226
1227                 XMLNode* cs_child = new XMLNode (X_("CapturingSources"));
1228                 XMLNode* cs_grandchild;
1229
1230                 cs_grandchild = new XMLNode (X_("file"));
1231                 cs_grandchild->add_property (X_("path"), _write_source->path());
1232                 cs_child->add_child_nocopy (*cs_grandchild);
1233
1234                 /* store the location where capture will start */
1235
1236                 Location* pi;
1237
1238                 if (_session.config.get_punch_in() && ((pi = _session.locations()->auto_punch_location()) != 0)) {
1239                         snprintf (buf, sizeof (buf), "%" PRId64, pi->start());
1240                 } else {
1241                         snprintf (buf, sizeof (buf), "%" PRId64, _session.transport_frame());
1242                 }
1243
1244                 cs_child->add_property (X_("at"), buf);
1245                 node->add_child_nocopy (*cs_child);
1246         }
1247
1248         if (_extra_xml) {
1249                 node->add_child_copy (*_extra_xml);
1250         }
1251
1252         return* node;
1253 }
1254
1255 int
1256 MidiDiskstream::set_state (const XMLNode& node, int /*version*/)
1257 {
1258         const XMLProperty* prop;
1259         XMLNodeList nlist = node.children();
1260         XMLNodeIterator niter;
1261         XMLNode* capture_pending_node = 0;
1262         LocaleGuard lg (X_("POSIX"));
1263
1264         in_set_state = true;
1265
1266         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1267                 /*if ((*niter)->name() == IO::state_node_name) {
1268                         deprecated_io_node = new XMLNode (**niter);
1269                 }*/
1270                 assert ((*niter)->name() != IO::state_node_name);
1271
1272                 if ((*niter)->name() == X_("CapturingSources")) {
1273                         capture_pending_node = *niter;
1274                 }
1275         }
1276
1277         /* prevent write sources from being created */
1278
1279         in_set_state = true;
1280
1281         if ((prop = node.property ("name")) != 0) {
1282                 _name = prop->value();
1283         }
1284
1285         if ((prop = node.property ("id")) != 0) {
1286                 _id = prop->value ();
1287         }
1288
1289         if ((prop = node.property ("flags")) != 0) {
1290                 _flags = Flag (string_2_enum (prop->value(), _flags));
1291         }
1292
1293         ChannelMode channel_mode = AllChannels;
1294         if ((prop = node.property ("channel-mode")) != 0) {
1295                 channel_mode = ChannelMode (string_2_enum(prop->value(), channel_mode));
1296         }
1297
1298         unsigned int channel_mask = 0xFFFF;
1299         if ((prop = node.property ("channel-mask")) != 0) {
1300                 sscanf (prop->value().c_str(), "0x%x", &channel_mask);
1301                 if (channel_mask & (~0xFFFF)) {
1302                         warning << _("MidiDiskstream: XML property channel-mask out of range") << endmsg;
1303                 }
1304         }
1305
1306         set_channel_mode(channel_mode, channel_mask);
1307
1308         if ((prop = node.property ("playlist")) == 0) {
1309                 return -1;
1310         }
1311
1312         {
1313                 bool had_playlist = (_playlist != 0);
1314
1315                 if (find_and_use_playlist (prop->value())) {
1316                         return -1;
1317                 }
1318
1319                 if (!had_playlist) {
1320                         _playlist->set_orig_diskstream_id (id());
1321                 }
1322
1323                 if (capture_pending_node) {
1324                         use_pending_capture_data (*capture_pending_node);
1325                 }
1326
1327         }
1328
1329         if ((prop = node.property ("speed")) != 0) {
1330                 double sp = atof (prop->value().c_str());
1331
1332                 if (realtime_set_speed (sp, false)) {
1333                         non_realtime_set_speed ();
1334                 }
1335         }
1336
1337         in_set_state = false;
1338
1339         return 0;
1340 }
1341
1342 int
1343 MidiDiskstream::use_new_write_source (uint32_t n)
1344 {
1345         if (!_session.writable() || !recordable()) {
1346                 return 1;
1347         }
1348
1349         assert(n == 0);
1350
1351         _write_source.reset();
1352
1353         try {
1354                 /* file starts off as a stub file, it will be converted
1355                    when we're done with a capture pass, or when "stolen"
1356                    by the GUI.
1357                 */
1358
1359                 _write_source = boost::dynamic_pointer_cast<SMFSource>(
1360                         _session.create_midi_source_for_session (0, name (), true));
1361
1362                 if (!_write_source) {
1363                         throw failed_constructor();
1364                 }
1365         }
1366
1367         catch (failed_constructor &err) {
1368                 error << string_compose (_("%1:%2 new capture file not initialized correctly"), _name, n) << endmsg;
1369                 _write_source.reset();
1370                 return -1;
1371         }
1372
1373         _write_source->mark_streaming_midi_write_started (_note_mode, _session.transport_frame());
1374
1375         return 0;
1376 }
1377
1378 list<boost::shared_ptr<Source> >
1379 MidiDiskstream::steal_write_sources()
1380 {
1381         list<boost::shared_ptr<Source> > ret;
1382
1383         /* put some data on the disk, even if its just a header for an empty file.
1384            XXX should we not have a more direct method for doing this? Maybe not
1385            since we don't want to mess around with the model/disk relationship
1386            that the Source has to pay attention to.
1387         */
1388
1389         boost::dynamic_pointer_cast<MidiSource>(_write_source)->session_saved ();
1390
1391         /* make it visible/present */
1392         _write_source->unstubify ();
1393         /* never let it go away */
1394         _write_source->mark_nonremovable ();
1395
1396         ret.push_back (_write_source);
1397
1398         /* get a new one */
1399
1400         use_new_write_source (0);
1401
1402         return ret;
1403 }
1404
1405 void
1406 MidiDiskstream::reset_write_sources (bool mark_write_complete, bool /*force*/)
1407 {
1408         if (!_session.writable() || !recordable()) {
1409                 return;
1410         }
1411
1412         if (_write_source && mark_write_complete) {
1413                 _write_source->mark_streaming_write_completed ();
1414         }
1415         use_new_write_source (0);
1416 }
1417
1418 int
1419 MidiDiskstream::rename_write_sources ()
1420 {
1421         if (_write_source != 0) {
1422                 _write_source->set_source_name (_name.val(), destructive());
1423                 /* XXX what to do if this fails ? */
1424         }
1425         return 0;
1426 }
1427
1428 void
1429 MidiDiskstream::set_block_size (pframes_t /*nframes*/)
1430 {
1431 }
1432
1433 void
1434 MidiDiskstream::allocate_temporary_buffers ()
1435 {
1436 }
1437
1438 void
1439 MidiDiskstream::monitor_input (bool yn)
1440 {
1441         if (_source_port)
1442                 _source_port->ensure_monitor_input (yn);
1443 }
1444
1445 void
1446 MidiDiskstream::set_align_style_from_io ()
1447 {
1448         bool have_physical = false;
1449
1450         if (_io == 0) {
1451                 return;
1452         }
1453
1454         get_input_sources ();
1455
1456         if (_source_port && _source_port->flags() & JackPortIsPhysical) {
1457                 have_physical = true;
1458         }
1459
1460         if (have_physical) {
1461                 set_align_style (ExistingMaterial);
1462         } else {
1463                 set_align_style (CaptureTime);
1464         }
1465 }
1466
1467
1468 float
1469 MidiDiskstream::playback_buffer_load () const
1470 {
1471         return (float) ((double) _playback_buf->read_space()/
1472                         (double) _playback_buf->capacity());
1473 }
1474
1475 float
1476 MidiDiskstream::capture_buffer_load () const
1477 {
1478         return (float) ((double) _capture_buf->write_space()/
1479                         (double) _capture_buf->capacity());
1480 }
1481
1482 int
1483 MidiDiskstream::use_pending_capture_data (XMLNode& /*node*/)
1484 {
1485         return 0;
1486 }
1487
1488 /** Writes playback events in the given range to \a dst, translating time stamps
1489  * so that an event at \a start has time = 0
1490  */
1491 void
1492 MidiDiskstream::get_playback (MidiBuffer& dst, framepos_t start, framepos_t end)
1493 {
1494         dst.clear();
1495         assert(dst.size() == 0);
1496
1497         // Reverse.  ... We just don't do reverse, ok?  Back off.
1498         if (end <= start) {
1499                 return;
1500         }
1501
1502         // Translates stamps to be relative to start
1503
1504
1505 #ifndef NDEBUG
1506         const size_t events_read = _playback_buf->read(dst, start, end);
1507         DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("%1 MDS events read %2 range %3 .. %4 rspace %5 wspace %6\n", _name, events_read, start, end,
1508                                                               _playback_buf->read_space(), _playback_buf->write_space()));
1509 #else
1510         _playback_buf->read(dst, start, end);
1511 #endif
1512
1513         gint32 frames_read = end - start;
1514         g_atomic_int_add(&_frames_read_from_ringbuffer, frames_read);
1515 }
1516