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                         _write_source->mark_for_remove ();
 940                         _write_source.reset();
 941                 }
 942
 943                 /* new source set up in "out" below */
 944
 945         } else {
 946
 947                 assert(_write_source);
 948
 949                 framecnt_t total_capture = 0;
 950                 for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
 951                         total_capture += (*ci)->frames;
 952                 }
 953
 954                 if (_write_source->length (capture_info.front()->start) != 0) {
 955
 956                         /* phew, we have data */
 957
 958                         /* figure out the name for this take */
 959
 960                         srcs.push_back (_write_source);
 961
 962                         _write_source->set_timeline_position (capture_info.front()->start);
 963                         _write_source->set_captured_for (_name);
 964
 965                         /* flush to disk: this step differs from the audio path,
 966                            where all the data is already on disk.
 967                         */
 968
 969                         _write_source->mark_streaming_write_completed ();
 970
 971                         /* set length in beats to entire capture length */
 972
 973                         BeatsFramesConverter converter (_session.tempo_map(), capture_info.front()->start);
 974                         const double total_capture_beats = converter.from(total_capture);
 975                         _write_source->set_length_beats(total_capture_beats);
 976
 977                         /* make it not a stub anymore */
 978
 979                         _write_source->unstubify ();
 980
 981                         /* we will want to be able to keep (over)writing the source
 982                            but we don't want it to be removable. this also differs
 983                            from the audio situation, where the source at this point
 984                            must be considered immutable. luckily, we can rely on
 985                            MidiSource::mark_streaming_write_completed() to have
 986                            already done the necessary work for that.
 987                         */
 988
 989                         string whole_file_region_name;
 990                         whole_file_region_name = region_name_from_path (_write_source->name(), true);
 991
 992                         /* Register a new region with the Session that
 993                            describes the entire source. Do this first
 994                            so that any sub-regions will obviously be
 995                            children of this one (later!)
 996                         */
 997
 998                         try {
 999                                 PropertyList plist;
1000
1001                                 plist.add (Properties::name, whole_file_region_name);
1002                                 plist.add (Properties::whole_file, true);
1003                                 plist.add (Properties::automatic, true);
1004                                 plist.add (Properties::start, 0);
1005                                 plist.add (Properties::length, total_capture);
1006                                 plist.add (Properties::layer, 0);
1007
1008                                 boost::shared_ptr<Region> rx (RegionFactory::create (srcs, plist));
1009
1010                                 region = boost::dynamic_pointer_cast<MidiRegion> (rx);
1011                                 region->special_set_position (capture_info.front()->start);
1012                         }
1013
1014
1015                         catch (failed_constructor& err) {
1016                                 error << string_compose(_("%1: could not create region for complete midi file"), _name) << endmsg;
1017                                 /* XXX what now? */
1018                         }
1019
1020                         _last_capture_sources.insert (_last_capture_sources.end(), srcs.begin(), srcs.end());
1021
1022                         _playlist->clear_changes ();
1023                         _playlist->freeze ();
1024
1025                         /* Session frame time of the initial capture in this pass, which is where the source starts */
1026                         framepos_t initial_capture = 0;
1027                         if (!capture_info.empty()) {
1028                                 initial_capture = capture_info.front()->start;
1029                         }
1030
1031                         for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1032
1033                                 string region_name;
1034
1035                                 RegionFactory::region_name (region_name, _write_source->name(), false);
1036
1037                                 // cerr << _name << ": based on ci of " << (*ci)->start << " for " << (*ci)->frames << " add a region\n";
1038
1039                                 try {
1040                                         PropertyList plist;
1041
1042                                         /* start of this region is the offset between the start of its capture and the start of the whole pass */
1043                                         plist.add (Properties::start, (*ci)->start - initial_capture);
1044                                         plist.add (Properties::length, (*ci)->frames);
1045                                         plist.add (Properties::name, region_name);
1046
1047                                         boost::shared_ptr<Region> rx (RegionFactory::create (srcs, plist));
1048                                         region = boost::dynamic_pointer_cast<MidiRegion> (rx);
1049                                 }
1050
1051                                 catch (failed_constructor& err) {
1052                                         error << _("MidiDiskstream: could not create region for captured midi!") << endmsg;
1053                                         continue; /* XXX is this OK? */
1054                                 }
1055
1056                                 // cerr << "add new region, buffer position = " << buffer_position << " @ " << (*ci)->start << endl;
1057
1058                                 i_am_the_modifier++;
1059                                 _playlist->add_region (region, (*ci)->start);
1060                                 i_am_the_modifier--;
1061                         }
1062
1063                         _playlist->thaw ();
1064                         _session.add_command (new StatefulDiffCommand(_playlist));
1065                 }
1066
1067                 mark_write_completed = true;
1068         }
1069
1070         use_new_write_source (0);
1071
1072         for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1073                 delete *ci;
1074         }
1075
1076         if (_playlist) {
1077                 midi_playlist()->clear_note_trackers ();
1078         }
1079
1080         capture_info.clear ();
1081         capture_start_frame = 0;
1082 }
1083
1084 void
1085 MidiDiskstream::transport_looped (framepos_t transport_frame)
1086 {
1087         if (was_recording) {
1088
1089                 // adjust the capture length knowing that the data will be recorded to disk
1090                 // only necessary after the first loop where we're recording
1091                 if (capture_info.size() == 0) {
1092                         capture_captured += _capture_offset;
1093
1094                         if (_alignment_style == ExistingMaterial) {
1095                                 capture_captured += _session.worst_output_latency();
1096                         } else {
1097                                 capture_captured += _roll_delay;
1098                         }
1099                 }
1100
1101                 finish_capture (true);
1102
1103                 // the next region will start recording via the normal mechanism
1104                 // we'll set the start position to the current transport pos
1105                 // no latency adjustment or capture offset needs to be made, as that already happened the first time
1106                 capture_start_frame = transport_frame;
1107                 first_recordable_frame = transport_frame; // mild lie
1108                 last_recordable_frame = max_framepos;
1109                 was_recording = true;
1110         }
1111 }
1112
1113 void
1114 MidiDiskstream::finish_capture (bool /*rec_monitors_input*/)
1115 {
1116         was_recording = false;
1117
1118         if (capture_captured == 0) {
1119                 return;
1120         }
1121
1122         // Why must we destroy?
1123         assert(!destructive());
1124
1125         CaptureInfo* ci = new CaptureInfo;
1126
1127         ci->start  = capture_start_frame;
1128         ci->frames = capture_captured;
1129
1130         /* XXX theoretical race condition here. Need atomic exchange ?
1131            However, the circumstances when this is called right
1132            now (either on record-disable or transport_stopped)
1133            mean that no actual race exists. I think ...
1134            We now have a capture_info_lock, but it is only to be used
1135            to synchronize in the transport_stop and the capture info
1136            accessors, so that invalidation will not occur (both non-realtime).
1137         */
1138
1139         // cerr << "Finish capture, add new CI, " << ci->start << '+' << ci->frames << endl;
1140
1141         capture_info.push_back (ci);
1142         capture_captured = 0;
1143 }
1144
1145 void
1146 MidiDiskstream::set_record_enabled (bool yn)
1147 {
1148         if (!recordable() || !_session.record_enabling_legal()) {
1149                 return;
1150         }
1151
1152         assert(!destructive());
1153
1154         /* yes, i know that this not proof against race conditions, but its
1155            good enough. i think.
1156         */
1157
1158         if (record_enabled() != yn) {
1159                 if (yn) {
1160                         engage_record_enable ();
1161                 } else {
1162                         disengage_record_enable ();
1163                 }
1164         }
1165 }
1166
1167 void
1168 MidiDiskstream::engage_record_enable ()
1169 {
1170         bool const rolling = _session.transport_speed() != 0.0f;
1171
1172         g_atomic_int_set (&_record_enabled, 1);
1173
1174         if (_source_port && Config->get_monitoring_model() == HardwareMonitoring) {
1175                 _source_port->request_monitor_input (!(_session.config.get_auto_input() && rolling));
1176         }
1177
1178         RecordEnableChanged (); /* EMIT SIGNAL */
1179 }
1180
1181 void
1182 MidiDiskstream::disengage_record_enable ()
1183 {
1184         g_atomic_int_set (&_record_enabled, 0);
1185         if (_source_port && Config->get_monitoring_model() == HardwareMonitoring) {
1186                 if (_source_port) {
1187                         _source_port->request_monitor_input (false);
1188                 }
1189         }
1190
1191         RecordEnableChanged (); /* EMIT SIGNAL */
1192 }
1193
1194 XMLNode&
1195 MidiDiskstream::get_state ()
1196 {
1197         XMLNode* node = new XMLNode ("Diskstream");
1198         char buf[64];
1199         LocaleGuard lg (X_("POSIX"));
1200
1201         snprintf (buf, sizeof(buf), "0x%x", _flags);
1202         node->add_property ("flags", buf);
1203
1204         node->add_property("channel-mode", enum_2_string(get_channel_mode()));
1205
1206         snprintf (buf, sizeof(buf), "0x%x", get_channel_mask());
1207         node->add_property("channel-mask", buf);
1208
1209         node->add_property ("playlist", _playlist->name());
1210
1211         snprintf (buf, sizeof(buf), "%f", _visible_speed);
1212         node->add_property ("speed", buf);
1213
1214         node->add_property("name", _name);
1215         id().print(buf, sizeof(buf));
1216         node->add_property("id", buf);
1217
1218         if (_write_source && _session.get_record_enabled()) {
1219
1220                 XMLNode* cs_child = new XMLNode (X_("CapturingSources"));
1221                 XMLNode* cs_grandchild;
1222
1223                 cs_grandchild = new XMLNode (X_("file"));
1224                 cs_grandchild->add_property (X_("path"), _write_source->path());
1225                 cs_child->add_child_nocopy (*cs_grandchild);
1226
1227                 /* store the location where capture will start */
1228
1229                 Location* pi;
1230
1231                 if (_session.config.get_punch_in() && ((pi = _session.locations()->auto_punch_location()) != 0)) {
1232                         snprintf (buf, sizeof (buf), "%" PRId64, pi->start());
1233                 } else {
1234                         snprintf (buf, sizeof (buf), "%" PRId64, _session.transport_frame());
1235                 }
1236
1237                 cs_child->add_property (X_("at"), buf);
1238                 node->add_child_nocopy (*cs_child);
1239         }
1240
1241         if (_extra_xml) {
1242                 node->add_child_copy (*_extra_xml);
1243         }
1244
1245         return* node;
1246 }
1247
1248 int
1249 MidiDiskstream::set_state (const XMLNode& node, int /*version*/)
1250 {
1251         const XMLProperty* prop;
1252         XMLNodeList nlist = node.children();
1253         XMLNodeIterator niter;
1254         XMLNode* capture_pending_node = 0;
1255         LocaleGuard lg (X_("POSIX"));
1256
1257         in_set_state = true;
1258
1259         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1260                 /*if ((*niter)->name() == IO::state_node_name) {
1261                         deprecated_io_node = new XMLNode (**niter);
1262                 }*/
1263                 assert ((*niter)->name() != IO::state_node_name);
1264
1265                 if ((*niter)->name() == X_("CapturingSources")) {
1266                         capture_pending_node = *niter;
1267                 }
1268         }
1269
1270         /* prevent write sources from being created */
1271
1272         in_set_state = true;
1273
1274         if ((prop = node.property ("name")) != 0) {
1275                 _name = prop->value();
1276         }
1277
1278         if ((prop = node.property ("id")) != 0) {
1279                 _id = prop->value ();
1280         }
1281
1282         if ((prop = node.property ("flags")) != 0) {
1283                 _flags = Flag (string_2_enum (prop->value(), _flags));
1284         }
1285
1286         ChannelMode channel_mode = AllChannels;
1287         if ((prop = node.property ("channel-mode")) != 0) {
1288                 channel_mode = ChannelMode (string_2_enum(prop->value(), channel_mode));
1289         }
1290
1291         unsigned int channel_mask = 0xFFFF;
1292         if ((prop = node.property ("channel-mask")) != 0) {
1293                 sscanf (prop->value().c_str(), "0x%x", &channel_mask);
1294                 if (channel_mask & (~0xFFFF)) {
1295                         warning << _("MidiDiskstream: XML property channel-mask out of range") << endmsg;
1296                 }
1297         }
1298
1299         set_channel_mode(channel_mode, channel_mask);
1300
1301         if ((prop = node.property ("playlist")) == 0) {
1302                 return -1;
1303         }
1304
1305         {
1306                 bool had_playlist = (_playlist != 0);
1307
1308                 if (find_and_use_playlist (prop->value())) {
1309                         return -1;
1310                 }
1311
1312                 if (!had_playlist) {
1313                         _playlist->set_orig_diskstream_id (id());
1314                 }
1315
1316                 if (capture_pending_node) {
1317                         use_pending_capture_data (*capture_pending_node);
1318                 }
1319
1320         }
1321
1322         if ((prop = node.property ("speed")) != 0) {
1323                 double sp = atof (prop->value().c_str());
1324
1325                 if (realtime_set_speed (sp, false)) {
1326                         non_realtime_set_speed ();
1327                 }
1328         }
1329
1330         in_set_state = false;
1331
1332         return 0;
1333 }
1334
1335 int
1336 MidiDiskstream::use_new_write_source (uint32_t n)
1337 {
1338         if (!_session.writable() || !recordable()) {
1339                 return 1;
1340         }
1341
1342         assert(n == 0);
1343
1344         _write_source.reset();
1345
1346         try {
1347                 /* file starts off as a stub file, it will be converted
1348                    when we're done with a capture pass, or when "stolen"
1349                    by the GUI.
1350                 */
1351
1352                 _write_source = boost::dynamic_pointer_cast<SMFSource>(
1353                         _session.create_midi_source_for_session (0, name (), true));
1354
1355                 if (!_write_source) {
1356                         throw failed_constructor();
1357                 }
1358         }
1359
1360         catch (failed_constructor &err) {
1361                 error << string_compose (_("%1:%2 new capture file not initialized correctly"), _name, n) << endmsg;
1362                 _write_source.reset();
1363                 return -1;
1364         }
1365
1366         _write_source->mark_streaming_midi_write_started (_note_mode, _session.transport_frame());
1367
1368         return 0;
1369 }
1370
1371 list<boost::shared_ptr<Source> >
1372 MidiDiskstream::steal_write_sources()
1373 {
1374         list<boost::shared_ptr<Source> > ret;
1375
1376         /* put some data on the disk, even if its just a header for an empty file.
1377            XXX should we not have a more direct method for doing this? Maybe not
1378            since we don't want to mess around with the model/disk relationship
1379            that the Source has to pay attention to.
1380         */
1381
1382         boost::dynamic_pointer_cast<MidiSource>(_write_source)->session_saved ();
1383
1384         /* make it visible/present */
1385         _write_source->unstubify ();
1386         /* never let it go away */
1387         _write_source->mark_nonremovable ();
1388
1389         ret.push_back (_write_source);
1390
1391         /* get a new one */
1392
1393         use_new_write_source (0);
1394
1395         return ret;
1396 }
1397
1398 void
1399 MidiDiskstream::reset_write_sources (bool mark_write_complete, bool /*force*/)
1400 {
1401         if (!_session.writable() || !recordable()) {
1402                 return;
1403         }
1404
1405         if (_write_source && mark_write_complete) {
1406                 _write_source->mark_streaming_write_completed ();
1407         }
1408         use_new_write_source (0);
1409 }
1410
1411 int
1412 MidiDiskstream::rename_write_sources ()
1413 {
1414         if (_write_source != 0) {
1415                 _write_source->set_source_name (_name.val(), destructive());
1416                 /* XXX what to do if this fails ? */
1417         }
1418         return 0;
1419 }
1420
1421 void
1422 MidiDiskstream::set_block_size (pframes_t /*nframes*/)
1423 {
1424 }
1425
1426 void
1427 MidiDiskstream::allocate_temporary_buffers ()
1428 {
1429 }
1430
1431 void
1432 MidiDiskstream::monitor_input (bool yn)
1433 {
1434         if (_source_port)
1435                 _source_port->ensure_monitor_input (yn);
1436 }
1437
1438 void
1439 MidiDiskstream::set_align_style_from_io ()
1440 {
1441         bool have_physical = false;
1442
1443         if (_io == 0) {
1444                 return;
1445         }
1446
1447         get_input_sources ();
1448
1449         if (_source_port && _source_port->flags() & JackPortIsPhysical) {
1450                 have_physical = true;
1451         }
1452
1453         if (have_physical) {
1454                 set_align_style (ExistingMaterial);
1455         } else {
1456                 set_align_style (CaptureTime);
1457         }
1458 }
1459
1460
1461 float
1462 MidiDiskstream::playback_buffer_load () const
1463 {
1464         return (float) ((double) _playback_buf->read_space()/
1465                         (double) _playback_buf->capacity());
1466 }
1467
1468 float
1469 MidiDiskstream::capture_buffer_load () const
1470 {
1471         return (float) ((double) _capture_buf->write_space()/
1472                         (double) _capture_buf->capacity());
1473 }
1474
1475 int
1476 MidiDiskstream::use_pending_capture_data (XMLNode& /*node*/)
1477 {
1478         return 0;
1479 }
1480
1481 /** Writes playback events in the given range to \a dst, translating time stamps
1482  * so that an event at \a start has time = 0
1483  */
1484 void
1485 MidiDiskstream::get_playback (MidiBuffer& dst, framepos_t start, framepos_t end)
1486 {
1487         dst.clear();
1488         assert(dst.size() == 0);
1489
1490         // Reverse.  ... We just don't do reverse, ok?  Back off.
1491         if (end <= start) {
1492                 return;
1493         }
1494
1495         // Translates stamps to be relative to start
1496
1497
1498 #ifndef NDEBUG
1499         const size_t events_read = _playback_buf->read(dst, start, end);
1500         DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("%1 MDS events read %2 range %3 .. %4 rspace %5 wspace %6\n", _name, events_read, start, end,
1501                                                               _playback_buf->read_space(), _playback_buf->write_space()));
1502 #else
1503         _playback_buf->read(dst, start, end);
1504 #endif
1505
1506         gint32 frames_read = end - start;
1507         g_atomic_int_add(&_frames_read_from_ringbuffer, frames_read);
1508 }
1509