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 (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, 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 || (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                         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 (framepos_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 (framecnt_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 (framecnt_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 (framepos_t& start, nframes_t dur, bool reversed)
 672 {
 673         nframes_t this_read = 0;
 674         bool reloop = false;
 675         framepos_t loop_end = 0;
 676         framepos_t loop_start = 0;
 677         Location *loc = 0;
 678
 679         if (!reversed) {
 680
 681                 framecnt_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 (framepos_t), (uint8_t *) &loop_start);
 753                                 start = loop_start;
 754                         } else {
 755                                 start += this_read;
 756                         }
 757                 }
 758
 759                 dur -= this_read;
 760                 //offset += this_read;
 761         }
 762
 763         return 0;
 764 }
 765
 766 int
 767 MidiDiskstream::do_refill_with_alloc ()
 768 {
 769         return do_refill();
 770 }
 771
 772 int
 773 MidiDiskstream::do_refill ()
 774 {
 775         int     ret         = 0;
 776         size_t  write_space = _playback_buf->write_space();
 777         bool    reversed    = (_visible_speed * _session.transport_speed()) < 0.0f;
 778
 779         if (write_space == 0) {
 780                 return 0;
 781         }
 782
 783         if (reversed) {
 784                 return 0;
 785         }
 786
 787         /* at end: nothing to do */
 788         if (file_frame == max_framepos) {
 789                 return 0;
 790         }
 791
 792         // At this point we...
 793         assert(_playback_buf->write_space() > 0); // ... have something to write to, and
 794         assert(file_frame <= max_framepos); // ... something to write
 795
 796         // now calculate how much time is in the ringbuffer.
 797         // and lets write as much as we need to get this to be midi_readahead;
 798         uint32_t frames_read = g_atomic_int_get(&_frames_read_from_ringbuffer);
 799         uint32_t frames_written = g_atomic_int_get(&_frames_written_to_ringbuffer);
 800         if ((frames_written - frames_read) >= midi_readahead) {
 801                 //cout << "MDS Nothing to do. all fine" << endl;
 802                 return 0;
 803         }
 804
 805         nframes_t to_read = midi_readahead - (frames_written - frames_read);
 806
 807         //cout << "MDS read for midi_readahead " << to_read << "  rb_contains: "
 808         //      << frames_written - frames_read << endl;
 809
 810         to_read = (nframes_t) min ((framecnt_t) to_read, (framecnt_t) (max_framepos - file_frame));
 811
 812         if (read (file_frame, to_read, reversed)) {
 813                 ret = -1;
 814         }
 815
 816         return ret;
 817 }
 818
 819 /** Flush pending data to disk.
 820  *
 821  * Important note: this function will write *AT MOST* disk_io_chunk_frames
 822  * of data to disk. it will never write more than that.  If it writes that
 823  * much and there is more than that waiting to be written, it will return 1,
 824  * otherwise 0 on success or -1 on failure.
 825  *
 826  * If there is less than disk_io_chunk_frames to be written, no data will be
 827  * written at all unless @a force_flush is true.
 828  */
 829 int
 830 MidiDiskstream::do_flush (RunContext /*context*/, bool force_flush)
 831 {
 832         uint32_t to_write;
 833         int32_t ret = 0;
 834         nframes_t total;
 835
 836         _write_data_count = 0;
 837
 838         total = _session.transport_frame() - _last_flush_frame;
 839
 840         if (_last_flush_frame > _session.transport_frame()
 841                         || _last_flush_frame < capture_start_frame) {
 842                 _last_flush_frame = _session.transport_frame();
 843         }
 844
 845         if (total == 0 || _capture_buf->read_space() == 0
 846                         || (!force_flush && (total < disk_io_chunk_frames && was_recording))) {
 847                 goto out;
 848         }
 849
 850         /* if there are 2+ chunks of disk i/o possible for
 851            this track, let the caller know so that it can arrange
 852            for us to be called again, ASAP.
 853
 854            if we are forcing a flush, then if there is* any* extra
 855            work, let the caller know.
 856
 857            if we are no longer recording and there is any extra work,
 858            let the caller know too.
 859            */
 860
 861         if (total >= 2 * disk_io_chunk_frames || ((force_flush || !was_recording) && total > disk_io_chunk_frames)) {
 862                 ret = 1;
 863         }
 864
 865         to_write = disk_io_chunk_frames;
 866
 867         assert(!destructive());
 868
 869         if (record_enabled() &&
 870             ((_session.transport_frame() - _last_flush_frame > disk_io_chunk_frames) ||
 871              force_flush)) {
 872                 if ((!_write_source) || _write_source->midi_write (*_capture_buf, capture_start_frame, to_write) != to_write) {
 873                         error << string_compose(_("MidiDiskstream %1: cannot write to disk"), _id) << endmsg;
 874                         return -1;
 875                 } else {
 876                         _last_flush_frame = _session.transport_frame();
 877                 }
 878         }
 879
 880 out:
 881         return ret;
 882 }
 883
 884 void
 885 MidiDiskstream::transport_stopped_wallclock (struct tm& /*when*/, time_t /*twhen*/, bool abort_capture)
 886 {
 887         bool more_work = true;
 888         int err = 0;
 889         boost::shared_ptr<MidiRegion> region;
 890         MidiRegion::SourceList srcs;
 891         MidiRegion::SourceList::iterator src;
 892         vector<CaptureInfo*>::iterator ci;
 893         bool mark_write_completed = false;
 894
 895         finish_capture (true);
 896
 897         /* butler is already stopped, but there may be work to do
 898            to flush remaining data to disk.
 899            */
 900
 901         while (more_work && !err) {
 902                 switch (do_flush (TransportContext, true)) {
 903                         case 0:
 904                                 more_work = false;
 905                                 break;
 906                         case 1:
 907                                 break;
 908                         case -1:
 909                                 error << string_compose(_("MidiDiskstream \"%1\": cannot flush captured data to disk!"), _name) << endmsg;
 910                                 err++;
 911                 }
 912         }
 913
 914         /* XXX is there anything we can do if err != 0 ? */
 915         Glib::Mutex::Lock lm (capture_info_lock);
 916
 917         if (capture_info.empty()) {
 918                 return;
 919         }
 920
 921         if (abort_capture) {
 922
 923                 if (_write_source) {
 924
 925                         _write_source->mark_for_remove ();
 926                         _write_source.reset();
 927                 }
 928
 929                 /* new source set up in "out" below */
 930
 931         } else {
 932
 933                 assert(_write_source);
 934
 935                 nframes_t total_capture = 0;
 936                 for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
 937                         total_capture += (*ci)->frames;
 938                 }
 939
 940                 if (_write_source->length (capture_info.front()->start) != 0) {
 941
 942                         /* phew, we have data */
 943
 944                         /* figure out the name for this take */
 945
 946                         srcs.push_back (_write_source);
 947
 948                         _write_source->set_timeline_position (capture_info.front()->start);
 949                         _write_source->set_captured_for (_name);
 950
 951                         /* flush to disk: this step differs from the audio path,
 952                            where all the data is already on disk.
 953                          */
 954
 955                         _write_source->mark_streaming_write_completed ();
 956
 957                         /* make it not a stub anymore */
 958
 959                         _write_source->unstubify ();
 960
 961                         /* we will want to be able to keep (over)writing the source
 962                            but we don't want it to be removable. this also differs
 963                            from the audio situation, where the source at this point
 964                            must be considered immutable. luckily, we can rely on
 965                            MidiSource::mark_streaming_write_completed() to have
 966                            already done the necessary work for that.
 967                         */
 968
 969                         string whole_file_region_name;
 970                         whole_file_region_name = region_name_from_path (_write_source->name(), true);
 971
 972                         /* Register a new region with the Session that
 973                            describes the entire source. Do this first
 974                            so that any sub-regions will obviously be
 975                            children of this one (later!)
 976                         */
 977
 978                         try {
 979                                 PropertyList plist;
 980
 981                                 plist.add (Properties::name, whole_file_region_name);
 982                                 plist.add (Properties::whole_file, true);
 983                                 plist.add (Properties::automatic, true);
 984                                 plist.add (Properties::start, 0);
 985                                 plist.add (Properties::length, total_capture);
 986                                 plist.add (Properties::layer, 0);
 987
 988                                 boost::shared_ptr<Region> rx (RegionFactory::create (srcs, plist));
 989
 990                                 region = boost::dynamic_pointer_cast<MidiRegion> (rx);
 991                                 region->special_set_position (capture_info.front()->start);
 992                         }
 993
 994
 995                         catch (failed_constructor& err) {
 996                                 error << string_compose(_("%1: could not create region for complete midi file"), _name) << endmsg;
 997                                 /* XXX what now? */
 998                         }
 999
1000                         _last_capture_sources.insert (_last_capture_sources.end(), srcs.begin(), srcs.end());
1001
1002                         _playlist->clear_changes ();
1003                         _playlist->freeze ();
1004
1005                         uint32_t buffer_position = 0;
1006                         for (buffer_position = 0, ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1007
1008                                 string region_name;
1009
1010                                 RegionFactory::region_name (region_name, _write_source->name(), false);
1011
1012                                 // cerr << _name << ": based on ci of " << (*ci)->start << " for " << (*ci)->frames << " add a region\n";
1013
1014                                 try {
1015                                         PropertyList plist;
1016
1017                                         plist.add (Properties::start, buffer_position);
1018                                         plist.add (Properties::length, (*ci)->frames);
1019                                         plist.add (Properties::name, region_name);
1020
1021                                         boost::shared_ptr<Region> rx (RegionFactory::create (srcs, plist));
1022                                         region = boost::dynamic_pointer_cast<MidiRegion> (rx);
1023                                 }
1024
1025                                 catch (failed_constructor& err) {
1026                                         error << _("MidiDiskstream: could not create region for captured midi!") << endmsg;
1027                                         continue; /* XXX is this OK? */
1028                                 }
1029
1030                                 // cerr << "add new region, buffer position = " << buffer_position << " @ " << (*ci)->start << endl;
1031
1032                                 i_am_the_modifier++;
1033                                 _playlist->add_region (region, (*ci)->start);
1034                                 i_am_the_modifier--;
1035
1036                                 buffer_position += (*ci)->frames;
1037                         }
1038
1039                         _playlist->thaw ();
1040                         _session.add_command (new StatefulDiffCommand(_playlist));
1041                 }
1042
1043                 mark_write_completed = true;
1044         }
1045
1046         use_new_write_source (0);
1047
1048         for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1049                 delete *ci;
1050         }
1051
1052         if (_playlist) {
1053                 midi_playlist()->clear_note_trackers ();
1054         }
1055
1056         capture_info.clear ();
1057         capture_start_frame = 0;
1058 }
1059
1060 void
1061 MidiDiskstream::transport_looped (framepos_t transport_frame)
1062 {
1063         if (was_recording) {
1064
1065                 // adjust the capture length knowing that the data will be recorded to disk
1066                 // only necessary after the first loop where we're recording
1067                 if (capture_info.size() == 0) {
1068                         capture_captured += _capture_offset;
1069
1070                         if (_alignment_style == ExistingMaterial) {
1071                                 capture_captured += _session.worst_output_latency();
1072                         } else {
1073                                 capture_captured += _roll_delay;
1074                         }
1075                 }
1076
1077                 finish_capture (true);
1078
1079                 // the next region will start recording via the normal mechanism
1080                 // we'll set the start position to the current transport pos
1081                 // no latency adjustment or capture offset needs to be made, as that already happened the first time
1082                 capture_start_frame = transport_frame;
1083                 first_recordable_frame = transport_frame; // mild lie
1084                 last_recordable_frame = max_framepos;
1085                 was_recording = true;
1086         }
1087 }
1088
1089 void
1090 MidiDiskstream::finish_capture (bool /*rec_monitors_input*/)
1091 {
1092         was_recording = false;
1093
1094         if (capture_captured == 0) {
1095                 return;
1096         }
1097
1098         // Why must we destroy?
1099         assert(!destructive());
1100
1101         CaptureInfo* ci = new CaptureInfo;
1102
1103         ci->start  = capture_start_frame;
1104         ci->frames = capture_captured;
1105
1106         /* XXX theoretical race condition here. Need atomic exchange ?
1107            However, the circumstances when this is called right
1108            now (either on record-disable or transport_stopped)
1109            mean that no actual race exists. I think ...
1110            We now have a capture_info_lock, but it is only to be used
1111            to synchronize in the transport_stop and the capture info
1112            accessors, so that invalidation will not occur (both non-realtime).
1113         */
1114
1115         // cerr << "Finish capture, add new CI, " << ci->start << '+' << ci->frames << endl;
1116
1117         capture_info.push_back (ci);
1118         capture_captured = 0;
1119 }
1120
1121 void
1122 MidiDiskstream::set_record_enabled (bool yn)
1123 {
1124         if (!recordable() || !_session.record_enabling_legal()) {
1125                 return;
1126         }
1127
1128         assert(!destructive());
1129
1130         /* yes, i know that this not proof against race conditions, but its
1131            good enough. i think.
1132         */
1133
1134         if (record_enabled() != yn) {
1135                 if (yn) {
1136                         engage_record_enable ();
1137                 } else {
1138                         disengage_record_enable ();
1139                 }
1140         }
1141 }
1142
1143 void
1144 MidiDiskstream::engage_record_enable ()
1145 {
1146     bool rolling = _session.transport_speed() != 0.0f;
1147
1148         g_atomic_int_set (&_record_enabled, 1);
1149
1150         if (_source_port && Config->get_monitoring_model() == HardwareMonitoring) {
1151                 _source_port->request_monitor_input (!(_session.config.get_auto_input() && rolling));
1152         }
1153
1154         _write_source->mark_streaming_midi_write_started (_note_mode, _session.transport_frame());
1155
1156         RecordEnableChanged (); /* EMIT SIGNAL */
1157 }
1158
1159 void
1160 MidiDiskstream::disengage_record_enable ()
1161 {
1162         g_atomic_int_set (&_record_enabled, 0);
1163         if (_source_port && Config->get_monitoring_model() == HardwareMonitoring) {
1164                 if (_source_port) {
1165                         _source_port->request_monitor_input (false);
1166                 }
1167         }
1168
1169         RecordEnableChanged (); /* EMIT SIGNAL */
1170 }
1171
1172 XMLNode&
1173 MidiDiskstream::get_state ()
1174 {
1175         XMLNode* node = new XMLNode ("Diskstream");
1176         char buf[64];
1177         LocaleGuard lg (X_("POSIX"));
1178
1179         snprintf (buf, sizeof(buf), "0x%x", _flags);
1180         node->add_property ("flags", buf);
1181
1182         node->add_property("channel-mode", enum_2_string(get_channel_mode()));
1183
1184         snprintf (buf, sizeof(buf), "0x%x", get_channel_mask());
1185         node->add_property("channel-mask", buf);
1186
1187         node->add_property ("playlist", _playlist->name());
1188
1189         snprintf (buf, sizeof(buf), "%f", _visible_speed);
1190         node->add_property ("speed", buf);
1191
1192         node->add_property("name", _name);
1193         id().print(buf, sizeof(buf));
1194         node->add_property("id", buf);
1195
1196         if (_write_source && _session.get_record_enabled()) {
1197
1198                 XMLNode* cs_child = new XMLNode (X_("CapturingSources"));
1199                 XMLNode* cs_grandchild;
1200
1201                 cs_grandchild = new XMLNode (X_("file"));
1202                 cs_grandchild->add_property (X_("path"), _write_source->path());
1203                 cs_child->add_child_nocopy (*cs_grandchild);
1204
1205                 /* store the location where capture will start */
1206
1207                 Location* pi;
1208
1209                 if (_session.config.get_punch_in() && ((pi = _session.locations()->auto_punch_location()) != 0)) {
1210                         snprintf (buf, sizeof (buf), "%" PRId64, pi->start());
1211                 } else {
1212                         snprintf (buf, sizeof (buf), "%" PRId64, _session.transport_frame());
1213                 }
1214
1215                 cs_child->add_property (X_("at"), buf);
1216                 node->add_child_nocopy (*cs_child);
1217         }
1218
1219         if (_extra_xml) {
1220                 node->add_child_copy (*_extra_xml);
1221         }
1222
1223         return* node;
1224 }
1225
1226 int
1227 MidiDiskstream::set_state (const XMLNode& node, int /*version*/)
1228 {
1229         const XMLProperty* prop;
1230         XMLNodeList nlist = node.children();
1231         XMLNodeIterator niter;
1232         XMLNode* capture_pending_node = 0;
1233         LocaleGuard lg (X_("POSIX"));
1234
1235         in_set_state = true;
1236
1237         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1238                 /*if ((*niter)->name() == IO::state_node_name) {
1239                         deprecated_io_node = new XMLNode (**niter);
1240                 }*/
1241                 assert ((*niter)->name() != IO::state_node_name);
1242
1243                 if ((*niter)->name() == X_("CapturingSources")) {
1244                         capture_pending_node = *niter;
1245                 }
1246         }
1247
1248         /* prevent write sources from being created */
1249
1250         in_set_state = true;
1251
1252         if ((prop = node.property ("name")) != 0) {
1253                 _name = prop->value();
1254         }
1255
1256         if ((prop = node.property ("id")) != 0) {
1257                 _id = prop->value ();
1258         }
1259
1260         if ((prop = node.property ("flags")) != 0) {
1261                 _flags = Flag (string_2_enum (prop->value(), _flags));
1262         }
1263
1264         ChannelMode channel_mode = AllChannels;
1265         if ((prop = node.property ("channel-mode")) != 0) {
1266                 channel_mode = ChannelMode (string_2_enum(prop->value(), channel_mode));
1267         }
1268
1269         unsigned int channel_mask = 0xFFFF;
1270         if ((prop = node.property ("channel-mask")) != 0) {
1271                 sscanf (prop->value().c_str(), "0x%x", &channel_mask);
1272                 if (channel_mask & (~0xFFFF)) {
1273                         warning << _("MidiDiskstream: XML property channel-mask out of range") << endmsg;
1274                 }
1275         }
1276
1277         set_channel_mode(channel_mode, channel_mask);
1278
1279         if ((prop = node.property ("playlist")) == 0) {
1280                 return -1;
1281         }
1282
1283         {
1284                 bool had_playlist = (_playlist != 0);
1285
1286                 if (find_and_use_playlist (prop->value())) {
1287                         return -1;
1288                 }
1289
1290                 if (!had_playlist) {
1291                         _playlist->set_orig_diskstream_id (id());
1292                 }
1293
1294                 if (capture_pending_node) {
1295                         use_pending_capture_data (*capture_pending_node);
1296                 }
1297
1298         }
1299
1300         if ((prop = node.property ("speed")) != 0) {
1301                 double sp = atof (prop->value().c_str());
1302
1303                 if (realtime_set_speed (sp, false)) {
1304                         non_realtime_set_speed ();
1305                 }
1306         }
1307
1308         in_set_state = false;
1309
1310         return 0;
1311 }
1312
1313 int
1314 MidiDiskstream::use_new_write_source (uint32_t n)
1315 {
1316         if (!_session.writable() || !recordable()) {
1317                 return 1;
1318         }
1319
1320         assert(n == 0);
1321
1322         _write_source.reset();
1323
1324         try {
1325                 /* file starts off as a stub file, it will be converted
1326                    when we're done with a capture pass, or when "stolen"
1327                    by the GUI.
1328                 */
1329
1330                 _write_source = boost::dynamic_pointer_cast<SMFSource>(
1331                         _session.create_midi_source_for_session (0, name (), true));
1332
1333                 if (!_write_source) {
1334                         throw failed_constructor();
1335                 }
1336         }
1337
1338         catch (failed_constructor &err) {
1339                 error << string_compose (_("%1:%2 new capture file not initialized correctly"), _name, n) << endmsg;
1340                 _write_source.reset();
1341                 return -1;
1342         }
1343
1344         _write_source->mark_streaming_midi_write_started (_note_mode, _session.transport_frame());
1345
1346         return 0;
1347 }
1348
1349 list<boost::shared_ptr<Source> >
1350 MidiDiskstream::steal_write_sources()
1351 {
1352         list<boost::shared_ptr<Source> > ret;
1353
1354         /* put some data on the disk, even if its just a header for an empty file.
1355            XXX should we not have a more direct method for doing this? Maybe not
1356            since we don't want to mess around with the model/disk relationship
1357            that the Source has to pay attention to.
1358          */
1359
1360         boost::dynamic_pointer_cast<MidiSource>(_write_source)->session_saved ();
1361
1362         /* make it visible/present */
1363         _write_source->unstubify ();
1364         /* never let it go away */
1365         _write_source->mark_nonremovable ();
1366
1367         ret.push_back (_write_source);
1368
1369         /* get a new one */
1370
1371         use_new_write_source (0);
1372
1373         return ret;
1374 }
1375
1376 void
1377 MidiDiskstream::reset_write_sources (bool mark_write_complete, bool /*force*/)
1378 {
1379         if (!_session.writable() || !recordable()) {
1380                 return;
1381         }
1382
1383         if (_write_source && mark_write_complete) {
1384                 _write_source->mark_streaming_write_completed ();
1385         }
1386         use_new_write_source (0);
1387 }
1388
1389 int
1390 MidiDiskstream::rename_write_sources ()
1391 {
1392         if (_write_source != 0) {
1393                 _write_source->set_source_name (_name.val(), destructive());
1394                 /* XXX what to do if this fails ? */
1395         }
1396         return 0;
1397 }
1398
1399 void
1400 MidiDiskstream::set_block_size (nframes_t /*nframes*/)
1401 {
1402 }
1403
1404 void
1405 MidiDiskstream::allocate_temporary_buffers ()
1406 {
1407 }
1408
1409 void
1410 MidiDiskstream::monitor_input (bool yn)
1411 {
1412         if (_source_port)
1413                 _source_port->ensure_monitor_input (yn);
1414 }
1415
1416 void
1417 MidiDiskstream::set_align_style_from_io ()
1418 {
1419         bool have_physical = false;
1420
1421         if (_io == 0) {
1422                 return;
1423         }
1424
1425         get_input_sources ();
1426
1427         if (_source_port && _source_port->flags() & JackPortIsPhysical) {
1428                 have_physical = true;
1429         }
1430
1431         if (have_physical) {
1432                 set_align_style (ExistingMaterial);
1433         } else {
1434                 set_align_style (CaptureTime);
1435         }
1436 }
1437
1438
1439 float
1440 MidiDiskstream::playback_buffer_load () const
1441 {
1442         return (float) ((double) _playback_buf->read_space()/
1443                         (double) _playback_buf->capacity());
1444 }
1445
1446 float
1447 MidiDiskstream::capture_buffer_load () const
1448 {
1449         return (float) ((double) _capture_buf->write_space()/
1450                         (double) _capture_buf->capacity());
1451 }
1452
1453 int
1454 MidiDiskstream::use_pending_capture_data (XMLNode& /*node*/)
1455 {
1456         return 0;
1457 }
1458
1459 /** Writes playback events in the given range to \a dst, translating time stamps
1460  * so that an event at \a start has time = 0
1461  */
1462 void
1463 MidiDiskstream::get_playback (MidiBuffer& dst, framepos_t start, framepos_t end)
1464 {
1465         dst.clear();
1466         assert(dst.size() == 0);
1467
1468         // Reverse.  ... We just don't do reverse, ok?  Back off.
1469         if (end <= start) {
1470                 return;
1471         }
1472
1473         // Translates stamps to be relative to start
1474
1475
1476 #ifndef NDEBUG
1477         const size_t events_read = _playback_buf->read(dst, start, end);
1478         DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("%1 MDS events read %2 range %3 .. %4 rspace %5 wspace %6\n", _name, events_read, start, end,
1479                                                               _playback_buf->read_space(), _playback_buf->write_space()));
1480 #else
1481         _playback_buf->read(dst, start, end);
1482 #endif
1483
1484         gint32 frames_read = end - start;
1485         g_atomic_int_add(&_frames_read_from_ringbuffer, frames_read);
1486 }
1487