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