Reland of [Chromecast] Process streams with different post-processing.

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/audio/audio_device_description.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 {
 
@@ skipping 91 matching lines @@
 std::unique_ptr<::media::AudioBus> GetTestData(size_t index) {
   CHECK_LT(index, NUM_DATA_SETS);
   int frames = NUM_SAMPLES / kNumChannels;
   auto data = ::media::AudioBus::Create(kNumChannels, frames);
   data->FromInterleaved(kTestData[index], frames, kBytesPerSample);
   return data;
 }
 
 class MockInputQueue : public StreamMixerAlsa::InputQueue {
  public:
-  explicit MockInputQueue(int samples_per_second)
+  explicit MockInputQueue(int samples_per_second,
+                          const std::string& device_id =
+                              ::media::AudioDeviceDescription::kDefaultDeviceId)
       : paused_(true),
         samples_per_second_(samples_per_second),
         max_read_size_(kTestMaxReadSize),
         multiplier_(1.0),
         primary_(true),
-        deleting_(false) {
+        deleting_(false),
+        device_id_(device_id),
+        filter_group_(nullptr) {
     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_; }
   bool primary() const override { return primary_; }
   bool IsDeleting() const override { return deleting_; }
   MOCK_METHOD1(Initialize,
                void(const MediaPipelineBackendAlsa::RenderingDelay&
                         mixer_rendering_delay));
+  std::string device_id() const override { return device_id_; }
+  void set_filter_group(FilterGroup* group) override { filter_group_ = group; }
+  FilterGroup* filter_group() override { return filter_group_; }
   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_METHOD0(OnSkipped, void());
   MOCK_METHOD1(AfterWriteFrames,
                void(const MediaPipelineBackendAlsa::RenderingDelay&
                         mixer_rendering_delay));
   MOCK_METHOD1(SignalError, void(StreamMixerAlsaInput::MixerError error));
@@ skipping 43 matching lines @@
     deleting_ = true;
     delete_cb.Run(this);
   }
 
   bool paused_;
   int samples_per_second_;
   int max_read_size_;
   float multiplier_;
   bool primary_;
   bool deleting_;
+  const std::string device_id_;
+  FilterGroup* filter_group_;
+
   std::unique_ptr<::media::AudioBus> data_;
 
   DISALLOW_COPY_AND_ASSIGN(MockInputQueue);
 };
 
 // Given |inputs|, returns mixed audio data according to the mixing method used
 // by the mixer.
 std::unique_ptr<::media::AudioBus> GetMixedAudioData(
     const std::vector<testing::StrictMock<MockInputQueue>*>& inputs) {
   int read_size = std::numeric_limits<int>::max();
@@ skipping 280 matching lines @@
 
   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
   // expected stream. The stream should match exactly.
   auto actual = ::media::AudioBus::Create(kNumChannels, kNumFrames);
+  actual->FromInterleaved(&(mock_alsa()->data()[0]), kNumFrames,
+                          kBytesPerSample);
+  CompareAudioData(*expected, *actual);
+}
+
+TEST_F(StreamMixerAlsaTest, TwoUnscaledStreamsWithDifferentIdsMixProperly) {
+  // Create a group of input streams.
+  std::vector<testing::StrictMock<MockInputQueue>*> inputs;
+  inputs.push_back(new testing::StrictMock<MockInputQueue>(
+      kTestSamplesPerSecond,
+      ::media::AudioDeviceDescription::kDefaultDeviceId));
+  inputs.back()->SetPaused(false);
+  inputs.push_back(new testing::StrictMock<MockInputQueue>(
+      kTestSamplesPerSecond,
+      ::media::AudioDeviceDescription::kCommunicationsDeviceId));
+  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.
+  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
+  // expected stream. The stream should match exactly.
+  auto actual = ::media::AudioBus::Create(kNumChannels, kNumFrames);
   actual->FromInterleaved(
       &(mock_alsa()->data()[0]), kNumFrames, kBytesPerSample);
   CompareAudioData(*expected, *actual);
 }
 
 TEST_F(StreamMixerAlsaTest, TwoUnscaledStreamsMixProperlyWithEdgeCases) {
   // Create a group of input streams.
   std::vector<testing::StrictMock<MockInputQueue>*> inputs;
   const int kNumInputs = 2;
   for (int i = 0; i < kNumInputs; ++i) {
@@ skipping 205 matching lines @@
   EXPECT_CALL(*inputs[1], VolumeScaleAccumulate(_, _, _, _)).Times(0);
   EXPECT_CALL(*inputs[1], OnSkipped());
   EXPECT_CALL(*inputs[1], AfterWriteFrames(_));
 
   EXPECT_CALL(*mock_alsa(), PcmWritei(_, _, kNumFrames)).Times(1);
   mixer->WriteFramesForTest();
 }
 
 }  // namespace media
 }  // namespace chromecast