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