fix (no)use of offset in AudioEngine::get_sync_offset()

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

diff --git a/libs/ardour/audio_diskstream.cc b/libs/ardour/audio_diskstream.cc
index 1e0e13a276d7966d315f5a46a52a767fb9b3e061..5c00f10f48fd4aee8c769c7fca071d5c8c712119 100644 (file)
--- a/libs/ardour/audio_diskstream.cc
+++ b/libs/ardour/audio_diskstream.cc
@@ -388,7 +388,7 @@ AudioDiskstream::use_destructive_playlist ()
 }
 
 void
-AudioDiskstream::check_record_status (nframes_t transport_frame, nframes_t nframes, bool can_record)
+AudioDiskstream::check_record_status (nframes_t transport_frame, nframes_t /*nframes*/, bool can_record)
 {
        int possibly_recording;
        int rolling;
@@ -818,7 +818,6 @@ AudioDiskstream::process_varispeed_playback(nframes_t nframes, boost::shared_ptr
 {
          ChannelList::iterator chan;
        
-               /*
                interpolation.set_speed (_target_speed);
                
                int channel = 0;
@@ -826,74 +825,14 @@ AudioDiskstream::process_varispeed_playback(nframes_t nframes, boost::shared_ptr
                        ChannelInfo* chaninfo (*chan);
        
                        playback_distance = interpolation.interpolate (
-                                       channel, nframes, chaninfo->current_playback_buffer, chaninfo->speed_buffer); 
+                                       channel, nframes, chaninfo->current_playback_buffer, chaninfo->speed_buffer);
+                                       
+                       chaninfo->current_playback_buffer = chaninfo->speed_buffer;
                }
-               */
-         
-         // the idea behind phase is that when the speed is not 1.0, we have to 
-         // interpolate between samples and then we have to store where we thought we were. 
-         // rather than being at sample N or N+1, we were at N+0.8792922
-         // so the "phase" element, if you want to think about this way, 
-         // varies from 0 to 1, representing the "offset" between samples
-         uint64_t    phase = interpolation.get_last_phase();
-         
-         interpolation.set_speed (_target_speed);
-         
-         // acceleration
-         uint64_t    phi = interpolation.get_phi();
-         uint64_t    target_phi = interpolation.get_target_phi();
-         int64_t     phi_delta;
-         
-         // index in the input buffers
-         nframes_t   i = 0;
-
-         // Linearly interpolate into the speed buffer
-         // using 40.24 fixed point math
-         //
-         // Fixed point is just an integer with an implied scaling factor. 
-         // In 40.24 the scaling factor is 2^24 = 16777216,  
-         // so a value of 10*2^24 (in integer space) is equivalent to 10.0. 
-         //
-         // The advantage is that addition and modulus [like x = (x + y) % 2^40]  
-         // have no rounding errors and no drift, and just require a single integer add.
-         // (swh)
-         
-         const int64_t fractional_part_mask  = 0xFFFFFF;
-         const Sample  binary_scaling_factor = 16777216.0f;
-
-         // phi = fixed point speed
-         if (phi != target_phi) {
-                 phi_delta = ((int64_t)(target_phi - phi)) / nframes;
-         } else {
-                 phi_delta = 0;
-         }
-
-         for (chan = c->begin(); chan != c->end(); ++chan) {
-
-                 Sample fractional_phase_part;
-                 ChannelInfo* chaninfo (*chan);
-
-                 i = 0;
-                 phase = interpolation.get_last_phase();
-
-                 for (nframes_t outsample = 0; outsample < nframes; ++outsample) {
-                         i = phase >> 24;
-                         fractional_phase_part = (phase & fractional_part_mask) / binary_scaling_factor;
-                         chaninfo->speed_buffer[outsample] = 
-                                 chaninfo->current_playback_buffer[i] * (1.0f - fractional_phase_part) +
-                                 chaninfo->current_playback_buffer[i+1] * fractional_phase_part;
-                         phase += phi + phi_delta;
-                 }
-                 
-                 chaninfo->current_playback_buffer = chaninfo->speed_buffer;
-         }
-
-         playback_distance = i; // + 1;
-         interpolation.set_last_phase (phase & fractional_part_mask);
 }
 
 bool
-AudioDiskstream::commit (nframes_t nframes)
+AudioDiskstream::commit (nframes_t /*nframes*/)
 {
        bool need_butler = false;
 
@@ -1091,7 +1030,7 @@ AudioDiskstream::internal_playback_seek (nframes_t distance)
 
 int
 AudioDiskstream::read (Sample* buf, Sample* mixdown_buffer, float* gain_buffer, nframes_t& start, nframes_t cnt, 
-                      ChannelInfo* channel_info, int channel, bool reversed)
+                      ChannelInfo* /*channel_info*/, int channel, bool reversed)
 {
        nframes_t this_read = 0;
        bool reloop = false;
@@ -1425,7 +1364,7 @@ AudioDiskstream::_do_refill (Sample* mixdown_buffer, float* gain_buffer)
  * written at all unless @a force_flush is true.
  */
 int
-AudioDiskstream::do_flush (RunContext context, bool force_flush)
+AudioDiskstream::do_flush (RunContext /*context*/, bool force_flush)
 {
        uint32_t to_write;
        int32_t ret = 0;
@@ -1785,7 +1724,7 @@ AudioDiskstream::transport_looped (nframes_t transport_frame)
 }
 
 void
-AudioDiskstream::finish_capture (bool rec_monitors_input, boost::shared_ptr<ChannelList> c)
+AudioDiskstream::finish_capture (bool /*rec_monitors_input*/, boost::shared_ptr<ChannelList> c)
 {
        was_recording = false;
        
@@ -2120,7 +2059,7 @@ AudioDiskstream::use_new_write_source (uint32_t n)
 }
 
 void
-AudioDiskstream::reset_write_sources (bool mark_write_complete, bool force)
+AudioDiskstream::reset_write_sources (bool mark_write_complete, bool /*force*/)
 {
        ChannelList::iterator chan;
        boost::shared_ptr<ChannelList> c = channels.reader();
@@ -2181,7 +2120,7 @@ AudioDiskstream::rename_write_sources ()
 }
 
 void
-AudioDiskstream::set_block_size (nframes_t nframes)
+AudioDiskstream::set_block_size (nframes_t /*nframes*/)
 {
        if (_session.get_block_size() > speed_buffer_size) {
                speed_buffer_size = _session.get_block_size();