} else if (mr) {
items.push_back (MenuElem (_("Quantize"), sigc::mem_fun(*this, &Editor::quantize_region)));
+ items.push_back (MenuElem (_("Fork"), sigc::mem_fun(*this, &Editor::fork_region)));
items.push_back (SeparatorElem());
}
void reset_region_scale_amplitude ();
void adjust_region_scale_amplitude (bool up);
void quantize_region ();
+ void fork_region ();
void do_insert_time ();
void insert_time (nframes64_t, nframes64_t, Editing::InsertTimeOption, bool, bool, bool);
rs.clear ();
}
+void
+Editor::fork_region ()
+{
+ RegionSelection rs;
+
+ get_regions_for_action (rs);
+
+ if (rs.empty()) {
+ return;
+ }
+
+ begin_reversible_command (_("Fork Region(s)"));
+
+ track_canvas->get_window()->set_cursor (*wait_cursor);
+ gdk_flush ();
+
+ for (RegionSelection::iterator r = rs.begin(); r != rs.end(); ) {
+ RegionSelection::iterator tmp = r;
+ ++tmp;
+
+ MidiRegionView* const mrv = dynamic_cast<MidiRegionView*>(*r);
+
+ if (mrv) {
+ boost::shared_ptr<Playlist> playlist = mrv->region()->playlist();
+ boost::shared_ptr<MidiRegion> newregion = mrv->midi_region()->clone ();
+
+ playlist->clear_history ();
+ cerr << "Replace region with " << newregion->name() << endl;
+ playlist->replace_region (mrv->region(), newregion, mrv->region()->position());
+ _session->add_command(new StatefulDiffCommand (playlist));
+ }
+
+ r = tmp;
+ }
+
+ commit_reversible_command ();
+ rs.clear ();
+
+ track_canvas->get_window()->set_cursor (*current_canvas_cursor);
+}
+
void
Editor::quantize_region ()
{
using namespace ARDOUR;
MidiCutBuffer::MidiCutBuffer (Session* s)
- : AutomatableSequence<MidiModel::TimeType> (*s, 0)
+ : AutomatableSequence<MidiModel::TimeType> (*s)
, _origin (0)
{
};
virtual framecnt_t read (Sample*, framepos_t pos, framecnt_t cnt, int channel) const;
- virtual framecnt_t read_with_ops (Sample*, framepos_t pos, framecnt_t cnt, int channel, ReadOps rops) const;
virtual framecnt_t readable_length() const { return length(); }
virtual framecnt_t read_at (Sample *buf, Sample *mixdown_buf, float *gain_buf,
{
public:
Automatable(Session&);
+ Automatable (const Automatable& other);
Automatable();
virtual ~Automatable() {}
template<typename T>
class AutomatableSequence : public Automatable, public Evoral::Sequence<T> {
public:
- AutomatableSequence(Session& s, size_t /*size*/)
+ AutomatableSequence(Session& s)
: Evoral::ControlSet()
, Automatable(s)
, Evoral::Sequence<T>(EventTypeMap::instance())
{}
+
+ AutomatableSequence(const AutomatableSequence<T>& other)
+ : Evoral::ControlSet(other)
+ , Automatable(other._a_session)
+ , Evoral::Sequence<T>(other)
+ {}
+
};
} // namespace ARDOUR
extern uint64_t MidiClock;
extern uint64_t Monitor;
extern uint64_t Solo;
+ extern uint64_t AudioPlayback;
}
}
public:
typedef double TimeType;
- MidiModel(MidiSource* s, size_t size=0);
+ MidiModel(MidiSource* s);
NoteMode note_mode() const { return (percussive() ? Percussive : Sustained); }
void set_note_mode(NoteMode mode) { set_percussive(mode == Percussive); };
void apply_command(Session& session, Command* cmd);
void apply_command_as_subcommand(Session& session, Command* cmd);
- bool write_to(boost::shared_ptr<MidiSource> source);
+ bool write_to(boost::shared_ptr<MidiSource> source, Evoral::MusicalTime begin = Evoral::MinMusicalTime,
+ Evoral::MusicalTime end = Evoral::MaxMusicalTime);
// MidiModel doesn't use the normal AutomationList serialisation code
// since controller data is stored in the .mid
public:
~MidiRegion();
+ boost::shared_ptr<MidiRegion> clone ();
+
boost::shared_ptr<MidiSource> midi_source (uint32_t n=0) const;
/* Stub Readable interface */
MidiSource (Session& session, const XMLNode&);
virtual ~MidiSource ();
+ boost::shared_ptr<MidiSource> clone (Evoral::MusicalTime begin = Evoral::MinMusicalTime,
+ Evoral::MusicalTime end = Evoral::MaxMusicalTime);
+
/** Read the data in a given time range from the MIDI source.
* All time stamps in parameters are in audio frames (even if the source has tempo time).
* \param dst Ring buffer where read events are written
}
namespace ARDOUR {
-
+class MidiSource;
/** Tracks played notes, so they can be resolved in potential stuck note
* situations (e.g. looping, transport stop, etc).
void remove (uint8_t note, uint8_t chn);
void resolve_notes (MidiBuffer& buffer, nframes64_t time);
void resolve_notes (Evoral::EventSink<nframes_t>& buffer, nframes64_t time);
+ void resolve_notes (MidiSource& src, Evoral::MusicalTime time);
void dump (std::ostream&);
void reset ();
bool empty() const { return _on == 0; }
uint16_t on() const { return _on; }
+ bool active (uint8_t note, uint8_t channel) {
+ return _active_notes[(channel*128)+note] > 0;
+ }
private:
void track_note_onoffs(const Evoral::MIDIEvent<MidiBuffer::TimeType>& event);
return (x);
}
-std::string bump_name_once(std::string s);
+std::string bump_name_once(const std::string& s, char delimiter);
int cmp_nocase (const std::string& s, const std::string& s2);
#include "ardour/types.h"
+#include "ardour/debug.h"
#include "ardour/configuration.h"
#include "ardour/audioplaylist.h"
#include "ardour/audioregion.h"
if ((*i)->coverage (start, end) != OverlapNone) {
relevant_regions[(*i)->layer()].push_back (*i);
relevant_layers.push_back ((*i)->layer());
- }
+ }
}
for (Crossfades::iterator i = _crossfades.begin(); i != _crossfades.end(); ++i) {
vector<boost::shared_ptr<Region> > r (relevant_regions[*l]);
vector<boost::shared_ptr<Crossfade> >& x (relevant_xfades[*l]);
+
for (vector<boost::shared_ptr<Region> >::iterator i = r.begin(); i != r.end(); ++i) {
boost::shared_ptr<AudioRegion> ar = boost::dynamic_pointer_cast<AudioRegion>(*i);
+ DEBUG_TRACE (DEBUG::AudioPlayback, string_compose ("read from region %1\n", ar->name()));
assert(ar);
ar->read_at (buf, mixdown_buffer, gain_buffer, start, cnt, chan_n, read_frames, skip_frames);
_read_data_count += ar->read_data_count();
return _read_at (_sources, _length, buf, 0, 0, _position + timeline_position, cnt, channel, 0, 0, ReadOps (0));
}
-framecnt_t
-AudioRegion::read_with_ops (Sample* buf, framepos_t file_position, framecnt_t cnt, int channel, ReadOps rops) const
-{
- return _read_at (_sources, _length, buf, 0, 0, file_position, cnt, channel, 0, 0, rops);
-}
-
framecnt_t
AudioRegion::read_at (Sample *buf, Sample *mixdown_buffer, float *gain_buffer,
framepos_t file_position, framecnt_t cnt, uint32_t chan_n,
{
}
+Automatable::Automatable (const Automatable& other)
+ : ControlSet (other)
+ , _a_session (other._a_session)
+ , _last_automation_snapshot (0)
+{
+ Glib::Mutex::Lock lm (other._control_lock);
+
+ for (Controls::const_iterator i = other._controls.begin(); i != other._controls.end(); ++i) {
+ boost::shared_ptr<Evoral::Control> ac (control_factory (i->first));
+ _controls[ac->parameter()] = ac;
+ }
+}
int
Automatable::old_set_automation_state (const XMLNode& node)
{
uint64_t PBD::DEBUG::MidiClock = PBD::new_debug_bit ("midiclock");
uint64_t PBD::DEBUG::Monitor = PBD::new_debug_bit ("monitor");
uint64_t PBD::DEBUG::Solo = PBD::new_debug_bit ("solo");
+uint64_t PBD::DEBUG::AudioPlayback = PBD::new_debug_bit ("audioplayback");
#include "ardour/midi_model.h"
#include "ardour/midi_source.h"
+#include "ardour/midi_state_tracker.h"
#include "ardour/smf_source.h"
#include "ardour/types.h"
#include "ardour/session.h"
using namespace ARDOUR;
using namespace PBD;
-MidiModel::MidiModel(MidiSource* s, size_t size)
- : AutomatableSequence<TimeType>(s->session(), size)
+MidiModel::MidiModel(MidiSource* s)
+ : AutomatableSequence<TimeType>(s->session())
, _midi_source(s)
{
}
return *diff_command;
}
-/** Write the model to a MidiSource (i.e. save the model).
+/** Write part or all of the model to a MidiSource (i.e. save the model).
* This is different from manually using read to write to a source in that
* note off events are written regardless of the track mode. This is so the
* user can switch a recorded track (with note durations from some instrument)
* destroying the original note durations.
*/
bool
-MidiModel::write_to(boost::shared_ptr<MidiSource> source)
+MidiModel::write_to (boost::shared_ptr<MidiSource> source, Evoral::MusicalTime begin_time, Evoral::MusicalTime end_time)
{
ReadLock lock(read_lock());
+ MidiStateTracker mst;
+ Evoral::MusicalTime extra_note_on_time = end_time;
const bool old_percussive = percussive();
set_percussive(false);
source->mark_streaming_midi_write_started(note_mode(), _midi_source->timeline_position());
for (Evoral::Sequence<TimeType>::const_iterator i = begin(); i != end(); ++i) {
- source->append_event_unlocked_beats(*i);
- }
+ const Evoral::Event<Evoral::MusicalTime>& ev (*i);
+
+ if (ev.time() >= begin_time && ev.time() < end_time) {
+
+ const Evoral::MIDIEvent<Evoral::MusicalTime>* mev =
+ static_cast<const Evoral::MIDIEvent<Evoral::MusicalTime>* > (&ev);
+
+ if (!mev) {
+ continue;
+ }
+
+
+ if (mev->is_note_off()) {
+
+ if (!mst.active (mev->note(), mev->channel())) {
+
+ /* add a note-on at the start of the range we're writing
+ to the file. velocity is just an arbitary reasonable value.
+ */
+
+ Evoral::MIDIEvent<Evoral::MusicalTime> on (mev->event_type(), extra_note_on_time, 3, 0, true);
+ on.set_type (mev->type());
+ on.set_note (mev->note());
+ on.set_channel (mev->channel());
+ on.set_velocity (mev->velocity());
+
+ cerr << "Add note on for odd note off, note = " << (int) on.note() << endl;
+ source->append_event_unlocked_beats (on);
+ mst.add (on.note(), on.channel());
+ mst.dump (cerr);
+ extra_note_on_time += 1.0/128.0;
+ }
+
+ cerr << "MIDI Note off (note = " << (int) mev->note() << endl;
+ source->append_event_unlocked_beats (*i);
+ mst.remove (mev->note(), mev->channel());
+ mst.dump (cerr);
+
+ } else if (mev->is_note_on()) {
+ cerr << "MIDI Note on (note = " << (int) mev->note() << endl;
+ mst.add (mev->note(), mev->channel());
+ source->append_event_unlocked_beats(*i);
+ mst.dump (cerr);
+ } else {
+ cerr << "MIDI other event type\n";
+ source->append_event_unlocked_beats(*i);
+ }
+ }
+ }
+
+ mst.resolve_notes (*source, end_time);
set_percussive(old_percussive);
source->mark_streaming_write_completed();
#include "ardour/dB.h"
#include "ardour/playlist.h"
#include "ardour/midi_source.h"
+#include "ardour/region_factory.h"
#include "ardour/types.h"
#include "ardour/midi_ring_buffer.h"
{
}
+/** Create a new MidiRegion that has its own version of some/all of the Source used by another.
+ */
+boost::shared_ptr<MidiRegion>
+MidiRegion::clone ()
+{
+ BeatsFramesConverter bfc (_session.tempo_map(), _position);
+ double bbegin = bfc.from (_position);
+ double bend = bfc.from (last_frame() + 1);
+
+ boost::shared_ptr<MidiSource> ms = midi_source(0)->clone (bbegin, bend);
+
+ PropertyList plist;
+
+ plist.add (Properties::name, ms->name());
+ plist.add (Properties::whole_file, true);
+ plist.add (Properties::start, 0);
+ plist.add (Properties::length, _length);
+ plist.add (Properties::layer, 0);
+
+ return boost::dynamic_pointer_cast<MidiRegion> (RegionFactory::create (ms, plist, true));
+}
+
void
MidiRegion::set_position_internal (framepos_t pos, bool allow_bbt_recompute)
{
#include <iomanip>
#include <algorithm>
+#include <glibmm/fileutils.h>
+
#include "pbd/xml++.h"
#include "pbd/pthread_utils.h"
#include "pbd/basename.h"
}
}
+
MidiSource::~MidiSource ()
{
}
_writing = false;
}
+boost::shared_ptr<MidiSource>
+MidiSource::clone (Evoral::MusicalTime begin, Evoral::MusicalTime end)
+{
+ string newname = PBD::basename_nosuffix(_name.val());
+ string newpath;
+
+ /* get a new name for the MIDI file we're going to write to
+ */
+
+ do {
+
+ newname = bump_name_once (newname, '-');
+ /* XXX build path safely */
+ newpath = _session.session_directory().midi_path().to_string() +"/"+ newname + ".mid";
+
+ } while (Glib::file_test (newpath, Glib::FILE_TEST_EXISTS));
+
+ boost::shared_ptr<MidiSource> newsrc = boost::dynamic_pointer_cast<MidiSource>(
+ SourceFactory::createWritable(DataType::MIDI, _session,
+ newpath, false, _session.frame_rate()));
+
+ newsrc->set_timeline_position(_timeline_position);
+
+ if (_model) {
+ _model->write_to (newsrc, begin, end);
+ } else {
+ error << string_compose (_("programming error: %1"), X_("no model for MidiSource during ::clone()"));
+ return boost::shared_ptr<MidiSource>();
+ }
+
+ newsrc->flush_midi();
+
+ /* force a reload of the model if the range is partial */
+
+ if (begin != Evoral::MinMusicalTime || end != Evoral::MaxMusicalTime) {
+ newsrc->load_model (true, true);
+ }
+
+ return newsrc;
+}
+
void
MidiSource::session_saved()
{
flush_midi();
if (_model && _model->edited()) {
- string newname;
- const string basename = PBD::basename_nosuffix(_name.val());
- string::size_type last_dash = basename.find_last_of("-");
- if (last_dash == string::npos || last_dash == basename.find_first_of("-")) {
- newname = basename + "-1";
- } else {
- stringstream ss(basename.substr(last_dash+1));
- unsigned write_count = 0;
- ss >> write_count;
- // cerr << "WRITE COUNT: " << write_count << endl;
- ++write_count; // start at 1
- ss.clear();
- ss << basename.substr(0, last_dash) << "-" << write_count;
- newname = ss.str();
- }
-
- string newpath = _session.session_directory().midi_path().to_string() +"/"+ newname + ".mid";
-
- boost::shared_ptr<MidiSource> newsrc = boost::dynamic_pointer_cast<MidiSource>(
- SourceFactory::createWritable(DataType::MIDI, _session,
- newpath, false, _session.frame_rate()));
-
- newsrc->set_timeline_position(_timeline_position);
- _model->write_to(newsrc);
-
- // cyclic dependency here, ugly :(
- newsrc->set_model(_model);
- _model->set_midi_source(newsrc.get());
-
- newsrc->flush_midi();
+ boost::shared_ptr<MidiSource> newsrc = clone ();
- Switched (newsrc); /* EMIT SIGNAL */
+ if (newsrc) {
+ _model->set_midi_source (newsrc.get());
+ Switched (newsrc); /* EMIT SIGNAL */
+ }
}
}
#include <iostream>
#include "ardour/event_type_map.h"
#include "ardour/midi_ring_buffer.h"
+#include "ardour/midi_source.h"
#include "ardour/midi_state_tracker.h"
using namespace std;
_on = 0;
}
+void
+MidiStateTracker::resolve_notes (MidiSource& src, Evoral::MusicalTime time)
+{
+ if (!_on) {
+ return;
+ }
+
+ /* NOTE: the src must be locked */
+
+ for (int channel = 0; channel < 16; ++channel) {
+ for (int note = 0; note < 128; ++note) {
+ while (_active_notes[note + 128 * channel]) {
+ Evoral::MIDIEvent<Evoral::MusicalTime> ev ((MIDI_CMD_NOTE_OFF|channel), time, 3, 0, true);
+ ev.set_type (MIDI_CMD_NOTE_OFF);
+ ev.set_channel (channel);
+ ev.set_note (note);
+ ev.set_velocity (0);
+ src.append_event_unlocked_beats (ev);
+ _active_notes[note + 128 * channel]--;
+ cerr << "Resolved " << ev << endl;
+ /* don't stack events up at the same time
+ */
+ time += 1.0/128.0;
+ }
+ }
+ }
+ _on = 0;
+}
+
void
MidiStateTracker::dump (ostream& o)
{
to_check.insert (start);
to_check.insert (end);
+ DEBUG_TRACE (DEBUG::AudioPlayback, ">>>>> REGIONS TO READ\n");
+
for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
/* find all/any regions that span start+end */
case OverlapInternal:
covering.push_back (*i);
+ DEBUG_TRACE (DEBUG::AudioPlayback, string_compose ("toread: will cover %1 (OInternal)\n", (*i)->name()));
break;
case OverlapStart:
to_check.insert ((*i)->position());
+ if ((*i)->position() != 0) {
+ to_check.insert ((*i)->position()-1);
+ }
+ DEBUG_TRACE (DEBUG::AudioPlayback, string_compose ("toread: will check %1 for %2\n", (*i)->position(), (*i)->name()));
covering.push_back (*i);
break;
case OverlapEnd:
to_check.insert ((*i)->last_frame());
+ to_check.insert ((*i)->last_frame()+1);
+ DEBUG_TRACE (DEBUG::AudioPlayback, string_compose ("toread: will cover %1 (OEnd)\n", (*i)->name()));
+ DEBUG_TRACE (DEBUG::AudioPlayback, string_compose ("\ttoread: will check %1 for %2\n", (*i)->last_frame(), (*i)->name()));
+ DEBUG_TRACE (DEBUG::AudioPlayback, string_compose ("\ttoread: will check %1 for %2\n", (*i)->last_frame(), (*i)->name()));
covering.push_back (*i);
break;
case OverlapExternal:
covering.push_back (*i);
to_check.insert ((*i)->position());
+ if ((*i)->position() != 0) {
+ to_check.insert ((*i)->position()-1);
+ }
to_check.insert ((*i)->last_frame());
+ to_check.insert ((*i)->last_frame()+1);
+ DEBUG_TRACE (DEBUG::AudioPlayback, string_compose ("toread: will cover %1 (OExt)\n", (*i)->name()));
+ DEBUG_TRACE (DEBUG::AudioPlayback, string_compose ("\ttoread: will check %1 for %2\n", (*i)->position(), (*i)->name()));
+ DEBUG_TRACE (DEBUG::AudioPlayback, string_compose ("\ttoread: will check %1 for %2\n", (*i)->last_frame(), (*i)->name()));
break;
}
if (covering.size() == 1) {
rlist->push_back (covering.front());
+ DEBUG_TRACE (DEBUG::AudioPlayback, string_compose ("Just one covering region (%1)\n", covering.front()->name()));
} else {
here.clear ();
+ DEBUG_TRACE (DEBUG::AudioPlayback, string_compose ("++++ Considering %1\n", *t));
+
for (RegionList::iterator x = covering.begin(); x != covering.end(); ++x) {
if ((*x)->covers (*t)) {
here.push_back (*x);
- }
+ DEBUG_TRACE (DEBUG::AudioPlayback, string_compose ("region %1 covers %2\n",
+ (*x)->name(),
+ (*t)));
+ } else {
+ DEBUG_TRACE (DEBUG::AudioPlayback, string_compose ("region %1 does NOT covers %2\n",
+ (*x)->name(),
+ (*t)));
+ }
+
}
RegionSortByLayer cmp;
if ((*c)->opaque()) {
/* the other regions at this position are hidden by this one */
-
+ DEBUG_TRACE (DEBUG::AudioPlayback, string_compose ("%1 is opaque, ignore all others\n",
+ (*c)->name()));
break;
}
}
}
}
+ DEBUG_TRACE (DEBUG::AudioPlayback, string_compose ("<<<<< REGIONS TO READ returns %1\n", rlist->size()));
+
return rlist;
}
string newname = name;
do {
- newname = bump_name_once (newname);
+ newname = bump_name_once (newname, '.');
} while (session.playlists->by_name (newname)!=NULL);
return newname;
string newname = name;
while (!session.io_name_is_legal (newname)) {
- newname = bump_name_once (newname);
+ newname = bump_name_once (newname, '.');
}
return newname;
/* tell sources we're saving first, in case they write out to a new file
* which should be saved with the state rather than the old one */
- for (SourceMap::const_iterator i = sources.begin(); i != sources.end(); ++i)
+ for (SourceMap::const_iterator i = sources.begin(); i != sources.end(); ++i) {
i->second->session_saved();
+ }
tree.set_root (&get_state());
return legal;
}
-string bump_name_once(std::string name)
+string
+bump_name_once (const std::string& name, char delimiter)
{
- string::size_type period;
+ string::size_type delim;
string newname;
- if ((period = name.find_last_of ('.')) == string::npos) {
+ if ((delim = name.find_last_of (delimiter)) == string::npos) {
newname = name;
- newname += ".1";
+ newname += delimiter;
+ newname += "1";
} else {
int isnumber = 1;
- const char *last_element = name.c_str() + period + 1;
+ const char *last_element = name.c_str() + delim + 1;
for (size_t i = 0; i < strlen(last_element); i++) {
if (!isdigit(last_element[i])) {
isnumber = 0;
}
errno = 0;
- long int version = strtol (name.c_str()+period+1, (char **)NULL, 10);
+ long int version = strtol (name.c_str()+delim+1, (char **)NULL, 10);
if (isnumber == 0 || errno != 0) {
// last_element is not a number, or is too large
newname = name;
- newname += ".1";
+ newname += delimiter;
+ newname += "1";
} else {
char buf[32];
snprintf (buf, sizeof(buf), "%ld", version+1);
- newname = name.substr (0, period+1);
+ newname = name.substr (0, delim+1);
newname += buf;
}
}
class ControlSet : public boost::noncopyable {
public:
ControlSet();
+ ControlSet (const ControlSet&);
virtual ~ControlSet() {}
virtual boost::shared_ptr<Evoral::Control>
inline bool is_aftertouch() const { return (type() == MIDI_CMD_NOTE_PRESSURE); }
inline bool is_channel_pressure() const { return (type() == MIDI_CMD_CHANNEL_PRESSURE); }
inline uint8_t note() const { return (this->_buf[1]); }
+ inline void set_note(uint8_t n) { this->_buf[1] = n; }
inline uint8_t velocity() const { return (this->_buf[2]); }
inline void set_velocity(uint8_t value) { this->_buf[2] = value; }
inline void scale_velocity(float factor) {
class Sequence : virtual public ControlSet {
public:
Sequence(const TypeMap& type_map);
+ Sequence(const Sequence<Time>& other);
protected:
struct WriteLockImpl {
#include <stdint.h>
#include <list>
#include <cmath>
+#include <cfloat>
namespace Evoral {
/** Musical time: beats relative to some defined origin */
typedef double MusicalTime;
+const MusicalTime MaxMusicalTime = DBL_MAX;
+const MusicalTime MinMusicalTime = DBL_MIN;
static inline bool musical_time_equal (MusicalTime a, MusicalTime b) {
/* acceptable tolerance is 1 tick. Nice if there was no magic number here */
{
}
+ControlSet::ControlSet (const ControlSet& other)
+ : noncopyable ()
+{
+ /* derived class must copy controls */
+}
+
void
ControlSet::add_control(boost::shared_ptr<Control> ac)
{
assert( ! _end_iter._lock);
}
+template<typename Time>
+Sequence<Time>::Sequence(const Sequence<Time>& other)
+ : ControlSet (other)
+ , _edited(false)
+ , _type_map(other._type_map)
+ , _writing(false)
+ , _end_iter(*this, DBL_MAX)
+ , _percussive(other._percussive)
+ , _lowest_note(other._lowest_note)
+ , _highest_note(other._highest_note)
+{
+ for (typename Notes::const_iterator i = other._notes.begin(); i != other._notes.end(); ++i) {
+ boost::shared_ptr<Note<Time> > n (new Note<Time> (**i));
+ _notes.insert (n);
+ }
+
+ for (typename SysExes::const_iterator i = other._sysexes.begin(); i != other._sysexes.end(); ++i) {
+ boost::shared_ptr<Event<Time> > n (new Event<Time> (**i, true));
+ _sysexes.push_back (n);
+ }
+
+ DUMP(format("Sequence copied: %1%\n") % this);
+ assert(_end_iter._is_end);
+ assert(! _end_iter._lock);
+}
+
/** Write the controller event pointed to by \a iter to \a ev.
* The buffer of \a ev will be allocated or resized as necessary.
* The event_type of \a ev should be set to the expected output type.
projects / ardour.git / commitdiff