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