_region->StateChanged.connect (mem_fun(*this, &MidiRegionView::region_changed));
set_colors ();
+
+ boost::shared_ptr<MidiRegion> mr = boost::dynamic_pointer_cast<MidiRegion> (_region);
+ mr->midi_source(0)->load_model();
+
+ begin_write();
+ for (size_t i=0; i < mr->midi_source(0)->model().n_events(); ++i)
+ add_event(mr->midi_source(0)->model().event_at(i));
+ end_write();
}
MidiRegionView::~MidiRegionView ()
MidiModel(size_t size=0);
~MidiModel();
+ void clear() { _events.clear(); }
+
/** Resizes vector if necessary (NOT realtime safe) */
void append(const MidiBuffer& data);
+ /** Resizes vector if necessary (NOT realtime safe) */
+ void append(const MidiEvent& ev);
+
inline const MidiEvent& event_at(unsigned i) const { return _events[i]; }
inline size_t n_events() const { return _events.size(); }
protected:
/* playlist "callbacks" */
- void flush_notifications ();
void finalize_split_region (boost::shared_ptr<Region> original, boost::shared_ptr<Region> left, boost::shared_ptr<Region> right);
void remove_dependents (boost::shared_ptr<Region> region);
private:
- XMLNode& state (bool full_state);
void dump () const;
bool region_changed (Change, boost::shared_ptr<Region>);
MidiRegion (boost::shared_ptr<MidiSource>, const XMLNode&);
MidiRegion (SourceList &, const XMLNode&);
- private:
- friend class Playlist;
-
private:
nframes_t _read_at (const SourceList&, MidiRingBuffer& dst,
nframes_t position,
void recompute_at_start ();
void recompute_at_end ();
+
+ protected:
+
+ int set_live_state (const XMLNode&, Change&, bool send);
};
} /* namespace ARDOUR */
XMLNode& get_state ();
int set_state (const XMLNode&);
+ virtual void load_model(bool lock=true) = 0;
+ virtual void destroy_model() = 0;
+
MidiModel& model() { return _model; }
protected:
protected:
XMLNode& state (bool full);
+
+ int _set_state (const XMLNode&, bool call_base);
private:
int set_diskstream (boost::shared_ptr<MidiDiskstream> ds);
-
void set_state_part_two ();
void set_state_part_three ();
};
int set_state (const XMLNode&);
void seek_to(nframes_t time);
+
+ void load_model(bool lock=true);
+ void destroy_model();
private:
}
}
+
+/** Append \a in_event to model. NOT (even remotely) realtime safe.
+ *
+ * Timestamps of events in \a buf are expected to be relative to
+ * the start of this model (t=0) and MUST be monotonically increasing
+ * and MUST be >= the latest event currently in the model.
+ *
+ * Events in buf are deep copied.
+ */
+void
+MidiModel::append(const MidiEvent& in_event)
+{
+ assert(_events.empty() || in_event.time >= _events.back().time);
+
+ _events.push_back(in_event);
+ MidiEvent& my_event = _events.back();
+ assert(my_event.time == in_event.time);
+ assert(my_event.size == in_event.size);
+
+ my_event.buffer = new Byte[my_event.size];
+ memcpy(my_event.buffer, in_event.buffer, my_event.size);
+}
+
const XMLProperty* prop = node.property("type");
assert(prop && DataType(prop->value()) == DataType::MIDI);
- in_set_state = true;
+ in_set_state++;
set_state (node);
- in_set_state = false;
+ in_set_state--;
}
MidiPlaylist::MidiPlaylist (Session& session, string name, bool hidden)
MidiPlaylist::~MidiPlaylist ()
{
GoingAway (); /* EMIT SIGNAL */
+
+ /* drop connections to signals */
+
+ notify_callbacks ();
}
struct RegionSortByLayer {
void
MidiPlaylist::remove_dependents (boost::shared_ptr<Region> region)
{
+ /* MIDI regions have no dependents (crossfades) */
}
-void
-MidiPlaylist::flush_notifications ()
-{
- Playlist::flush_notifications();
-
- if (in_flush) {
- return;
- }
-
- in_flush = true;
-
- in_flush = false;
-}
-
void
MidiPlaylist::refresh_dependents (boost::shared_ptr<Region> r)
{
+ /* MIDI regions have no dependents (crossfades) */
}
void
void
MidiPlaylist::check_dependents (boost::shared_ptr<Region> r, bool norefresh)
{
+ /* MIDI regions have no dependents (crossfades) */
}
int
MidiPlaylist::set_state (const XMLNode& node)
{
- if (!in_set_state) {
- Playlist::set_state (node);
- }
-
- // Actually Charles, I don't much care for children
-
- /*
- XMLNodeList nlist = node.children();
-
- for (XMLNodeConstIterator niter = nlist.begin(); niter != nlist.end(); ++niter) {
+ in_set_state++;
+ freeze ();
- XMLNode* const child = *niter;
+ Playlist::set_state (node);
- }*/
+ thaw();
+ in_set_state--;
return 0;
}
-XMLNode&
-MidiPlaylist::state (bool full_state)
-{
- XMLNode& node = Playlist::state (full_state);
-
- return node;
-}
-
void
MidiPlaylist::dump () const
{
#include <pbd/basename.h>
#include <pbd/xml++.h>
+#include <pbd/enumwriter.h>
#include <ardour/midi_region.h>
#include <ardour/session.h>
MidiRegion::state (bool full)
{
XMLNode& node (Region::state (full));
- XMLNode *child;
char buf[64];
char buf2[64];
LocaleGuard lg (X_("POSIX"));
- snprintf (buf, sizeof (buf), "0x%x", (int) _flags);
- node.add_property ("flags", buf);
-
+ node.add_property ("flags", enum_2_string (_flags));
+
for (uint32_t n=0; n < _sources.size(); ++n) {
snprintf (buf2, sizeof(buf2), "source-%d", n);
_sources[n]->id().print (buf, sizeof(buf));
node.add_property (buf2, buf);
}
- snprintf (buf, sizeof (buf), "%u", (uint32_t) _sources.size());
- node.add_property ("channels", buf);
-
- child = node.add_child ("Envelope");
-
- if ( ! full) {
- child->add_property ("default", "yes");
- }
-
if (full && _extra_xml) {
node.add_child_copy (*_extra_xml);
}
}
int
-MidiRegion::set_state (const XMLNode& node)
+MidiRegion::set_live_state (const XMLNode& node, Change& what_changed, bool send)
{
- const XMLNodeList& nlist = node.children();
const XMLProperty *prop;
LocaleGuard lg (X_("POSIX"));
- Region::set_state (node);
+ Region::set_live_state (node, what_changed, false);
+ uint32_t old_flags = _flags;
+
if ((prop = node.property ("flags")) != 0) {
- _flags = Flag (strtol (prop->value().c_str(), (char **) 0, 16));
+ _flags = Flag (string_2_enum (prop->value(), _flags));
+
+ //_flags = Flag (strtol (prop->value().c_str(), (char **) 0, 16));
+
+ _flags = Flag (_flags & ~Region::LeftOfSplit);
+ _flags = Flag (_flags & ~Region::RightOfSplit);
}
- /* Now find child items */
- for (XMLNodeConstIterator niter = nlist.begin(); niter != nlist.end(); ++niter) {
-
- XMLNode *child;
- //XMLProperty *prop;
-
- child = (*niter);
-
- /** Hello, children */
+ if ((old_flags ^ _flags) & Muted) {
+ what_changed = Change (what_changed|MuteChanged);
+ }
+ if ((old_flags ^ _flags) & Opaque) {
+ what_changed = Change (what_changed|OpacityChanged);
+ }
+ if ((old_flags ^ _flags) & Locked) {
+ what_changed = Change (what_changed|LockChanged);
+ }
+
+ if (send) {
+ send_change (what_changed);
}
return 0;
}
+int
+MidiRegion::set_state (const XMLNode& node)
+{
+ /* Region::set_state() calls the virtual set_live_state(),
+ which will get us back to AudioRegion::set_live_state()
+ to handle the relevant stuff.
+ */
+
+ return Region::set_state (node);
+}
+
void
MidiRegion::recompute_at_end ()
{
#include <sigc++/retype_return.h>
#include <sigc++/bind.h>
+#include <pbd/enumwriter.h>
+
#include <ardour/midi_track.h>
#include <ardour/midi_diskstream.h>
#include <ardour/session.h>
MidiTrack::MidiTrack (Session& sess, const XMLNode& node)
: Track (sess, node)
{
- _freeze_record.state = NoFreeze;
- set_state (node);
- _declickable = true;
- _saved_meter_point = _meter_point;
+ _set_state(node, false);
set_input_minimum(ChanCount(DataType::MIDI, 1));
set_input_maximum(ChanCount(DataType::MIDI, 1));
int
MidiTrack::set_state (const XMLNode& node)
+{
+ return _set_state (node, true);
+}
+
+int
+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;
- }
+ _mode = TrackMode (string_2_enum (prop->value(), _mode));
} else {
_mode = Normal;
}
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);
}
}
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<FreezeRecordInsertInfo*>::iterator i = _freeze_record.insert_info.begin(); i != _freeze_record.insert_info.end(); ++i) {
inode = new XMLNode (X_("insert"));
/* 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);
+ 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_("mode"), enum_2_string (_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->id().print (buf, sizeof(buf));
root.add_property ("diskstream-id", buf);
+
+ root.add_child_nocopy (_rec_enable_control.get_state());
return root;
}
}
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;
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);
+
+ /* fix for older sessions from before EnumWriter */
+
+ string pstr;
+
+ if (prop->value() == "capture") {
+ pstr = "CaptureTime";
+ } else if (prop->value() == "existing") {
+ pstr = "ExistingMaterial";
+ } else {
+ pstr = prop->value();
}
+
+ AlignStyle as = AlignStyle (string_2_enum (pstr, as));
+ _diskstream->set_persistent_align_style (as);
}
}
return;
#include <ardour/playlist.h>
#include <ardour/audioplaylist.h>
#include <ardour/audio_track.h>
+#include <ardour/midi_playlist.h>
+#include <ardour/midi_track.h>
#include <ardour/tempo.h>
#include <ardour/audiosource.h>
#include <ardour/audioregion.h>
return new MementoCommand<Locations>(_locations, before, after);
} else if (obj_T == typeid (TempoMap).name()) {
return new MementoCommand<TempoMap>(*_tempo_map, before, after);
- } else if (obj_T == typeid (Playlist).name() || obj_T == typeid (AudioPlaylist).name()) {
+ } else if (obj_T == typeid (Playlist).name() || obj_T == typeid (AudioPlaylist).name() || obj_T == typeid (MidiPlaylist).name()) {
if (boost::shared_ptr<Playlist> pl = playlist_by_name(child->property("name")->value())) {
return new MementoCommand<Playlist>(*(pl.get()), before, after);
}
- } else if (obj_T == typeid (Route).name() || obj_T == typeid (AudioTrack).name()) {
+ } else if (obj_T == typeid (Route).name() || obj_T == typeid (AudioTrack).name() || obj_T == typeid(MidiTrack).name()) {
return new MementoCommand<Route>(*route_by_id(id), before, after);
} else if (obj_T == typeid (Curve).name() || obj_T == typeid (AutomationList).name()) {
if (automation_lists.count(id))
/* Object loading order:
- MIDI
+ MIDI Control
Path
extra
Options/Config
nchans = atoi (prop->value().c_str());
}
-
if ((prop = node.property ("name")) == 0) {
cerr << "no name for this region\n";
abort ();
}
}
-
return region;
}
const XMLProperty* prop;
boost::shared_ptr<Source> source;
boost::shared_ptr<MidiSource> ms;
- MidiRegion::SourceList sources;
+ SourceList sources;
uint32_t nchans = 1;
if (node.name() != X_("Region")) {
if ((prop = node.property (X_("channels"))) != 0) {
nchans = atoi (prop->value().c_str());
}
+
+ if ((prop = node.property ("name")) == 0) {
+ cerr << "no name for this region\n";
+ abort ();
+ }
// Multiple midi channels? that's just crazy talk
assert(nchans == 1);
try {
boost::shared_ptr<MidiRegion> region (boost::dynamic_pointer_cast<MidiRegion> (RegionFactory::create (sources, node)));
+ /* a final detail: this is the one and only place that we know how long missing files are */
+
+ if (region->whole_file()) {
+ for (SourceList::iterator sx = sources.begin(); sx != sources.end(); ++sx) {
+ boost::shared_ptr<SilentFileSource> sfp = boost::dynamic_pointer_cast<SilentFileSource> (*sx);
+ if (sfp) {
+ sfp->set_length (region->length());
+ }
+ }
+ }
+
return region;
}
node->add_child_nocopy (i->second->get_state());
}
- /* XXX get MIDI and other sources here */
-
return *node;
}
return value;
}
+
+void
+SMFSource::load_model(bool lock)
+{
+ if (lock)
+ Glib::Mutex::Lock lm (_lock);
+
+ _model.clear();
+
+ fseek(_fd, _header_size, 0);
+
+ nframes_t time = 0;
+ MidiEvent ev;
+
+ int ret;
+ while ((ret = read_event(ev)) >= 0) {
+ time += ev.time;
+ ev.time = time;
+ if (ret > 0) { // didn't skip (meta) event
+ _model.append(ev);
+ }
+ }
+}
+
+void
+SMFSource::destroy_model()
+{
+ _model.clear();
+}
+
projects / ardour.git / commitdiff