(*i)->invalidate ();
}
- _model->read_lock();
+ MidiModel::ReadLock lock(_model->read_lock());
MidiModel::Notes& notes (_model->notes());
_optimization_iterator = _events.begin();
display_sysexes();
display_program_changes();
- _model->read_unlock();
-
_marked_for_selection.clear ();
_marked_for_velocity.clear ();
boost::shared_ptr<Evoral::Note<TimeType> > find_note (boost::shared_ptr<Evoral::Note<TimeType> >);
+private:
+ struct WriteLockImpl : public AutomatableSequence<Evoral::MusicalTime>::WriteLockImpl {
+ WriteLockImpl(Glib::Mutex::Lock* source_lock, Glib::RWLock& s, Glib::Mutex& c)
+ : AutomatableSequence<Evoral::MusicalTime>::WriteLockImpl(s, c)
+ , source_lock(source_lock)
+ {}
+ ~WriteLockImpl() {
+ delete source_lock;
+ }
+ Glib::Mutex::Lock* source_lock;
+ };
+
+public:
+ virtual WriteLock write_lock();
+
private:
friend class DeltaCommand;
bool _writing;
mutable Evoral::Sequence<Evoral::MusicalTime>::const_iterator _model_iter;
- mutable bool _model_iterator_valid;
+ mutable bool _model_iter_valid;
mutable double _length_beats;
mutable sframes_t _last_read_end;
// This could be made much faster by using a priority_queue for added and
// removed notes (or sort here), and doing a single iteration over _model
- Glib::Mutex::Lock lm (_model->_midi_source->mutex());
- _model->_midi_source->invalidate(); // release model read lock
- _model->write_lock();
+ MidiModel::WriteLock lock(_model->write_lock());
for (NoteList::iterator i = _added_notes.begin(); i != _added_notes.end(); ++i) {
_model->add_note_unlocked(*i);
_model->remove_note_unlocked(*i);
}
- _model->write_unlock();
+ lock.reset();
_model->ContentsChanged(); /* EMIT SIGNAL */
}
// This could be made much faster by using a priority_queue for added and
// removed notes (or sort here), and doing a single iteration over _model
- Glib::Mutex::Lock lm (_model->_midi_source->mutex());
- _model->_midi_source->invalidate(); // release model read lock
- _model->write_lock();
+ MidiModel::WriteLock lock(_model->write_lock());;
for (NoteList::iterator i = _added_notes.begin(); i != _added_notes.end(); ++i) {
_model->remove_note_unlocked(*i);
_model->add_note_unlocked(*i);
}
- _model->write_unlock();
+ lock.reset();
_model->ContentsChanged(); /* EMIT SIGNAL */
}
void
MidiModel::DiffCommand::operator()()
{
- Glib::Mutex::Lock lm (_model->_midi_source->mutex());
- _model->_midi_source->invalidate(); // release model read lock
- _model->write_lock();
+ MidiModel::WriteLock lock(_model->write_lock());
for (ChangeList::iterator i = _changes.begin(); i != _changes.end(); ++i) {
Property prop = i->property;
}
}
- _model->write_unlock();
+ lock.reset();
_model->ContentsChanged(); /* EMIT SIGNAL */
}
void
MidiModel::DiffCommand::undo()
{
- Glib::Mutex::Lock lm (_model->_midi_source->mutex());
- _model->_midi_source->invalidate(); // release model read lock
- _model->write_lock();
+ MidiModel::WriteLock lock(_model->write_lock());
for (ChangeList::iterator i = _changes.begin(); i != _changes.end(); ++i) {
Property prop = i->property;
}
}
- _model->write_unlock();
+ lock.reset();
_model->ContentsChanged(); /* EMIT SIGNAL */
}
bool
MidiModel::write_to(boost::shared_ptr<MidiSource> source)
{
- read_lock();
+ ReadLock lock(read_lock());
const bool old_percussive = percussive();
set_percussive(false);
set_percussive(old_percussive);
- read_unlock();
set_edited(false);
return true;
return boost::shared_ptr<Evoral::Note<TimeType> >();
}
+
+MidiModel::WriteLock
+MidiModel::write_lock()
+{
+ Glib::Mutex::Lock* source_lock = new Glib::Mutex::Lock(_midi_source->mutex());
+ _midi_source->invalidate(); // Release cached iterator's read lock on model
+ return WriteLock(new WriteLockImpl(source_lock, _lock, _control_lock));
+}
, _read_data_count(0)
, _write_data_count(0)
, _writing(false)
- , _model_iterator_valid(true)
+ , _model_iter_valid(false)
, _length_beats(0.0)
, _last_read_end(0)
, _last_write_end(0)
, _read_data_count(0)
, _write_data_count(0)
, _writing(false)
- , _model_iterator_valid(true)
+ , _model_iter_valid(false)
, _length_beats(0.0)
, _last_read_end(0)
, _last_write_end(0)
void
MidiSource::invalidate ()
{
- _model_iterator_valid = false;
+ _model_iter_valid = false;
+ _model_iter.invalidate();
}
nframes_t
Evoral::Sequence<double>::const_iterator& i = _model_iter;
// If the cached iterator is invalid, search for the first event past start
- if (_last_read_end == 0 || start != _last_read_end || !_model_iterator_valid) {
+ if (_last_read_end == 0 || start != _last_read_end || !_model_iter_valid) {
for (i = _model->begin(); i != _model->end(); ++i) {
if (BEATS_TO_FRAMES(i->time()) >= start) {
break;
}
}
- _model_iterator_valid = true;
+ _model_iter_valid = true;
}
_last_read_end = start + cnt;
public:
Sequence(const TypeMap& type_map);
- void write_lock();
- void write_unlock();
+protected:
+ struct WriteLockImpl {
+ WriteLockImpl(Glib::RWLock& s, Glib::Mutex& c)
+ : sequence_lock(new Glib::RWLock::WriterLock(s))
+ , control_lock(new Glib::Mutex::Lock(c))
+ { }
+ ~WriteLockImpl() {
+ delete sequence_lock;
+ delete control_lock;
+ }
+ Glib::RWLock::WriterLock* sequence_lock;
+ Glib::Mutex::Lock* control_lock;
+ };
+
+public:
+ typedef boost::shared_ptr<Glib::RWLock::ReaderLock> ReadLock;
+ typedef boost::shared_ptr<WriteLockImpl> WriteLock;
- void read_lock() const;
- void read_unlock() const;
+ virtual ReadLock read_lock() const { return ReadLock(new Glib::RWLock::ReaderLock(_lock)); }
+ virtual WriteLock write_lock() { return WriteLock(new WriteLockImpl(_lock, _control_lock)); }
void clear();
~const_iterator();
inline bool valid() const { return !_is_end && _event; }
- inline bool locked() const { return _locked; }
+ //inline bool locked() const { return _locked; }
void invalidate();
mutable ActiveNotes _active_notes;
MIDIMessageType _type;
bool _is_end;
- bool _locked;
+ typename Sequence::ReadLock _lock;
typename Notes::const_iterator _note_iter;
typename SysExes::const_iterator _sysex_iter;
ControlIterators _control_iters;
uint8_t highest_note() const { return _highest_note; }
protected:
- bool _edited;
+ bool _edited;
+ mutable Glib::RWLock _lock;
private:
friend class const_iterator;
void append_control_unlocked(const Parameter& param, Time time, double value);
void append_sysex_unlocked(const MIDIEvent<Time>& ev);
- mutable Glib::RWLock _lock;
-
const TypeMap& _type_map;
Notes _notes;
namespace Evoral {
-template<typename Time>
-void Sequence<Time>::write_lock() {
- _lock.writer_lock();
- _control_lock.lock();
-}
-
-template<typename Time>
-void Sequence<Time>::write_unlock() {
- _lock.writer_unlock();
- _control_lock.unlock();
-}
-
-template<typename Time>
-void Sequence<Time>::read_lock() const {
- _lock.reader_lock();
-}
-
-template<typename Time>
-void Sequence<Time>::read_unlock() const {
- _lock.reader_unlock();
-}
-
-
// Read iterator (const_iterator)
template<typename Time>
Sequence<Time>::const_iterator::const_iterator()
: _seq(NULL)
, _is_end(true)
- , _locked(false)
, _control_iter(_control_iters.end())
{
_event = boost::shared_ptr< Event<Time> >(new Event<Time>());
: _seq(&seq)
, _type(NIL)
, _is_end((t == DBL_MAX) || seq.empty())
- , _locked(!_is_end)
, _note_iter(seq.notes().end())
, _sysex_iter(seq.sysexes().end())
, _control_iter(_control_iters.end())
{
DUMP(format("Created Iterator @ %1% (is end: %2%)\n)") % t % _is_end);
- if (_is_end) {
+ if (!_is_end) {
+ _lock = seq.read_lock();
+ } else {
return;
}
- seq.read_lock();
+ typename Sequence<Time>::ReadLock lock(seq.read_lock());
// Find first note which begins at or after t
_note_iter = seq.note_lower_bound(t);
DUMP(format("Starting at end @ %1%\n") % t);
_type = NIL;
_is_end = true;
- _locked = false;
- _seq->read_unlock();
} else {
DUMP(printf("New iterator = 0x%x : 0x%x @ %f\n",
(int)_event->event_type(),
template<typename Time>
Sequence<Time>::const_iterator::~const_iterator()
{
- if (_locked) {
- _seq->read_unlock();
- }
}
template<typename Time>
_sysex_iter = _seq->sysexes().end();
}
_control_iter = _control_iters.end();
- if (_locked) {
- _seq->read_unlock();
- _locked = false;
- }
+ _lock.reset();
}
template<typename Time>
typename Sequence<Time>::const_iterator&
Sequence<Time>::const_iterator::operator=(const const_iterator& other)
{
- if (_seq != other._seq) {
- if (_locked) {
- _seq->read_unlock();
- }
- if (other._locked) {
- other._seq->read_lock();
- }
- } else if (!_locked && other._locked) {
- _seq->read_lock();
- }
-
_seq = other._seq;
_event = other._event;
_active_notes = other._active_notes;
_type = other._type;
_is_end = other._is_end;
- _locked = other._locked;
_note_iter = other._note_iter;
_sysex_iter = other._sysex_iter;
_control_iters = other._control_iters;
+ if (other._lock)
+ _lock = _seq->read_lock();
+ else
+ _lock.reset();
+
if (other._control_iter == other._control_iters.end()) {
_control_iter = _control_iters.end();
} else {
{
DUMP(format("Sequence (size %1%) constructed: %2%\n") % size % this);
assert(_end_iter._is_end);
- assert( ! _end_iter._locked);
+ assert( ! _end_iter._lock);
}
/** Write the controller event pointed to by \a iter to \a ev.
void
Sequence<Time>::clear()
{
- _lock.writer_lock();
+ WriteLock lock(write_lock());
_notes.clear();
for (Controls::iterator li = _controls.begin(); li != _controls.end(); ++li)
li->second->list()->clear();
- _lock.writer_unlock();
}
/** Begin a write of events to the model.
Sequence<Time>::start_write()
{
DUMP(format("%1% : start_write (percussive = %2%)\n") % this % _percussive);
- write_lock();
+ WriteLock lock(write_lock());
_writing = true;
for (int i = 0; i < 16; ++i) {
_write_notes[i].clear();
}
_dirty_controls.clear();
- write_unlock();
}
/** Finish a write of events to the model.
void
Sequence<Time>::end_write(bool delete_stuck)
{
- write_lock();
+ WriteLock lock(write_lock());
if (!_writing) {
- write_unlock();
return;
}
}
_writing = false;
- write_unlock();
}
/** Append \a ev to model. NOT realtime safe.
void
Sequence<Time>::append(const Event<Time>& event)
{
- write_lock();
+ WriteLock lock(write_lock());
_edited = true;
const MIDIEvent<Time>& ev = (const MIDIEvent<Time>&)event;
if (!midi_event_is_valid(ev.buffer(), ev.size())) {
cerr << "WARNING: Sequence ignoring illegal MIDI event" << endl;
- write_unlock();
return;
}
} else {
printf("WARNING: Sequence: Unknown MIDI event type %X\n", ev.type());
}
-
- write_unlock();
}
template<typename Time>
projects / ardour.git / commitdiff