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

Fix more broken whitespace.

Browse source 
git-svn-id: svn://localhost/ardour2/branches/3.0@8314 d708f5d6-7413-0410-9779-e7cbd77b26cf
This commit is contained in:
David Robillard 2010-12-20 22:51:17 +00:00
parent 7e3404e2a0
commit f6ed36a457
9 changed files with 969 additions and 969 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -35,12 +35,12 @@ class TempoMap;
*/ */
class BeatsFramesConverter : public Evoral::TimeConverter<double,framepos_t> { class BeatsFramesConverter : public Evoral::TimeConverter<double,framepos_t> {
public: public:
BeatsFramesConverter (const TempoMap& tempo_map, framepos_t origin) BeatsFramesConverter (const TempoMap& tempo_map, framepos_t origin)
: Evoral::TimeConverter<double, framepos_t> (origin) : Evoral::TimeConverter<double, framepos_t> (origin)
, _tempo_map(tempo_map) , _tempo_map(tempo_map)
{} {}
framepos_t to (double beats) const; framepos_t to (double beats) const;
double from (framepos_t frames) const; double from (framepos_t frames) const;
private: private:

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

@ -62,7 +62,7 @@ class MidiRegion : public Region
~MidiRegion(); ~MidiRegion();
boost::shared_ptr<MidiRegion> clone (); boost::shared_ptr<MidiRegion> clone ();
boost::shared_ptr<MidiSource> midi_source (uint32_t n=0) const; boost::shared_ptr<MidiSource> midi_source (uint32_t n=0) const;
@ -71,17 +71,17 @@ class MidiRegion : public Region
virtual framecnt_t readable_length() const { return length(); } virtual framecnt_t readable_length() const { return length(); }
framecnt_t read_at (Evoral::EventSink<framepos_t>& dst, framecnt_t read_at (Evoral::EventSink<framepos_t>& dst,
framepos_t position, framepos_t position,
framecnt_t dur, framecnt_t dur,
uint32_t chan_n = 0, uint32_t chan_n = 0,
NoteMode mode = Sustained, NoteMode mode = Sustained,
MidiStateTracker* tracker = 0) const; MidiStateTracker* tracker = 0) const;
framepos_t master_read_at (MidiRingBuffer<framepos_t>& dst, framepos_t master_read_at (MidiRingBuffer<framepos_t>& dst,
framepos_t position, framepos_t position,
framecnt_t dur, framecnt_t dur,
uint32_t chan_n = 0, uint32_t chan_n = 0,
NoteMode mode = Sustained) const; NoteMode mode = Sustained) const;
XMLNode& state (); XMLNode& state ();
int set_state (const XMLNode&, int version); int set_state (const XMLNode&, int version);
@ -117,38 +117,38 @@ class MidiRegion : public Region
private: private:
friend class RegionFactory; friend class RegionFactory;
PBD::Property<Evoral::MusicalTime> _length_beats; PBD::Property<Evoral::MusicalTime> _length_beats;
MidiRegion (const SourceList&); MidiRegion (const SourceList&);
MidiRegion (boost::shared_ptr<const MidiRegion>, frameoffset_t offset = 0, bool offset_relative = true); MidiRegion (boost::shared_ptr<const MidiRegion>, frameoffset_t offset = 0, bool offset_relative = true);
framecnt_t _read_at (const SourceList&, Evoral::EventSink<framepos_t>& dst, framecnt_t _read_at (const SourceList&, Evoral::EventSink<framepos_t>& dst,
framepos_t position, framepos_t position,
framecnt_t dur, framecnt_t dur,
uint32_t chan_n = 0, uint32_t chan_n = 0,
NoteMode mode = Sustained, NoteMode mode = Sustained,
MidiStateTracker* tracker = 0) const; MidiStateTracker* tracker = 0) const;
void register_properties (); void register_properties ();
void post_set (const PBD::PropertyChange&); void post_set (const PBD::PropertyChange&);
void recompute_at_start (); void recompute_at_start ();
void recompute_at_end (); void recompute_at_end ();
void set_position_internal (framepos_t pos, bool allow_bbt_recompute); void set_position_internal (framepos_t pos, bool allow_bbt_recompute);
void set_length_internal (framecnt_t len); void set_length_internal (framecnt_t len);
void update_length_beats (); void update_length_beats ();
void model_changed (); void model_changed ();
void model_automation_state_changed (Evoral::Parameter const &); void model_automation_state_changed (Evoral::Parameter const &);
void model_contents_changed (); void model_contents_changed ();
std::set<Evoral::Parameter> _filtered_parameters; ///< parameters that we ask our source not to return when reading std::set<Evoral::Parameter> _filtered_parameters; ///< parameters that we ask our source not to return when reading
PBD::ScopedConnection _model_connection; PBD::ScopedConnection _model_connection;
PBD::ScopedConnection _source_connection; PBD::ScopedConnection _source_connection;
PBD::ScopedConnection _model_contents_connection; PBD::ScopedConnection _model_contents_connection;
double _last_length_beats; double _last_length_beats;
}; };
} /* namespace ARDOUR */ } /* namespace ARDOUR */

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

