smokephil/ardour
1
0
Fork 0
mirror of https://github.com/Ardour/ardour.git synced 2025-12-08 07:45:00 +01:00
Code Issues Projects Releases Wiki Activity

Make (MIDI) event time stamp type a template parameter.

Browse source 
git-svn-id: svn://localhost/ardour2/branches/3.0@4473 d708f5d6-7413-0410-9779-e7cbd77b26cf
This commit is contained in:
David Robillard 2009-02-02 02:36:05 +00:00
parent ead5dd4568
commit 166ef64e3d
54 changed files with 534 additions and 424 deletions
Download patch file Download diff file Expand all files Collapse all files

10
gtk2_ardour/canvas-hit.h
View file

@ -29,11 +29,13 @@ namespace Canvas {
class CanvasHit : public Diamond, public CanvasNoteEvent { class CanvasHit : public Diamond, public CanvasNoteEvent {
public: public:
typedef Evoral::Note<double> NoteType;
CanvasHit( CanvasHit(
MidiRegionView& region, MidiRegionView& region,
Group& group, Group& group,
double size, double size,
const boost::shared_ptr<Evoral::Note> note = boost::shared_ptr<Evoral::Note>()) const boost::shared_ptr<NoteType> note = boost::shared_ptr<NoteType>())
: Diamond(group, size), CanvasNoteEvent(region, this, note) : Diamond(group, size), CanvasNoteEvent(region, this, note)
{ {

2
gtk2_ardour/canvas-note-event.cc
View file

@ -39,7 +39,7 @@ const uint32_t CanvasNoteEvent::midi_channel_colors[16] = {
}; };
CanvasNoteEvent::CanvasNoteEvent(MidiRegionView& region, Item* item, CanvasNoteEvent::CanvasNoteEvent(MidiRegionView& region, Item* item,
const boost::shared_ptr<Evoral::Note> note) const boost::shared_ptr<NoteType> note)
: _region(region) : _region(region)
, _item(item) , _item(item)
, _text(0) , _text(0)

27
gtk2_ardour/canvas-note-event.h
View file

@ -32,7 +32,7 @@
class Editor; class Editor;
class MidiRegionView; class MidiRegionView;
namespace Evoral { class Note; } namespace Evoral { template<typename T> class Note; }
namespace Gnome { namespace Gnome {
namespace Canvas { namespace Canvas {
@ -51,10 +51,11 @@ namespace Canvas {
*/ */
class CanvasNoteEvent : public sigc::trackable, public InteractiveItem { class CanvasNoteEvent : public sigc::trackable, public InteractiveItem {
public: public:
typedef Evoral::Note<double> NoteType;
CanvasNoteEvent( CanvasNoteEvent(
MidiRegionView& region, MidiRegionView& region,
Item* item, Item* item,
const boost::shared_ptr<Evoral::Note> note = boost::shared_ptr<Evoral::Note>()); const boost::shared_ptr<NoteType> note = boost::shared_ptr<NoteType>());
virtual ~CanvasNoteEvent(); virtual ~CanvasNoteEvent();
@ -87,7 +88,7 @@ public:
virtual double x2() = 0; virtual double x2() = 0;
virtual double y2() = 0; virtual double y2() = 0;
const boost::shared_ptr<Evoral::Note> note() const { return _note; } const boost::shared_ptr<NoteType> note() const { return _note; }
inline static uint32_t meter_style_fill_color(uint8_t vel) inline static uint32_t meter_style_fill_color(uint8_t vel)
{ {
@ -116,14 +117,14 @@ public:
protected: protected:
enum State { None, Pressed, Dragging }; enum State { None, Pressed, Dragging };
MidiRegionView& _region; MidiRegionView& _region;
Item* const _item; Item* const _item;
InteractiveText* _text; InteractiveText* _text;
Widget* _channel_selector_widget; Widget* _channel_selector_widget;
State _state; State _state;
const boost::shared_ptr<Evoral::Note> _note; const boost::shared_ptr<NoteType> _note;
bool _own_note; bool _own_note;
bool _selected; bool _selected;
}; };
} // namespace Gnome } // namespace Gnome

8
gtk2_ardour/canvas-note.h
View file

@ -31,6 +31,8 @@ namespace Canvas {
class CanvasNote : public SimpleRect, public CanvasNoteEvent { class CanvasNote : public SimpleRect, public CanvasNoteEvent {
public: public:
typedef Evoral::Note<double> NoteType;
double x1() { return property_x1(); } double x1() { return property_x1(); }
double y1() { return property_y1(); } double y1() { return property_y1(); }
double x2() { return property_x2(); } double x2() { return property_x2(); }
@ -53,9 +55,9 @@ public:
}; };
CanvasNote( CanvasNote(
MidiRegionView& region, MidiRegionView& region,
Group& group, Group& group,
const boost::shared_ptr<Evoral::Note> note = boost::shared_ptr<Evoral::Note>()) const boost::shared_ptr<NoteType> note = boost::shared_ptr<NoteType>())
: SimpleRect(group), CanvasNoteEvent(region, this, note), _note_state(None) : SimpleRect(group), CanvasNoteEvent(region, this, note), _note_state(None)
{ {

20
gtk2_ardour/midi_region_view.cc
View file

@ -456,7 +456,7 @@ MidiRegionView::create_note_at(double x, double y, double length)
new_note_length = snap_to_frame(new_note_time_position_relative + new_note_length) + _region->start() new_note_length = snap_to_frame(new_note_time_position_relative + new_note_length) + _region->start()
- new_note_time; - new_note_time;
const boost::shared_ptr<Evoral::Note> new_note(new Evoral::Note( const boost::shared_ptr<NoteType> new_note(new NoteType(
0, new_note_time, new_note_length, (uint8_t)note, 0x40)); 0, new_note_time, new_note_length, (uint8_t)note, 0x40));
view->update_note_range(new_note->note()); view->update_note_range(new_note->note());
@ -504,7 +504,7 @@ MidiRegionView::start_delta_command(string name)
} }
void void
MidiRegionView::command_add_note(const boost::shared_ptr<Evoral::Note> note, bool selected) MidiRegionView::command_add_note(const boost::shared_ptr<NoteType> note, bool selected)
{ {
if (_delta_command) if (_delta_command)
_delta_command->add(note); _delta_command->add(note);
@ -889,7 +889,7 @@ MidiRegionView::extend_active_notes()
} }
void void
MidiRegionView::play_midi_note(boost::shared_ptr<Evoral::Note> note) MidiRegionView::play_midi_note(boost::shared_ptr<NoteType> note)
{ {
if (!trackview.editor().sound_notes()) { if (!trackview.editor().sound_notes()) {
return; return;
@ -907,7 +907,7 @@ MidiRegionView::play_midi_note(boost::shared_ptr<Evoral::Note> note)
} }
bool bool
MidiRegionView::play_midi_note_off(boost::shared_ptr<Evoral::Note> note) MidiRegionView::play_midi_note_off(boost::shared_ptr<NoteType> note)
{ {
RouteUI* route_ui = dynamic_cast<RouteUI*> (&trackview); RouteUI* route_ui = dynamic_cast<RouteUI*> (&trackview);
assert(route_ui); assert(route_ui);
@ -925,7 +925,7 @@ MidiRegionView::play_midi_note_off(boost::shared_ptr<Evoral::Note> note)
* event arrives, to properly display the note. * event arrives, to properly display the note.
*/ */
void void
MidiRegionView::add_note(const boost::shared_ptr<Evoral::Note> note) MidiRegionView::add_note(const boost::shared_ptr<NoteType> note)
{ {
assert(note->time() >= 0); assert(note->time() >= 0);
assert(midi_view()->note_mode() == Sustained || midi_view()->note_mode() == Percussive); assert(midi_view()->note_mode() == Sustained || midi_view()->note_mode() == Percussive);
@ -967,7 +967,7 @@ MidiRegionView::add_note(const boost::shared_ptr<Evoral::Note> note)
// finish the old note rectangle // finish the old note rectangle
if (_active_notes[note->note()]) { if (_active_notes[note->note()]) {
CanvasNote* const old_rect = _active_notes[note->note()]; CanvasNote* const old_rect = _active_notes[note->note()];
boost::shared_ptr<Evoral::Note> old_note = old_rect->note(); boost::shared_ptr<NoteType> old_note = old_rect->note();
cerr << "MidiModel: WARNING: Note has length 0: chan " << old_note->channel() cerr << "MidiModel: WARNING: Note has length 0: chan " << old_note->channel()
<< "note " << (int)old_note->note() << " @ " << old_note->time() << endl; << "note " << (int)old_note->note() << " @ " << old_note->time() << endl;
/* FIXME: How large to make it? Make it a diamond? */ /* FIXME: How large to make it? Make it a diamond? */
@ -1338,7 +1338,7 @@ MidiRegionView::note_dropped(CanvasNoteEvent* ev, double dt, uint8_t dnote)
Selection::iterator next = i; Selection::iterator next = i;
++next; ++next;
const boost::shared_ptr<Evoral::Note> copy(new Evoral::Note(*(*i)->note().get())); const boost::shared_ptr<NoteType> copy(new NoteType(*(*i)->note().get()));
// we need to snap here again in nframes64_t in order to be sample accurate // we need to snap here again in nframes64_t in order to be sample accurate
double new_note_time = (*i)->note()->time(); double new_note_time = (*i)->note()->time();
@ -1530,7 +1530,7 @@ MidiRegionView::commit_resizing(CanvasNote::NoteEnd note_end, double event_x, bo
// transform to region start relative // transform to region start relative
current_frame += _region->start(); current_frame += _region->start();
const boost::shared_ptr<Evoral::Note> copy(new Evoral::Note(*(canvas_note->note().get()))); const boost::shared_ptr<NoteType> copy(new NoteType(*(canvas_note->note().get())));
// resize beginning of note // resize beginning of note
if (note_end == CanvasNote::NOTE_ON && current_frame < copy->end_time()) { if (note_end == CanvasNote::NOTE_ON && current_frame < copy->end_time()) {
@ -1556,7 +1556,7 @@ MidiRegionView::commit_resizing(CanvasNote::NoteEnd note_end, double event_x, bo
void void
MidiRegionView::change_note_velocity(CanvasNoteEvent* event, int8_t velocity, bool relative) MidiRegionView::change_note_velocity(CanvasNoteEvent* event, int8_t velocity, bool relative)
{ {
const boost::shared_ptr<Evoral::Note> copy(new Evoral::Note(*(event->note().get()))); const boost::shared_ptr<NoteType> copy(new NoteType(*(event->note().get())));
if (relative) { if (relative) {
uint8_t new_velocity = copy->velocity() + velocity; uint8_t new_velocity = copy->velocity() + velocity;
@ -1598,7 +1598,7 @@ MidiRegionView::change_channel(uint8_t channel)
++next; ++next;
CanvasNoteEvent* event = *i; CanvasNoteEvent* event = *i;
const boost::shared_ptr<Evoral::Note> copy(new Evoral::Note(*(event->note().get()))); const boost::shared_ptr<NoteType> copy(new NoteType(*(event->note().get())));
copy->set_channel(channel); copy->set_channel(channel);

12
gtk2_ardour/midi_region_view.h
View file

@ -58,6 +58,8 @@ class AutomationRegionView;
class MidiRegionView : public RegionView class MidiRegionView : public RegionView
{ {
public: public:
typedef Evoral::Note<ARDOUR::MidiModel::TimeType> NoteType;
MidiRegionView (ArdourCanvas::Group *, MidiRegionView (ArdourCanvas::Group *,
RouteTimeAxisView&, RouteTimeAxisView&,
boost::shared_ptr<ARDOUR::MidiRegion>, boost::shared_ptr<ARDOUR::MidiRegion>,
@ -91,7 +93,7 @@ class MidiRegionView : public RegionView
GhostRegion* add_ghost (TimeAxisView&); GhostRegion* add_ghost (TimeAxisView&);
void add_note(const boost::shared_ptr<Evoral::Note> note); void add_note(const boost::shared_ptr<NoteType> note);
void resolve_note(uint8_t note_num, double end_time); void resolve_note(uint8_t note_num, double end_time);
struct ControlEvent struct ControlEvent
@ -159,7 +161,7 @@ class MidiRegionView : public RegionView
void display_model(boost::shared_ptr<ARDOUR::MidiModel> model); void display_model(boost::shared_ptr<ARDOUR::MidiModel> model);
void start_delta_command(string name = "midi edit"); void start_delta_command(string name = "midi edit");
void command_add_note(const boost::shared_ptr<Evoral::Note> note, bool selected); void command_add_note(const boost::shared_ptr<NoteType> note, bool selected);
void command_remove_note(ArdourCanvas::CanvasNoteEvent* ev); void command_remove_note(ArdourCanvas::CanvasNoteEvent* ev);
void apply_command(); void apply_command();
@ -264,12 +266,12 @@ class MidiRegionView : public RegionView
/** Play the NoteOn event of the given note immediately /** Play the NoteOn event of the given note immediately
* and schedule the playback of the corresponding NoteOff event. * and schedule the playback of the corresponding NoteOff event.
*/ */
void play_midi_note(boost::shared_ptr<Evoral::Note> note); void play_midi_note(boost::shared_ptr<NoteType> note);
/** Play the NoteOff-Event of the given note immediately /** Play the NoteOff-Event of the given note immediately
* (scheduled by @ref play_midi_note()). * (scheduled by @ref play_midi_note()).
*/ */
bool play_midi_note_off(boost::shared_ptr<Evoral::Note> note); bool play_midi_note_off(boost::shared_ptr<NoteType> note);
void clear_events(); void clear_events();
void switch_source(boost::shared_ptr<ARDOUR::Source> src); void switch_source(boost::shared_ptr<ARDOUR::Source> src);
@ -317,7 +319,7 @@ class MidiRegionView : public RegionView
/** New notes (created in the current command) which should be selected /** New notes (created in the current command) which should be selected
* when they appear after the command is applied. */ * when they appear after the command is applied. */
std::set< boost::shared_ptr<Evoral::Note> > _marked_for_selection; std::set< boost::shared_ptr<NoteType> > _marked_for_selection;
std::vector<NoteResizeData *> _resize_data; std::vector<NoteResizeData *> _resize_data;
}; };

2
gtk2_ardour/midi_streamview.cc
View file

@ -605,7 +605,7 @@ MidiStreamView::update_rec_regions (boost::shared_ptr<MidiModel> data, nframes_t
// FIXME: slooooooooow! // FIXME: slooooooooow!
const boost::shared_ptr<Evoral::Note> note = data->note_at(i); const boost::shared_ptr<MidiRegionView::NoteType> note = data->note_at(i);
if (note->length() > 0 && note->end_time() + region->position() > start) if (note->length() > 0 && note->end_time() + region->position() > start)
mrv->resolve_note(note->note(), note->end_time()); mrv->resolve_note(note->note(), note->end_time());

5
libs/ardour/ardour/automatable.h
View file

@ -114,12 +114,13 @@ public:
/** Contains notes and controllers */ /** Contains notes and controllers */
class AutomatableSequence : public Automatable, public Evoral::Sequence { template<typename T>
class AutomatableSequence : public Automatable, public Evoral::Sequence<T> {
public: public:
AutomatableSequence(Session& s, size_t size) AutomatableSequence(Session& s, size_t size)
: Evoral::ControlSet() : Evoral::ControlSet()
, Automatable(s) , Automatable(s)
, Evoral::Sequence(EventTypeMap::instance()) , Evoral::Sequence<T>(EventTypeMap::instance())
{} {}
}; };

5
libs/ardour/ardour/diskstream.h
View file

@ -143,7 +143,8 @@ class Diskstream : public SessionObject
void remove_region_from_last_capture (boost::weak_ptr<Region> wregion); void remove_region_from_last_capture (boost::weak_ptr<Region> wregion);
void move_processor_automation (boost::weak_ptr<Processor>, Evoral::RangeMoveList const &); void move_processor_automation (boost::weak_ptr<Processor>,
list< Evoral::RangeMove<nframes_t> > const &);
sigc::signal<void> RecordEnableChanged; sigc::signal<void> RecordEnableChanged;
sigc::signal<void> SpeedChanged; sigc::signal<void> SpeedChanged;
@ -209,7 +210,7 @@ class Diskstream : public SessionObject
virtual void playlist_changed (Change); virtual void playlist_changed (Change);
virtual void playlist_deleted (boost::weak_ptr<Playlist>); virtual void playlist_deleted (boost::weak_ptr<Playlist>);
virtual void playlist_ranges_moved (Evoral::RangeMoveList const &); virtual void playlist_ranges_moved (list< Evoral::RangeMove<nframes_t> > const &);
virtual void transport_stopped (struct tm&, time_t, bool abort) = 0; virtual void transport_stopped (struct tm&, time_t, bool abort) = 0;
virtual void transport_looped (nframes_t transport_frame) = 0; virtual void transport_looped (nframes_t transport_frame) = 0;

20
libs/ardour/ardour/midi_buffer.h
View file

@ -32,6 +32,8 @@ namespace ARDOUR {
class MidiBuffer : public Buffer class MidiBuffer : public Buffer
{ {
public: public:
typedef double TimeType;
MidiBuffer(size_t capacity); MidiBuffer(size_t capacity);
~MidiBuffer(); ~MidiBuffer();
@ -41,7 +43,7 @@ public:
void copy(const MidiBuffer& copy); void copy(const MidiBuffer& copy);
bool push_back(const Evoral::MIDIEvent& event); bool push_back(const Evoral::MIDIEvent<TimeType>& event);
bool push_back(const jack_midi_event_t& event); bool push_back(const jack_midi_event_t& event);
uint8_t* reserve(double time, size_t size); uint8_t* reserve(double time, size_t size);
@ -54,14 +56,14 @@ public:
struct iterator_base { struct iterator_base {
iterator_base<B,E>(B& b, size_t o) : buffer(b), offset(o) {} iterator_base<B,E>(B& b, size_t o) : buffer(b), offset(o) {}
inline E operator*() const { inline E operator*() const {
uint8_t* ev_start = buffer._data + offset + sizeof(Evoral::EventTime); uint8_t* ev_start = buffer._data + offset + sizeof(TimeType);
return E(EventTypeMap::instance().midi_event_type(*ev_start), return E(EventTypeMap::instance().midi_event_type(*ev_start),
*(Evoral::EventTime*)(buffer._data + offset), *(TimeType*)(buffer._data + offset),
Evoral::midi_event_size(*ev_start) + 1, ev_start); Evoral::midi_event_size(*ev_start) + 1, ev_start);
} }
inline iterator_base<B,E>& operator++() { inline iterator_base<B,E>& operator++() {
uint8_t* ev_start = buffer._data + offset + sizeof(Evoral::EventTime); uint8_t* ev_start = buffer._data + offset + sizeof(TimeType);
offset += sizeof(Evoral::EventTime) + Evoral::midi_event_size(*ev_start) + 1; offset += sizeof(TimeType) + Evoral::midi_event_size(*ev_start) + 1;
return *this; return *this;
} }
inline bool operator!=(const iterator_base<B,E>& other) const { inline bool operator!=(const iterator_base<B,E>& other) const {
@ -71,8 +73,8 @@ public:
size_t offset; size_t offset;
}; };
typedef iterator_base<MidiBuffer, Evoral::MIDIEvent> iterator; typedef iterator_base< MidiBuffer, Evoral::MIDIEvent<TimeType> > iterator;
typedef iterator_base<const MidiBuffer, const Evoral::MIDIEvent> const_iterator; typedef iterator_base< const MidiBuffer, const Evoral::MIDIEvent<TimeType> > const_iterator;
iterator begin() { return iterator(*this, 0); } iterator begin() { return iterator(*this, 0); }
iterator end() { return iterator(*this, _size); } iterator end() { return iterator(*this, _size); }
@ -81,8 +83,8 @@ public:
const_iterator end() const { return const_iterator(*this, _size); } const_iterator end() const { return const_iterator(*this, _size); }
private: private:
friend class iterator_base<MidiBuffer, Evoral::MIDIEvent>; friend class iterator_base< MidiBuffer, Evoral::MIDIEvent<TimeType> >;
friend class iterator_base<const MidiBuffer, const Evoral::MIDIEvent>; friend class iterator_base< const MidiBuffer, const Evoral::MIDIEvent<TimeType> >;
size_t _size; ///< Size in bytes of used portion of _data size_t _size; ///< Size in bytes of used portion of _data
uint8_t* _data; ///< timestamp, event, timestamp, event, ... uint8_t* _data; ///< timestamp, event, timestamp, event, ...

20
libs/ardour/ardour/midi_diskstream.h
View file

@ -170,18 +170,18 @@ class MidiDiskstream : public Diskstream
void engage_record_enable (); void engage_record_enable ();
void disengage_record_enable (); void disengage_record_enable ();
void check_note_onoffs(Evoral::MIDIEvent &event); void check_note_onoffs(Evoral::MIDIEvent<MidiBuffer::TimeType> &event);
void emit_pending_note_offs(MidiBuffer &dst, nframes_t time); void emit_pending_note_offs(MidiBuffer &dst, nframes_t time);
MidiRingBuffer* _playback_buf; MidiRingBuffer<MidiBuffer::TimeType>* _playback_buf;
MidiRingBuffer* _capture_buf; MidiRingBuffer<MidiBuffer::TimeType>* _capture_buf;
MidiPort* _source_port; MidiPort* _source_port;
boost::shared_ptr<SMFSource> _write_source; boost::shared_ptr<SMFSource> _write_source;
nframes_t _last_flush_frame; nframes_t _last_flush_frame;
NoteMode _note_mode; NoteMode _note_mode;
MidiStateTracker _midistate_tracker; MidiStateTracker _midistate_tracker;
volatile gint _frames_written_to_ringbuffer; volatile gint _frames_written_to_ringbuffer;
volatile gint _frames_read_from_ringbuffer; volatile gint _frames_read_from_ringbuffer;
}; };
}; /* namespace ARDOUR */ }; /* namespace ARDOUR */

14
libs/ardour/ardour/midi_model.h
View file

@ -47,8 +47,10 @@ class MidiSource;
* Because of this MIDI controllers and automatable controllers/widgets/etc * Because of this MIDI controllers and automatable controllers/widgets/etc
* are easily interchangeable. * are easily interchangeable.
*/ */
class MidiModel : public AutomatableSequence { class MidiModel : public AutomatableSequence<double> {
public: public:
typedef double TimeType;
MidiModel(MidiSource* s, size_t size=0); MidiModel(MidiSource* s, size_t size=0);
NoteMode note_mode() const { return (percussive() ? Percussive : Sustained); } NoteMode note_mode() const { return (percussive() ? Percussive : Sustained); }
@ -71,17 +73,17 @@ public:
int set_state (const XMLNode&); int set_state (const XMLNode&);
XMLNode& get_state (); XMLNode& get_state ();
void add(const boost::shared_ptr<Evoral::Note> note); void add(const boost::shared_ptr< Evoral::Note<TimeType> > note);
void remove(const boost::shared_ptr<Evoral::Note> note); void remove(const boost::shared_ptr< Evoral::Note<TimeType> > note);
private: private:
XMLNode &marshal_note(const boost::shared_ptr<Evoral::Note> note); XMLNode &marshal_note(const boost::shared_ptr< Evoral::Note<TimeType> > note);
boost::shared_ptr<Evoral::Note> unmarshal_note(XMLNode *xml_note); boost::shared_ptr< Evoral::Note<TimeType> > unmarshal_note(XMLNode *xml_note);
boost::shared_ptr<MidiModel> _model; boost::shared_ptr<MidiModel> _model;
const std::string _name; const std::string _name;
typedef std::list< boost::shared_ptr<Evoral::Note> > NoteList; typedef std::list< boost::shared_ptr< Evoral::Note<TimeType> > > NoteList;
NoteList _added_notes; NoteList _added_notes;
NoteList _removed_notes; NoteList _removed_notes;

4
libs/ardour/ardour/midi_playlist.h
View file

@ -34,7 +34,7 @@ class Session;
class Region; class Region;
class MidiRegion; class MidiRegion;
class Source; class Source;
class MidiRingBuffer; template<typename T> class MidiRingBuffer;
class MidiPlaylist : public ARDOUR::Playlist class MidiPlaylist : public ARDOUR::Playlist
{ {
@ -47,7 +47,7 @@ public:
~MidiPlaylist (); ~MidiPlaylist ();
nframes_t read (MidiRingBuffer& buf, nframes_t read (MidiRingBuffer<double>& buf,
nframes_t start, nframes_t cnt, uint32_t chan_n=0); nframes_t start, nframes_t cnt, uint32_t chan_n=0);
int set_state (const XMLNode&); int set_state (const XMLNode&);

10
libs/ardour/ardour/midi_region.h
View file

@ -43,11 +43,13 @@ class Playlist;
class Session; class Session;
class MidiFilter; class MidiFilter;
class MidiSource; class MidiSource;
class MidiRingBuffer; template<typename T> class MidiRingBuffer;
class MidiRegion : public Region class MidiRegion : public Region
{ {
public: public:
typedef double TimeType;
~MidiRegion(); ~MidiRegion();
boost::shared_ptr<MidiSource> midi_source (uint32_t n=0) const; boost::shared_ptr<MidiSource> midi_source (uint32_t n=0) const;
@ -56,13 +58,13 @@ class MidiRegion : public Region
virtual nframes64_t read (Sample*, nframes64_t pos, nframes64_t cnt, int channel) const { return 0; } virtual nframes64_t read (Sample*, nframes64_t pos, nframes64_t cnt, int channel) const { return 0; }
virtual nframes64_t readable_length() const { return length(); } virtual nframes64_t readable_length() const { return length(); }
nframes_t read_at (MidiRingBuffer& dst, nframes_t read_at (MidiRingBuffer<TimeType>& dst,
nframes_t position, nframes_t position,
nframes_t dur, nframes_t dur,
uint32_t chan_n = 0, uint32_t chan_n = 0,
NoteMode mode = Sustained) const; NoteMode mode = Sustained) const;
nframes_t master_read_at (MidiRingBuffer& dst, nframes_t master_read_at (MidiRingBuffer<TimeType>& dst,
nframes_t position, nframes_t position,
nframes_t dur, nframes_t dur,
uint32_t chan_n = 0, uint32_t chan_n = 0,
@ -106,7 +108,7 @@ class MidiRegion : public Region
MidiRegion (const SourceList &, const XMLNode&); MidiRegion (const SourceList &, const XMLNode&);
private: private:
nframes_t _read_at (const SourceList&, MidiRingBuffer& dst, nframes_t _read_at (const SourceList&, MidiRingBuffer<TimeType>& dst,
nframes_t position, nframes_t position,
nframes_t dur, nframes_t dur,
uint32_t chan_n = 0, uint32_t chan_n = 0,

21
libs/ardour/ardour/midi_ring_buffer.h
View file

@ -37,16 +37,17 @@ class MidiBuffer;
* *
* [timestamp][type][size][size bytes of raw MIDI][timestamp][type][size](etc...) * [timestamp][type][size][size bytes of raw MIDI][timestamp][type][size](etc...)
*/ */
class MidiRingBuffer : public Evoral::EventRingBuffer { template<typename T>
class MidiRingBuffer : public Evoral::EventRingBuffer<T> {
public: public:
/** @param size Size in bytes. /** @param size Size in bytes.
*/ */
MidiRingBuffer(size_t size) MidiRingBuffer(size_t size)
: Evoral::EventRingBuffer(size) : Evoral::EventRingBuffer<T>(size)
, _channel_mask(0x0000FFFF) , _channel_mask(0x0000FFFF)
{} {}
inline bool read_prefix(Evoral::EventTime* time, Evoral::EventType* type, uint32_t* size); inline bool read_prefix(T* time, Evoral::EventType* type, uint32_t* size);
inline bool read_contents(uint32_t size, uint8_t* buf); inline bool read_contents(uint32_t size, uint8_t* buf);
size_t read(MidiBuffer& dst, nframes_t start, nframes_t end, nframes_t offset=0); size_t read(MidiBuffer& dst, nframes_t start, nframes_t end, nframes_t offset=0);
@ -86,14 +87,15 @@ private:
/** Read the time and size of an event. This call MUST be immediately proceeded /** Read the time and size of an event. This call MUST be immediately proceeded
* by a call to read_contents (or the read pointer will be garbage). * by a call to read_contents (or the read pointer will be garbage).
*/ */
template<typename T>
inline bool inline bool
MidiRingBuffer::read_prefix(Evoral::EventTime* time, Evoral::EventType* type, uint32_t* size) MidiRingBuffer<T>::read_prefix(T* time, Evoral::EventType* type, uint32_t* size)
{ {
bool success = Evoral::EventRingBuffer::full_read(sizeof(Evoral::EventTime), (uint8_t*)time); bool success = Evoral::EventRingBuffer<T>::full_read(sizeof(T), (uint8_t*)time);
if (success) if (success)
success = Evoral::EventRingBuffer::full_read(sizeof(Evoral::EventType), (uint8_t*)type); success = Evoral::EventRingBuffer<T>::full_read(sizeof(Evoral::EventType), (uint8_t*)type);
if (success) if (success)
success = Evoral::EventRingBuffer::full_read(sizeof(uint32_t), (uint8_t*)size); success = Evoral::EventRingBuffer<T>::full_read(sizeof(uint32_t), (uint8_t*)size);
return success; return success;
} }
@ -102,10 +104,11 @@ MidiRingBuffer::read_prefix(Evoral::EventTime* time, Evoral::EventType* type, ui
/** Read the content of an event. This call MUST be immediately preceded /** Read the content of an event. This call MUST be immediately preceded
* by a call to read_prefix (or the returned even will be garbage). * by a call to read_prefix (or the returned even will be garbage).
*/ */
template<typename T>
inline bool inline bool
MidiRingBuffer::read_contents(uint32_t size, uint8_t* buf) MidiRingBuffer<T>::read_contents(uint32_t size, uint8_t* buf)
{ {
return Evoral::EventRingBuffer::full_read(size, buf); return Evoral::EventRingBuffer<T>::full_read(size, buf);
} }

14
libs/ardour/ardour/midi_source.h
View file

@ -39,12 +39,14 @@ using std::string;
namespace ARDOUR { namespace ARDOUR {
class MidiRingBuffer; template<typename T> class MidiRingBuffer;
/** Source for MIDI data */ /** Source for MIDI data */
class MidiSource : public Source class MidiSource : public Source
{ {
public: public:
typedef double TimeType;
MidiSource (Session& session, string name); MidiSource (Session& session, string name);
MidiSource (Session& session, const XMLNode&); MidiSource (Session& session, const XMLNode&);
virtual ~MidiSource (); virtual ~MidiSource ();
@ -55,10 +57,10 @@ class MidiSource : public Source
virtual uint32_t n_channels () const { return 1; } virtual uint32_t n_channels () const { return 1; }
// FIXME: integrate this with the Readable::read interface somehow // FIXME: integrate this with the Readable::read interface somehow
virtual nframes_t midi_read (MidiRingBuffer& dst, nframes_t start, nframes_t cnt, nframes_t stamp_offset, nframes_t negative_stamp_offset) const; virtual nframes_t midi_read (MidiRingBuffer<TimeType>& dst, nframes_t start, nframes_t cnt, nframes_t stamp_offset, nframes_t negative_stamp_offset) const;
virtual nframes_t midi_write (MidiRingBuffer& src, nframes_t cnt); virtual nframes_t midi_write (MidiRingBuffer<TimeType>& src, nframes_t cnt);
virtual void append_event_unlocked(EventTimeUnit unit, const Evoral::Event& ev) = 0; virtual void append_event_unlocked(EventTimeUnit unit, const Evoral::Event<TimeType>& ev) = 0;
virtual void mark_for_remove() = 0; virtual void mark_for_remove() = 0;
virtual void mark_streaming_midi_write_started (NoteMode mode, nframes_t start_time); virtual void mark_streaming_midi_write_started (NoteMode mode, nframes_t start_time);
@ -99,8 +101,8 @@ class MidiSource : public Source
//virtual int flush_header() = 0; //virtual int flush_header() = 0;
//virtual int flush_footer() = 0; //virtual int flush_footer() = 0;
virtual nframes_t read_unlocked (MidiRingBuffer& dst, nframes_t start, nframes_t cnt, nframes_t stamp_offset, nframes_t negative_stamp_offset) const = 0; virtual nframes_t read_unlocked (MidiRingBuffer<TimeType>& dst, nframes_t start, nframes_t cnt, nframes_t stamp_offset, nframes_t negative_stamp_offset) const = 0;
virtual nframes_t write_unlocked (MidiRingBuffer& dst, nframes_t cnt) = 0; virtual nframes_t write_unlocked (MidiRingBuffer<TimeType>& dst, nframes_t cnt) = 0;
mutable Glib::Mutex _lock; mutable Glib::Mutex _lock;
string _captured_for; string _captured_for;

2
libs/ardour/ardour/midi_state_tracker.h
View file

@ -40,7 +40,7 @@ public:
void resolve_notes (MidiBuffer& buffer, nframes_t time); void resolve_notes (MidiBuffer& buffer, nframes_t time);
private: private:
void track_note_onoffs(const Evoral::MIDIEvent& event); void track_note_onoffs(const Evoral::MIDIEvent<MidiBuffer::TimeType>& event);
std::bitset<128*16> _active_notes; std::bitset<128*16> _active_notes;
}; };

4
libs/ardour/ardour/midi_track.h
View file

@ -104,8 +104,8 @@ private:
void set_state_part_two (); void set_state_part_two ();
void set_state_part_three (); void set_state_part_three ();
MidiRingBuffer _immediate_events; MidiRingBuffer<double> _immediate_events;
NoteMode _note_mode; NoteMode _note_mode;
}; };
} /* namespace ARDOUR*/ } /* namespace ARDOUR*/

4
libs/ardour/ardour/playlist.h
View file

@ -128,7 +128,7 @@ class Playlist : public SessionObject, public boost::enable_shared_from_this<Pla
sigc::signal<void> Modified; sigc::signal<void> Modified;
sigc::signal<void> NameChanged; sigc::signal<void> NameChanged;
sigc::signal<void> LengthChanged; sigc::signal<void> LengthChanged;
sigc::signal<void, Evoral::RangeMoveList const &> RangesMoved; sigc::signal<void, list< Evoral::RangeMove<nframes_t> > const &> RangesMoved;
static string bump_name (string old_name, Session&); static string bump_name (string old_name, Session&);
@ -190,7 +190,7 @@ class Playlist : public SessionObject, public boost::enable_shared_from_this<Pla
RegionList pending_bounds; RegionList pending_bounds;
bool pending_modified; bool pending_modified;
bool pending_length; bool pending_length;
Evoral::RangeMoveList pending_range_moves; list< Evoral::RangeMove<nframes_t> > pending_range_moves;
bool save_on_thaw; bool save_on_thaw;
string last_save_reason; string last_save_reason;
uint32_t in_set_state; uint32_t in_set_state;

12
libs/ardour/ardour/smf_source.h
View file

@ -27,14 +27,14 @@
#include <ardour/midi_source.h> #include <ardour/midi_source.h>
#include <evoral/SMF.hpp> #include <evoral/SMF.hpp>
namespace Evoral { class Event; } namespace Evoral { template<typename T> class Event; }
namespace ARDOUR { namespace ARDOUR {
class MidiRingBuffer; template<typename T> class MidiRingBuffer;
/** Standard Midi File (Type 0) Source */ /** Standard Midi File (Type 0) Source */
class SMFSource : public MidiSource, public Evoral::SMF { class SMFSource : public MidiSource, public Evoral::SMF<double> {
public: public:
enum Flag { enum Flag {
Writable = 0x1, Writable = 0x1,
@ -74,7 +74,7 @@ class SMFSource : public MidiSource, public Evoral::SMF {
void set_allow_remove_if_empty (bool yn); void set_allow_remove_if_empty (bool yn);
void mark_for_remove(); void mark_for_remove();
void append_event_unlocked(EventTimeUnit unit, const Evoral::Event& ev); void append_event_unlocked(EventTimeUnit unit, const Evoral::Event<double>& ev);
int move_to_trash (const string trash_dir_name); int move_to_trash (const string trash_dir_name);
@ -100,14 +100,14 @@ class SMFSource : public MidiSource, public Evoral::SMF {
int init (string idstr, bool must_exist); int init (string idstr, bool must_exist);
nframes_t read_unlocked ( nframes_t read_unlocked (
MidiRingBuffer& dst, MidiRingBuffer<double>& dst,
nframes_t start, nframes_t start,
nframes_t cn, nframes_t cn,
nframes_t stamp_offset, nframes_t stamp_offset,
nframes_t negative_stamp_offset) const; nframes_t negative_stamp_offset) const;
nframes_t write_unlocked ( nframes_t write_unlocked (
MidiRingBuffer& src, MidiRingBuffer<double>& src,
nframes_t cnt); nframes_t cnt);
bool find (std::string path, bool must_exist, bool& is_new); bool find (std::string path, bool must_exist, bool& is_new);

19
libs/ardour/diskstream.cc
View file

@ -418,12 +418,18 @@ Diskstream::remove_region_from_last_capture (boost::weak_ptr<Region> wregion)
} }
void void
Diskstream::playlist_ranges_moved (Evoral::RangeMoveList const & movements) Diskstream::playlist_ranges_moved (list< Evoral::RangeMove<nframes_t> > const & movements_frames)
{ {
if (Config->get_automation_follows_regions () == false) { if (Config->get_automation_follows_regions () == false) {
return; return;
} }
list< Evoral::RangeMove<double> > movements;
for (list< Evoral::RangeMove<nframes_t> >::const_iterator i = movements_frames.begin();
i != movements_frames.end(); ++i) {
movements.push_back(Evoral::RangeMove<double>(i->from, i->length, i->to));
}
/* move gain automation */ /* move gain automation */
boost::shared_ptr<AutomationList> gain_alist = _io->gain_control()->alist(); boost::shared_ptr<AutomationList> gain_alist = _io->gain_control()->alist();
XMLNode & before = gain_alist->get_state (); XMLNode & before = gain_alist->get_state ();
@ -452,18 +458,25 @@ Diskstream::playlist_ranges_moved (Evoral::RangeMoveList const & movements)
/* XXX: ewww */ /* XXX: ewww */
Route * route = dynamic_cast<Route*> (_io); Route * route = dynamic_cast<Route*> (_io);
if (route) { if (route) {
route->foreach_processor (sigc::bind (sigc::mem_fun (*this, &Diskstream::move_processor_automation), movements)); route->foreach_processor (sigc::bind (sigc::mem_fun (*this, &Diskstream::move_processor_automation), movements_frames));
} }
} }
void void
Diskstream::move_processor_automation (boost::weak_ptr<Processor> p, Evoral::RangeMoveList const & movements) Diskstream::move_processor_automation (boost::weak_ptr<Processor> p,
list< Evoral::RangeMove<nframes_t> > const & movements_frames)
{ {
boost::shared_ptr<Processor> processor (p.lock ()); boost::shared_ptr<Processor> processor (p.lock ());
if (!processor) { if (!processor) {
return; return;
} }
list< Evoral::RangeMove<double> > movements;
for (list< Evoral::RangeMove<nframes_t> >::const_iterator i = movements_frames.begin();
i != movements_frames.end(); ++i) {
movements.push_back(Evoral::RangeMove<double>(i->from, i->length, i->to));
}
set<Evoral::Parameter> const a = processor->what_can_be_automated (); set<Evoral::Parameter> const a = processor->what_can_be_automated ();
for (set<Evoral::Parameter>::iterator i = a.begin (); i != a.end (); ++i) { for (set<Evoral::Parameter>::iterator i = a.begin (); i != a.end (); ++i) {

2
libs/ardour/import.cc
View file

@ -312,7 +312,7 @@ static void
write_midi_data_to_new_files (Evoral::SMFReader* source, Session::import_status& status, write_midi_data_to_new_files (Evoral::SMFReader* source, Session::import_status& status,
vector<boost::shared_ptr<Source> >& newfiles) vector<boost::shared_ptr<Source> >& newfiles)
{ {
Evoral::Event ev(0, 0.0, 4, NULL, true); Evoral::Event<double> ev(0, 0.0, 4, NULL, true);
status.progress = 0.0f; status.progress = 0.0f;

2
libs/ardour/meter.cc
View file

@ -50,7 +50,7 @@ PeakMeter::run_in_place (BufferSet& bufs, nframes_t start_frame, nframes_t end_f
// GUI needs a better MIDI meter, not much information can be // GUI needs a better MIDI meter, not much information can be
// expressed through peaks alone // expressed through peaks alone
for (MidiBuffer::iterator i = bufs.get_midi(n).begin(); i != bufs.get_midi(n).end(); ++i) { for (MidiBuffer::iterator i = bufs.get_midi(n).begin(); i != bufs.get_midi(n).end(); ++i) {
const Evoral::MIDIEvent ev(*i, false); const Evoral::MIDIEvent<double> ev(*i, false);
if (ev.is_note_on()) { if (ev.is_note_on()) {
const float this_vel = log(ev.buffer()[2] / 127.0 * (M_E*M_E-M_E) + M_E) - 1.0; const float this_vel = log(ev.buffer()[2] / 127.0 * (M_E*M_E-M_E) + M_E) - 1.0;
//printf("V %d -> %f\n", (int)((Byte)ev.buffer[2]), this_vel); //printf("V %d -> %f\n", (int)((Byte)ev.buffer[2]), this_vel);

18
libs/ardour/midi_buffer.cc
View file

@ -99,7 +99,7 @@ MidiBuffer::read_from(const Buffer& src, nframes_t nframes, nframes_t offset)
} }
for (MidiBuffer::const_iterator i = msrc.begin(); i != msrc.end(); ++i) { for (MidiBuffer::const_iterator i = msrc.begin(); i != msrc.end(); ++i) {
const Evoral::MIDIEvent ev(*i, false); const Evoral::MIDIEvent<TimeType> ev(*i, false);
/*cout << this << " MidiBuffer::read_from event type: " << int(ev.type()) /*cout << this << " MidiBuffer::read_from event type: " << int(ev.type())
<< " time: " << ev.time() << " size: " << ev.size() << " time: " << ev.time() << " size: " << ev.size()
<< " status: " << (int)*ev.buffer() << " buffer size: " << _size << endl;*/ << " status: " << (int)*ev.buffer() << " buffer size: " << _size << endl;*/
@ -126,16 +126,16 @@ MidiBuffer::read_from(const Buffer& src, nframes_t nframes, nframes_t offset)
* @return false if operation failed (not enough room) * @return false if operation failed (not enough room)
*/ */
bool bool
MidiBuffer::push_back(const Evoral::MIDIEvent& ev) MidiBuffer::push_back(const Evoral::MIDIEvent<TimeType>& ev)
{ {
const size_t stamp_size = sizeof(Evoral::EventTime); const size_t stamp_size = sizeof(TimeType);
if (_size + stamp_size + ev.size() >= _capacity) { if (_size + stamp_size + ev.size() >= _capacity) {
cerr << "MidiBuffer::push_back failed (buffer is full)" << endl; cerr << "MidiBuffer::push_back failed (buffer is full)" << endl;
return false; return false;
} }
uint8_t* const write_loc = _data + _size; uint8_t* const write_loc = _data + _size;
*((Evoral::EventTime*)write_loc) = ev.time(); *((TimeType*)write_loc) = ev.time();
memcpy(write_loc + stamp_size, ev.buffer(), ev.size()); memcpy(write_loc + stamp_size, ev.buffer(), ev.size());
_size += stamp_size + ev.size(); _size += stamp_size + ev.size();
@ -155,14 +155,14 @@ MidiBuffer::push_back(const Evoral::MIDIEvent& ev)
bool bool
MidiBuffer::push_back(const jack_midi_event_t& ev) MidiBuffer::push_back(const jack_midi_event_t& ev)
{ {
const size_t stamp_size = sizeof(Evoral::EventTime); const size_t stamp_size = sizeof(TimeType);
if (_size + stamp_size + ev.size >= _capacity) { if (_size + stamp_size + ev.size >= _capacity) {
cerr << "MidiBuffer::push_back failed (buffer is full)" << endl; cerr << "MidiBuffer::push_back failed (buffer is full)" << endl;
return false; return false;
} }
uint8_t* const write_loc = _data + _size; uint8_t* const write_loc = _data + _size;
*((Evoral::EventTime*)write_loc) = ev.time; *((TimeType*)write_loc) = ev.time;
memcpy(write_loc + stamp_size, ev.buffer, ev.size); memcpy(write_loc + stamp_size, ev.buffer, ev.size);
_size += stamp_size + ev.size; _size += stamp_size + ev.size;
@ -180,15 +180,15 @@ MidiBuffer::push_back(const jack_midi_event_t& ev)
* location, or the buffer will be corrupted and very nasty things will happen. * location, or the buffer will be corrupted and very nasty things will happen.
*/ */
uint8_t* uint8_t*
MidiBuffer::reserve(Evoral::EventTime time, size_t size) MidiBuffer::reserve(TimeType time, size_t size)
{ {
const size_t stamp_size = sizeof(Evoral::EventTime); const size_t stamp_size = sizeof(TimeType);
if (_size + stamp_size + size >= _capacity) { if (_size + stamp_size + size >= _capacity) {
return 0; return 0;
} }
uint8_t* const write_loc = _data + _size; uint8_t* const write_loc = _data + _size;
*((Evoral::EventTime*)write_loc) = time; *((TimeType*)write_loc) = time;
_size += stamp_size + size; _size += stamp_size + size;
_silent = false; _silent = false;

7
libs/ardour/midi_diskstream.cc
View file

@ -121,8 +121,9 @@ MidiDiskstream::init (Diskstream::Flag f)
set_block_size (_session.get_block_size()); set_block_size (_session.get_block_size());
allocate_temporary_buffers (); allocate_temporary_buffers ();
_playback_buf = new MidiRingBuffer (_session.midi_diskstream_buffer_size()); const size_t size = _session.midi_diskstream_buffer_size();
_capture_buf = new MidiRingBuffer (_session.midi_diskstream_buffer_size()); _playback_buf = new MidiRingBuffer<MidiBuffer::TimeType> (size);
_capture_buf = new MidiRingBuffer<MidiBuffer::TimeType> (size);
_n_channels = ChanCount(DataType::MIDI, 1); _n_channels = ChanCount(DataType::MIDI, 1);
@ -521,7 +522,7 @@ MidiDiskstream::process (nframes_t transport_frame, nframes_t nframes, nframes_t
// Pump entire port buffer into the ring buffer (FIXME: split cycles?) // Pump entire port buffer into the ring buffer (FIXME: split cycles?)
MidiBuffer& buf = _source_port->get_midi_buffer(nframes, offset); MidiBuffer& buf = _source_port->get_midi_buffer(nframes, offset);
for (MidiBuffer::iterator i = buf.begin(); i != buf.end(); ++i) { for (MidiBuffer::iterator i = buf.begin(); i != buf.end(); ++i) {
const Evoral::MIDIEvent ev(*i, false); const Evoral::MIDIEvent<MidiBuffer::TimeType> ev(*i, false);
assert(ev.buffer()); assert(ev.buffer());
_capture_buf->write(ev.time() + transport_frame, ev.type(), ev.size(), ev.buffer()); _capture_buf->write(ev.time() + transport_frame, ev.type(), ev.size(), ev.buffer());
} }

15
libs/ardour/midi_model.cc
View file

@ -38,7 +38,7 @@ using namespace ARDOUR;
using namespace PBD; using namespace PBD;
MidiModel::MidiModel(MidiSource *s, size_t size) MidiModel::MidiModel(MidiSource *s, size_t size)
: AutomatableSequence(s->session(), size) : AutomatableSequence<TimeType>(s->session(), size)
, _midi_source(s) , _midi_source(s)
{ {
cerr << "MidiModel \"" << s->name() << "\" constructed: " << this << endl; cerr << "MidiModel \"" << s->name() << "\" constructed: " << this << endl;
@ -90,7 +90,7 @@ MidiModel::DeltaCommand::DeltaCommand(boost::shared_ptr<MidiModel> m,
} }
void void
MidiModel::DeltaCommand::add(const boost::shared_ptr<Evoral::Note> note) MidiModel::DeltaCommand::add(const boost::shared_ptr< Evoral::Note<TimeType> > note)
{ {
//cerr << "MEC: apply" << endl; //cerr << "MEC: apply" << endl;
_removed_notes.remove(note); _removed_notes.remove(note);
@ -98,7 +98,7 @@ MidiModel::DeltaCommand::add(const boost::shared_ptr<Evoral::Note> note)
} }
void void
MidiModel::DeltaCommand::remove(const boost::shared_ptr<Evoral::Note> note) MidiModel::DeltaCommand::remove(const boost::shared_ptr< Evoral::Note<TimeType> > note)
{ {
//cerr << "MEC: remove" << endl; //cerr << "MEC: remove" << endl;
_added_notes.remove(note); _added_notes.remove(note);
@ -156,7 +156,7 @@ MidiModel::DeltaCommand::undo()
} }
XMLNode& XMLNode&
MidiModel::DeltaCommand::marshal_note(const boost::shared_ptr<Evoral::Note> note) MidiModel::DeltaCommand::marshal_note(const boost::shared_ptr< Evoral::Note<TimeType> > note)
{ {
XMLNode *xml_note = new XMLNode("note"); XMLNode *xml_note = new XMLNode("note");
ostringstream note_str(ios::ate); ostringstream note_str(ios::ate);
@ -182,7 +182,7 @@ MidiModel::DeltaCommand::marshal_note(const boost::shared_ptr<Evoral::Note> note
return *xml_note; return *xml_note;
} }
boost::shared_ptr<Evoral::Note> boost::shared_ptr< Evoral::Note<double> >
MidiModel::DeltaCommand::unmarshal_note(XMLNode *xml_note) MidiModel::DeltaCommand::unmarshal_note(XMLNode *xml_note)
{ {
unsigned int note; unsigned int note;
@ -232,7 +232,8 @@ MidiModel::DeltaCommand::unmarshal_note(XMLNode *xml_note)
velocity = 127; velocity = 127;
} }
boost::shared_ptr<Evoral::Note> note_ptr(new Evoral::Note(channel, time, length, note, velocity)); boost::shared_ptr< Evoral::Note<TimeType> > note_ptr(new Evoral::Note<TimeType>(
channel, time, length, note, velocity));
return note_ptr; return note_ptr;
} }
@ -296,7 +297,7 @@ MidiModel::write_to(boost::shared_ptr<MidiSource> source)
const bool old_percussive = percussive(); const bool old_percussive = percussive();
set_percussive(false); set_percussive(false);
for (Evoral::Sequence::const_iterator i = begin(); i != end(); ++i) { for (Evoral::Sequence<TimeType>::const_iterator i = begin(); i != end(); ++i) {
source->append_event_unlocked(Frames, *i); source->append_event_unlocked(Frames, *i);
} }

2
libs/ardour/midi_playlist.cc
View file

@ -124,7 +124,7 @@ struct RegionSortByLayer {
/** Returns the number of frames in time duration read (eg could be large when 0 events are read) */ /** Returns the number of frames in time duration read (eg could be large when 0 events are read) */
nframes_t nframes_t
MidiPlaylist::read (MidiRingBuffer& dst, nframes_t start, MidiPlaylist::read (MidiRingBuffer<MidiBuffer::TimeType>& dst, nframes_t start,
nframes_t dur, unsigned chan_n) nframes_t dur, unsigned chan_n)
{ {
/* this function is never called from a realtime thread, so /* this function is never called from a realtime thread, so

2
libs/ardour/midi_port.cc
View file

@ -147,7 +147,7 @@ MidiPort::flush_buffers (nframes_t nframes, nframes_t offset)
void* jack_buffer = jack_port_get_buffer (_jack_port, nframes); void* jack_buffer = jack_port_get_buffer (_jack_port, nframes);
for (MidiBuffer::iterator i = _buffer->begin(); i != _buffer->end(); ++i) { for (MidiBuffer::iterator i = _buffer->begin(); i != _buffer->end(); ++i) {
const Evoral::Event& ev = *i; const Evoral::Event<double>& ev = *i;
// event times should be frames, relative to cycle start // event times should be frames, relative to cycle start
assert(ev.time() >= 0); assert(ev.time() >= 0);
assert(ev.time() < (nframes+offset)); assert(ev.time() < (nframes+offset));

6
libs/ardour/midi_region.cc
View file

@ -117,19 +117,19 @@ MidiRegion::~MidiRegion ()
} }
nframes_t nframes_t
MidiRegion::read_at (MidiRingBuffer& out, nframes_t position, nframes_t dur, uint32_t chan_n, NoteMode mode) const MidiRegion::read_at (MidiRingBuffer<TimeType>& out, nframes_t position, nframes_t dur, uint32_t chan_n, NoteMode mode) const
{ {
return _read_at (_sources, out, position, dur, chan_n, mode); return _read_at (_sources, out, position, dur, chan_n, mode);
} }
nframes_t nframes_t
MidiRegion::master_read_at (MidiRingBuffer& out, nframes_t position, nframes_t dur, uint32_t chan_n, NoteMode mode) const MidiRegion::master_read_at (MidiRingBuffer<TimeType>& out, nframes_t position, nframes_t dur, uint32_t chan_n, NoteMode mode) const
{ {
return _read_at (_master_sources, out, position, dur, chan_n, mode); return _read_at (_master_sources, out, position, dur, chan_n, mode);
} }
nframes_t nframes_t
MidiRegion::_read_at (const SourceList& srcs, MidiRingBuffer& dst, nframes_t position, nframes_t dur, uint32_t chan_n, NoteMode mode) const MidiRegion::_read_at (const SourceList& srcs, MidiRingBuffer<TimeType>& dst, nframes_t position, nframes_t dur, uint32_t chan_n, NoteMode mode) const
{ {
/*cerr << "MidiRegion " << _name << "._read_at(" << position << ") - " /*cerr << "MidiRegion " << _name << "._read_at(" << position << ") - "
<< position << " duration: " << dur << endl;*/ << position << " duration: " << dur << endl;*/

20
libs/ardour/midi_ring_buffer.cc
View file

@ -29,14 +29,15 @@ namespace ARDOUR {
* Timestamps of events returned are relative to start (i.e. event with stamp 0 * Timestamps of events returned are relative to start (i.e. event with stamp 0
* occurred at start), with offset added. * occurred at start), with offset added.
*/ */
template<typename T>
size_t size_t
MidiRingBuffer::read(MidiBuffer& dst, nframes_t start, nframes_t end, nframes_t offset) MidiRingBuffer<T>::read(MidiBuffer& dst, nframes_t start, nframes_t end, nframes_t offset)
{ {
if (read_space() == 0) { if (this->read_space() == 0) {
return 0; return 0;
} }
Evoral::EventTime ev_time; T ev_time;
Evoral::EventType ev_type; Evoral::EventType ev_type;
uint32_t ev_size; uint32_t ev_size;
@ -44,9 +45,9 @@ MidiRingBuffer::read(MidiBuffer& dst, nframes_t start, nframes_t end, nframes_t
//cerr << "MRB read " << start << " .. " << end << " + " << offset << endl; //cerr << "MRB read " << start << " .. " << end << " + " << offset << endl;
while (read_space() >= sizeof(Evoral::EventTime) + sizeof(Evoral::EventType) + sizeof(uint32_t)) { while (this->read_space() >= sizeof(T) + sizeof(Evoral::EventType) + sizeof(uint32_t)) {
full_peek(sizeof(Evoral::EventTime), (uint8_t*)&ev_time); this->full_peek(sizeof(T), (uint8_t*)&ev_time);
if (ev_time > end) { if (ev_time > end) {
//cerr << "MRB: PAST END (" << ev_time << " : " << end << ")" << endl; //cerr << "MRB: PAST END (" << ev_time << " : " << end << ")" << endl;
@ -67,7 +68,7 @@ MidiRingBuffer::read(MidiBuffer& dst, nframes_t start, nframes_t end, nframes_t
if (ev_type == LoopEventType) { if (ev_type == LoopEventType) {
ev_time -= start; ev_time -= start;
ev_time += offset; ev_time += offset;
Evoral::MIDIEvent loopevent(LoopEventType, ev_time); Evoral::MIDIEvent<T> loopevent(LoopEventType, ev_time);
dst.push_back(loopevent); dst.push_back(loopevent);
// We can safely return, without reading the data, because // We can safely return, without reading the data, because
@ -76,7 +77,7 @@ MidiRingBuffer::read(MidiBuffer& dst, nframes_t start, nframes_t end, nframes_t
} }
uint8_t status; uint8_t status;
success = full_peek(sizeof(uint8_t), &status); success = this->full_peek(sizeof(uint8_t), &status);
assert(success); // If this failed, buffer is corrupt, all hope is lost assert(success); // If this failed, buffer is corrupt, all hope is lost
// Ignore event if it doesn't match channel filter // Ignore event if it doesn't match channel filter
@ -84,7 +85,7 @@ MidiRingBuffer::read(MidiBuffer& dst, nframes_t start, nframes_t end, nframes_t
const uint8_t channel = status & 0x0F; const uint8_t channel = status & 0x0F;
if ( !(get_channel_mask() & (1L << channel)) ) { if ( !(get_channel_mask() & (1L << channel)) ) {
//cerr << "MRB skipping event due to channel mask" << endl; //cerr << "MRB skipping event due to channel mask" << endl;
skip(ev_size); // Advance read pointer to next event this->skip(ev_size); // Advance read pointer to next event
continue; continue;
} }
} }
@ -103,7 +104,7 @@ MidiRingBuffer::read(MidiBuffer& dst, nframes_t start, nframes_t end, nframes_t
continue; continue;
} }
success = Evoral::EventRingBuffer::full_read(ev_size, write_loc); success = Evoral::EventRingBuffer<T>::full_read(ev_size, write_loc);
if (success) { if (success) {
if (is_channel_event(status) && get_channel_mode() == ForceChannel) { if (is_channel_event(status) && get_channel_mode() == ForceChannel) {
@ -121,6 +122,7 @@ MidiRingBuffer::read(MidiBuffer& dst, nframes_t start, nframes_t end, nframes_t
return count; return count;
} }
template class MidiRingBuffer<double>;
} // namespace ARDOUR } // namespace ARDOUR

4
libs/ardour/midi_source.cc
View file

@ -101,7 +101,7 @@ MidiSource::set_state (const XMLNode& node)
} }
nframes_t nframes_t
MidiSource::midi_read (MidiRingBuffer& dst, nframes_t start, nframes_t cnt, nframes_t stamp_offset, nframes_t negative_stamp_offset) const MidiSource::midi_read (MidiRingBuffer<MidiBuffer::TimeType>& dst, nframes_t start, nframes_t cnt, nframes_t stamp_offset, nframes_t negative_stamp_offset) const
{ {
Glib::Mutex::Lock lm (_lock); Glib::Mutex::Lock lm (_lock);
if (_model) { if (_model) {
@ -115,7 +115,7 @@ MidiSource::midi_read (MidiRingBuffer& dst, nframes_t start, nframes_t cnt, nfra
} }
nframes_t nframes_t
MidiSource::midi_write (MidiRingBuffer& dst, nframes_t cnt) MidiSource::midi_write (MidiRingBuffer<MidiBuffer::TimeType>& dst, nframes_t cnt)
{ {
Glib::Mutex::Lock lm (_lock); Glib::Mutex::Lock lm (_lock);
return write_unlocked (dst, cnt); return write_unlocked (dst, cnt);

7
libs/ardour/midi_state_tracker.cc
View file

@ -31,7 +31,7 @@ MidiStateTracker::MidiStateTracker ()
} }
void void
MidiStateTracker::track_note_onoffs (const Evoral::MIDIEvent &event) MidiStateTracker::track_note_onoffs (const Evoral::MIDIEvent<MidiBuffer::TimeType>& event)
{ {
if (event.is_note_on()) { if (event.is_note_on()) {
_active_notes [event.note() + 128 * event.channel()] = true; _active_notes [event.note() + 128 * event.channel()] = true;
@ -46,7 +46,7 @@ MidiStateTracker::track (const MidiBuffer::iterator &from, const MidiBuffer::ite
bool ret = false; bool ret = false;
for (MidiBuffer::iterator i = from; i != to; ++i) { for (MidiBuffer::iterator i = from; i != to; ++i) {
const Evoral::MIDIEvent ev(*i, false); const Evoral::MIDIEvent<MidiBuffer::TimeType> ev(*i, false);
if (ev.event_type() == LoopEventType) { if (ev.event_type() == LoopEventType) {
ret = true; ret = true;
continue; continue;
@ -68,7 +68,8 @@ MidiStateTracker::resolve_notes (MidiBuffer &dst, nframes_t time)
for (int note = 0; note < 128; ++note) { for (int note = 0; note < 128; ++note) {
if (_active_notes[channel * 128 + note]) { if (_active_notes[channel * 128 + note]) {
uint8_t buffer[3] = { MIDI_CMD_NOTE_OFF | channel, note, 0 }; uint8_t buffer[3] = { MIDI_CMD_NOTE_OFF | channel, note, 0 };
Evoral::MIDIEvent noteoff (time, MIDI_CMD_NOTE_OFF, 3, buffer, false); Evoral::MIDIEvent<MidiBuffer::TimeType> noteoff
(time, MIDI_CMD_NOTE_OFF, 3, buffer, false);
dst.push_back (noteoff); dst.push_back (noteoff);

5
libs/ardour/midi_stretch.cc
View file

@ -87,11 +87,12 @@ MidiStretch::run (boost::shared_ptr<Region> r)
boost::shared_ptr<MidiModel> new_model = new_src->model(); boost::shared_ptr<MidiModel> new_model = new_src->model();
new_model->start_write(); new_model->start_write();
for (Evoral::Sequence::const_iterator i = old_model->begin(); i != old_model->end(); ++i) { for (Evoral::Sequence<MidiModel::TimeType>::const_iterator i = old_model->begin();
i != old_model->end(); ++i) {
const double new_time = i->time() * _request.time_fraction; const double new_time = i->time() * _request.time_fraction;
// FIXME: double copy // FIXME: double copy
Evoral::Event ev = Evoral::Event(*i, true); Evoral::Event<MidiModel::TimeType> ev(*i, true);
ev.time() = new_time; ev.time() = new_time;
new_model->append(ev); new_model->append(ev);
} }

4
libs/ardour/playlist.cc
View file

@ -363,7 +363,7 @@ Playlist::notify_region_removed (boost::shared_ptr<Region> r)
void void
Playlist::notify_region_moved (boost::shared_ptr<Region> r) Playlist::notify_region_moved (boost::shared_ptr<Region> r)
{ {
Evoral::RangeMove const move (r->last_position (), r->length (), r->position ()); Evoral::RangeMove<nframes_t> const move (r->last_position (), r->length (), r->position ());
if (holding_state ()) { if (holding_state ()) {
@ -371,7 +371,7 @@ Playlist::notify_region_moved (boost::shared_ptr<Region> r)
} else { } else {
Evoral::RangeMoveList m; list< Evoral::RangeMove<nframes_t> > m;
m.push_back (move); m.push_back (move);
RangesMoved (m); RangesMoved (m);

2
libs/ardour/quantize.cc
View file

@ -69,7 +69,7 @@ Quantize::run (boost::shared_ptr<Region> r)
double q_frames = _q * (m.frames_per_bar(t, session.frame_rate()) / (double)m.beats_per_bar()); double q_frames = _q * (m.frames_per_bar(t, session.frame_rate()) / (double)m.beats_per_bar());
for (Evoral::Sequence::Notes::iterator i = model->notes().begin(); for (Evoral::Sequence<MidiModel::TimeType>::Notes::iterator i = model->notes().begin();
i != model->notes().end(); ++i) { i != model->notes().end(); ++i) {
const double new_time = lrint((*i)->time() / q_frames) * q_frames; const double new_time = lrint((*i)->time() / q_frames) * q_frames;
double new_dur = lrint((*i)->length() / q_frames) * q_frames; double new_dur = lrint((*i)->length() / q_frames) * q_frames;

32
libs/ardour/smf_source.cc
View file

@ -55,7 +55,7 @@ uint64_t SMFSource::header_position_offset;
SMFSource::SMFSource (Session& s, std::string path, Flag flags) SMFSource::SMFSource (Session& s, std::string path, Flag flags)
: MidiSource (s, region_name_from_path(path, false)) : MidiSource (s, region_name_from_path(path, false))
, SMF () , Evoral::SMF<double> ()
, _flags (Flag(flags | Writable)) // FIXME: this needs to be writable for now , _flags (Flag(flags | Writable)) // FIXME: this needs to be writable for now
, _allow_remove_if_empty(true) , _allow_remove_if_empty(true)
{ {
@ -128,7 +128,7 @@ SMFSource::init (string pathstr, bool must_exist)
/** All stamps in audio frames */ /** All stamps in audio frames */
nframes_t nframes_t
SMFSource::read_unlocked (MidiRingBuffer& dst, nframes_t start, nframes_t cnt, nframes_t stamp_offset, nframes_t negative_stamp_offset) const SMFSource::read_unlocked (MidiRingBuffer<double>& dst, nframes_t start, nframes_t cnt, nframes_t stamp_offset, nframes_t negative_stamp_offset) const
{ {
//cerr << "SMF read_unlocked " << name() << " read " << start << ", count=" << cnt << ", offset=" << stamp_offset << endl; //cerr << "SMF read_unlocked " << name() << " read " << start << ", count=" << cnt << ", offset=" << stamp_offset << endl;
@ -146,7 +146,7 @@ SMFSource::read_unlocked (MidiRingBuffer& dst, nframes_t start, nframes_t cnt, n
size_t scratch_size = 0; // keep track of scratch to minimize reallocs size_t scratch_size = 0; // keep track of scratch to minimize reallocs
// FIXME: don't seek to start and search every read (brutal!) // FIXME: don't seek to start and search every read (brutal!)
SMF::seek_to_start(); Evoral::SMF<double>::seek_to_start();
// FIXME: assumes tempo never changes after start // FIXME: assumes tempo never changes after start
const double frames_per_beat = _session.tempo_map().tempo_at(_timeline_position).frames_per_beat( const double frames_per_beat = _session.tempo_map().tempo_at(_timeline_position).frames_per_beat(
@ -155,7 +155,7 @@ SMFSource::read_unlocked (MidiRingBuffer& dst, nframes_t start, nframes_t cnt, n
const uint64_t start_ticks = (uint64_t)((start / frames_per_beat) * ppqn()); const uint64_t start_ticks = (uint64_t)((start / frames_per_beat) * ppqn());
while (!SMF::eof()) { while (!Evoral::SMF<double>::eof()) {
int ret = read_event(&ev_delta_t, &ev_size, &ev_buffer); int ret = read_event(&ev_delta_t, &ev_size, &ev_buffer);
if (ret == -1) { // EOF if (ret == -1) { // EOF
//cerr << "SMF - EOF\n"; //cerr << "SMF - EOF\n";
@ -194,11 +194,11 @@ SMFSource::read_unlocked (MidiRingBuffer& dst, nframes_t start, nframes_t cnt, n
/** All stamps in audio frames */ /** All stamps in audio frames */
nframes_t nframes_t
SMFSource::write_unlocked (MidiRingBuffer& src, nframes_t cnt) SMFSource::write_unlocked (MidiRingBuffer<double>& src, nframes_t cnt)
{ {
_write_data_count = 0; _write_data_count = 0;
Evoral::EventTime time; double time;
Evoral::EventType type; Evoral::EventType type;
uint32_t size; uint32_t size;
@ -208,7 +208,7 @@ SMFSource::write_unlocked (MidiRingBuffer& src, nframes_t cnt)
if (_model && ! _model->writing()) if (_model && ! _model->writing())
_model->start_write(); _model->start_write();
Evoral::MIDIEvent ev(0, 0.0, 4, NULL, true); Evoral::MIDIEvent<double> ev(0, 0.0, 4, NULL, true);
while (true) { while (true) {
bool ret = src.peek_time(&time); bool ret = src.peek_time(&time);
@ -251,7 +251,7 @@ SMFSource::write_unlocked (MidiRingBuffer& src, nframes_t cnt)
make_sure_controls_have_the_right_interpolation(); make_sure_controls_have_the_right_interpolation();
} }
SMF::flush(); Evoral::SMF<double>::flush();
free(buf); free(buf);
const nframes_t oldlen = _length; const nframes_t oldlen = _length;
@ -264,7 +264,7 @@ SMFSource::write_unlocked (MidiRingBuffer& src, nframes_t cnt)
void void
SMFSource::append_event_unlocked(EventTimeUnit unit, const Evoral::Event& ev) SMFSource::append_event_unlocked(EventTimeUnit unit, const Evoral::Event<double>& ev)
{ {
if (ev.size() == 0) { if (ev.size() == 0) {
cerr << "SMFSource: Warning: skipping empty event" << endl; cerr << "SMFSource: Warning: skipping empty event" << endl;
@ -299,7 +299,7 @@ SMFSource::append_event_unlocked(EventTimeUnit unit, const Evoral::Event& ev)
delta_time = (uint32_t)((ev.time() - last_event_time()) * ppqn()); delta_time = (uint32_t)((ev.time() - last_event_time()) * ppqn());
} }
SMF::append_event_unlocked(delta_time, ev); Evoral::SMF<double>::append_event_unlocked(delta_time, ev);
_write_data_count += ev.size(); _write_data_count += ev.size();
} }
@ -354,7 +354,7 @@ void
SMFSource::mark_streaming_midi_write_started (NoteMode mode, nframes_t start_frame) SMFSource::mark_streaming_midi_write_started (NoteMode mode, nframes_t start_frame)
{ {
MidiSource::mark_streaming_midi_write_started (mode, start_frame); MidiSource::mark_streaming_midi_write_started (mode, start_frame);
SMF::begin_write (start_frame); Evoral::SMF<double>::begin_write (start_frame);
} }
void void
@ -367,7 +367,7 @@ SMFSource::mark_streaming_write_completed ()
} }
_model->set_edited(false); _model->set_edited(false);
SMF::end_write (); Evoral::SMF<double>::end_write ();
} }
void void
@ -632,10 +632,10 @@ SMFSource::load_model(bool lock, bool force_reload)
} }
_model->start_write(); _model->start_write();
SMF::seek_to_start(); Evoral::SMF<double>::seek_to_start();
uint64_t time = 0; /* in SMF ticks */ uint64_t time = 0; /* in SMF ticks */
Evoral::Event ev; Evoral::Event<double> ev;
size_t scratch_size = 0; // keep track of scratch and minimize reallocs size_t scratch_size = 0; // keep track of scratch and minimize reallocs
@ -655,7 +655,7 @@ SMFSource::load_model(bool lock, bool force_reload)
if (ret > 0) { // didn't skip (meta) event if (ret > 0) { // didn't skip (meta) event
// make ev.time absolute time in frames // make ev.time absolute time in frames
ev.time() = time * frames_per_beat / (Evoral::EventTime)ppqn(); ev.time() = time * frames_per_beat / (double)ppqn();
ev.set_event_type(EventTypeMap::instance().midi_event_type(buf[0])); ev.set_event_type(EventTypeMap::instance().midi_event_type(buf[0]));
_model->append(ev); _model->append(ev);
} }
@ -704,6 +704,6 @@ SMFSource::destroy_model()
void void
SMFSource::flush_midi() SMFSource::flush_midi()
{ {
SMF::end_write(); Evoral::SMF<double>::end_write();
} }

2
libs/evoral/evoral/ControlList.hpp
View file

@ -120,7 +120,7 @@ public:
void erase_range (double start, double end); void erase_range (double start, double end);
void erase (iterator); void erase (iterator);
void erase (iterator, iterator); void erase (iterator, iterator);
void move_ranges (RangeMoveList const &); void move_ranges (std::list< RangeMove<double> > const &);
void modify (iterator, double, double); void modify (iterator, double, double);
boost::shared_ptr<ControlList> cut (double, double); boost::shared_ptr<ControlList> cut (double, double);

88
libs/evoral/evoral/Event.hpp
View file

@ -38,12 +38,12 @@ namespace Evoral {
/** An event (much like a type generic jack_midi_event_t) /** An event (much like a type generic jack_midi_event_t)
* *
* time is either a frame time (from/to Jack) or a beat time (internal * Template parameter T is the type of the time stamp used for this event.
* tempo time, used in MidiModel) depending on context.
*/ */
template<typename T>
struct Event { struct Event {
#ifdef EVORAL_EVENT_ALLOC #ifdef EVORAL_EVENT_ALLOC
Event(EventType type=0, EventTime t=0, uint32_t s=0, uint8_t* b=NULL, bool alloc=false); Event(EventType type=0, T t=0, uint32_t s=0, uint8_t* b=NULL, bool alloc=false);
/** Copy \a copy. /** Copy \a copy.
* *
@ -58,18 +58,18 @@ struct Event {
inline const Event& operator=(const Event& copy) { inline const Event& operator=(const Event& copy) {
_type = copy._type; _type = copy._type;
_time = copy._time; _time = copy._time;
if (_owns_buffer) { if (_owns_buf) {
if (copy._buffer) { if (copy._buf) {
if (copy._size > _size) { if (copy._size > _size) {
_buffer = (uint8_t*)::realloc(_buffer, copy._size); _buf = (uint8_t*)::realloc(_buf, copy._size);
} }
memcpy(_buffer, copy._buffer, copy._size); memcpy(_buf, copy._buf, copy._size);
} else { } else {
free(_buffer); free(_buf);
_buffer = NULL; _buf = NULL;
} }
} else { } else {
_buffer = copy._buffer; _buf = copy._buf;
} }
_size = copy._size; _size = copy._size;
@ -77,26 +77,26 @@ struct Event {
} }
inline void shallow_copy(const Event& copy) { inline void shallow_copy(const Event& copy) {
if (_owns_buffer) { if (_owns_buf) {
free(_buffer); free(_buf);
_buffer = false; _buf = false;
_owns_buffer = false; _owns_buf = false;
} }
_type = copy._type; _type = copy._type;
_time = copy._time; _time = copy._time;
_size = copy._size; _size = copy._size;
_buffer = copy._buffer; _buf = copy._buf;
} }
inline void set(uint8_t* buf, uint32_t size, EventTime t) { inline void set(uint8_t* buf, uint32_t size, T t) {
if (_owns_buffer) { if (_owns_buf) {
if (_size < size) { if (_size < size) {
_buffer = (uint8_t*) ::realloc(_buffer, size); _buf = (uint8_t*) ::realloc(_buf, size);
} }
memcpy (_buffer, buf, size); memcpy (_buf, buf, size);
} else { } else {
_buffer = buf; _buf = buf;
} }
_time = t; _time = t;
@ -113,11 +113,11 @@ struct Event {
if (_size != other._size) if (_size != other._size)
return false; return false;
if (_buffer == other._buffer) if (_buf == other._buf)
return true; return true;
for (uint32_t i=0; i < _size; ++i) for (uint32_t i=0; i < _size; ++i)
if (_buffer[i] != other._buffer[i]) if (_buf[i] != other._buf[i])
return false; return false;
return true; return true;
@ -125,25 +125,25 @@ struct Event {
inline bool operator!=(const Event& other) const { return ! operator==(other); } inline bool operator!=(const Event& other) const { return ! operator==(other); }
inline bool owns_buffer() const { return _owns_buffer; } inline bool owns_buffer() const { return _owns_buf; }
inline void set_buffer(uint32_t size, uint8_t* buf, bool own) { inline void set_buffer(uint32_t size, uint8_t* buf, bool own) {
if (_owns_buffer) { if (_owns_buf) {
free(_buffer); free(_buf);
_buffer = NULL; _buf = NULL;
} }
_size = size; _size = size;
_buffer = buf; _buf = buf;
_owns_buffer = own; _owns_buf = own;
} }
inline void realloc(uint32_t size) { inline void realloc(uint32_t size) {
if (_owns_buffer) { if (_owns_buf) {
if (size > _size) if (size > _size)
_buffer = (uint8_t*) ::realloc(_buffer, size); _buf = (uint8_t*) ::realloc(_buf, size);
} else { } else {
_buffer = (uint8_t*) ::malloc(size); _buf = (uint8_t*) ::malloc(size);
_owns_buffer = true; _owns_buf = true;
} }
_size = size; _size = size;
@ -153,33 +153,33 @@ struct Event {
_type = 0; _type = 0;
_time = 0; _time = 0;
_size = 0; _size = 0;
_buffer = NULL; _buf = NULL;
} }
#else #else
inline void set_buffer(uint8_t* buf) { _buffer = buf; } inline void set_buffer(uint8_t* buf) { _buf = buf; }
#endif // EVORAL_EVENT_ALLOC #endif // EVORAL_EVENT_ALLOC
inline EventType event_type() const { return _type; } inline EventType event_type() const { return _type; }
inline void set_event_type(EventType t) { _type = t; } inline void set_event_type(EventType t) { _type = t; }
inline EventTime time() const { return _time; } inline T time() const { return _time; }
inline EventTime& time() { return _time; } inline T& time() { return _time; }
inline uint32_t size() const { return _size; } inline uint32_t size() const { return _size; }
inline uint32_t& size() { return _size; } inline uint32_t& size() { return _size; }
inline const uint8_t* buffer() const { return _buffer; } inline const uint8_t* buffer() const { return _buf; }
inline uint8_t*& buffer() { return _buffer; } inline uint8_t*& buffer() { return _buf; }
protected: protected:
EventType _type; /**< Type of event (application relative, NOT MIDI 'type') */ EventType _type; /**< Type of event (application relative, NOT MIDI 'type') */
EventTime _time; /**< Sample index (or beat time) at which event is valid */ T _time; /**< Sample index (or beat time) at which event is valid */
uint32_t _size; /**< Number of uint8_ts of data in \a buffer */ uint32_t _size; /**< Number of uint8_ts of data in \a buffer */
uint8_t* _buffer; /**< Raw MIDI data */ uint8_t* _buf; /**< Raw MIDI data */
#ifdef EVORAL_EVENT_ALLOC #ifdef EVORAL_EVENT_ALLOC
bool _owns_buffer; /**< Whether buffer is locally allocated */ bool _owns_buf; /**< Whether buffer is locally allocated */
#endif #endif
}; };

26
libs/evoral/evoral/EventRingBuffer.hpp
View file

@ -34,7 +34,8 @@ namespace Evoral {
* This packs a timestamp, size, and size bytes of data flat into the buffer. * This packs a timestamp, size, and size bytes of data flat into the buffer.
* Useful for MIDI events, OSC messages, etc. * Useful for MIDI events, OSC messages, etc.
*/ */
class EventRingBuffer : public Evoral::RingBuffer<uint8_t>, public Evoral::EventSink { template<typename T>
class EventRingBuffer : public Evoral::RingBuffer<uint8_t>, public Evoral::EventSink<T> {
public: public:
/** @param capacity Ringbuffer capacity in bytes. /** @param capacity Ringbuffer capacity in bytes.
@ -44,25 +45,27 @@ public:
size_t capacity() const { return _size; } size_t capacity() const { return _size; }
bool peek_time(EventTime* time); bool peek_time(T* time);
uint32_t write(EventTime time, EventType type, uint32_t size, const uint8_t* buf); uint32_t write(T time, EventType type, uint32_t size, const uint8_t* buf);
bool read (EventTime* time, EventType* type, uint32_t* size, uint8_t* buf); bool read (T* time, EventType* type, uint32_t* size, uint8_t* buf);
}; };
template<typename T>
inline bool inline bool
EventRingBuffer::peek_time(EventTime* time) EventRingBuffer<T>::peek_time(T* time)
{ {
bool success = RingBuffer<uint8_t>::full_peek(sizeof(EventTime), (uint8_t*)time); bool success = RingBuffer<uint8_t>::full_peek(sizeof(T), (uint8_t*)time);
return success; return success;
} }
template<typename T>
inline bool inline bool
EventRingBuffer::read(EventTime* time, EventType* type, uint32_t* size, uint8_t* buf) EventRingBuffer<T>::read(T* time, EventType* type, uint32_t* size, uint8_t* buf)
{ {
bool success = RingBuffer<uint8_t>::full_read(sizeof(EventTime), (uint8_t*)time); bool success = RingBuffer<uint8_t>::full_read(sizeof(T), (uint8_t*)time);
if (success) if (success)
success = RingBuffer<uint8_t>::full_read(sizeof(EventType), (uint8_t*)type); success = RingBuffer<uint8_t>::full_read(sizeof(EventType), (uint8_t*)type);
if (success) if (success)
@ -74,13 +77,14 @@ EventRingBuffer::read(EventTime* time, EventType* type, uint32_t* size, uint8_t*
} }
template<typename T>
inline uint32_t inline uint32_t
EventRingBuffer::write(EventTime time, EventType type, uint32_t size, const uint8_t* buf) EventRingBuffer<T>::write(T time, EventType type, uint32_t size, const uint8_t* buf)
{ {
if (write_space() < (sizeof(EventTime) + sizeof(EventType) + sizeof(uint32_t) + size)) { if (write_space() < (sizeof(T) + sizeof(EventType) + sizeof(uint32_t) + size)) {
return 0; return 0;
} else { } else {
RingBuffer<uint8_t>::write(sizeof(EventTime), (uint8_t*)&time); RingBuffer<uint8_t>::write(sizeof(T), (uint8_t*)&time);
RingBuffer<uint8_t>::write(sizeof(EventType), (uint8_t*)&type); RingBuffer<uint8_t>::write(sizeof(EventType), (uint8_t*)&type);
RingBuffer<uint8_t>::write(sizeof(uint32_t), (uint8_t*)&size); RingBuffer<uint8_t>::write(sizeof(uint32_t), (uint8_t*)&size);
RingBuffer<uint8_t>::write(size, buf); RingBuffer<uint8_t>::write(size, buf);

3
libs/evoral/evoral/EventSink.hpp
View file

@ -26,10 +26,11 @@ namespace Evoral {
/** Pure virtual base for anything you can write events to. /** Pure virtual base for anything you can write events to.
*/ */
template<typename T>
class EventSink { class EventSink {
public: public:
virtual ~EventSink() {} virtual ~EventSink() {}
virtual uint32_t write(EventTime time, EventType type, uint32_t size, const uint8_t* buf) = 0; virtual uint32_t write(T time, EventType type, uint32_t size, const uint8_t* buf) = 0;
}; };

60
libs/evoral/evoral/MIDIEvent.hpp
View file

@ -19,10 +19,11 @@
#ifndef EVORAL_MIDI_EVENT_HPP #ifndef EVORAL_MIDI_EVENT_HPP
#define EVORAL_MIDI_EVENT_HPP #define EVORAL_MIDI_EVENT_HPP
#include <boost/shared_ptr.hpp>
#include "evoral/Event.hpp" #include "evoral/Event.hpp"
#include "evoral/midi_events.h" #include "evoral/midi_events.h"
#ifdef EVORAL_MIDI_XML #ifdef EVORAL_MIDI_XML
#include <pbd/xml++.h> class XMLNode;
#endif #endif
namespace Evoral { namespace Evoral {
@ -33,13 +34,14 @@ namespace Evoral {
* but the application must make sure the event actually contains * but the application must make sure the event actually contains
* valid MIDI data for these functions to make sense. * valid MIDI data for these functions to make sense.
*/ */
struct MIDIEvent : public Event { template<typename T>
MIDIEvent(EventType type=0, EventTime t=0, uint32_t s=0, uint8_t* b=NULL, bool alloc=false) struct MIDIEvent : public Event<T> {
: Event(type, t, s, b, alloc) MIDIEvent(EventType type=0, T t=0, uint32_t s=0, uint8_t* b=NULL, bool alloc=false)
: Event<T>(type, t, s, b, alloc)
{} {}
MIDIEvent(const Event& copy, bool alloc) MIDIEvent(const Event<T>& copy, bool alloc)
: Event(copy, alloc) : Event<T>(copy, alloc)
{} {}
#ifdef EVORAL_MIDI_XML #ifdef EVORAL_MIDI_XML
@ -52,12 +54,12 @@ struct MIDIEvent : public Event {
boost::shared_ptr<XMLNode> to_xml() const; boost::shared_ptr<XMLNode> to_xml() const;
#endif #endif
inline uint8_t type() const { return (_buffer[0] & 0xF0); } inline uint8_t type() const { return (this->_buf[0] & 0xF0); }
inline void set_type(uint8_t type) { _buffer[0] = (0x0F & _buffer[0]) inline void set_type(uint8_t type) { this->_buf[0] = (0x0F & this->_buf[0])
| (0xF0 & type); } | (0xF0 & type); }
inline uint8_t channel() const { return (_buffer[0] & 0x0F); } inline uint8_t channel() const { return (this->_buf[0] & 0x0F); }
inline void set_channel(uint8_t channel) { _buffer[0] = (0xF0 & _buffer[0]) inline void set_channel(uint8_t channel) { this->_buf[0] = (0xF0 & this->_buf[0])
| (0x0F & channel); } | (0x0F & channel); }
inline bool is_note_on() const { return (type() == MIDI_CMD_NOTE_ON); } inline bool is_note_on() const { return (type() == MIDI_CMD_NOTE_ON); }
inline bool is_note_off() const { return (type() == MIDI_CMD_NOTE_OFF); } inline bool is_note_off() const { return (type() == MIDI_CMD_NOTE_OFF); }
inline bool is_cc() const { return (type() == MIDI_CMD_CONTROL); } inline bool is_cc() const { return (type() == MIDI_CMD_CONTROL); }
@ -66,24 +68,24 @@ struct MIDIEvent : public Event {
inline bool is_note() const { return (is_note_on() || is_note_off()); } inline bool is_note() const { return (is_note_on() || is_note_off()); }
inline bool is_aftertouch() const { return (type() == MIDI_CMD_NOTE_PRESSURE); } inline bool is_aftertouch() const { return (type() == MIDI_CMD_NOTE_PRESSURE); }
inline bool is_channel_pressure() const { return (type() == MIDI_CMD_CHANNEL_PRESSURE); } inline bool is_channel_pressure() const { return (type() == MIDI_CMD_CHANNEL_PRESSURE); }
inline uint8_t note() const { return (_buffer[1]); } inline uint8_t note() const { return (this->_buf[1]); }
inline uint8_t velocity() const { return (_buffer[2]); } inline uint8_t velocity() const { return (this->_buf[2]); }
inline uint8_t cc_number() const { return (_buffer[1]); } inline uint8_t cc_number() const { return (this->_buf[1]); }
inline void set_cc_number(uint8_t number) { _buffer[1] = number; } inline void set_cc_number(uint8_t number) { this->_buf[1] = number; }
inline uint8_t cc_value() const { return (_buffer[2]); } inline uint8_t cc_value() const { return (this->_buf[2]); }
inline void set_cc_value(uint8_t value) { _buffer[2] = value; } inline void set_cc_value(uint8_t value) { this->_buf[2] = value; }
inline uint8_t pitch_bender_lsb() const { return (_buffer[1]); } inline uint8_t pitch_bender_lsb() const { return (this->_buf[1]); }
inline uint8_t pitch_bender_msb() const { return (_buffer[2]); } inline uint8_t pitch_bender_msb() const { return (this->_buf[2]); }
inline uint16_t pitch_bender_value() const { return ( ((0x7F & _buffer[2]) << 7) inline uint16_t pitch_bender_value() const { return ( ((0x7F & this->_buf[2]) << 7)
| (0x7F & _buffer[1]) ); } | (0x7F & this->_buf[1]) ); }
inline uint8_t pgm_number() const { return (_buffer[1]); } inline uint8_t pgm_number() const { return (this->_buf[1]); }
inline void set_pgm_number(uint8_t number){ _buffer[1] = number; } inline void set_pgm_number(uint8_t number){ this->_buf[1] = number; }
inline uint8_t aftertouch() const { return (_buffer[1]); } inline uint8_t aftertouch() const { return (this->_buf[1]); }
inline uint8_t channel_pressure() const { return (_buffer[1]); } inline uint8_t channel_pressure() const { return (this->_buf[1]); }
inline bool is_channel_event() const { return (0x80 <= type()) && (type() <= 0xE0); } inline bool is_channel_event() const { return (0x80 <= type()) && (type() <= 0xE0); }
inline bool is_smf_meta_event() const { return _buffer[0] == 0xFF; } inline bool is_smf_meta_event() const { return this->_buf[0] == 0xFF; }
inline bool is_sysex() const { return _buffer[0] == 0xF0 inline bool is_sysex() const { return this->_buf[0] == 0xF0
|| _buffer[0] == 0xF7; } || this->_buf[0] == 0xF7; }
}; };
} // namespace Evoral } // namespace Evoral

27
libs/evoral/evoral/Note.hpp
View file

@ -29,15 +29,16 @@ namespace Evoral {
* *
* Currently a note is defined as (on event, length, off event). * Currently a note is defined as (on event, length, off event).
*/ */
template<typename T>
class Note { class Note {
public: public:
Note(uint8_t chan=0, EventTime time=0, EventLength len=0, uint8_t note=0, uint8_t vel=0x40); Note(uint8_t chan=0, T time=0, EventLength len=0, uint8_t note=0, uint8_t vel=0x40);
Note(const Note& copy); Note(const Note<T>& copy);
~Note(); ~Note();
const Note& operator=(const Note& copy); const Note<T>& operator=(const Note<T>& copy);
inline bool operator==(const Note& other) { inline bool operator==(const Note<T>& other) {
return time() == other.time() && return time() == other.time() &&
note() == other.note() && note() == other.note() &&
length() == other.length() && length() == other.length() &&
@ -45,8 +46,8 @@ public:
channel() == other.channel(); channel() == other.channel();
} }
inline EventTime time() const { return _on_event.time(); } inline T time() const { return _on_event.time(); }
inline EventTime end_time() const { return _off_event.time(); } inline T end_time() const { return _off_event.time(); }
inline uint8_t note() const { return _on_event.note(); } inline uint8_t note() const { return _on_event.note(); }
inline uint8_t velocity() const { return _on_event.velocity(); } inline uint8_t velocity() const { return _on_event.velocity(); }
inline EventLength length() const { return _off_event.time() - _on_event.time(); } inline EventLength length() const { return _off_event.time() - _on_event.time(); }
@ -55,21 +56,21 @@ public:
return _on_event.channel(); return _on_event.channel();
} }
inline void set_time(EventTime t) { _off_event.time() = t + length(); _on_event.time() = t; } inline void set_time(T t) { _off_event.time() = t + length(); _on_event.time() = t; }
inline void set_note(uint8_t n) { _on_event.buffer()[1] = n; _off_event.buffer()[1] = n; } inline void set_note(uint8_t n) { _on_event.buffer()[1] = n; _off_event.buffer()[1] = n; }
inline void set_velocity(uint8_t n) { _on_event.buffer()[2] = n; } inline void set_velocity(uint8_t n) { _on_event.buffer()[2] = n; }
inline void set_length(EventLength l) { _off_event.time() = _on_event.time() + l; } inline void set_length(EventLength l) { _off_event.time() = _on_event.time() + l; }
inline void set_channel(uint8_t c) { _on_event.set_channel(c); _off_event.set_channel(c); } inline void set_channel(uint8_t c) { _on_event.set_channel(c); _off_event.set_channel(c); }
inline Event& on_event() { return _on_event; } inline Event<T>& on_event() { return _on_event; }
inline const Event& on_event() const { return _on_event; } inline const Event<T>& on_event() const { return _on_event; }
inline Event& off_event() { return _off_event; } inline Event<T>& off_event() { return _off_event; }
inline const Event& off_event() const { return _off_event; } inline const Event<T>& off_event() const { return _off_event; }
private: private:
// Event buffers are self-contained // Event buffers are self-contained
MIDIEvent _on_event; MIDIEvent<T> _on_event;
MIDIEvent _off_event; MIDIEvent<T> _off_event;
}; };

23
libs/evoral/evoral/SMF.hpp
View file

@ -24,12 +24,13 @@
namespace Evoral { namespace Evoral {
class Event; template<typename T> class Event;
class EventRingBuffer; template<typename T> class EventRingBuffer;
/** Standard Midi File (Type 0) /** Standard Midi File (Type 0)
*/ */
template<typename T>
class SMF { class SMF {
public: public:
SMF(); SMF();
@ -37,14 +38,14 @@ public:
void seek_to_start() const; void seek_to_start() const;
uint16_t ppqn() const { return _ppqn; } uint16_t ppqn() const { return _ppqn; }
bool is_empty() const { return _empty; } bool is_empty() const { return _empty; }
bool eof() const { return feof(_fd); } bool eof() const { return feof(_fd); }
EventTime last_event_time() const { return _last_ev_time; } T last_event_time() const { return _last_ev_time; }
void begin_write(FrameTime start_time); void begin_write(FrameTime start_time);
void append_event_unlocked(uint32_t delta_t, const Evoral::Event& ev); void append_event_unlocked(uint32_t delta_t, const Event<T>& ev);
void end_write(); void end_write();
void flush(); void flush();
@ -70,11 +71,11 @@ protected:
private: private:
static const uint16_t _ppqn = 19200; static const uint16_t _ppqn = 19200;
FILE* _fd; FILE* _fd;
EventTime _last_ev_time; ///< last frame time written, relative to source start T _last_ev_time; ///< last frame time written, relative to source start
uint32_t _track_size; uint32_t _track_size;
uint32_t _header_size; ///< size of SMF header, including MTrk chunk header uint32_t _header_size; ///< size of SMF header, including MTrk chunk header
bool _empty; ///< true iff file contains(non-empty) events bool _empty; ///< true iff file contains(non-empty) events
}; };
}; /* namespace Evoral */ }; /* namespace Evoral */

85
libs/evoral/evoral/Sequence.hpp
View file

@ -35,9 +35,9 @@
namespace Evoral { namespace Evoral {
class TypeMap; class TypeMap;
class EventSink; template<typename T> class EventSink;
class Note; template<typename T> class Note;
class Event; template<typename T> class Event;
/** An iterator over (the x axis of) a 2-d double coordinate space. /** An iterator over (the x axis of) a 2-d double coordinate space.
*/ */
@ -58,6 +58,7 @@ public:
/** This is a higher level view of events, with separate representations for /** This is a higher level view of events, with separate representations for
* notes (instead of just unassociated note on/off events) and controller data. * notes (instead of just unassociated note on/off events) and controller data.
* Controller data is represented as a list of time-stamped float values. */ * Controller data is represented as a list of time-stamped float values. */
template<typename T>
class Sequence : virtual public ControlSet { class Sequence : virtual public ControlSet {
public: public:
Sequence(const TypeMap& type_map, size_t size=0); Sequence(const TypeMap& type_map, size_t size=0);
@ -79,49 +80,49 @@ public:
bool writing() const { return _writing; } bool writing() const { return _writing; }
void end_write(bool delete_stuck=false); void end_write(bool delete_stuck=false);
size_t read(EventSink& dst, size_t read(EventSink<T>& dst,
timestamp_t start, timestamp_t start,
timedur_t length, timedur_t length,
timestamp_t stamp_offset) const; timestamp_t stamp_offset) const;
/** Resizes vector if necessary (NOT realtime safe) */ /** Resizes vector if necessary (NOT realtime safe) */
void append(const Event& ev); void append(const Event<T>& ev);
inline const boost::shared_ptr<const Note> note_at(unsigned i) const { return _notes[i]; } inline const boost::shared_ptr< const Note<T> > note_at(unsigned i) const { return _notes[i]; }
inline const boost::shared_ptr<Note> note_at(unsigned i) { return _notes[i]; } inline const boost::shared_ptr< Note<T> > note_at(unsigned i) { return _notes[i]; }
inline size_t n_notes() const { return _notes.size(); } inline size_t n_notes() const { return _notes.size(); }
inline bool empty() const { return _notes.size() == 0 && ControlSet::empty(); } inline bool empty() const { return _notes.size() == 0 && ControlSet::empty(); }
inline static bool note_time_comparator(const boost::shared_ptr<const Note>& a, inline static bool note_time_comparator(const boost::shared_ptr< const Note<T> >& a,
const boost::shared_ptr<const Note>& b) { const boost::shared_ptr< const Note<T> >& b) {
return a->time() < b->time(); return a->time() < b->time();
} }
struct LaterNoteEndComparator { struct LaterNoteEndComparator {
typedef const Note* value_type; typedef const Note<T>* value_type;
inline bool operator()(const boost::shared_ptr<const Note> a, inline bool operator()(const boost::shared_ptr< const Note<T> > a,
const boost::shared_ptr<const Note> b) const { const boost::shared_ptr< const Note<T> > b) const {
return a->end_time() > b->end_time(); return a->end_time() > b->end_time();
} }
}; };
typedef std::vector< boost::shared_ptr<Note> > Notes; typedef std::vector< boost::shared_ptr< Note<T> > > Notes;
inline Notes& notes() { return _notes; } inline Notes& notes() { return _notes; }
inline const Notes& notes() const { return _notes; } inline const Notes& notes() const { return _notes; }
/** Read iterator */ /** Read iterator */
class const_iterator { class const_iterator {
public: public:
const_iterator(const Sequence& seq, EventTime t); const_iterator(const Sequence<T>& seq, T t);
~const_iterator(); ~const_iterator();
inline bool valid() const { return !_is_end && _event; } inline bool valid() const { return !_is_end && _event; }
inline bool locked() const { return _locked; } inline bool locked() const { return _locked; }
const Event& operator*() const { return *_event; } const Event<T>& operator*() const { return *_event; }
const boost::shared_ptr<Event> operator->() const { return _event; } const boost::shared_ptr< Event<T> > operator->() const { return _event; }
const boost::shared_ptr<Event> get_event_pointer() { return _event; } const boost::shared_ptr< Event<T> > get_event_pointer() { return _event; }
const const_iterator& operator++(); // prefix only const const_iterator& operator++(); // prefix only
bool operator==(const const_iterator& other) const; bool operator==(const const_iterator& other) const;
@ -130,13 +131,13 @@ public:
const_iterator& operator=(const const_iterator& other); const_iterator& operator=(const const_iterator& other);
private: private:
friend class Sequence; friend class Sequence<T>;
const Sequence* _seq; const Sequence<T>* _seq;
boost::shared_ptr<Event> _event; boost::shared_ptr< Event<T> > _event;
typedef std::priority_queue< boost::shared_ptr<Note>, typedef std::priority_queue< boost::shared_ptr< Note<T> >,
std::deque< boost::shared_ptr<Note> >, std::deque< boost::shared_ptr< Note<T> > >,
LaterNoteEndComparator > LaterNoteEndComparator >
ActiveNotes; ActiveNotes;
@ -144,21 +145,21 @@ public:
typedef std::vector<ControlIterator> ControlIterators; typedef std::vector<ControlIterator> ControlIterators;
bool _is_end; bool _is_end;
bool _locked; bool _locked;
Notes::const_iterator _note_iter; typename Notes::const_iterator _note_iter;
ControlIterators _control_iters; ControlIterators _control_iters;
ControlIterators::iterator _control_iter; ControlIterators::iterator _control_iter;
}; };
const_iterator begin(EventTime t=0) const { return const_iterator(*this, t); } const_iterator begin(T t=0) const { return const_iterator(*this, t); }
const const_iterator& end() const { return _end_iter; } const const_iterator& end() const { return _end_iter; }
void read_seek(EventTime t) { _read_iter = begin(t); } void read_seek(T t) { _read_iter = begin(t); }
EventTime read_time() const { return _read_iter.valid() ? _read_iter->time() : 0.0; } T read_time() const { return _read_iter.valid() ? _read_iter->time() : 0.0; }
bool control_to_midi_event(boost::shared_ptr<Event>& ev, bool control_to_midi_event(boost::shared_ptr< Event<T> >& ev,
const ControlIterator& iter) const; const ControlIterator& iter) const;
bool edited() const { return _edited; } bool edited() const { return _edited; }
void set_edited(bool yn) { _edited = yn; } void set_edited(bool yn) { _edited = yn; }
@ -167,8 +168,8 @@ public:
bool is_sorted() const; bool is_sorted() const;
#endif #endif
void add_note_unlocked(const boost::shared_ptr<Note> note); void add_note_unlocked(const boost::shared_ptr< Note<T> > note);
void remove_note_unlocked(const boost::shared_ptr<const Note> note); void remove_note_unlocked(const boost::shared_ptr< const Note<T> > note);
uint8_t lowest_note() const { return _lowest_note; } uint8_t lowest_note() const { return _lowest_note; }
uint8_t highest_note() const { return _highest_note; } uint8_t highest_note() const { return _highest_note; }
@ -180,9 +181,9 @@ protected:
private: private:
friend class const_iterator; friend class const_iterator;
void append_note_on_unlocked(uint8_t chan, EventTime time, uint8_t note, uint8_t velocity); void append_note_on_unlocked(uint8_t chan, T time, uint8_t note, uint8_t velocity);
void append_note_off_unlocked(uint8_t chan, EventTime time, uint8_t note); void append_note_off_unlocked(uint8_t chan, T time, uint8_t note);
void append_control_unlocked(const Parameter& param, EventTime time, double value); void append_control_unlocked(const Parameter& param, T time, double value);
mutable Glib::RWLock _lock; mutable Glib::RWLock _lock;
@ -205,7 +206,7 @@ private:
uint8_t _highest_note; uint8_t _highest_note;
typedef std::priority_queue< typedef std::priority_queue<
boost::shared_ptr<Note>, std::deque< boost::shared_ptr<Note> >, boost::shared_ptr< Note<T> >, std::deque< boost::shared_ptr< Note<T> > >,
LaterNoteEndComparator> LaterNoteEndComparator>
ActiveNotes; ActiveNotes;
}; };

12
libs/evoral/evoral/types.hpp
View file

@ -33,9 +33,6 @@ typedef double timestamp_t;
/** Duration of time in timestamp_t units */ /** Duration of time in timestamp_t units */
typedef timestamp_t timedur_t; typedef timestamp_t timedur_t;
/** Time stamp of an event */
typedef double EventTime;
/** Time stamp of an event */ /** Time stamp of an event */
typedef double EventLength; typedef double EventLength;
@ -43,15 +40,14 @@ typedef double EventLength;
typedef uint32_t EventType; typedef uint32_t EventType;
/** Type to describe the movement of a time range */ /** Type to describe the movement of a time range */
template<typename T>
struct RangeMove { struct RangeMove {
RangeMove (EventTime f, FrameTime l, EventTime t) : from (f), length (l), to (t) {} RangeMove (T f, FrameTime l, T t) : from (f), length (l), to (t) {}
EventTime from; ///< start of the range T from; ///< start of the range
FrameTime length; ///< length of the range FrameTime length; ///< length of the range
EventTime to; ///< new start of the range T to; ///< new start of the range
}; };
typedef std::list<RangeMove> RangeMoveList;
} // namespace Evoral } // namespace Evoral
#endif // EVORAL_TYPES_HPP #endif // EVORAL_TYPES_HPP

8
libs/evoral/src/ControlList.cpp
View file

@ -1285,8 +1285,10 @@ ControlList::paste (ControlList& alist, double pos, float times)
/** Move automation around according to a list of region movements */ /** Move automation around according to a list of region movements */
void void
ControlList::move_ranges (RangeMoveList const & movements) ControlList::move_ranges (const list< RangeMove<double> >& movements)
{ {
typedef list< RangeMove<double> > RangeMoveList;
{ {
Glib::Mutex::Lock lm (_lock); Glib::Mutex::Lock lm (_lock);
@ -1304,8 +1306,8 @@ ControlList::move_ranges (RangeMoveList const & movements)
/* copy the events into the new list */ /* copy the events into the new list */
for (RangeMoveList::const_iterator i = movements.begin (); i != movements.end (); ++i) { for (RangeMoveList::const_iterator i = movements.begin (); i != movements.end (); ++i) {
iterator j = old_events.begin (); iterator j = old_events.begin ();
EventTime const limit = i->from + i->length; const double limit = i->from + i->length;
EventTime const dx = i->to - i->from; const double dx = i->to - i->from;
while (j != old_events.end () && (*j)->when <= limit) { while (j != old_events.end () && (*j)->when <= limit) {
if ((*j)->when >= i->from) { if ((*j)->when >= i->from) {
ControlEvent* ev = new ControlEvent (**j); ControlEvent* ev = new ControlEvent (**j);

43
libs/evoral/src/Event.cpp
View file

@ -22,47 +22,52 @@ namespace Evoral {
#ifdef EVORAL_EVENT_ALLOC #ifdef EVORAL_EVENT_ALLOC
Event::Event(uint32_t tid, EventTime t, uint32_t s, uint8_t* b, bool owns_buffer) template<typename T>
Event<T>::Event(uint32_t tid, T t, uint32_t s, uint8_t* b, bool owns_buf)
: _type(tid) : _type(tid)
, _time(t) , _time(t)
, _size(s) , _size(s)
, _buffer(b) , _buf(b)
, _owns_buffer(owns_buffer) , _owns_buf(owns_buf)
{ {
if (owns_buffer) { if (owns_buf) {
_buffer = (uint8_t*)malloc(_size); _buf = (uint8_t*)malloc(_size);
if (b) { if (b) {
memcpy(_buffer, b, _size); memcpy(_buf, b, _size);
} else { } else {
memset(_buffer, 0, _size); memset(_buf, 0, _size);
} }
} }
} }
Event::Event(const Event& copy, bool owns_buffer) template<typename T>
Event<T>::Event(const Event& copy, bool owns_buf)
: _type(copy._type) : _type(copy._type)
, _time(copy._time) , _time(copy._time)
, _size(copy._size) , _size(copy._size)
, _buffer(copy._buffer) , _buf(copy._buf)
, _owns_buffer(owns_buffer) , _owns_buf(owns_buf)
{ {
if (owns_buffer) { if (owns_buf) {
_buffer = (uint8_t*)malloc(_size); _buf = (uint8_t*)malloc(_size);
if (copy._buffer) { if (copy._buf) {
memcpy(_buffer, copy._buffer, _size); memcpy(_buf, copy._buf, _size);
} else { } else {
memset(_buffer, 0, _size); memset(_buf, 0, _size);
} }
} }
} }
Event::~Event() { template<typename T>
if (_owns_buffer) { Event<T>::~Event() {
free(_buffer); if (_owns_buf) {
free(_buf);
} }
} }
#endif // EVORAL_EVENT_ALLOC #endif // EVORAL_EVENT_ALLOC
} // namespace MIDI template class Event<double>;
} // namespace Evoral

26
libs/evoral/src/MIDIEvent.cpp
View file

@ -16,27 +16,34 @@
* 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/ */
#include <string>
#include "evoral/MIDIEvent.hpp" #include "evoral/MIDIEvent.hpp"
#ifdef EVORAL_MIDI_XML
#include <pbd/xml++.h>
#endif
using namespace std;
namespace Evoral { namespace Evoral {
#ifdef EVORAL_MIDI_XML #ifdef EVORAL_MIDI_XML
MIDIEvent::MIDIEvent(const XMLNode& event) template<typename T>
: Event() MIDIEvent<T>::MIDIEvent(const XMLNode& event)
: Event<T>()
{ {
string name = event.name(); string name = event.name();
if (name == "ControlChange") { if (name == "ControlChange") {
_buffer = (uint8_t*) ::malloc(3); this->_buf = (uint8_t*) ::malloc(3);
_owns_buffer = true; this->_owns_buf = true;
set_type(MIDI_CMD_CONTROL); set_type(MIDI_CMD_CONTROL);
set_cc_number(atoi(event.property("Control")->value().c_str())); set_cc_number(atoi(event.property("Control")->value().c_str()));
set_cc_value (atoi(event.property("Value")->value().c_str())); set_cc_value (atoi(event.property("Value")->value().c_str()));
} else if (name == "ProgramChange") { } else if (name == "ProgramChange") {
_buffer = (uint8_t*) ::malloc(2); this->_buf = (uint8_t*) ::malloc(2);
_owns_buffer = true; this->_owns_buf = true;
set_type(MIDI_CMD_PGM_CHANGE); set_type(MIDI_CMD_PGM_CHANGE);
set_pgm_number(atoi(event.property("Number")->value().c_str())); set_pgm_number(atoi(event.property("Number")->value().c_str()));
@ -44,8 +51,9 @@ MIDIEvent::MIDIEvent(const XMLNode& event)
} }
template<typename T>
boost::shared_ptr<XMLNode> boost::shared_ptr<XMLNode>
MIDIEvent::to_xml() const MIDIEvent<T>::to_xml() const
{ {
XMLNode *result = 0; XMLNode *result = 0;
@ -73,5 +81,7 @@ MIDIEvent::to_xml() const
#endif // EVORAL_MIDI_XML #endif // EVORAL_MIDI_XML
} // namespace MIDI template class MIDIEvent<double>;
} // namespace Evoral

16
libs/evoral/src/Note.cpp
View file

@ -21,7 +21,8 @@
namespace Evoral { namespace Evoral {
Note::Note(uint8_t chan, EventTime t, EventLength l, uint8_t n, uint8_t v) template<typename T>
Note<T>::Note(uint8_t chan, T t, EventLength l, uint8_t n, uint8_t v)
// FIXME: types? // FIXME: types?
: _on_event(0xDE, t, 3, NULL, true) : _on_event(0xDE, t, 3, NULL, true)
, _off_event(0xAD, t + l, 3, NULL, true) , _off_event(0xAD, t + l, 3, NULL, true)
@ -45,7 +46,8 @@ Note::Note(uint8_t chan, EventTime t, EventLength l, uint8_t n, uint8_t v)
} }
Note::Note(const Note& copy) template<typename T>
Note<T>::Note(const Note<T>& copy)
: _on_event(copy._on_event, true) : _on_event(copy._on_event, true)
, _off_event(copy._off_event, true) , _off_event(copy._off_event, true)
{ {
@ -71,13 +73,15 @@ Note::Note(const Note& copy)
} }
Note::~Note() template<typename T>
Note<T>::~Note()
{ {
} }
const Note& template<typename T>
Note::operator=(const Note& copy) const Note<T>&
Note<T>::operator=(const Note<T>& copy)
{ {
_on_event = copy._on_event; _on_event = copy._on_event;
_off_event = copy._off_event; _off_event = copy._off_event;
@ -93,4 +97,6 @@ Note::operator=(const Note& copy)
return *this; return *this;
} }
template class Note<double>;
} // namespace Evoral } // namespace Evoral

53
libs/evoral/src/SMF.cpp
View file

@ -32,7 +32,8 @@ using namespace std;
namespace Evoral { namespace Evoral {
SMF::SMF() template<typename T>
SMF<T>::SMF()
: _fd(0) : _fd(0)
, _last_ev_time(0) , _last_ev_time(0)
, _track_size(4) // 4 bytes for the ever-present EOT event , _track_size(4) // 4 bytes for the ever-present EOT event
@ -41,7 +42,8 @@ SMF::SMF()
{ {
} }
SMF::~SMF() template<typename T>
SMF<T>::~SMF()
{ {
} }
@ -53,8 +55,9 @@ SMF::~SMF()
* -1 if the file can not be opened for reading, * -1 if the file can not be opened for reading,
* -2 if the file can not be opened for writing * -2 if the file can not be opened for writing
*/ */
template<typename T>
int int
SMF::open(const std::string& path) SMF<T>::open(const std::string& path)
{ {
//cerr << "Opening SMF file " << path() << " writeable: " << writable() << endl; //cerr << "Opening SMF file " << path() << " writeable: " << writable() << endl;
_fd = fopen(path.c_str(), "r+"); _fd = fopen(path.c_str(), "r+");
@ -87,8 +90,9 @@ SMF::open(const std::string& path)
return (_fd == 0) ? -1 : 0; return (_fd == 0) ? -1 : 0;
} }
template<typename T>
void void
SMF::close() SMF<T>::close()
{ {
if (_fd) { if (_fd) {
flush_header(); flush_header();
@ -98,14 +102,16 @@ SMF::close()
} }
} }
template<typename T>
void void
SMF::seek_to_start() const SMF<T>::seek_to_start() const
{ {
fseek(_fd, _header_size, SEEK_SET); fseek(_fd, _header_size, SEEK_SET);
} }
template<typename T>
void void
SMF::seek_to_footer_position() SMF<T>::seek_to_footer_position()
{ {
uint8_t buffer[4]; uint8_t buffer[4];
@ -126,14 +132,16 @@ SMF::seek_to_footer_position()
} }
} }
template<typename T>
void void
SMF::flush() SMF<T>::flush()
{ {
fflush(_fd); fflush(_fd);
} }
template<typename T>
int int
SMF::flush_header() SMF<T>::flush_header()
{ {
// FIXME: write timeline position somehow? // FIXME: write timeline position somehow?
@ -161,8 +169,9 @@ SMF::flush_header()
return 0; return 0;
} }
template<typename T>
int int
SMF::flush_footer() SMF<T>::flush_footer()
{ {
//cerr << path() << " SMF Flushing footer\n"; //cerr << path() << " SMF Flushing footer\n";
seek_to_footer_position(); seek_to_footer_position();
@ -172,8 +181,9 @@ SMF::flush_footer()
return 0; return 0;
} }
template<typename T>
void void
SMF::write_footer() SMF<T>::write_footer()
{ {
write_var_len(0); write_var_len(0);
char eot[3] = { 0xFF, 0x2F, 0x00 }; // end-of-track meta-event char eot[3] = { 0xFF, 0x2F, 0x00 }; // end-of-track meta-event
@ -196,8 +206,9 @@ SMF::write_footer()
* Returns event length (including status byte) on success, 0 if event was * Returns event length (including status byte) on success, 0 if event was
* skipped (eg a meta event), or -1 on EOF (or end of track). * skipped (eg a meta event), or -1 on EOF (or end of track).
*/ */
template<typename T>
int int
SMF::read_event(uint32_t* delta_t, uint32_t* size, uint8_t** buf) const SMF<T>::read_event(uint32_t* delta_t, uint32_t* size, uint8_t** buf) const
{ {
if (feof(_fd)) { if (feof(_fd)) {
return -1; return -1;
@ -263,8 +274,9 @@ SMF::read_event(uint32_t* delta_t, uint32_t* size, uint8_t** buf) const
return (int)*size; return (int)*size;
} }
template<typename T>
void void
SMF::append_event_unlocked(uint32_t delta_t, const Evoral::Event& ev) SMF<T>::append_event_unlocked(uint32_t delta_t, const Event<T>& ev)
{ {
if (ev.size() == 0) if (ev.size() == 0)
return; return;
@ -279,22 +291,25 @@ SMF::append_event_unlocked(uint32_t delta_t, const Evoral::Event& ev)
_empty = false; _empty = false;
} }
template<typename T>
void void
SMF::begin_write(FrameTime start_frame) SMF<T>::begin_write(FrameTime start_frame)
{ {
_last_ev_time = 0; _last_ev_time = 0;
fseek(_fd, _header_size, SEEK_SET); fseek(_fd, _header_size, SEEK_SET);
} }
template<typename T>
void void
SMF::end_write() SMF<T>::end_write()
{ {
flush_header(); flush_header();
flush_footer(); flush_footer();
} }
template<typename T>
void void
SMF::write_chunk_header(const char id[4], uint32_t length) SMF<T>::write_chunk_header(const char id[4], uint32_t length)
{ {
const uint32_t length_be = GUINT32_TO_BE(length); const uint32_t length_be = GUINT32_TO_BE(length);
@ -302,8 +317,9 @@ SMF::write_chunk_header(const char id[4], uint32_t length)
fwrite(&length_be, 4, 1, _fd); fwrite(&length_be, 4, 1, _fd);
} }
template<typename T>
void void
SMF::write_chunk(const char id[4], uint32_t length, void* data) SMF<T>::write_chunk(const char id[4], uint32_t length, void* data)
{ {
write_chunk_header(id, length); write_chunk_header(id, length);
@ -311,8 +327,9 @@ SMF::write_chunk(const char id[4], uint32_t length, void* data)
} }
/** Returns the size (in bytes) of the value written. */ /** Returns the size (in bytes) of the value written. */
template<typename T>
size_t size_t
SMF::write_var_len(uint32_t value) SMF<T>::write_var_len(uint32_t value)
{ {
size_t ret = 0; size_t ret = 0;
@ -336,4 +353,6 @@ SMF::write_var_len(uint32_t value)
return ret; return ret;
} }
template class SMF<double>;
} // namespace Evoral } // namespace Evoral

110
libs/evoral/src/Sequence.cpp
View file

@ -35,21 +35,25 @@ using namespace std;
namespace Evoral { namespace Evoral {
void Sequence::write_lock() { template<typename T>
void Sequence<T>::write_lock() {
_lock.writer_lock(); _lock.writer_lock();
_control_lock.lock(); _control_lock.lock();
} }
void Sequence::write_unlock() { template<typename T>
void Sequence<T>::write_unlock() {
_lock.writer_unlock(); _lock.writer_unlock();
_control_lock.unlock(); _control_lock.unlock();
} }
void Sequence::read_lock() const { template<typename T>
void Sequence<T>::read_lock() const {
_lock.reader_lock(); _lock.reader_lock();
} }
void Sequence::read_unlock() const { template<typename T>
void Sequence<T>::read_unlock() const {
_lock.reader_unlock(); _lock.reader_unlock();
} }
@ -64,7 +68,8 @@ static ostream& errorout = cerr;
// Read iterator (const_iterator) // Read iterator (const_iterator)
Sequence::const_iterator::const_iterator(const Sequence& seq, EventTime t) template<typename T>
Sequence<T>::const_iterator::const_iterator(const Sequence<T>& seq, T t)
: _seq(&seq) : _seq(&seq)
, _is_end( (t == DBL_MAX) || seq.empty() ) , _is_end( (t == DBL_MAX) || seq.empty() )
, _locked( !_is_end ) , _locked( !_is_end )
@ -79,7 +84,8 @@ Sequence::const_iterator::const_iterator(const Sequence& seq, EventTime t)
// find first note which begins after t // find first note which begins after t
_note_iter = seq.notes().end(); _note_iter = seq.notes().end();
for (Sequence::Notes::const_iterator i = seq.notes().begin(); i != seq.notes().end(); ++i) { for (typename Sequence<T>::Notes::const_iterator i = seq.notes().begin();
i != seq.notes().end(); ++i) {
if ((*i)->time() >= t) { if ((*i)->time() >= t) {
_note_iter = i; _note_iter = i;
break; break;
@ -130,7 +136,7 @@ Sequence::const_iterator::const_iterator(const Sequence& seq, EventTime t)
&& (!earliest_control.list && (!earliest_control.list
|| (*_note_iter)->on_event().time() < earliest_control.x)) { || (*_note_iter)->on_event().time() < earliest_control.x)) {
debugout << "Reading note on event @ " << (*_note_iter)->on_event().time() << endl; debugout << "Reading note on event @ " << (*_note_iter)->on_event().time() << endl;
_event = boost::shared_ptr<Event>(new Event((*_note_iter)->on_event(), true)); _event = boost::shared_ptr< Event<T> >(new Event<T>((*_note_iter)->on_event(), true));
_active_notes.push(*_note_iter); _active_notes.push(*_note_iter);
++_note_iter; ++_note_iter;
_control_iter = _control_iters.end(); _control_iter = _control_iters.end();
@ -152,22 +158,24 @@ Sequence::const_iterator::const_iterator(const Sequence& seq, EventTime t)
} }
} else { } else {
debugout << "New Iterator = " << _event->event_type(); debugout << "New Iterator = " << _event->event_type();
debugout << " : " << hex << (int)((MIDIEvent*)_event.get())->type(); debugout << " : " << hex << (int)((MIDIEvent<T>*)_event.get())->type();
debugout << " @ " << _event->time() << endl; debugout << " @ " << _event->time() << endl;
} }
//assert(_is_end || (_event->buffer() && _event->buffer()[0] != '\0')); //assert(_is_end || (_event->buffer() && _event->buffer()[0] != '\0'));
} }
Sequence::const_iterator::~const_iterator() template<typename T>
Sequence<T>::const_iterator::~const_iterator()
{ {
if (_locked) { if (_locked) {
_seq->read_unlock(); _seq->read_unlock();
} }
} }
const template<typename T>
Sequence::const_iterator& Sequence::const_iterator::operator++() const typename Sequence<T>::const_iterator&
Sequence<T>::const_iterator::operator++()
{ {
if (_is_end) { if (_is_end) {
throw std::logic_error("Attempt to iterate past end of Sequence"); throw std::logic_error("Attempt to iterate past end of Sequence");
@ -176,7 +184,7 @@ Sequence::const_iterator& Sequence::const_iterator::operator++()
debugout << "Iterator ++" << endl; debugout << "Iterator ++" << endl;
assert(_event->buffer() && _event->size() > 0); assert(_event->buffer() && _event->size() > 0);
const MIDIEvent& ev = *((MIDIEvent*)_event.get()); const MIDIEvent<T>& ev = *((MIDIEvent<T>*)_event.get());
//debugout << "const_iterator::operator++: " << _event->to_string() << endl; //debugout << "const_iterator::operator++: " << _event->to_string() << endl;
@ -214,10 +222,10 @@ Sequence::const_iterator& Sequence::const_iterator::operator++()
} }
} }
enum Type {NIL, NOTE_ON, NOTE_OFF, CONTROL}; enum Type { NIL, NOTE_ON, NOTE_OFF, CONTROL };
Type type = NIL; Type type = NIL;
EventTime t = 0; T t = 0;
// Next earliest note on // Next earliest note on
if (_note_iter != _seq->notes().end()) { if (_note_iter != _seq->notes().end()) {
@ -262,8 +270,9 @@ Sequence::const_iterator& Sequence::const_iterator::operator++()
return *this; return *this;
} }
template<typename T>
bool bool
Sequence::const_iterator::operator==(const const_iterator& other) const Sequence<T>::const_iterator::operator==(const const_iterator& other) const
{ {
if (_is_end || other._is_end) { if (_is_end || other._is_end) {
return (_is_end == other._is_end); return (_is_end == other._is_end);
@ -272,8 +281,9 @@ Sequence::const_iterator::operator==(const const_iterator& other) const
} }
} }
Sequence::const_iterator& template<typename T>
Sequence::const_iterator::operator=(const const_iterator& other) typename Sequence<T>::const_iterator&
Sequence<T>::const_iterator::operator=(const const_iterator& other)
{ {
if (_locked && _seq != other._seq) { if (_locked && _seq != other._seq) {
_seq->read_unlock(); _seq->read_unlock();
@ -292,7 +302,7 @@ Sequence::const_iterator::operator=(const const_iterator& other)
if (_event) { if (_event) {
*_event = *other._event.get(); *_event = *other._event.get();
} else { } else {
_event = boost::shared_ptr<Event>(new Event(*other._event, true)); _event = boost::shared_ptr< Event<T> >(new Event<T>(*other._event, true));
} }
} else { } else {
if (_event) { if (_event) {
@ -305,7 +315,8 @@ Sequence::const_iterator::operator=(const const_iterator& other)
// Sequence // Sequence
Sequence::Sequence(const TypeMap& type_map, size_t size) template<typename T>
Sequence<T>::Sequence(const TypeMap& type_map, size_t size)
: _read_iter(*this, DBL_MAX) : _read_iter(*this, DBL_MAX)
, _edited(false) , _edited(false)
, _type_map(type_map) , _type_map(type_map)
@ -326,8 +337,9 @@ Sequence::Sequence(const TypeMap& type_map, size_t size)
* adding \a offset to each event's timestamp. * adding \a offset to each event's timestamp.
* \return number of events written to \a dst * \return number of events written to \a dst
*/ */
template<typename T>
size_t size_t
Sequence::read(EventSink& dst, timestamp_t start, timedur_t nframes, timestamp_t offset) const Sequence<T>::read(EventSink<T>& dst, timestamp_t start, timedur_t nframes, timestamp_t offset) const
{ {
debugout << this << " read @ " << start << " * " << nframes << " + " << offset << endl; debugout << this << " read @ " << start << " * " << nframes << " + " << offset << endl;
debugout << this << " # notes: " << n_notes() << endl; debugout << this << " # notes: " << n_notes() << endl;
@ -370,13 +382,14 @@ Sequence::read(EventSink& dst, timestamp_t start, timedur_t nframes, timestamp_t
* The event_type of \a ev should be set to the expected output type. * The event_type of \a ev should be set to the expected output type.
* \return true on success * \return true on success
*/ */
template<typename T>
bool bool
Sequence::control_to_midi_event(boost::shared_ptr<Event>& ev, const ControlIterator& iter) const Sequence<T>::control_to_midi_event(boost::shared_ptr< Event<T> >& ev, const ControlIterator& iter) const
{ {
assert(iter.list.get()); assert(iter.list.get());
const uint32_t event_type = iter.list->parameter().type(); const uint32_t event_type = iter.list->parameter().type();
if (!ev) { if (!ev) {
ev = boost::shared_ptr<Event>(new Event(event_type, 0, 3, NULL, true)); ev = boost::shared_ptr< Event<T> >(new Event<T>(event_type, 0, 3, NULL, true));
} }
uint8_t midi_type = _type_map.parameter_midi_type(iter.list->parameter()); uint8_t midi_type = _type_map.parameter_midi_type(iter.list->parameter());
@ -438,8 +451,9 @@ Sequence::control_to_midi_event(boost::shared_ptr<Event>& ev, const ControlItera
/** Clear all events from the model. /** Clear all events from the model.
*/ */
template<typename T>
void void
Sequence::clear() Sequence<T>::clear()
{ {
_lock.writer_lock(); _lock.writer_lock();
_notes.clear(); _notes.clear();
@ -457,8 +471,9 @@ Sequence::clear()
* stored; note off events are discarded entirely and all contained notes will * stored; note off events are discarded entirely and all contained notes will
* have length 0. * have length 0.
*/ */
template<typename T>
void void
Sequence::start_write() Sequence<T>::start_write()
{ {
debugout << this << " START WRITE, PERCUSSIVE = " << _percussive << endl; debugout << this << " START WRITE, PERCUSSIVE = " << _percussive << endl;
write_lock(); write_lock();
@ -476,8 +491,9 @@ Sequence::start_write()
* that were never resolved with a corresonding note off will be deleted. * that were never resolved with a corresonding note off will be deleted.
* Otherwise they will remain as notes with length 0. * Otherwise they will remain as notes with length 0.
*/ */
template<typename T>
void void
Sequence::end_write(bool delete_stuck) Sequence<T>::end_write(bool delete_stuck)
{ {
write_lock(); write_lock();
assert(_writing); assert(_writing);
@ -485,7 +501,7 @@ Sequence::end_write(bool delete_stuck)
debugout << this << " END WRITE: " << _notes.size() << " NOTES\n"; debugout << this << " END WRITE: " << _notes.size() << " NOTES\n";
if (!_percussive && delete_stuck) { if (!_percussive && delete_stuck) {
for (Notes::iterator n = _notes.begin(); n != _notes.end() ;) { for (typename Notes::iterator n = _notes.begin(); n != _notes.end() ;) {
if ((*n)->length() == 0) { if ((*n)->length() == 0) {
errorout << "WARNING: Stuck note lost: " << (*n)->note() << endl; errorout << "WARNING: Stuck note lost: " << (*n)->note() << endl;
n = _notes.erase(n); n = _notes.erase(n);
@ -499,7 +515,7 @@ Sequence::end_write(bool delete_stuck)
for (int i = 0; i < 16; ++i) { for (int i = 0; i < 16; ++i) {
if (!_write_notes[i].empty()) { if (!_write_notes[i].empty()) {
errorout << "WARNING: Sequence::end_write: Channel " << i << " has " errorout << "WARNING: Sequence<T>::end_write: Channel " << i << " has "
<< _write_notes[i].size() << " stuck notes" << endl; << _write_notes[i].size() << " stuck notes" << endl;
} }
_write_notes[i].clear(); _write_notes[i].clear();
@ -519,13 +535,14 @@ Sequence::end_write(bool delete_stuck)
* the start of this model (t=0) and MUST be monotonically increasing * the start of this model (t=0) and MUST be monotonically increasing
* and MUST be >= the latest event currently in the model. * and MUST be >= the latest event currently in the model.
*/ */
template<typename T>
void void
Sequence::append(const Event& event) Sequence<T>::append(const Event<T>& event)
{ {
write_lock(); write_lock();
_edited = true; _edited = true;
const MIDIEvent& ev = (const MIDIEvent&)event; const MIDIEvent<T>& ev = (const MIDIEvent<T>&)event;
assert(_notes.empty() || ev.time() >= _notes.back()->time()); assert(_notes.empty() || ev.time() >= _notes.back()->time());
assert(_writing); assert(_writing);
@ -565,8 +582,9 @@ Sequence::append(const Event& event)
write_unlock(); write_unlock();
} }
template<typename T>
void void
Sequence::append_note_on_unlocked(uint8_t chan, EventTime time, uint8_t note_num, uint8_t velocity) Sequence<T>::append_note_on_unlocked(uint8_t chan, T time, uint8_t note_num, uint8_t velocity)
{ {
debugout << this << " c" << (int)chan << " note " << (int)note_num << " off @ " << time << endl; debugout << this << " c" << (int)chan << " note " << (int)note_num << " off @ " << time << endl;
assert(note_num <= 127); assert(note_num <= 127);
@ -579,7 +597,7 @@ Sequence::append_note_on_unlocked(uint8_t chan, EventTime time, uint8_t note_num
if (note_num > _highest_note) if (note_num > _highest_note)
_highest_note = note_num; _highest_note = note_num;
boost::shared_ptr<Note> new_note(new Note(chan, time, 0, note_num, velocity)); boost::shared_ptr< Note<T> > new_note(new Note<T>(chan, time, 0, note_num, velocity));
_notes.push_back(new_note); _notes.push_back(new_note);
if (!_percussive) { if (!_percussive) {
debugout << "Sustained: Appending active note on " << (unsigned)(uint8_t)note_num << endl; debugout << "Sustained: Appending active note on " << (unsigned)(uint8_t)note_num << endl;
@ -589,8 +607,9 @@ Sequence::append_note_on_unlocked(uint8_t chan, EventTime time, uint8_t note_num
} }
} }
template<typename T>
void void
Sequence::append_note_off_unlocked(uint8_t chan, EventTime time, uint8_t note_num) Sequence<T>::append_note_off_unlocked(uint8_t chan, T time, uint8_t note_num)
{ {
debugout << this << " c" << (int)chan << " note " << (int)note_num << " off @ " << time << endl; debugout << this << " c" << (int)chan << " note " << (int)note_num << " off @ " << time << endl;
assert(note_num <= 127); assert(note_num <= 127);
@ -612,7 +631,7 @@ Sequence::append_note_off_unlocked(uint8_t chan, EventTime time, uint8_t note_nu
for (WriteNotes::iterator n = _write_notes[chan].begin(); n for (WriteNotes::iterator n = _write_notes[chan].begin(); n
!= _write_notes[chan].end(); ++n) { != _write_notes[chan].end(); ++n) {
Note& note = *_notes[*n].get(); Note<T>& note = *_notes[*n].get();
if (note.note() == note_num) { if (note.note() == note_num) {
assert(time >= note.time()); assert(time >= note.time());
note.set_length(time - note.time()); note.set_length(time - note.time());
@ -629,8 +648,9 @@ Sequence::append_note_off_unlocked(uint8_t chan, EventTime time, uint8_t note_nu
} }
} }
template<typename T>
void void
Sequence::append_control_unlocked(const Parameter& param, EventTime time, double value) Sequence<T>::append_control_unlocked(const Parameter& param, T time, double value)
{ {
debugout << this << " " << _type_map.to_symbol(param) << " @ " << time << " \t= \t" << value debugout << this << " " << _type_map.to_symbol(param) << " @ " << time << " \t= \t" << value
<< " # controls: " << _controls.size() << endl; << " # controls: " << _controls.size() << endl;
@ -638,25 +658,26 @@ Sequence::append_control_unlocked(const Parameter& param, EventTime time, double
c->list()->rt_add(time, value); c->list()->rt_add(time, value);
} }
template<typename T>
void void
Sequence::add_note_unlocked(const boost::shared_ptr<Note> note) Sequence<T>::add_note_unlocked(const boost::shared_ptr< Note<T> > note)
{ {
debugout << this << " add note " << (int)note->note() << " @ " << note->time() << endl; debugout << this << " add note " << (int)note->note() << " @ " << note->time() << endl;
_edited = true; _edited = true;
Notes::iterator i = upper_bound(_notes.begin(), _notes.end(), note, typename Notes::iterator i = upper_bound(_notes.begin(), _notes.end(), note,
note_time_comparator); note_time_comparator);
_notes.insert(i, note); _notes.insert(i, note);
} }
template<typename T>
void void
Sequence::remove_note_unlocked(const boost::shared_ptr<const Note> note) Sequence<T>::remove_note_unlocked(const boost::shared_ptr< const Note<T> > note)
{ {
_edited = true; _edited = true;
debugout << this << " remove note " << (int)note->note() << " @ " << note->time() << endl; debugout << this << " remove note " << (int)note->note() << " @ " << note->time() << endl;
for (Notes::iterator n = _notes.begin(); n != _notes.end(); ++n) { for (typename Notes::iterator n = _notes.begin(); n != _notes.end(); ++n) {
Note& _n = *(*n); Note<T>& _n = *(*n);
const Note& _note = *note; const Note<T>& _note = *note;
// TODO: There is still the issue, that after restarting ardour // TODO: There is still the issue, that after restarting ardour
// persisted undo does not work, because of rounding errors in the // persisted undo does not work, because of rounding errors in the
// event times after saving/restoring to/from MIDI files // event times after saving/restoring to/from MIDI files
@ -675,10 +696,11 @@ Sequence::remove_note_unlocked(const boost::shared_ptr<const Note> note)
/** Slow! for debugging only. */ /** Slow! for debugging only. */
#ifndef NDEBUG #ifndef NDEBUG
template<typename T>
bool bool
Sequence::is_sorted() const { Sequence<T>::is_sorted() const {
bool t = 0; bool t = 0;
for (Notes::const_iterator n = _notes.begin(); n != _notes.end(); ++n) for (typename Notes::const_iterator n = _notes.begin(); n != _notes.end(); ++n)
if ((*n)->time() < t) if ((*n)->time() < t)
return false; return false;
else else
@ -688,5 +710,7 @@ Sequence::is_sorted() const {
} }
#endif #endif
template class Sequence<double>;
} // namespace Evoral } // namespace Evoral

8
libs/midi++2/jack_midiport.cc
View file

@ -97,7 +97,7 @@ JACK_MidiPort::write(byte * msg, size_t msglen, timestamp_t timestamp)
if (!is_process_thread()) { if (!is_process_thread()) {
Glib::Mutex::Lock lm (non_process_thread_fifo_lock); Glib::Mutex::Lock lm (non_process_thread_fifo_lock);
RingBuffer<Evoral::Event>::rw_vector vec; RingBuffer< Evoral::Event<double> >::rw_vector vec;
non_process_thread_fifo.get_write_vector (&vec); non_process_thread_fifo.get_write_vector (&vec);
@ -161,7 +161,7 @@ JACK_MidiPort::write(byte * msg, size_t msglen, timestamp_t timestamp)
void void
JACK_MidiPort::flush (void* jack_port_buffer) JACK_MidiPort::flush (void* jack_port_buffer)
{ {
RingBuffer<Evoral::Event>::rw_vector vec; RingBuffer< Evoral::Event<double> >::rw_vector vec;
size_t written; size_t written;
non_process_thread_fifo.get_read_vector (&vec); non_process_thread_fifo.get_read_vector (&vec);
@ -171,7 +171,7 @@ JACK_MidiPort::flush (void* jack_port_buffer)
} }
if (vec.len[0]) { if (vec.len[0]) {
Evoral::Event* evp = vec.buf[0]; Evoral::Event<double>* evp = vec.buf[0];
for (size_t n = 0; n < vec.len[0]; ++n, ++evp) { for (size_t n = 0; n < vec.len[0]; ++n, ++evp) {
jack_midi_event_write (jack_port_buffer, jack_midi_event_write (jack_port_buffer,
@ -180,7 +180,7 @@ JACK_MidiPort::flush (void* jack_port_buffer)
} }
if (vec.len[1]) { if (vec.len[1]) {
Evoral::Event* evp = vec.buf[1]; Evoral::Event<double>* evp = vec.buf[1];
for (size_t n = 0; n < vec.len[1]; ++n, ++evp) { for (size_t n = 0; n < vec.len[1]; ++n, ++evp) {
jack_midi_event_write (jack_port_buffer, jack_midi_event_write (jack_port_buffer,

3
libs/midi++2/midi++/jack.h
View file

@ -82,9 +82,8 @@ private:
void flush (void* jack_port_buffer); void flush (void* jack_port_buffer);
static pthread_t _process_thread; static pthread_t _process_thread;
RingBuffer<Evoral::Event> non_process_thread_fifo; RingBuffer< Evoral::Event<double> > non_process_thread_fifo;
Glib::Mutex non_process_thread_fifo_lock; Glib::Mutex non_process_thread_fifo_lock;
}; };

2
libs/midi++2/midi++/midnam_patch.h
View file

@ -84,7 +84,7 @@ public:
class PatchBank; class PatchBank;
typedef std::list<boost::shared_ptr<Evoral::MIDIEvent> > PatchMidiCommands; typedef std::list< boost::shared_ptr< Evoral::MIDIEvent<double> > > PatchMidiCommands;
class Patch : public PBD::Stateful class Patch : public PBD::Stateful
{ {