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

media/audio/win/audio_low_latency_input_win.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/win/audio_low_latency_input_win.h"
 
 #include <memory>
 
 #include "base/logging.h"
 #include "base/metrics/histogram_macros.h"
@@ skipping 308 matching lines @@
   // 1) The recorded buffer size is smaller, or does not match exactly with,
   //    the selected packet size used in each callback.
   // 2) The selected buffer size is larger than the recorded buffer size in
   //    each event.
   size_t buffer_frame_index = 0;
   size_t capture_buffer_size =
       std::max(2 * endpoint_buffer_size_frames_ * frame_size_,
                2 * packet_size_frames_ * frame_size_);
   std::unique_ptr<uint8_t[]> capture_buffer(new uint8_t[capture_buffer_size]);
 
-  LARGE_INTEGER now_count = {};
   bool recording = true;
   bool error = false;
   double volume = GetVolume();
   HANDLE wait_array[2] = {stop_capture_event_.Get(),
                           audio_samples_ready_event_.Get()};
 
   base::win::ScopedComPtr<IAudioClock> audio_clock;
   audio_client_->GetService(__uuidof(IAudioClock), audio_clock.ReceiveVoid());
 
   while (recording && !error) {
@@ skipping 54 matching lines @@
           buffer_frame_index += num_frames_to_read;
         }
 
         hr = audio_capture_client_->ReleaseBuffer(num_frames_to_read);
         DLOG_IF(ERROR, FAILED(hr)) << "Failed to release capture buffer";
 
         // Derive a delay estimate for the captured audio packet.
         // The value contains two parts (A+B), where A is the delay of the
         // first audio frame in the packet and B is the extra delay
         // contained in any stored data. Unit is in audio frames.
-        QueryPerformanceCounter(&now_count);
         // first_audio_frame_timestamp will be 0 if we didn't get a timestamp.
+
+        base::TimeTicks delay_timestamp =
+            base::TimeTicks::FromQPCValue(first_audio_frame_timestamp);
+
+        // TODO(dalecurtis): This is all wrong and brain is mush, fix tomorrow.

[miu, 2017/02/12 04:21:37]

It may help to consult what was done for this same change in the
audio_low_latency_OUTPUT_win.cc. You may also want to loop-in the developer that
made the output interface bytes-->TimeXXX changes to take a quick look at this
CL.

+        // Needs to compensate for input buffers from past cycles.
+        base::TimeDelta delay =
+            first_audio_frame_timestamp
+                ? base::TimeTicks::Now() - delay_timestamp
+                : base::TimeDelta::FromSecondsD(
+                      num_frames_to_read /
+                      static_cast<double>(format_.nSamplesPerSec));
+
+#if 0
         double audio_delay_frames =
             first_audio_frame_timestamp == 0
                 ? num_frames_to_read
                 : ((perf_count_to_100ns_units_ * now_count.QuadPart -
                     first_audio_frame_timestamp) /
                    10000.0) *
                           ms_to_frame_count_ +
                       buffer_frame_index - num_frames_to_read;
-
+#endif
         // Get a cached AGC volume level which is updated once every second
         // on the audio manager thread. Note that, |volume| is also updated
         // each time SetVolume() is called through IPC by the render-side AGC.
         GetAgcVolume(&volume);
 
         // Deliver captured data to the registered consumer using a packet
         // size which was specified at construction.
-        uint32_t delay_frames = static_cast<uint32_t>(audio_delay_frames + 0.5);
         while (buffer_frame_index >= packet_size_frames_) {
           // Copy data to audio bus to match the OnData interface.
           uint8_t* audio_data =
               reinterpret_cast<uint8_t*>(capture_buffer.get());
           audio_bus_->FromInterleaved(audio_data, audio_bus_->frames(),
                                       format_.wBitsPerSample / 8);
 
           // Deliver data packet, delay estimation and volume level to
           // the user.
-          sink_->OnData(this, audio_bus_.get(), delay_frames * frame_size_,
-                        volume);
+          sink_->OnData(this, audio_bus_.get(), delay, delay_timestamp, volume);
 
           // Store parts of the recorded data which can't be delivered
           // using the current packet size. The stored section will be used
           // either in the next while-loop iteration or in the next
           // capture event.
           // TODO(tommi): If this data will be used in the next capture
           // event, we will report incorrect delay estimates because
           // we'll use the one for the captured data that time around
           // (i.e. in the future).
           memmove(&capture_buffer[0], &capture_buffer[packet_size_bytes_],
                   (buffer_frame_index - packet_size_frames_) * frame_size_);
 
           DCHECK_GE(buffer_frame_index, packet_size_frames_);
           buffer_frame_index -= packet_size_frames_;
-          if (delay_frames > packet_size_frames_) {
-            delay_frames -= packet_size_frames_;
-          } else {
-            delay_frames = 0;
-          }
         }
       } break;
       default:
         error = true;
         break;
     }
   }
 
   if (recording && error) {
     // TODO(henrika): perhaps it worth improving the cleanup here by e.g.
@@ skipping 269 matching lines @@
   return hr;
 }
 
 void WASAPIAudioInputStream::ReportOpenResult() const {
   DCHECK(!opened_);  // This method must be called before we set this flag.
   UMA_HISTOGRAM_ENUMERATION("Media.Audio.Capture.Win.Open", open_result_,
                             OPEN_RESULT_MAX + 1);
 }
 
 }  // namespace media