Express audio delay more precisely in frames rather than milliseconds.

media/audio/audio_output_device.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/audio_output_device.h"
 
 #include <stddef.h>
 #include <stdint.h>
+
+#include <cmath>
 #include <utility>
 
 #include "base/callback_helpers.h"
 #include "base/macros.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
 #include "media/audio/audio_output_controller.h"
 #include "media/base/limits.h"
@@ skipping 387 matching lines @@
             sizeof(AudioOutputBufferParameters) +
                 AudioBus::CalculateMemorySize(audio_parameters_));
 
   AudioOutputBuffer* buffer =
       reinterpret_cast<AudioOutputBuffer*>(shared_memory_.memory());
   output_bus_ = AudioBus::WrapMemory(audio_parameters_, buffer->audio);
 }
 
 // Called whenever we receive notifications about pending data.
 void AudioOutputDevice::AudioThreadCallback::Process(uint32_t pending_data) {
-  // Convert the number of pending bytes in the render buffer into milliseconds.
-  uint32_t audio_delay_milliseconds = pending_data / bytes_per_ms_;
+  // Convert the number of pending bytes in the render buffer into frames.
+  double frames_delayed = static_cast<double>(pending_data) / bytes_per_frame_;
 
   callback_num_++;
   TRACE_EVENT1("audio", "AudioOutputDevice::FireRenderCallback",
                "callback_num", callback_num_);
 
   // When playback starts, we get an immediate callback to Process to make sure
   // that we have some data, we'll get another one after the device is awake and
   // ingesting data, which is what we want to track with this trace.
   if (callback_num_ == 2) {
     TRACE_EVENT_ASYNC_END0("audio", "StartingPlayback", this);
   }
 
   // Read and reset the number of frames skipped.
   AudioOutputBuffer* buffer =
       reinterpret_cast<AudioOutputBuffer*>(shared_memory_.memory());
   uint32_t frames_skipped = buffer->params.frames_skipped;
   buffer->params.frames_skipped = 0;
 
+  DVLOG(4) << __FUNCTION__ << " pending_data:" << pending_data
+           << " frames_delayed(pre-round):" << frames_delayed
+           << " frames_skipped:" << frames_skipped;
+
   // Update the audio-delay measurement, inform about the number of skipped
   // frames, and ask client to render audio.  Since |output_bus_| is wrapping
   // the shared memory the Render() call is writing directly into the shared
   // memory.
-  render_callback_->Render(output_bus_.get(), audio_delay_milliseconds,
+  render_callback_->Render(output_bus_.get(), std::round(frames_delayed),
                            frames_skipped);
 }
 
 }  // namespace media