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 nframes_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<nframes_t>(size);
 132         _capture_buf = new MidiRingBuffer<nframes_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 (nframes_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 == NoChange) {
 162                         return;
 163                 }
 164
 165                 if (input_change_pending & 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 = 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 ((nframes_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 (nframes_t transport_frame, nframes_t nframes, bool can_record, bool rec_monitors_input, bool& need_butler)
 492 {
 493         int       ret = -1;
 494         nframes_t rec_offset = 0;
 495         nframes_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, nframes, 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 || (_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                         capture_captured = 0;
 524                         was_recording = true;
 525                 }
 526         }
 527
 528
 529         if (can_record && !_last_capture_sources.empty()) {
 530                 _last_capture_sources.clear ();
 531         }
 532
 533         if (nominally_recording || rec_nframes) {
 534
 535                 // Pump entire port buffer into the ring buffer (FIXME: split cycles?)
 536                 MidiBuffer& buf = _source_port->get_midi_buffer(nframes);
 537                 for (MidiBuffer::iterator i = buf.begin(); i != buf.end(); ++i) {
 538                         const Evoral::MIDIEvent<MidiBuffer::TimeType> ev(*i, false);
 539                         assert(ev.buffer());
 540                         _capture_buf->write(ev.time() + transport_frame, ev.type(), ev.size(), ev.buffer());
 541                 }
 542
 543         } else {
 544
 545                 if (was_recording) {
 546                         finish_capture (rec_monitors_input);
 547                 }
 548
 549         }
 550
 551         if (rec_nframes) {
 552
 553                 /* data will be written to disk */
 554
 555                 if (rec_nframes == nframes && rec_offset == 0) {
 556                         playback_distance = nframes;
 557                 }
 558
 559                 adjust_capture_position = rec_nframes;
 560
 561         } else if (nominally_recording) {
 562
 563                 /* XXXX do this for MIDI !!!
 564                    can't do actual capture yet - waiting for latency effects to finish before we start
 565                    */
 566
 567                 playback_distance = nframes;
 568
 569         }
 570
 571         ret = 0;
 572
 573         if (commit (nframes)) {
 574                 need_butler = true;
 575         }
 576
 577         return ret;
 578 }
 579
 580 bool
 581 MidiDiskstream::commit (nframes_t nframes)
 582 {
 583         bool need_butler = false;
 584
 585         if (_actual_speed < 0.0) {
 586                 playback_sample -= playback_distance;
 587         } else {
 588                 playback_sample += playback_distance;
 589         }
 590
 591         if (adjust_capture_position != 0) {
 592                 capture_captured += adjust_capture_position;
 593                 adjust_capture_position = 0;
 594         }
 595
 596         uint32_t frames_read = g_atomic_int_get(&_frames_read_from_ringbuffer);
 597         uint32_t frames_written = g_atomic_int_get(&_frames_written_to_ringbuffer);
 598         if ((frames_written - frames_read) + nframes < midi_readahead) {
 599                 need_butler = true;
 600         }
 601
 602         /*cerr << "MDS written: " << frames_written << " - read: " << frames_read <<
 603                 " = " << frames_written - frames_read
 604                 << " + " << nframes << " < " << midi_readahead << " = " << need_butler << ")" << endl;*/
 605
 606         return need_butler;
 607 }
 608
 609 void
 610 MidiDiskstream::set_pending_overwrite (bool yn)
 611 {
 612         /* called from audio thread, so we can use the read ptr and playback sample as we wish */
 613
 614         _pending_overwrite = yn;
 615
 616         overwrite_frame = playback_sample;
 617 }
 618
 619 int
 620 MidiDiskstream::overwrite_existing_buffers ()
 621 {
 622         //read(overwrite_frame, disk_io_chunk_frames, false);
 623         overwrite_queued = false;
 624         _pending_overwrite = false;
 625
 626         return 0;
 627 }
 628
 629 int
 630 MidiDiskstream::seek (nframes_t frame, bool complete_refill)
 631 {
 632         Glib::Mutex::Lock lm (state_lock);
 633         int ret = -1;
 634
 635         _playback_buf->reset();
 636         _capture_buf->reset();
 637         g_atomic_int_set(&_frames_read_from_ringbuffer, 0);
 638         g_atomic_int_set(&_frames_written_to_ringbuffer, 0);
 639
 640         playback_sample = frame;
 641         file_frame = frame;
 642
 643         if (complete_refill) {
 644                 while ((ret = do_refill_with_alloc ()) > 0) ;
 645         } else {
 646                 ret = do_refill_with_alloc ();
 647         }
 648
 649         return ret;
 650 }
 651
 652 int
 653 MidiDiskstream::can_internal_playback_seek (nframes_t distance)
 654 {
 655         uint32_t frames_read    = g_atomic_int_get(&_frames_read_from_ringbuffer);
 656         uint32_t frames_written = g_atomic_int_get(&_frames_written_to_ringbuffer);
 657         return ((frames_written - frames_read) < distance);
 658 }
 659
 660 int
 661 MidiDiskstream::internal_playback_seek (nframes_t distance)
 662 {
 663         first_recordable_frame += distance;
 664         playback_sample += distance;
 665
 666         return 0;
 667 }
 668
 669 /** @a start is set to the new frame position (TIME) read up to */
 670 int
 671 MidiDiskstream::read (nframes_t& start, nframes_t dur, bool reversed)
 672 {
 673         nframes_t this_read = 0;
 674         bool reloop = false;
 675         nframes_t loop_end = 0;
 676         nframes_t loop_start = 0;
 677         Location *loc = 0;
 678
 679         if (!reversed) {
 680
 681                 nframes_t loop_length = 0;
 682
 683                 /* Make the use of a Location atomic for this read operation.
 684
 685                    Note: Locations don't get deleted, so all we care about
 686                    when I say "atomic" is that we are always pointing to
 687                    the same one and using a start/length values obtained
 688                    just once.
 689                 */
 690
 691                 if ((loc = loop_location) != 0) {
 692                         loop_start = loc->start();
 693                         loop_end = loc->end();
 694                         loop_length = loop_end - loop_start;
 695                 }
 696
 697                 /* if we are looping, ensure that the first frame we read is at the correct
 698                    position within the loop.
 699                 */
 700
 701                 if (loc && (start >= loop_end)) {
 702                         //cerr << "start adjusted from " << start;
 703                         start = loop_start + ((start - loop_start) % loop_length);
 704                         //cerr << "to " << start << endl;
 705                 }
 706                 //cerr << "start is " << start << "  loopstart: " << loop_start << "  loopend: " << loop_end << endl;
 707         }
 708
 709         while (dur) {
 710
 711                 /* take any loop into account. we can't read past the end of the loop. */
 712
 713                 if (loc && (loop_end - start < dur)) {
 714                         this_read = loop_end - start;
 715                         //cerr << "reloop true: thisread: " << this_read << "  dur: " << dur << endl;
 716                         reloop = true;
 717                 } else {
 718                         reloop = false;
 719                         this_read = dur;
 720                 }
 721
 722                 if (this_read == 0) {
 723                         break;
 724                 }
 725
 726                 this_read = min(dur,this_read);
 727
 728                 if (midi_playlist()->read (*_playback_buf, start, this_read) != this_read) {
 729                         error << string_compose(
 730                                         _("MidiDiskstream %1: cannot read %2 from playlist at frame %3"),
 731                                         _id, this_read, start) << endmsg;
 732                         return -1;
 733                 }
 734
 735                 g_atomic_int_add(&_frames_written_to_ringbuffer, this_read);
 736
 737                 _read_data_count = _playlist->read_data_count();
 738
 739                 if (reversed) {
 740
 741                         // Swap note ons with note offs here.  etc?
 742                         // Fully reversing MIDI requires look-ahead (well, behind) to find previous
 743                         // CC values etc.  hard.
 744
 745                 } else {
 746
 747                         /* if we read to the end of the loop, go back to the beginning */
 748
 749                         if (reloop) {
 750                                 // Synthesize LoopEvent here, because the next events
 751                                 // written will have non-monotonic timestamps.
 752                                 _playback_buf->write(loop_end - 1, LoopEventType, sizeof (nframes_t), (uint8_t *) &loop_start);
 753                                 cout << "Pushing LoopEvent ts=" << loop_end-1
 754                                      << " start+this_read " << start+this_read << endl;
 755
 756                                 start = loop_start;
 757                         } else {
 758                                 start += this_read;
 759                         }
 760                 }
 761
 762                 dur -= this_read;
 763                 //offset += this_read;
 764         }
 765
 766         return 0;
 767 }
 768
 769 int
 770 MidiDiskstream::do_refill_with_alloc ()
 771 {
 772         return do_refill();
 773 }
 774
 775 int
 776 MidiDiskstream::do_refill ()
 777 {
 778         int     ret         = 0;
 779         size_t  write_space = _playback_buf->write_space();
 780         bool    reversed    = (_visible_speed * _session.transport_speed()) < 0.0f;
 781
 782         if (write_space == 0) {
 783                 return 0;
 784         }
 785
 786         if (reversed) {
 787                 return 0;
 788         }
 789
 790         /* at end: nothing to do */
 791         if (file_frame == max_frames) {
 792                 return 0;
 793         }
 794
 795         // At this point we...
 796         assert(_playback_buf->write_space() > 0); // ... have something to write to, and
 797         assert(file_frame <= max_frames); // ... something to write
 798
 799         // now calculate how much time is in the ringbuffer.
 800         // and lets write as much as we need to get this to be midi_readahead;
 801         uint32_t frames_read = g_atomic_int_get(&_frames_read_from_ringbuffer);
 802         uint32_t frames_written = g_atomic_int_get(&_frames_written_to_ringbuffer);
 803         if ((frames_written - frames_read) >= midi_readahead) {
 804                 //cout << "MDS Nothing to do. all fine" << endl;
 805                 return 0;
 806         }
 807
 808         nframes_t to_read = midi_readahead - (frames_written - frames_read);
 809
 810         //cout << "MDS read for midi_readahead " << to_read << "  rb_contains: "
 811         //      << frames_written - frames_read << endl;
 812
 813         to_read = min(to_read, (max_frames - file_frame));
 814
 815         if (read (file_frame, to_read, reversed)) {
 816                 ret = -1;
 817         }
 818
 819         return ret;
 820 }
 821
 822 /** Flush pending data to disk.
 823  *
 824  * Important note: this function will write *AT MOST* disk_io_chunk_frames
 825  * of data to disk. it will never write more than that.  If it writes that
 826  * much and there is more than that waiting to be written, it will return 1,
 827  * otherwise 0 on success or -1 on failure.
 828  *
 829  * If there is less than disk_io_chunk_frames to be written, no data will be
 830  * written at all unless @a force_flush is true.
 831  */
 832 int
 833 MidiDiskstream::do_flush (RunContext /*context*/, bool force_flush)
 834 {
 835         uint32_t to_write;
 836         int32_t ret = 0;
 837         nframes_t total;
 838
 839         _write_data_count = 0;
 840
 841         total = _session.transport_frame() - _last_flush_frame;
 842
 843         if (_last_flush_frame > _session.transport_frame()
 844                         || _last_flush_frame < capture_start_frame) {
 845                 _last_flush_frame = _session.transport_frame();
 846         }
 847
 848         if (total == 0 || _capture_buf->read_space() == 0
 849                         || (!force_flush && (total < disk_io_chunk_frames && was_recording))) {
 850                 goto out;
 851         }
 852
 853         /* if there are 2+ chunks of disk i/o possible for
 854            this track, let the caller know so that it can arrange
 855            for us to be called again, ASAP.
 856
 857            if we are forcing a flush, then if there is* any* extra
 858            work, let the caller know.
 859
 860            if we are no longer recording and there is any extra work,
 861            let the caller know too.
 862            */
 863
 864         if (total >= 2 * disk_io_chunk_frames || ((force_flush || !was_recording) && total > disk_io_chunk_frames)) {
 865                 ret = 1;
 866         }
 867
 868         to_write = disk_io_chunk_frames;
 869
 870         assert(!destructive());
 871
 872         if (record_enabled() &&
 873             ((_session.transport_frame() - _last_flush_frame > disk_io_chunk_frames) ||
 874              force_flush)) {
 875                 if ((!_write_source) || _write_source->midi_write (*_capture_buf, capture_start_frame, to_write) != to_write) {
 876                         error << string_compose(_("MidiDiskstream %1: cannot write to disk"), _id) << endmsg;
 877                         return -1;
 878                 } else {
 879                         _last_flush_frame = _session.transport_frame();
 880                 }
 881         }
 882
 883 out:
 884         return ret;
 885 }
 886
 887 void
 888 MidiDiskstream::transport_stopped_wallclock (struct tm& /*when*/, time_t /*twhen*/, bool abort_capture)
 889 {
 890         bool more_work = true;
 891         int err = 0;
 892         boost::shared_ptr<MidiRegion> region;
 893         MidiRegion::SourceList srcs;
 894         MidiRegion::SourceList::iterator src;
 895         vector<CaptureInfo*>::iterator ci;
 896         bool mark_write_completed = false;
 897
 898         finish_capture (true);
 899
 900         /* butler is already stopped, but there may be work to do
 901            to flush remaining data to disk.
 902            */
 903
 904         while (more_work && !err) {
 905                 switch (do_flush (TransportContext, true)) {
 906                         case 0:
 907                                 more_work = false;
 908                                 break;
 909                         case 1:
 910                                 break;
 911                         case -1:
 912                                 error << string_compose(_("MidiDiskstream \"%1\": cannot flush captured data to disk!"), _name) << endmsg;
 913                                 err++;
 914                 }
 915         }
 916
 917         /* XXX is there anything we can do if err != 0 ? */
 918         Glib::Mutex::Lock lm (capture_info_lock);
 919
 920         if (capture_info.empty()) {
 921                 return;
 922         }
 923
 924         if (abort_capture) {
 925
 926                 if (_write_source) {
 927
 928                         _write_source->mark_for_remove ();
 929                         _write_source.reset();
 930                 }
 931
 932                 /* new source set up in "out" below */
 933
 934         } else {
 935
 936                 assert(_write_source);
 937
 938                 nframes_t total_capture = 0;
 939                 for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
 940                         total_capture += (*ci)->frames;
 941                 }
 942
 943                 if (_write_source->length (capture_info.front()->start) != 0) {
 944
 945                         /* phew, we have data */
 946
 947                         /* figure out the name for this take */
 948
 949                         srcs.push_back (_write_source);
 950
 951                         _write_source->set_timeline_position (capture_info.front()->start);
 952                         _write_source->set_captured_for (_name);
 953
 954                         /* flush to disk: this step differs from the audio path,
 955                            where all the data is already on disk.
 956                          */
 957
 958                         _write_source->mark_streaming_write_completed ();
 959
 960                         /* make it not a stub anymore */
 961
 962                         _write_source->unstubify ();
 963
 964                         /* we will want to be able to keep (over)writing the source
 965                            but we don't want it to be removable. this also differs
 966                            from the audio situation, where the source at this point
 967                            must be considered immutable. luckily, we can rely on
 968                            MidiSource::mark_streaming_write_completed() to have
 969                            already done the necessary work for that.
 970                         */
 971
 972                         string whole_file_region_name;
 973                         whole_file_region_name = region_name_from_path (_write_source->name(), true);
 974
 975                         /* Register a new region with the Session that
 976                            describes the entire source. Do this first
 977                            so that any sub-regions will obviously be
 978                            children of this one (later!)
 979                         */
 980
 981                         try {
 982                                 PropertyList plist;
 983
 984                                 plist.add (Properties::name, whole_file_region_name);
 985                                 plist.add (Properties::whole_file, true);
 986                                 plist.add (Properties::automatic, true);
 987                                 plist.add (Properties::start, 0);
 988                                 plist.add (Properties::length, total_capture);
 989                                 plist.add (Properties::layer, 0);
 990
 991                                 boost::shared_ptr<Region> rx (RegionFactory::create (srcs, plist));
 992
 993                                 region = boost::dynamic_pointer_cast<MidiRegion> (rx);
 994                                 region->special_set_position (capture_info.front()->start);
 995                         }
 996
 997
 998                         catch (failed_constructor& err) {
 999                                 error << string_compose(_("%1: could not create region for complete midi file"), _name) << endmsg;
1000                                 /* XXX what now? */
1001                         }
1002
1003                         _last_capture_sources.insert (_last_capture_sources.end(), srcs.begin(), srcs.end());
1004
1005                         _playlist->clear_history ();
1006                         _playlist->freeze ();
1007
1008                         uint32_t buffer_position = 0;
1009                         for (buffer_position = 0, ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1010
1011                                 string region_name;
1012
1013                                 RegionFactory::region_name (region_name, _write_source->name(), false);
1014
1015                                 // cerr << _name << ": based on ci of " << (*ci)->start << " for " << (*ci)->frames << " add a region\n";
1016
1017                                 try {
1018                                         PropertyList plist;
1019
1020                                         plist.add (Properties::start, buffer_position);
1021                                         plist.add (Properties::length, (*ci)->frames);
1022                                         plist.add (Properties::name, region_name);
1023
1024                                         boost::shared_ptr<Region> rx (RegionFactory::create (srcs, plist));
1025                                         region = boost::dynamic_pointer_cast<MidiRegion> (rx);
1026                                 }
1027
1028                                 catch (failed_constructor& err) {
1029                                         error << _("MidiDiskstream: could not create region for captured midi!") << endmsg;
1030                                         continue; /* XXX is this OK? */
1031                                 }
1032
1033                                 // cerr << "add new region, buffer position = " << buffer_position << " @ " << (*ci)->start << endl;
1034
1035                                 i_am_the_modifier++;
1036                                 _playlist->add_region (region, (*ci)->start);
1037                                 i_am_the_modifier--;
1038
1039                                 buffer_position += (*ci)->frames;
1040                         }
1041
1042                         _playlist->thaw ();
1043                         _session.add_command (new StatefulDiffCommand(_playlist));
1044                 }
1045
1046                 mark_write_completed = true;
1047         }
1048
1049         use_new_write_source (0);
1050
1051         for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1052                 delete *ci;
1053         }
1054
1055         if (_playlist) {
1056                 midi_playlist()->clear_note_trackers ();
1057         }
1058
1059         capture_info.clear ();
1060         capture_start_frame = 0;
1061 }
1062
1063 void
1064 MidiDiskstream::transport_looped (nframes_t transport_frame)
1065 {
1066         if (was_recording) {
1067
1068                 // adjust the capture length knowing that the data will be recorded to disk
1069                 // only necessary after the first loop where we're recording
1070                 if (capture_info.size() == 0) {
1071                         capture_captured += _capture_offset;
1072
1073                         if (_alignment_style == ExistingMaterial) {
1074                                 capture_captured += _session.worst_output_latency();
1075                         } else {
1076                                 capture_captured += _roll_delay;
1077                         }
1078                 }
1079
1080                 finish_capture (true);
1081
1082                 // the next region will start recording via the normal mechanism
1083                 // we'll set the start position to the current transport pos
1084                 // no latency adjustment or capture offset needs to be made, as that already happened the first time
1085                 capture_start_frame = transport_frame;
1086                 first_recordable_frame = transport_frame; // mild lie
1087                 last_recordable_frame = max_frames;
1088                 was_recording = true;
1089         }
1090 }
1091
1092 void
1093 MidiDiskstream::finish_capture (bool /*rec_monitors_input*/)
1094 {
1095         was_recording = false;
1096
1097         if (capture_captured == 0) {
1098                 return;
1099         }
1100
1101         // Why must we destroy?
1102         assert(!destructive());
1103
1104         CaptureInfo* ci = new CaptureInfo;
1105
1106         ci->start  = capture_start_frame;
1107         ci->frames = capture_captured;
1108
1109         /* XXX theoretical race condition here. Need atomic exchange ?
1110            However, the circumstances when this is called right
1111            now (either on record-disable or transport_stopped)
1112            mean that no actual race exists. I think ...
1113            We now have a capture_info_lock, but it is only to be used
1114            to synchronize in the transport_stop and the capture info
1115            accessors, so that invalidation will not occur (both non-realtime).
1116         */
1117
1118         // cerr << "Finish capture, add new CI, " << ci->start << '+' << ci->frames << endl;
1119
1120         capture_info.push_back (ci);
1121         capture_captured = 0;
1122 }
1123
1124 void
1125 MidiDiskstream::set_record_enabled (bool yn)
1126 {
1127         if (!recordable() || !_session.record_enabling_legal()) {
1128                 return;
1129         }
1130
1131         assert(!destructive());
1132
1133         /* yes, i know that this not proof against race conditions, but its
1134            good enough. i think.
1135         */
1136
1137         if (record_enabled() != yn) {
1138                 if (yn) {
1139                         engage_record_enable ();
1140                 } else {
1141                         disengage_record_enable ();
1142                 }
1143         }
1144 }
1145
1146 void
1147 MidiDiskstream::engage_record_enable ()
1148 {
1149     bool rolling = _session.transport_speed() != 0.0f;
1150
1151         g_atomic_int_set (&_record_enabled, 1);
1152
1153         if (_source_port && Config->get_monitoring_model() == HardwareMonitoring) {
1154                 _source_port->request_monitor_input (!(_session.config.get_auto_input() && rolling));
1155         }
1156
1157         _write_source->mark_streaming_midi_write_started (_note_mode, _session.transport_frame());
1158
1159         RecordEnableChanged (); /* EMIT SIGNAL */
1160 }
1161
1162 void
1163 MidiDiskstream::disengage_record_enable ()
1164 {
1165         g_atomic_int_set (&_record_enabled, 0);
1166         if (_source_port && Config->get_monitoring_model() == HardwareMonitoring) {
1167                 if (_source_port) {
1168                         _source_port->request_monitor_input (false);
1169                 }
1170         }
1171
1172         RecordEnableChanged (); /* EMIT SIGNAL */
1173 }
1174
1175 XMLNode&
1176 MidiDiskstream::get_state ()
1177 {
1178         XMLNode* node = new XMLNode ("Diskstream");
1179         char buf[64];
1180         LocaleGuard lg (X_("POSIX"));
1181
1182         snprintf (buf, sizeof(buf), "0x%x", _flags);
1183         node->add_property ("flags", buf);
1184
1185         node->add_property("channel-mode", enum_2_string(get_channel_mode()));
1186
1187         snprintf (buf, sizeof(buf), "0x%x", get_channel_mask());
1188         node->add_property("channel-mask", buf);
1189
1190         node->add_property ("playlist", _playlist->name());
1191
1192         snprintf (buf, sizeof(buf), "%f", _visible_speed);
1193         node->add_property ("speed", buf);
1194
1195         node->add_property("name", _name);
1196         id().print(buf, sizeof(buf));
1197         node->add_property("id", buf);
1198
1199         if (_write_source && _session.get_record_enabled()) {
1200
1201                 XMLNode* cs_child = new XMLNode (X_("CapturingSources"));
1202                 XMLNode* cs_grandchild;
1203
1204                 cs_grandchild = new XMLNode (X_("file"));
1205                 cs_grandchild->add_property (X_("path"), _write_source->path());
1206                 cs_child->add_child_nocopy (*cs_grandchild);
1207
1208                 /* store the location where capture will start */
1209
1210                 Location* pi;
1211
1212                 if (_session.config.get_punch_in() && ((pi = _session.locations()->auto_punch_location()) != 0)) {
1213                         snprintf (buf, sizeof (buf), "%" PRId64, pi->start());
1214                 } else {
1215                         snprintf (buf, sizeof (buf), "%" PRId64, _session.transport_frame());
1216                 }
1217
1218                 cs_child->add_property (X_("at"), buf);
1219                 node->add_child_nocopy (*cs_child);
1220         }
1221
1222         if (_extra_xml) {
1223                 node->add_child_copy (*_extra_xml);
1224         }
1225
1226         return* node;
1227 }
1228
1229 int
1230 MidiDiskstream::set_state (const XMLNode& node, int /*version*/)
1231 {
1232         const XMLProperty* prop;
1233         XMLNodeList nlist = node.children();
1234         XMLNodeIterator niter;
1235         XMLNode* capture_pending_node = 0;
1236         LocaleGuard lg (X_("POSIX"));
1237
1238         in_set_state = true;
1239
1240         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1241                 /*if ((*niter)->name() == IO::state_node_name) {
1242                         deprecated_io_node = new XMLNode (**niter);
1243                 }*/
1244                 assert ((*niter)->name() != IO::state_node_name);
1245
1246                 if ((*niter)->name() == X_("CapturingSources")) {
1247                         capture_pending_node = *niter;
1248                 }
1249         }
1250
1251         /* prevent write sources from being created */
1252
1253         in_set_state = true;
1254
1255         if ((prop = node.property ("name")) != 0) {
1256                 _name = prop->value();
1257         }
1258
1259         if ((prop = node.property ("id")) != 0) {
1260                 _id = prop->value ();
1261         }
1262
1263         if ((prop = node.property ("flags")) != 0) {
1264                 _flags = Flag (string_2_enum (prop->value(), _flags));
1265         }
1266
1267         ChannelMode channel_mode = AllChannels;
1268         if ((prop = node.property ("channel-mode")) != 0) {
1269                 channel_mode = ChannelMode (string_2_enum(prop->value(), channel_mode));
1270         }
1271
1272         unsigned int channel_mask = 0xFFFF;
1273         if ((prop = node.property ("channel-mask")) != 0) {
1274                 sscanf (prop->value().c_str(), "0x%x", &channel_mask);
1275                 if (channel_mask & (~0xFFFF)) {
1276                         warning << _("MidiDiskstream: XML property channel-mask out of range") << endmsg;
1277                 }
1278         }
1279
1280         set_channel_mode(channel_mode, channel_mask);
1281
1282         if ((prop = node.property ("playlist")) == 0) {
1283                 return -1;
1284         }
1285
1286         {
1287                 bool had_playlist = (_playlist != 0);
1288
1289                 if (find_and_use_playlist (prop->value())) {
1290                         return -1;
1291                 }
1292
1293                 if (!had_playlist) {
1294                         _playlist->set_orig_diskstream_id (id());
1295                 }
1296
1297                 if (capture_pending_node) {
1298                         use_pending_capture_data (*capture_pending_node);
1299                 }
1300
1301         }
1302
1303         if ((prop = node.property ("speed")) != 0) {
1304                 double sp = atof (prop->value().c_str());
1305
1306                 if (realtime_set_speed (sp, false)) {
1307                         non_realtime_set_speed ();
1308                 }
1309         }
1310
1311         in_set_state = false;
1312
1313         return 0;
1314 }
1315
1316 int
1317 MidiDiskstream::use_new_write_source (uint32_t n)
1318 {
1319         if (!_session.writable() || !recordable()) {
1320                 return 1;
1321         }
1322
1323         assert(n == 0);
1324
1325         _write_source.reset();
1326
1327         try {
1328                 /* file starts off as a stub file, it will be converted
1329                    when we're done with a capture pass, or when "stolen"
1330                    by the GUI.
1331                 */
1332
1333                 _write_source = boost::dynamic_pointer_cast<SMFSource>(
1334                         _session.create_midi_source_for_session (0, name (), true));
1335
1336                 if (!_write_source) {
1337                         throw failed_constructor();
1338                 }
1339         }
1340
1341         catch (failed_constructor &err) {
1342                 error << string_compose (_("%1:%2 new capture file not initialized correctly"), _name, n) << endmsg;
1343                 _write_source.reset();
1344                 return -1;
1345         }
1346
1347         _write_source->mark_streaming_midi_write_started (_note_mode, _session.transport_frame());
1348
1349         return 0;
1350 }
1351
1352 list<boost::shared_ptr<Source> >
1353 MidiDiskstream::steal_write_sources()
1354 {
1355         list<boost::shared_ptr<Source> > ret;
1356
1357         /* put some data on the disk, even if its just a header for an empty file.
1358            XXX should we not have a more direct method for doing this? Maybe not
1359            since we don't want to mess around with the model/disk relationship
1360            that the Source has to pay attention to.
1361          */
1362
1363         boost::dynamic_pointer_cast<MidiSource>(_write_source)->session_saved ();
1364
1365         /* make it visible/present */
1366         _write_source->unstubify ();
1367         /* never let it go away */
1368         _write_source->mark_nonremovable ();
1369
1370         ret.push_back (_write_source);
1371
1372         /* get a new one */
1373
1374         use_new_write_source (0);
1375
1376         return ret;
1377 }
1378
1379 void
1380 MidiDiskstream::reset_write_sources (bool mark_write_complete, bool /*force*/)
1381 {
1382         if (!_session.writable() || !recordable()) {
1383                 return;
1384         }
1385
1386         if (_write_source && mark_write_complete) {
1387                 _write_source->mark_streaming_write_completed ();
1388         }
1389         use_new_write_source (0);
1390 }
1391
1392 int
1393 MidiDiskstream::rename_write_sources ()
1394 {
1395         if (_write_source != 0) {
1396                 _write_source->set_source_name (_name.val(), destructive());
1397                 /* XXX what to do if this fails ? */
1398         }
1399         return 0;
1400 }
1401
1402 void
1403 MidiDiskstream::set_block_size (nframes_t /*nframes*/)
1404 {
1405 }
1406
1407 void
1408 MidiDiskstream::allocate_temporary_buffers ()
1409 {
1410 }
1411
1412 void
1413 MidiDiskstream::monitor_input (bool yn)
1414 {
1415         if (_source_port)
1416                 _source_port->ensure_monitor_input (yn);
1417 }
1418
1419 void
1420 MidiDiskstream::set_align_style_from_io ()
1421 {
1422         bool have_physical = false;
1423
1424         if (_io == 0) {
1425                 return;
1426         }
1427
1428         get_input_sources ();
1429
1430         if (_source_port && _source_port->flags() & JackPortIsPhysical) {
1431                 have_physical = true;
1432         }
1433
1434         if (have_physical) {
1435                 set_align_style (ExistingMaterial);
1436         } else {
1437                 set_align_style (CaptureTime);
1438         }
1439 }
1440
1441
1442 float
1443 MidiDiskstream::playback_buffer_load () const
1444 {
1445         return (float) ((double) _playback_buf->read_space()/
1446                         (double) _playback_buf->capacity());
1447 }
1448
1449 float
1450 MidiDiskstream::capture_buffer_load () const
1451 {
1452         return (float) ((double) _capture_buf->write_space()/
1453                         (double) _capture_buf->capacity());
1454 }
1455
1456 int
1457 MidiDiskstream::use_pending_capture_data (XMLNode& /*node*/)
1458 {
1459         return 0;
1460 }
1461
1462 /** Writes playback events in the given range to \a dst, translating time stamps
1463  * so that an event at \a start has time = 0
1464  */
1465 void
1466 MidiDiskstream::get_playback (MidiBuffer& dst, nframes_t start, nframes_t end)
1467 {
1468         dst.clear();
1469         assert(dst.size() == 0);
1470
1471         // Reverse.  ... We just don't do reverse, ok?  Back off.
1472         if (end <= start) {
1473                 return;
1474         }
1475
1476         // Translates stamps to be relative to start
1477
1478
1479 #ifndef NDEBUG
1480         const size_t events_read = _playback_buf->read(dst, start, end);
1481         DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("%1 MDS events read %2 range %3 .. %4 rspace %5 wspace %6\n", _name, events_read, start, end,
1482                                                               _playback_buf->read_space(), _playback_buf->write_space()));
1483 #else
1484         _playback_buf->read(dst, start, end);
1485 #endif
1486
1487         gint32 frames_read = end - start;
1488         g_atomic_int_add(&_frames_read_from_ringbuffer, frames_read);
1489 }
1490