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