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