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                 set_align_style_from_io ();
 175
 176                 input_change_pending.type = IOChange::NoChange;
 177
 178                 /* implicit unlock */
 179         }
 180
 181         /* unlike with audio, there is never any need to reset write sources
 182            based on input configuration changes because ... a MIDI track
 183            has just 1 MIDI port as input, always.
 184         */
 185
 186         /* now refill channel buffers */
 187
 188         if (speed() != 1.0f || speed() != -1.0f) {
 189                 seek ((framepos_t) (_session.transport_frame() * (double) speed()));
 190         }
 191         else {
 192                 seek (_session.transport_frame());
 193         }
 194
 195         _last_flush_frame = _session.transport_frame();
 196 }
 197
 198 void
 199 MidiDiskstream::get_input_sources ()
 200 {
 201         uint32_t ni = _io->n_ports().n_midi();
 202
 203         if (ni == 0) {
 204                 return;
 205         }
 206
 207         // This is all we do for now at least
 208         assert(ni == 1);
 209
 210         _source_port = _io->midi(0);
 211
 212         // do... stuff?
 213 }
 214
 215 int
 216 MidiDiskstream::find_and_use_playlist (const string& name)
 217 {
 218         boost::shared_ptr<MidiPlaylist> playlist;
 219
 220         if ((playlist = boost::dynamic_pointer_cast<MidiPlaylist> (_session.playlists->by_name (name))) == 0) {
 221                 playlist = boost::dynamic_pointer_cast<MidiPlaylist> (PlaylistFactory::create (DataType::MIDI, _session, name));
 222         }
 223
 224         if (!playlist) {
 225                 error << string_compose(_("MidiDiskstream: Playlist \"%1\" isn't an midi playlist"), name) << endmsg;
 226                 return -1;
 227         }
 228
 229         return use_playlist (playlist);
 230 }
 231
 232 int
 233 MidiDiskstream::use_playlist (boost::shared_ptr<Playlist> playlist)
 234 {
 235         assert(boost::dynamic_pointer_cast<MidiPlaylist>(playlist));
 236
 237         Diskstream::use_playlist(playlist);
 238
 239         return 0;
 240 }
 241
 242 int
 243 MidiDiskstream::use_new_playlist ()
 244 {
 245         string newname;
 246         boost::shared_ptr<MidiPlaylist> playlist;
 247
 248         if (!in_set_state && destructive()) {
 249                 return 0;
 250         }
 251
 252         if (_playlist) {
 253                 newname = Playlist::bump_name (_playlist->name(), _session);
 254         } else {
 255                 newname = Playlist::bump_name (_name, _session);
 256         }
 257
 258         if ((playlist = boost::dynamic_pointer_cast<MidiPlaylist> (PlaylistFactory::create (
 259                         DataType::MIDI, _session, newname, hidden()))) != 0) {
 260
 261                 playlist->set_orig_diskstream_id (id());
 262                 return use_playlist (playlist);
 263
 264         } else {
 265                 return -1;
 266         }
 267 }
 268
 269 int
 270 MidiDiskstream::use_copy_playlist ()
 271 {
 272         assert(midi_playlist());
 273
 274         if (destructive()) {
 275                 return 0;
 276         }
 277
 278         if (_playlist == 0) {
 279                 error << string_compose(_("MidiDiskstream %1: there is no existing playlist to make a copy of!"), _name) << endmsg;
 280                 return -1;
 281         }
 282
 283         string newname;
 284         boost::shared_ptr<MidiPlaylist> playlist;
 285
 286         newname = Playlist::bump_name (_playlist->name(), _session);
 287
 288         if ((playlist  = boost::dynamic_pointer_cast<MidiPlaylist>(PlaylistFactory::create (midi_playlist(), newname))) != 0) {
 289                 playlist->set_orig_diskstream_id (id());
 290                 return use_playlist (playlist);
 291         } else {
 292                 return -1;
 293         }
 294 }
 295
 296 /** Overloaded from parent to die horribly
 297  */
 298 int
 299 MidiDiskstream::set_destructive (bool yn)
 300 {
 301         assert( ! destructive());
 302         assert( ! yn);
 303         return -1;
 304 }
 305
 306 void
 307 MidiDiskstream::set_note_mode (NoteMode m)
 308 {
 309         _note_mode = m;
 310         midi_playlist()->set_note_mode(m);
 311         if (_write_source && _write_source->model())
 312                 _write_source->model()->set_note_mode(m);
 313 }
 314
 315 #if 0
 316 static void
 317 trace_midi (ostream& o, MIDI::byte *msg, size_t len)
 318 {
 319         using namespace MIDI;
 320         eventType type;
 321         const char trace_prefix = ':';
 322
 323         type = (eventType) (msg[0]&0xF0);
 324
 325         switch (type) {
 326         case off:
 327                 o << trace_prefix
 328                    << "Channel "
 329                    << (msg[0]&0xF)+1
 330                    << " NoteOff NoteNum "
 331                    << (int) msg[1]
 332                    << " Vel "
 333                    << (int) msg[2]
 334                    << endl;
 335                 break;
 336
 337         case on:
 338                 o << trace_prefix
 339                    << "Channel "
 340                    << (msg[0]&0xF)+1
 341                    << " NoteOn NoteNum "
 342                    << (int) msg[1]
 343                    << " Vel "
 344                    << (int) msg[2]
 345                    << endl;
 346                 break;
 347
 348         case polypress:
 349                 o << trace_prefix
 350                    << "Channel "
 351                    << (msg[0]&0xF)+1
 352                    << " PolyPressure"
 353                    << (int) msg[1]
 354                    << endl;
 355                 break;
 356
 357         case MIDI::controller:
 358                 o << trace_prefix
 359                    << "Channel "
 360                    << (msg[0]&0xF)+1
 361                    << " Controller "
 362                    << (int) msg[1]
 363                    << " Value "
 364                    << (int) msg[2]
 365                    << endl;
 366                 break;
 367
 368         case program:
 369                 o << trace_prefix
 370                    << "Channel "
 371                    << (msg[0]&0xF)+1
 372                    <<  " Program Change ProgNum "
 373                    << (int) msg[1]
 374                    << endl;
 375                 break;
 376
 377         case chanpress:
 378                 o << trace_prefix
 379                    << "Channel "
 380                    << (msg[0]&0xF)+1
 381                    << " Channel Pressure "
 382                    << (int) msg[1]
 383                    << endl;
 384                 break;
 385
 386         case MIDI::pitchbend:
 387                 o << trace_prefix
 388                    << "Channel "
 389                    << (msg[0]&0xF)+1
 390                    << " Pitch Bend "
 391                    << ((msg[2]<<7)|msg[1])
 392                    << endl;
 393                 break;
 394
 395         case MIDI::sysex:
 396                 if (len == 1) {
 397                         switch (msg[0]) {
 398                         case 0xf8:
 399                                 o << trace_prefix
 400                                    << "Clock"
 401                                    << endl;
 402                                 break;
 403                         case 0xfa:
 404                                 o << trace_prefix
 405                                    << "Start"
 406                                    << endl;
 407                                 break;
 408                         case 0xfb:
 409                                 o << trace_prefix
 410                                    << "Continue"
 411                                    << endl;
 412                                 break;
 413                         case 0xfc:
 414                                 o << trace_prefix
 415                                    << "Stop"
 416                                    << endl;
 417                                 break;
 418                         case 0xfe:
 419                                 o << trace_prefix
 420                                    << "Active Sense"
 421                                    << endl;
 422                                 break;
 423                         case 0xff:
 424                                 o << trace_prefix
 425                                    << "System Reset"
 426                                    << endl;
 427                                 break;
 428                         default:
 429                                 o << trace_prefix
 430                                    << "System Exclusive (1 byte : " << hex << (int) *msg << dec << ')'
 431                                    << endl;
 432                                 break;
 433                         }
 434                 } else {
 435                         o << trace_prefix
 436                            << "System Exclusive (" << len << ") = [ " << hex;
 437                         for (unsigned int i = 0; i < len; ++i) {
 438                                 o << (int) msg[i] << ' ';
 439                         }
 440                         o << dec << ']' << endl;
 441
 442                 }
 443                 break;
 444
 445         case MIDI::song:
 446                 o << trace_prefix << "Song" << endl;
 447                 break;
 448
 449         case MIDI::tune:
 450                 o << trace_prefix << "Tune" << endl;
 451                 break;
 452
 453         case MIDI::eox:
 454                 o << trace_prefix << "End-of-System Exclusive" << endl;
 455                 break;
 456
 457         case MIDI::timing:
 458                 o << trace_prefix << "Timing" << endl;
 459                 break;
 460
 461         case MIDI::start:
 462                 o << trace_prefix << "Start" << endl;
 463                 break;
 464
 465         case MIDI::stop:
 466                 o << trace_prefix << "Stop" << endl;
 467                 break;
 468
 469         case MIDI::contineu:
 470                 o << trace_prefix << "Continue" << endl;
 471                 break;
 472
 473         case active:
 474                 o << trace_prefix << "Active Sense" << endl;
 475                 break;
 476
 477         default:
 478                 o << trace_prefix << "Unrecognized MIDI message" << endl;
 479                 break;
 480         }
 481 }
 482 #endif
 483
 484 int
 485 MidiDiskstream::process (framepos_t transport_frame, pframes_t nframes, bool can_record, bool rec_monitors_input, bool& need_butler)
 486 {
 487         int       ret = -1;
 488         framecnt_t rec_offset = 0;
 489         framecnt_t rec_nframes = 0;
 490         bool      nominally_recording;
 491         bool      re = record_enabled ();
 492
 493         playback_distance = 0;
 494
 495         check_record_status (transport_frame, can_record);
 496
 497         nominally_recording = (can_record && re);
 498
 499         if (nframes == 0) {
 500                 return 0;
 501         }
 502
 503         Glib::Mutex::Lock sm (state_lock, Glib::TRY_LOCK);
 504
 505         if (!sm.locked()) {
 506                 return 1;
 507         }
 508
 509         adjust_capture_position = 0;
 510
 511         if (nominally_recording || (re && was_recording && _session.get_record_enabled() && _session.config.get_punch_in())) {
 512                 OverlapType ot = coverage (first_recordable_frame, last_recordable_frame, transport_frame, transport_frame + nframes);
 513
 514                 calculate_record_range(ot, transport_frame, nframes, rec_nframes, rec_offset);
 515
 516                 if (rec_nframes && !was_recording) {
 517                         _write_source->mark_write_starting_now ();
 518                         capture_captured = 0;
 519                         was_recording = true;
 520                 }
 521         }
 522
 523
 524         if (can_record && !_last_capture_sources.empty()) {
 525                 _last_capture_sources.clear ();
 526         }
 527
 528         if (nominally_recording || rec_nframes) {
 529
 530                 // Pump entire port buffer into the ring buffer (FIXME: split cycles?)
 531                 MidiBuffer& buf = _source_port->get_midi_buffer(nframes);
 532                 for (MidiBuffer::iterator i = buf.begin(); i != buf.end(); ++i) {
 533                         const Evoral::MIDIEvent<MidiBuffer::TimeType> ev(*i, false);
 534                         assert(ev.buffer());
 535                         _capture_buf->write(ev.time() + transport_frame, ev.type(), ev.size(), ev.buffer());
 536                 }
 537
 538                 if (buf.size() != 0) {
 539                         /* Make a copy of this data and emit it for the GUI to see */
 540                         boost::shared_ptr<MidiBuffer> copy (new MidiBuffer (buf.capacity ()));
 541                         for (MidiBuffer::iterator i = buf.begin(); i != buf.end(); ++i) {
 542                                 copy->push_back ((*i).time() + transport_frame, (*i).size(), (*i).buffer());
 543                         }
 544
 545                         DataRecorded (copy, _write_source); /* EMIT SIGNAL */
 546                 }
 547
 548         } else {
 549
 550                 if (was_recording) {
 551                         finish_capture (rec_monitors_input);
 552                 }
 553
 554         }
 555
 556         if (rec_nframes) {
 557
 558                 /* data will be written to disk */
 559
 560                 if (rec_nframes == nframes && rec_offset == 0) {
 561                         playback_distance = nframes;
 562                 }
 563
 564                 adjust_capture_position = rec_nframes;
 565
 566         } else if (nominally_recording) {
 567
 568                 /* XXXX do this for MIDI !!!
 569                    can't do actual capture yet - waiting for latency effects to finish before we start
 570                    */
 571
 572                 playback_distance = nframes;
 573
 574         } else {
 575
 576                 /* XXX: should be doing varispeed stuff here, similar to the code in AudioDiskstream::process */
 577
 578                 playback_distance = nframes;
 579
 580         }
 581
 582         ret = 0;
 583
 584         if (commit (nframes)) {
 585                 need_butler = true;
 586         }
 587
 588         return ret;
 589 }
 590
 591 bool
 592 MidiDiskstream::commit (framecnt_t nframes)
 593 {
 594         bool need_butler = false;
 595
 596         if (_actual_speed < 0.0) {
 597                 playback_sample -= playback_distance;
 598         } else {
 599                 playback_sample += playback_distance;
 600         }
 601
 602         if (adjust_capture_position != 0) {
 603                 capture_captured += adjust_capture_position;
 604                 adjust_capture_position = 0;
 605         }
 606
 607         uint32_t frames_read = g_atomic_int_get(&_frames_read_from_ringbuffer);
 608         uint32_t frames_written = g_atomic_int_get(&_frames_written_to_ringbuffer);
 609         if ((frames_written - frames_read) + nframes < midi_readahead) {
 610                 need_butler = true;
 611         }
 612
 613         /*cerr << "MDS written: " << frames_written << " - read: " << frames_read <<
 614                 " = " << frames_written - frames_read
 615                 << " + " << nframes << " < " << midi_readahead << " = " << need_butler << ")" << endl;*/
 616
 617         return need_butler;
 618 }
 619
 620 void
 621 MidiDiskstream::set_pending_overwrite (bool yn)
 622 {
 623         /* called from audio thread, so we can use the read ptr and playback sample as we wish */
 624
 625         _pending_overwrite = yn;
 626
 627         overwrite_frame = playback_sample;
 628 }
 629
 630 int
 631 MidiDiskstream::overwrite_existing_buffers ()
 632 {
 633         /* This is safe as long as the butler thread is suspended, which it should be */
 634         _playback_buf->reset ();
 635
 636         g_atomic_int_set (&_frames_read_from_ringbuffer, 0);
 637         g_atomic_int_set (&_frames_written_to_ringbuffer, 0);
 638
 639         read (overwrite_frame, disk_io_chunk_frames, false);
 640         overwrite_queued = false;
 641         _pending_overwrite = false;
 642
 643         return 0;
 644 }
 645
 646 int
 647 MidiDiskstream::seek (framepos_t frame, bool complete_refill)
 648 {
 649         Glib::Mutex::Lock lm (state_lock);
 650         int ret = -1;
 651
 652         _playback_buf->reset();
 653         _capture_buf->reset();
 654         g_atomic_int_set(&_frames_read_from_ringbuffer, 0);
 655         g_atomic_int_set(&_frames_written_to_ringbuffer, 0);
 656
 657         playback_sample = frame;
 658         file_frame = frame;
 659
 660         if (complete_refill) {
 661                 while ((ret = do_refill_with_alloc ()) > 0) ;
 662         } else {
 663                 ret = do_refill_with_alloc ();
 664         }
 665
 666         return ret;
 667 }
 668
 669 int
 670 MidiDiskstream::can_internal_playback_seek (framecnt_t distance)
 671 {
 672         uint32_t frames_read    = g_atomic_int_get(&_frames_read_from_ringbuffer);
 673         uint32_t frames_written = g_atomic_int_get(&_frames_written_to_ringbuffer);
 674         return ((frames_written - frames_read) < distance);
 675 }
 676
 677 int
 678 MidiDiskstream::internal_playback_seek (framecnt_t distance)
 679 {
 680         first_recordable_frame += distance;
 681         playback_sample += distance;
 682
 683         return 0;
 684 }
 685
 686 /** @a start is set to the new frame position (TIME) read up to */
 687 int
 688 MidiDiskstream::read (framepos_t& start, framecnt_t dur, bool reversed)
 689 {
 690         framecnt_t this_read = 0;
 691         bool reloop = false;
 692         framepos_t loop_end = 0;
 693         framepos_t loop_start = 0;
 694         Location *loc = 0;
 695
 696         if (!reversed) {
 697
 698                 framecnt_t loop_length = 0;
 699
 700                 /* Make the use of a Location atomic for this read operation.
 701
 702                    Note: Locations don't get deleted, so all we care about
 703                    when I say "atomic" is that we are always pointing to
 704                    the same one and using a start/length values obtained
 705                    just once.
 706                 */
 707
 708                 if ((loc = loop_location) != 0) {
 709                         loop_start = loc->start();
 710                         loop_end = loc->end();
 711                         loop_length = loop_end - loop_start;
 712                 }
 713
 714                 /* if we are looping, ensure that the first frame we read is at the correct
 715                    position within the loop.
 716                 */
 717
 718                 if (loc && (start >= loop_end)) {
 719                         //cerr << "start adjusted from " << start;
 720                         start = loop_start + ((start - loop_start) % loop_length);
 721                         //cerr << "to " << start << endl;
 722                 }
 723                 //cerr << "start is " << start << "  loopstart: " << loop_start << "  loopend: " << loop_end << endl;
 724         }
 725
 726         while (dur) {
 727
 728                 /* take any loop into account. we can't read past the end of the loop. */
 729
 730                 if (loc && (loop_end - start < dur)) {
 731                         this_read = loop_end - start;
 732                         //cerr << "reloop true: thisread: " << this_read << "  dur: " << dur << endl;
 733                         reloop = true;
 734                 } else {
 735                         reloop = false;
 736                         this_read = dur;
 737                 }
 738
 739                 if (this_read == 0) {
 740                         break;
 741                 }
 742
 743                 this_read = min(dur,this_read);
 744
 745                 if (midi_playlist()->read (*_playback_buf, start, this_read) != this_read) {
 746                         error << string_compose(
 747                                         _("MidiDiskstream %1: cannot read %2 from playlist at frame %3"),
 748                                         _id, this_read, start) << endmsg;
 749                         return -1;
 750                 }
 751
 752                 g_atomic_int_add(&_frames_written_to_ringbuffer, this_read);
 753
 754                 _read_data_count = _playlist->read_data_count();
 755
 756                 if (reversed) {
 757
 758                         // Swap note ons with note offs here.  etc?
 759                         // Fully reversing MIDI requires look-ahead (well, behind) to find previous
 760                         // CC values etc.  hard.
 761
 762                 } else {
 763
 764                         /* if we read to the end of the loop, go back to the beginning */
 765
 766                         if (reloop) {
 767                                 // Synthesize LoopEvent here, because the next events
 768                                 // written will have non-monotonic timestamps.
 769                                 _playback_buf->write(loop_end - 1, LoopEventType, sizeof (framepos_t), (uint8_t *) &loop_start);
 770                                 start = loop_start;
 771                         } else {
 772                                 start += this_read;
 773                         }
 774                 }
 775
 776                 dur -= this_read;
 777                 //offset += this_read;
 778         }
 779
 780         return 0;
 781 }
 782
 783 int
 784 MidiDiskstream::do_refill_with_alloc ()
 785 {
 786         return do_refill();
 787 }
 788
 789 int
 790 MidiDiskstream::do_refill ()
 791 {
 792         int     ret         = 0;
 793         size_t  write_space = _playback_buf->write_space();
 794         bool    reversed    = (_visible_speed * _session.transport_speed()) < 0.0f;
 795
 796         if (write_space == 0) {
 797                 return 0;
 798         }
 799
 800         if (reversed) {
 801                 return 0;
 802         }
 803
 804         /* at end: nothing to do */
 805         if (file_frame == max_framepos) {
 806                 return 0;
 807         }
 808
 809         // At this point we...
 810         assert(_playback_buf->write_space() > 0); // ... have something to write to, and
 811         assert(file_frame <= max_framepos); // ... something to write
 812
 813         // now calculate how much time is in the ringbuffer.
 814         // and lets write as much as we need to get this to be midi_readahead;
 815         uint32_t frames_read = g_atomic_int_get(&_frames_read_from_ringbuffer);
 816         uint32_t frames_written = g_atomic_int_get(&_frames_written_to_ringbuffer);
 817         if ((frames_written - frames_read) >= midi_readahead) {
 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->drop_references ();
 941                         _write_source.reset();
 942                 }
 943
 944                 /* new source set up in "out" below */
 945
 946         } else {
 947
 948                 assert(_write_source);
 949
 950                 framecnt_t total_capture = 0;
 951                 for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
 952                         total_capture += (*ci)->frames;
 953                 }
 954
 955                 if (_write_source->length (capture_info.front()->start) != 0) {
 956
 957                         /* phew, we have data */
 958
 959                         /* figure out the name for this take */
 960
 961                         srcs.push_back (_write_source);
 962
 963                         _write_source->set_timeline_position (capture_info.front()->start);
 964                         _write_source->set_captured_for (_name);
 965
 966                         /* flush to disk: this step differs from the audio path,
 967                            where all the data is already on disk.
 968                         */
 969
 970                         _write_source->mark_streaming_write_completed ();
 971
 972                         /* set length in beats to entire capture length */
 973
 974                         BeatsFramesConverter converter (_session.tempo_map(), capture_info.front()->start);
 975                         const double total_capture_beats = converter.from(total_capture);
 976                         _write_source->set_length_beats(total_capture_beats);
 977
 978                         /* we will want to be able to keep (over)writing the source
 979                            but we don't want it to be removable. this also differs
 980                            from the audio situation, where the source at this point
 981                            must be considered immutable. luckily, we can rely on
 982                            MidiSource::mark_streaming_write_completed() to have
 983                            already done the necessary work for that.
 984                         */
 985
 986                         string whole_file_region_name;
 987                         whole_file_region_name = region_name_from_path (_write_source->name(), true);
 988
 989                         /* Register a new region with the Session that
 990                            describes the entire source. Do this first
 991                            so that any sub-regions will obviously be
 992                            children of this one (later!)
 993                         */
 994
 995                         try {
 996                                 PropertyList plist;
 997
 998                                 plist.add (Properties::name, whole_file_region_name);
 999                                 plist.add (Properties::whole_file, true);
1000                                 plist.add (Properties::automatic, true);
1001                                 plist.add (Properties::start, 0);
1002                                 plist.add (Properties::length, total_capture);
1003                                 plist.add (Properties::layer, 0);
1004
1005                                 boost::shared_ptr<Region> rx (RegionFactory::create (srcs, plist));
1006
1007                                 region = boost::dynamic_pointer_cast<MidiRegion> (rx);
1008                                 region->special_set_position (capture_info.front()->start);
1009                         }
1010
1011
1012                         catch (failed_constructor& err) {
1013                                 error << string_compose(_("%1: could not create region for complete midi file"), _name) << endmsg;
1014                                 /* XXX what now? */
1015                         }
1016
1017                         _last_capture_sources.insert (_last_capture_sources.end(), srcs.begin(), srcs.end());
1018
1019                         _playlist->clear_changes ();
1020                         _playlist->freeze ();
1021
1022                         /* Session frame time of the initial capture in this pass, which is where the source starts */
1023                         framepos_t initial_capture = 0;
1024                         if (!capture_info.empty()) {
1025                                 initial_capture = capture_info.front()->start;
1026                         }
1027
1028                         for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1029
1030                                 string region_name;
1031
1032                                 RegionFactory::region_name (region_name, _write_source->name(), false);
1033
1034                                 // cerr << _name << ": based on ci of " << (*ci)->start << " for " << (*ci)->frames << " add a region\n";
1035
1036                                 try {
1037                                         PropertyList plist;
1038
1039                                         /* start of this region is the offset between the start of its capture and the start of the whole pass */
1040                                         plist.add (Properties::start, (*ci)->start - initial_capture);
1041                                         plist.add (Properties::length, (*ci)->frames);
1042                                         plist.add (Properties::length_beats, converter.from((*ci)->frames));
1043                                         plist.add (Properties::name, region_name);
1044
1045                                         boost::shared_ptr<Region> rx (RegionFactory::create (srcs, plist));
1046                                         region = boost::dynamic_pointer_cast<MidiRegion> (rx);
1047                                 }
1048
1049                                 catch (failed_constructor& err) {
1050                                         error << _("MidiDiskstream: could not create region for captured midi!") << endmsg;
1051                                         continue; /* XXX is this OK? */
1052                                 }
1053
1054                                 // cerr << "add new region, buffer position = " << buffer_position << " @ " << (*ci)->start << endl;
1055
1056                                 i_am_the_modifier++;
1057                                 _playlist->add_region (region, (*ci)->start);
1058                                 i_am_the_modifier--;
1059                         }
1060
1061                         _playlist->thaw ();
1062                         _session.add_command (new StatefulDiffCommand(_playlist));
1063
1064                 } else {
1065
1066                         /* No data was recorded, so this capture will
1067                            effectively be aborted; do the same as we
1068                            do for an explicit abort.
1069                         */
1070
1071                         if (_write_source) {
1072                                 _write_source->mark_for_remove ();
1073                                 _write_source->drop_references ();
1074                                 _write_source.reset();
1075                         }
1076                 }
1077
1078
1079                 mark_write_completed = true;
1080         }
1081
1082         use_new_write_source (0);
1083
1084         for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1085                 delete *ci;
1086         }
1087
1088         if (_playlist) {
1089                 midi_playlist()->clear_note_trackers ();
1090         }
1091
1092         capture_info.clear ();
1093         capture_start_frame = 0;
1094 }
1095
1096 void
1097 MidiDiskstream::transport_looped (framepos_t transport_frame)
1098 {
1099         if (was_recording) {
1100
1101                 // adjust the capture length knowing that the data will be recorded to disk
1102                 // only necessary after the first loop where we're recording
1103                 if (capture_info.size() == 0) {
1104                         capture_captured += _capture_offset;
1105
1106                         if (_alignment_style == ExistingMaterial) {
1107                                 capture_captured += _session.worst_output_latency();
1108                         } else {
1109                                 capture_captured += _roll_delay;
1110                         }
1111                 }
1112
1113                 finish_capture (true);
1114
1115                 // the next region will start recording via the normal mechanism
1116                 // we'll set the start position to the current transport pos
1117                 // no latency adjustment or capture offset needs to be made, as that already happened the first time
1118                 capture_start_frame = transport_frame;
1119                 first_recordable_frame = transport_frame; // mild lie
1120                 last_recordable_frame = max_framepos;
1121                 was_recording = true;
1122         }
1123 }
1124
1125 void
1126 MidiDiskstream::finish_capture (bool /*rec_monitors_input*/)
1127 {
1128         was_recording = false;
1129
1130         if (capture_captured == 0) {
1131                 return;
1132         }
1133
1134         // Why must we destroy?
1135         assert(!destructive());
1136
1137         CaptureInfo* ci = new CaptureInfo;
1138
1139         ci->start  = capture_start_frame;
1140         ci->frames = capture_captured;
1141
1142         /* XXX theoretical race condition here. Need atomic exchange ?
1143            However, the circumstances when this is called right
1144            now (either on record-disable or transport_stopped)
1145            mean that no actual race exists. I think ...
1146            We now have a capture_info_lock, but it is only to be used
1147            to synchronize in the transport_stop and the capture info
1148            accessors, so that invalidation will not occur (both non-realtime).
1149         */
1150
1151         // cerr << "Finish capture, add new CI, " << ci->start << '+' << ci->frames << endl;
1152
1153         capture_info.push_back (ci);
1154         capture_captured = 0;
1155 }
1156
1157 void
1158 MidiDiskstream::set_record_enabled (bool yn)
1159 {
1160         if (!recordable() || !_session.record_enabling_legal()) {
1161                 return;
1162         }
1163
1164         assert(!destructive());
1165
1166         /* yes, i know that this not proof against race conditions, but its
1167            good enough. i think.
1168         */
1169
1170         if (record_enabled() != yn) {
1171                 if (yn) {
1172                         engage_record_enable ();
1173                 } else {
1174                         disengage_record_enable ();
1175                 }
1176         }
1177 }
1178
1179 void
1180 MidiDiskstream::engage_record_enable ()
1181 {
1182         bool const rolling = _session.transport_speed() != 0.0f;
1183
1184         g_atomic_int_set (&_record_enabled, 1);
1185
1186         if (_source_port && Config->get_monitoring_model() == HardwareMonitoring) {
1187                 _source_port->request_monitor_input (!(_session.config.get_auto_input() && rolling));
1188         }
1189
1190         RecordEnableChanged (); /* EMIT SIGNAL */
1191 }
1192
1193 void
1194 MidiDiskstream::disengage_record_enable ()
1195 {
1196         g_atomic_int_set (&_record_enabled, 0);
1197         RecordEnableChanged (); /* EMIT SIGNAL */
1198 }
1199
1200 XMLNode&
1201 MidiDiskstream::get_state ()
1202 {
1203         XMLNode& node (Diskstream::get_state());
1204         char buf[64];
1205         LocaleGuard lg (X_("POSIX"));
1206
1207         node.add_property("channel-mode", enum_2_string(get_channel_mode()));
1208         snprintf (buf, sizeof(buf), "0x%x", get_channel_mask());
1209         node.add_property("channel-mask", buf);
1210
1211         if (_write_source && _session.get_record_enabled()) {
1212
1213                 XMLNode* cs_child = new XMLNode (X_("CapturingSources"));
1214                 XMLNode* cs_grandchild;
1215
1216                 cs_grandchild = new XMLNode (X_("file"));
1217                 cs_grandchild->add_property (X_("path"), _write_source->path());
1218                 cs_child->add_child_nocopy (*cs_grandchild);
1219
1220                 /* store the location where capture will start */
1221
1222                 Location* pi;
1223
1224                 if (_session.config.get_punch_in() && ((pi = _session.locations()->auto_punch_location()) != 0)) {
1225                         snprintf (buf, sizeof (buf), "%" PRId64, pi->start());
1226                 } else {
1227                         snprintf (buf, sizeof (buf), "%" PRId64, _session.transport_frame());
1228                 }
1229
1230                 cs_child->add_property (X_("at"), buf);
1231                 node.add_child_nocopy (*cs_child);
1232         }
1233
1234         return node;
1235 }
1236
1237 int
1238 MidiDiskstream::set_state (const XMLNode& node, int version)
1239 {
1240         const XMLProperty* prop;
1241         XMLNodeList nlist = node.children();
1242         XMLNodeIterator niter;
1243         XMLNode* capture_pending_node = 0;
1244         LocaleGuard lg (X_("POSIX"));
1245
1246         /* prevent write sources from being created */
1247
1248         in_set_state = true;
1249
1250         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1251                 assert ((*niter)->name() != IO::state_node_name);
1252
1253                 if ((*niter)->name() == X_("CapturingSources")) {
1254                         capture_pending_node = *niter;
1255                 }
1256         }
1257
1258         if (Diskstream::set_state (node, version)) {
1259                 return -1;
1260         }
1261
1262         ChannelMode channel_mode = AllChannels;
1263         if ((prop = node.property ("channel-mode")) != 0) {
1264                 channel_mode = ChannelMode (string_2_enum(prop->value(), channel_mode));
1265         }
1266
1267         unsigned int channel_mask = 0xFFFF;
1268         if ((prop = node.property ("channel-mask")) != 0) {
1269                 sscanf (prop->value().c_str(), "0x%x", &channel_mask);
1270                 if (channel_mask & (~0xFFFF)) {
1271                         warning << _("MidiDiskstream: XML property channel-mask out of range") << endmsg;
1272                 }
1273         }
1274
1275
1276         if (capture_pending_node) {
1277                 use_pending_capture_data (*capture_pending_node);
1278         }
1279
1280         set_channel_mode (channel_mode, channel_mask);
1281
1282         in_set_state = false;
1283
1284         return 0;
1285 }
1286
1287 int
1288 MidiDiskstream::use_new_write_source (uint32_t n)
1289 {
1290         if (!_session.writable() || !recordable()) {
1291                 return 1;
1292         }
1293
1294         assert(n == 0);
1295
1296         _write_source.reset();
1297
1298         try {
1299                 _write_source = boost::dynamic_pointer_cast<SMFSource>(
1300                         _session.create_midi_source_for_session (0, name ()));
1301
1302                 if (!_write_source) {
1303                         throw failed_constructor();
1304                 }
1305         }
1306
1307         catch (failed_constructor &err) {
1308                 error << string_compose (_("%1:%2 new capture file not initialized correctly"), _name, n) << endmsg;
1309                 _write_source.reset();
1310                 return -1;
1311         }
1312
1313         return 0;
1314 }
1315
1316 list<boost::shared_ptr<Source> >
1317 MidiDiskstream::steal_write_sources()
1318 {
1319         list<boost::shared_ptr<Source> > ret;
1320
1321         /* put some data on the disk, even if its just a header for an empty file.
1322            XXX should we not have a more direct method for doing this? Maybe not
1323            since we don't want to mess around with the model/disk relationship
1324            that the Source has to pay attention to.
1325         */
1326
1327         boost::dynamic_pointer_cast<MidiSource>(_write_source)->session_saved ();
1328
1329         /* never let it go away */
1330         _write_source->mark_nonremovable ();
1331
1332         ret.push_back (_write_source);
1333
1334         /* get a new one */
1335
1336         use_new_write_source (0);
1337
1338         return ret;
1339 }
1340
1341 void
1342 MidiDiskstream::reset_write_sources (bool mark_write_complete, bool /*force*/)
1343 {
1344         if (!_session.writable() || !recordable()) {
1345                 return;
1346         }
1347
1348         if (_write_source && mark_write_complete) {
1349                 _write_source->mark_streaming_write_completed ();
1350         }
1351         use_new_write_source (0);
1352 }
1353
1354 int
1355 MidiDiskstream::rename_write_sources ()
1356 {
1357         if (_write_source != 0) {
1358                 _write_source->set_source_name (_name.val(), destructive());
1359                 /* XXX what to do if this fails ? */
1360         }
1361         return 0;
1362 }
1363
1364 void
1365 MidiDiskstream::set_block_size (pframes_t /*nframes*/)
1366 {
1367 }
1368
1369 void
1370 MidiDiskstream::allocate_temporary_buffers ()
1371 {
1372 }
1373
1374 void
1375 MidiDiskstream::monitor_input (bool yn)
1376 {
1377         if (_source_port)
1378                 _source_port->ensure_monitor_input (yn);
1379 }
1380
1381 void
1382 MidiDiskstream::set_align_style_from_io ()
1383 {
1384         bool have_physical = false;
1385
1386         if (_alignment_choice != Automatic) {
1387                 return;
1388         }
1389
1390         if (_io == 0) {
1391                 return;
1392         }
1393
1394         get_input_sources ();
1395
1396         if (_source_port && _source_port->flags() & JackPortIsPhysical) {
1397                 have_physical = true;
1398         }
1399
1400         if (have_physical) {
1401                 set_align_style (ExistingMaterial);
1402         } else {
1403                 set_align_style (CaptureTime);
1404         }
1405 }
1406
1407
1408 float
1409 MidiDiskstream::playback_buffer_load () const
1410 {
1411         return (float) ((double) _playback_buf->read_space()/
1412                         (double) _playback_buf->capacity());
1413 }
1414
1415 float
1416 MidiDiskstream::capture_buffer_load () const
1417 {
1418         return (float) ((double) _capture_buf->write_space()/
1419                         (double) _capture_buf->capacity());
1420 }
1421
1422 int
1423 MidiDiskstream::use_pending_capture_data (XMLNode& /*node*/)
1424 {
1425         return 0;
1426 }
1427
1428 /** Writes playback events in the given range to \a dst, translating time stamps
1429  * so that an event at \a start has time = 0
1430  */
1431 void
1432 MidiDiskstream::get_playback (MidiBuffer& dst, framepos_t start, framepos_t end)
1433 {
1434         dst.clear();
1435         assert(dst.size() == 0);
1436
1437         // Reverse.  ... We just don't do reverse, ok?  Back off.
1438         if (end <= start) {
1439                 return;
1440         }
1441
1442         // Translates stamps to be relative to start
1443
1444
1445 #ifndef NDEBUG
1446         const size_t events_read = _playback_buf->read(dst, start, end);
1447         DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("%1 MDS events read %2 range %3 .. %4 rspace %5 wspace %6\n", _name, events_read, start, end,
1448                                                               _playback_buf->read_space(), _playback_buf->write_space()));
1449 #else
1450         _playback_buf->read(dst, start, end);
1451 #endif
1452
1453         gint32 frames_read = end - start;
1454         g_atomic_int_add(&_frames_read_from_ringbuffer, frames_read);
1455 }
1456