@ -96,6 +96,7 @@ class MidiSource : virtual public Source, public boost::enable_shared_from_this<
int set_state (const XMLNode&, int version); int set_state (const XMLNode&, int version);
bool length_mutable() const { return true; } bool length_mutable() const { return true; }
double length_beats() const { return _length_beats; }
virtual void load_model(bool lock=true, bool force_reload=false) = 0; virtual void load_model(bool lock=true, bool force_reload=false) = 0;
virtual void destroy_model() = 0; virtual void destroy_model() = 0;
@ -150,7 +151,7 @@ class MidiSource : virtual public Source, public boost::enable_shared_from_this<
mutable Evoral::Sequence<Evoral::MusicalTime>::const_iterator _model_iter; mutable Evoral::Sequence<Evoral::MusicalTime>::const_iterator _model_iter;
mutable bool _model_iter_valid; mutable bool _model_iter_valid;
mutable double _length_beats; mutable double _length_beats;
mutable framepos_t _last_read_end; mutable framepos_t _last_read_end;
framepos_t _last_write_end; framepos_t _last_write_end;

4
libs/ardour/beats_frames_converter.cc
View file

@ -27,13 +27,13 @@ namespace ARDOUR {
framecnt_t framecnt_t
BeatsFramesConverter::to (double beats) const BeatsFramesConverter::to (double beats) const
{ {
return _tempo_map.framepos_plus_bbt (_origin_b, Timecode::BBT_Time(beats)) - _origin_b; return _tempo_map.framepos_plus_bbt (_origin_b, Timecode::BBT_Time(beats)) - _origin_b;
} }
double double
BeatsFramesConverter::from (framecnt_t frames) const BeatsFramesConverter::from (framecnt_t frames) const
{ {
return _tempo_map.framewalk_to_beats (_origin_b, frames); return _tempo_map.framewalk_to_beats (_origin_b, frames);
} }
} /* namespace ARDOUR */ } /* namespace ARDOUR */

1528
libs/ardour/midi_model.cc
View file

File diff suppressed because it is too large Load diff

88
libs/ardour/midi_region.cc
View file

