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

media/audio/mac/audio_low_latency_input_mac.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/mac/audio_low_latency_input_mac.h"
 #include <CoreServices/CoreServices.h>
 #include <mach/mach.h>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 232 matching lines @@
     const AudioParameters& input_params,
     AudioDeviceID audio_device_id,
     const AudioManager::LogCallback& log_callback)
     : manager_(manager),
       number_of_frames_(input_params.frames_per_buffer()),
       number_of_frames_provided_(0),
       io_buffer_frame_size_(0),
       sink_(nullptr),
       audio_unit_(0),
       input_device_id_(audio_device_id),
-      hardware_latency_frames_(0),
       number_of_channels_in_frame_(0),
       fifo_(input_params.channels(),
             number_of_frames_,
             kNumberOfBlocksBufferInFifo),
       input_callback_is_active_(false),
       start_was_deferred_(false),
       buffer_size_was_changed_(false),
       audio_unit_render_has_worked_(false),
       device_listener_is_active_(false),
       last_sample_time_(0.0),
@@ skipping 246 matching lines @@
   // Finally, initialize the audio unit and ensure that it is ready to render.
   // Allocates memory according to the maximum number of audio frames
   // it can produce in response to a single render call.
   result = AudioUnitInitialize(audio_unit_);
   if (result != noErr) {
     HandleError(result);
     return false;
   }
 
   // The hardware latency is fixed and will not change during the call.
-  hardware_latency_frames_ = GetHardwareLatency();
+  hardware_latency_ = GetHardwareLatency();
 
   // The master channel is 0, Left and right are channels 1 and 2.
   // And the master channel is not counted in |number_of_channels_in_frame_|.
   number_of_channels_in_frame_ = GetNumberOfChannelsFromStream();
 
   return true;
 }
 
 void AUAudioInputStream::Start(AudioInputCallback* callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 422 matching lines @@
   UpdateCaptureTimestamp(time_stamp);
   last_number_of_frames_ = number_of_frames;
 
   // TODO(grunell): We'll only care about the first buffer size change, any
   // further changes will be ignored. This is in line with output side stats.
   // It would be nice to have all changes reflected in UMA stats.
   if (number_of_frames != number_of_frames_ && number_of_frames_provided_ == 0)
     number_of_frames_provided_ = number_of_frames;
 
   // Update the capture latency.
-  double capture_latency_frames = GetCaptureLatency(time_stamp);
+  base::TimeDelta capture_latency = GetCaptureLatency(time_stamp);
+  base::TimeDelta delay_timestamp = base::TimeTicks::Now();
 
   // The AGC volume level is updated once every second on a separate thread.
   // Note that, |volume| is also updated each time SetVolume() is called
   // through IPC by the render-side AGC.
   double normalized_volume = 0.0;
   GetAgcVolume(&normalized_volume);
 
   AudioBuffer& buffer = io_data->mBuffers[0];
   uint8_t* audio_data = reinterpret_cast<uint8_t*>(buffer.mData);
-  uint32_t capture_delay_bytes = static_cast<uint32_t>(
-      (capture_latency_frames + 0.5) * format_.mBytesPerFrame);
   DCHECK(audio_data);
   if (!audio_data)
     return kAudioUnitErr_InvalidElement;
 
   // Dynamically increase capacity of the FIFO to handle larger buffers from
   // CoreAudio. This can happen in combination with Apple Thunderbolt Displays
   // when the Display Audio is used as capture source and the cable is first
   // remove and then inserted again.
   // See http://www.crbug.com/434681 for details.
   if (static_cast<int>(number_of_frames) > fifo_.GetUnfilledFrames()) {
     // Derive required increase in number of FIFO blocks. The increase is
     // typically one block.
     const int blocks =
         static_cast<int>((number_of_frames - fifo_.GetUnfilledFrames()) /
                          number_of_frames_) + 1;
     DLOG(WARNING) << "Increasing FIFO capacity by " << blocks << " blocks";
     TRACE_EVENT_INSTANT1("audio", "Increasing FIFO capacity",
                          TRACE_EVENT_SCOPE_THREAD, "increased by", blocks);
     fifo_.IncreaseCapacity(blocks);
   }
 
   // Copy captured (and interleaved) data into FIFO.
   fifo_.Push(audio_data, number_of_frames, format_.mBitsPerChannel / 8);

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

Shouldn't we push latency and timestamp info the FIFO together with the data?

 
   // Consume and deliver the data when the FIFO has a block of available data.
   while (fifo_.available_blocks()) {
     const AudioBus* audio_bus = fifo_.Consume();
     DCHECK_EQ(audio_bus->frames(), static_cast<int>(number_of_frames_));
 
     // Compensate the audio delay caused by the FIFO.
     capture_delay_bytes += fifo_.GetAvailableFrames() * format_.mBytesPerFrame;

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

Hmm.. does it really compile? :)

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

Like I said, not done yet :)

