/** @param force_discrete true to force ControlLists to use discrete evaluation, otherwise false to get them to use their configured mode */
template<typename Time>
-Sequence<Time>::const_iterator::const_iterator(const Sequence<Time>& seq, Time t, bool force_discrete, std::set<Evoral::Parameter> const & filtered)
+Sequence<Time>::const_iterator::const_iterator(const Sequence<Time>& seq,
+ Time t,
+ bool force_discrete,
+ const std::set<Evoral::Parameter>& filtered,
+ const std::set<WeakNotePtr>* active_notes)
: _seq(&seq)
, _active_patch_change_message (0)
, _type(NIL)
_lock = seq.read_lock();
+ // Add currently active notes, if given
+ if (active_notes) {
+ for (typename std::set<WeakNotePtr>::const_iterator i = active_notes->begin();
+ i != active_notes->end(); ++i) {
+ NotePtr note = i->lock();
+ if (note && note->time() <= t && note->end_time() > t) {
+ _active_notes.push(note);
+ }
+ }
+ }
+
// Find first note which begins at or after t
_note_iter = seq.note_lower_bound(t);
assert (_patch_change_iter == seq.patch_changes().end() || (*_patch_change_iter)->time() >= t);
// Find first control event after t
- ControlIterator earliest_control(boost::shared_ptr<ControlList>(), DBL_MAX, 0.0);
_control_iters.reserve(seq._controls.size());
bool found = false;
size_t earliest_control_index = 0;
+ double earliest_control_x = DBL_MAX;
for (Controls::const_iterator i = seq._controls.begin(); i != seq._controls.end(); ++i) {
if (filtered.find (i->first) != filtered.end()) {
_control_iters.push_back(new_iter);
// Found a new earliest_control
- if (x < earliest_control.x) {
- earliest_control = new_iter;
+ if (x < earliest_control_x) {
+ earliest_control_x = x;
earliest_control_index = _control_iters.size() - 1;
- found = true;
+ found = true;
}
}
if (found) {
_control_iter = _control_iters.begin() + earliest_control_index;
assert(_control_iter != _control_iters.end());
+ assert(_control_iter->list);
} else {
_control_iter = _control_iters.end();
}
- // Now find the earliest event overall and point to it
- Time earliest_t = t;
+ // Choose the earliest event overall to point to
+ choose_next(t);
+
+ // Allocate a new event for storing the current event in MIDI format
+ _event = boost::shared_ptr< Event<Time> >(
+ new Event<Time>(0, Time(), 4, NULL, true));
+
+ // Set event from chosen sub-iterator
+ set_event();
+
+ if (_is_end) {
+ DEBUG_TRACE(DEBUG::Sequence,
+ string_compose("Starting at end @ %1\n", t));
+ } else {
+ DEBUG_TRACE(DEBUG::Sequence,
+ string_compose("Starting at type 0x%1 : 0x%2 @ %3\n",
+ (int)_event->event_type(),
+ (int)((MIDIEvent<Time>*)_event.get())->type(),
+ _event->time()));
+ }
+}
- if (_note_iter != seq.notes().end()) {
- _type = NOTE_ON;
+template<typename Time>
+void
+Sequence<Time>::const_iterator::invalidate(std::set< boost::weak_ptr< Note<Time> > >* notes)
+{
+ while (!_active_notes.empty()) {
+ if (notes) {
+ notes->insert(_active_notes.top());
+ }
+ _active_notes.pop();
+ }
+ _type = NIL;
+ _is_end = true;
+ if (_seq) {
+ _note_iter = _seq->notes().end();
+ _sysex_iter = _seq->sysexes().end();
+ _patch_change_iter = _seq->patch_changes().end();
+ _active_patch_change_message = 0;
+ }
+ _control_iters.clear();
+ _control_iter = _control_iters.end();
+ _lock.reset();
+}
+
+template<typename Time>
+Time
+Sequence<Time>::const_iterator::choose_next(Time earliest_t)
+{
+ _type = NIL;
+
+ // Next earliest note on
+ if (_note_iter != _seq->notes().end()) {
+ _type = NOTE_ON;
earliest_t = (*_note_iter)->time();
}
- if (_sysex_iter != seq.sysexes().end()
- && ((*_sysex_iter)->time() < earliest_t || _type == NIL)) {
- _type = SYSEX;
- earliest_t = (*_sysex_iter)->time();
+ // Use the next note off iff it's earlier or the same time as the note on
+ if ((!_active_notes.empty())) {
+ if (_type == NIL || _active_notes.top()->end_time().to_double() <= earliest_t.to_double()) {
+ _type = NOTE_OFF;
+ earliest_t = _active_notes.top()->end_time();
+ }
}
- if (_patch_change_iter != seq.patch_changes().end() && ((*_patch_change_iter)->time() < earliest_t || _type == NIL)) {
- _type = PATCH_CHANGE;
- earliest_t = (*_patch_change_iter)->time ();
+ // Use the next earliest controller iff it's earlier than the note event
+ if (_control_iter != _control_iters.end() &&
+ _control_iter->list && _control_iter->x != DBL_MAX) {
+ if (_type == NIL || _control_iter->x < earliest_t.to_double()) {
+ _type = CONTROL;
+ earliest_t = Time(_control_iter->x);
+ }
}
- if (_control_iter != _control_iters.end()
- && earliest_control.list && earliest_control.x >= t.to_double()
- && (earliest_control.x < earliest_t.to_double() || _type == NIL)) {
- _type = CONTROL;
- earliest_t = Time(earliest_control.x);
+ // Use the next earliest SysEx iff it's earlier than the controller
+ if (_sysex_iter != _seq->sysexes().end()) {
+ if (_type == NIL || (*_sysex_iter)->time() < earliest_t) {
+ _type = SYSEX;
+ earliest_t = (*_sysex_iter)->time();
+ }
}
+ // Use the next earliest patch change iff it's earlier than the SysEx
+ if (_patch_change_iter != _seq->patch_changes().end()) {
+ if (_type == NIL || (*_patch_change_iter)->time() < earliest_t) {
+ _type = PATCH_CHANGE;
+ earliest_t = (*_patch_change_iter)->time();
+ }
+ }
+ return earliest_t;
+}
+
+template<typename Time>
+void
+Sequence<Time>::const_iterator::set_event()
+{
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));
+ DEBUG_TRACE(DEBUG::Sequence, "iterator = note on\n");
+ _event->assign ((*_note_iter)->on_event());
_active_notes.push(*_note_iter);
break;
+ case NOTE_OFF:
+ DEBUG_TRACE(DEBUG::Sequence, "iterator = note off\n");
+ assert(!_active_notes.empty());
+ _event->assign (_active_notes.top()->off_event());
+ // We don't pop the active note until we increment past it
+ break;
case SYSEX:
- DEBUG_TRACE (DEBUG::Sequence, string_compose ("Starting at sysex event @ %1\n", earliest_t));
- _event = boost::shared_ptr< Event<Time> >(
- new Event<Time>(*(*_sysex_iter), true));
+ DEBUG_TRACE(DEBUG::Sequence, "iterator = sysex\n");
+ _event->assign (*(*_sysex_iter));
break;
case CONTROL:
- DEBUG_TRACE (DEBUG::Sequence, string_compose ("Starting at control event @ %1\n", earliest_t));
- seq.control_to_midi_event(_event, earliest_control);
+ DEBUG_TRACE(DEBUG::Sequence, "iterator = control\n");
+ _seq->control_to_midi_event(_event, *_control_iter);
break;
case PATCH_CHANGE:
- DEBUG_TRACE (DEBUG::Sequence, string_compose ("Starting at patch change event @ %1\n", earliest_t));
- _event = boost::shared_ptr<Event<Time> > (new Event<Time> ((*_patch_change_iter)->message (_active_patch_change_message), true));
+ DEBUG_TRACE(DEBUG::Sequence, "iterator = program change\n");
+ _event->assign ((*_patch_change_iter)->message (_active_patch_change_message));
break;
default:
+ _is_end = true;
break;
}
if (_type == NIL || !_event || _event->size() == 0) {
- DEBUG_TRACE (DEBUG::Sequence, string_compose ("Starting at end @ %1\n", t));
+ DEBUG_TRACE(DEBUG::Sequence, "iterator = end\n");
_type = NIL;
_is_end = true;
} else {
- DEBUG_TRACE (DEBUG::Sequence, string_compose ("New iterator = 0x%1 : 0x%2 @ %3\n",
- (int)_event->event_type(),
- (int)((MIDIEvent<Time>*)_event.get())->type(),
- _event->time()));
-
assert(midi_event_is_valid(_event->buffer(), _event->size()));
}
-
-}
-
-template<typename Time>
-Sequence<Time>::const_iterator::~const_iterator()
-{
-}
-
-template<typename Time>
-void
-Sequence<Time>::const_iterator::invalidate()
-{
- while (!_active_notes.empty()) {
- _active_notes.pop();
- }
- _type = NIL;
- _is_end = true;
- if (_seq) {
- _note_iter = _seq->notes().end();
- _sysex_iter = _seq->sysexes().end();
- _patch_change_iter = _seq->patch_changes().end();
- _active_patch_change_message = 0;
- }
- _control_iter = _control_iters.end();
- _lock.reset();
}
template<typename Time>
++_note_iter;
break;
case NOTE_OFF:
+ _active_notes.pop();
break;
case CONTROL:
// Increment current controller iterator
assert(false);
}
- // Now find the earliest event overall and point to it
- _type = NIL;
- Time earliest_t = std::numeric_limits<Time>::max();
-
- // Next earliest note on
- if (_note_iter != _seq->notes().end()) {
- _type = NOTE_ON;
- earliest_t = (*_note_iter)->time();
- }
-
- // Use the next note off iff it's earlier or the same time as the note on
-#ifdef PERCUSSIVE_IGNORE_NOTE_OFFS
- // issue 0005121 When in Percussive mode, all note offs go missing, which jams all MIDI instruments that they stop playing
- // remove this code since it drowns MIDI instruments by stealing all voices and crashes LinuxSampler
- if (!_seq->percussive() && (!_active_notes.empty())) {
-#else
- if ((!_active_notes.empty())) {
-#endif
- if (_type == NIL || _active_notes.top()->end_time() <= earliest_t) {
- _type = NOTE_OFF;
- earliest_t = _active_notes.top()->end_time();
- }
- }
-
- // Use the next earliest controller iff it's earlier than the note event
- if (_control_iter != _control_iters.end() && _control_iter->x != DBL_MAX) {
- if (_type == NIL || _control_iter->x < earliest_t.to_double()) {
- _type = CONTROL;
- earliest_t = Time(_control_iter->x);
- }
- }
-
- // Use the next earliest SysEx iff it's earlier than the controller
- if (_sysex_iter != _seq->sysexes().end()) {
- if (_type == NIL || (*_sysex_iter)->time() < earliest_t) {
- _type = SYSEX;
- earliest_t = (*_sysex_iter)->time();
- }
- }
+ // Choose the earliest event overall to point to
+ choose_next(std::numeric_limits<Time>::max());
- // Use the next earliest patch change iff it's earlier than the SysEx
- if (_patch_change_iter != _seq->patch_changes().end()) {
- if (_type == NIL || (*_patch_change_iter)->time() < earliest_t) {
- _type = PATCH_CHANGE;
- earliest_t = (*_patch_change_iter)->time();
- }
- }
-
- // Set event to reflect new position
- switch (_type) {
- case NOTE_ON:
- // DEBUG_TRACE(DEBUG::Sequence, "iterator = note on\n");
- *_event = (*_note_iter)->on_event();
- _active_notes.push(*_note_iter);
- break;
- case NOTE_OFF:
- // DEBUG_TRACE(DEBUG::Sequence, "iterator = note off\n");
- assert(!_active_notes.empty());
- *_event = _active_notes.top()->off_event();
- _active_notes.pop();
- break;
- case CONTROL:
- //DEBUG_TRACE(DEBUG::Sequence, "iterator = control\n");
- _seq->control_to_midi_event(_event, *_control_iter);
- break;
- case SYSEX:
- //DEBUG_TRACE(DEBUG::Sequence, "iterator = sysex\n");
- *_event = *(*_sysex_iter);
- break;
- case PATCH_CHANGE:
- //DEBUG_TRACE(DEBUG::Sequence, "iterator = patch change\n");
- *_event = (*_patch_change_iter)->message (_active_patch_change_message);
- break;
- default:
- //DEBUG_TRACE(DEBUG::Sequence, "iterator = end\n");
- _is_end = true;
- }
+ // Set event from chosen sub-iterator
+ set_event();
assert(_is_end || (_event->size() > 0 && _event->buffer() && _event->buffer()[0] != '\0'));
DEBUG_TRACE (DEBUG::Sequence, string_compose ("%1 : end_write (%2 notes) delete stuck option %3 @ %4\n", this, _notes.size(), option, when));
- #ifdef PERCUSSIVE_IGNORE_NOTE_OFFS
- if (!_percussive) {
- #endif
- for (typename Notes::iterator n = _notes.begin(); n != _notes.end() ;) {
- typename Notes::iterator next = n;
- ++next;
+ for (typename Notes::iterator n = _notes.begin(); n != _notes.end() ;) {
+ typename Notes::iterator next = n;
+ ++next;
- if (!(*n)->length()) {
- switch (option) {
- case Relax:
- break;
- case DeleteStuckNotes:
- cerr << "WARNING: Stuck note lost: " << (*n)->note() << endl;
- _notes.erase(n);
- break;
- case ResolveStuckNotes:
- if (when <= (*n)->time()) {
- cerr << "WARNING: Stuck note resolution - end time @ "
- << when << " is before note on: " << (**n) << endl;
- _notes.erase (*n);
- } else {
- (*n)->set_length (when - (*n)->time());
- cerr << "WARNING: resolved note-on with no note-off to generate " << (**n) << endl;
- }
- break;
+ if (!(*n)->length()) {
+ switch (option) {
+ case Relax:
+ break;
+ case DeleteStuckNotes:
+ cerr << "WARNING: Stuck note lost: " << (*n)->note() << endl;
+ _notes.erase(n);
+ break;
+ case ResolveStuckNotes:
+ if (when <= (*n)->time()) {
+ cerr << "WARNING: Stuck note resolution - end time @ "
+ << when << " is before note on: " << (**n) << endl;
+ _notes.erase (*n);
+ } else {
+ (*n)->set_length (when - (*n)->time());
+ cerr << "WARNING: resolved note-on with no note-off to generate " << (**n) << endl;
}
+ break;
}
-
- n = next;
}
- #ifdef PERCUSSIVE_IGNORE_NOTE_OFFS
+
+ n = next;
}
- #endif
for (int i = 0; i < 16; ++i) {
_write_notes[i].clear();
return;
}
- if (ev.is_note_on()) {
- NotePtr note(new Note<Time>(ev.channel(), ev.time(), Time(), ev.note(), ev.velocity()));
- append_note_on_unlocked (note, evid);
- } else if (ev.is_note_off()) {
- NotePtr note(new Note<Time>(ev.channel(), ev.time(), Time(), ev.note(), ev.velocity()));
+ if (ev.is_note_on() && ev.velocity() > 0) {
+ append_note_on_unlocked (ev, evid);
+ } else if (ev.is_note_off() || (ev.is_note_on() && ev.velocity() == 0)) {
/* XXX note: event ID is discarded because we merge the on+off events into
a single note object
*/
- append_note_off_unlocked (note);
+ append_note_off_unlocked (ev);
} else if (ev.is_sysex()) {
append_sysex_unlocked(ev, evid);
} else if (ev.is_cc() && (ev.cc_number() == MIDI_CTL_MSB_BANK || ev.cc_number() == MIDI_CTL_LSB_BANK)) {
template<typename Time>
void
-Sequence<Time>::append_note_on_unlocked (NotePtr note, event_id_t evid)
+Sequence<Time>::append_note_on_unlocked (const MIDIEvent<Time>& ev, 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()));
+ (int)ev.channel(), (int)ev.note(),
+ ev.time(), (int)ev.velocity()));
assert(_writing);
- if (note->note() > 127) {
- error << string_compose (_("illegal note number (%1) used in Note on event - event will be ignored"), (int) note->note()) << endmsg;
+ if (ev.note() > 127) {
+ error << string_compose (_("invalid note on number (%1) ignored"), (int) ev.note()) << endmsg;
return;
- }
- if (note->channel() >= 16) {
- error << string_compose (_("illegal channel number (%1) used in Note on event - event will be ignored"), (int) note->channel()) << endmsg;
+ } else if (ev.channel() >= 16) {
+ error << string_compose (_("invalid note on channel (%1) ignored"), (int) ev.channel()) << endmsg;
return;
- }
-
- if (note->id() < 0) {
- note->set_id (evid);
- }
-
- if (note->velocity() == 0) {
- append_note_off_unlocked (note);
+ } else if (ev.velocity() == 0) {
+ // Note on with velocity 0 handled as note off by caller
+ error << string_compose (_("invalid note on velocity (%1) ignored"), (int) ev.velocity()) << endmsg;
return;
}
- add_note_unlocked (note);
+ NotePtr note(new Note<Time>(ev.channel(), ev.time(), Time(), ev.note(), ev.velocity()));
+ note->set_id (evid);
- #ifdef PERCUSSIVE_IGNORE_NOTE_OFFS
- if (!_percussive) {
- #endif
+ add_note_unlocked (note);
- 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);
-
- #ifdef PERCUSSIVE_IGNORE_NOTE_OFFS
- } else {
- DEBUG_TRACE(DEBUG::Sequence, "Percussive: NOT appending active note on\n");
- }
- #endif
+ DEBUG_TRACE (DEBUG::Sequence, string_compose ("Appending active note on %1 channel %2\n",
+ (unsigned)(uint8_t)note->note(), note->channel()));
+ _write_notes[note->channel()].insert (note);
}
template<typename Time>
void
-Sequence<Time>::append_note_off_unlocked (NotePtr note)
+Sequence<Time>::append_note_off_unlocked (const MIDIEvent<Time>& ev)
{
DEBUG_TRACE (DEBUG::Sequence, string_compose ("%1 c=%2 note %3 OFF @ %4 v=%5\n",
- this, (int)note->channel(),
- (int)note->note(), note->time(), (int)note->velocity()));
+ this, (int)ev.channel(),
+ (int)ev.note(), ev.time(), (int)ev.velocity()));
assert(_writing);
- if (note->note() > 127) {
- error << string_compose (_("illegal note number (%1) used in Note off event - event will be ignored"), (int) note->note()) << endmsg;
+ if (ev.note() > 127) {
+ error << string_compose (_("invalid note off number (%1) ignored"), (int) ev.note()) << endmsg;
return;
- }
- if (note->channel() >= 16) {
- error << string_compose (_("illegal channel number (%1) used in Note off event - event will be ignored"), (int) note->channel()) << endmsg;
+ } else if (ev.channel() >= 16) {
+ error << string_compose (_("invalid note off channel (%1) ignored"), (int) ev.channel()) << endmsg;
return;
}
_edited = true;
-#ifdef PERCUSSIVE_IGNORE_NOTE_OFFS
- if (_percussive) {
- DEBUG_TRACE(DEBUG::Sequence, "Sequence Ignoring note off (percussive mode)\n");
- return;
- }
-#endif
-
bool resolved = false;
/* _write_notes is sorted earliest-latest, so this will find the first matching note (FIFO) that
/* XXX use _overlap_pitch_resolution to determine FIFO/LIFO ... */
- for (typename WriteNotes::iterator n = _write_notes[note->channel()].begin(); n != _write_notes[note->channel()].end(); ) {
+ for (typename WriteNotes::iterator n = _write_notes[ev.channel()].begin(); n != _write_notes[ev.channel()].end(); ) {
typename WriteNotes::iterator tmp = n;
++tmp;
NotePtr nn = *n;
- if (note->note() == nn->note() && nn->channel() == note->channel()) {
- assert(note->time() >= nn->time());
+ if (ev.note() == nn->note() && nn->channel() == ev.channel()) {
+ assert(ev.time() >= nn->time());
- nn->set_length (note->time() - nn->time());
- nn->set_off_velocity (note->velocity());
+ nn->set_length (ev.time() - nn->time());
+ nn->set_off_velocity (ev.velocity());
- _write_notes[note->channel()].erase(n);
+ _write_notes[ev.channel()].erase(n);
DEBUG_TRACE (DEBUG::Sequence, string_compose ("resolved note @ %2 length: %1\n", nn->length(), nn->time()));
resolved = true;
break;
}
if (!resolved) {
- cerr << this << " spurious note off chan " << (int)note->channel()
- << ", note " << (int)note->note() << " @ " << note->time() << endl;
+ cerr << this << " spurious note off chan " << (int)ev.channel()
+ << ", note " << (int)ev.note() << " @ " << ev.time() << endl;
}
}
{
DEBUG_TRACE (DEBUG::Sequence, string_compose ("%1 %2 @ %3 = %4 # controls: %5\n",
this, _type_map.to_symbol(param), time, value, _controls.size()));
- boost::shared_ptr<Control> c;
- Controls::iterator i = _controls.find(param);
- if (i != _controls.end()) {
- c = i->second;
- } else {
- /* Create a new control list with discrete interpolation by default, to
- play back recorded data exactly. */
- c = control_factory(param);
- c->list()->set_interpolation(ControlList::Discrete);
- add_control(c);
- }
-
+ boost::shared_ptr<Control> c = control(param, true);
c->list()->add (time.to_double(), value);
/* XXX control events should use IDs */
}
str << "--- dump\n";
}
-template class Sequence<Evoral::MusicalTime>;
+template class Sequence<Evoral::Beats>;
} // namespace Evoral