libs/ardour/midi_track.cc

   1 /*
   2     Copyright (C) 2006 Paul Davis
   3     Author: David Robillard
   4
   5     This program is free software; you can redistribute it and/or modify
   6     it under the terms of the GNU General Public License as published by
   7     the Free Software Foundation; either version 2 of the License, or
   8     (at your option) any later version.
   9
  10     This program is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13     GNU General Public License for more details.
  14
  15     You should have received a copy of the GNU General Public License
  16     along with this program; if not, write to the Free Software
  17     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18 */
  19
  20 #include "pbd/error.h"
  21
  22 #include "pbd/enumwriter.h"
  23 #include "pbd/convert.h"
  24 #include "midi++/events.h"
  25 #include "evoral/midi_util.h"
  26
  27 #include "ardour/amp.h"
  28 #include "ardour/buffer_set.h"
  29 #include "ardour/debug.h"
  30 #include "ardour/delivery.h"
  31 #include "ardour/io_processor.h"
  32 #include "ardour/meter.h"
  33 #include "ardour/midi_diskstream.h"
  34 #include "ardour/midi_playlist.h"
  35 #include "ardour/midi_port.h"
  36 #include "ardour/midi_region.h"
  37 #include "ardour/midi_source.h"
  38 #include "ardour/midi_track.h"
  39 #include "ardour/panner.h"
  40 #include "ardour/port.h"
  41 #include "ardour/processor.h"
  42 #include "ardour/route_group_specialized.h"
  43 #include "ardour/session.h"
  44 #include "ardour/session_playlists.h"
  45 #include "ardour/utils.h"
  46
  47 #include "i18n.h"
  48
  49 using namespace std;
  50 using namespace ARDOUR;
  51 using namespace PBD;
  52
  53 MidiTrack::MidiTrack (Session& sess, string name, Route::Flag flag, TrackMode mode)
  54         : Track (sess, name, flag, mode, DataType::MIDI)
  55         , _immediate_events(1024) // FIXME: size?
  56         , _step_edit_ring_buffer(64) // FIXME: size?
  57         , _note_mode(Sustained)
  58         , _step_editing (false)
  59         , _midi_thru (true)
  60         , _input_active (true)
  61 {
  62 }
  63
  64 MidiTrack::~MidiTrack ()
  65 {
  66 }
  67
  68 int
  69 MidiTrack::init ()
  70 {
  71         if (Track::init ()) {
  72                 return -1;
  73         }
  74
  75         _input->changed.connect_same_thread (*this, boost::bind (&MidiTrack::track_input_active, this, _1, _2));
  76
  77         return 0;
  78 }
  79
  80 boost::shared_ptr<Diskstream>
  81 MidiTrack::create_diskstream ()
  82 {
  83         MidiDiskstream::Flag dflags = MidiDiskstream::Flag (0);
  84
  85         if (_flags & Hidden) {
  86                 dflags = MidiDiskstream::Flag (dflags | MidiDiskstream::Hidden);
  87         } else {
  88                 dflags = MidiDiskstream::Flag (dflags | MidiDiskstream::Recordable);
  89         }
  90
  91         assert(_mode != Destructive);
  92
  93         return boost::shared_ptr<Diskstream> (new MidiDiskstream (_session, name(), dflags));
  94 }
  95
  96
  97 void
  98 MidiTrack::set_record_enabled (bool yn, void *src)
  99 {
 100         if (_step_editing) {
 101                 return;
 102         }
 103
 104         Track::set_record_enabled (yn, src);
 105 }
 106
 107 void
 108 MidiTrack::set_diskstream (boost::shared_ptr<Diskstream> ds)
 109 {
 110         Track::set_diskstream (ds);
 111
 112         _diskstream->set_track (this);
 113         _diskstream->set_destructive (_mode == Destructive);
 114
 115         _diskstream->set_record_enabled (false);
 116         //_diskstream->monitor_input (false);
 117
 118         _diskstream_data_recorded_connection.disconnect ();
 119         boost::shared_ptr<MidiDiskstream> mds = boost::dynamic_pointer_cast<MidiDiskstream> (ds);
 120         mds->DataRecorded.connect_same_thread (
 121                 _diskstream_data_recorded_connection,
 122                 boost::bind (&MidiTrack::diskstream_data_recorded, this, _1));
 123
 124         DiskstreamChanged (); /* EMIT SIGNAL */
 125 }
 126
 127 boost::shared_ptr<MidiDiskstream>
 128 MidiTrack::midi_diskstream() const
 129 {
 130         return boost::dynamic_pointer_cast<MidiDiskstream>(_diskstream);
 131 }
 132
 133 int
 134 MidiTrack::set_state (const XMLNode& node, int version)
 135 {
 136         const XMLProperty *prop;
 137
 138         if (Track::set_state (node, version)) {
 139                 return -1;
 140         }
 141
 142         // No destructive MIDI tracks (yet?)
 143         _mode = Normal;
 144
 145         if ((prop = node.property (X_("note-mode"))) != 0) {
 146                 _note_mode = NoteMode (string_2_enum (prop->value(), _note_mode));
 147         } else {
 148                 _note_mode = Sustained;
 149         }
 150
 151         if ((prop = node.property ("midi-thru")) != 0) {
 152                 set_midi_thru (string_is_affirmative (prop->value()));
 153         }
 154
 155         if ((prop = node.property ("input-active")) != 0) {
 156                 set_input_active (string_is_affirmative (prop->value()));
 157         }
 158
 159         pending_state = const_cast<XMLNode*> (&node);
 160
 161         if (_session.state_of_the_state() & Session::Loading) {
 162                 _session.StateReady.connect_same_thread (
 163                         *this, boost::bind (&MidiTrack::set_state_part_two, this));
 164         } else {
 165                 set_state_part_two ();
 166         }
 167
 168         return 0;
 169 }
 170
 171 XMLNode&
 172 MidiTrack::state(bool full_state)
 173 {
 174         XMLNode& root (Track::state(full_state));
 175         XMLNode* freeze_node;
 176         char buf[64];
 177
 178         if (_freeze_record.playlist) {
 179                 XMLNode* inode;
 180
 181                 freeze_node = new XMLNode (X_("freeze-info"));
 182                 freeze_node->add_property ("playlist", _freeze_record.playlist->name());
 183                 freeze_node->add_property ("state", enum_2_string (_freeze_record.state));
 184
 185                 for (vector<FreezeRecordProcessorInfo*>::iterator i = _freeze_record.processor_info.begin(); i != _freeze_record.processor_info.end(); ++i) {
 186                         inode = new XMLNode (X_("processor"));
 187                         (*i)->id.print (buf, sizeof(buf));
 188                         inode->add_property (X_("id"), buf);
 189                         inode->add_child_copy ((*i)->state);
 190
 191                         freeze_node->add_child_nocopy (*inode);
 192                 }
 193
 194                 root.add_child_nocopy (*freeze_node);
 195         }
 196
 197         root.add_property (X_("note-mode"), enum_2_string (_note_mode));
 198
 199         root.add_property ("step-editing", (_step_editing ? "yes" : "no"));
 200         root.add_property ("note-mode", enum_2_string (_note_mode));
 201         root.add_property ("midi-thru", (_midi_thru ? "yes" : "no"));
 202         root.add_property ("input-active", (_input_active ? "yes" : "no"));
 203
 204         return root;
 205 }
 206
 207 void
 208 MidiTrack::set_state_part_two ()
 209 {
 210         XMLNode* fnode;
 211         XMLProperty* prop;
 212         LocaleGuard lg (X_("POSIX"));
 213
 214         /* This is called after all session state has been restored but before
 215            have been made ports and connections are established.
 216         */
 217
 218         if (pending_state == 0) {
 219                 return;
 220         }
 221
 222         if ((fnode = find_named_node (*pending_state, X_("freeze-info"))) != 0) {
 223
 224                 _freeze_record.state = Frozen;
 225
 226                 for (vector<FreezeRecordProcessorInfo*>::iterator i = _freeze_record.processor_info.begin(); i != _freeze_record.processor_info.end(); ++i) {
 227                         delete *i;
 228                 }
 229                 _freeze_record.processor_info.clear ();
 230
 231                 if ((prop = fnode->property (X_("playlist"))) != 0) {
 232                         boost::shared_ptr<Playlist> pl = _session.playlists->by_name (prop->value());
 233                         if (pl) {
 234                                 _freeze_record.playlist = boost::dynamic_pointer_cast<MidiPlaylist> (pl);
 235                         } else {
 236                                 _freeze_record.playlist.reset();
 237                                 _freeze_record.state = NoFreeze;
 238                         return;
 239                         }
 240                 }
 241
 242                 if ((prop = fnode->property (X_("state"))) != 0) {
 243                         _freeze_record.state = FreezeState (string_2_enum (prop->value(), _freeze_record.state));
 244                 }
 245
 246                 XMLNodeConstIterator citer;
 247                 XMLNodeList clist = fnode->children();
 248
 249                 for (citer = clist.begin(); citer != clist.end(); ++citer) {
 250                         if ((*citer)->name() != X_("processor")) {
 251                                 continue;
 252                         }
 253
 254                         if ((prop = (*citer)->property (X_("id"))) == 0) {
 255                                 continue;
 256                         }
 257
 258                         FreezeRecordProcessorInfo* frii = new FreezeRecordProcessorInfo (*((*citer)->children().front()),
 259                                                                                    boost::shared_ptr<Processor>());
 260                         frii->id = prop->value ();
 261                         _freeze_record.processor_info.push_back (frii);
 262                 }
 263         }
 264
 265         if (midi_diskstream ()) {
 266                 midi_diskstream()->set_block_size (_session.get_block_size ());
 267         }
 268
 269         return;
 270 }
 271
 272 int
 273 MidiTrack::roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, int declick, bool& need_butler)
 274 {
 275         Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
 276         if (!lm.locked()) {
 277                 return 0;
 278         }
 279
 280         boost::shared_ptr<MidiDiskstream> diskstream = midi_diskstream();
 281
 282         automation_snapshot (start_frame);
 283
 284         if (n_outputs().n_total() == 0 && _processors.empty()) {
 285                 return 0;
 286         }
 287
 288         if (!_active) {
 289                 silence (nframes);
 290                 return 0;
 291         }
 292
 293         framepos_t transport_frame = _session.transport_frame();
 294
 295         int dret;
 296         framecnt_t playback_distance;
 297
 298         if ((nframes = check_initial_delay (nframes, transport_frame)) == 0) {
 299                 /* need to do this so that the diskstream sets its
 300                    playback distance to zero, thus causing diskstream::commit
 301                    to do nothing.
 302                    */
 303                 dret = diskstream->process (transport_frame, 0, playback_distance);
 304                 need_butler = diskstream->commit (playback_distance);
 305                 return dret;
 306         }
 307
 308         _silent = false;
 309
 310         if ((dret = diskstream->process (transport_frame, nframes, playback_distance)) != 0) {
 311                 need_butler = diskstream->commit (playback_distance);
 312                 silence (nframes);
 313                 return dret;
 314         }
 315
 316         /* special condition applies */
 317
 318         if (_meter_point == MeterInput) {
 319                 _input->process_input (_meter, start_frame, end_frame, nframes);
 320         }
 321
 322         if (monitoring_state() == MonitoringInput) {
 323
 324                 /* not actually recording, but we want to hear the input material anyway,
 325                    at least potentially (depending on monitoring options)
 326                 */
 327
 328                 passthru (start_frame, end_frame, nframes, 0);
 329
 330         } else {
 331                 /*
 332                    XXX is it true that the earlier test on n_outputs()
 333                    means that we can avoid checking it again here? i think
 334                    so, because changing the i/o configuration of an IO
 335                    requires holding the AudioEngine lock, which we hold
 336                    while in the process() tree.
 337                    */
 338
 339
 340                 /* copy the diskstream data to all output buffers */
 341
 342                 //const size_t limit = n_process_buffers().n_audio();
 343                 BufferSet& bufs = _session.get_scratch_buffers (n_process_buffers());
 344                 MidiBuffer& mbuf (bufs.get_midi (0));
 345
 346                 /* we are a MIDI track, so we always start the chain with a single-channel diskstream */
 347                 ChanCount c;
 348                 c.set_audio (0);
 349                 c.set_midi (1);
 350                 bufs.set_count (c);
 351
 352                 diskstream->get_playback (mbuf, nframes);
 353
 354                 /* append immediate messages to the first MIDI buffer (thus sending it to the first output port) */
 355
 356                 write_out_of_band_data (bufs, start_frame, end_frame, nframes);
 357
 358                 /* final argument: don't waste time with automation if we're recording or we've just stopped (yes it can happen) */
 359
 360                 process_output_buffers (
 361                         bufs, start_frame, end_frame, nframes,
 362                         declick, (!diskstream->record_enabled() && !_session.transport_stopped())
 363                         );
 364         }
 365
 366         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
 367                 boost::shared_ptr<Delivery> d = boost::dynamic_pointer_cast<Delivery> (*i);
 368                 if (d) {
 369                         d->flush_buffers (nframes, end_frame - start_frame - 1);
 370                 }
 371         }
 372
 373         need_butler = diskstream->commit (playback_distance);
 374
 375         return 0;
 376 }
 377
 378 int
 379 MidiTrack::no_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, bool state_changing)
 380 {
 381         int ret = Track::no_roll (nframes, start_frame, end_frame, state_changing);
 382
 383         if (ret == 0 && _step_editing) {
 384                 push_midi_input_to_step_edit_ringbuffer (nframes);
 385         }
 386
 387         return ret;
 388 }
 389
 390 void
 391 MidiTrack::realtime_locate ()
 392 {
 393         Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
 394         if (!lm.locked ()) {
 395                 return;
 396         }
 397
 398         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
 399                 (*i)->realtime_locate ();
 400         }
 401 }
 402
 403 void
 404 MidiTrack::realtime_handle_transport_stopped ()
 405 {
 406         Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
 407         if (!lm.locked ()) {
 408                 return;
 409         }
 410
 411         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
 412                 (*i)->realtime_handle_transport_stopped ();
 413         }
 414 }
 415
 416 void
 417 MidiTrack::push_midi_input_to_step_edit_ringbuffer (framecnt_t nframes)
 418 {
 419         PortSet& ports (_input->ports());
 420
 421         for (PortSet::iterator p = ports.begin(DataType::MIDI); p != ports.end(DataType::MIDI); ++p) {
 422
 423                 Buffer& b (p->get_buffer (nframes));
 424                 const MidiBuffer* const mb = dynamic_cast<MidiBuffer*>(&b);
 425                 assert (mb);
 426
 427                 for (MidiBuffer::const_iterator e = mb->begin(); e != mb->end(); ++e) {
 428
 429                         const Evoral::MIDIEvent<framepos_t> ev(*e, false);
 430
 431                         /* note on, since for step edit, note length is determined
 432                            elsewhere
 433                         */
 434
 435                         if (ev.is_note_on()) {
 436                                 /* we don't care about the time for this purpose */
 437                                 _step_edit_ring_buffer.write (0, ev.type(), ev.size(), ev.buffer());
 438                         }
 439                 }
 440         }
 441 }
 442
 443 void
 444 MidiTrack::write_out_of_band_data (BufferSet& bufs, framepos_t /*start*/, framepos_t /*end*/, framecnt_t nframes)
 445 {
 446         MidiBuffer& buf (bufs.get_midi (0));
 447
 448         // Append immediate events
 449
 450         if (_immediate_events.read_space()) {
 451
 452                 DEBUG_TRACE (DEBUG::MidiIO, string_compose ("%1 has %2 of immediate events to deliver\n",
 453                                                             name(), _immediate_events.read_space()));
 454
 455                 /* write as many of the immediate events as we can, but give "true" as
 456                  * the last argument ("stop on overflow in destination") so that we'll
 457                  * ship the rest out next time.
 458                  *
 459                  * the (nframes-1) argument puts all these events at the last
 460                  * possible position of the output buffer, so that we do not
 461                  * violate monotonicity when writing.
 462                  */
 463
 464                 _immediate_events.read (buf, 0, 1, nframes-1, true);
 465         }
 466
 467         // MIDI thru: send incoming data "through" output
 468         if (_midi_thru && _session.transport_speed() != 0.0f && _input->n_ports().n_midi()) {
 469                 buf.merge_in_place (_input->midi(0)->get_midi_buffer(nframes));
 470         }
 471 }
 472
 473 int
 474 MidiTrack::export_stuff (BufferSet& /*bufs*/, framecnt_t /*nframes*/, framepos_t /*end_frame*/)
 475 {
 476         return -1;
 477 }
 478
 479 boost::shared_ptr<Region>
 480 MidiTrack::bounce (InterThreadInfo& /*itt*/)
 481 {
 482         std::cerr << "MIDI bounce currently unsupported" << std::endl;
 483         return boost::shared_ptr<Region> ();
 484 }
 485
 486
 487 boost::shared_ptr<Region>
 488 MidiTrack::bounce_range (framepos_t /*start*/, framepos_t /*end*/, InterThreadInfo& /*itt*/, bool /*enable_processing*/)
 489 {
 490         std::cerr << "MIDI bounce range currently unsupported" << std::endl;
 491         return boost::shared_ptr<Region> ();
 492 }
 493
 494 void
 495 MidiTrack::freeze_me (InterThreadInfo& /*itt*/)
 496 {
 497         std::cerr << "MIDI freeze currently unsupported" << std::endl;
 498 }
 499
 500 void
 501 MidiTrack::unfreeze ()
 502 {
 503         _freeze_record.state = UnFrozen;
 504         FreezeChange (); /* EMIT SIGNAL */
 505 }
 506
 507 void
 508 MidiTrack::set_note_mode (NoteMode m)
 509 {
 510         _note_mode = m;
 511         midi_diskstream()->set_note_mode(m);
 512 }
 513
 514 void
 515 MidiTrack::midi_panic()
 516 {
 517         DEBUG_TRACE (DEBUG::MidiIO, string_compose ("%1 delivers panic data\n", name()));
 518         for (uint8_t channel = 0; channel <= 0xF; channel++) {
 519                 uint8_t ev[3] = { MIDI_CMD_CONTROL | channel, MIDI_CTL_SUSTAIN, 0 };
 520                 write_immediate_event(3, ev);
 521                 ev[1] = MIDI_CTL_ALL_NOTES_OFF;
 522                 write_immediate_event(3, ev);
 523                 ev[1] = MIDI_CTL_RESET_CONTROLLERS;
 524                 write_immediate_event(3, ev);
 525         }
 526 }
 527
 528 /** \return true on success, false on failure (no buffer space left)
 529  */
 530 bool
 531 MidiTrack::write_immediate_event(size_t size, const uint8_t* buf)
 532 {
 533         if (!Evoral::midi_event_is_valid(buf, size)) {
 534                 cerr << "WARNING: Ignoring illegal immediate MIDI event" << endl;
 535                 return false;
 536         }
 537         const uint32_t type = EventTypeMap::instance().midi_event_type(buf[0]);
 538         return (_immediate_events.write(0, type, size, buf) == size);
 539 }
 540
 541 void
 542 MidiTrack::MidiControl::set_value(double val)
 543 {
 544         bool valid = false;
 545         if (isinf(val)) {
 546                 cerr << "MIDIControl value is infinity" << endl;
 547         } else if (isnan(val)) {
 548                 cerr << "MIDIControl value is NaN" << endl;
 549         } else if (val < _list->parameter().min()) {
 550                 cerr << "MIDIControl value is < " << _list->parameter().min() << endl;
 551         } else if (val > _list->parameter().max()) {
 552                 cerr << "MIDIControl value is > " << _list->parameter().max() << endl;
 553         } else {
 554                 valid = true;
 555         }
 556
 557         if (!valid) {
 558                 return;
 559         }
 560
 561         assert(val <= _list->parameter().max());
 562         if ( ! automation_playback()) {
 563                 size_t size = 3;
 564                 uint8_t ev[3] = { _list->parameter().channel(), int(val), 0 };
 565                 switch(_list->parameter().type()) {
 566                 case MidiCCAutomation:
 567                         ev[0] += MIDI_CMD_CONTROL;
 568                         ev[1] = _list->parameter().id();
 569                         ev[2] = int(val);
 570                         break;
 571
 572                 case MidiPgmChangeAutomation:
 573                         size = 2;
 574                         ev[0] += MIDI_CMD_PGM_CHANGE;
 575                         ev[1] = int(val);
 576                         break;
 577
 578                 case MidiChannelPressureAutomation:
 579                         size = 2;
 580                         ev[0] += MIDI_CMD_CHANNEL_PRESSURE;
 581                         ev[1] = int(val);
 582                         break;
 583
 584                 case MidiPitchBenderAutomation:
 585                         ev[0] += MIDI_CMD_BENDER;
 586                         ev[1] = 0x7F & int(val);
 587                         ev[2] = 0x7F & (int(val) >> 7);
 588                         break;
 589
 590                 default:
 591                         assert(false);
 592                 }
 593                 _route->write_immediate_event(size,  ev);
 594         }
 595
 596         AutomationControl::set_value(val);
 597 }
 598
 599 void
 600 MidiTrack::set_step_editing (bool yn)
 601 {
 602         if (_session.record_status() != Session::Disabled) {
 603                 return;
 604         }
 605
 606         if (yn != _step_editing) {
 607                 _step_editing = yn;
 608                 StepEditStatusChange (yn);
 609         }
 610 }
 611
 612 void
 613 MidiTrack::set_midi_thru (bool yn)
 614 {
 615         _midi_thru = yn;
 616 }
 617
 618 boost::shared_ptr<SMFSource>
 619 MidiTrack::write_source (uint32_t)
 620 {
 621         return midi_diskstream()->write_source ();
 622 }
 623
 624 void
 625 MidiTrack::set_channel_mode (ChannelMode mode, uint16_t mask)
 626 {
 627         midi_diskstream()->set_channel_mode (mode, mask);
 628 }
 629
 630 ChannelMode
 631 MidiTrack::get_channel_mode ()
 632 {
 633         return midi_diskstream()->get_channel_mode ();
 634 }
 635
 636 uint16_t
 637 MidiTrack::get_channel_mask ()
 638 {
 639         return midi_diskstream()->get_channel_mask ();
 640 }
 641
 642 boost::shared_ptr<MidiPlaylist>
 643 MidiTrack::midi_playlist ()
 644 {
 645         return midi_diskstream()->midi_playlist ();
 646 }
 647
 648 void
 649 MidiTrack::diskstream_data_recorded (boost::weak_ptr<MidiSource> src)
 650 {
 651         DataRecorded (src); /* EMIT SIGNAL */
 652 }
 653
 654 bool
 655 MidiTrack::should_monitor () const
 656 {
 657         return true;
 658 }
 659
 660 bool
 661 MidiTrack::send_silence () const
 662 {
 663         return false;
 664 }
 665
 666 bool
 667 MidiTrack::input_active () const
 668 {
 669         return _input_active;
 670 }
 671
 672 void
 673 MidiTrack::set_input_active (bool yn)
 674 {
 675         if (yn != _input_active) {
 676                 _input_active = yn;
 677                 map_input_active (yn);
 678                 InputActiveChanged (); /* EMIT SIGNAL */
 679         }
 680 }
 681
 682 void
 683 MidiTrack::map_input_active (bool yn)
 684 {
 685         if (!_input) {
 686                 return;
 687         }
 688
 689         PortSet& ports (_input->ports());
 690
 691         for (PortSet::iterator p = ports.begin(DataType::MIDI); p != ports.end(DataType::MIDI); ++p) {
 692                 boost::shared_ptr<MidiPort> mp = boost::dynamic_pointer_cast<MidiPort> (*p);
 693                 if (yn != mp->input_active()) {
 694                         mp->set_input_active (yn);
 695                 }
 696         }
 697 }
 698
 699 void
 700 MidiTrack::track_input_active (IOChange change, void* /* src */)
 701 {
 702         if (change.type & IOChange::ConfigurationChanged) {
 703                 map_input_active (_input_active);
 704         }
 705 }
 706
 707 boost::shared_ptr<Diskstream>
 708 MidiTrack::diskstream_factory (XMLNode const & node)
 709 {
 710         return boost::shared_ptr<Diskstream> (new MidiDiskstream (_session, node));
 711 }
 712
 713 boost::shared_ptr<MidiBuffer>
 714 MidiTrack::get_gui_feed_buffer () const
 715 {
 716         return midi_diskstream()->get_gui_feed_buffer ();
 717 }
 718
 719 void
 720 MidiTrack::act_on_mute ()
 721 {
 722         /* this is called right after our mute status has changed.
 723            if we are now muted, send suitable output to shutdown
 724            all our notes.
 725
 726            XXX we should should also stop all relevant note trackers.
 727         */
 728
 729         if (muted()) {
 730                 /* only send messages for channels we are using */
 731
 732                 uint16_t mask = get_channel_mask();
 733
 734                 for (uint8_t channel = 0; channel <= 0xF; channel++) {
 735
 736                         if ((1<<channel) & mask) {
 737
 738                                 DEBUG_TRACE (DEBUG::MidiIO, string_compose ("%1 delivers mute message to channel %2\n", name(), channel+1));
 739                                 uint8_t ev[3] = { MIDI_CMD_CONTROL | channel, MIDI_CTL_SUSTAIN, 0 };
 740                                 write_immediate_event (3, ev);
 741                                 ev[1] = MIDI_CTL_ALL_NOTES_OFF;
 742                                 write_immediate_event (3, ev);
 743                         }
 744                 }
 745         }
 746 }
 747