-    sink_->OnData(this, audio_bus, capture_delay_bytes, normalized_volume);
+    sink_->OnData(this, audio_bus, capture_latency, delay_timestamp,

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

Shouldn't we adjust latency and timestamp values taking into account the fifo?

+                  normalized_volume);
   }
 
   return noErr;
 }
 
 void AUAudioInputStream::DevicePropertyChangedOnMainThread(
     const std::vector<UInt32>& properties) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(device_listener_is_active_);
   // Use property as key to a map and increase its value. We are not
@@ skipping 89 matching lines @@
       kAudioDevicePropertyNominalSampleRate, kAudioObjectPropertyScopeGlobal,
       kAudioObjectPropertyElementMaster};
   result = AudioObjectGetPropertyData(device_id, &nominal_sample_rate_address,
                                       0, 0, &info_size, &nominal_sample_rate);
   if (result != noErr)
     return 0.0;
 
   return static_cast<int>(nominal_sample_rate);
 }
 
-double AUAudioInputStream::GetHardwareLatency() {
+base::TimeDelta AUAudioInputStream::GetHardwareLatency() {
   if (!audio_unit_ || input_device_id_ == kAudioObjectUnknown) {
     DLOG(WARNING) << "Audio unit object is NULL or device ID is unknown";
-    return 0.0;
+    return base::TimeDelta();
   }
 
   // Get audio unit latency.
   Float64 audio_unit_latency_sec = 0.0;
   UInt32 size = sizeof(audio_unit_latency_sec);
   OSStatus result = AudioUnitGetProperty(
       audio_unit_, kAudioUnitProperty_Latency, kAudioUnitScope_Global, 0,
       &audio_unit_latency_sec, &size);
   OSSTATUS_DLOG_IF(WARNING, result != noErr, result)
       << "Could not get audio unit latency";
 
   // Get input audio device latency.
   AudioObjectPropertyAddress property_address = {
       kAudioDevicePropertyLatency, kAudioDevicePropertyScopeInput,
       kAudioObjectPropertyElementMaster};
   UInt32 device_latency_frames = 0;
   size = sizeof(device_latency_frames);
   result = AudioObjectGetPropertyData(input_device_id_, &property_address, 0,
                                       nullptr, &size, &device_latency_frames);
   DLOG_IF(WARNING, result != noErr) << "Could not get audio device latency.";
 
-  return static_cast<double>((audio_unit_latency_sec * format_.mSampleRate) +
-                             device_latency_frames);
+  return base::TimeDelta::FromSecondsD(
+      audio_unit_latency_sec +
+      device_latency_frames / static_cast<double>(format_.mSampleRate));
 }
 
-double AUAudioInputStream::GetCaptureLatency(
+base::TimeDelta AUAudioInputStream::GetCaptureLatency(
     const AudioTimeStamp* input_time_stamp) {
   // Get the delay between between the actual recording instant and the time
   // when the data packet is provided as a callback.
   UInt64 capture_time_ns =
       AudioConvertHostTimeToNanos(input_time_stamp->mHostTime);
   UInt64 now_ns = AudioConvertHostTimeToNanos(AudioGetCurrentHostTime());
-  double delay_frames = static_cast<double>(1e-9 * (now_ns - capture_time_ns) *
-                                            format_.mSampleRate);
 
   // Total latency is composed by the dynamic latency and the fixed
   // hardware latency.
-  return (delay_frames + hardware_latency_frames_);
+  return hardware_latency_ +
+         base::TimeDelta::FromMicroseconds((now_ns - capture_time_ns) /
+                                           kNanosecondsPerMicrosecond);
 }
 
 int AUAudioInputStream::GetNumberOfChannelsFromStream() {
   // Get the stream format, to be able to read the number of channels.
   AudioObjectPropertyAddress property_address = {
       kAudioDevicePropertyStreamFormat, kAudioDevicePropertyScopeInput,
       kAudioObjectPropertyElementMaster};
   AudioStreamBasicDescription stream_format;
   UInt32 size = sizeof(stream_format);
   OSStatus result = AudioObjectGetPropertyData(
@@ skipping 513 matching lines @@
 
   number_of_frames_provided_ = 0;
   glitches_detected_ = 0;
   last_sample_time_ = 0;
   last_number_of_frames_ = 0;
   total_lost_frames_ = 0;
   largest_glitch_frames_ = 0;
 }
 
 }  // namespace media