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