Modifies AudioInputCallback::OnData and use media::AudioBus instead of plain byte vector

content/browser/speech/speech_recognizer_impl_unittest.cc

 // Copyright (c) 2013 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 <vector>
 
 #include "content/browser/browser_thread_impl.h"
 #include "content/browser/speech/google_one_shot_remote_engine.h"
 #include "content/browser/speech/speech_recognizer_impl.h"
 #include "content/public/browser/speech_recognition_event_listener.h"
 #include "media/audio/audio_manager_base.h"
 #include "media/audio/fake_audio_input_stream.h"
 #include "media/audio/fake_audio_output_stream.h"
 #include "media/audio/mock_audio_manager.h"
 #include "media/audio/test_audio_input_controller_factory.h"
+#include "media/base/audio_bus.h"
 #include "net/base/net_errors.h"
 #include "net/url_request/test_url_fetcher_factory.h"
 #include "net/url_request/url_request_status.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::MessageLoopProxy;
 using media::AudioInputController;
 using media::AudioInputStream;
 using media::AudioManager;
 using media::AudioOutputStream;
@@ skipping 33 matching lines @@
     audio_manager_.reset(new media::MockAudioManager(
         base::MessageLoop::current()->message_loop_proxy().get()));
     recognizer_->SetAudioManagerForTesting(audio_manager_.get());
 
     int audio_packet_length_bytes =
         (SpeechRecognizerImpl::kAudioSampleRate *
          GoogleOneShotRemoteEngine::kAudioPacketIntervalMs *
          ChannelLayoutToChannelCount(SpeechRecognizerImpl::kChannelLayout) *
          SpeechRecognizerImpl::kNumBitsPerAudioSample) / (8 * 1000);
     audio_packet_.resize(audio_packet_length_bytes);
