#define isnan_local std::isnan
#endif
-#include "pbd/ffs.h"
#include "pbd/enumwriter.h"
-#include "pbd/convert.h"
+#include "pbd/types_convert.h"
#include "evoral/midi_util.h"
+#include "ardour/beats_frames_converter.h"
#include "ardour/buffer_set.h"
#include "ardour/debug.h"
#include "ardour/delivery.h"
#include "ardour/midi_diskstream.h"
#include "ardour/midi_playlist.h"
#include "ardour/midi_port.h"
+#include "ardour/midi_region.h"
#include "ardour/midi_track.h"
+#include "ardour/monitor_control.h"
#include "ardour/parameter_types.h"
#include "ardour/port.h"
#include "ardour/processor.h"
+#include "ardour/profile.h"
+#include "ardour/route_group_specialized.h"
#include "ardour/session.h"
#include "ardour/session_playlists.h"
+#include "ardour/types_convert.h"
#include "ardour/utils.h"
-#include "i18n.h"
+#include "pbd/i18n.h"
namespace ARDOUR {
class InterThreadInfo;
using namespace ARDOUR;
using namespace PBD;
-MidiTrack::MidiTrack (Session& sess, string name, Route::Flag flag, TrackMode mode)
- : Track (sess, name, flag, mode, DataType::MIDI)
- , _immediate_events(1024) // FIXME: size?
+MidiTrack::MidiTrack (Session& sess, string name, TrackMode mode)
+ : Track (sess, name, PresentationInfo::MidiTrack, mode, DataType::MIDI)
+ , _immediate_events(6096) // FIXME: size?
, _step_edit_ring_buffer(64) // FIXME: size?
, _note_mode(Sustained)
, _step_editing (false)
, _input_active (true)
- , _playback_channel_mask(0x0000ffff)
- , _capture_channel_mask(0x0000ffff)
{
+ _session.SessionLoaded.connect_same_thread (*this, boost::bind (&MidiTrack::restore_controls, this));
}
MidiTrack::~MidiTrack ()
}
-void
-MidiTrack::set_record_enabled (bool yn, void *src)
+bool
+MidiTrack::can_be_record_safe ()
{
if (_step_editing) {
- return;
+ return false;
+ }
+
+ return Track::can_be_record_safe ();
+}
+
+bool
+MidiTrack::can_be_record_enabled ()
+{
+ if (_step_editing) {
+ return false;
}
- Track::set_record_enabled (yn, src);
+ return Track::can_be_record_enabled ();
}
void
*/
boost::shared_ptr<MidiDiskstream> mds = boost::dynamic_pointer_cast<MidiDiskstream> (ds);
mds->set_note_mode (_note_mode);
-
+
Track::set_diskstream (ds);
- mds->reset_tracker ();
+ mds->reset_tracker ();
_diskstream->set_track (this);
- _diskstream->set_destructive (_mode == Destructive);
+#ifdef XXX_OLD_DESTRUCTIVE_API_XXX
+ if (Profile->get_trx()) {
+ _diskstream->set_destructive (false);
+ } else {
+ _diskstream->set_destructive (_mode == Destructive);
+ }
+#endif
_diskstream->set_record_enabled (false);
_diskstream_data_recorded_connection.disconnect ();
int
MidiTrack::set_state (const XMLNode& node, int version)
{
- const XMLProperty *prop;
-
/* 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 {
+ if (!node.get_property (X_("note-mode"), _note_mode)) {
_note_mode = Sustained;
}
// No destructive MIDI tracks (yet?)
_mode = Normal;
- if ((prop = node.property ("input-active")) != 0) {
- set_input_active (string_is_affirmative (prop->value()));
+ bool yn;
+ if (node.get_property ("input-active", yn)) {
+ set_input_active (yn);
}
ChannelMode playback_channel_mode = AllChannels;
ChannelMode capture_channel_mode = AllChannels;
- if ((prop = node.property ("playback-channel-mode")) != 0) {
- playback_channel_mode = ChannelMode (string_2_enum(prop->value(), playback_channel_mode));
- }
- if ((prop = node.property ("capture-channel-mode")) != 0) {
- capture_channel_mode = ChannelMode (string_2_enum(prop->value(), capture_channel_mode));
- }
- if ((prop = node.property ("channel-mode")) != 0) {
+ node.get_property ("playback-channel-mode", playback_channel_mode);
+ node.get_property ("capture-channel-mode", capture_channel_mode);
+
+ if (node.get_property ("channel-mode", playback_channel_mode)) {
/* 3.0 behaviour where capture and playback modes were not separated */
- playback_channel_mode = ChannelMode (string_2_enum(prop->value(), playback_channel_mode));
capture_channel_mode = playback_channel_mode;
}
+ XMLProperty const * prop;
+
unsigned int playback_channel_mask = 0xffff;
unsigned int capture_channel_mask = 0xffff;
XMLNode* inode;
freeze_node = new XMLNode (X_("freeze-info"));
- freeze_node->add_property ("playlist", _freeze_record.playlist->name());
- freeze_node->add_property ("state", enum_2_string (_freeze_record.state));
+ freeze_node->set_property ("playlist", _freeze_record.playlist->name());
+ freeze_node->set_property ("state", _freeze_record.state);
for (vector<FreezeRecordProcessorInfo*>::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->set_property (X_("id"), id());
inode->add_child_copy ((*i)->state);
freeze_node->add_child_nocopy (*inode);
root.add_child_nocopy (*freeze_node);
}
- root.add_property("playback_channel-mode", enum_2_string(get_playback_channel_mode()));
- root.add_property("capture_channel-mode", enum_2_string(get_capture_channel_mode()));
+ root.set_property("playback-channel-mode", get_playback_channel_mode());
+ root.set_property("capture-channel-mode", get_capture_channel_mode());
snprintf (buf, sizeof(buf), "0x%x", get_playback_channel_mask());
- root.add_property("playback-channel-mask", buf);
+ root.set_property("playback-channel-mask", std::string(buf));
snprintf (buf, sizeof(buf), "0x%x", get_capture_channel_mask());
- root.add_property("capture-channel-mask", buf);
+ root.set_property("capture-channel-mask", std::string(buf));
+
+ root.set_property ("note-mode", _note_mode);
+ root.set_property ("step-editing", _step_editing);
+ root.set_property ("input-active", _input_active);
- root.add_property ("note-mode", enum_2_string (_note_mode));
- root.add_property ("step-editing", (_step_editing ? "yes" : "no"));
- root.add_property ("input-active", (_input_active ? "yes" : "no"));
+ for (Controls::const_iterator c = _controls.begin(); c != _controls.end(); ++c) {
+ if (boost::dynamic_pointer_cast<MidiTrack::MidiControl>(c->second)) {
+ boost::shared_ptr<AutomationControl> ac = boost::dynamic_pointer_cast<AutomationControl> (c->second);
+ assert (ac);
+ root.add_child_nocopy (ac->get_state ());
+ }
+ }
return root;
}
MidiTrack::set_state_part_two ()
{
XMLNode* fnode;
- XMLProperty* prop;
- LocaleGuard lg (X_("C"));
/* This is called after all session state has been restored but before
have been made ports and connections are established.
}
_freeze_record.processor_info.clear ();
- if ((prop = fnode->property (X_("playlist"))) != 0) {
- boost::shared_ptr<Playlist> pl = _session.playlists->by_name (prop->value());
+ std::string str;
+ if (fnode->get_property (X_("playlist"), str)) {
+ boost::shared_ptr<Playlist> pl = _session.playlists->by_name (str);
if (pl) {
_freeze_record.playlist = boost::dynamic_pointer_cast<MidiPlaylist> (pl);
} else {
_freeze_record.playlist.reset();
_freeze_record.state = NoFreeze;
- return;
+ return;
}
}
- if ((prop = fnode->property (X_("state"))) != 0) {
- _freeze_record.state = FreezeState (string_2_enum (prop->value(), _freeze_record.state));
- }
+ fnode->get_property (X_("state"), _freeze_record.state);
XMLNodeConstIterator citer;
XMLNodeList clist = fnode->children();
continue;
}
- if ((prop = (*citer)->property (X_("id"))) == 0) {
+ if (!(*citer)->get_property (X_("id"), str)) {
continue;
}
FreezeRecordProcessorInfo* frii = new FreezeRecordProcessorInfo (*((*citer)->children().front()),
boost::shared_ptr<Processor>());
- frii->id = prop->value ();
+ frii->id = str;
_freeze_record.processor_info.push_back (frii);
}
}
return;
}
+void
+MidiTrack::restore_controls ()
+{
+ // TODO order events (CC before PGM to set banks)
+ for (Controls::const_iterator c = _controls.begin(); c != _controls.end(); ++c) {
+ boost::shared_ptr<MidiTrack::MidiControl> mctrl = boost::dynamic_pointer_cast<MidiTrack::MidiControl>(c->second);
+ if (mctrl) {
+ mctrl->restore_value();
+ }
+ }
+}
+
+void
+MidiTrack::update_controls(const BufferSet& bufs)
+{
+ const MidiBuffer& buf = bufs.get_midi(0);
+ for (MidiBuffer::const_iterator e = buf.begin(); e != buf.end(); ++e) {
+ const Evoral::Event<framepos_t>& ev = *e;
+ const Evoral::Parameter param = midi_parameter(ev.buffer(), ev.size());
+ const boost::shared_ptr<Evoral::Control> control = this->control(param);
+ if (control) {
+ control->set_double(ev.value(), _session.transport_frame(), false);
+ }
+ }
+}
+
/** @param need_butler to be set to true if this track now needs the butler, otherwise it can be left alone
* or set to false.
*/
if (!lm.locked()) {
boost::shared_ptr<MidiDiskstream> diskstream = midi_diskstream();
framecnt_t playback_distance = diskstream->calculate_playback_distance(nframes);
- if (can_internal_playback_seek(llabs(playback_distance))) {
+ if (can_internal_playback_seek(::llabs(playback_distance))) {
/* TODO should declick, and/or note-off */
internal_playback_seek(playback_distance);
}
if (!_active) {
silence (nframes);
- if (_meter_point == MeterInput && (_monitoring & MonitorInput || _diskstream->record_enabled())) {
+ if (_meter_point == MeterInput && ((_monitoring_control->monitoring_choice() & MonitorInput) || _diskstream->record_enabled())) {
_meter->reset();
}
return 0;
fill_buffers_with_input (bufs, _input, nframes);
- if (_meter_point == MeterInput && (_monitoring & MonitorInput || _diskstream->record_enabled())) {
- _meter->run (bufs, start_frame, end_frame, nframes, true);
- }
+ /* filter captured data before meter sees it */
+ _capture_filter.filter (bufs);
- /* filter captured data before the diskstream sees it */
+ if (_meter_point == MeterInput && ((_monitoring_control->monitoring_choice() & MonitorInput) || _diskstream->record_enabled())) {
+ _meter->run (bufs, start_frame, end_frame, 1.0 /*speed()*/, nframes, true);
+ }
- filter_channels (bufs, get_capture_channel_mode(), get_capture_channel_mask());
_silent = false;
return dret;
}
- /* filter playback data before we do anything else */
-
- filter_channels (bufs, get_playback_channel_mode(), get_playback_channel_mask ());
+ /* note diskstream uses our filter to filter/map playback channels appropriately. */
if (monitoring_state() == MonitoringInput) {
diskstream->flush_playback (start_frame, end_frame);
- }
+ }
+
-
/* append immediate messages to the first MIDI buffer (thus sending it to the first output port) */
-
+
write_out_of_band_data (bufs, start_frame, end_frame, nframes);
-
+
/* final argument: don't waste time with automation if we're not recording or rolling */
-
+
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) {
- boost::shared_ptr<Delivery> d = boost::dynamic_pointer_cast<Delivery> (*i);
- if (d) {
- d->flush_buffers (nframes);
- }
- }
+ flush_processor_buffers_locked (nframes);
need_butler = diskstream->commit (playback_distance);
-
+
return 0;
}
}
}
+void
+MidiTrack::non_realtime_locate (framepos_t pos)
+{
+ Track::non_realtime_locate(pos);
+
+ boost::shared_ptr<MidiPlaylist> playlist = midi_diskstream()->midi_playlist();
+ if (!playlist) {
+ return;
+ }
+
+ /* Get the top unmuted region at this position. */
+ boost::shared_ptr<MidiRegion> region = boost::dynamic_pointer_cast<MidiRegion>(
+ playlist->top_unmuted_region_at(pos));
+ if (!region) {
+ return;
+ }
+
+ /* the source may be missing, but the control still referenced in the GUI */
+ if (!region->midi_source() || !region->model()) {
+ return;
+ }
+
+ Glib::Threads::Mutex::Lock lm (_control_lock, Glib::Threads::TRY_LOCK);
+ if (!lm.locked()) {
+ return;
+ }
+
+ /* Update track controllers based on its "automation". */
+ const framepos_t origin = region->position() - region->start();
+ BeatsFramesConverter bfc(_session.tempo_map(), origin);
+ for (Controls::const_iterator c = _controls.begin(); c != _controls.end(); ++c) {
+ boost::shared_ptr<MidiTrack::MidiControl> tcontrol;
+ boost::shared_ptr<Evoral::Control> rcontrol;
+ if ((tcontrol = boost::dynamic_pointer_cast<MidiTrack::MidiControl>(c->second)) &&
+ (rcontrol = region->control(tcontrol->parameter()))) {
+ const Evoral::Beats pos_beats = bfc.from(pos - origin);
+ if (rcontrol->list()->size() > 0) {
+ tcontrol->set_value(rcontrol->list()->eval(pos_beats.to_double()), Controllable::NoGroup);
+ }
+ }
+ }
+}
+
void
MidiTrack::push_midi_input_to_step_edit_ringbuffer (framecnt_t nframes)
{
for (MidiBuffer::const_iterator e = mb->begin(); e != mb->end(); ++e) {
- const Evoral::MIDIEvent<framepos_t> ev(*e, false);
+ const Evoral::Event<framepos_t> ev(*e, false);
/* note on, since for step edit, note length is determined
elsewhere
if (ev.is_note_on()) {
/* we don't care about the time for this purpose */
- _step_edit_ring_buffer.write (0, ev.type(), ev.size(), ev.buffer());
- }
- }
- }
-}
-
-void
-MidiTrack::filter_channels (BufferSet& bufs, ChannelMode mode, uint32_t mask)
-{
- if (mode == AllChannels) {
- return;
- }
-
- MidiBuffer& buf (bufs.get_midi (0));
-
- for (MidiBuffer::iterator e = buf.begin(); e != buf.end(); ) {
-
- Evoral::MIDIEvent<framepos_t> ev(*e, false);
-
- if (ev.is_channel_event()) {
- switch (mode) {
- case FilterChannels:
- if (0 == ((1<<ev.channel()) & mask)) {
- e = buf.erase (e);
- } else {
- ++e;
- }
- break;
- case ForceChannel:
- ev.set_channel (PBD::ffs (mask) - 1);
- ++e;
- break;
- case AllChannels:
- /* handled by the opening if() */
- ++e;
- break;
+ _step_edit_ring_buffer.write (0, ev.event_type(), ev.size(), ev.buffer());
}
- } else {
- ++e;
}
}
}
{
MidiBuffer& buf (bufs.get_midi (0));
+ update_controls (bufs);
+
// Append immediate events
if (_immediate_events.read_space()) {
cerr << "WARNING: Ignoring illegal immediate MIDI event" << endl;
return false;
}
- const uint32_t type = midi_parameter_type(buf[0]);
- return (_immediate_events.write (0, type, size, buf) == size);
+ return (_immediate_events.write (0, Evoral::MIDI_EVENT, size, buf) == size);
}
void
case MidiPgmChangeAutomation:
case MidiPitchBenderAutomation:
case MidiChannelPressureAutomation:
+ case MidiNotePressureAutomation:
case MidiSystemExclusiveAutomation:
/* The track control for MIDI parameters is for immediate events to act
as a control surface, write/touch for them is not currently
}
void
-MidiTrack::MidiControl::set_value(double val)
+MidiTrack::MidiControl::restore_value ()
+{
+ actually_set_value (get_value(), Controllable::NoGroup);
+}
+
+void
+MidiTrack::MidiControl::actually_set_value (double val, PBD::Controllable::GroupControlDisposition group_override)
{
const Evoral::Parameter ¶meter = _list ? _list->parameter() : Control::parameter();
const Evoral::ParameterDescriptor &desc = EventTypeMap::instance().descriptor(parameter);
ev[1] = int(val);
break;
+ case MidiNotePressureAutomation:
+ ev[0] += MIDI_CMD_NOTE_PRESSURE;
+ ev[1] = parameter.id();
+ ev[2] = int(val);
+ break;
+
case MidiPitchBenderAutomation:
ev[0] += MIDI_CMD_BENDER;
ev[1] = 0x7F & int(val);
_route->write_immediate_event(size, ev);
}
- AutomationControl::set_value(val);
+ AutomationControl::actually_set_value(val, group_override);
}
void
}
void
-MidiTrack::set_playback_channel_mode(ChannelMode mode, uint16_t mask)
+MidiTrack::set_playback_channel_mode(ChannelMode mode, uint16_t mask)
{
- ChannelMode old = get_playback_channel_mode ();
- uint16_t old_mask = get_playback_channel_mask ();
-
- if (old != mode || mask != old_mask) {
- _set_playback_channel_mode (mode, mask);
- PlaybackChannelModeChanged ();
- _session.set_dirty ();
+ if (_playback_filter.set_channel_mode(mode, mask)) {
+ _session.set_dirty();
}
}
void
-MidiTrack::set_capture_channel_mode(ChannelMode mode, uint16_t mask)
+MidiTrack::set_capture_channel_mode(ChannelMode mode, uint16_t mask)
{
- ChannelMode old = get_capture_channel_mode ();
- uint16_t old_mask = get_capture_channel_mask ();
-
- if (old != mode || mask != old_mask) {
- _set_capture_channel_mode (mode, mask);
- CaptureChannelModeChanged ();
- _session.set_dirty ();
+ if (_capture_filter.set_channel_mode(mode, mask)) {
+ _session.set_dirty();
}
}
void
MidiTrack::set_playback_channel_mask (uint16_t mask)
{
- uint16_t old = get_playback_channel_mask();
-
- if (old != mask) {
- _set_playback_channel_mask (mask);
- PlaybackChannelMaskChanged ();
- _session.set_dirty ();
+ if (_playback_filter.set_channel_mask(mask)) {
+ _session.set_dirty();
}
}
void
MidiTrack::set_capture_channel_mask (uint16_t mask)
{
- uint16_t old = get_capture_channel_mask();
-
- if (old != mask) {
- _set_capture_channel_mask (mask);
- CaptureChannelMaskChanged ();
- _session.set_dirty ();
+ if (_capture_filter.set_channel_mask(mask)) {
+ _session.set_dirty();
}
}
return;
}
- if (muted()) {
+ if (muted() || _mute_master->muted_by_others_soloing_at (MuteMaster::AllPoints)) {
/* only send messages for channels we are using */
- uint16_t mask = get_playback_channel_mask();
+ uint16_t mask = _playback_filter.get_channel_mask();
for (uint8_t channel = 0; channel <= 0xF; channel++) {
DEBUG_TRACE (DEBUG::MidiIO, string_compose ("%1 delivers mute message to channel %2\n", name(), channel+1));
uint8_t ev[3] = { ((uint8_t) (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);
+
+ /* Note we do not send MIDI_CTL_ALL_NOTES_OFF here, since this may
+ silence notes that came from another non-muted track. */
}
}
+
+ /* Resolve active notes. */
+ midi_diskstream()->resolve_tracker(_immediate_events, Port::port_offset());
}
}
-
+
void
-MidiTrack::set_monitoring (MonitorChoice mc)
+MidiTrack::monitoring_changed (bool self, Controllable::GroupControlDisposition gcd)
{
- if (mc != _monitoring) {
+ Track::monitoring_changed (self, gcd);
- Track::set_monitoring (mc);
-
- /* monitoring state changed, so flush out any on notes at the
- * port level.
- */
+ /* monitoring state changed, so flush out any on notes at the
+ * port level.
+ */
- 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 ();
- }
- }
+ PortSet& ports (_output->ports());
- boost::shared_ptr<MidiDiskstream> md (midi_diskstream());
-
- if (md) {
- md->reset_tracker ();
+ 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 ();
}
}
+
+ boost::shared_ptr<MidiDiskstream> md (midi_diskstream());
+
+ if (md) {
+ md->reset_tracker ();
+ }
}
MonitorState
MonitorState ms = Track::monitoring_state();
if (ms == MonitoringSilence) {
return MonitoringInput;
- }
+ }
return ms;
}
-