libs/ardour/midi_diskstream.cc

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