Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
-#include "pbd/error.h"
-
#include "pbd/enumwriter.h"
#include "pbd/convert.h"
-#include "midi++/events.h"
#include "evoral/midi_util.h"
-#include "ardour/amp.h"
#include "ardour/buffer_set.h"
#include "ardour/debug.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_port.h"
-#include "ardour/midi_region.h"
-#include "ardour/midi_source.h"
#include "ardour/midi_track.h"
-#include "ardour/panner.h"
#include "ardour/port.h"
#include "ardour/processor.h"
-#include "ardour/route_group_specialized.h"
#include "ardour/session.h"
#include "ardour/session_playlists.h"
#include "ardour/utils.h"
#include "i18n.h"
+namespace ARDOUR {
+class InterThreadInfo;
+class MidiSource;
+class Region;
+class SMFSource;
+}
+
using namespace std;
using namespace ARDOUR;
using namespace PBD;
, _step_edit_ring_buffer(64) // FIXME: size?
, _note_mode(Sustained)
, _step_editing (false)
- , _midi_thru (true)
, _input_active (true)
{
}
void
MidiTrack::set_diskstream (boost::shared_ptr<Diskstream> ds)
{
+ /* We have to do this here, as Track::set_diskstream will cause a buffer refill,
+ and the diskstream must be set up to fill its buffers using the correct _note_mode.
+ */
+ boost::shared_ptr<MidiDiskstream> mds = boost::dynamic_pointer_cast<MidiDiskstream> (ds);
+ mds->set_note_mode (_note_mode);
+
Track::set_diskstream (ds);
- midi_diskstream()->reset_tracker ();
+ mds->reset_tracker ();
_diskstream->set_track (this);
_diskstream->set_destructive (_mode == Destructive);
_diskstream->set_record_enabled (false);
_diskstream_data_recorded_connection.disconnect ();
- 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));
{
const XMLProperty *prop;
- if (Track::set_state (node, version)) {
- return -1;
- }
-
- // No destructive MIDI tracks (yet?)
- _mode = Normal;
-
+ /* This must happen before Track::set_state(), as there will be a buffer
+ fill during that call, and we must fill buffers using the correct
+ _note_mode.
+ */
if ((prop = node.property (X_("note-mode"))) != 0) {
_note_mode = NoteMode (string_2_enum (prop->value(), _note_mode));
} else {
_note_mode = Sustained;
}
- if ((prop = node.property ("midi-thru")) != 0) {
- set_midi_thru (string_is_affirmative (prop->value()));
+ if (Track::set_state (node, version)) {
+ return -1;
}
+ // No destructive MIDI tracks (yet?)
+ _mode = Normal;
+
if ((prop = node.property ("input-active")) != 0) {
set_input_active (string_is_affirmative (prop->value()));
}
root.add_child_nocopy (*freeze_node);
}
- root.add_property (X_("note-mode"), enum_2_string (_note_mode));
-
- root.add_property ("step-editing", (_step_editing ? "yes" : "no"));
root.add_property ("note-mode", enum_2_string (_note_mode));
- root.add_property ("midi-thru", (_midi_thru ? "yes" : "no"));
+ root.add_property ("step-editing", (_step_editing ? "yes" : "no"));
root.add_property ("input-active", (_input_active ? "yes" : "no"));
return root;
int
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);
+ Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
if (!lm.locked()) {
return 0;
}
boost::shared_ptr<MidiDiskstream> diskstream = midi_diskstream();
- automation_snapshot (start_frame);
-
if (n_outputs().n_total() == 0 && _processors.empty()) {
return 0;
}
return dret;
}
+
_silent = false;
if ((dret = diskstream->process (transport_frame, nframes, playback_distance)) != 0) {
at least potentially (depending on monitoring options)
*/
+ /* because the playback buffer is event based and not a
+ * continuous stream, we need to make sure that we empty
+ * it of events every cycle to avoid it filling up with events
+ * read from disk, while we are actually monitoring input
+ */
+
+ diskstream->flush_playback (start_frame, end_frame);
+
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
/* copy the diskstream data to all output buffers */
- //const size_t limit = n_process_buffers().n_audio();
BufferSet& bufs = _session.get_scratch_buffers (n_process_buffers());
MidiBuffer& mbuf (bufs.get_midi (0));
- /* we are a MIDI track, so we always start the chain with a single-channel diskstream */
+ /* we are a MIDI track, so we always start the chain with a
+ * single-MIDI-channel diskstream
+ */
ChanCount c;
c.set_audio (0);
c.set_midi (1);
bufs.set_count (c);
+ assert (nframes > 0);
+
diskstream->get_playback (mbuf, nframes);
/* append immediate messages to the first MIDI buffer (thus sending it to the first output port) */
void
MidiTrack::realtime_locate ()
{
- Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
+ Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
if (!lm.locked ()) {
return;
void
MidiTrack::realtime_handle_transport_stopped ()
{
- Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
+ Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
if (!lm.locked ()) {
return;
_immediate_events.read (buf, 0, 1, nframes-1, true);
}
-
- // MIDI thru: send incoming data "through" output
- if (_midi_thru && _session.transport_speed() != 0.0f && _input->n_ports().n_midi()) {
- buf.merge_in_place (_input->midi(0)->get_midi_buffer(nframes));
- }
}
int
}
}
-void
-MidiTrack::set_midi_thru (bool yn)
-{
- _midi_thru = yn;
-}
-
boost::shared_ptr<SMFSource>
MidiTrack::write_source (uint32_t)
{
XXX we should should also stop all relevant note trackers.
*/
+ /* If we haven't got a diskstream yet, there's nothing to worry about,
+ and we can't call get_channel_mask() anyway.
+ */
+ if (!midi_diskstream()) {
+ return;
+ }
+
if (muted()) {
/* only send messages for channels we are using */
void
MidiTrack::set_monitoring (MonitorChoice mc)
{
- Track::set_monitoring (mc);
+ if (mc != _monitoring) {
+
+ Track::set_monitoring (mc);
+
+ /* monitoring state changed, so flush out any on notes at the
+ * port level.
+ */
- boost::shared_ptr<MidiDiskstream> md (midi_diskstream());
+ PortSet& ports (_output->ports());
+
+ for (PortSet::iterator p = ports.begin(); p != ports.end(); ++p) {
+ boost::shared_ptr<MidiPort> mp = boost::dynamic_pointer_cast<MidiPort> (*p);
+ if (mp) {
+ mp->require_resolve ();
+ }
+ }
- if (md) {
- md->reset_tracker ();
+ boost::shared_ptr<MidiDiskstream> md (midi_diskstream());
+
+ if (md) {
+ md->reset_tracker ();
+ }
}
}
MonitorState
MidiTrack::monitoring_state () const
{
- /* Explicit requests */
-
- if (_monitoring & MonitorInput) {
+ MonitorState ms = Track::monitoring_state();
+ if (ms == MonitoringSilence) {
return MonitoringInput;
- }
-
- if (_monitoring & MonitorDisk) {
- return MonitoringDisk;
- }
-
- if (_session.transport_rolling()) {
- return MonitoringDisk;
}
-
- /* the return value here doesn't mean that we're actually monitoring
- * input, let alone input *audio*. but it means that we are NOT
- * monitoring silence. this allows us to still hear any audio generated
- * by using internal generation techniques
- */
-
- return MonitoringInput;
+ return ms;
}
projects / ardour.git / blobdiff