boost::shared_ptr<MidiDiskstream> mds = boost::dynamic_pointer_cast<MidiDiskstream> (ds);
mds->DataRecorded.connect_same_thread (
_diskstream_data_recorded_connection,
- boost::bind (&MidiTrack::diskstream_data_recorded, this, _1, _2));
+ boost::bind (&MidiTrack::diskstream_data_recorded, this, _1));
DiskstreamChanged (); /* EMIT SIGNAL */
}
int
MidiTrack::set_state (const XMLNode& node, int version)
-{
- return _set_state (node, version, true);
-}
-
-int
-MidiTrack::_set_state (const XMLNode& node, int version, bool call_base)
{
const XMLProperty *prop;
- XMLNodeConstIterator iter;
- if (Route::_set_state (node, version, call_base)) {
+ if (Track::set_state (node, version)) {
return -1;
}
set_input_active (string_is_affirmative (prop->value()));
}
- XMLNodeList nlist;
- XMLNodeConstIterator niter;
- XMLNode *child;
-
- nlist = node.children();
-
- if (version >= 3000) {
- if ((child = find_named_node (node, X_("Diskstream"))) != 0) {
- boost::shared_ptr<MidiDiskstream> ds (new MidiDiskstream (_session, *child));
- ds->do_refill_with_alloc ();
- set_diskstream (ds);
- }
- }
-
- /* set rec-enable control *AFTER* setting up diskstream, because it may
- want to operate on the diskstream as it sets its own state
- */
-
- for (niter = nlist.begin(); niter != nlist.end(); ++niter){
- child = *niter;
-
- if (child->name() == Controllable::xml_node_name && (prop = child->property ("name")) != 0) {
- if (prop->value() == X_("recenable")) {
- _rec_enable_control->set_state (*child, version);
- }
- }
- }
-
pending_state = const_cast<XMLNode*> (&node);
if (_session.state_of_the_state() & Session::Loading) {
XMLNode&
MidiTrack::state(bool full_state)
{
- XMLNode& root (Route::state(full_state));
+ XMLNode& root (Track::state(full_state));
XMLNode* freeze_node;
char buf[64];
}
root.add_property (X_("note-mode"), enum_2_string (_note_mode));
- root.add_child_nocopy (_rec_enable_control->get_state());
- root.add_child_nocopy (_diskstream->get_state ());
root.add_property ("step-editing", (_step_editing ? "yes" : "no"));
root.add_property ("note-mode", enum_2_string (_note_mode));
}
int
-MidiTrack::roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, int declick,
- bool can_record, bool& needs_butler)
+MidiTrack::roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, int declick, bool& need_butler)
{
Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
if (!lm.locked()) {
return 0;
}
- int dret;
boost::shared_ptr<MidiDiskstream> diskstream = midi_diskstream();
automation_snapshot (start_frame);
framepos_t transport_frame = _session.transport_frame();
+ int dret;
+ framecnt_t playback_distance;
+
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, can_record, needs_butler);
+ dret = diskstream->process (transport_frame, 0, playback_distance);
+ need_butler = diskstream->commit (playback_distance);
+ return dret;
}
_silent = false;
- if ((dret = diskstream->process (transport_frame, nframes, can_record, needs_butler)) != 0) {
+ if ((dret = diskstream->process (transport_frame, nframes, playback_distance)) != 0) {
+ need_butler = diskstream->commit (playback_distance);
silence (nframes);
return dret;
}
_input->process_input (_meter, start_frame, end_frame, nframes);
}
- if (diskstream->record_enabled() && !can_record && !_session.config.get_auto_input()) {
+ if (monitoring_state() == MonitoringInput) {
/* not actually recording, but we want to hear the input material anyway,
at least potentially (depending on monitoring options)
c.set_midi (1);
bufs.set_count (c);
- diskstream->get_playback (mbuf, start_frame, end_frame);
+ diskstream->get_playback (mbuf, nframes);
/* append immediate messages to the first MIDI buffer (thus sending it to the first output port) */
/* final argument: don't waste time with automation if we're recording or we've just stopped (yes it can happen) */
- process_output_buffers (bufs, start_frame, end_frame, nframes,
- (!_session.get_record_enabled() || !Config->get_do_not_record_plugins()), declick,
- (!diskstream->record_enabled() && !_session.transport_stopped()));
+ process_output_buffers (
+ bufs, start_frame, end_frame, nframes,
+ declick, (!diskstream->record_enabled() && !_session.transport_stopped())
+ );
}
for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
}
}
+ need_butler = diskstream->commit (playback_distance);
+
return 0;
}
int
-MidiTrack::no_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame,
- bool state_changing, bool can_record)
+MidiTrack::no_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, bool state_changing)
{
- int ret = Track::no_roll (nframes, start_frame, end_frame, state_changing, can_record);
+ int ret = Track::no_roll (nframes, start_frame, end_frame, state_changing);
if (ret == 0 && _step_editing) {
push_midi_input_to_step_edit_ringbuffer (nframes);
}
void
-MidiTrack::diskstream_data_recorded (boost::shared_ptr<MidiBuffer> buf, boost::weak_ptr<MidiSource> src)
+MidiTrack::diskstream_data_recorded (boost::weak_ptr<MidiSource> src)
{
- DataRecorded (buf, src); /* EMIT SIGNAL */
+ DataRecorded (src); /* EMIT SIGNAL */
}
bool
PortSet& ports (_input->ports());
for (PortSet::iterator p = ports.begin(DataType::MIDI); p != ports.end(DataType::MIDI); ++p) {
- MidiPort* mp = dynamic_cast<MidiPort*> (&*p);
+ boost::shared_ptr<MidiPort> mp = boost::dynamic_pointer_cast<MidiPort> (*p);
if (yn != mp->input_active()) {
mp->set_input_active (yn);
}
}
}
+boost::shared_ptr<Diskstream>
+MidiTrack::diskstream_factory (XMLNode const & node)
+{
+ return boost::shared_ptr<Diskstream> (new MidiDiskstream (_session, node));
+}
+
+boost::shared_ptr<MidiBuffer>
+MidiTrack::get_gui_feed_buffer () const
+{
+ return midi_diskstream()->get_gui_feed_buffer ();
+}
projects / ardour.git / blobdiff