Switch browser side audio capture path to use base time primitives.

media/audio/pulse/pulse_input.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "media/audio/pulse/pulse_input.h"
 
 #include <stdint.h>
 
 #include "base/logging.h"
 #include "media/audio/audio_device_description.h"
@@ skipping 252 matching lines @@
 
   if (s && stream->callback_ &&
       pa_stream_get_state(s) == PA_STREAM_FAILED) {
     stream->callback_->OnError(stream);
   }
 
   pa_threaded_mainloop_signal(stream->pa_mainloop_, 0);
 }
 
 void PulseAudioInputStream::ReadData() {
-  uint32_t hardware_delay = pulse::GetHardwareLatencyInBytes(
-      handle_, params_.sample_rate(), params_.GetBytesPerFrame());
+  base::TimeDelta hardware_delay = pulse::GetHardwareLatency(handle_);
 
   // Update the AGC volume level once every second. Note that,
   // |volume| is also updated each time SetVolume() is called
   // through IPC by the render-side AGC.
   // We disregard the |normalized_volume| from GetAgcVolume()
   // and use the value calculated by |volume_|.
   double normalized_volume = 0.0;
   GetAgcVolume(&normalized_volume);
   normalized_volume = volume_ / GetMaxVolume();
 
@@ skipping 17 matching lines @@
     fifo_.Push(data, number_of_frames, params_.bits_per_sample() / 8);
 
     // Checks if we still have data.
     pa_stream_drop(handle_);
   } while (pa_stream_readable_size(handle_) > 0);
 
   while (fifo_.available_blocks()) {
     const AudioBus* audio_bus = fifo_.Consume();
 
     // Compensate the audio delay caused by the FIFO.
-    hardware_delay += fifo_.GetAvailableFrames() * params_.GetBytesPerFrame();
-    callback_->OnData(this, audio_bus, hardware_delay, normalized_volume);
+    hardware_delay += base::TimeDelta::FromSecondsD(
+        fifo_.GetAvailableFrames() /
+        static_cast<double>(params_.sample_rate()));

[o1ka, 2017/02/10 13:28:50]

I'm not sure if this is a good enough approximation, if each fifo Push() has a
different latency.

And I don't really understand if and how pulse::GetHardwareLatency() and/or
other calculations take into account Sleep() call at l.320.

Comments would be very helpful.

[DaleCurtis, 2017/02/11 01:43:13]

It's a good question, the answer is they don't. I've moved them inside the loop
so they are correctly compensating. Probably this code can be removed now that
we have a circular buffer at the process boundary.

+    callback_->OnData(this, audio_bus, hardware_delay, base::TimeTicks::Now(),
+                      normalized_volume);
 
     // Sleep 5ms to wait until render consumes the data in order to avoid
     // back to back OnData() method.
     if (fifo_.available_blocks())
       base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(5));
   }
 
   pa_threaded_mainloop_signal(pa_mainloop_, 0);
 }
 
 bool PulseAudioInputStream::GetSourceInformation(pa_source_info_cb_t callback) {
   AutoPulseLock auto_lock(pa_mainloop_);
   if (!handle_)
     return false;
 
   size_t index = pa_stream_get_device_index(handle_);
   pa_operation* operation =
       pa_context_get_source_info_by_index(pa_context_, index, callback, this);
   WaitForOperationCompletion(pa_mainloop_, operation);
   return true;
 }
 
 }  // namespace media