libs/ardour/midi_diskstream.cc

   1 /*
   2     Copyright (C) 2000-2003 Paul Davis
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17 */
  18
  19 #include <fstream>
  20 #include <cstdio>
  21 #include <unistd.h>
  22 #include <cmath>
  23 #include <cerrno>
  24 #include <string>
  25 #include <climits>
  26 #include <fcntl.h>
  27 #include <cstdlib>
  28 #include <ctime>
  29 #include <sys/stat.h>
  30 #include <sys/mman.h>
  31
  32 #include "pbd/error.h"
  33 #include "pbd/basename.h"
  34 #include <glibmm/thread.h>
  35 #include "pbd/xml++.h"
  36 #include "pbd/memento_command.h"
  37 #include "pbd/enumwriter.h"
  38 #include "pbd/stateful_diff_command.h"
  39 #include "pbd/stacktrace.h"
  40
  41 #include "ardour/ardour.h"
  42 #include "ardour/audioengine.h"
  43 #include "ardour/butler.h"
  44 #include "ardour/configuration.h"
  45 #include "ardour/cycle_timer.h"
  46 #include "ardour/debug.h"
  47 #include "ardour/io.h"
  48 #include "ardour/midi_diskstream.h"
  49 #include "ardour/midi_playlist.h"
  50 #include "ardour/midi_port.h"
  51 #include "ardour/midi_region.h"
  52 #include "ardour/playlist_factory.h"
  53 #include "ardour/region_factory.h"
  54 #include "ardour/send.h"
  55 #include "ardour/session.h"
  56 #include "ardour/smf_source.h"
  57 #include "ardour/utils.h"
  58 #include "ardour/session_playlists.h"
  59 #include "ardour/route.h"
  60
  61 #include "midi++/types.h"
  62
  63 #include "i18n.h"
  64 #include <locale.h>
  65
  66 using namespace std;
  67 using namespace ARDOUR;
  68 using namespace PBD;
  69
  70 framecnt_t MidiDiskstream::midi_readahead = 4096;
  71
  72 MidiDiskstream::MidiDiskstream (Session &sess, const string &name, Diskstream::Flag flag)
  73         : Diskstream(sess, name, flag)
  74         , _playback_buf(0)
  75         , _capture_buf(0)
  76         , _source_port(0)
  77         , _last_flush_frame(0)
  78         , _note_mode(Sustained)
  79         , _frames_written_to_ringbuffer(0)
  80         , _frames_read_from_ringbuffer(0)
  81 {
  82         /* prevent any write sources from being created */
  83
  84         in_set_state = true;
  85
  86         init ();
  87         use_new_playlist ();
  88         use_new_write_source (0);
  89
  90         in_set_state = false;
  91
  92         assert(!destructive());
  93 }
  94
  95 MidiDiskstream::MidiDiskstream (Session& sess, const XMLNode& node)
  96         : Diskstream(sess, node)
  97         , _playback_buf(0)
  98         , _capture_buf(0)
  99         , _source_port(0)
 100         , _last_flush_frame(0)
 101         , _note_mode(Sustained)
 102         , _frames_written_to_ringbuffer(0)
 103         , _frames_read_from_ringbuffer(0)
 104 {
 105         in_set_state = true;
 106
 107         init ();
 108
 109         if (set_state (node, Stateful::loading_state_version)) {
 110                 in_set_state = false;
 111                 throw failed_constructor();
 112         }
 113
 114         use_new_write_source (0);
 115
 116         in_set_state = false;
 117 }
 118
 119 void
 120 MidiDiskstream::init ()
 121 {
 122         /* there are no channels at this point, so these
 123            two calls just get speed_buffer_size and wrap_buffer
 124            size setup without duplicating their code.
 125         */
 126
 127         set_block_size (_session.get_block_size());
 128         allocate_temporary_buffers ();
 129
 130         const size_t size = _session.butler()->midi_diskstream_buffer_size();
 131         _playback_buf = new MidiRingBuffer<framepos_t>(size);
 132         _capture_buf = new MidiRingBuffer<framepos_t>(size);
 133
 134         _n_channels = ChanCount(DataType::MIDI, 1);
 135
 136         assert(recordable());
 137 }
 138
 139 MidiDiskstream::~MidiDiskstream ()
 140 {
 141         Glib::Mutex::Lock lm (state_lock);
 142 }
 143
 144
 145 void
 146 MidiDiskstream::non_realtime_locate (framepos_t position)
 147 {
 148         if (_write_source) {
 149                 _write_source->set_timeline_position (position);
 150         }
 151         seek(position, false);
 152 }
 153
 154
 155 void
 156 MidiDiskstream::non_realtime_input_change ()
 157 {
 158         {
 159                 Glib::Mutex::Lock lm (state_lock);
 160
 161                 if (input_change_pending.type == IOChange::NoChange) {
 162                         return;
 163                 }
 164
 165                 if (input_change_pending.type & IOChange::ConfigurationChanged) {
 166                         if (_io->n_ports().n_midi() != _n_channels.n_midi()) {
 167                                 error << "Can not feed IO " << _io->n_ports()
 168                                         << " with diskstream " << _n_channels << endl;
 169                         }
 170                 }
 171
 172                 get_input_sources ();
 173                 set_capture_offset ();
 174
 175                 if (first_input_change) {
 176                         set_align_style (_persistent_alignment_style);
 177                         first_input_change = false;
 178                 } else {
 179                         set_align_style_from_io ();
 180                 }
 181
 182                 input_change_pending.type = IOChange::NoChange;
 183
 184                 /* implicit unlock */
 185         }
 186
 187         /* unlike with audio, there is never any need to reset write sources
 188            based on input configuration changes because ... a MIDI track
 189            has just 1 MIDI port as input, always.
 190         */
 191
 192         /* now refill channel buffers */
 193
 194         if (speed() != 1.0f || speed() != -1.0f) {
 195                 seek ((framepos_t) (_session.transport_frame() * (double) speed()));
 196         }
 197         else {
 198                 seek (_session.transport_frame());
 199         }
 200
 201         _last_flush_frame = _session.transport_frame();
 202 }
 203
 204 void
 205 MidiDiskstream::get_input_sources ()
 206 {
 207         uint32_t ni = _io->n_ports().n_midi();
 208
 209         if (ni == 0) {
 210                 return;
 211         }
 212
 213         // This is all we do for now at least
 214         assert(ni == 1);
 215
 216         _source_port = _io->midi(0);
 217
 218         // do... stuff?
 219 }
 220
 221 int
 222 MidiDiskstream::find_and_use_playlist (const string& name)
 223 {
 224         boost::shared_ptr<MidiPlaylist> playlist;
 225
 226         if ((playlist = boost::dynamic_pointer_cast<MidiPlaylist> (_session.playlists->by_name (name))) == 0) {
 227                 playlist = boost::dynamic_pointer_cast<MidiPlaylist> (PlaylistFactory::create (DataType::MIDI, _session, name));
 228         }
 229
 230         if (!playlist) {
 231                 error << string_compose(_("MidiDiskstream: Playlist \"%1\" isn't an midi playlist"), name) << endmsg;
 232                 return -1;
 233         }
 234
 235         return use_playlist (playlist);
 236 }
 237
 238 int
 239 MidiDiskstream::use_playlist (boost::shared_ptr<Playlist> playlist)
 240 {
 241         assert(boost::dynamic_pointer_cast<MidiPlaylist>(playlist));
 242
 243         Diskstream::use_playlist(playlist);
 244
 245         return 0;
 246 }
 247
 248 int
 249 MidiDiskstream::use_new_playlist ()
 250 {
 251         string newname;
 252         boost::shared_ptr<MidiPlaylist> playlist;
 253
 254         if (!in_set_state && destructive()) {
 255                 return 0;
 256         }
 257
 258         if (_playlist) {
 259                 newname = Playlist::bump_name (_playlist->name(), _session);
 260         } else {
 261                 newname = Playlist::bump_name (_name, _session);
 262         }
 263
 264         if ((playlist = boost::dynamic_pointer_cast<MidiPlaylist> (PlaylistFactory::create (
 265                         DataType::MIDI, _session, newname, hidden()))) != 0) {
 266
 267                 playlist->set_orig_diskstream_id (id());
 268                 return use_playlist (playlist);
 269
 270         } else {
 271                 return -1;
 272         }
 273 }
 274
 275 int
 276 MidiDiskstream::use_copy_playlist ()
 277 {
 278         assert(midi_playlist());
 279
 280         if (destructive()) {
 281                 return 0;
 282         }
 283
 284         if (_playlist == 0) {
 285                 error << string_compose(_("MidiDiskstream %1: there is no existing playlist to make a copy of!"), _name) << endmsg;
 286                 return -1;
 287         }
 288
 289         string newname;
 290         boost::shared_ptr<MidiPlaylist> playlist;
 291
 292         newname = Playlist::bump_name (_playlist->name(), _session);
 293
 294         if ((playlist  = boost::dynamic_pointer_cast<MidiPlaylist>(PlaylistFactory::create (midi_playlist(), newname))) != 0) {
 295                 playlist->set_orig_diskstream_id (id());
 296                 return use_playlist (playlist);
 297         } else {
 298                 return -1;
 299         }
 300 }
 301
 302 /** Overloaded from parent to die horribly
 303  */
 304 int
 305 MidiDiskstream::set_destructive (bool yn)
 306 {
 307         assert( ! destructive());
 308         assert( ! yn);
 309         return -1;
 310 }
 311
 312 void
 313 MidiDiskstream::set_note_mode (NoteMode m)
 314 {
 315         _note_mode = m;
 316         midi_playlist()->set_note_mode(m);
 317         if (_write_source && _write_source->model())
 318                 _write_source->model()->set_note_mode(m);
 319 }
 320
 321 #if 0
 322 static void
 323 trace_midi (ostream& o, MIDI::byte *msg, size_t len)
 324 {
 325         using namespace MIDI;
 326         eventType type;
 327         const char trace_prefix = ':';
 328
 329         type = (eventType) (msg[0]&0xF0);
 330
 331         switch (type) {
 332         case off:
 333                 o << trace_prefix
 334                    << "Channel "
 335                    << (msg[0]&0xF)+1
 336                    << " NoteOff NoteNum "
 337                    << (int) msg[1]
 338                    << " Vel "
 339                    << (int) msg[2]
 340                    << endl;
 341                 break;
 342
 343         case on:
 344                 o << trace_prefix
 345                    << "Channel "
 346                    << (msg[0]&0xF)+1
 347                    << " NoteOn NoteNum "
 348                    << (int) msg[1]
 349                    << " Vel "
 350                    << (int) msg[2]
 351                    << endl;
 352                 break;
 353
 354         case polypress:
 355                 o << trace_prefix
 356                    << "Channel "
 357                    << (msg[0]&0xF)+1
 358                    << " PolyPressure"
 359                    << (int) msg[1]
 360                    << endl;
 361                 break;
 362
 363         case MIDI::controller:
 364                 o << trace_prefix
 365                    << "Channel "
 366                    << (msg[0]&0xF)+1
 367                    << " Controller "
 368                    << (int) msg[1]
 369                    << " Value "
 370                    << (int) msg[2]
 371                    << endl;
 372                 break;
 373
 374         case program:
 375                 o << trace_prefix
 376                    << "Channel "
 377                    << (msg[0]&0xF)+1
 378                    <<  " Program Change ProgNum "
 379                    << (int) msg[1]
 380                    << endl;
 381                 break;
 382
 383         case chanpress:
 384                 o << trace_prefix
 385                    << "Channel "
 386                    << (msg[0]&0xF)+1
 387                    << " Channel Pressure "
 388                    << (int) msg[1]
 389                    << endl;
 390                 break;
 391
 392         case MIDI::pitchbend:
 393                 o << trace_prefix
 394                    << "Channel "
 395                    << (msg[0]&0xF)+1
 396                    << " Pitch Bend "
 397                    << ((msg[2]<<7)|msg[1])
 398                    << endl;
 399                 break;
 400
 401         case MIDI::sysex:
 402                 if (len == 1) {
 403                         switch (msg[0]) {
 404                         case 0xf8:
 405                                 o << trace_prefix
 406                                    << "Clock"
 407                                    << endl;
 408                                 break;
 409                         case 0xfa:
 410                                 o << trace_prefix
 411                                    << "Start"
 412                                    << endl;
 413                                 break;
 414                         case 0xfb:
 415                                 o << trace_prefix
 416                                    << "Continue"
 417                                    << endl;
 418                                 break;
 419                         case 0xfc:
 420                                 o << trace_prefix
 421                                    << "Stop"
 422                                    << endl;
 423                                 break;
 424                         case 0xfe:
 425                                 o << trace_prefix
 426                                    << "Active Sense"
 427                                    << endl;
 428                                 break;
 429                         case 0xff:
 430                                 o << trace_prefix
 431                                    << "System Reset"
 432                                    << endl;
 433                                 break;
 434                         default:
 435                                 o << trace_prefix
 436                                    << "System Exclusive (1 byte : " << hex << (int) *msg << dec << ')'
 437                                    << endl;
 438                                 break;
 439                         }
 440                 } else {
 441                         o << trace_prefix
 442                            << "System Exclusive (" << len << ") = [ " << hex;
 443                         for (unsigned int i = 0; i < len; ++i) {
 444                                 o << (int) msg[i] << ' ';
 445                         }
 446                         o << dec << ']' << endl;
 447
 448                 }
 449                 break;
 450
 451         case MIDI::song:
 452                 o << trace_prefix << "Song" << endl;
 453                 break;
 454
 455         case MIDI::tune:
 456                 o << trace_prefix << "Tune" << endl;
 457                 break;
 458
 459         case MIDI::eox:
 460                 o << trace_prefix << "End-of-System Exclusive" << endl;
 461                 break;
 462
 463         case MIDI::timing:
 464                 o << trace_prefix << "Timing" << endl;
 465                 break;
 466
 467         case MIDI::start:
 468                 o << trace_prefix << "Start" << endl;
 469                 break;
 470
 471         case MIDI::stop:
 472                 o << trace_prefix << "Stop" << endl;
 473                 break;
 474
 475         case MIDI::contineu:
 476                 o << trace_prefix << "Continue" << endl;
 477                 break;
 478
 479         case active:
 480                 o << trace_prefix << "Active Sense" << endl;
 481                 break;
 482
 483         default:
 484                 o << trace_prefix << "Unrecognized MIDI message" << endl;
 485                 break;
 486         }
 487 }
 488 #endif
 489
 490 int
 491 MidiDiskstream::process (framepos_t transport_frame, pframes_t nframes, bool can_record, bool rec_monitors_input, bool& need_butler)
 492 {
 493         int       ret = -1;
 494         framecnt_t rec_offset = 0;
 495         framecnt_t rec_nframes = 0;
 496         bool      nominally_recording;
 497         bool      re = record_enabled ();
 498
 499         playback_distance = 0;
 500
 501         check_record_status (transport_frame, can_record);
 502
 503         nominally_recording = (can_record && re);
 504
 505         if (nframes == 0) {
 506                 return 0;
 507         }
 508
 509         Glib::Mutex::Lock sm (state_lock, Glib::TRY_LOCK);
 510
 511         if (!sm.locked()) {
 512                 return 1;
 513         }
 514
 515         adjust_capture_position = 0;
 516
 517         if (nominally_recording || (re && was_recording && _session.get_record_enabled() && _session.config.get_punch_in())) {
 518                 OverlapType ot = coverage (first_recordable_frame, last_recordable_frame, transport_frame, transport_frame + nframes);
 519
 520                 calculate_record_range(ot, transport_frame, nframes, rec_nframes, rec_offset);
 521
 522                 if (rec_nframes && !was_recording) {
 523                         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                 if (buf.size() != 0) {
 544                         /* Make a copy of this data and emit it for the GUI to see */
 545                         boost::shared_ptr<MidiBuffer> copy (new MidiBuffer (buf.capacity ()));
 546                         for (MidiBuffer::iterator i = buf.begin(); i != buf.end(); ++i) {
 547                                 copy->push_back ((*i).time() + transport_frame, (*i).size(), (*i).buffer());
 548                         }
 549
 550                         DataRecorded (copy, _write_source); /* EMIT SIGNAL */
 551                 }
 552
 553         } else {
 554
 555                 if (was_recording) {
 556                         finish_capture (rec_monitors_input);
 557                 }
 558
 559         }
 560
 561         if (rec_nframes) {
 562
 563                 /* data will be written to disk */
 564
 565                 if (rec_nframes == nframes && rec_offset == 0) {
 566                         playback_distance = nframes;
 567                 }
 568
 569                 adjust_capture_position = rec_nframes;
 570
 571         } else if (nominally_recording) {
 572
 573                 /* XXXX do this for MIDI !!!
 574                    can't do actual capture yet - waiting for latency effects to finish before we start
 575                    */
 576
 577                 playback_distance = nframes;
 578
 579         }
 580
 581         ret = 0;
 582
 583         if (commit (nframes)) {
 584                 need_butler = true;
 585         }
 586
 587         return ret;
 588 }
 589
 590 bool
 591 MidiDiskstream::commit (framecnt_t nframes)
 592 {
 593         bool need_butler = false;
 594
 595         if (_actual_speed < 0.0) {
 596                 playback_sample -= playback_distance;
 597         } else {
 598                 playback_sample += playback_distance;
 599         }
 600
 601         if (adjust_capture_position != 0) {
 602                 capture_captured += adjust_capture_position;
 603                 adjust_capture_position = 0;
 604         }
 605
 606         uint32_t frames_read = g_atomic_int_get(&_frames_read_from_ringbuffer);
 607         uint32_t frames_written = g_atomic_int_get(&_frames_written_to_ringbuffer);
 608         if ((frames_written - frames_read) + nframes < midi_readahead) {
 609                 need_butler = true;
 610         }
 611
 612         /*cerr << "MDS written: " << frames_written << " - read: " << frames_read <<
 613                 " = " << frames_written - frames_read
 614                 << " + " << nframes << " < " << midi_readahead << " = " << need_butler << ")" << endl;*/
 615
 616         return need_butler;
 617 }
 618
 619 void
 620 MidiDiskstream::set_pending_overwrite (bool yn)
 621 {
 622         /* called from audio thread, so we can use the read ptr and playback sample as we wish */
 623
 624         _pending_overwrite = yn;
 625
 626         overwrite_frame = playback_sample;
 627 }
 628
 629 int
 630 MidiDiskstream::overwrite_existing_buffers ()
 631 {
 632         read (overwrite_frame, disk_io_chunk_frames, false);
 633         overwrite_queued = false;
 634         _pending_overwrite = false;
 635
 636         return 0;
 637 }
 638
 639 int
 640 MidiDiskstream::seek (framepos_t frame, bool complete_refill)
 641 {
 642         Glib::Mutex::Lock lm (state_lock);
 643         int ret = -1;
 644
 645         _playback_buf->reset();
 646         _capture_buf->reset();
 647         g_atomic_int_set(&_frames_read_from_ringbuffer, 0);
 648         g_atomic_int_set(&_frames_written_to_ringbuffer, 0);
 649
 650         playback_sample = frame;
 651         file_frame = frame;
 652
 653         if (complete_refill) {
 654                 while ((ret = do_refill_with_alloc ()) > 0) ;
 655         } else {
 656                 ret = do_refill_with_alloc ();
 657         }
 658
 659         return ret;
 660 }
 661
 662 int
 663 MidiDiskstream::can_internal_playback_seek (framecnt_t distance)
 664 {
 665         uint32_t frames_read    = g_atomic_int_get(&_frames_read_from_ringbuffer);
 666         uint32_t frames_written = g_atomic_int_get(&_frames_written_to_ringbuffer);
 667         return ((frames_written - frames_read) < distance);
 668 }
 669
 670 int
 671 MidiDiskstream::internal_playback_seek (framecnt_t distance)
 672 {
 673         first_recordable_frame += distance;
 674         playback_sample += distance;
 675
 676         return 0;
 677 }
 678
 679 /** @a start is set to the new frame position (TIME) read up to */
 680 int
 681 MidiDiskstream::read (framepos_t& start, framecnt_t dur, bool reversed)
 682 {
 683         framecnt_t this_read = 0;
 684         bool reloop = false;
 685         framepos_t loop_end = 0;
 686         framepos_t loop_start = 0;
 687         Location *loc = 0;
 688
 689         if (!reversed) {
 690
 691                 framecnt_t loop_length = 0;
 692
 693                 /* Make the use of a Location atomic for this read operation.
 694
 695                    Note: Locations don't get deleted, so all we care about
 696                    when I say "atomic" is that we are always pointing to
 697                    the same one and using a start/length values obtained
 698                    just once.
 699                 */
 700
 701                 if ((loc = loop_location) != 0) {
 702                         loop_start = loc->start();
 703                         loop_end = loc->end();
 704                         loop_length = loop_end - loop_start;
 705                 }
 706
 707                 /* if we are looping, ensure that the first frame we read is at the correct
 708                    position within the loop.
 709                 */
 710
 711                 if (loc && (start >= loop_end)) {
 712                         //cerr << "start adjusted from " << start;
 713                         start = loop_start + ((start - loop_start) % loop_length);
 714                         //cerr << "to " << start << endl;
 715                 }
 716                 //cerr << "start is " << start << "  loopstart: " << loop_start << "  loopend: " << loop_end << endl;
 717         }
 718
 719         while (dur) {
 720
 721                 /* take any loop into account. we can't read past the end of the loop. */
 722
 723                 if (loc && (loop_end - start < dur)) {
 724                         this_read = loop_end - start;
 725                         //cerr << "reloop true: thisread: " << this_read << "  dur: " << dur << endl;
 726                         reloop = true;
 727                 } else {
 728                         reloop = false;
 729                         this_read = dur;
 730                 }
 731
 732                 if (this_read == 0) {
 733                         break;
 734                 }
 735
 736                 this_read = min(dur,this_read);
 737
 738                 if (midi_playlist()->read (*_playback_buf, start, this_read) != this_read) {
 739                         error << string_compose(
 740                                         _("MidiDiskstream %1: cannot read %2 from playlist at frame %3"),
 741                                         _id, this_read, start) << endmsg;
 742                         return -1;
 743                 }
 744
 745                 g_atomic_int_add(&_frames_written_to_ringbuffer, this_read);
 746
 747                 _read_data_count = _playlist->read_data_count();
 748
 749                 if (reversed) {
 750
 751                         // Swap note ons with note offs here.  etc?
 752                         // Fully reversing MIDI requires look-ahead (well, behind) to find previous
 753                         // CC values etc.  hard.
 754
 755                 } else {
 756
 757                         /* if we read to the end of the loop, go back to the beginning */
 758
 759                         if (reloop) {
 760                                 // Synthesize LoopEvent here, because the next events
 761                                 // written will have non-monotonic timestamps.
 762                                 _playback_buf->write(loop_end - 1, LoopEventType, sizeof (framepos_t), (uint8_t *) &loop_start);
 763                                 start = loop_start;
 764                         } else {
 765                                 start += this_read;
 766                         }
 767                 }
 768
 769                 dur -= this_read;
 770                 //offset += this_read;
 771         }
 772
 773         return 0;
 774 }
 775
 776 int
 777 MidiDiskstream::do_refill_with_alloc ()
 778 {
 779         return do_refill();
 780 }
 781
 782 int
 783 MidiDiskstream::do_refill ()
 784 {
 785         int     ret         = 0;
 786         size_t  write_space = _playback_buf->write_space();
 787         bool    reversed    = (_visible_speed * _session.transport_speed()) < 0.0f;
 788
 789         if (write_space == 0) {
 790                 return 0;
 791         }
 792
 793         if (reversed) {
 794                 return 0;
 795         }
 796
 797         /* at end: nothing to do */
 798         if (file_frame == max_framepos) {
 799                 return 0;
 800         }
 801
 802         // At this point we...
 803         assert(_playback_buf->write_space() > 0); // ... have something to write to, and
 804         assert(file_frame <= max_framepos); // ... something to write
 805
 806         // now calculate how much time is in the ringbuffer.
 807         // and lets write as much as we need to get this to be midi_readahead;
 808         uint32_t frames_read = g_atomic_int_get(&_frames_read_from_ringbuffer);
 809         uint32_t frames_written = g_atomic_int_get(&_frames_written_to_ringbuffer);
 810         if ((frames_written - frames_read) >= midi_readahead) {
 811                 //cout << "MDS Nothing to do. all fine" << endl;
 812                 return 0;
 813         }
 814
 815         framecnt_t to_read = midi_readahead - (frames_written - frames_read);
 816
 817         //cout << "MDS read for midi_readahead " << to_read << "  rb_contains: "
 818         //      << frames_written - frames_read << endl;
 819
 820         to_read = (framecnt_t) min ((framecnt_t) to_read, (framecnt_t) (max_framepos - file_frame));
 821
 822         if (read (file_frame, to_read, reversed)) {
 823                 ret = -1;
 824         }
 825
 826         return ret;
 827 }
 828
 829 /** Flush pending data to disk.
 830  *
 831  * Important note: this function will write *AT MOST* disk_io_chunk_frames
 832  * of data to disk. it will never write more than that.  If it writes that
 833  * much and there is more than that waiting to be written, it will return 1,
 834  * otherwise 0 on success or -1 on failure.
 835  *
 836  * If there is less than disk_io_chunk_frames to be written, no data will be
 837  * written at all unless @a force_flush is true.
 838  */
 839 int
 840 MidiDiskstream::do_flush (RunContext /*context*/, bool force_flush)
 841 {
 842         uint32_t to_write;
 843         int32_t ret = 0;
 844         framecnt_t total;
 845
 846         _write_data_count = 0;
 847
 848         total = _session.transport_frame() - _last_flush_frame;
 849
 850         if (_last_flush_frame > _session.transport_frame() || _last_flush_frame < capture_start_frame) {
 851                 _last_flush_frame = _session.transport_frame();
 852         }
 853
 854         if (total == 0 || _capture_buf->read_space() == 0
 855                         || (!force_flush && (total < disk_io_chunk_frames && was_recording))) {
 856                 goto out;
 857         }
 858
 859         /* if there are 2+ chunks of disk i/o possible for
 860            this track, let the caller know so that it can arrange
 861            for us to be called again, ASAP.
 862
 863            if we are forcing a flush, then if there is* any* extra
 864            work, let the caller know.
 865
 866            if we are no longer recording and there is any extra work,
 867            let the caller know too.
 868            */
 869
 870         if (total >= 2 * disk_io_chunk_frames || ((force_flush || !was_recording) && total > disk_io_chunk_frames)) {
 871                 ret = 1;
 872         }
 873
 874         to_write = disk_io_chunk_frames;
 875
 876         assert(!destructive());
 877
 878         if (record_enabled() &&
 879             ((_session.transport_frame() - _last_flush_frame > disk_io_chunk_frames) ||
 880              force_flush)) {
 881                 if ((!_write_source) || _write_source->midi_write (*_capture_buf, get_capture_start_frame (0), to_write) != to_write) {
 882                         error << string_compose(_("MidiDiskstream %1: cannot write to disk"), _id) << endmsg;
 883                         return -1;
 884                 } else {
 885                         _last_flush_frame = _session.transport_frame();
 886                 }
 887         }
 888
 889 out:
 890         return ret;
 891 }
 892
 893 void
 894 MidiDiskstream::transport_stopped_wallclock (struct tm& /*when*/, time_t /*twhen*/, bool abort_capture)
 895 {
 896         bool more_work = true;
 897         int err = 0;
 898         boost::shared_ptr<MidiRegion> region;
 899         MidiRegion::SourceList srcs;
 900         MidiRegion::SourceList::iterator src;
 901         vector<CaptureInfo*>::iterator ci;
 902         bool mark_write_completed = false;
 903
 904         finish_capture (true);
 905
 906         /* butler is already stopped, but there may be work to do
 907            to flush remaining data to disk.
 908            */
 909
 910         while (more_work && !err) {
 911                 switch (do_flush (TransportContext, true)) {
 912                         case 0:
 913                                 more_work = false;
 914                                 break;
 915                         case 1:
 916                                 break;
 917                         case -1:
 918                                 error << string_compose(_("MidiDiskstream \"%1\": cannot flush captured data to disk!"), _name) << endmsg;
 919                                 err++;
 920                 }
 921         }
 922
 923         /* XXX is there anything we can do if err != 0 ? */
 924         Glib::Mutex::Lock lm (capture_info_lock);
 925
 926         if (capture_info.empty()) {
 927                 return;
 928         }
 929
 930         if (abort_capture) {
 931
 932                 if (_write_source) {
 933
 934                         _write_source->mark_for_remove ();
 935                         _write_source.reset();
 936                 }
 937
 938                 /* new source set up in "out" below */
 939
 940         } else {
 941
 942                 assert(_write_source);
 943
 944                 framecnt_t total_capture = 0;
 945                 for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
 946                         total_capture += (*ci)->frames;
 947                 }
 948
 949                 if (_write_source->length (capture_info.front()->start) != 0) {
 950
 951                         /* phew, we have data */
 952
 953                         /* figure out the name for this take */
 954
 955                         srcs.push_back (_write_source);
 956
 957                         _write_source->set_timeline_position (capture_info.front()->start);
 958                         _write_source->set_captured_for (_name);
 959
 960                         /* flush to disk: this step differs from the audio path,
 961                            where all the data is already on disk.
 962                          */
 963
 964                         _write_source->mark_streaming_write_completed ();
 965
 966                         /* make it not a stub anymore */
 967
 968                         _write_source->unstubify ();
 969
 970                         /* we will want to be able to keep (over)writing the source
 971                            but we don't want it to be removable. this also differs
 972                            from the audio situation, where the source at this point
 973                            must be considered immutable. luckily, we can rely on
 974                            MidiSource::mark_streaming_write_completed() to have
 975                            already done the necessary work for that.
 976                         */
 977
 978                         string whole_file_region_name;
 979                         whole_file_region_name = region_name_from_path (_write_source->name(), true);
 980
 981                         /* Register a new region with the Session that
 982                            describes the entire source. Do this first
 983                            so that any sub-regions will obviously be
 984                            children of this one (later!)
 985                         */
 986
 987                         try {
 988                                 PropertyList plist;
 989
 990                                 plist.add (Properties::name, whole_file_region_name);
 991                                 plist.add (Properties::whole_file, true);
 992                                 plist.add (Properties::automatic, true);
 993                                 plist.add (Properties::start, 0);
 994                                 plist.add (Properties::length, total_capture);
 995                                 plist.add (Properties::layer, 0);
 996
 997                                 boost::shared_ptr<Region> rx (RegionFactory::create (srcs, plist));
 998
 999                                 region = boost::dynamic_pointer_cast<MidiRegion> (rx);
1000                                 region->special_set_position (capture_info.front()->start);
1001                         }
1002
1003
1004                         catch (failed_constructor& err) {
1005                                 error << string_compose(_("%1: could not create region for complete midi file"), _name) << endmsg;
1006                                 /* XXX what now? */
1007                         }
1008
1009                         _last_capture_sources.insert (_last_capture_sources.end(), srcs.begin(), srcs.end());
1010
1011                         _playlist->clear_changes ();
1012                         _playlist->freeze ();
1013
1014                         /* Session frame time of the initial capture in this pass, which is where the source starts */
1015                         framepos_t initial_capture = 0;
1016                         if (!capture_info.empty()) {
1017                                 initial_capture = capture_info.front()->start;
1018                         }
1019
1020                         for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1021
1022                                 string region_name;
1023
1024                                 RegionFactory::region_name (region_name, _write_source->name(), false);
1025
1026                                 // cerr << _name << ": based on ci of " << (*ci)->start << " for " << (*ci)->frames << " add a region\n";
1027
1028                                 try {
1029                                         PropertyList plist;
1030
1031                                         /* start of this region is the offset between the start of its capture and the start of the whole pass */
1032                                         plist.add (Properties::start, (*ci)->start - initial_capture);
1033                                         plist.add (Properties::length, (*ci)->frames);
1034                                         plist.add (Properties::name, region_name);
1035
1036                                         boost::shared_ptr<Region> rx (RegionFactory::create (srcs, plist));
1037                                         region = boost::dynamic_pointer_cast<MidiRegion> (rx);
1038                                 }
1039
1040                                 catch (failed_constructor& err) {
1041                                         error << _("MidiDiskstream: could not create region for captured midi!") << endmsg;
1042                                         continue; /* XXX is this OK? */
1043                                 }
1044
1045                                 // cerr << "add new region, buffer position = " << buffer_position << " @ " << (*ci)->start << endl;
1046
1047                                 i_am_the_modifier++;
1048                                 _playlist->add_region (region, (*ci)->start);
1049                                 i_am_the_modifier--;
1050                         }
1051
1052                         _playlist->thaw ();
1053                         _session.add_command (new StatefulDiffCommand(_playlist));
1054                 }
1055
1056                 mark_write_completed = true;
1057         }
1058
1059         use_new_write_source (0);
1060
1061         for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1062                 delete *ci;
1063         }
1064
1065         if (_playlist) {
1066                 midi_playlist()->clear_note_trackers ();
1067         }
1068
1069         capture_info.clear ();
1070         capture_start_frame = 0;
1071 }
1072
1073 void
1074 MidiDiskstream::transport_looped (framepos_t transport_frame)
1075 {
1076         if (was_recording) {
1077
1078                 // adjust the capture length knowing that the data will be recorded to disk
1079                 // only necessary after the first loop where we're recording
1080                 if (capture_info.size() == 0) {
1081                         capture_captured += _capture_offset;
1082
1083                         if (_alignment_style == ExistingMaterial) {
1084                                 capture_captured += _session.worst_output_latency();
1085                         } else {
1086                                 capture_captured += _roll_delay;
1087                         }
1088                 }
1089
1090                 finish_capture (true);
1091
1092                 // the next region will start recording via the normal mechanism
1093                 // we'll set the start position to the current transport pos
1094                 // no latency adjustment or capture offset needs to be made, as that already happened the first time
1095                 capture_start_frame = transport_frame;
1096                 first_recordable_frame = transport_frame; // mild lie
1097                 last_recordable_frame = max_framepos;
1098                 was_recording = true;
1099         }
1100 }
1101
1102 void
1103 MidiDiskstream::finish_capture (bool /*rec_monitors_input*/)
1104 {
1105         was_recording = false;
1106
1107         if (capture_captured == 0) {
1108                 return;
1109         }
1110
1111         // Why must we destroy?
1112         assert(!destructive());
1113
1114         CaptureInfo* ci = new CaptureInfo;
1115
1116         ci->start  = capture_start_frame;
1117         ci->frames = capture_captured;
1118
1119         /* XXX theoretical race condition here. Need atomic exchange ?
1120            However, the circumstances when this is called right
1121            now (either on record-disable or transport_stopped)
1122            mean that no actual race exists. I think ...
1123            We now have a capture_info_lock, but it is only to be used
1124            to synchronize in the transport_stop and the capture info
1125            accessors, so that invalidation will not occur (both non-realtime).
1126         */
1127
1128         // cerr << "Finish capture, add new CI, " << ci->start << '+' << ci->frames << endl;
1129
1130         capture_info.push_back (ci);
1131         capture_captured = 0;
1132 }
1133
1134 void
1135 MidiDiskstream::set_record_enabled (bool yn)
1136 {
1137         if (!recordable() || !_session.record_enabling_legal()) {
1138                 return;
1139         }
1140
1141         assert(!destructive());
1142
1143         /* yes, i know that this not proof against race conditions, but its
1144            good enough. i think.
1145         */
1146
1147         if (record_enabled() != yn) {
1148                 if (yn) {
1149                         engage_record_enable ();
1150                 } else {
1151                         disengage_record_enable ();
1152                 }
1153         }
1154 }
1155
1156 void
1157 MidiDiskstream::engage_record_enable ()
1158 {
1159         bool const rolling = _session.transport_speed() != 0.0f;
1160
1161         g_atomic_int_set (&_record_enabled, 1);
1162
1163         if (_source_port && Config->get_monitoring_model() == HardwareMonitoring) {
1164                 _source_port->request_monitor_input (!(_session.config.get_auto_input() && rolling));
1165         }
1166
1167         RecordEnableChanged (); /* EMIT SIGNAL */
1168 }
1169
1170 void
1171 MidiDiskstream::disengage_record_enable ()
1172 {
1173         g_atomic_int_set (&_record_enabled, 0);
1174         if (_source_port && Config->get_monitoring_model() == HardwareMonitoring) {
1175                 if (_source_port) {
1176                         _source_port->request_monitor_input (false);
1177                 }
1178         }
1179
1180         RecordEnableChanged (); /* EMIT SIGNAL */
1181 }
1182
1183 XMLNode&
1184 MidiDiskstream::get_state ()
1185 {
1186         XMLNode* node = new XMLNode ("Diskstream");
1187         char buf[64];
1188         LocaleGuard lg (X_("POSIX"));
1189
1190         snprintf (buf, sizeof(buf), "0x%x", _flags);
1191         node->add_property ("flags", buf);
1192
1193         node->add_property("channel-mode", enum_2_string(get_channel_mode()));
1194
1195         snprintf (buf, sizeof(buf), "0x%x", get_channel_mask());
1196         node->add_property("channel-mask", buf);
1197
1198         node->add_property ("playlist", _playlist->name());
1199
1200         snprintf (buf, sizeof(buf), "%f", _visible_speed);
1201         node->add_property ("speed", buf);
1202
1203         node->add_property("name", _name);
1204         id().print(buf, sizeof(buf));
1205         node->add_property("id", buf);
1206
1207         if (_write_source && _session.get_record_enabled()) {
1208
1209                 XMLNode* cs_child = new XMLNode (X_("CapturingSources"));
1210                 XMLNode* cs_grandchild;
1211
1212                 cs_grandchild = new XMLNode (X_("file"));
1213                 cs_grandchild->add_property (X_("path"), _write_source->path());
1214                 cs_child->add_child_nocopy (*cs_grandchild);
1215
1216                 /* store the location where capture will start */
1217
1218                 Location* pi;
1219
1220                 if (_session.config.get_punch_in() && ((pi = _session.locations()->auto_punch_location()) != 0)) {
1221                         snprintf (buf, sizeof (buf), "%" PRId64, pi->start());
1222                 } else {
1223                         snprintf (buf, sizeof (buf), "%" PRId64, _session.transport_frame());
1224                 }
1225
1226                 cs_child->add_property (X_("at"), buf);
1227                 node->add_child_nocopy (*cs_child);
1228         }
1229
1230         if (_extra_xml) {
1231                 node->add_child_copy (*_extra_xml);
1232         }
1233
1234         return* node;
1235 }
1236
1237 int
1238 MidiDiskstream::set_state (const XMLNode& node, int /*version*/)
1239 {
1240         const XMLProperty* prop;
1241         XMLNodeList nlist = node.children();
1242         XMLNodeIterator niter;
1243         XMLNode* capture_pending_node = 0;
1244         LocaleGuard lg (X_("POSIX"));
1245
1246         in_set_state = true;
1247
1248         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1249                 /*if ((*niter)->name() == IO::state_node_name) {
1250                         deprecated_io_node = new XMLNode (**niter);
1251                 }*/
1252                 assert ((*niter)->name() != IO::state_node_name);
1253
1254                 if ((*niter)->name() == X_("CapturingSources")) {
1255                         capture_pending_node = *niter;
1256                 }
1257         }
1258
1259         /* prevent write sources from being created */
1260
1261         in_set_state = true;
1262
1263         if ((prop = node.property ("name")) != 0) {
1264                 _name = prop->value();
1265         }
1266
1267         if ((prop = node.property ("id")) != 0) {
1268                 _id = prop->value ();
1269         }
1270
1271         if ((prop = node.property ("flags")) != 0) {
1272                 _flags = Flag (string_2_enum (prop->value(), _flags));
1273         }
1274
1275         ChannelMode channel_mode = AllChannels;
1276         if ((prop = node.property ("channel-mode")) != 0) {
1277                 channel_mode = ChannelMode (string_2_enum(prop->value(), channel_mode));
1278         }
1279
1280         unsigned int channel_mask = 0xFFFF;
1281         if ((prop = node.property ("channel-mask")) != 0) {
1282                 sscanf (prop->value().c_str(), "0x%x", &channel_mask);
1283                 if (channel_mask & (~0xFFFF)) {
1284                         warning << _("MidiDiskstream: XML property channel-mask out of range") << endmsg;
1285                 }
1286         }
1287
1288         set_channel_mode(channel_mode, channel_mask);
1289
1290         if ((prop = node.property ("playlist")) == 0) {
1291                 return -1;
1292         }
1293
1294         {
1295                 bool had_playlist = (_playlist != 0);
1296
1297                 if (find_and_use_playlist (prop->value())) {
1298                         return -1;
1299                 }
1300
1301                 if (!had_playlist) {
1302                         _playlist->set_orig_diskstream_id (id());
1303                 }
1304
1305                 if (capture_pending_node) {
1306                         use_pending_capture_data (*capture_pending_node);
1307                 }
1308
1309         }
1310
1311         if ((prop = node.property ("speed")) != 0) {
1312                 double sp = atof (prop->value().c_str());
1313
1314                 if (realtime_set_speed (sp, false)) {
1315                         non_realtime_set_speed ();
1316                 }
1317         }
1318
1319         in_set_state = false;
1320
1321         return 0;
1322 }
1323
1324 int
1325 MidiDiskstream::use_new_write_source (uint32_t n)
1326 {
1327         if (!_session.writable() || !recordable()) {
1328                 return 1;
1329         }
1330
1331         assert(n == 0);
1332
1333         _write_source.reset();
1334
1335         try {
1336                 /* file starts off as a stub file, it will be converted
1337                    when we're done with a capture pass, or when "stolen"
1338                    by the GUI.
1339                 */
1340
1341                 _write_source = boost::dynamic_pointer_cast<SMFSource>(
1342                         _session.create_midi_source_for_session (0, name (), true));
1343
1344                 if (!_write_source) {
1345                         throw failed_constructor();
1346                 }
1347         }
1348
1349         catch (failed_constructor &err) {
1350                 error << string_compose (_("%1:%2 new capture file not initialized correctly"), _name, n) << endmsg;
1351                 _write_source.reset();
1352                 return -1;
1353         }
1354
1355         _write_source->mark_streaming_midi_write_started (_note_mode, _session.transport_frame());
1356
1357         return 0;
1358 }
1359
1360 list<boost::shared_ptr<Source> >
1361 MidiDiskstream::steal_write_sources()
1362 {
1363         list<boost::shared_ptr<Source> > ret;
1364
1365         /* put some data on the disk, even if its just a header for an empty file.
1366            XXX should we not have a more direct method for doing this? Maybe not
1367            since we don't want to mess around with the model/disk relationship
1368            that the Source has to pay attention to.
1369          */
1370
1371         boost::dynamic_pointer_cast<MidiSource>(_write_source)->session_saved ();
1372
1373         /* make it visible/present */
1374         _write_source->unstubify ();
1375         /* never let it go away */
1376         _write_source->mark_nonremovable ();
1377
1378         ret.push_back (_write_source);
1379
1380         /* get a new one */
1381
1382         use_new_write_source (0);
1383
1384         return ret;
1385 }
1386
1387 void
1388 MidiDiskstream::reset_write_sources (bool mark_write_complete, bool /*force*/)
1389 {
1390         if (!_session.writable() || !recordable()) {
1391                 return;
1392         }
1393
1394         if (_write_source && mark_write_complete) {
1395                 _write_source->mark_streaming_write_completed ();
1396         }
1397         use_new_write_source (0);
1398 }
1399
1400 int
1401 MidiDiskstream::rename_write_sources ()
1402 {
1403         if (_write_source != 0) {
1404                 _write_source->set_source_name (_name.val(), destructive());
1405                 /* XXX what to do if this fails ? */
1406         }
1407         return 0;
1408 }
1409
1410 void
1411 MidiDiskstream::set_block_size (pframes_t /*nframes*/)
1412 {
1413 }
1414
1415 void
1416 MidiDiskstream::allocate_temporary_buffers ()
1417 {
1418 }
1419
1420 void
1421 MidiDiskstream::monitor_input (bool yn)
1422 {
1423         if (_source_port)
1424                 _source_port->ensure_monitor_input (yn);
1425 }
1426
1427 void
1428 MidiDiskstream::set_align_style_from_io ()
1429 {
1430         bool have_physical = false;
1431
1432         if (_io == 0) {
1433                 return;
1434         }
1435
1436         get_input_sources ();
1437
1438         if (_source_port && _source_port->flags() & JackPortIsPhysical) {
1439                 have_physical = true;
1440         }
1441
1442         if (have_physical) {
1443                 set_align_style (ExistingMaterial);
1444         } else {
1445                 set_align_style (CaptureTime);
1446         }
1447 }
1448
1449
1450 float
1451 MidiDiskstream::playback_buffer_load () const
1452 {
1453         return (float) ((double) _playback_buf->read_space()/
1454                         (double) _playback_buf->capacity());
1455 }
1456
1457 float
1458 MidiDiskstream::capture_buffer_load () const
1459 {
1460         return (float) ((double) _capture_buf->write_space()/
1461                         (double) _capture_buf->capacity());
1462 }
1463
1464 int
1465 MidiDiskstream::use_pending_capture_data (XMLNode& /*node*/)
1466 {
1467         return 0;
1468 }
1469
1470 /** Writes playback events in the given range to \a dst, translating time stamps
1471  * so that an event at \a start has time = 0
1472  */
1473 void
1474 MidiDiskstream::get_playback (MidiBuffer& dst, framepos_t start, framepos_t end)
1475 {
1476         dst.clear();
1477         assert(dst.size() == 0);
1478
1479         // Reverse.  ... We just don't do reverse, ok?  Back off.
1480         if (end <= start) {
1481                 return;
1482         }
1483
1484         // Translates stamps to be relative to start
1485
1486
1487 #ifndef NDEBUG
1488         const size_t events_read = _playback_buf->read(dst, start, end);
1489         DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("%1 MDS events read %2 range %3 .. %4 rspace %5 wspace %6\n", _name, events_read, start, end,
1490                                                               _playback_buf->read_space(), _playback_buf->write_space()));
1491 #else
1492         _playback_buf->read(dst, start, end);
1493 #endif
1494
1495         gint32 frames_read = end - start;
1496         g_atomic_int_add(&_frames_read_from_ringbuffer, frames_read);
1497 }
1498