add note IDs and use them for looking up notes during a history rebuild. NOTE: INVALIDATES OLDER HISTORY FILES
git-svn-id: svn://localhost/ardour2/branches/3.0@7449 d708f5d6-7413-0410-9779-e7cbd77b26cf
This commit is contained in:
parent
3ef1a678b4
commit
bf91ed99ec
|
@ -885,7 +885,6 @@ void
|
|||
MidiTimeAxisView::check_step_edit ()
|
||||
{
|
||||
MidiRingBuffer<nframes_t>& incoming (midi_track()->step_edit_ring_buffer());
|
||||
Evoral::Note<Evoral::MusicalTime> note;
|
||||
uint8_t* buf;
|
||||
uint32_t bufsize = 32;
|
||||
|
||||
|
|
|
@ -144,6 +144,7 @@ public:
|
|||
void set_midi_source (MidiSource *);
|
||||
|
||||
boost::shared_ptr<Evoral::Note<TimeType> > find_note (NotePtr);
|
||||
boost::shared_ptr<Evoral::Note<TimeType> > find_note (gint note_id);
|
||||
|
||||
InsertMergePolicy insert_merge_policy () const;
|
||||
void set_insert_merge_policy (InsertMergePolicy);
|
||||
|
|
|
@ -284,7 +284,6 @@ ARDOUR::init (bool use_vst, bool try_optimization)
|
|||
return -1;
|
||||
}
|
||||
|
||||
|
||||
Config->set_use_vst (use_vst);
|
||||
|
||||
Profile = new RuntimeProfile;
|
||||
|
|
|
@ -378,9 +378,12 @@ write_midi_data_to_new_files (Evoral::SMF* source, ImportStatus& status,
|
|||
bool first = true;
|
||||
|
||||
while (!status.cancel) {
|
||||
gint ignored; // imported files either don't have NoteID's or
|
||||
// we ignore them.
|
||||
|
||||
size = buf_size;
|
||||
|
||||
int ret = source->read_event(&delta_t, &size, &buf);
|
||||
int ret = source->read_event(&delta_t, &size, &buf, &ignored);
|
||||
if (size > buf_size)
|
||||
buf_size = size;
|
||||
|
||||
|
|
|
@ -382,25 +382,41 @@ MidiModel::DiffCommand::marshal_note(const NotePtr note)
|
|||
|
||||
cerr << "Marshalling note: " << *note << endl;
|
||||
|
||||
ostringstream note_str(ios::ate);
|
||||
note_str << int(note->note());
|
||||
xml_note->add_property("note", note_str.str());
|
||||
{
|
||||
ostringstream id_str(ios::ate);
|
||||
id_str << int(note->id());
|
||||
xml_note->add_property("id", id_str.str());
|
||||
}
|
||||
|
||||
ostringstream channel_str(ios::ate);
|
||||
channel_str << int(note->channel());
|
||||
xml_note->add_property("channel", channel_str.str());
|
||||
{
|
||||
ostringstream note_str(ios::ate);
|
||||
note_str << int(note->note());
|
||||
xml_note->add_property("note", note_str.str());
|
||||
}
|
||||
|
||||
ostringstream time_str(ios::ate);
|
||||
time_str << note->time();
|
||||
xml_note->add_property("time", time_str.str());
|
||||
{
|
||||
ostringstream channel_str(ios::ate);
|
||||
channel_str << int(note->channel());
|
||||
xml_note->add_property("channel", channel_str.str());
|
||||
}
|
||||
|
||||
ostringstream length_str(ios::ate);
|
||||
length_str << note->length();
|
||||
xml_note->add_property("length", length_str.str());
|
||||
{
|
||||
ostringstream time_str(ios::ate);
|
||||
time_str << note->time();
|
||||
xml_note->add_property("time", time_str.str());
|
||||
}
|
||||
|
||||
ostringstream velocity_str(ios::ate);
|
||||
velocity_str << (unsigned int) note->velocity();
|
||||
xml_note->add_property("velocity", velocity_str.str());
|
||||
{
|
||||
ostringstream length_str(ios::ate);
|
||||
length_str << note->length();
|
||||
xml_note->add_property("length", length_str.str());
|
||||
}
|
||||
|
||||
{
|
||||
ostringstream velocity_str(ios::ate);
|
||||
velocity_str << (unsigned int) note->velocity();
|
||||
xml_note->add_property("velocity", velocity_str.str());
|
||||
}
|
||||
|
||||
return *xml_note;
|
||||
}
|
||||
|
@ -414,6 +430,15 @@ MidiModel::DiffCommand::unmarshal_note(XMLNode *xml_note)
|
|||
unsigned int time;
|
||||
unsigned int length;
|
||||
unsigned int velocity;
|
||||
gint id;
|
||||
|
||||
if ((prop = xml_note->property("id")) != 0) {
|
||||
istringstream id_str(prop->value());
|
||||
id_str >> id;
|
||||
} else {
|
||||
error << "note information missing ID value" << endmsg;
|
||||
id = -1;
|
||||
}
|
||||
|
||||
if ((prop = xml_note->property("note")) != 0) {
|
||||
istringstream note_str(prop->value());
|
||||
|
@ -456,6 +481,7 @@ MidiModel::DiffCommand::unmarshal_note(XMLNode *xml_note)
|
|||
}
|
||||
|
||||
NotePtr note_ptr(new Evoral::Note<TimeType>(channel, time, length, note, velocity));
|
||||
note_ptr->set_id (id);
|
||||
|
||||
return note_ptr;
|
||||
}
|
||||
|
@ -463,7 +489,7 @@ MidiModel::DiffCommand::unmarshal_note(XMLNode *xml_note)
|
|||
XMLNode&
|
||||
MidiModel::DiffCommand::marshal_change(const NoteChange& change)
|
||||
{
|
||||
XMLNode* xml_change = new XMLNode("change");
|
||||
XMLNode* xml_change = new XMLNode("Change");
|
||||
|
||||
/* first, the change itself */
|
||||
|
||||
|
@ -489,49 +515,9 @@ MidiModel::DiffCommand::marshal_change(const NoteChange& change)
|
|||
xml_change->add_property ("new", new_value_str.str());
|
||||
}
|
||||
|
||||
/* now the rest of the note */
|
||||
|
||||
const SMFSource* smf = dynamic_cast<const SMFSource*> (_model->midi_source());
|
||||
|
||||
if (change.property != NoteNumber) {
|
||||
ostringstream note_str;
|
||||
note_str << int(change.note->note());
|
||||
xml_change->add_property("note", note_str.str());
|
||||
}
|
||||
|
||||
if (change.property != Channel) {
|
||||
ostringstream channel_str;
|
||||
channel_str << int(change.note->channel());
|
||||
xml_change->add_property("channel", channel_str.str());
|
||||
}
|
||||
|
||||
if (change.property != StartTime) {
|
||||
ostringstream time_str;
|
||||
if (smf) {
|
||||
time_str << smf->round_to_file_precision (change.note->time());
|
||||
} else {
|
||||
time_str << change.note->time();
|
||||
}
|
||||
xml_change->add_property("time", time_str.str());
|
||||
}
|
||||
|
||||
if (change.property != Length) {
|
||||
ostringstream length_str;
|
||||
if (smf) {
|
||||
length_str << smf->round_to_file_precision (change.note->length());
|
||||
} else {
|
||||
length_str << change.note->length();
|
||||
}
|
||||
xml_change->add_property ("length", length_str.str());
|
||||
}
|
||||
|
||||
if (change.property != Velocity) {
|
||||
ostringstream velocity_str;
|
||||
velocity_str << int (change.note->velocity());
|
||||
xml_change->add_property("velocity", velocity_str.str());
|
||||
}
|
||||
|
||||
/* and now notes that were remove as a side-effect */
|
||||
ostringstream id_str;
|
||||
id_str << change.note->id();
|
||||
xml_change->add_property ("id", id_str.str());
|
||||
|
||||
return *xml_change;
|
||||
}
|
||||
|
@ -541,11 +527,6 @@ MidiModel::DiffCommand::unmarshal_change(XMLNode *xml_change)
|
|||
{
|
||||
XMLProperty* prop;
|
||||
NoteChange change;
|
||||
unsigned int note;
|
||||
unsigned int channel;
|
||||
unsigned int velocity;
|
||||
Evoral::MusicalTime time;
|
||||
Evoral::MusicalTime length;
|
||||
|
||||
if ((prop = xml_change->property("property")) != 0) {
|
||||
change.property = (Property) string_2_enum (prop->value(), change.property);
|
||||
|
@ -554,6 +535,13 @@ MidiModel::DiffCommand::unmarshal_change(XMLNode *xml_change)
|
|||
/*NOTREACHED*/
|
||||
}
|
||||
|
||||
if ((prop = xml_change->property ("id")) == 0) {
|
||||
error << _("No NoteID found for note property change - ignored") << endmsg;
|
||||
return change;
|
||||
}
|
||||
|
||||
gint note_id = atoi (prop->value().c_str());
|
||||
|
||||
if ((prop = xml_change->property ("old")) != 0) {
|
||||
istringstream old_str (prop->value());
|
||||
if (change.property == StartTime || change.property == Length) {
|
||||
|
@ -582,78 +570,15 @@ MidiModel::DiffCommand::unmarshal_change(XMLNode *xml_change)
|
|||
/*NOTREACHED*/
|
||||
}
|
||||
|
||||
if (change.property != NoteNumber) {
|
||||
if ((prop = xml_change->property("note")) != 0) {
|
||||
istringstream note_str(prop->value());
|
||||
note_str >> note;
|
||||
} else {
|
||||
warning << "note information missing note value" << endmsg;
|
||||
note = 127;
|
||||
}
|
||||
} else {
|
||||
note = change.new_value;
|
||||
}
|
||||
|
||||
if (change.property != Channel) {
|
||||
if ((prop = xml_change->property("channel")) != 0) {
|
||||
istringstream channel_str(prop->value());
|
||||
channel_str >> channel;
|
||||
} else {
|
||||
warning << "note information missing channel" << endmsg;
|
||||
channel = 0;
|
||||
}
|
||||
} else {
|
||||
channel = change.new_value;
|
||||
}
|
||||
|
||||
if (change.property != StartTime) {
|
||||
if ((prop = xml_change->property("time")) != 0) {
|
||||
istringstream time_str(prop->value());
|
||||
time_str >> time;
|
||||
} else {
|
||||
warning << "note information missing time" << endmsg;
|
||||
time = 0;
|
||||
}
|
||||
} else {
|
||||
time = change.new_time;
|
||||
}
|
||||
|
||||
if (change.property != Length) {
|
||||
if ((prop = xml_change->property("length")) != 0) {
|
||||
istringstream length_str(prop->value());
|
||||
length_str >> length;
|
||||
} else {
|
||||
warning << "note information missing length" << endmsg;
|
||||
length = 1;
|
||||
}
|
||||
} else {
|
||||
length = change.new_time;
|
||||
}
|
||||
|
||||
if (change.property != Velocity) {
|
||||
if ((prop = xml_change->property("velocity")) != 0) {
|
||||
istringstream velocity_str(prop->value());
|
||||
velocity_str >> velocity;
|
||||
} else {
|
||||
warning << "note information missing velocity" << endmsg;
|
||||
velocity = 127;
|
||||
}
|
||||
} else {
|
||||
velocity = change.new_value;
|
||||
}
|
||||
|
||||
/* we must point at the instance of the note that is actually in the model.
|
||||
so go look for it ...
|
||||
*/
|
||||
|
||||
NotePtr new_note (new Evoral::Note<TimeType> (channel, time, length, note, velocity));
|
||||
|
||||
change.note = _model->find_note (new_note);
|
||||
change.note = _model->find_note (note_id);
|
||||
|
||||
if (!change.note) {
|
||||
warning << "MIDI note " << *new_note << " not found in model - programmers should investigate this" << endmsg;
|
||||
/* use the actual new note */
|
||||
change.note = new_note;
|
||||
warning << "MIDI note #" << note_id << " not found in model - programmers should investigate this" << endmsg;
|
||||
return change;
|
||||
}
|
||||
|
||||
return change;
|
||||
|
@ -925,6 +850,22 @@ MidiModel::find_note (NotePtr other)
|
|||
return NotePtr();
|
||||
}
|
||||
|
||||
Evoral::Sequence<MidiModel::TimeType>::NotePtr
|
||||
MidiModel::find_note (gint note_id)
|
||||
{
|
||||
/* used only for looking up notes when reloading history from disk,
|
||||
so we don't care about performance *too* much.
|
||||
*/
|
||||
|
||||
for (Notes::iterator l = notes().begin(); l != notes().end(); ++l) {
|
||||
if ((*l)->id() == note_id) {
|
||||
return *l;
|
||||
}
|
||||
}
|
||||
|
||||
return NotePtr();
|
||||
}
|
||||
|
||||
/** Lock and invalidate the source.
|
||||
* This should be used by commands and editing things
|
||||
*/
|
||||
|
|
|
@ -205,7 +205,7 @@ MidiSource::midi_read (Evoral::EventSink<nframes_t>& dst, sframes_t source_start
|
|||
const sframes_t time_frames = converter.to(i->time());
|
||||
if (time_frames < start + cnt) {
|
||||
dst.write(time_frames + stamp_offset - negative_stamp_offset,
|
||||
i->event_type(), i->size(), i->buffer());
|
||||
i->event_type(), i->size(), i->buffer());
|
||||
if (tracker) {
|
||||
Evoral::MIDIEvent<Evoral::MusicalTime>& ev (*(Evoral::MIDIEvent<Evoral::MusicalTime>*) (&(*i)));
|
||||
if (ev.is_note_on()) {
|
||||
|
|
|
@ -152,7 +152,6 @@ MidiStateTracker::resolve_notes (MidiSource& src, Evoral::MusicalTime time)
|
|||
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;
|
||||
|
|
|
@ -100,7 +100,7 @@ MidiStretch::run (boost::shared_ptr<Region> r)
|
|||
// FIXME: double copy
|
||||
Evoral::Event<MidiModel::TimeType> ev(*i, true);
|
||||
ev.time() = new_time;
|
||||
new_model->append(ev);
|
||||
new_model->append(ev, Evoral::next_event_id());
|
||||
}
|
||||
|
||||
new_model->end_write();
|
||||
|
|
|
@ -271,7 +271,6 @@ RegionFactory::map_add (boost::shared_ptr<Region> r)
|
|||
|
||||
{
|
||||
Glib::Mutex::Lock lm (region_map_lock);
|
||||
cerr << "MAP ADD: " << r->name() << " ID = " << r->id() << endl;
|
||||
region_map.insert (p);
|
||||
}
|
||||
|
||||
|
|
|
@ -1043,6 +1043,11 @@ Session::state(bool full_state)
|
|||
snprintf (buf, sizeof (buf), "%" PRIu64, ID::counter());
|
||||
node->add_property ("id-counter", buf);
|
||||
|
||||
/* save the event ID counter */
|
||||
|
||||
snprintf (buf, sizeof (buf), "%d", Evoral::event_id_counter());
|
||||
node->add_property ("event-counter", buf);
|
||||
|
||||
/* various options */
|
||||
|
||||
node->add_child_nocopy (config.get_variables ());
|
||||
|
@ -1225,6 +1230,9 @@ Session::set_state (const XMLNode& node, int version)
|
|||
ID::init_counter (now);
|
||||
}
|
||||
|
||||
if ((prop = node.property (X_("event-counter"))) != 0) {
|
||||
Evoral::init_event_id_counter (atoi (prop->value()));
|
||||
}
|
||||
|
||||
IO::disable_connecting ();
|
||||
|
||||
|
|
|
@ -134,7 +134,9 @@ SMFSource::read_unlocked (Evoral::EventSink<nframes_t>& destination, sframes_t s
|
|||
DEBUG_TRACE (DEBUG::MidiSourceIO, string_compose ("SMF read_unlocked: seek to %1\n", start));
|
||||
Evoral::SMF::seek_to_start();
|
||||
while (time < start_ticks) {
|
||||
ret = read_event(&ev_delta_t, &ev_size, &ev_buffer);
|
||||
gint ignored;
|
||||
|
||||
ret = read_event(&ev_delta_t, &ev_size, &ev_buffer, &ignored);
|
||||
if (ret == -1) { // EOF
|
||||
_smf_last_read_end = start + duration;
|
||||
return duration;
|
||||
|
@ -149,7 +151,9 @@ SMFSource::read_unlocked (Evoral::EventSink<nframes_t>& destination, sframes_t s
|
|||
_smf_last_read_end = start + duration;
|
||||
|
||||
while (true) {
|
||||
ret = read_event(&ev_delta_t, &ev_size, &ev_buffer);
|
||||
gint ignored; /* XXX don't ignore note id's ??*/
|
||||
|
||||
ret = read_event(&ev_delta_t, &ev_size, &ev_buffer, &ignored);
|
||||
if (ret == -1) { // EOF
|
||||
break;
|
||||
}
|
||||
|
@ -247,6 +251,8 @@ SMFSource::write_unlocked (MidiRingBuffer<nframes_t>& source, sframes_t position
|
|||
|
||||
ev.set(buf, size, time);
|
||||
ev.set_event_type(EventTypeMap::instance().midi_event_type(ev.buffer()[0]));
|
||||
ev.set_id (Evoral::next_event_id());
|
||||
|
||||
if (!(ev.is_channel_event() || ev.is_smf_meta_event() || ev.is_sysex())) {
|
||||
/*cerr << "SMFSource: WARNING: caller tried to write non SMF-Event of type "
|
||||
<< std::hex << int(ev.buffer()[0]) << endl;*/
|
||||
|
@ -274,9 +280,9 @@ SMFSource::append_event_unlocked_beats (const Evoral::Event<double>& ev)
|
|||
return;
|
||||
}
|
||||
|
||||
/*printf("SMFSource: %s - append_event_unlocked_beats time = %lf, size = %u, data = ",
|
||||
name().c_str(), ev.time(), ev.size());
|
||||
for (size_t i = 0; i < ev.size(); ++i) printf("%X ", ev.buffer()[i]); printf("\n");*/
|
||||
/* printf("SMFSource: %s - append_event_unlocked_beats ID = %d time = %lf, size = %u, data = ",
|
||||
name().c_str(), ev.id(), ev.time(), ev.size());
|
||||
for (size_t i = 0; i < ev.size(); ++i) printf("%X ", ev.buffer()[i]); printf("\n");*/
|
||||
|
||||
assert(ev.time() >= 0);
|
||||
if (ev.time() < _last_ev_time_beats) {
|
||||
|
@ -284,19 +290,28 @@ SMFSource::append_event_unlocked_beats (const Evoral::Event<double>& ev)
|
|||
return;
|
||||
}
|
||||
|
||||
Evoral::event_id_t event_id;
|
||||
|
||||
if (ev.id() < 0) {
|
||||
event_id = Evoral::next_event_id();
|
||||
} else {
|
||||
event_id = ev.id();
|
||||
}
|
||||
|
||||
if (_model) {
|
||||
_model->append (ev, event_id);
|
||||
}
|
||||
|
||||
_length_beats = max(_length_beats, ev.time());
|
||||
|
||||
const double delta_time_beats = ev.time() - _last_ev_time_beats;
|
||||
const uint32_t delta_time_ticks = (uint32_t)lrint(delta_time_beats * (double)ppqn());
|
||||
|
||||
Evoral::SMF::append_event_delta(delta_time_ticks, ev.size(), ev.buffer());
|
||||
Evoral::SMF::append_event_delta(delta_time_ticks, ev.size(), ev.buffer(), event_id);
|
||||
_last_ev_time_beats = ev.time();
|
||||
|
||||
_write_data_count += ev.size();
|
||||
|
||||
if (_model) {
|
||||
_model->append (ev);
|
||||
}
|
||||
}
|
||||
|
||||
/** Append an event with a timestamp in frames (nframes_t) */
|
||||
|
@ -308,9 +323,9 @@ SMFSource::append_event_unlocked_frames (const Evoral::Event<nframes_t>& ev, sfr
|
|||
return;
|
||||
}
|
||||
|
||||
/*printf("SMFSource: %s - append_event_unlocked_frames time = %u, size = %u, data = ",
|
||||
name().c_str(), ev.time(), ev.size());
|
||||
for (size_t i=0; i < ev.size(); ++i) printf("%X ", ev.buffer()[i]); printf("\n");*/
|
||||
/* printf("SMFSource: %s - append_event_unlocked_frames ID = %d time = %u, size = %u, data = ",
|
||||
name().c_str(), ev.id(), ev.time(), ev.size());
|
||||
for (size_t i=0; i < ev.size(); ++i) printf("%X ", ev.buffer()[i]); printf("\n");*/
|
||||
|
||||
if (ev.time() < _last_ev_time_frames) {
|
||||
cerr << "SMFSource: Warning: Skipping event with non-monotonic time" << endl;
|
||||
|
@ -318,24 +333,34 @@ SMFSource::append_event_unlocked_frames (const Evoral::Event<nframes_t>& ev, sfr
|
|||
}
|
||||
|
||||
BeatsFramesConverter converter(_session.tempo_map(), position);
|
||||
const double ev_time_beats = converter.from(ev.time());
|
||||
Evoral::event_id_t event_id;
|
||||
|
||||
_length_beats = max(_length_beats, converter.from(ev.time()));
|
||||
if (ev.id() < 0) {
|
||||
event_id = Evoral::next_event_id();
|
||||
} else {
|
||||
event_id = ev.id();
|
||||
}
|
||||
|
||||
if (_model) {
|
||||
const Evoral::Event<double> beat_ev (ev.event_type(),
|
||||
ev_time_beats,
|
||||
ev.size(),
|
||||
(uint8_t*)ev.buffer());
|
||||
_model->append (beat_ev, event_id);
|
||||
}
|
||||
|
||||
_length_beats = max(_length_beats, ev_time_beats);
|
||||
|
||||
const sframes_t delta_time_frames = ev.time() - _last_ev_time_frames;
|
||||
const double delta_time_beats = converter.from(delta_time_frames);
|
||||
const uint32_t delta_time_ticks = (uint32_t)(lrint(delta_time_beats * (double)ppqn()));
|
||||
|
||||
Evoral::SMF::append_event_delta(delta_time_ticks, ev.size(), ev.buffer());
|
||||
Evoral::SMF::append_event_delta(delta_time_ticks, ev.size(), ev.buffer(), event_id);
|
||||
_last_ev_time_frames = ev.time();
|
||||
|
||||
_write_data_count += ev.size();
|
||||
|
||||
if (_model) {
|
||||
const double ev_time_beats = converter.from(ev.time());
|
||||
const Evoral::Event<double> beat_ev(
|
||||
ev.event_type(), ev_time_beats, ev.size(), (uint8_t*)ev.buffer());
|
||||
_model->append (beat_ev);
|
||||
}
|
||||
}
|
||||
|
||||
XMLNode&
|
||||
|
@ -435,13 +460,35 @@ SMFSource::load_model (bool lock, bool force_reload)
|
|||
uint32_t size = 0;
|
||||
uint8_t* buf = NULL;
|
||||
int ret;
|
||||
while ((ret = read_event(&delta_t, &size, &buf)) >= 0) {
|
||||
time += delta_t;
|
||||
ev.set(buf, size, time / (double)ppqn());
|
||||
gint event_id;
|
||||
bool have_event_id = false;
|
||||
|
||||
if (ret > 0) { // didn't skip (meta) event
|
||||
while ((ret = read_event (&delta_t, &size, &buf, &event_id)) >= 0) {
|
||||
|
||||
time += delta_t;
|
||||
|
||||
if (ret == 0) {
|
||||
|
||||
/* meta-event : did we get an event ID ?
|
||||
*/
|
||||
|
||||
if (event_id >= 0) {
|
||||
have_event_id = true;
|
||||
}
|
||||
|
||||
continue;
|
||||
}
|
||||
|
||||
if (ret > 0) {
|
||||
|
||||
/* not a meta-event */
|
||||
|
||||
ev.set (buf, size, time / (double)ppqn());
|
||||
ev.set_event_type(EventTypeMap::instance().midi_event_type(buf[0]));
|
||||
|
||||
if (!have_event_id) {
|
||||
event_id = Evoral::next_event_id();
|
||||
}
|
||||
#ifndef NDEBUG
|
||||
std::string ss;
|
||||
|
||||
|
@ -455,15 +502,21 @@ SMFSource::load_model (bool lock, bool force_reload)
|
|||
delta_t, time, size, ss , ev.event_type(), name()));
|
||||
#endif
|
||||
|
||||
_model->append (ev);
|
||||
}
|
||||
_model->append (ev, event_id);
|
||||
|
||||
if (ev.size() > scratch_size) {
|
||||
scratch_size = ev.size();
|
||||
}
|
||||
ev.size() = scratch_size; // ensure read_event only allocates if necessary
|
||||
if (ev.size() > scratch_size) {
|
||||
scratch_size = ev.size();
|
||||
}
|
||||
|
||||
_length_beats = max(_length_beats, ev.time());
|
||||
ev.size() = scratch_size; // ensure read_event only allocates if necessary
|
||||
|
||||
_length_beats = max(_length_beats, ev.time());
|
||||
}
|
||||
|
||||
/* event ID's must immediately precede the event they are for
|
||||
*/
|
||||
|
||||
have_event_id = false;
|
||||
}
|
||||
|
||||
_model->end_write(false);
|
||||
|
|
|
@ -26,7 +26,6 @@
|
|||
#include <assert.h>
|
||||
#include "evoral/types.hpp"
|
||||
|
||||
|
||||
/** If this is not defined, all methods of MidiEvent are RT safe
|
||||
* but MidiEvent will never deep copy and (depending on the scenario)
|
||||
* may not be usable in STL containers, signals, etc.
|
||||
|
@ -35,6 +34,9 @@
|
|||
|
||||
namespace Evoral {
|
||||
|
||||
event_id_t event_id_counter();
|
||||
event_id_t next_event_id();
|
||||
void init_event_id_counter (event_id_t n);
|
||||
|
||||
/** An event (much like a type generic jack_midi_event_t)
|
||||
*
|
||||
|
@ -43,7 +45,7 @@ namespace Evoral {
|
|||
template<typename Time>
|
||||
struct Event {
|
||||
#ifdef EVORAL_EVENT_ALLOC
|
||||
Event(EventType type=0, Time time=0, uint32_t size=0, uint8_t* buf=NULL, bool alloc=false);
|
||||
Event (EventType type=0, Time time=0, uint32_t size=0, uint8_t* buf=NULL, bool alloc=false);
|
||||
|
||||
/** Copy \a copy.
|
||||
*
|
||||
|
@ -56,6 +58,7 @@ struct Event {
|
|||
~Event();
|
||||
|
||||
inline const Event& operator=(const Event& copy) {
|
||||
_id = copy.id(); // XXX is this right? do we want ID copy semantics?
|
||||
_type = copy._type;
|
||||
_original_time = copy._original_time;
|
||||
_nominal_time = copy._nominal_time;
|
||||
|
@ -77,20 +80,6 @@ struct Event {
|
|||
return *this;
|
||||
}
|
||||
|
||||
inline void shallow_copy(const Event& copy) {
|
||||
if (_owns_buf) {
|
||||
free(_buf);
|
||||
_buf = false;
|
||||
_owns_buf = false;
|
||||
}
|
||||
|
||||
_type = copy._type;
|
||||
_original_time = copy._nominal_time;
|
||||
_nominal_time = copy._nominal_time;
|
||||
_size = copy._size;
|
||||
_buf = copy._buf;
|
||||
}
|
||||
|
||||
inline void set(uint8_t* buf, uint32_t size, Time t) {
|
||||
if (_owns_buf) {
|
||||
if (_size < size) {
|
||||
|
@ -181,6 +170,9 @@ struct Event {
|
|||
inline const uint8_t* buffer() const { return _buf; }
|
||||
inline uint8_t*& buffer() { return _buf; }
|
||||
|
||||
inline event_id_t id() const { return _id; }
|
||||
inline void set_id (event_id_t n) { _id = n; }
|
||||
|
||||
protected:
|
||||
EventType _type; /**< Type of event (application relative, NOT MIDI 'type') */
|
||||
Time _original_time; /**< Sample index (or beat time) at which event is valid */
|
||||
|
@ -189,17 +181,17 @@ protected:
|
|||
uint8_t* _buf; /**< Raw MIDI data */
|
||||
|
||||
#ifdef EVORAL_EVENT_ALLOC
|
||||
bool _owns_buf; /**< Whether buffer is locally allocated */
|
||||
bool _owns_buf; /**< Whether buffer is locally allocated */
|
||||
#endif
|
||||
event_id_t _id; /** UUID for each event, should probably be 64bit or at least unsigned */
|
||||
};
|
||||
|
||||
|
||||
} // namespace Evoral
|
||||
|
||||
|
||||
template<typename Time>
|
||||
std::ostream& operator<<(std::ostream& o, const Evoral::Event<Time>& ev) {
|
||||
o << "Event type = " << ev.event_type() << " @ " << ev.time();
|
||||
o << "Event #" << ev.id() << " type = " << ev.event_type() << " @ " << ev.time();
|
||||
o << std::hex;
|
||||
for (uint32_t n = 0; n < ev.size(); ++n) {
|
||||
o << ' ' << (int) ev.buffer()[n];
|
||||
|
|
|
@ -35,9 +35,9 @@ class EventList : public std::list<Evoral::Event<Time> *>, public Evoral::EventS
|
|||
public:
|
||||
EventList() {}
|
||||
|
||||
uint32_t write(Time time, EventType type, uint32_t size, const uint8_t* buf) {
|
||||
uint32_t write(Time time, EventType type, uint32_t size, const uint8_t* buf) {
|
||||
push_back(new Evoral::Event<Time>(
|
||||
type, time, size, const_cast<uint8_t*>(buf), true)); // Event copies buffer
|
||||
type, time, size, const_cast<uint8_t*>(buf), true)); // Event copies buffer
|
||||
return size;
|
||||
}
|
||||
};
|
||||
|
|
|
@ -18,7 +18,6 @@
|
|||
#ifndef EVORAL_EVENT_RING_BUFFER_HPP
|
||||
#define EVORAL_EVENT_RING_BUFFER_HPP
|
||||
|
||||
#include <glib.h>
|
||||
#include "evoral/RingBuffer.hpp"
|
||||
#include "evoral/EventSink.hpp"
|
||||
#include "evoral/types.hpp"
|
||||
|
@ -47,7 +46,7 @@ public:
|
|||
|
||||
bool peek_time(Time* time);
|
||||
|
||||
uint32_t write(Time time, EventType type, uint32_t size, const uint8_t* buf);
|
||||
uint32_t write(Time time, EventType type, uint32_t size, const uint8_t* buf);
|
||||
bool read (Time* time, EventType* type, uint32_t* size, uint8_t* buf);
|
||||
};
|
||||
|
||||
|
|
|
@ -30,7 +30,7 @@ template<typename Time>
|
|||
class EventSink {
|
||||
public:
|
||||
virtual ~EventSink() {}
|
||||
virtual uint32_t write(Time time, EventType type, uint32_t size, const uint8_t* buf) = 0;
|
||||
virtual uint32_t write(Time time, EventType type, uint32_t size, const uint8_t* buf) = 0;
|
||||
};
|
||||
|
||||
|
||||
|
|
|
@ -37,8 +37,8 @@ namespace Evoral {
|
|||
*/
|
||||
template<typename Time>
|
||||
struct MIDIEvent : public Event<Time> {
|
||||
MIDIEvent(EventType type=0, Time time=0, uint32_t size=0, uint8_t* buf=NULL, bool alloc=false)
|
||||
: Event<Time>(type, time, size, buf, alloc)
|
||||
MIDIEvent(EventType type=0, Time time=0, uint32_t size=0, uint8_t* buf=NULL, bool alloc=false)
|
||||
: Event<Time>(type, time, size, buf, alloc)
|
||||
{}
|
||||
|
||||
MIDIEvent(const Event<Time>& copy, bool alloc)
|
||||
|
|
|
@ -19,6 +19,7 @@
|
|||
#ifndef EVORAL_NOTE_HPP
|
||||
#define EVORAL_NOTE_HPP
|
||||
|
||||
#include <glib.h>
|
||||
#include <stdint.h>
|
||||
#include "evoral/MIDIEvent.hpp"
|
||||
|
||||
|
@ -31,7 +32,7 @@ namespace Evoral {
|
|||
template<typename Time>
|
||||
class Note {
|
||||
public:
|
||||
Note(uint8_t chan=0, Time time=0, Time len=0, uint8_t note=0, uint8_t vel=0x40);
|
||||
Note(uint8_t chan=0, Time time=0, Time len=0, uint8_t note=0, uint8_t vel=0x40);
|
||||
Note(const Note<Time>& copy);
|
||||
~Note();
|
||||
|
||||
|
@ -46,6 +47,9 @@ public:
|
|||
channel() == other.channel();
|
||||
}
|
||||
|
||||
inline event_id_t id() const { return _on_event.id(); }
|
||||
void set_id (event_id_t);
|
||||
|
||||
inline Time time() const { return _on_event.time(); }
|
||||
inline Time end_time() const { return _off_event.time(); }
|
||||
inline uint8_t note() const { return _on_event.note(); }
|
||||
|
@ -69,7 +73,7 @@ public:
|
|||
inline Event<Time>& off_event() { return _off_event; }
|
||||
inline const Event<Time>& off_event() const { return _off_event; }
|
||||
|
||||
private:
|
||||
private:
|
||||
// Event buffers are self-contained
|
||||
MIDIEvent<Time> _on_event;
|
||||
MIDIEvent<Time> _off_event;
|
||||
|
@ -79,7 +83,7 @@ private:
|
|||
|
||||
template<typename Time>
|
||||
std::ostream& operator<<(std::ostream& o, const Evoral::Note<Time>& n) {
|
||||
o << "Note: pitch = " << (int) n.note()
|
||||
o << "Note #" << n.id() << ": pitch = " << (int) n.note()
|
||||
<< " @ " << n.time() << " .. " << n.end_time()
|
||||
<< " velocity " << (int) n.velocity()
|
||||
<< " chn " << (int) n.channel();
|
||||
|
|
|
@ -21,6 +21,7 @@
|
|||
#define EVORAL_SMF_HPP
|
||||
|
||||
#include <cassert>
|
||||
#include "evoral/types.hpp"
|
||||
|
||||
struct smf_struct;
|
||||
struct smf_track_struct;
|
||||
|
@ -52,14 +53,14 @@ public:
|
|||
void seek_to_start() const;
|
||||
int seek_to_track(int track);
|
||||
|
||||
int read_event(uint32_t* delta_t, uint32_t* size, uint8_t** buf) const;
|
||||
int read_event(uint32_t* delta_t, uint32_t* size, uint8_t** buf, event_id_t* note_id) const;
|
||||
|
||||
uint16_t num_tracks() const;
|
||||
uint16_t ppqn() const;
|
||||
bool is_empty() const { return _empty; }
|
||||
|
||||
void begin_write();
|
||||
void append_event_delta(uint32_t delta_t, uint32_t size, const uint8_t* buf);
|
||||
void append_event_delta(uint32_t delta_t, uint32_t size, const uint8_t* buf, event_id_t note_id);
|
||||
void end_write() THROW_FILE_ERROR;
|
||||
|
||||
void flush() {};
|
||||
|
|
|
@ -98,7 +98,7 @@ public:
|
|||
bool writing() const { return _writing; }
|
||||
void end_write(bool delete_stuck=false);
|
||||
|
||||
void append(const Event<Time>& ev);
|
||||
void append(const Event<Time>& ev, Evoral::event_id_t evid);
|
||||
|
||||
inline size_t n_notes() const { return _notes.size(); }
|
||||
inline bool empty() const { return _notes.size() == 0 && ControlSet::controls_empty(); }
|
||||
|
@ -268,10 +268,10 @@ private:
|
|||
bool overlaps_unlocked (const NotePtr& ev, const NotePtr& ignore_this_note) const;
|
||||
bool contains_unlocked (const NotePtr& ev) const;
|
||||
|
||||
void append_note_on_unlocked (NotePtr);
|
||||
void append_note_on_unlocked (NotePtr, Evoral::event_id_t);
|
||||
void append_note_off_unlocked(NotePtr);
|
||||
void append_control_unlocked(const Parameter& param, Time time, double value);
|
||||
void append_sysex_unlocked(const MIDIEvent<Time>& ev);
|
||||
void append_control_unlocked(const Parameter& param, Time time, double value, Evoral::event_id_t);
|
||||
void append_sysex_unlocked(const MIDIEvent<Time>& ev, Evoral::event_id_t);
|
||||
|
||||
void get_notes_by_pitch (Notes&, NoteOperator, uint8_t val, int chan_mask = 0) const;
|
||||
void get_notes_by_velocity (Notes&, NoteOperator, uint8_t val, int chan_mask = 0) const;
|
||||
|
|
|
@ -28,6 +28,12 @@
|
|||
|
||||
namespace Evoral {
|
||||
|
||||
/** ID of an event (note or other). This must be operable on by glib
|
||||
atomic ops
|
||||
*/
|
||||
|
||||
typedef int32_t event_id_t;
|
||||
|
||||
/** Frame count (i.e. length of time in audio frames) */
|
||||
typedef uint32_t FrameTime;
|
||||
|
||||
|
|
|
@ -16,20 +16,42 @@
|
|||
* 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*/
|
||||
|
||||
#include <glib.h>
|
||||
#include "evoral/Event.hpp"
|
||||
|
||||
namespace Evoral {
|
||||
|
||||
static event_id_t _event_id_counter = 0;
|
||||
|
||||
event_id_t
|
||||
event_id_counter()
|
||||
{
|
||||
return g_atomic_int_get (&_event_id_counter);
|
||||
}
|
||||
|
||||
void
|
||||
init_event_id_counter(event_id_t n)
|
||||
{
|
||||
g_atomic_int_set (&_event_id_counter, n);
|
||||
}
|
||||
|
||||
event_id_t
|
||||
next_event_id ()
|
||||
{
|
||||
return g_atomic_int_exchange_and_add (&_event_id_counter, 1);
|
||||
}
|
||||
|
||||
#ifdef EVORAL_EVENT_ALLOC
|
||||
|
||||
template<typename Timestamp>
|
||||
Event<Timestamp>::Event(EventType type, Timestamp time, uint32_t size, uint8_t* buf, bool alloc)
|
||||
: _type(type)
|
||||
: _type(type)
|
||||
, _original_time(time)
|
||||
, _nominal_time(time)
|
||||
, _size(size)
|
||||
, _buf(buf)
|
||||
, _owns_buf(alloc)
|
||||
, _id (-1)
|
||||
{
|
||||
if (alloc) {
|
||||
_buf = (uint8_t*)malloc(_size);
|
||||
|
@ -49,6 +71,7 @@ Event<Timestamp>::Event(const Event& copy, bool owns_buf)
|
|||
, _size(copy._size)
|
||||
, _buf(copy._buf)
|
||||
, _owns_buf(owns_buf)
|
||||
, _id (copy.id())
|
||||
{
|
||||
if (owns_buf) {
|
||||
_buf = (uint8_t*)malloc(_size);
|
||||
|
|
|
@ -18,6 +18,7 @@
|
|||
|
||||
#include <iostream>
|
||||
#include <limits>
|
||||
#include <glib.h>
|
||||
#include "evoral/Note.hpp"
|
||||
|
||||
namespace Evoral {
|
||||
|
@ -25,8 +26,8 @@ namespace Evoral {
|
|||
template<typename Time>
|
||||
Note<Time>::Note(uint8_t chan, Time t, Time l, uint8_t n, uint8_t v)
|
||||
// FIXME: types?
|
||||
: _on_event(0xDE, t, 3, NULL, true)
|
||||
, _off_event(0xAD, t + l, 3, NULL, true)
|
||||
: _on_event (0xDE, t, 3, NULL, true)
|
||||
, _off_event (0xAD, t + l, 3, NULL, true)
|
||||
{
|
||||
assert(chan < 16);
|
||||
|
||||
|
@ -49,9 +50,11 @@ Note<Time>::Note(uint8_t chan, Time t, Time l, uint8_t n, uint8_t v)
|
|||
|
||||
template<typename Time>
|
||||
Note<Time>::Note(const Note<Time>& copy)
|
||||
: _on_event(copy._on_event, true)
|
||||
: _on_event(copy._on_event, true)
|
||||
, _off_event(copy._off_event, true)
|
||||
{
|
||||
set_id (copy.id());
|
||||
|
||||
assert(_on_event.buffer());
|
||||
assert(_off_event.buffer());
|
||||
/*
|
||||
|
@ -78,6 +81,13 @@ Note<Time>::~Note()
|
|||
{
|
||||
}
|
||||
|
||||
template<typename Time> void
|
||||
Note<Time>::set_id (event_id_t id)
|
||||
{
|
||||
_on_event.set_id (id);
|
||||
_off_event.set_id (id);
|
||||
}
|
||||
|
||||
template<typename Time>
|
||||
const Note<Time>&
|
||||
Note<Time>::operator=(const Note<Time>& other)
|
||||
|
|
|
@ -184,6 +184,22 @@ SMF::seek_to_start() const
|
|||
_smf_track->next_event_number = 1;
|
||||
}
|
||||
|
||||
static void
|
||||
midify_note_id (event_id_t note_id, uint8_t* buf)
|
||||
{
|
||||
buf[0] = (note_id & 0xfe000000) >> 25;
|
||||
buf[1] = (note_id & 0x01fc0000) >> 18;
|
||||
buf[2] = (note_id & 0x0003f800) >> 11;
|
||||
buf[3] = (note_id & 0x000007f0) >> 4;
|
||||
buf[4] = (note_id & 0x0000000f);
|
||||
}
|
||||
|
||||
static event_id_t
|
||||
unmidify_note_id (uint8_t* buf)
|
||||
{
|
||||
return ((int) buf[0] << 25) | ((int) buf[1] << 18) | ((int) buf[2] << 11) | ((int)buf[3] << 4) | (int) buf[4];
|
||||
}
|
||||
|
||||
/** Read an event from the current position in file.
|
||||
*
|
||||
* File position MUST be at the beginning of a delta time, or this will die very messily.
|
||||
|
@ -195,24 +211,37 @@ SMF::seek_to_start() const
|
|||
* \a size must be the capacity of \a buf. If it is not large enough, \a buf will
|
||||
* be reallocated and *size will be set to the new size of buf.
|
||||
*
|
||||
* if the event is a meta-event and is an Evoral Note ID, then \a note_id will be set
|
||||
* to the value of the NoteID; otherwise, meta-events will set \a note_id to -1.
|
||||
*
|
||||
* \return event length (including status byte) on success, 0 if event was
|
||||
* skipped (e.g. a meta event), or -1 on EOF (or end of track).
|
||||
* a meta event, or -1 on EOF (or end of track).
|
||||
*/
|
||||
int
|
||||
SMF::read_event(uint32_t* delta_t, uint32_t* size, uint8_t** buf) const
|
||||
SMF::read_event(uint32_t* delta_t, uint32_t* size, uint8_t** buf, event_id_t* note_id) const
|
||||
{
|
||||
smf_event_t* event;
|
||||
|
||||
assert(delta_t);
|
||||
assert(size);
|
||||
assert(buf);
|
||||
assert(note_id);
|
||||
|
||||
if ((event = smf_track_get_next_event(_smf_track)) != NULL) {
|
||||
|
||||
*delta_t = event->delta_time_pulses;
|
||||
|
||||
if (smf_event_is_metadata(event)) {
|
||||
return 0;
|
||||
*note_id = -1; // "no note id in this meta-event */
|
||||
if (event->midi_buffer[1] == 0x99) { // Evoral meta-event
|
||||
if (event->midi_buffer[2] == 6) { // 6 bytes following
|
||||
if (event->midi_buffer[3] == 0x1) { // Evoral Note ID
|
||||
*note_id = unmidify_note_id (&event->midi_buffer[4]);
|
||||
cerr << "Loaded Event ID " << *note_id << endl;
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0; /* this is a meta-event */
|
||||
}
|
||||
|
||||
int event_size = event->midi_buffer_length;
|
||||
|
@ -239,7 +268,7 @@ SMF::read_event(uint32_t* delta_t, uint32_t* size, uint8_t** buf) const
|
|||
}
|
||||
|
||||
void
|
||||
SMF::append_event_delta(uint32_t delta_t, uint32_t size, const uint8_t* buf)
|
||||
SMF::append_event_delta(uint32_t delta_t, uint32_t size, const uint8_t* buf, event_id_t note_id)
|
||||
{
|
||||
if (size == 0) {
|
||||
return;
|
||||
|
@ -257,6 +286,26 @@ SMF::append_event_delta(uint32_t delta_t, uint32_t size, const uint8_t* buf)
|
|||
|
||||
smf_event_t* event;
|
||||
|
||||
/* XXX july 2010: currently only store event ID's for notes
|
||||
*/
|
||||
|
||||
if (((buf[0] & 0xf0) == MIDI_CMD_NOTE_ON || ((buf[0] & 0xf0) == MIDI_CMD_NOTE_OFF)) && note_id >= 0) {
|
||||
event = smf_event_new ();
|
||||
assert(event != NULL);
|
||||
|
||||
event->midi_buffer = new uint8_t[9];
|
||||
event->midi_buffer_length = 9;
|
||||
|
||||
event->midi_buffer[0] = 0xff; // Meta-event
|
||||
event->midi_buffer[1] = 0x99; // Evoral meta-event
|
||||
event->midi_buffer[2] = 6; // 6 bytes of data follow */
|
||||
event->midi_buffer[3] = 0x1; // Evoral Note ID
|
||||
midify_note_id (note_id, &event->midi_buffer[4]);
|
||||
|
||||
assert(_smf_track);
|
||||
smf_track_add_event_delta_pulses(_smf_track, event, 0);
|
||||
}
|
||||
|
||||
event = smf_event_new_from_pointer(buf, size);
|
||||
assert(event != NULL);
|
||||
|
||||
|
|
|
@ -165,8 +165,7 @@ Sequence<Time>::const_iterator::const_iterator(const Sequence<Time>& seq, Time t
|
|||
switch (_type) {
|
||||
case NOTE_ON:
|
||||
DEBUG_TRACE (DEBUG::Sequence, string_compose ("Starting at note on event @ %1\n", earliest_t));
|
||||
_event = boost::shared_ptr< Event<Time> >(
|
||||
new Event<Time>((*_note_iter)->on_event(), true));
|
||||
_event = boost::shared_ptr<Event<Time> > (new Event<Time> ((*_note_iter)->on_event(), true));
|
||||
_active_notes.push(*_note_iter);
|
||||
break;
|
||||
case SYSEX:
|
||||
|
@ -603,7 +602,9 @@ Sequence<Time>::add_note_unlocked(const NotePtr note, void* arg)
|
|||
return false;
|
||||
}
|
||||
|
||||
_edited = true;
|
||||
if (note->id() < 0) {
|
||||
note->set_id (Evoral::next_event_id());
|
||||
}
|
||||
|
||||
if (note->note() < _lowest_note)
|
||||
_lowest_note = note->note();
|
||||
|
@ -613,7 +614,9 @@ Sequence<Time>::add_note_unlocked(const NotePtr note, void* arg)
|
|||
_notes.insert (note);
|
||||
_pitches[note->channel()].insert (note);
|
||||
|
||||
return true;
|
||||
_edited = true;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
template<typename Time>
|
||||
|
@ -676,10 +679,9 @@ Sequence<Time>::remove_note_unlocked(const constNotePtr note)
|
|||
*/
|
||||
template<typename Time>
|
||||
void
|
||||
Sequence<Time>::append(const Event<Time>& event)
|
||||
Sequence<Time>::append(const Event<Time>& event, event_id_t evid)
|
||||
{
|
||||
WriteLock lock(write_lock());
|
||||
_edited = true;
|
||||
|
||||
const MIDIEvent<Time>& ev = (const MIDIEvent<Time>&)event;
|
||||
|
||||
|
@ -691,224 +693,237 @@ Sequence<Time>::append(const Event<Time>& event)
|
|||
return;
|
||||
}
|
||||
|
||||
|
||||
if (ev.is_note_on()) {
|
||||
NotePtr note(new Note<Time>(ev.channel(), ev.time(), 0, ev.note(), ev.velocity()));
|
||||
append_note_on_unlocked (note);
|
||||
append_note_on_unlocked (note, evid);
|
||||
} else if (ev.is_note_off()) {
|
||||
NotePtr note(new Note<Time>(ev.channel(), ev.time(), 0, ev.note(), ev.velocity()));
|
||||
/* XXX note: event ID is discarded because we merge the on+off events into
|
||||
a single note object
|
||||
*/
|
||||
append_note_off_unlocked (note);
|
||||
} else if (ev.is_sysex()) {
|
||||
append_sysex_unlocked(ev);
|
||||
append_sysex_unlocked(ev, evid);
|
||||
} else if (ev.is_cc()) {
|
||||
append_control_unlocked(
|
||||
Evoral::MIDI::ContinuousController(ev.event_type(), ev.channel(), ev.cc_number()),
|
||||
ev.time(), ev.cc_value(), evid);
|
||||
} else if (ev.is_pgm_change()) {
|
||||
append_control_unlocked(
|
||||
Evoral::MIDI::ProgramChange(ev.event_type(), ev.channel()),
|
||||
ev.time(), ev.pgm_number(), evid);
|
||||
} else if (ev.is_pitch_bender()) {
|
||||
append_control_unlocked(
|
||||
Evoral::MIDI::PitchBender(ev.event_type(), ev.channel()),
|
||||
ev.time(), double ((0x7F & ev.pitch_bender_msb()) << 7
|
||||
| (0x7F & ev.pitch_bender_lsb())),
|
||||
evid);
|
||||
} else if (ev.is_channel_pressure()) {
|
||||
append_control_unlocked(
|
||||
Evoral::MIDI::ChannelPressure(ev.event_type(), ev.channel()),
|
||||
ev.time(), ev.channel_pressure(), evid);
|
||||
} else if (!_type_map.type_is_midi(ev.event_type())) {
|
||||
printf("WARNING: Sequence: Unknown event type %X: ", ev.event_type());
|
||||
for (size_t i=0; i < ev.size(); ++i) {
|
||||
printf("%X ", ev.buffer()[i]);
|
||||
}
|
||||
printf("\n");
|
||||
} else if (ev.is_cc()) {
|
||||
append_control_unlocked(
|
||||
Evoral::MIDI::ContinuousController(ev.event_type(), ev.channel(), ev.cc_number()),
|
||||
ev.time(), ev.cc_value());
|
||||
} else if (ev.is_pgm_change()) {
|
||||
append_control_unlocked(
|
||||
Evoral::MIDI::ProgramChange(ev.event_type(), ev.channel()),
|
||||
ev.time(), ev.pgm_number());
|
||||
} else if (ev.is_pitch_bender()) {
|
||||
append_control_unlocked(
|
||||
Evoral::MIDI::PitchBender(ev.event_type(), ev.channel()),
|
||||
ev.time(), double( (0x7F & ev.pitch_bender_msb()) << 7
|
||||
| (0x7F & ev.pitch_bender_lsb()) ));
|
||||
} else if (ev.is_channel_pressure()) {
|
||||
append_control_unlocked(
|
||||
Evoral::MIDI::ChannelPressure(ev.event_type(), ev.channel()),
|
||||
ev.time(), ev.channel_pressure());
|
||||
} else {
|
||||
printf("WARNING: Sequence: Unknown MIDI event type %X\n", ev.type());
|
||||
}
|
||||
|
||||
_edited = true;
|
||||
}
|
||||
|
||||
template<typename Time>
|
||||
void
|
||||
Sequence<Time>::append_note_on_unlocked (NotePtr note, event_id_t evid)
|
||||
{
|
||||
DEBUG_TRACE (DEBUG::Sequence, string_compose ("%1 c=%2 note %3 on @ %4 v=%5\n", this,
|
||||
(int) note->channel(), (int) note->note(),
|
||||
note->time(), (int) note->velocity()));
|
||||
assert(note->note() <= 127);
|
||||
assert(note->channel() < 16);
|
||||
assert(_writing);
|
||||
|
||||
if (note->id() < 0) {
|
||||
note->set_id (evid);
|
||||
}
|
||||
|
||||
if (note->velocity() == 0) {
|
||||
append_note_off_unlocked (note);
|
||||
return;
|
||||
}
|
||||
|
||||
add_note_unlocked (note);
|
||||
|
||||
if (!_percussive) {
|
||||
DEBUG_TRACE (DEBUG::Sequence, string_compose ("Sustained: Appending active note on %1 channel %2\n",
|
||||
(unsigned)(uint8_t)note->note(), note->channel()));
|
||||
_write_notes[note->channel()].insert (note);
|
||||
} else {
|
||||
DEBUG_TRACE(DEBUG::Sequence, "Percussive: NOT appending active note on\n");
|
||||
}
|
||||
}
|
||||
|
||||
template<typename Time>
|
||||
void
|
||||
Sequence<Time>::append_note_on_unlocked (NotePtr note)
|
||||
{
|
||||
DEBUG_TRACE (DEBUG::Sequence, string_compose ("%1 c=%2 note %3 on @ %4 v=%5\n", this,
|
||||
(int) note->channel(), (int) note->note(),
|
||||
note->time(), (int) note->velocity()));
|
||||
assert(note->note() <= 127);
|
||||
assert(note->channel() < 16);
|
||||
assert(_writing);
|
||||
void
|
||||
Sequence<Time>::append_note_off_unlocked (NotePtr note)
|
||||
{
|
||||
DEBUG_TRACE (DEBUG::Sequence, string_compose ("%1 c=%2 note %3 on @ %4 v=%5\n",
|
||||
this, (int)note->channel(),
|
||||
(int)note->note(), note->time(), (int)note->velocity()));
|
||||
assert(note->note() <= 127);
|
||||
assert(note->channel() < 16);
|
||||
assert(_writing);
|
||||
_edited = true;
|
||||
|
||||
if (note->velocity() == 0) {
|
||||
append_note_off_unlocked (note);
|
||||
return;
|
||||
}
|
||||
if (_percussive) {
|
||||
DEBUG_TRACE(DEBUG::Sequence, "Sequence Ignoring note off (percussive mode)\n");
|
||||
return;
|
||||
}
|
||||
|
||||
add_note_unlocked (note);
|
||||
bool resolved = false;
|
||||
|
||||
if (!_percussive) {
|
||||
DEBUG_TRACE (DEBUG::Sequence, string_compose ("Sustained: Appending active note on %1 channel %2\n",
|
||||
(unsigned)(uint8_t)note->note(), note->channel()));
|
||||
_write_notes[note->channel()].insert (note);
|
||||
} else {
|
||||
DEBUG_TRACE(DEBUG::Sequence, "Percussive: NOT appending active note on\n");
|
||||
}
|
||||
}
|
||||
/* _write_notes is sorted earliest-latest, so this will find the first matching note (FIFO) that
|
||||
matches this note (by pitch & channel). the MIDI specification doesn't provide any guidance
|
||||
whether to use FIFO or LIFO for this matching process, so SMF is fundamentally a lossy
|
||||
format.
|
||||
*/
|
||||
|
||||
template<typename Time>
|
||||
void
|
||||
Sequence<Time>::append_note_off_unlocked (NotePtr note)
|
||||
{
|
||||
DEBUG_TRACE (DEBUG::Sequence, string_compose ("%1 c=%2 note %3 on @ %4 v=%5\n",
|
||||
this, (int)note->channel(),
|
||||
(int)note->note(), note->time(), (int)note->velocity()));
|
||||
assert(note->note() <= 127);
|
||||
assert(note->channel() < 16);
|
||||
assert(_writing);
|
||||
_edited = true;
|
||||
/* XXX use _overlap_pitch_resolution to determine FIFO/LIFO ... */
|
||||
|
||||
if (_percussive) {
|
||||
DEBUG_TRACE(DEBUG::Sequence, "Sequence Ignoring note off (percussive mode)\n");
|
||||
return;
|
||||
}
|
||||
for (typename WriteNotes::iterator n = _write_notes[note->channel()].begin(); n != _write_notes[note->channel()].end(); ++n) {
|
||||
NotePtr nn = *n;
|
||||
if (note->note() == nn->note() && nn->channel() == note->channel()) {
|
||||
assert(note->time() >= nn->time());
|
||||
|
||||
bool resolved = false;
|
||||
nn->set_length (note->time() - nn->time());
|
||||
nn->set_off_velocity (note->velocity());
|
||||
|
||||
/* _write_notes is sorted earliest-latest, so this will find the first matching note (FIFO) that
|
||||
matches this note (by pitch & channel). the MIDI specification doesn't provide any guidance
|
||||
whether to use FIFO or LIFO for this matching process, so SMF is fundamentally a lossy
|
||||
format.
|
||||
*/
|
||||
_write_notes[note->channel()].erase(n);
|
||||
DEBUG_TRACE (DEBUG::Sequence, string_compose ("resolved note, length: %1\n", note->length()));
|
||||
resolved = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/* XXX use _overlap_pitch_resolution to determine FIFO/LIFO ... */
|
||||
if (!resolved) {
|
||||
cerr << this << " spurious note off chan " << (int)note->channel()
|
||||
<< ", note " << (int)note->note() << " @ " << note->time() << endl;
|
||||
}
|
||||
}
|
||||
|
||||
for (typename WriteNotes::iterator n = _write_notes[note->channel()].begin(); n != _write_notes[note->channel()].end(); ++n) {
|
||||
NotePtr nn = *n;
|
||||
if (note->note() == nn->note() && nn->channel() == note->channel()) {
|
||||
assert(note->time() >= nn->time());
|
||||
template<typename Time>
|
||||
void
|
||||
Sequence<Time>::append_control_unlocked(const Parameter& param, Time time, double value, event_id_t evid)
|
||||
{
|
||||
DEBUG_TRACE (DEBUG::Sequence, string_compose ("%1 %2 @ %3\t=\t%4 # controls: %5\n",
|
||||
this, _type_map.to_symbol(param), time, value, _controls.size()));
|
||||
boost::shared_ptr<Control> c = control(param, true);
|
||||
c->list()->rt_add(time, value);
|
||||
/* XXX control events should use IDs */
|
||||
}
|
||||
|
||||
nn->set_length (note->time() - nn->time());
|
||||
nn->set_off_velocity (note->velocity());
|
||||
template<typename Time>
|
||||
void
|
||||
Sequence<Time>::append_sysex_unlocked(const MIDIEvent<Time>& ev, event_id_t evid)
|
||||
{
|
||||
#ifdef DEBUG_SEQUENCE
|
||||
cerr << this << " SysEx @ " << ev.time() << " \t= \t [ " << hex;
|
||||
for (size_t i=0; i < ev.size(); ++i) {
|
||||
cerr << int(ev.buffer()[i]) << " ";
|
||||
} cerr << "]" << endl;
|
||||
#endif
|
||||
|
||||
_write_notes[note->channel()].erase(n);
|
||||
DEBUG_TRACE (DEBUG::Sequence, string_compose ("resolved note, length: %1\n", note->length()));
|
||||
resolved = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
boost::shared_ptr<MIDIEvent<Time> > event(new MIDIEvent<Time>(ev, true));
|
||||
/* XXX sysex events should use IDs */
|
||||
_sysexes.push_back(event);
|
||||
}
|
||||
|
||||
if (!resolved) {
|
||||
cerr << this << " spurious note off chan " << (int)note->channel()
|
||||
<< ", note " << (int)note->note() << " @ " << note->time() << endl;
|
||||
}
|
||||
}
|
||||
template<typename Time>
|
||||
bool
|
||||
Sequence<Time>::contains (const NotePtr& note) const
|
||||
{
|
||||
ReadLock lock (read_lock());
|
||||
return contains_unlocked (note);
|
||||
}
|
||||
|
||||
template<typename Time>
|
||||
void
|
||||
Sequence<Time>::append_control_unlocked(const Parameter& param, Time time, double value)
|
||||
{
|
||||
DEBUG_TRACE (DEBUG::Sequence, string_compose ("%1 %2 @ %3\t=\t%4 # controls: %5\n",
|
||||
this, _type_map.to_symbol(param), time, value, _controls.size()));
|
||||
boost::shared_ptr<Control> c = control(param, true);
|
||||
c->list()->rt_add(time, value);
|
||||
}
|
||||
template<typename Time>
|
||||
bool
|
||||
Sequence<Time>::contains_unlocked (const NotePtr& note) const
|
||||
{
|
||||
const Pitches& p (pitches (note->channel()));
|
||||
NotePtr search_note(new Note<Time>(0, 0, 0, note->note()));
|
||||
|
||||
template<typename Time>
|
||||
void
|
||||
Sequence<Time>::append_sysex_unlocked(const MIDIEvent<Time>& ev)
|
||||
{
|
||||
#ifdef DEBUG_SEQUENCE
|
||||
cerr << this << " SysEx @ " << ev.time() << " \t= \t [ " << hex;
|
||||
for (size_t i=0; i < ev.size(); ++i) {
|
||||
cerr << int(ev.buffer()[i]) << " ";
|
||||
} cerr << "]" << endl;
|
||||
#endif
|
||||
for (typename Pitches::const_iterator i = p.lower_bound (search_note);
|
||||
i != p.end() && (*i)->note() == note->note(); ++i) {
|
||||
|
||||
boost::shared_ptr<MIDIEvent<Time> > event(new MIDIEvent<Time>(ev, true));
|
||||
_sysexes.push_back(event);
|
||||
}
|
||||
if (**i == *note) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
template<typename Time>
|
||||
bool
|
||||
Sequence<Time>::contains (const NotePtr& note) const
|
||||
{
|
||||
return contains_unlocked (note);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
template<typename Time>
|
||||
bool
|
||||
Sequence<Time>::contains_unlocked (const NotePtr& note) const
|
||||
{
|
||||
const Pitches& p (pitches (note->channel()));
|
||||
NotePtr search_note(new Note<Time>(0, 0, 0, note->note()));
|
||||
template<typename Time>
|
||||
bool
|
||||
Sequence<Time>::overlaps (const NotePtr& note, const NotePtr& without) const
|
||||
{
|
||||
ReadLock lock (read_lock());
|
||||
return overlaps_unlocked (note, without);
|
||||
}
|
||||
|
||||
for (typename Pitches::const_iterator i = p.lower_bound (search_note);
|
||||
i != p.end() && (*i)->note() == note->note(); ++i) {
|
||||
template<typename Time>
|
||||
bool
|
||||
Sequence<Time>::overlaps_unlocked (const NotePtr& note, const NotePtr& without) const
|
||||
{
|
||||
Time sa = note->time();
|
||||
Time ea = note->end_time();
|
||||
|
||||
if (**i == *note) {
|
||||
cerr << "Existing note matches: " << *i << endl;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
const Pitches& p (pitches (note->channel()));
|
||||
NotePtr search_note(new Note<Time>(0, 0, 0, note->note()));
|
||||
|
||||
return false;
|
||||
}
|
||||
for (typename Pitches::const_iterator i = p.lower_bound (search_note);
|
||||
i != p.end() && (*i)->note() == note->note(); ++i) {
|
||||
|
||||
template<typename Time>
|
||||
bool
|
||||
Sequence<Time>::overlaps (const NotePtr& note, const NotePtr& without) const
|
||||
{
|
||||
ReadLock lock (read_lock());
|
||||
return overlaps_unlocked (note, without);
|
||||
}
|
||||
if (without && (**i) == *without) {
|
||||
continue;
|
||||
}
|
||||
|
||||
template<typename Time>
|
||||
bool
|
||||
Sequence<Time>::overlaps_unlocked (const NotePtr& note, const NotePtr& without) const
|
||||
{
|
||||
Time sa = note->time();
|
||||
Time ea = note->end_time();
|
||||
Time sb = (*i)->time();
|
||||
Time eb = (*i)->end_time();
|
||||
|
||||
const Pitches& p (pitches (note->channel()));
|
||||
NotePtr search_note(new Note<Time>(0, 0, 0, note->note()));
|
||||
if (((sb > sa) && (eb <= ea)) ||
|
||||
((eb >= sa) && (eb <= ea)) ||
|
||||
((sb > sa) && (sb <= ea)) ||
|
||||
((sa >= sb) && (sa <= eb) && (ea <= eb))) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
for (typename Pitches::const_iterator i = p.lower_bound (search_note);
|
||||
i != p.end() && (*i)->note() == note->note(); ++i) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (without && (**i) == *without) {
|
||||
continue;
|
||||
}
|
||||
template<typename Time>
|
||||
void
|
||||
Sequence<Time>::set_notes (const Sequence<Time>::Notes& n)
|
||||
{
|
||||
_notes = n;
|
||||
}
|
||||
|
||||
Time sb = (*i)->time();
|
||||
Time eb = (*i)->end_time();
|
||||
|
||||
if (((sb > sa) && (eb <= ea)) ||
|
||||
((eb >= sa) && (eb <= ea)) ||
|
||||
((sb > sa) && (sb <= ea)) ||
|
||||
((sa >= sb) && (sa <= eb) && (ea <= eb))) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
template<typename Time>
|
||||
void
|
||||
Sequence<Time>::set_notes (const Sequence<Time>::Notes& n)
|
||||
{
|
||||
_notes = n;
|
||||
}
|
||||
|
||||
/** Return the earliest note with time >= t */
|
||||
template<typename Time>
|
||||
typename Sequence<Time>::Notes::const_iterator
|
||||
Sequence<Time>::note_lower_bound (Time t) const
|
||||
{
|
||||
NotePtr search_note(new Note<Time>(0, t, 0, 0, 0));
|
||||
typename Sequence<Time>::Notes::const_iterator i = _notes.lower_bound(search_note);
|
||||
assert(i == _notes.end() || (*i)->time() >= t);
|
||||
return i;
|
||||
}
|
||||
/** Return the earliest note with time >= t */
|
||||
template<typename Time>
|
||||
typename Sequence<Time>::Notes::const_iterator
|
||||
Sequence<Time>::note_lower_bound (Time t) const
|
||||
{
|
||||
NotePtr search_note(new Note<Time>(0, t, 0, 0, 0));
|
||||
typename Sequence<Time>::Notes::const_iterator i = _notes.lower_bound(search_note);
|
||||
assert(i == _notes.end() || (*i)->time() >= t);
|
||||
return i;
|
||||
}
|
||||
|
||||
template<typename Time>
|
||||
void
|
||||
|
|
Loading…
Reference in New Issue
Block a user