Fix a numerical issue in NetEq delay plotting

webrtc/modules/audio_coding/neteq/tools/neteq_delay_analyzer.cc

 /*
  *  Copyright (c) 2017 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #include "webrtc/modules/audio_coding/neteq/tools/neteq_delay_analyzer.h"
 
 #include <algorithm>
 #include <limits>
 #include <utility>
 
+#include <webrtc/base/checks.h>
+
 namespace webrtc {
 namespace test {
 namespace {
 // Helper function for NetEqDelayAnalyzer::CreateGraphs. Returns the
 // interpolated value of a function at the point x. Vector x_vec contains the
 // sample points, and y_vec contains the function values at these points. The
 // return value is a linear interpolation between y_vec values.
 double LinearInterpolate(double x,
                          const std::vector<int64_t>& x_vec,
                          const std::vector<int64_t>& y_vec) {
@@ skipping 81 matching lines @@
       nominal_get_audio_time_ms.begin() + 1, [](int64_t& x) { return x + 10; });
   RTC_DCHECK(
       std::is_sorted(get_audio_time_ms_.begin(), get_audio_time_ms_.end()));
 
   std::vector<double> rtp_timestamps_ms;
   double offset = std::numeric_limits<double>::max();
   TimestampUnwrapper unwrapper;
   // This loop traverses data_ and populates rtp_timestamps_ms as well as
   // calculates the base offset.
   for (auto& d : data_) {
-    rtp_timestamps_ms.push_back(unwrapper.Unwrap(d.first) /
-                                (last_sample_rate_hz_ / 1000.f));

[ivoc, 2017/06/12 10:19:19]

Are you sure this change has any effect? I tried this division for 8000.f,
16000.f, 32000.f and 48000.f, but the results are always exact (floats can
exactly represent all integers up to 16 million).

[hlundin-webrtc, 2017/06/12 11:54:58]

The machine instructions change quite a bit: https://godbolt.org/g/kfXdqX

If I understand correctly, the inner division by 1000 is transformed from a
floating point divss to a multiplication and shifts. The outer division is
changed from a floating point divss to an idiv. So, it does make a change.

With the old code, I get an alternating +/- offset of the results, which causes
a saw-tooth graph, without motivation. This change resolves that.

+    rtp_timestamps_ms.push_back(
+        unwrapper.Unwrap(d.first) /
+        rtc::CheckedDivExact(last_sample_rate_hz_, 1000));
     offset =
         std::min(offset, d.second.arrival_time_ms - rtp_timestamps_ms.back());
   }
 
   // Calculate send times in seconds for each packet. This is the (unwrapped)
   // RTP timestamp in ms divided by 1000.
   send_time_s->resize(rtp_timestamps_ms.size());
   std::transform(rtp_timestamps_ms.begin(), rtp_timestamps_ms.end(),
                  send_time_s->begin(), [rtp_timestamps_ms](double x) {
                    return (x - rtp_timestamps_ms[0]) / 1000.f;
@@ skipping 34 matching lines @@
     }
   }
   RTC_DCHECK(data_it == data_.end());
   RTC_DCHECK_EQ(send_time_s->size(), corrected_arrival_delay_ms->size());
   RTC_DCHECK_EQ(send_time_s->size(), playout_delay_ms->size());
   RTC_DCHECK_EQ(send_time_s->size(), target_delay_ms->size());
 }
 
 }  // namespace test
 }  // namespace webrtc