Reland: Make more media APIs aware of |delay| and |delay_timestamp|

media/audio/win/audio_output_win_unittest.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 <windows.h>
 #include <mmsystem.h>
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
@@ skipping 514 matching lines @@
   oas->Close();
 }
 
 // Simple source that uses a SyncSocket to retrieve the audio data
 // from a potentially remote thread.
 class SyncSocketSource : public AudioOutputStream::AudioSourceCallback {
  public:
   SyncSocketSource(base::SyncSocket* socket, const AudioParameters& params)
       : socket_(socket), params_(params) {
     // Setup AudioBus wrapping data we'll receive over the sync socket.
-    data_size_ = AudioBus::CalculateMemorySize(params);
+    packet_size_ = AudioBus::CalculateMemorySize(params);
     data_.reset(static_cast<float*>(
-        base::AlignedAlloc(data_size_, AudioBus::kChannelAlignment)));
-    audio_bus_ = AudioBus::WrapMemory(params, data_.get());
+        base::AlignedAlloc(packet_size_ + sizeof(AudioOutputBufferParameters),
+                           AudioBus::kChannelAlignment)));
+    audio_bus_ = AudioBus::WrapMemory(params, output_buffer()->audio);
   }
   ~SyncSocketSource() override {}
 
   // AudioSourceCallback::OnMoreData implementation:
   int OnMoreData(base::TimeDelta delay,
                  base::TimeTicks /* delay_timestamp */,
                  int /* prior_frames_skipped */,
                  AudioBus* dest) override {
-    uint32_t total_bytes_delay =
-        delay.InSecondsF() * params_.GetBytesPerSecond();
-    socket_->Send(&total_bytes_delay, sizeof(total_bytes_delay));
-    uint32_t size = socket_->Receive(data_.get(), data_size_);
+    uint32_t control_signal = 0;
+    socket_->Send(&control_signal, sizeof(control_signal));
+    output_buffer()->params.delay = delay.InMicroseconds();
+    uint32_t size = socket_->Receive(data_.get(), packet_size_);
+
     DCHECK_EQ(static_cast<size_t>(size) % sizeof(*audio_bus_->channel(0)), 0U);
     audio_bus_->CopyTo(dest);
     return audio_bus_->frames();
   }
+  int packet_size() const { return packet_size_; }
+  AudioOutputBuffer* output_buffer() const {
+    return reinterpret_cast<AudioOutputBuffer*>(data_.get());
+  }
 
   // AudioSourceCallback::OnError implementation:
   void OnError(AudioOutputStream* stream) override {}
 
  private:
   base::SyncSocket* socket_;
   const AudioParameters params_;
-  int data_size_;
+  int packet_size_;
   std::unique_ptr<float, base::AlignedFreeDeleter> data_;
   std::unique_ptr<AudioBus> audio_bus_;
 };
 
 struct SyncThreadContext {
   base::SyncSocket* socket;
   int sample_rate;
   int channels;
   int frames;
   double sine_freq;
   uint32_t packet_size_bytes;
-  int bytes_per_second;
+  AudioOutputBuffer* buffer;
 };
 
 // This thread provides the data that the SyncSocketSource above needs
 // using the other end of a SyncSocket. The protocol is as follows:
 //
 // SyncSocketSource ---send 4 bytes ------------> SyncSocketThread
 //                  <--- audio packet ----------
 //
 DWORD __stdcall SyncSocketThread(void* context) {
   SyncThreadContext& ctx = *(reinterpret_cast<SyncThreadContext*>(context));
 
   // Setup AudioBus wrapping data we'll pass over the sync socket.
   std::unique_ptr<float, base::AlignedFreeDeleter> data(static_cast<float*>(
       base::AlignedAlloc(ctx.packet_size_bytes, AudioBus::kChannelAlignment)));
   std::unique_ptr<AudioBus> audio_bus =
       AudioBus::WrapMemory(ctx.channels, ctx.frames, data.get());
 
   SineWaveAudioSource sine(1, ctx.sine_freq, ctx.sample_rate);
   const int kTwoSecFrames = ctx.sample_rate * 2;
 
-  uint32_t total_bytes_delay = 0;
-  int times = 0;
+  uint32_t control_signal = 0;
   for (int ix = 0; ix < kTwoSecFrames; ix += ctx.frames) {
-    if (ctx.socket->Receive(&total_bytes_delay, sizeof(total_bytes_delay)) == 0)
+    if (ctx.socket->Receive(&control_signal, sizeof(control_signal)) == 0)
       break;
-    if ((times > 0) && (total_bytes_delay < 1000)) __debugbreak();
-    base::TimeDelta delay = base::TimeDelta::FromSecondsD(
-        static_cast<double>(total_bytes_delay) / ctx.bytes_per_second);
+    base::TimeDelta delay =
+        base::TimeDelta::FromMicroseconds(ctx.buffer->params.delay);
     sine.OnMoreData(delay, base::TimeTicks::Now(), 0, audio_bus.get());

[chcunningham, 2016/11/30 20:54:28]

I'd send in the delay_timestamp as well. 

[Mikhail, 2016/12/01 12:22:29]

Done.

     ctx.socket->Send(data.get(), ctx.packet_size_bytes);
-    ++times;
   }
 
   return 0;
 }
 
 // Test the basic operation of AudioOutputStream used with a SyncSocket.
 // The emphasis is to verify that it is possible to feed data to the audio
 // layer using a source based on SyncSocket. In a real situation we would
 // go for the low-latency version in combination with SyncSocket, but to keep
 // the test more simple, AUDIO_PCM_LINEAR is utilized instead. The main
@@ skipping 15 matching lines @@
   ASSERT_TRUE(oas->Open());
 
   base::SyncSocket sockets[2];
   ASSERT_TRUE(base::SyncSocket::CreatePair(&sockets[0], &sockets[1]));
 
   SyncSocketSource source(&sockets[0], params);
 
   SyncThreadContext thread_context;
   thread_context.sample_rate = params.sample_rate();
   thread_context.sine_freq = 200.0;
-  thread_context.packet_size_bytes = AudioBus::CalculateMemorySize(params);
+  thread_context.packet_size_bytes = source.packet_size();
   thread_context.frames = params.frames_per_buffer();
   thread_context.channels = params.channels();
   thread_context.socket = &sockets[1];
-  thread_context.bytes_per_second = params.GetBytesPerSecond();
+  thread_context.buffer = source.output_buffer();
 
   HANDLE thread = ::CreateThread(NULL, 0, SyncSocketThread,
                                  &thread_context, 0, NULL);
 
   oas->Start(&source);
 
   ::WaitForSingleObject(thread, INFINITE);
   ::CloseHandle(thread);
 
   oas->Stop();
   oas->Close();
 }
 
 }  // namespace media