X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fmidi_track.cc;h=a6ff1b93f42fa6d1c4696c3b7cc912563d2c4ac6;hb=498afeb63edeb8a5ce0103296ffda4216d64186d;hp=d7d1dae96532db15543b88c98627209b215d4dbe;hpb=0cdb918d4dd409075c0e2fdc50633e7b6adb22f2;p=ardour.git diff --git a/libs/ardour/midi_track.cc b/libs/ardour/midi_track.cc index d7d1dae965..a6ff1b93f4 100644 --- a/libs/ardour/midi_track.cc +++ b/libs/ardour/midi_track.cc @@ -16,22 +16,30 @@ along with this program; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ -#include +#include "pbd/error.h" #include #include #include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include +#include "pbd/enumwriter.h" +#include "midi++/events.h" +#include "evoral/midi_util.h" + +#include "ardour/amp.h" +#include "ardour/buffer_set.h" +#include "ardour/delivery.h" +#include "ardour/io_processor.h" +#include "ardour/meter.h" +#include "ardour/midi_diskstream.h" +#include "ardour/midi_playlist.h" +#include "ardour/midi_region.h" +#include "ardour/midi_source.h" +#include "ardour/midi_track.h" +#include "ardour/panner.h" +#include "ardour/processor.h" +#include "ardour/route_group_specialized.h" +#include "ardour/session.h" +#include "ardour/utils.h" #include "i18n.h" @@ -40,73 +48,63 @@ using namespace ARDOUR; using namespace PBD; MidiTrack::MidiTrack (Session& sess, string name, Route::Flag flag, TrackMode mode) - : Track (sess, name, flag, mode, Buffer::MIDI) + : Track (sess, name, flag, mode, DataType::MIDI) + , _immediate_events(1024) // FIXME: size? + , _note_mode(Sustained) { - MidiDiskstream::Flag dflags = MidiDiskstream::Flag (0); - - if (_flags & Hidden) { - dflags = MidiDiskstream::Flag (dflags | MidiDiskstream::Hidden); - } else { - dflags = MidiDiskstream::Flag (dflags | MidiDiskstream::Recordable); - } - - if (mode == Destructive) { - dflags = MidiDiskstream::Flag (dflags | MidiDiskstream::Destructive); - } + use_new_diskstream (); - MidiDiskstream* ds = new MidiDiskstream (_session, name, dflags); - _declickable = true; _freeze_record.state = NoFreeze; _saved_meter_point = _meter_point; _mode = mode; - - set_diskstream (*ds, this); } MidiTrack::MidiTrack (Session& sess, const XMLNode& node) - : Track (sess, node) + : Track (sess, node, DataType::MIDI ) + , _immediate_events(1024) // FIXME: size? + , _note_mode(Sustained) { - _freeze_record.state = NoFreeze; - set_state (node); - _declickable = true; - _saved_meter_point = _meter_point; + _set_state(node, false); } MidiTrack::~MidiTrack () { - if (_diskstream) { - _diskstream->unref(); - } } -#if 0 void -MidiTrack::handle_smpte_offset_change () +MidiTrack::use_new_diskstream () { - diskstream -} -#endif + MidiDiskstream::Flag dflags = MidiDiskstream::Flag (0); + if (_flags & Hidden) { + dflags = MidiDiskstream::Flag (dflags | MidiDiskstream::Hidden); + } else { + dflags = MidiDiskstream::Flag (dflags | MidiDiskstream::Recordable); + } + + assert(_mode != Destructive); + + boost::shared_ptr ds (new MidiDiskstream (_session, name(), dflags)); + _session.add_diskstream (ds); + + set_diskstream (boost::dynamic_pointer_cast (ds)); +} int -MidiTrack::set_diskstream (MidiDiskstream& ds, void *src) +MidiTrack::set_diskstream (boost::shared_ptr ds) { - if (_diskstream) { - _diskstream->unref(); - } - - _diskstream = &ds.ref(); - _diskstream->set_io (*this); + _diskstream = ds; + _diskstream->set_io (*(_input.get())); _diskstream->set_destructive (_mode == Destructive); - _diskstream->set_record_enabled (false, this); + _diskstream->set_record_enabled (false); //_diskstream->monitor_input (false); ic_connection.disconnect(); - ic_connection = input_changed.connect (mem_fun (*_diskstream, &MidiDiskstream::handle_input_change)); + ic_connection = _input->changed.connect (mem_fun (*_diskstream, &MidiDiskstream::handle_input_change)); - DiskstreamChanged (src); /* EMIT SIGNAL */ + DiskstreamChanged (); /* EMIT SIGNAL */ return 0; } @@ -114,94 +112,61 @@ MidiTrack::set_diskstream (MidiDiskstream& ds, void *src) int MidiTrack::use_diskstream (string name) { - MidiDiskstream *dstream; + boost::shared_ptr dstream; - if ((dstream = dynamic_cast(_session.diskstream_by_name (name))) == 0) { - error << string_compose(_("MidiTrack: midi diskstream \"%1\" not known by session"), name) << endmsg; + cerr << "\n\n\nMIDI use diskstream\n"; + + if ((dstream = boost::dynamic_pointer_cast(_session.diskstream_by_name (name))) == 0) { + error << string_compose(_("MidiTrack: midi diskstream \"%1\" not known by session"), name) << endmsg; return -1; } - return set_diskstream (*dstream, this); + cerr << "\n\n\nMIDI found DS\n"; + return set_diskstream (dstream); } int MidiTrack::use_diskstream (const PBD::ID& id) { - MidiDiskstream *dstream; + boost::shared_ptr dstream; - if ((dstream = dynamic_cast(_session.diskstream_by_id (id))) == 0) { + if ((dstream = boost::dynamic_pointer_cast (_session.diskstream_by_id (id))) == 0) { error << string_compose(_("MidiTrack: midi diskstream \"%1\" not known by session"), id) << endmsg; return -1; } - return set_diskstream (*dstream, this); -} - -bool -MidiTrack::record_enabled () const -{ - return _diskstream->record_enabled (); + return set_diskstream (dstream); } -void -MidiTrack::set_record_enable (bool yn, void *src) +boost::shared_ptr +MidiTrack::midi_diskstream() const { - if (_freeze_record.state == Frozen) { - return; - } -#if 0 - if (_mix_group && src != _mix_group && _mix_group->is_active()) { - _mix_group->apply (&MidiTrack::set_record_enable, yn, _mix_group); - return; - } - - /* keep track of the meter point as it was before we rec-enabled */ - - if (!diskstream->record_enabled()) { - _saved_meter_point = _meter_point; - } - - diskstream->set_record_enabled (yn, src); - - if (diskstream->record_enabled()) { - set_meter_point (MeterInput, this); - } else { - set_meter_point (_saved_meter_point, this); - } - - if (_session.get_midi_feedback()) { - _midi_rec_enable_control.send_feedback (record_enabled()); - } -#endif + return boost::dynamic_pointer_cast(_diskstream); } -MidiDiskstream& -MidiTrack::midi_diskstream() const +int +MidiTrack::set_state (const XMLNode& node) { - return *dynamic_cast(_diskstream); + return _set_state (node, true); } int -MidiTrack::set_state (const XMLNode& node) +MidiTrack::_set_state (const XMLNode& node, bool call_base) { const XMLProperty *prop; XMLNodeConstIterator iter; - if (Route::set_state (node)) { + if (Route::_set_state (node, call_base)) { return -1; } - - if ((prop = node.property (X_("mode"))) != 0) { - if (prop->value() == X_("normal")) { - _mode = Normal; - } else if (prop->value() == X_("destructive")) { - _mode = Destructive; - } else { - warning << string_compose ("unknown midi track mode \"%1\" seen and ignored", prop->value()) << endmsg; - _mode = Normal; - } + + // No destructive MIDI tracks (yet?) + _mode = Normal; + + if ((prop = node.property (X_("note-mode"))) != 0) { + _note_mode = NoteMode (string_2_enum (prop->value(), _note_mode)); } else { - _mode = Normal; + _note_mode = Sustained; } if ((prop = node.property ("diskstream-id")) == 0) { @@ -221,13 +186,25 @@ MidiTrack::set_state (const XMLNode& node) } else { PBD::ID id (prop->value()); + PBD::ID zero ("0"); - if (use_diskstream (id)) { + /* this wierd hack is used when creating tracks from a template. there isn't + a particularly good time to interpose between setting the first part of + the track state (notably Route::set_state() and the track mode), and the + second part (diskstream stuff). So, we have a special ID for the diskstream + that means "you should create a new diskstream here, not look for + an old one. + */ + + cerr << "\n\n\n\n MIDI track " << name() << " found DS id " << id << endl; + + if (id == zero) { + use_new_diskstream (); + } else if (use_diskstream (id)) { return -1; } } - XMLNodeList nlist; XMLNodeConstIterator niter; XMLNode *child; @@ -236,18 +213,19 @@ MidiTrack::set_state (const XMLNode& node) for (niter = nlist.begin(); niter != nlist.end(); ++niter){ child = *niter; - if (child->name() == X_("remote_control")) { - if ((prop = child->property (X_("id"))) != 0) { - int32_t x; - sscanf (prop->value().c_str(), "%d", &x); - set_remote_control_id (x); - } + if (child->name() == X_("recenable")) { + _rec_enable_control->set_state (*child); + _session.add_controllable (_rec_enable_control); } } pending_state = const_cast (&node); - _session.StateReady.connect (mem_fun (*this, &MidiTrack::set_state_part_two)); + if (_session.state_of_the_state() & Session::Loading) { + _session.StateReady.connect (mem_fun (*this, &MidiTrack::set_state_part_two)); + } else { + set_state_part_two (); + } return 0; } @@ -264,12 +242,11 @@ MidiTrack::state(bool full_state) freeze_node = new XMLNode (X_("freeze-info")); freeze_node->add_property ("playlist", _freeze_record.playlist->name()); - snprintf (buf, sizeof (buf), "%d", (int) _freeze_record.state); - freeze_node->add_property ("state", buf); + freeze_node->add_property ("state", enum_2_string (_freeze_record.state)); - for (vector::iterator i = _freeze_record.insert_info.begin(); i != _freeze_record.insert_info.end(); ++i) { - inode = new XMLNode (X_("insert")); - (*i)->id.print (buf); + for (vector::iterator i = _freeze_record.processor_info.begin(); i != _freeze_record.processor_info.end(); ++i) { + inode = new XMLNode (X_("processor")); + (*i)->id.print (buf, sizeof(buf)); inode->add_property (X_("id"), buf); inode->add_child_copy ((*i)->state); @@ -281,40 +258,23 @@ MidiTrack::state(bool full_state) /* Alignment: act as a proxy for the diskstream */ - XMLNode* align_node = new XMLNode (X_("alignment")); - switch (_diskstream->alignment_style()) { - case ExistingMaterial: - snprintf (buf, sizeof (buf), X_("existing")); - break; - case CaptureTime: - snprintf (buf, sizeof (buf), X_("capture")); - break; - } - align_node->add_property (X_("style"), buf); + XMLNode* align_node = new XMLNode (X_("Alignment")); + AlignStyle as = _diskstream->alignment_style (); + align_node->add_property (X_("style"), enum_2_string (as)); root.add_child_nocopy (*align_node); - XMLNode* remote_control_node = new XMLNode (X_("remote_control")); - snprintf (buf, sizeof (buf), "%d", _remote_control_id); - remote_control_node->add_property (X_("id"), buf); - root.add_child_nocopy (*remote_control_node); - - switch (_mode) { - case Normal: - root.add_property (X_("mode"), X_("normal")); - break; - case Destructive: - root.add_property (X_("mode"), X_("destructive")); - break; - } - + root.add_property (X_("note-mode"), enum_2_string (_note_mode)); + /* we don't return diskstream state because we don't own the diskstream exclusively. control of the diskstream state is ceded to the Session, even if we create the diskstream. */ - _diskstream->id().print (buf); + _diskstream->id().print (buf, sizeof(buf)); root.add_property ("diskstream-id", buf); + + root.add_child_nocopy (_rec_enable_control->get_state()); return root; } @@ -336,35 +296,33 @@ MidiTrack::set_state_part_two () if ((fnode = find_named_node (*pending_state, X_("freeze-info"))) != 0) { - - _freeze_record.have_mementos = false; _freeze_record.state = Frozen; - for (vector::iterator i = _freeze_record.insert_info.begin(); i != _freeze_record.insert_info.end(); ++i) { + for (vector::iterator i = _freeze_record.processor_info.begin(); i != _freeze_record.processor_info.end(); ++i) { delete *i; } - _freeze_record.insert_info.clear (); + _freeze_record.processor_info.clear (); if ((prop = fnode->property (X_("playlist"))) != 0) { - Playlist* pl = _session.playlist_by_name (prop->value()); + boost::shared_ptr pl = _session.playlist_by_name (prop->value()); if (pl) { - _freeze_record.playlist = dynamic_cast (pl); + _freeze_record.playlist = boost::dynamic_pointer_cast (pl); } else { - _freeze_record.playlist = 0; + _freeze_record.playlist.reset(); _freeze_record.state = NoFreeze; return; } } if ((prop = fnode->property (X_("state"))) != 0) { - _freeze_record.state = (FreezeState) atoi (prop->value().c_str()); + _freeze_record.state = FreezeState (string_2_enum (prop->value(), _freeze_record.state)); } XMLNodeConstIterator citer; XMLNodeList clist = fnode->children(); for (citer = clist.begin(); citer != clist.end(); ++citer) { - if ((*citer)->name() != X_("insert")) { + if ((*citer)->name() != X_("processor")) { continue; } @@ -372,528 +330,266 @@ MidiTrack::set_state_part_two () continue; } - FreezeRecordInsertInfo* frii = new FreezeRecordInsertInfo (*((*citer)->children().front())); - frii->insert = 0; + FreezeRecordProcessorInfo* frii = new FreezeRecordProcessorInfo (*((*citer)->children().front()), + boost::shared_ptr()); frii->id = prop->value (); - _freeze_record.insert_info.push_back (frii); + _freeze_record.processor_info.push_back (frii); } } /* Alignment: act as a proxy for the diskstream */ - if ((fnode = find_named_node (*pending_state, X_("alignment"))) != 0) { + if ((fnode = find_named_node (*pending_state, X_("Alignment"))) != 0) { if ((prop = fnode->property (X_("style"))) != 0) { - if (prop->value() == "existing") { - _diskstream->set_persistent_align_style (ExistingMaterial); - } else if (prop->value() == "capture") { - _diskstream->set_persistent_align_style (CaptureTime); - } - } - } - return; -} - -uint32_t -MidiTrack::n_process_buffers () -{ - return max ((uint32_t) _diskstream->n_channels(), redirect_max_outs); -} - -void -MidiTrack::passthru_silence (jack_nframes_t start_frame, jack_nframes_t end_frame, jack_nframes_t nframes, jack_nframes_t offset, int declick, bool meter) -{ - uint32_t nbufs = n_process_buffers (); - process_output_buffers (_session.get_silent_buffers (nbufs), nbufs, start_frame, end_frame, nframes, offset, true, declick, meter); -} - -int -MidiTrack::no_roll (jack_nframes_t nframes, jack_nframes_t start_frame, jack_nframes_t end_frame, jack_nframes_t offset, - bool session_state_changing, bool can_record, bool rec_monitors_input) -{ - if (n_outputs() == 0) { - return 0; - } - - if (!_active) { - silence (nframes, offset); - return 0; - } - if (session_state_changing) { - - /* XXX is this safe to do against transport state changes? */ - - passthru_silence (start_frame, end_frame, nframes, offset, 0, false); - return 0; - } + /* fix for older sessions from before EnumWriter */ - midi_diskstream().check_record_status (start_frame, nframes, can_record); + string pstr; - bool send_silence; - - if (_have_internal_generator) { - /* since the instrument has no input streams, - there is no reason to send any signal - into the route. - */ - send_silence = true; - } else { - - if (_session.get_auto_input()) { - if (Config->get_use_sw_monitoring()) { - send_silence = false; + if (prop->value() == "capture") { + pstr = "CaptureTime"; + } else if (prop->value() == "existing") { + pstr = "ExistingMaterial"; } else { - send_silence = true; + pstr = prop->value(); } - } else { - if (_diskstream->record_enabled()) { - if (Config->get_use_sw_monitoring()) { - send_silence = false; - } else { - send_silence = true; - } - } else { - send_silence = true; - } - } - } - apply_gain_automation = false; - - if (send_silence) { - - /* if we're sending silence, but we want the meters to show levels for the signal, - meter right here. - */ - - if (_have_internal_generator) { - passthru_silence (start_frame, end_frame, nframes, offset, 0, true); - } else { - if (_meter_point == MeterInput) { - just_meter_input (start_frame, end_frame, nframes, offset); - } - passthru_silence (start_frame, end_frame, nframes, offset, 0, false); + AlignStyle as = AlignStyle (string_2_enum (pstr, as)); + _diskstream->set_persistent_align_style (as); } - - } else { - - /* we're sending signal, but we may still want to meter the input. - */ - - passthru (start_frame, end_frame, nframes, offset, 0, (_meter_point == MeterInput)); } - - return 0; -} + return; +} int -MidiTrack::roll (jack_nframes_t nframes, jack_nframes_t start_frame, jack_nframes_t end_frame, jack_nframes_t offset, int declick, - bool can_record, bool rec_monitors_input) +MidiTrack::roll (nframes_t nframes, sframes_t start_frame, sframes_t end_frame, int declick, + bool can_record, bool rec_monitors_input) { -#if 0 int dret; - Sample* b; - Sample* tmpb; - jack_nframes_t transport_frame; - + boost::shared_ptr diskstream = midi_diskstream(); + { - Glib::RWLock::ReaderLock lm (redirect_lock, Glib::TRY_LOCK); + Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK); if (lm.locked()) { // automation snapshot can also be called from the non-rt context // and it uses the redirect list, so we take the lock out here automation_snapshot (start_frame); } } - - if (n_outputs() == 0 && _redirects.empty()) { + + if (n_outputs().n_total() == 0 && _processors.empty()) { return 0; } if (!_active) { - silence (nframes, offset); + silence (nframes); return 0; } - transport_frame = _session.transport_frame(); + nframes_t transport_frame = _session.transport_frame(); - if ((nframes = check_initial_delay (nframes, offset, transport_frame)) == 0) { + + if ((nframes = check_initial_delay (nframes, transport_frame)) == 0) { /* need to do this so that the diskstream sets its playback distance to zero, thus causing diskstream::commit to do nothing. - */ - return diskstream->process (transport_frame, 0, 0, can_record, rec_monitors_input); + */ + return diskstream->process (transport_frame, 0, can_record, rec_monitors_input); } _silent = false; - apply_gain_automation = false; - if ((dret = diskstream->process (transport_frame, nframes, offset, can_record, rec_monitors_input)) != 0) { - - silence (nframes, offset); + if ((dret = diskstream->process (transport_frame, nframes, can_record, rec_monitors_input)) != 0) { + silence (nframes); return dret; } /* special condition applies */ - + if (_meter_point == MeterInput) { - just_meter_input (start_frame, end_frame, nframes, offset); + _input->process_input (_meter, start_frame, end_frame, nframes); } - if (diskstream->record_enabled() && !can_record && !_session.get_auto_input()) { + if (diskstream->record_enabled() && !can_record && !_session.config.get_auto_input()) { /* not actually recording, but we want to hear the input material anyway, at least potentially (depending on monitoring options) - */ - - passthru (start_frame, end_frame, nframes, offset, 0, true); + */ - } else if ((b = diskstream->playback_buffer(0)) != 0) { + passthru (start_frame, end_frame, nframes, 0); + } else { /* - XXX is it true that the earlier test on n_outputs() - means that we can avoid checking it again here? i think - so, because changing the i/o configuration of an IO - requires holding the AudioEngine lock, which we hold - while in the process() tree. - */ - - - /* copy the diskstream data to all output buffers */ - - vector& bufs = _session.get_passthru_buffers (); - uint32_t limit = n_process_buffers (); - - uint32_t n; - uint32_t i; - - - for (i = 0, n = 1; i < limit; ++i, ++n) { - memcpy (bufs[i], b, sizeof (Sample) * nframes); - if (n < diskstream->n_channels()) { - tmpb = diskstream->playback_buffer(n); - if (tmpb!=0) { - b = tmpb; - } - } - } + XXX is it true that the earlier test on n_outputs() + means that we can avoid checking it again here? i think + so, because changing the i/o configuration of an IO + requires holding the AudioEngine lock, which we hold + while in the process() tree. + */ - /* don't waste time with automation if we're recording or we've just stopped (yes it can happen) */ - if (!diskstream->record_enabled() && _session.transport_rolling()) { - Glib::Mutex::Lock am (automation_lock, Glib::TRY_LOCK); - - if (am.locked() && gain_automation_playback()) { - apply_gain_automation = _gain_automation_curve.rt_safe_get_vector (start_frame, end_frame, _session.gain_automation_buffer(), nframes); - } - } + /* copy the diskstream data to all output buffers */ - process_output_buffers (bufs, limit, start_frame, end_frame, nframes, offset, (!_session.get_record_enabled() || !_session.get_do_not_record_plugins()), declick, (_meter_point != MeterInput)); - - } else { - /* problem with the diskstream; just be quiet for a bit */ - silence (nframes, offset); - } -#endif - return 0; -} + //const size_t limit = n_process_buffers().n_audio(); + BufferSet& bufs = _session.get_scratch_buffers (n_process_buffers()); -int -MidiTrack::silent_roll (jack_nframes_t nframes, jack_nframes_t start_frame, jack_nframes_t end_frame, jack_nframes_t offset, - bool can_record, bool rec_monitors_input) -{ - if (n_outputs() == 0 && _redirects.empty()) { - return 0; - } + diskstream->get_playback(bufs.get_midi(0), start_frame, end_frame); - if (!_active) { - silence (nframes, offset); - return 0; + process_output_buffers (bufs, start_frame, end_frame, nframes, + (!_session.get_record_enabled() || !Config->get_do_not_record_plugins()), declick); + } - _silent = true; - apply_gain_automation = false; + _main_outs->flush (nframes); - silence (nframes, offset); - - return midi_diskstream().process (_session.transport_frame() + offset, nframes, offset, can_record, rec_monitors_input); + return 0; } -int -MidiTrack::set_name (string str, void *src) +void +MidiTrack::write_controller_messages(MidiBuffer& output_buf, sframes_t start, sframes_t end, nframes_t nframes) { - int ret; + // Append immediate events (UI controls) - if (record_enabled() && _session.actively_recording()) { - /* this messes things up if done while recording */ - return -1; - } - - if (_diskstream->set_name (str, src)) { - return -1; - } + // XXX TAKE _port_offset in Port into account??? - /* save state so that the statefile fully reflects any filename changes */ - - if ((ret = IO::set_name (str, src)) == 0) { - _session.save_state (""); - } - return ret; + _immediate_events.read (output_buf, 0, 0, nframes - 1); // all stamps = 0 } int -MidiTrack::export_stuff (vector& buffers, char * workbuf, uint32_t nbufs, jack_nframes_t start, jack_nframes_t nframes) +MidiTrack::export_stuff (BufferSet& bufs, nframes_t nframes, sframes_t end_frame) { -#if 0 - gain_t gain_automation[nframes]; - gain_t gain_buffer[nframes]; - float mix_buffer[nframes]; - RedirectList::iterator i; - bool post_fader_work = false; - gain_t this_gain = _gain; - vector::iterator bi; - Sample * b; - - Glib::RWLock::ReaderLock rlock (redirect_lock); - - if (diskstream->playlist()->read (buffers[0], mix_buffer, gain_buffer, workbuf, start, nframes) != nframes) { - return -1; - } - - uint32_t n=1; - bi = buffers.begin(); - b = buffers[0]; - ++bi; - for (; bi != buffers.end(); ++bi, ++n) { - if (n < diskstream->n_channels()) { - if (diskstream->playlist()->read ((*bi), mix_buffer, gain_buffer, workbuf, start, nframes, n) != nframes) { - return -1; - } - b = (*bi); - } - else { - /* duplicate last across remaining buffers */ - memcpy ((*bi), b, sizeof (Sample) * nframes); - } - } - - - /* note: only run inserts during export. other layers in the machinery - will already have checked that there are no external port inserts. - */ - - for (i = _redirects.begin(); i != _redirects.end(); ++i) { - Insert *insert; - - if ((insert = dynamic_cast(*i)) != 0) { - switch (insert->placement()) { - case PreFader: - insert->run (buffers, nbufs, nframes, 0); - break; - case PostFader: - post_fader_work = true; - break; - } - } - } - - if (_gain_automation_curve.automation_state() == Play) { - - _gain_automation_curve.get_vector (start, start + nframes, gain_automation, nframes); - - for (bi = buffers.begin(); bi != buffers.end(); ++bi) { - Sample *b = *bi; - for (jack_nframes_t n = 0; n < nframes; ++n) { - b[n] *= gain_automation[n]; - } - } - - } else { - - for (bi = buffers.begin(); bi != buffers.end(); ++bi) { - Sample *b = *bi; - for (jack_nframes_t n = 0; n < nframes; ++n) { - b[n] *= this_gain; - } - } - } - - if (post_fader_work) { - - for (i = _redirects.begin(); i != _redirects.end(); ++i) { - PluginInsert *insert; - - if ((insert = dynamic_cast(*i)) != 0) { - switch ((*i)->placement()) { - case PreFader: - break; - case PostFader: - insert->run (buffers, nbufs, nframes, 0); - break; - } - } - } - } -#endif - return 0; + return -1; } void -MidiTrack::set_latency_delay (jack_nframes_t longest_session_latency) +MidiTrack::set_latency_delay (nframes_t longest_session_latency) { Route::set_latency_delay (longest_session_latency); _diskstream->set_roll_delay (_roll_delay); } -void +boost::shared_ptr MidiTrack::bounce (InterThreadInfo& itt) { - //vector srcs; - //_session.write_one_midi_track (*this, 0, _session.current_end_frame(), false, srcs, itt); + throw; + // vector srcs; + // return _session.write_one_track (*this, 0, _session.current_end_frame(), false, srcs, itt); + return boost::shared_ptr (); } -void -MidiTrack::bounce_range (jack_nframes_t start, jack_nframes_t end, InterThreadInfo& itt) +boost::shared_ptr +MidiTrack::bounce_range (nframes_t start, nframes_t end, InterThreadInfo& itt, bool enable_processing) { + throw; //vector srcs; - //_session.write_one_midi_track (*this, start, end, false, srcs, itt); + //return _session.write_one_track (*this, start, end, false, srcs, itt); + return boost::shared_ptr (); } void MidiTrack::freeze (InterThreadInfo& itt) { -#if 0 - Insert* insert; - vector srcs; - string new_playlist_name; - Playlist* new_playlist; - string dir; - AudioRegion* region; - string region_name; - - if ((_freeze_record.playlist = diskstream->playlist()) == 0) { - return; - } - - uint32_t n = 1; - - while (n < (UINT_MAX-1)) { - - string candidate; - - candidate = string_compose ("%1", _freeze_record.playlist->name(), n); - - if (_session.playlist_by_name (candidate) == 0) { - new_playlist_name = candidate; - break; - } - - ++n; - - } - - if (n == (UINT_MAX-1)) { - PBD::error << string_compose (X_("There Are too many frozen versions of playlist \"%1\"" - " to create another one"), _freeze_record.playlist->name()) - << endmsg; - return; - } - - if (_session.write_one_midi_track (*this, 0, _session.current_end_frame(), true, srcs, itt)) { - return; - } - - _freeze_record.insert_info.clear (); - _freeze_record.have_mementos = true; - - { - Glib::RWLock::ReaderLock lm (redirect_lock); - - for (RedirectList::iterator r = _redirects.begin(); r != _redirects.end(); ++r) { - - if ((insert = dynamic_cast(*r)) != 0) { - - FreezeRecordInsertInfo* frii = new FreezeRecordInsertInfo ((*r)->get_state()); - - frii->insert = insert; - frii->id = insert->id(); - frii->memento = (*r)->get_memento(); - - _freeze_record.insert_info.push_back (frii); - - /* now deactivate the insert */ - - insert->set_active (false, this); - } - } - } - - new_playlist = new MidiPlaylist (_session, new_playlist_name, false); - region_name = new_playlist_name; - - /* create a new region from all filesources, keep it private */ - - region = new AudioRegion (srcs, 0, srcs[0]->length(), - region_name, 0, - (AudioRegion::Flag) (AudioRegion::WholeFile|AudioRegion::DefaultFlags), - false); - - new_playlist->set_orig_diskstream_id (diskstream->id()); - new_playlist->add_region (*region, 0); - new_playlist->set_frozen (true); - region->set_locked (true); - - diskstream->use_playlist (dynamic_cast(new_playlist)); - diskstream->set_record_enabled (false, this); - - _freeze_record.state = Frozen; - FreezeChange(); /* EMIT SIGNAL */ -#endif } void MidiTrack::unfreeze () { -#if 0 - if (_freeze_record.playlist) { - diskstream->use_playlist (_freeze_record.playlist); - - if (_freeze_record.have_mementos) { + _freeze_record.state = UnFrozen; + FreezeChange (); /* EMIT SIGNAL */ +} - for (vector::iterator i = _freeze_record.insert_info.begin(); i != _freeze_record.insert_info.end(); ++i) { - (*i)->memento (); - } +void +MidiTrack::set_note_mode (NoteMode m) +{ + _note_mode = m; + midi_diskstream()->set_note_mode(m); +} - } else { +void +MidiTrack::midi_panic() +{ + for (uint8_t channel = 0; channel <= 0xF; channel++) { + uint8_t ev[3] = { MIDI_CMD_CONTROL | channel, MIDI_CTL_SUSTAIN, 0 }; + write_immediate_event(3, ev); + ev[1] = MIDI_CTL_ALL_NOTES_OFF; + write_immediate_event(3, ev); + ev[1] = MIDI_CTL_RESET_CONTROLLERS; + write_immediate_event(3, ev); + } +} - Glib::RWLock::ReaderLock lm (redirect_lock); // should this be a write lock? jlc - for (RedirectList::iterator i = _redirects.begin(); i != _redirects.end(); ++i) { - for (vector::iterator ii = _freeze_record.insert_info.begin(); ii != _freeze_record.insert_info.end(); ++ii) { - if ((*ii)->id == (*i)->id()) { - (*i)->set_state (((*ii)->state)); - break; - } - } - } - } - - _freeze_record.playlist = 0; +/** \return true on success, false on failure (no buffer space left) + */ +bool +MidiTrack::write_immediate_event(size_t size, const uint8_t* buf) +{ + if (!Evoral::midi_event_is_valid(buf, size)) { + cerr << "WARNING: Ignoring illegal immediate MIDI event" << endl; + return false; } -#endif - _freeze_record.state = UnFrozen; - FreezeChange (); /* EMIT SIGNAL */ + const uint32_t type = EventTypeMap::instance().midi_event_type(buf[0]); + return (_immediate_events.write(0, type, size, buf) == size); } void -MidiTrack::set_mode (TrackMode m) +MidiTrack::MidiControl::set_value(float val) { - if (_diskstream) { - if (_mode != m) { - _mode = m; - _diskstream->set_destructive (m == Destructive); - ModeChanged(); + bool valid = false; + if (isinf(val)) { + cerr << "MIDIControl value is infinity" << endl; + } else if (isnan(val)) { + cerr << "MIDIControl value is NaN" << endl; + } else if (val < _list->parameter().min()) { + cerr << "MIDIControl value is < " << _list->parameter().min() << endl; + } else if (val > _list->parameter().max()) { + cerr << "MIDIControl value is > " << _list->parameter().max() << endl; + } else { + valid = true; + } + + if (!valid) { + return; + } + + assert(val <= _list->parameter().max()); + size_t size = 3; + + if ( ! automation_playback()) { + uint8_t ev[3] = { _list->parameter().channel(), int(val), 0 }; + switch(_list->parameter().type()) { + case MidiCCAutomation: + ev[0] += MIDI_CMD_CONTROL; + ev[1] = _list->parameter().id(); + ev[2] = int(val); + break; + + case MidiPgmChangeAutomation: + size = 2; + ev[0] += MIDI_CMD_PGM_CHANGE; + ev[1] = int(val); + break; + + case MidiChannelPressureAutomation: + size = 2; + ev[0] += MIDI_CMD_CHANNEL_PRESSURE; + ev[1] = int(val); + break; + + case MidiPitchBenderAutomation: + ev[0] += MIDI_CMD_BENDER; + ev[1] = 0x7F & int(val); + ev[2] = 0x7F & (int(val) >> 7); + break; + + default: + assert(false); } + _route->write_immediate_event(size, ev); } -} + + AutomationControl::set_value(val); +} +