[chromecast] Slew stream volume changes in StreamMixerAlsa.

chromecast/media/cma/backend/alsa/stream_mixer_alsa_unittest.cc

 // Copyright 2015 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 "chromecast/media/cma/backend/alsa/stream_mixer_alsa.h"
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 #include <utility>
 
 #include "base/memory/ptr_util.h"
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "chromecast/media/cma/backend/alsa/mock_alsa_wrapper.h"
 #include "media/base/audio_bus.h"
+#include "media/base/vector_math.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::_;
 
 namespace chromecast {
 namespace media {
 
 namespace {
 
@@ skipping 98 matching lines @@
  public:
   explicit MockInputQueue(int samples_per_second)
       : paused_(true),
         samples_per_second_(samples_per_second),
         max_read_size_(kTestMaxReadSize),
         multiplier_(1.0),
         primary_(true),
         deleting_(false) {
     ON_CALL(*this, GetResampledData(_, _)).WillByDefault(
         testing::Invoke(this, &MockInputQueue::DoGetResampledData));
+    ON_CALL(*this, VolumeScaleAccumulate(_, _, _, _)).WillByDefault(
+        testing::Invoke(this, &MockInputQueue::DoVolumeScaleAccumulate));
     ON_CALL(*this, PrepareToDelete(_)).WillByDefault(
         testing::Invoke(this, &MockInputQueue::DoPrepareToDelete));
   }
   ~MockInputQueue() override {}
 
   bool paused() const { return paused_; }
 
   // StreamMixerAlsa::InputQueue implementation:
   int input_samples_per_second() const override { return samples_per_second_; }
-  float volume_multiplier() const override { return multiplier_; }
   bool primary() const override { return primary_; }
   bool IsDeleting() const override { return deleting_; }
   MOCK_METHOD1(Initialize,
                void(const MediaPipelineBackendAlsa::RenderingDelay&
                         mixer_rendering_delay));
   int MaxReadSize() override { return max_read_size_; }
   MOCK_METHOD2(GetResampledData, void(::media::AudioBus* dest, int frames));
+  MOCK_METHOD4(
+      VolumeScaleAccumulate,
+      void(bool repeat_transition, const float* src, int frames, float* dest));
   MOCK_METHOD1(AfterWriteFrames,
                void(const MediaPipelineBackendAlsa::RenderingDelay&
                         mixer_rendering_delay));
   MOCK_METHOD1(SignalError, void(StreamMixerAlsaInput::MixerError error));
   MOCK_METHOD1(PrepareToDelete, void(const OnReadyToDeleteCb& delete_cb));
 
   // Setters and getters for test control.
   void SetPaused(bool paused) { paused_ = paused; }
   void SetMaxReadSize(int max_read_size) { max_read_size_ = max_read_size; }
   void SetData(std::unique_ptr<::media::AudioBus> data) {
@@ skipping 16 matching lines @@
   void DoGetResampledData(::media::AudioBus* dest, int frames) {
     CHECK(dest);
     CHECK_GE(dest->frames(), frames);
     if (data_) {
       data_->CopyPartialFramesTo(0, frames, 0, dest);
     } else {
       dest->ZeroFramesPartial(0, frames);
     }
   }
 
+  void DoVolumeScaleAccumulate(bool repeat_transition,
+                               const float* src,
+                               int frames,
+                               float* dest) {
+    CHECK(src);
+    CHECK(dest);
+    CHECK(multiplier_ >= 0.0 && multiplier_ <= 1.0);
+    ::media::vector_math::FMAC(src, multiplier_, frames, dest);
+  }
+
   void DoPrepareToDelete(const OnReadyToDeleteCb& delete_cb) {
     deleting_ = true;
     delete_cb.Run(this);
   }
 
   bool paused_;
   int samples_per_second_;
   int max_read_size_;
   float multiplier_;
   bool primary_;
@@ skipping 157 matching lines @@
 
   // The mixer should pull data from all streams, using the smallest
   // MaxReadSize provided by any of the channels.
   // TODO(slan): Check that the proper number of frames is pulled.
   ASSERT_EQ(3u, inputs.size());
   inputs[0]->SetMaxReadSize(1024);
   inputs[1]->SetMaxReadSize(512);
   inputs[2]->SetMaxReadSize(2048);
   for (auto* input : inputs) {
     EXPECT_CALL(*input, GetResampledData(_, 512)).Times(1);
+    EXPECT_CALL(*input, VolumeScaleAccumulate(_, _, 512, _))
+        .Times(kNumChannels);
     EXPECT_CALL(*input, AfterWriteFrames(_)).Times(1);
   }
 
   // TODO(slan): Verify that the data is mixed properly with math.
   EXPECT_CALL(*mock_alsa(), PcmWritei(_, _, 512)).Times(1);
   mixer->WriteFramesForTest();
 
   // Make two of these streams non-primary, and exhaust a non-primary stream.
   // All non-empty streams shall be polled for data and the mixer shall write
   // to ALSA.
   inputs[1]->SetPrimary(false);
   inputs[1]->SetMaxReadSize(0);
   inputs[2]->SetPrimary(false);
   for (auto* input : inputs) {
-    if (input != inputs[1])
+    if (input != inputs[1]) {
       EXPECT_CALL(*input, GetResampledData(_, 1024)).Times(1);
+      EXPECT_CALL(*input, VolumeScaleAccumulate(_, _, 1024, _))
+          .Times(kNumChannels);
+    }
     EXPECT_CALL(*input, AfterWriteFrames(_)).Times(1);
   }
   // Note that the new smallest stream shall dictate the length of the write.
   EXPECT_CALL(*mock_alsa(), PcmWritei(_, _, 1024)).Times(1);
   mixer->WriteFramesForTest();
 
   // Exhaust a primary stream. No streams shall be polled for data, and no
   // data shall be written to ALSA.
   inputs[0]->SetMaxReadSize(0);
   EXPECT_CALL(*mock_alsa(), PcmWritei(_, _, _)).Times(0);
@@ skipping 10 matching lines @@
   EXPECT_EQ(StreamMixerAlsa::kStateNormalPlayback, mixer->state());
 
   // Populate the stream with data.
   const int kNumFrames = 32;
   input->SetData(GetTestData(0));
 
   ASSERT_EQ(mock_alsa()->data().size(), 0u);
 
   // Write the stream to ALSA.
   EXPECT_CALL(*input, GetResampledData(_, kNumFrames));
+  EXPECT_CALL(*input, VolumeScaleAccumulate(_, _, kNumFrames, _))
+      .Times(kNumChannels);
   EXPECT_CALL(*input, AfterWriteFrames(_));
   mixer->WriteFramesForTest();
 
   // Get the actual stream rendered to ALSA, and compare it against the
   // expected stream. The stream should match exactly.
   auto actual = ::media::AudioBus::Create(kNumChannels, kNumFrames);
   ASSERT_GT(mock_alsa()->data().size(), 0u);
   actual->FromInterleaved(
       &(mock_alsa()->data()[0]), kNumFrames, kBytesPerSample);
   CompareAudioData(input->data(), *actual);
@@ skipping 12 matching lines @@
   const int kNumFrames = 32;
   ASSERT_EQ(sizeof(kTestData[0]), kNumChannels * kNumFrames * kBytesPerSample);
   auto data = GetTestData(0);
   input->SetData(std::move(data));
 
   // Set a volume multiplier on the stream.
   input->SetVolumeMultiplier(0.75);
 
   // Write the stream to ALSA.
   EXPECT_CALL(*input, GetResampledData(_, kNumFrames));
+  EXPECT_CALL(*input, VolumeScaleAccumulate(_, _, kNumFrames, _))
+      .Times(kNumChannels);
   EXPECT_CALL(*input, AfterWriteFrames(_));
   mixer->WriteFramesForTest();
 
   // Check that the retrieved stream is scaled correctly.
   auto actual = ::media::AudioBus::Create(kNumChannels, kNumFrames);
   actual->FromInterleaved(
       &(mock_alsa()->data()[0]), kNumFrames, kBytesPerSample);
   auto expected = GetMixedAudioData(input);
   CompareAudioData(*expected, *actual);
 }
@@ skipping 12 matching lines @@
   for (size_t i = 0; i < inputs.size(); ++i) {
     EXPECT_CALL(*inputs[i], Initialize(_)).Times(1);
     mixer->AddInput(base::WrapUnique(inputs[i]));
   }
 
   // Poll the inputs for data.
   const int kNumFrames = 32;
   for (size_t i = 0; i < inputs.size(); ++i) {
     inputs[i]->SetData(GetTestData(i));
     EXPECT_CALL(*inputs[i], GetResampledData(_, kNumFrames));
+    EXPECT_CALL(*inputs[i], VolumeScaleAccumulate(_, _, kNumFrames, _))
+        .Times(kNumChannels);
     EXPECT_CALL(*inputs[i], AfterWriteFrames(_));
   }
 
   EXPECT_CALL(*mock_alsa(), PcmWritei(_, _, kNumFrames)).Times(1);
   mixer->WriteFramesForTest();
 
   // Mix the inputs manually.
   auto expected = GetMixedAudioData(inputs);
 
   // Get the actual stream rendered to ALSA, and compare it against the
@@ skipping 52 matching lines @@
     0.0,         0.0,
     kMaxSample,  kMaxSample,
     0.0,         0.0,
   };
 
   for (size_t i = 0; i < inputs.size(); ++i) {
     auto test_data = ::media::AudioBus::Create(kNumChannels, kNumFrames);
     test_data->FromInterleaved(kEdgeData[i], kNumFrames, kBytesPerSample);
     inputs[i]->SetData(std::move(test_data));
     EXPECT_CALL(*inputs[i], GetResampledData(_, kNumFrames));
+    EXPECT_CALL(*inputs[i], VolumeScaleAccumulate(_, _, kNumFrames, _))
+        .Times(kNumChannels);
     EXPECT_CALL(*inputs[i], AfterWriteFrames(_));
   }
 
   EXPECT_CALL(*mock_alsa(), PcmWritei(_, _, kNumFrames)).Times(1);
   mixer->WriteFramesForTest();
 
   // Use the hand-calculated results above.
   auto expected = ::media::AudioBus::Create(kNumChannels, kNumFrames);
   expected->FromInterleaved(kResult, kNumFrames, kBytesPerSample);
 
@@ skipping 10 matching lines @@
   input->SetPaused(false);
 
   StreamMixerAlsa* mixer = StreamMixerAlsa::Get();
   EXPECT_CALL(*input, Initialize(_)).Times(1);
   mixer->AddInput(base::WrapUnique(input));
   EXPECT_EQ(StreamMixerAlsa::kStateNormalPlayback, mixer->state());
 
   // The input stream will provide buffers of several different lengths.
   input->SetMaxReadSize(7);
   EXPECT_CALL(*input, GetResampledData(_, 7));
+  EXPECT_CALL(*input, VolumeScaleAccumulate(_, _, 7, _)).Times(kNumChannels);
   EXPECT_CALL(*input, AfterWriteFrames(_));
   EXPECT_CALL(*mock_alsa(), PcmWritei(_, _, 7)).Times(1);
   mixer->WriteFramesForTest();
 
   input->SetMaxReadSize(100);
   EXPECT_CALL(*input, GetResampledData(_, 100));
+  EXPECT_CALL(*input, VolumeScaleAccumulate(_, _, 100, _)).Times(kNumChannels);
   EXPECT_CALL(*input, AfterWriteFrames(_));
   EXPECT_CALL(*mock_alsa(), PcmWritei(_, _, 100)).Times(1);
   mixer->WriteFramesForTest();
 
   input->SetMaxReadSize(32);
   EXPECT_CALL(*input, GetResampledData(_, 32));
+  EXPECT_CALL(*input, VolumeScaleAccumulate(_, _, 32, _)).Times(kNumChannels);
   EXPECT_CALL(*input, AfterWriteFrames(_));
   EXPECT_CALL(*mock_alsa(), PcmWritei(_, _, 32)).Times(1);
   mixer->WriteFramesForTest();
 
   input->SetMaxReadSize(1024);
   EXPECT_CALL(*input, GetResampledData(_, 1024));
+  EXPECT_CALL(*input, VolumeScaleAccumulate(_, _, 1024, _)).Times(kNumChannels);
   EXPECT_CALL(*input, AfterWriteFrames(_));
   EXPECT_CALL(*mock_alsa(), PcmWritei(_, _, 1024)).Times(1);
   mixer->WriteFramesForTest();
 }
 
 TEST_F(StreamMixerAlsaTest, StuckStreamWithoutUnderrun) {
   // Create a group of input streams.
   std::vector<testing::StrictMock<MockInputQueue>*> inputs;
   const int kNumInputs = 2;
   for (int i = 0; i < kNumInputs; ++i) {
     inputs.push_back(
         new testing::StrictMock<MockInputQueue>(kTestSamplesPerSecond));
     inputs.back()->SetMaxReadSize(0);
     inputs.back()->SetPaused(false);
   }
 
   StreamMixerAlsa* mixer = StreamMixerAlsa::Get();
   for (size_t i = 0; i < inputs.size(); ++i) {
     EXPECT_CALL(*inputs[i], Initialize(_)).Times(1);
     mixer->AddInput(base::WrapUnique(inputs[i]));
   }
 
   // Poll the inputs for data. Should not pull any data since one input has none
   // to give.
   inputs[0]->SetData(GetTestData(0));
   EXPECT_CALL(*inputs[0], GetResampledData(_, _)).Times(0);
+  EXPECT_CALL(*inputs[0], VolumeScaleAccumulate(_, _, _, _)).Times(0);
   EXPECT_CALL(*inputs[0], AfterWriteFrames(_)).Times(0);
 
   EXPECT_CALL(*mock_alsa(), PcmWritei(_, _, _)).Times(0);
   mixer->WriteFramesForTest();
 }
 
 TEST_F(StreamMixerAlsaTest, StuckStreamWithUnderrun) {
   // Create a group of input streams.
   std::vector<testing::StrictMock<MockInputQueue>*> inputs;
   const int kNumInputs = 2;
@@ skipping 12 matching lines @@
 
   mock_alsa()->set_state(SND_PCM_STATE_XRUN);
 
   // Poll the inputs for data. The first input will provide data (since the
   // output is in an underrun condition); the second input can't provide any
   // data, but AfterWriteFrames() will still be called on it so that it has the
   // correct rendering delay.
   const int kNumFrames = 32;
   inputs[0]->SetData(GetTestData(0));
   EXPECT_CALL(*inputs[0], GetResampledData(_, kNumFrames));
+  EXPECT_CALL(*inputs[0], VolumeScaleAccumulate(_, _, kNumFrames, _))
+      .Times(kNumChannels);
   EXPECT_CALL(*inputs[0], AfterWriteFrames(_));
   EXPECT_CALL(*inputs[1], GetResampledData(_, _)).Times(0);
+  EXPECT_CALL(*inputs[1], VolumeScaleAccumulate(_, _, kNumFrames, _)).Times(0);
   EXPECT_CALL(*inputs[1], AfterWriteFrames(_));
 
   EXPECT_CALL(*mock_alsa(), PcmWritei(_, _, kNumFrames)).Times(1);
   mixer->WriteFramesForTest();
 }
 
 TEST_F(StreamMixerAlsaTest, StuckStreamWithLowBuffer) {
   // Create a group of input streams.
   std::vector<testing::StrictMock<MockInputQueue>*> inputs;
   const int kNumInputs = 2;
@@ skipping 12 matching lines @@
 
   mock_alsa()->set_avail(4086);
 
   // Poll the inputs for data. The first input will provide data (since the
   // output is in an low buffer condition); the second input can't provide any
   // data, but AfterWriteFrames() will still be called on it so that it has the
   // correct rendering delay.
   const int kNumFrames = 32;
   inputs[0]->SetData(GetTestData(0));
   EXPECT_CALL(*inputs[0], GetResampledData(_, kNumFrames));
+  EXPECT_CALL(*inputs[0], VolumeScaleAccumulate(_, _, kNumFrames, _))
+      .Times(kNumChannels);
   EXPECT_CALL(*inputs[0], AfterWriteFrames(_));
   EXPECT_CALL(*inputs[1], GetResampledData(_, _)).Times(0);
+  EXPECT_CALL(*inputs[1], VolumeScaleAccumulate(_, _, _, _)).Times(0);
   EXPECT_CALL(*inputs[1], AfterWriteFrames(_));
 
   EXPECT_CALL(*mock_alsa(), PcmWritei(_, _, kNumFrames)).Times(1);
   mixer->WriteFramesForTest();
 }
 
 }  // namespace media
 }  // namespace chromecast