replace fixed-point linear interpolation with double-based version, thereby removing...

[ardour.git] / libs / ardour / smf_source.cc

diff --git a/libs/ardour/smf_source.cc b/libs/ardour/smf_source.cc
index 34947f419aaf5da22cf63df2aa66970b4e5cba75..40848dc9edfe5c21a13de406551eddec08fa88f4 100644 (file)
--- a/libs/ardour/smf_source.cc
+++ b/libs/ardour/smf_source.cc
@@ -95,8 +95,8 @@ SMFSource::~SMFSource ()
 
 /** All stamps in audio frames */
 nframes_t
-SMFSource::read_unlocked (MidiRingBuffer<nframes_t>& dst, sframes_t position,
-               sframes_t start, nframes_t dur,
+SMFSource::read_unlocked (MidiRingBuffer<nframes_t>& destination, sframes_t source_start,
+               sframes_t start, nframes_t duration,
                sframes_t stamp_offset, sframes_t negative_stamp_offset) const
 {
        int      ret  = 0;
@@ -112,24 +112,24 @@ SMFSource::read_unlocked (MidiRingBuffer<nframes_t>& dst, sframes_t position,
 
        size_t scratch_size = 0; // keep track of scratch to minimize reallocs
        
-       BeatsFramesConverter converter(_session, position);
+       BeatsFramesConverter converter(_session, source_start);
 
        const uint64_t start_ticks = (uint64_t)(converter.from(start) * ppqn());
 
        if (_last_read_end == 0 || start != _last_read_end) {
-               cerr << "SMFSource::read_unlocked seeking to " << start << endl;
+               //cerr << "SMFSource::read_unlocked seeking to " << start << endl;
                Evoral::SMF::seek_to_start();
                while (time < start_ticks) {
                        ret = read_event(&ev_delta_t, &ev_size, &ev_buffer);
                        if (ret == -1) { // EOF
-                               _last_read_end = start + dur;
-                               return dur;
+                               _last_read_end = start + duration;
+                               return duration;
                        }
                        time += ev_delta_t; // accumulate delta time
                }
        }
        
-       _last_read_end = start + dur;
+       _last_read_end = start + duration;
 
        while (true) {
                ret = read_event(&ev_delta_t, &ev_size, &ev_buffer);
@@ -148,8 +148,8 @@ SMFSource::read_unlocked (MidiRingBuffer<nframes_t>& dst, sframes_t position,
                assert(time >= start_ticks);
                const sframes_t ev_frame_time = converter.to(time / (double)ppqn()) + stamp_offset;
 
-               if (ev_frame_time < start + dur) {
-                       dst.write(ev_frame_time - negative_stamp_offset, ev_type, ev_size, ev_buffer);
+               if (ev_frame_time < start + duration) {
+                       destination.write(ev_frame_time - negative_stamp_offset, ev_type, ev_size, ev_buffer);
                } else {
                        break;
                }
@@ -162,12 +162,12 @@ SMFSource::read_unlocked (MidiRingBuffer<nframes_t>& dst, sframes_t position,
                ev_size = scratch_size; // ensure read_event only allocates if necessary
        }
        
-       return dur;
+       return duration;
 }
 
 /** All stamps in audio frames */
 nframes_t
-SMFSource::write_unlocked (MidiRingBuffer<nframes_t>& src, sframes_t position, nframes_t dur)
+SMFSource::write_unlocked (MidiRingBuffer<nframes_t>& source, sframes_t position, nframes_t duration)
 {
        _write_data_count = 0;
                
@@ -185,12 +185,12 @@ SMFSource::write_unlocked (MidiRingBuffer<nframes_t>& src, sframes_t position, n
        Evoral::MIDIEvent<nframes_t> ev;
 
        while (true) {
-               bool ret = src.peek_time(&time);
-               if (!ret || time > _last_write_end + dur) {
+               bool ret = source.peek_time(&time);
+               if (!ret || time > _last_write_end + duration) {
                        break;
                }
 
-               ret = src.read_prefix(&time, &type, &size);
+               ret = source.read_prefix(&time, &type, &size);
                if (!ret) {
                        cerr << "ERROR: Unable to read event prefix, corrupt MIDI ring buffer" << endl;
                        break;
@@ -201,7 +201,7 @@ SMFSource::write_unlocked (MidiRingBuffer<nframes_t>& src, sframes_t position, n
                        buf = (uint8_t*)realloc(buf, size);
                }
 
-               ret = src.read_contents(size, buf);
+               ret = source.read_contents(size, buf);
                if (!ret) {
                        cerr << "ERROR: Read time/size but not buffer, corrupt MIDI ring buffer" << endl;
                        break;
@@ -228,9 +228,9 @@ SMFSource::write_unlocked (MidiRingBuffer<nframes_t>& src, sframes_t position, n
        Evoral::SMF::flush();
        free(buf);
 
-       ViewDataRangeReady(position + _last_write_end, dur); /* EMIT SIGNAL */
+       ViewDataRangeReady(position + _last_write_end, duration); /* EMIT SIGNAL */
 
-       return dur;
+       return duration;
 }
                
 
@@ -279,7 +279,6 @@ SMFSource::append_event_unlocked_frames (const Evoral::Event<nframes_t>& ev, sfr
                        name().c_str(), ev.time(), ev.size()); 
        for (size_t i=0; i < ev.size(); ++i) printf("%X ", ev.buffer()[i]); printf("\n");*/
        
-       assert(ev.time() >= 0);
        if (ev.time() < _last_ev_time_frames) {
                cerr << "SMFSource: Warning: Skipping event with non-monotonic time" << endl;
                return;
@@ -375,10 +374,10 @@ SMFSource::load_model (bool lock, bool force_reload)
 
        if (! _model) {
                _model = boost::shared_ptr<MidiModel>(new MidiModel(this));
-               cerr << _name << " loaded new model " << _model.get() << endl;
+               //cerr << _name << " loaded new model " << _model.get() << endl;
        } else {
-               cerr << _name << " reloading model " << _model.get()
-                       << " (" << _model->n_notes() << " notes)" <<endl;
+               /*cerr << _name << " reloading model " << _model.get()
+                       << " (" << _model->n_notes() << " notes)" << endl;*/
                _model->clear();
        }