Binding media stream audio track to speech recognition [renderer]

content/renderer/speech_recognition_audio_source_provider_unittest.cc

+// Copyright 2014 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 "content/renderer/speech_recognition_audio_source_provider.h"
+
+#include "base/logging.h"
+#include "base/strings/utf_string_conversions.h"
+#include "content/renderer/media/media_stream_audio_source.h"
+#include "content/renderer/media/mock_media_constraint_factory.h"
+#include "content/renderer/media/rtc_media_constraints.h"
+#include "content/renderer/media/webrtc/mock_peer_connection_dependency_factory.h"
+#include "content/renderer/media/webrtc/webrtc_local_audio_track_adapter.h"
+#include "content/renderer/media/webrtc_audio_capturer.h"
+#include "content/renderer/media/webrtc_audio_device_impl.h"
+#include "content/renderer/media/webrtc_local_audio_source_provider.h"
+#include "content/renderer/media/webrtc_local_audio_track.h"
+#include "media/audio/audio_parameters.h"
+#include "media/base/audio_bus.h"
+#include "media/base/audio_capturer_source.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/WebKit/public/platform/WebMediaStreamTrack.h"
+
+namespace content {
+
+////////////////////////////////////////////////////////////////////////////////
+
+// Buffer to be shared between two fake sockets.

[burnik, 2014/09/12 12:09:12]

'fake' is interchangeable with 'mock' regarding sockets.

[burnik, 2014/09/15 15:00:07]

Done.

+struct SharedBuffer {
+  uint8 data[100000];

[no longer working on chromium, 2014/09/15 08:31:29]

noooooo, you can't allocate 100000 bytes in stack like this, change it the code
to use heap.

[burnik, 2014/09/15 15:00:07]

This is allocated on and owned by the FakeSpeechRecognizer.
Size is reduced to 8.

+  size_t start;
+  size_t length;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+// Fake socket used for Send/Receive.
+// Data is written and read from a shared buffer used as a FIFO and there is
+// no blocking. |OnSendCB| is used to trigger a |Receive| on the other socket.
+class MockSyncSocket : public base::SyncSocket {
+ public:
+  typedef base::Callback<void()> OnSendCB;
+
+  explicit MockSyncSocket(SharedBuffer* shared_buffer);
+  MockSyncSocket(SharedBuffer* shared_buffer, const OnSendCB& on_send_cb);
+
+  virtual size_t Send(const void* buffer, size_t length) OVERRIDE;
+  virtual size_t Receive(void* buffer, size_t length) OVERRIDE;
+
+  // When |in_failure_mode_| == true, the socket fails to send.
+  void SetFailureMode(bool in_failure_mode) {
+    in_failure_mode_ = in_failure_mode;
+  }
+
+ private:
+  SharedBuffer* buffer_;
+  const OnSendCB on_send_cb_;
+  bool in_failure_mode_;
+};
+
+MockSyncSocket::MockSyncSocket(SharedBuffer* buffer)
+    : buffer_(buffer), in_failure_mode_(false) {}
+
+MockSyncSocket::MockSyncSocket(SharedBuffer* buffer, const OnSendCB& on_send_cb)
+    : buffer_(buffer), on_send_cb_(on_send_cb), in_failure_mode_(false) {}
+
+size_t MockSyncSocket::Send(const void* buffer, size_t length) {
+  if (in_failure_mode_) return 0;
+  uint8* b = static_cast<uint8*>(const_cast<void*>(buffer));
+  for (size_t i = 0; i < length; i++, buffer_->length++)
+    buffer_->data[buffer_->start + buffer_->length] = b[i];
+  on_send_cb_.Run();
+  return length;
+}
+
+size_t MockSyncSocket::Receive(void* buffer, size_t length) {
+  uint8* b = static_cast<uint8*>(const_cast<void*>(buffer));
+  for (size_t i = buffer_->start; i < buffer_->length; i++, buffer_->start++)
+    b[i] = buffer_->data[buffer_->start];
+  return length;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+class FakeSpeechRecognizer {
+ public:
+  FakeSpeechRecognizer() : is_responsive_(true) {}
+  ~FakeSpeechRecognizer() {}
+
+  void Initialize(
+      const blink::WebMediaStreamTrack& track,
+      const media::AudioParameters& sink_params,
+      const SpeechRecognitionAudioSourceProvider::OnErrorCB& on_error_cb);
+
+  // TODO(burnik): Move from the recognizer to test.
+  SpeechRecognitionAudioSourceProvider* SourceProvider();
+
+  // Emulates a single iteraton of a thread receiving on the socket.
+  virtual void EmulateReceiveThreadLoopIteration();
+
+  // Used to simulate an unresponsive behaviour of the consumer.
+  void SimulateResponsiveness(bool is_responsive) {
+    is_responsive_ = is_responsive;
+  }
+  // Used to simulate a problem with sockets.
+  void SetFailureModeOnForeignSocket(bool in_failure_mode) {
+    DCHECK(foreign_socket_.get());
+    foreign_socket_->SetFailureMode(in_failure_mode);
+  }
+
+  uint32 buffer_index() { return *shared_buffer_index_; }
+  media::AudioBus* audio_bus() const { return audio_track_bus_.get(); }
+
+ private:
+  bool is_responsive_;
+  // Shared memory for the audio and synchronization.
+  scoped_ptr<base::SharedMemory> shared_memory_;
+
+  // Fake sockets shared buffer.
+  scoped_ptr<SharedBuffer> shared_buffer_;
+  scoped_ptr<MockSyncSocket> local_socket_;
+  scoped_ptr<MockSyncSocket> foreign_socket_;
+
+  // Audio bus wrapping the shared memory from the renderer.
+  scoped_ptr<media::AudioBus> audio_track_bus_;
+
+  uint32* shared_buffer_index_;
+  // Producer. TODO(burnik): this should be outside the recognizer.
+  scoped_ptr<SpeechRecognitionAudioSourceProvider> audio_source_provider_;
+};
+
+void FakeSpeechRecognizer::Initialize(
+    const blink::WebMediaStreamTrack& track,
+    const media::AudioParameters& sink_params,
+    const SpeechRecognitionAudioSourceProvider::OnErrorCB& on_error_cb) {
+  // Shared memory is allocated, mapped and shared.
+  uint32 shared_memory_size = sizeof(media::AudioInputBufferParameters) +
+                              media::AudioBus::CalculateMemorySize(sink_params);
+  shared_memory_.reset(new base::SharedMemory());
+
+  ASSERT_TRUE(shared_memory_->CreateAndMapAnonymous(shared_memory_size))
+      << "Failed to create shared memory";
+
+  base::SharedMemoryHandle foreign_memory_handle;
+  ASSERT_TRUE(shared_memory_->ShareToProcess(base::GetCurrentProcessHandle(),
+                                             &foreign_memory_handle))
+      << "Failed to share memory";
+
+  media::AudioInputBuffer* buffer =
+      static_cast<media::AudioInputBuffer*>(shared_memory_->memory());
+  audio_track_bus_ = media::AudioBus::WrapMemory(sink_params, buffer->audio);
+
+  // Reference to the counter used to synchronize.
+  shared_buffer_index_ = &(buffer->params.size);
+  *shared_buffer_index_ = 0U;
+
+  // Create a shared buffer for the |MockSyncSocket|s.
+  shared_buffer_.reset(new SharedBuffer());
+  ASSERT_EQ(shared_buffer_->start, 0U);
+  ASSERT_EQ(shared_buffer_->length, 0U);
+
+  // Local socket will receive signals from the producer.
+  local_socket_.reset(new MockSyncSocket(shared_buffer_.get()));
+
+  // We automatically trigger a Receive when data is sent over the socket.
+  foreign_socket_.reset(new MockSyncSocket(
+      shared_buffer_.get(),
+      base::Bind(&FakeSpeechRecognizer::EmulateReceiveThreadLoopIteration,
+                 base::Unretained(this))));
+
+  // This is usually done to pair the sockets. Here it's not effective.
+  base::SyncSocket::CreatePair(local_socket_.get(), foreign_socket_.get());
+
+  // Create the producer. TODO(burnik): move out of the recognizer.
+  audio_source_provider_.reset(new SpeechRecognitionAudioSourceProvider(
+      track, sink_params, foreign_memory_handle, foreign_socket_.get(),
+      on_error_cb));
+}
+
+// TODO(burnik): Remove from the recognizer.
+SpeechRecognitionAudioSourceProvider* FakeSpeechRecognizer::SourceProvider() {
+  return audio_source_provider_.get();
+}
+
+// Emulates the receive on the socket. This would normally be done on a
+// receiving thread's loop on the browser.
+void FakeSpeechRecognizer::EmulateReceiveThreadLoopIteration() {
+  // When not responsive do nothing as if the process is busy.
+  if (!is_responsive_) return;
+  local_socket_->Receive(shared_buffer_index_, sizeof(*shared_buffer_index_));
+  // Notify the producer that the audio buffer has been consumed.
+  (*shared_buffer_index_)++;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+// Input audio format
+static const media::AudioParameters::Format kInputFormat =
+    media::AudioParameters::AUDIO_PCM_LOW_LATENCY;
+const media::ChannelLayout kInputChannelLayout = media::CHANNEL_LAYOUT_MONO;
+const int kInputChannels = 1;
+const int kInputSampleRate = 44100;
+const int kInputBitsPerSample = 16;
+const int kInputFramesPerBuffer = 441;
+
+// Output audio format
+const media::AudioParameters::Format kOutputFormat =
+    media::AudioParameters::AUDIO_PCM_LOW_LATENCY;
+const media::ChannelLayout kOutputChannelLayout = media::CHANNEL_LAYOUT_STEREO;
+const int kOutputChannels = 2;
+const int kOutputSampleRate = 16000;
+const int kOutputBitsPerSample = 16;
+const int kOutputFramesPerBuffer = 1600;
+
+// Minimal number of buffers which trigger a single socket transfer.
+const size_t kBuffersPerNotification =
+    (kOutputFramesPerBuffer * kInputSampleRate) /
+    (kInputFramesPerBuffer * kOutputSampleRate);
+
+// Number of buffers which make the FIFO ready for consumption.
+const size_t kBuffersForReadyFifo =
+    (kOutputFramesPerBuffer * kInputSampleRate) / kOutputSampleRate;
+
+////////////////////////////////////////////////////////////////////////////////
+
+class SpeechRecognitionAudioSourceProviderTest : public testing::Test {
+ public:
+  SpeechRecognitionAudioSourceProviderTest() {}
+
+  // Mock for error callback.
+  MOCK_METHOD1(ErrorCallback,
+               void(SpeechRecognitionAudioSourceProvider::ErrorState));
+
+  // testing::Test methods.
+  virtual void SetUp() OVERRIDE {
+    // Audio Environment setup.
+    source_params_.Reset(kInputFormat, kInputChannelLayout, kInputChannels,
+                         kInputSampleRate, kInputBitsPerSample,
+                         kInputFramesPerBuffer);
+
+    sink_params_.Reset(kOutputFormat, kOutputChannelLayout, kOutputChannels,
+                       kOutputSampleRate, kOutputBitsPerSample,
+                       kOutputFramesPerBuffer);
+
+    source_data_length_ =
+        source_params_.frames_per_buffer() * source_params_.channels();
+    source_data_.reset(new int16[source_data_length_]);
+
+    MockMediaConstraintFactory constraint_factory;
+    scoped_refptr<WebRtcAudioCapturer> capturer(
+        WebRtcAudioCapturer::CreateCapturer(
+            -1, StreamDeviceInfo(),
+            constraint_factory.CreateWebMediaConstraints(), NULL, NULL));
+    scoped_refptr<WebRtcLocalAudioTrackAdapter> adapter(
+        WebRtcLocalAudioTrackAdapter::Create(std::string(), NULL));
+    native_track_ = new WebRtcLocalAudioTrack(adapter.get(), capturer, NULL);
+    native_track_->OnSetFormat(source_params_);
+
+    blink::WebMediaStreamSource audio_source;
+    audio_source.initialize(base::UTF8ToUTF16("dummy_source_id"),
+                            blink::WebMediaStreamSource::TypeAudio,
+                            base::UTF8ToUTF16("dummy_source_name"));
+    blink_track_.initialize(blink::WebString::fromUTF8("audio_track"),
+                            audio_source);
+    blink_track_.setExtraData(native_track_);
+
+    // Create the consumer.
+    recognizer_ = new FakeSpeechRecognizer();
+    recognizer_->Initialize(
+        blink_track_, sink_params_,
+        base::Bind(&SpeechRecognitionAudioSourceProviderTest::ErrorCallback,
+                   base::Unretained(this)));
+
+    // Init the producer.
+    audio_source_provider_.reset(recognizer_->SourceProvider());
+  }
+
+  virtual void TearDown() OVERRIDE { blink_track_.reset(); }
+
+ protected:
+  // TODO(burnik): Recheck steps and simplify method. Try reusing in |SetUp()|.
+  static blink::WebMediaStreamTrack CreateBlinkTrackWithMediaStreamType(
+      const MediaStreamType device_type) {
+    MockMediaConstraintFactory constraint_factory;
+
+    MediaStreamSource::SourceStoppedCallback cb;
+
+    StreamDeviceInfo device_info(device_type, "Mock audio device",
+                                 "mock_audio_device_id");
+    WebRtcAudioDeviceImpl* device = new WebRtcAudioDeviceImpl();
+    scoped_ptr<MediaStreamAudioSource> stream_audio_source(
+        new MediaStreamAudioSource(-1, device_info, cb, NULL));
+    const blink::WebMediaConstraints constraints =
+        constraint_factory.CreateWebMediaConstraints();
+    MockPeerConnectionDependencyFactory* factory =
+        new MockPeerConnectionDependencyFactory();
+    scoped_refptr<webrtc::AudioSourceInterface> audio_source =
+        factory->CreateLocalAudioSource(new RTCMediaConstraints(constraints));
+    scoped_refptr<WebRtcAudioCapturer> capturer(
+        WebRtcAudioCapturer::CreateCapturer(-1, device_info, constraints,
+                                            device, stream_audio_source.get()));
+    scoped_refptr<WebRtcLocalAudioTrackAdapter> adapter(
+        WebRtcLocalAudioTrackAdapter::Create(std::string(),
+                                             audio_source.get()));
+    scoped_ptr<WebRtcLocalAudioTrack> native_track(
+        new WebRtcLocalAudioTrack(adapter.get(), capturer, NULL));
+
+    blink::WebMediaStreamSource blink_audio_source;
+    blink_audio_source.initialize(base::UTF8ToUTF16("dummy_source_id"),
+                                  blink::WebMediaStreamSource::TypeAudio,
+                                  base::UTF8ToUTF16("dummy_source_name"));
+    blink_audio_source.setExtraData(stream_audio_source.release());
+
+    blink::WebMediaStreamTrack blink_track;
+    blink_track.initialize(blink::WebString::fromUTF8("audio_track"),
+                           blink_audio_source);
+    blink_track.setExtraData(native_track.release());
+
+    return blink_track;
+  }
+
+  // Emulates an audio capture device capturing data from the source.
+  inline void CaptureAudio(const size_t buffers) {
+    DCHECK(native_track_);
+    for (size_t i = 0; i < buffers; ++i)
+      native_track_->Capture(source_data_.get(),
+                             base::TimeDelta::FromMilliseconds(0), 1, false,
+                             false);
+  }
+
+  // Helper method to verify captured audio data has been consumed.
+  inline void AssertConsumedBuffers(const size_t buffer_index) {
+    ASSERT_EQ(buffer_index, recognizer_->buffer_index());
+  }
+
+  // Helper method to push audio data to producer and verify it was consumed.
+  inline void CaptureAudioAndAssertConsumedBuffers(const size_t buffers,
+                                                   const size_t buffer_index) {
+    CaptureAudio(buffers);
+    AssertConsumedBuffers(buffer_index);
+  }
+
+ protected:
+  // Producer.
+  scoped_ptr<SpeechRecognitionAudioSourceProvider> audio_source_provider_;
+  // Consumer.
+  FakeSpeechRecognizer* recognizer_;
+  // Audio related members.
+  size_t source_data_length_;
+  media::AudioParameters source_params_;
+  scoped_ptr<int16[]> source_data_;
+  size_t sink_data_length_;
+  media::AudioParameters sink_params_;
+  blink::WebMediaStreamTrack blink_track_;
+  WebRtcLocalAudioTrack* native_track_;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+
+TEST_F(SpeechRecognitionAudioSourceProviderTest, CheckAllowedAudioTrackType) {
+  typedef std::map<MediaStreamType, bool> AllowedAudioTrackSourceTypePolicy;
+  // This test must be aligned with the policy of allowed tracks.
+  AllowedAudioTrackSourceTypePolicy p;
+  p[MEDIA_NO_SERVICE] = false;
+  p[MEDIA_DEVICE_AUDIO_CAPTURE] = true;  // Only one allowed for now.
+  p[MEDIA_DEVICE_VIDEO_CAPTURE] = false;
+  p[MEDIA_TAB_AUDIO_CAPTURE] = false;
+  p[MEDIA_TAB_VIDEO_CAPTURE] = false;
+  p[MEDIA_DESKTOP_VIDEO_CAPTURE] = false;
+  p[MEDIA_LOOPBACK_AUDIO_CAPTURE] = false;
+  p[MEDIA_DEVICE_AUDIO_OUTPUT] = false;
+  // Ensure this test gets updated along with |content::MediaStreamType| enum.
+  EXPECT_EQ(NUM_MEDIA_TYPES, p.size());
+  // Check the the entire policy.
+  for (AllowedAudioTrackSourceTypePolicy::iterator it = p.begin();
+       it != p.end(); ++it) {
+    ASSERT_EQ(it->second,
+              SpeechRecognitionAudioSourceProvider::IsAllowedAudioTrack(
+                  CreateBlinkTrackWithMediaStreamType(it->first)));
+  }
+}
+
+TEST_F(SpeechRecognitionAudioSourceProviderTest, RecognizerNotifiedOnSocket) {
+  AssertConsumedBuffers(0U);
+  CaptureAudioAndAssertConsumedBuffers(kBuffersPerNotification, 1U);
+  CaptureAudioAndAssertConsumedBuffers(kBuffersPerNotification, 2U);
+  CaptureAudioAndAssertConsumedBuffers(kBuffersPerNotification, 3U);
+}
+
+TEST_F(SpeechRecognitionAudioSourceProviderTest, AudioDataIsResampledOnSink) {
+  // fill audio input frames with 0,1,2,3,...,440
+  for (size_t i = 0; i < source_data_length_; ++i) source_data_[i] = i;
+
+  const size_t num_frames_to_test = 12;
+  int16 sink_data[kOutputFramesPerBuffer * kOutputChannels];
+  media::AudioBus* sink_bus = recognizer_->audio_bus();
+
+  // Render the audio data from the recognizer.
+  sink_bus->ToInterleaved(sink_bus->frames(),
+                          sink_params_.bits_per_sample() / 8, sink_data);
+
+  // Test both channels are zeroed out before we trigger resampling.
+  for (size_t i = 0; i < num_frames_to_test; ++i) {
+    ASSERT_EQ(0, sink_data[i * 2]);
+    ASSERT_EQ(0, sink_data[i * 2 + 1]);
+  }
+
+  // Trigger the source provider to resample the input data.
+  AssertConsumedBuffers(0U);
+  CaptureAudioAndAssertConsumedBuffers(kBuffersPerNotification, 1U);
+
+  // Render the audio data from the recognizer.
+  sink_bus->ToInterleaved(sink_bus->frames(),
+                          sink_params_.bits_per_sample() / 8, sink_data);
+
+  // Resampled data expected frames - based on |source_data_|.
+  // Note: these values also depend on input/output audio params.
+  const int16 expected_data[num_frames_to_test] = {0,  2,  5,  8,  11, 13,
+                                                   16, 19, 22, 24, 27, 30};
+
+  // Test both channels have same resampled data.
+  for (size_t i = 0; i < num_frames_to_test; ++i) {
+    ASSERT_EQ(expected_data[i], sink_data[i * 2]);
+    ASSERT_EQ(expected_data[i], sink_data[i * 2 + 1]);
+  }
+}
+
+TEST_F(SpeechRecognitionAudioSourceProviderTest, SyncSocketFailsSendingData) {
+  // (2) Start out with no problems.
+  AssertConsumedBuffers(0U);
+  CaptureAudioAndAssertConsumedBuffers(kBuffersPerNotification, 1U);
+
+  // (2) A failure occurs (socket cannot to send).
+  recognizer_->SetFailureModeOnForeignSocket(true);
+  EXPECT_CALL(*this,
+              ErrorCallback(SpeechRecognitionAudioSourceProvider::SEND_FAILED))
+      .Times(1);
+  CaptureAudioAndAssertConsumedBuffers(kBuffersPerNotification, 1U);
+
+  // (3) Miraculasly recovered from the socket failure.

[burnik, 2014/09/12 12:09:12]

* Miraculously

[burnik, 2014/09/15 15:00:07]

Done.

+  recognizer_->SetFailureModeOnForeignSocket(false);
+  CaptureAudioAndAssertConsumedBuffers(kBuffersPerNotification, 2U);
+}
+
+TEST_F(SpeechRecognitionAudioSourceProviderTest, PeerProcessGotUnresponsive) {
+  EXPECT_GT(kBuffersForReadyFifo, kBuffersPerNotification);
+  AssertConsumedBuffers(0U);
+
+  // (1) We respond to audio packets as expected.
+  recognizer_->SimulateResponsiveness(true);
+  // First round of input has to have one additional buffer

[burnik, 2014/09/12 12:09:12]

This comment is deprecated.

[burnik, 2014/09/15 15:00:07]

Done.

+  // to trigger processing.
+  CaptureAudioAndAssertConsumedBuffers(kBuffersPerNotification, 1U);
+
+  // (2) The recognizer on the browser becomes unresponsive.
+  recognizer_->SimulateResponsiveness(false);
+  EXPECT_CALL(*this, ErrorCallback(
+                         SpeechRecognitionAudioSourceProvider::BUFFER_SYNC_LAG))
+      .Times(testing::AtLeast(1));
+  CaptureAudioAndAssertConsumedBuffers(kBuffersPerNotification, 1U);
+
+  // (2) The producer gets an overflow.
+  EXPECT_CALL(
+      *this,
+      ErrorCallback(SpeechRecognitionAudioSourceProvider::AUDIO_FIFO_OVERFLOW))
+      .Times(testing::AtLeast(1));
+  CaptureAudioAndAssertConsumedBuffers(kBuffersForReadyFifo, 1U);
+}
+
+TEST_F(SpeechRecognitionAudioSourceProviderTest, OnReadyStateChangedOccured) {
+  AssertConsumedBuffers(0U);
+  CaptureAudioAndAssertConsumedBuffers(kBuffersPerNotification, 1U);
+  EXPECT_CALL(
+      *this, ErrorCallback(SpeechRecognitionAudioSourceProvider::TRACK_STOPPED))
+      .Times(1);
+
+  native_track_->Stop();
+  CaptureAudioAndAssertConsumedBuffers(kBuffersPerNotification, 1U);
+}
+
+}  // namespace content