+
+    const int channels =
+        ChannelLayoutToChannelCount(SpeechRecognizerImpl::kChannelLayout);
+    bytes_per_sample_ = SpeechRecognizerImpl::kNumBitsPerAudioSample / 8;
+    const int frames = audio_packet_length_bytes / channels / bytes_per_sample_;
+    audio_bus_ = media::AudioBus::Create(channels, frames);
+    audio_bus_->Zero();
   }
 
   void CheckEventsConsistency() {
     // Note: "!x || y" == "x implies y".
     EXPECT_TRUE(!recognition_ended_ || recognition_started_);
     EXPECT_TRUE(!audio_ended_ || audio_started_);
     EXPECT_TRUE(!sound_ended_ || sound_started_);
     EXPECT_TRUE(!audio_started_ || recognition_started_);
     EXPECT_TRUE(!sound_started_ || audio_started_);
     EXPECT_TRUE(!audio_ended_ || (sound_ended_ || !sound_started_));
@@ skipping 61 matching lines @@
   // testing::Test methods.
   virtual void SetUp() OVERRIDE {
     AudioInputController::set_factory_for_testing(
         &audio_input_controller_factory_);
   }
 
   virtual void TearDown() OVERRIDE {
     AudioInputController::set_factory_for_testing(NULL);
   }
 
+  void CopyPacketToAudioBus() {
+    // Copy the created signal into an audio bus in a deinterleaved format.
+    audio_bus_->FromInterleaved(
+        &audio_packet_[0], audio_bus_->frames(), bytes_per_sample_);
+  }
+
   void FillPacketWithTestWaveform() {
     // Fill the input with a simple pattern, a 125Hz sawtooth waveform.
     for (size_t i = 0; i < audio_packet_.size(); ++i)
       audio_packet_[i] = static_cast<uint8>(i);
+    CopyPacketToAudioBus();
   }
 
   void FillPacketWithNoise() {
     int value = 0;
     int factor = 175;
     for (size_t i = 0; i < audio_packet_.size(); ++i) {
       value += factor;
       audio_packet_[i] = value % 100;
     }
+    CopyPacketToAudioBus();
   }
 
  protected:
   base::MessageLoopForIO message_loop_;
   BrowserThreadImpl io_thread_;
   scoped_refptr<SpeechRecognizerImpl> recognizer_;
   scoped_ptr<AudioManager> audio_manager_;
   bool recognition_started_;
   bool recognition_ended_;
   bool result_received_;
   bool audio_started_;
   bool audio_ended_;
   bool sound_started_;
   bool sound_ended_;
   SpeechRecognitionErrorCode error_;
   net::TestURLFetcherFactory url_fetcher_factory_;
   TestAudioInputControllerFactory audio_input_controller_factory_;
   std::vector<uint8> audio_packet_;
+  scoped_ptr<media::AudioBus> audio_bus_;
+  int bytes_per_sample_;
   float volume_;
   float noise_volume_;
 };
 
 TEST_F(SpeechRecognizerImplTest, StopNoData) {
   // Check for callbacks when stopping record before any audio gets recorded.
   recognizer_->StartRecognition(media::AudioManagerBase::kDefaultDeviceId);
   recognizer_->StopAudioCapture();
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_TRUE(recognition_started_);
@@ skipping 24 matching lines @@
   TestAudioInputController* controller =
       audio_input_controller_factory_.controller();
   ASSERT_TRUE(controller);
 
   // Try sending 5 chunks of mock audio data and verify that each of them
   // resulted immediately in a packet sent out via the network. This verifies
   // that we are streaming out encoded data as chunks without waiting for the
   // full recording to complete.
   const size_t kNumChunks = 5;
   for (size_t i = 0; i < kNumChunks; ++i) {
-    controller->event_handler()->OnData(controller, &audio_packet_[0],
-                                        audio_packet_.size());
+    controller->event_handler()->OnData(controller, audio_bus_.get());
     base::MessageLoop::current()->RunUntilIdle();
     net::TestURLFetcher* fetcher = url_fetcher_factory_.GetFetcherByID(0);
     ASSERT_TRUE(fetcher);
     EXPECT_EQ(i + 1, fetcher->upload_chunks().size());
   }
 
   recognizer_->StopAudioCapture();
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_TRUE(audio_started_);
   EXPECT_TRUE(audio_ended_);
@@ skipping 20 matching lines @@
   CheckFinalEventsConsistency();
 }
 
 TEST_F(SpeechRecognizerImplTest, CancelWithData) {
   // Start recording, give some data and then cancel.
   recognizer_->StartRecognition(media::AudioManagerBase::kDefaultDeviceId);
   base::MessageLoop::current()->RunUntilIdle();
   TestAudioInputController* controller =
       audio_input_controller_factory_.controller();
   ASSERT_TRUE(controller);
-  controller->event_handler()->OnData(controller, &audio_packet_[0],
-                                      audio_packet_.size());
+  controller->event_handler()->OnData(controller, audio_bus_.get());
   base::MessageLoop::current()->RunUntilIdle();
   recognizer_->AbortRecognition();
   base::MessageLoop::current()->RunUntilIdle();
   ASSERT_TRUE(url_fetcher_factory_.GetFetcherByID(0));
   EXPECT_TRUE(recognition_started_);
   EXPECT_TRUE(audio_started_);
   EXPECT_FALSE(result_received_);
   EXPECT_EQ(SPEECH_RECOGNITION_ERROR_ABORTED, error_);
   CheckFinalEventsConsistency();
 }
 
 TEST_F(SpeechRecognizerImplTest, ConnectionError) {
   // Start recording, give some data and then stop. Issue the network callback
   // with a connection error and verify that the recognizer bubbles the error up
   recognizer_->StartRecognition(media::AudioManagerBase::kDefaultDeviceId);
   base::MessageLoop::current()->RunUntilIdle();
   TestAudioInputController* controller =
       audio_input_controller_factory_.controller();
   ASSERT_TRUE(controller);
-  controller->event_handler()->OnData(controller, &audio_packet_[0],
-                                      audio_packet_.size());
+  controller->event_handler()->OnData(controller, audio_bus_.get());
   base::MessageLoop::current()->RunUntilIdle();
   net::TestURLFetcher* fetcher = url_fetcher_factory_.GetFetcherByID(0);
   ASSERT_TRUE(fetcher);
 
   recognizer_->StopAudioCapture();
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_TRUE(audio_started_);
   EXPECT_TRUE(audio_ended_);
   EXPECT_FALSE(recognition_ended_);
   EXPECT_FALSE(result_received_);
@@ skipping 16 matching lines @@
 }
 
 TEST_F(SpeechRecognizerImplTest, ServerError) {
   // Start recording, give some data and then stop. Issue the network callback
   // with a 500 error and verify that the recognizer bubbles the error up
   recognizer_->StartRecognition(media::AudioManagerBase::kDefaultDeviceId);
   base::MessageLoop::current()->RunUntilIdle();
   TestAudioInputController* controller =
       audio_input_controller_factory_.controller();
   ASSERT_TRUE(controller);
-  controller->event_handler()->OnData(controller, &audio_packet_[0],
-                                      audio_packet_.size());
+  controller->event_handler()->OnData(controller, audio_bus_.get());
   base::MessageLoop::current()->RunUntilIdle();
   net::TestURLFetcher* fetcher = url_fetcher_factory_.GetFetcherByID(0);
   ASSERT_TRUE(fetcher);
 
   recognizer_->StopAudioCapture();
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_TRUE(audio_started_);
   EXPECT_TRUE(audio_ended_);
   EXPECT_FALSE(recognition_ended_);
   EXPECT_FALSE(result_received_);
@@ skipping 32 matching lines @@
 }
 
 TEST_F(SpeechRecognizerImplTest, AudioControllerErrorWithData) {
   // Check if things tear down properly if AudioInputController threw an error
   // after giving some audio data.
   recognizer_->StartRecognition(media::AudioManagerBase::kDefaultDeviceId);
   base::MessageLoop::current()->RunUntilIdle();
   TestAudioInputController* controller =
       audio_input_controller_factory_.controller();
   ASSERT_TRUE(controller);
-  controller->event_handler()->OnData(controller, &audio_packet_[0],
-                                      audio_packet_.size());
+  controller->event_handler()->OnData(controller, audio_bus_.get());
   controller->event_handler()->OnError(controller,
       AudioInputController::UNKNOWN_ERROR);
   base::MessageLoop::current()->RunUntilIdle();
   ASSERT_TRUE(url_fetcher_factory_.GetFetcherByID(0));
   EXPECT_TRUE(recognition_started_);
   EXPECT_TRUE(audio_started_);
   EXPECT_FALSE(result_received_);
   EXPECT_EQ(SPEECH_RECOGNITION_ERROR_AUDIO, error_);
   CheckFinalEventsConsistency();
 }
 
 TEST_F(SpeechRecognizerImplTest, NoSpeechCallbackIssued) {
   // Start recording and give a lot of packets with audio samples set to zero.
   // This should trigger the no-speech detector and issue a callback.
   recognizer_->StartRecognition(media::AudioManagerBase::kDefaultDeviceId);
   base::MessageLoop::current()->RunUntilIdle();
   TestAudioInputController* controller =
       audio_input_controller_factory_.controller();
   ASSERT_TRUE(controller);
 
   int num_packets = (SpeechRecognizerImpl::kNoSpeechTimeoutMs) /
                      GoogleOneShotRemoteEngine::kAudioPacketIntervalMs + 1;
   // The vector is already filled with zero value samples on create.
   for (int i = 0; i < num_packets; ++i) {
-    controller->event_handler()->OnData(controller, &audio_packet_[0],
-                                        audio_packet_.size());
+    controller->event_handler()->OnData(controller, audio_bus_.get());
   }
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_TRUE(recognition_started_);
   EXPECT_TRUE(audio_started_);
   EXPECT_FALSE(result_received_);
   EXPECT_EQ(SPEECH_RECOGNITION_ERROR_NO_SPEECH, error_);
   CheckFinalEventsConsistency();
 }
 
 TEST_F(SpeechRecognizerImplTest, NoSpeechCallbackNotIssued) {
   // Start recording and give a lot of packets with audio samples set to zero
   // and then some more with reasonably loud audio samples. This should be
   // treated as normal speech input and the no-speech detector should not get
   // triggered.
   recognizer_->StartRecognition(media::AudioManagerBase::kDefaultDeviceId);
   base::MessageLoop::current()->RunUntilIdle();
   TestAudioInputController* controller =
       audio_input_controller_factory_.controller();
   ASSERT_TRUE(controller);
   controller = audio_input_controller_factory_.controller();
   ASSERT_TRUE(controller);
 
   int num_packets = (SpeechRecognizerImpl::kNoSpeechTimeoutMs) /
                      GoogleOneShotRemoteEngine::kAudioPacketIntervalMs;
 
   // The vector is already filled with zero value samples on create.
   for (int i = 0; i < num_packets / 2; ++i) {
-    controller->event_handler()->OnData(controller, &audio_packet_[0],
-                                        audio_packet_.size());
+    controller->event_handler()->OnData(controller, audio_bus_.get());
   }
 
   FillPacketWithTestWaveform();
   for (int i = 0; i < num_packets / 2; ++i) {
-    controller->event_handler()->OnData(controller, &audio_packet_[0],
-                                        audio_packet_.size());
+    controller->event_handler()->OnData(controller, audio_bus_.get());
   }
 
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(SPEECH_RECOGNITION_ERROR_NONE, error_);
   EXPECT_TRUE(audio_started_);
   EXPECT_FALSE(audio_ended_);
   EXPECT_FALSE(recognition_ended_);
   recognizer_->AbortRecognition();
   base::MessageLoop::current()->RunUntilIdle();
   CheckFinalEventsConsistency();
@@ skipping 10 matching lines @@
       audio_input_controller_factory_.controller();
   ASSERT_TRUE(controller);
   controller = audio_input_controller_factory_.controller();
   ASSERT_TRUE(controller);
 
   // Feed some samples to begin with for the endpointer to do noise estimation.
   int num_packets = SpeechRecognizerImpl::kEndpointerEstimationTimeMs /
                     GoogleOneShotRemoteEngine::kAudioPacketIntervalMs;
   FillPacketWithNoise();
   for (int i = 0; i < num_packets; ++i) {
-    controller->event_handler()->OnData(controller, &audio_packet_[0],
-                                        audio_packet_.size());
+    controller->event_handler()->OnData(controller, audio_bus_.get());
   }
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(-1.0f, volume_);  // No audio volume set yet.
 
   // The vector is already filled with zero value samples on create.
-  controller->event_handler()->OnData(controller, &audio_packet_[0],
-                                      audio_packet_.size());
+  controller->event_handler()->OnData(controller, audio_bus_.get());
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_FLOAT_EQ(0.74939233f, volume_);
 
   FillPacketWithTestWaveform();
-  controller->event_handler()->OnData(controller, &audio_packet_[0],
-                                      audio_packet_.size());
+  controller->event_handler()->OnData(controller, audio_bus_.get());
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_NEAR(0.89926866f, volume_, 0.00001f);
   EXPECT_FLOAT_EQ(0.75071919f, noise_volume_);
 
   EXPECT_EQ(SPEECH_RECOGNITION_ERROR_NONE, error_);
   EXPECT_FALSE(audio_ended_);
   EXPECT_FALSE(recognition_ended_);
   recognizer_->AbortRecognition();
   base::MessageLoop::current()->RunUntilIdle();
   CheckFinalEventsConsistency();
 }
 
 }  // namespace content