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