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 = new XMLNode ("Diskstream");
1210         char buf[64];
1211         LocaleGuard lg (X_("POSIX"));
1212
1213         snprintf (buf, sizeof(buf), "0x%x", _flags);
1214         node->add_property ("flags", buf);
1215
1216         node->add_property("channel-mode", enum_2_string(get_channel_mode()));
1217
1218         snprintf (buf, sizeof(buf), "0x%x", get_channel_mask());
1219         node->add_property("channel-mask", buf);
1220
1221         node->add_property ("playlist", _playlist->name());
1222
1223         snprintf (buf, sizeof(buf), "%f", _visible_speed);
1224         node->add_property ("speed", buf);
1225
1226         node->add_property("name", _name);
1227         id().print(buf, sizeof(buf));
1228         node->add_property("id", buf);
1229
1230         if (_write_source && _session.get_record_enabled()) {
1231
1232                 XMLNode* cs_child = new XMLNode (X_("CapturingSources"));
1233                 XMLNode* cs_grandchild;
1234
1235                 cs_grandchild = new XMLNode (X_("file"));
1236                 cs_grandchild->add_property (X_("path"), _write_source->path());
1237                 cs_child->add_child_nocopy (*cs_grandchild);
1238
1239                 /* store the location where capture will start */
1240
1241                 Location* pi;
1242
1243                 if (_session.config.get_punch_in() && ((pi = _session.locations()->auto_punch_location()) != 0)) {
1244                         snprintf (buf, sizeof (buf), "%" PRId64, pi->start());
1245                 } else {
1246                         snprintf (buf, sizeof (buf), "%" PRId64, _session.transport_frame());
1247                 }
1248
1249                 cs_child->add_property (X_("at"), buf);
1250                 node->add_child_nocopy (*cs_child);
1251         }
1252
1253         if (_extra_xml) {
1254                 node->add_child_copy (*_extra_xml);
1255         }
1256
1257         return* node;
1258 }
1259
1260 int
1261 MidiDiskstream::set_state (const XMLNode& node, int /*version*/)
1262 {
1263         const XMLProperty* prop;
1264         XMLNodeList nlist = node.children();
1265         XMLNodeIterator niter;
1266         XMLNode* capture_pending_node = 0;
1267         LocaleGuard lg (X_("POSIX"));
1268
1269         in_set_state = true;
1270
1271         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1272                 /*if ((*niter)->name() == IO::state_node_name) {
1273                         deprecated_io_node = new XMLNode (**niter);
1274                 }*/
1275                 assert ((*niter)->name() != IO::state_node_name);
1276
1277                 if ((*niter)->name() == X_("CapturingSources")) {
1278                         capture_pending_node = *niter;
1279                 }
1280         }
1281
1282         /* prevent write sources from being created */
1283
1284         in_set_state = true;
1285
1286         if ((prop = node.property ("name")) != 0) {
1287                 _name = prop->value();
1288         }
1289
1290         if ((prop = node.property ("id")) != 0) {
1291                 _id = prop->value ();
1292         }
1293
1294         if ((prop = node.property ("flags")) != 0) {
1295                 _flags = Flag (string_2_enum (prop->value(), _flags));
1296         }
1297
1298         ChannelMode channel_mode = AllChannels;
1299         if ((prop = node.property ("channel-mode")) != 0) {
1300                 channel_mode = ChannelMode (string_2_enum(prop->value(), channel_mode));
1301         }
1302
1303         unsigned int channel_mask = 0xFFFF;
1304         if ((prop = node.property ("channel-mask")) != 0) {
1305                 sscanf (prop->value().c_str(), "0x%x", &channel_mask);
1306                 if (channel_mask & (~0xFFFF)) {
1307                         warning << _("MidiDiskstream: XML property channel-mask out of range") << endmsg;
1308                 }
1309         }
1310
1311         set_channel_mode(channel_mode, channel_mask);
1312
1313         if ((prop = node.property ("playlist")) == 0) {
1314                 return -1;
1315         }
1316
1317         {
1318                 bool had_playlist = (_playlist != 0);
1319
1320                 if (find_and_use_playlist (prop->value())) {
1321                         return -1;
1322                 }
1323
1324                 if (!had_playlist) {
1325                         _playlist->set_orig_diskstream_id (id());
1326                 }
1327
1328                 if (capture_pending_node) {
1329                         use_pending_capture_data (*capture_pending_node);
1330                 }
1331
1332         }
1333
1334         if ((prop = node.property ("speed")) != 0) {
1335                 double sp = atof (prop->value().c_str());
1336
1337                 if (realtime_set_speed (sp, false)) {
1338                         non_realtime_set_speed ();
1339                 }
1340         }
1341
1342         in_set_state = false;
1343
1344         return 0;
1345 }
1346
1347 int
1348 MidiDiskstream::use_new_write_source (uint32_t n)
1349 {
1350         if (!_session.writable() || !recordable()) {
1351                 return 1;
1352         }
1353
1354         assert(n == 0);
1355
1356         _write_source.reset();
1357
1358         try {
1359                 _write_source = boost::dynamic_pointer_cast<SMFSource>(
1360                         _session.create_midi_source_for_session (0, name ()));
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         return 0;
1374 }
1375
1376 list<boost::shared_ptr<Source> >
1377 MidiDiskstream::steal_write_sources()
1378 {
1379         list<boost::shared_ptr<Source> > ret;
1380
1381         /* put some data on the disk, even if its just a header for an empty file.
1382            XXX should we not have a more direct method for doing this? Maybe not
1383            since we don't want to mess around with the model/disk relationship
1384            that the Source has to pay attention to.
1385         */
1386
1387         boost::dynamic_pointer_cast<MidiSource>(_write_source)->session_saved ();
1388
1389         /* never let it go away */
1390         _write_source->mark_nonremovable ();
1391
1392         ret.push_back (_write_source);
1393
1394         /* get a new one */
1395
1396         use_new_write_source (0);
1397
1398         return ret;
1399 }
1400
1401 void
1402 MidiDiskstream::reset_write_sources (bool mark_write_complete, bool /*force*/)
1403 {
1404         if (!_session.writable() || !recordable()) {
1405                 return;
1406         }
1407
1408         if (_write_source && mark_write_complete) {
1409                 _write_source->mark_streaming_write_completed ();
1410         }
1411         use_new_write_source (0);
1412 }
1413
1414 int
1415 MidiDiskstream::rename_write_sources ()
1416 {
1417         if (_write_source != 0) {
1418                 _write_source->set_source_name (_name.val(), destructive());
1419                 /* XXX what to do if this fails ? */
1420         }
1421         return 0;
1422 }
1423
1424 void
1425 MidiDiskstream::set_block_size (pframes_t /*nframes*/)
1426 {
1427 }
1428
1429 void
1430 MidiDiskstream::allocate_temporary_buffers ()
1431 {
1432 }
1433
1434 void
1435 MidiDiskstream::monitor_input (bool yn)
1436 {
1437         if (_source_port)
1438                 _source_port->ensure_monitor_input (yn);
1439 }
1440
1441 void
1442 MidiDiskstream::set_align_style_from_io ()
1443 {
1444         bool have_physical = false;
1445
1446         if (_io == 0) {
1447                 return;
1448         }
1449
1450         get_input_sources ();
1451
1452         if (_source_port && _source_port->flags() & JackPortIsPhysical) {
1453                 have_physical = true;
1454         }
1455
1456         if (have_physical) {
1457                 set_align_style (ExistingMaterial);
1458         } else {
1459                 set_align_style (CaptureTime);
1460         }
1461 }
1462
1463
1464 float
1465 MidiDiskstream::playback_buffer_load () const
1466 {
1467         return (float) ((double) _playback_buf->read_space()/
1468                         (double) _playback_buf->capacity());
1469 }
1470
1471 float
1472 MidiDiskstream::capture_buffer_load () const
1473 {
1474         return (float) ((double) _capture_buf->write_space()/
1475                         (double) _capture_buf->capacity());
1476 }
1477
1478 int
1479 MidiDiskstream::use_pending_capture_data (XMLNode& /*node*/)
1480 {
1481         return 0;
1482 }
1483
1484 /** Writes playback events in the given range to \a dst, translating time stamps
1485  * so that an event at \a start has time = 0
1486  */
1487 void
1488 MidiDiskstream::get_playback (MidiBuffer& dst, framepos_t start, framepos_t end)
1489 {
1490         dst.clear();
1491         assert(dst.size() == 0);
1492
1493         // Reverse.  ... We just don't do reverse, ok?  Back off.
1494         if (end <= start) {
1495                 return;
1496         }
1497
1498         // Translates stamps to be relative to start
1499
1500
1501 #ifndef NDEBUG
1502         const size_t events_read = _playback_buf->read(dst, start, end);
1503         DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("%1 MDS events read %2 range %3 .. %4 rspace %5 wspace %6\n", _name, events_read, start, end,
1504                                                               _playback_buf->read_space(), _playback_buf->write_space()));
1505 #else
1506         _playback_buf->read(dst, start, end);
1507 #endif
1508
1509         gint32 frames_read = end - start;
1510         g_atomic_int_add(&_frames_read_from_ringbuffer, frames_read);
1511 }
1512