@ -51,16 +51,16 @@ namespace ARDOUR {
namespace Properties { namespace Properties {
PBD::PropertyDescriptor<void*> midi_data; PBD::PropertyDescriptor<void*> midi_data;
PBD::PropertyDescriptor<Evoral::MusicalTime> length_beats; PBD::PropertyDescriptor<Evoral::MusicalTime> length_beats;
} }
} }
void void
MidiRegion::make_property_quarks () MidiRegion::make_property_quarks ()
{ {
Properties::midi_data.property_id = g_quark_from_static_string (X_("midi-data")); Properties::midi_data.property_id = g_quark_from_static_string (X_("midi-data"));
DEBUG_TRACE (DEBUG::Properties, string_compose ("quark for midi-data = %1\n", Properties::midi_data.property_id)); DEBUG_TRACE (DEBUG::Properties, string_compose ("quark for midi-data = %1\n", Properties::midi_data.property_id));
Properties::length_beats.property_id = g_quark_from_static_string (X_("length-beats")); Properties::length_beats.property_id = g_quark_from_static_string (X_("length-beats"));
DEBUG_TRACE (DEBUG::Properties, string_compose ("quark for length-beats = %1\n", Properties::length_beats.property_id)); DEBUG_TRACE (DEBUG::Properties, string_compose ("quark for length-beats = %1\n", Properties::length_beats.property_id));
} }
void void
@ -72,10 +72,12 @@ MidiRegion::register_properties ()
/* Basic MidiRegion constructor (many channels) */ /* Basic MidiRegion constructor (many channels) */
MidiRegion::MidiRegion (const SourceList& srcs) MidiRegion::MidiRegion (const SourceList& srcs)
: Region (srcs) : Region (srcs)
, _length_beats (Properties::length_beats, (Evoral::MusicalTime) 0) , _length_beats (Properties::length_beats, (Evoral::MusicalTime) 0)
{ {
update_length_beats (); _length_beats = midi_source(0)->length_beats();
register_properties (); cout << "NEW MIDI REGION LENGTH BEATS: " << _length_beats << endl;
register_properties ();
midi_source(0)->ModelChanged.connect_same_thread (_source_connection, boost::bind (&MidiRegion::model_changed, this)); midi_source(0)->ModelChanged.connect_same_thread (_source_connection, boost::bind (&MidiRegion::model_changed, this));
model_changed (); model_changed ();
@ -86,10 +88,10 @@ MidiRegion::MidiRegion (const SourceList& srcs)
/** Create a new MidiRegion, that is part of an existing one */ /** Create a new MidiRegion, that is part of an existing one */
MidiRegion::MidiRegion (boost::shared_ptr<const MidiRegion> other, frameoffset_t offset, bool offset_relative) MidiRegion::MidiRegion (boost::shared_ptr<const MidiRegion> other, frameoffset_t offset, bool offset_relative)
: Region (other, offset, offset_relative) : Region (other, offset, offset_relative)
, _length_beats (Properties::length_beats, (Evoral::MusicalTime) 0) , _length_beats (Properties::length_beats, (Evoral::MusicalTime) 0)
{ {
update_length_beats (); update_length_beats ();
register_properties (); register_properties ();
assert(_name.val().find("/") == string::npos); assert(_name.val().find("/") == string::npos);
midi_source(0)->ModelChanged.connect_same_thread (_source_connection, boost::bind (&MidiRegion::model_changed, this)); midi_source(0)->ModelChanged.connect_same_thread (_source_connection, boost::bind (&MidiRegion::model_changed, this));
@ -105,60 +107,60 @@ MidiRegion::~MidiRegion ()
boost::shared_ptr<MidiRegion> boost::shared_ptr<MidiRegion>
MidiRegion::clone () MidiRegion::clone ()
{ {
BeatsFramesConverter bfc (_session.tempo_map(), _position); BeatsFramesConverter bfc (_session.tempo_map(), _position);
Evoral::MusicalTime const bbegin = bfc.from (_start); Evoral::MusicalTime const bbegin = bfc.from (_start);
Evoral::MusicalTime const bend = bfc.from (_start + _length); Evoral::MusicalTime const bend = bfc.from (_start + _length);
boost::shared_ptr<MidiSource> ms = midi_source(0)->clone (bbegin, bend); boost::shared_ptr<MidiSource> ms = midi_source(0)->clone (bbegin, bend);
PropertyList plist; PropertyList plist;
plist.add (Properties::name, ms->name()); plist.add (Properties::name, ms->name());
plist.add (Properties::whole_file, true); plist.add (Properties::whole_file, true);
plist.add (Properties::start, _start); plist.add (Properties::start, _start);
plist.add (Properties::length, _length); plist.add (Properties::length, _length);
plist.add (Properties::length_beats, _length_beats); plist.add (Properties::length_beats, _length_beats);
plist.add (Properties::layer, 0); plist.add (Properties::layer, 0);
return boost::dynamic_pointer_cast<MidiRegion> (RegionFactory::create (ms, plist, true)); return boost::dynamic_pointer_cast<MidiRegion> (RegionFactory::create (ms, plist, true));
} }
void void
MidiRegion::post_set (const PropertyChange& pc) MidiRegion::post_set (const PropertyChange& pc)
{ {
if (pc.contains (Properties::length) || pc.contains (Properties::position)) { if (pc.contains (Properties::length) || pc.contains (Properties::position)) {
update_length_beats (); update_length_beats ();
} }
} }
void void
MidiRegion::set_length_internal (framecnt_t len) MidiRegion::set_length_internal (framecnt_t len)
{ {
Region::set_length_internal (len); Region::set_length_internal (len);
update_length_beats (); update_length_beats ();
} }
void void
MidiRegion::update_length_beats () MidiRegion::update_length_beats ()
{ {
BeatsFramesConverter converter (_session.tempo_map(), _position); BeatsFramesConverter converter (_session.tempo_map(), _position);
_length_beats = converter.from (_length); _length_beats = converter.from (_length);
} }
void void
MidiRegion::set_position_internal (framepos_t pos, bool allow_bbt_recompute) MidiRegion::set_position_internal (framepos_t pos, bool allow_bbt_recompute)
{ {
Region::set_position_internal (pos, allow_bbt_recompute); Region::set_position_internal (pos, allow_bbt_recompute);
/* zero length regions don't exist - so if _length_beats is zero, this object /* zero length regions don't exist - so if _length_beats is zero, this object
is under construction. is under construction.
*/ */
if (_length_beats) { if (_length_beats) {
/* leave _length_beats alone, and change _length to reflect the state of things /* leave _length_beats alone, and change _length to reflect the state of things
at the new position (tempo map may dictate a different number of frames at the new position (tempo map may dictate a different number of frames
*/ */
BeatsFramesConverter converter (_session.tempo_map(), _position); BeatsFramesConverter converter (_session.tempo_map(), _position);
Region::set_length_internal (converter.to (_length_beats)); Region::set_length_internal (converter.to (_length_beats));
} }
} }
framecnt_t framecnt_t
@ -247,11 +249,11 @@ MidiRegion::set_state (const XMLNode& node, int version)
{ {
int ret = Region::set_state (node, version); int ret = Region::set_state (node, version);
if (ret == 0) { if (ret == 0) {
update_length_beats (); update_length_beats ();
} }
return ret; return ret;
} }
void void
@ -327,7 +329,7 @@ MidiRegion::model_changed ()
void void
MidiRegion::model_contents_changed () MidiRegion::model_contents_changed ()
{ {
send_change (PropertyChange (Properties::midi_data)); send_change (PropertyChange (Properties::midi_data));
} }
void void
@ -358,7 +360,7 @@ MidiRegion::model_automation_state_changed (Evoral::Parameter const & p)
void void
MidiRegion::fix_negative_start () MidiRegion::fix_negative_start ()
{ {
BeatsFramesConverter c (_session.tempo_map(), _position); BeatsFramesConverter c (_session.tempo_map(), _position);
model()->insert_silence_at_start (c.from (-_start)); model()->insert_silence_at_start (c.from (-_start));
_start = 0; _start = 0;

110
libs/ardour/midi_source.cc
View file

@ -168,15 +168,15 @@ MidiSource::set_state (const XMLNode& node, int /*version*/)
bool bool
MidiSource::empty () const MidiSource::empty () const
{ {
return _length_beats == 0; return _length_beats == 0;
} }
framecnt_t framecnt_t
MidiSource::length (framepos_t pos) const MidiSource::length (framepos_t pos) const
{ {
if (_length_beats == 0) { if (_length_beats == 0) {
return 0; return 0;
} }
BeatsFramesConverter converter(_session.tempo_map(), pos); BeatsFramesConverter converter(_session.tempo_map(), pos);
return converter.to(_length_beats); return converter.to(_length_beats);
@ -200,7 +200,7 @@ framecnt_t
MidiSource::midi_read (Evoral::EventSink<framepos_t>& dst, framepos_t source_start, MidiSource::midi_read (Evoral::EventSink<framepos_t>& dst, framepos_t source_start,
framepos_t start, framecnt_t cnt, framepos_t start, framecnt_t cnt,
MidiStateTracker* tracker, MidiStateTracker* tracker,
std::set<Evoral::Parameter> const & filtered) const std::set<Evoral::Parameter> const & filtered) const
{ {
Glib::Mutex::Lock lm (_lock); Glib::Mutex::Lock lm (_lock);
@ -298,86 +298,84 @@ MidiSource::mark_streaming_write_completed ()
boost::shared_ptr<MidiSource> boost::shared_ptr<MidiSource>
MidiSource::clone (Evoral::MusicalTime begin, Evoral::MusicalTime end) MidiSource::clone (Evoral::MusicalTime begin, Evoral::MusicalTime end)
{ {
string newname = PBD::basename_nosuffix(_name.val()); string newname = PBD::basename_nosuffix(_name.val());
string newpath; string newpath;
/* get a new name for the MIDI file we're going to write to /* get a new name for the MIDI file we're going to write to
*/ */
do { do {
newname = bump_name_once (newname, '-'); newname = bump_name_once (newname, '-');
/* XXX build path safely */ /* XXX build path safely */
newpath = _session.session_directory().midi_path().to_string() +"/"+ newname + ".mid"; newpath = _session.session_directory().midi_path().to_string() +"/"+ newname + ".mid";
} while (Glib::file_test (newpath, Glib::FILE_TEST_EXISTS)); } while (Glib::file_test (newpath, Glib::FILE_TEST_EXISTS));
boost::shared_ptr<MidiSource> newsrc = boost::dynamic_pointer_cast<MidiSource>( boost::shared_ptr<MidiSource> newsrc = boost::dynamic_pointer_cast<MidiSource>(
SourceFactory::createWritable(DataType::MIDI, _session, SourceFactory::createWritable(DataType::MIDI, _session,
newpath, string(), false, _session.frame_rate())); newpath, string(), false, _session.frame_rate()));
newsrc->set_timeline_position(_timeline_position); newsrc->set_timeline_position(_timeline_position);
newsrc->copy_interpolation_from (this); newsrc->copy_interpolation_from (this);
newsrc->copy_automation_state_from (this); newsrc->copy_automation_state_from (this);
if (_model) { if (_model) {
if (begin == Evoral::MinMusicalTime && end == Evoral::MaxMusicalTime) { if (begin == Evoral::MinMusicalTime && end == Evoral::MaxMusicalTime) {
_model->write_to (newsrc); _model->write_to (newsrc);
} else { } else {
_model->write_section_to (newsrc, begin, end); _model->write_section_to (newsrc, begin, end);
} }
} else { } else {
error << string_compose (_("programming error: %1"), X_("no model for MidiSource during ::clone()")); error << string_compose (_("programming error: %1"), X_("no model for MidiSource during ::clone()"));
return boost::shared_ptr<MidiSource>(); return boost::shared_ptr<MidiSource>();
} }
newsrc->flush_midi(); newsrc->flush_midi();
/* force a reload of the model if the range is partial */ /* force a reload of the model if the range is partial */
if (begin != Evoral::MinMusicalTime || end != Evoral::MaxMusicalTime) { if (begin != Evoral::MinMusicalTime || end != Evoral::MaxMusicalTime) {
newsrc->load_model (true, true); newsrc->load_model (true, true);
} else { } else {
newsrc->set_model (_model); newsrc->set_model (_model);
} }
return newsrc; return newsrc;
} }
void void
MidiSource::session_saved() MidiSource::session_saved()
{ {
/* this writes a copy of the data to disk. /* this writes a copy of the data to disk.
XXX do we need to do this every time? XXX do we need to do this every time?
*/ */
if (_model && _model->edited()) { if (_model && _model->edited()) {
// if the model is edited, write its contents into
// the current source file (overwiting previous contents.
/* temporarily drop our reference to the model so that
as the model pushes its current state to us, we don't
try to update it.
*/
// if the model is edited, write its contents into boost::shared_ptr<MidiModel> mm = _model ;
// the current source file (overwiting previous contents. _model.reset ();
/* temporarily drop our reference to the model so that /* flush model contents to disk
as the model pushes its current state to us, we don't */
try to update it.
*/
boost::shared_ptr<MidiModel> mm = _model ; mm->sync_to_source ();
_model.reset ();
/* flush model contents to disk /* reacquire model */
*/
mm->sync_to_source (); _model = mm;
/* reacquire model */ } else {
flush_midi();
_model = mm; }
} else {
flush_midi();
}
} }
void void
@ -391,7 +389,7 @@ MidiSource::set_note_mode(NoteMode mode)
void void
MidiSource::drop_model () MidiSource::drop_model ()
{ {
_model.reset(); _model.reset();
ModelChanged (); /* EMIT SIGNAL */ ModelChanged (); /* EMIT SIGNAL */
} }

19
libs/ardour/midi_state_tracker.cc
View file

@ -140,21 +140,20 @@ MidiStateTracker::resolve_notes (MidiSource& src, Evoral::MusicalTime time)
return; return;
} }
/* NOTE: the src must be locked */ /* NOTE: the src must be locked */
for (int channel = 0; channel < 16; ++channel) { for (int channel = 0; channel < 16; ++channel) {
for (int note = 0; note < 128; ++note) { for (int note = 0; note < 128; ++note) {
while (_active_notes[note + 128 * channel]) { while (_active_notes[note + 128 * channel]) {
Evoral::MIDIEvent<Evoral::MusicalTime> ev ((MIDI_CMD_NOTE_OFF|channel), time, 3, 0, true); Evoral::MIDIEvent<Evoral::MusicalTime> ev ((MIDI_CMD_NOTE_OFF|channel), time, 3, 0, true);
ev.set_type (MIDI_CMD_NOTE_OFF); ev.set_type (MIDI_CMD_NOTE_OFF);
ev.set_channel (channel); ev.set_channel (channel);
ev.set_note (note); ev.set_note (note);
ev.set_velocity (0); ev.set_velocity (0);
src.append_event_unlocked_beats (ev); src.append_event_unlocked_beats (ev);
_active_notes[note + 128 * channel]--; _active_notes[note + 128 * channel]--;
/* don't stack events up at the same time /* don't stack events up at the same time */
*/ time += 1.0/128.0;
time += 1.0/128.0;
} }
} }
} }

132
libs/ardour/smf_source.cc
View file

@ -60,7 +60,7 @@ SMFSource::SMFSource (Session& s, const string& path, Source::Flag flags)
, _smf_last_read_end (0) , _smf_last_read_end (0)
, _smf_last_read_time (0) , _smf_last_read_time (0)
{ {
/* note that origin remains empty */ /* note that origin remains empty */
if (init(_path, false)) { if (init(_path, false)) {
throw failed_constructor (); throw failed_constructor ();
@ -131,7 +131,7 @@ SMFSource::read_unlocked (Evoral::EventSink<framepos_t>& destination, framepos_t
DEBUG_TRACE (DEBUG::MidiSourceIO, string_compose ("SMF read_unlocked: seek to %1\n", start)); DEBUG_TRACE (DEBUG::MidiSourceIO, string_compose ("SMF read_unlocked: seek to %1\n", start));
Evoral::SMF::seek_to_start(); Evoral::SMF::seek_to_start();
while (time < start_ticks) { while (time < start_ticks) {
gint ignored; gint ignored;
ret = read_event(&ev_delta_t, &ev_size, &ev_buffer, &ignored); ret = read_event(&ev_delta_t, &ev_size, &ev_buffer, &ignored);
if (ret == -1) { // EOF if (ret == -1) { // EOF
@ -148,7 +148,7 @@ SMFSource::read_unlocked (Evoral::EventSink<framepos_t>& destination, framepos_t
_smf_last_read_end = start + duration; _smf_last_read_end = start + duration;
while (true) { while (true) {
gint ignored; /* XXX don't ignore note id's ??*/ gint ignored; /* XXX don't ignore note id's ??*/
ret = read_event(&ev_delta_t, &ev_size, &ev_buffer, &ignored); ret = read_event(&ev_delta_t, &ev_size, &ev_buffer, &ignored);
if (ret == -1) { // EOF if (ret == -1) { // EOF
@ -250,7 +250,7 @@ SMFSource::write_unlocked (MidiRingBuffer<framepos_t>& source, framepos_t positi
ev.set(buf, size, time); ev.set(buf, size, time);
ev.set_event_type(EventTypeMap::instance().midi_event_type(ev.buffer()[0])); ev.set_event_type(EventTypeMap::instance().midi_event_type(ev.buffer()[0]));
ev.set_id (Evoral::next_event_id()); ev.set_id (Evoral::next_event_id());
if (!(ev.is_channel_event() || ev.is_smf_meta_event() || ev.is_sysex())) { if (!(ev.is_channel_event() || ev.is_smf_meta_event() || ev.is_sysex())) {
/*cerr << "SMFSource: WARNING: caller tried to write non SMF-Event of type " /*cerr << "SMFSource: WARNING: caller tried to write non SMF-Event of type "
@ -287,13 +287,13 @@ SMFSource::append_event_unlocked_beats (const Evoral::Event<double>& ev)
return; return;
} }
Evoral::event_id_t event_id; Evoral::event_id_t event_id;
if (ev.id() < 0) { if (ev.id() < 0) {
event_id = Evoral::next_event_id(); event_id = Evoral::next_event_id();
} else { } else {
event_id = ev.id(); event_id = ev.id();
} }
if (_model) { if (_model) {
_model->append (ev, event_id); _model->append (ev, event_id);
@ -330,28 +330,28 @@ SMFSource::append_event_unlocked_frames (const Evoral::Event<framepos_t>& ev, fr
} }
BeatsFramesConverter converter(_session.tempo_map(), position); BeatsFramesConverter converter(_session.tempo_map(), position);
const double ev_time_beats = converter.from(ev.time()); const double ev_time_beats = converter.from(ev.time());
Evoral::event_id_t event_id; Evoral::event_id_t event_id;
if (ev.id() < 0) { if (ev.id() < 0) {
event_id = Evoral::next_event_id(); event_id = Evoral::next_event_id();
} else { } else {
event_id = ev.id(); event_id = ev.id();
} }
if (_model) { if (_model) {
const Evoral::Event<double> beat_ev (ev.event_type(), const Evoral::Event<double> beat_ev (ev.event_type(),
ev_time_beats, ev_time_beats,
ev.size(), ev.size(),
(uint8_t*)ev.buffer()); (uint8_t*)ev.buffer());
_model->append (beat_ev, event_id); _model->append (beat_ev, event_id);
} }
_length_beats = max(_length_beats, ev_time_beats); _length_beats = max(_length_beats, ev_time_beats);
const framepos_t delta_time_frames = ev.time() - _last_ev_time_frames; const framepos_t delta_time_frames = ev.time() - _last_ev_time_frames;
const double delta_time_beats = converter.from(delta_time_frames); const double delta_time_beats = converter.from(delta_time_frames);
const uint32_t delta_time_ticks = (uint32_t)(lrint(delta_time_beats * (double)ppqn())); const uint32_t delta_time_ticks = (uint32_t)(lrint(delta_time_beats * (double)ppqn()));
Evoral::SMF::append_event_delta(delta_time_ticks, ev.size(), ev.buffer(), event_id); Evoral::SMF::append_event_delta(delta_time_ticks, ev.size(), ev.buffer(), event_id);
_last_ev_time_frames = ev.time(); _last_ev_time_frames = ev.time();
@ -363,9 +363,9 @@ SMFSource::append_event_unlocked_frames (const Evoral::Event<framepos_t>& ev, fr
XMLNode& XMLNode&
SMFSource::get_state () SMFSource::get_state ()
{ {
XMLNode& node = MidiSource::get_state(); XMLNode& node = MidiSource::get_state();
node.add_property (X_("origin"), _origin); node.add_property (X_("origin"), _origin);
return node; return node;
} }
int int
@ -412,9 +412,9 @@ SMFSource::mark_streaming_write_completed ()
Evoral::SMF::end_write (); Evoral::SMF::end_write ();
/* data in the file now, not removable */ /* data in the file now, not removable */
mark_nonremovable (); mark_nonremovable ();
} }
bool bool
@ -456,63 +456,63 @@ SMFSource::load_model (bool lock, bool force_reload)
uint32_t size = 0; uint32_t size = 0;
uint8_t* buf = NULL; uint8_t* buf = NULL;
int ret; int ret;
gint event_id; gint event_id;
bool have_event_id = false; bool have_event_id = false;
while ((ret = read_event (&delta_t, &size, &buf, &event_id)) >= 0) { while ((ret = read_event (&delta_t, &size, &buf, &event_id)) >= 0) {
time += delta_t; time += delta_t;
if (ret == 0) { if (ret == 0) {
/* meta-event : did we get an event ID ? /* meta-event : did we get an event ID ?
*/ */
if (event_id >= 0) { if (event_id >= 0) {
have_event_id = true; have_event_id = true;
} }
continue; continue;
} }
if (ret > 0) { if (ret > 0) {
/* not a meta-event */ /* not a meta-event */
ev.set (buf, size, time / (double)ppqn()); ev.set (buf, size, time / (double)ppqn());
ev.set_event_type(EventTypeMap::instance().midi_event_type(buf[0])); ev.set_event_type(EventTypeMap::instance().midi_event_type(buf[0]));
if (!have_event_id) { if (!have_event_id) {
event_id = Evoral::next_event_id(); event_id = Evoral::next_event_id();
} }
#ifndef NDEBUG #ifndef NDEBUG
std::string ss; std::string ss;
for (uint32_t xx = 0; xx < size; ++xx) { for (uint32_t xx = 0; xx < size; ++xx) {
char b[8]; char b[8];
snprintf (b, sizeof (b), "0x%x ", buf[xx]); snprintf (b, sizeof (b), "0x%x ", buf[xx]);
ss += b; ss += b;
} }
DEBUG_TRACE (DEBUG::MidiSourceIO, string_compose ("SMF %6 load model delta %1, time %2, size %3 buf %4, type %5\n", DEBUG_TRACE (DEBUG::MidiSourceIO, string_compose ("SMF %6 load model delta %1, time %2, size %3 buf %4, type %5\n",
delta_t, time, size, ss , ev.event_type(), name())); delta_t, time, size, ss , ev.event_type(), name()));
#endif #endif
_model->append (ev, event_id); _model->append (ev, event_id);
if (ev.size() > scratch_size) { if (ev.size() > scratch_size) {
scratch_size = ev.size(); scratch_size = ev.size();
} }
ev.size() = scratch_size; // ensure read_event only allocates if necessary ev.size() = scratch_size; // ensure read_event only allocates if necessary
_length_beats = max(_length_beats, ev.time()); _length_beats = max(_length_beats, ev.time());
} }
/* event ID's must immediately precede the event they are for /* event ID's must immediately precede the event they are for
*/ */
have_event_id = false; have_event_id = false;
} }
_model->end_write(false); _model->end_write(false);
@ -533,18 +533,18 @@ SMFSource::destroy_model ()
void void
SMFSource::flush_midi () SMFSource::flush_midi ()
{ {
if (!writable()) { if (!writable()) {
return; return;
} }
Evoral::SMF::end_write(); Evoral::SMF::end_write();
/* data in the file means its no longer removable */ /* data in the file means its no longer removable */
mark_nonremovable (); mark_nonremovable ();
} }
void void
SMFSource::set_path (const string& p) SMFSource::set_path (const string& p)
{ {
FileSource::set_path (p); FileSource::set_path (p);
SMF::set_path (_path); SMF::set_path (_path);
} }