output_device_mixer_impl_unittest.cc 52 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361
  1. // Copyright (c) 2021 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "services/audio/output_device_mixer_impl.h"
  5. #include <array>
  6. #include "base/logging.h"
  7. #include "base/memory/raw_ptr.h"
  8. #include "base/test/task_environment.h"
  9. #include "testing/gmock/include/gmock/gmock.h"
  10. #include "testing/gtest/include/gtest/gtest.h"
  11. using testing::_;
  12. using testing::InSequence;
  13. using testing::Mock;
  14. using testing::Return;
  15. using testing::StrictMock;
  16. namespace audio {
  17. namespace {
  18. using media::AudioOutputStream;
  19. const std::string kDeviceId = "device-id";
  20. MATCHER_P(AudioParamsEq, other, "AudioParameters matcher") {
  21. return arg.Equals(other);
  22. }
  23. // Mock listener.
  24. class MockListener : public ReferenceOutput::Listener {
  25. public:
  26. MOCK_METHOD3(OnPlayoutData,
  27. void(const media::AudioBus& audio_bus,
  28. int sample_rate,
  29. base::TimeDelta delay));
  30. };
  31. // Mock of a physical output stream_under_test.
  32. class MockAudioOutputStream : public AudioOutputStream {
  33. public:
  34. MockAudioOutputStream() = default;
  35. ~MockAudioOutputStream() override = default;
  36. MockAudioOutputStream(MockAudioOutputStream&& other) {
  37. provided_callback_ = other.provided_callback_;
  38. }
  39. void Start(AudioSourceCallback* callback) override {
  40. provided_callback_ = callback;
  41. StartCalled();
  42. }
  43. MOCK_METHOD0(StartCalled, void());
  44. MOCK_METHOD0(Stop, void());
  45. MOCK_METHOD0(Open, bool());
  46. void SetVolume(double volume) final { volume_ = volume; }
  47. double GetVolume() { return volume_; }
  48. MOCK_METHOD1(GetVolume, void(double*));
  49. MOCK_METHOD0(Close, void());
  50. MOCK_METHOD0(Flush, void());
  51. void SimulateOnMoreData() {
  52. DCHECK(provided_callback_);
  53. provided_callback_->OnMoreData(base::TimeDelta(), base::TimeTicks(), 0,
  54. nullptr);
  55. }
  56. void SimulateError() {
  57. DCHECK(provided_callback_);
  58. provided_callback_->OnError(AudioSourceCallback::ErrorType::kUnknown);
  59. }
  60. private:
  61. raw_ptr<AudioOutputStream::AudioSourceCallback> provided_callback_ = nullptr;
  62. double volume_ = 0;
  63. };
  64. class MockAudioSourceCallback : public AudioOutputStream::AudioSourceCallback {
  65. public:
  66. MockAudioSourceCallback() = default;
  67. MockAudioSourceCallback(MockAudioSourceCallback&& other) {}
  68. MOCK_METHOD4(OnMoreData,
  69. int(base::TimeDelta delay,
  70. base::TimeTicks delay_timestamp,
  71. int prior_frames_skipped,
  72. media::AudioBus* dest));
  73. MOCK_METHOD1(OnError,
  74. void(AudioOutputStream::AudioSourceCallback::ErrorType type));
  75. };
  76. // Mocks interesting calls of MixingGraph::Input.
  77. class MockMixingGraphInput : public MixingGraph::Input {
  78. public:
  79. MockMixingGraphInput() = default;
  80. MockMixingGraphInput(MockMixingGraphInput&& other) {}
  81. MOCK_CONST_METHOD0(GetParams, const media::AudioParameters&());
  82. void SetVolume(double volume) final { volume_ = volume; }
  83. double GetVolume() { return volume_; }
  84. MOCK_METHOD1(Start,
  85. void(AudioOutputStream::AudioSourceCallback* source_callback));
  86. MOCK_METHOD0(Stop, void());
  87. MOCK_METHOD2(ProvideInput,
  88. double(media::AudioBus* audio_bus, uint32_t frames_delayed));
  89. private:
  90. double volume_ = 0;
  91. };
  92. // MixingGraph::Input eventually produced by MockMixingGraph::CreateInput().
  93. // Delegates all the interesting calls to MockMixingGraphInput.
  94. class FakeMixingGraphInput : public MixingGraph::Input {
  95. public:
  96. FakeMixingGraphInput(const media::AudioParameters& params,
  97. MockMixingGraphInput* mock_input)
  98. : params_(params), mock_input_(mock_input) {}
  99. const media::AudioParameters& GetParams() const final { return params_; }
  100. void SetVolume(double volume) final { mock_input_->SetVolume(volume); }
  101. void Start(AudioOutputStream::AudioSourceCallback* source_callback) final {
  102. mock_input_->Start(source_callback);
  103. }
  104. void Stop() final { mock_input_->Stop(); }
  105. MOCK_METHOD2(ProvideInput,
  106. double(media::AudioBus* audio_bus, uint32_t frames_delayed));
  107. private:
  108. const media::AudioParameters params_;
  109. const raw_ptr<MockMixingGraphInput> mock_input_;
  110. };
  111. // Created and owned by OutputMixerManagerImpl; it's essentially a factory
  112. // producing FGraphakeMixerInput instances.
  113. class MockMixingGraph : public MixingGraph {
  114. public:
  115. using CreateGraphInputCallback =
  116. base::RepeatingCallback<std::unique_ptr<MixingGraph::Input>(
  117. const media::AudioParameters& params)>;
  118. MockMixingGraph(CreateGraphInputCallback create_graph_input_cb,
  119. MixingGraph::OnMoreDataCallback on_more_data_cb,
  120. MixingGraph::OnErrorCallback on_error_cb)
  121. : create_graph_input_cb_(std::move(create_graph_input_cb)),
  122. on_more_data_cb_(std::move(on_more_data_cb)),
  123. on_error_cb_(std::move(on_error_cb)) {}
  124. std::unique_ptr<Input> CreateInput(
  125. const media::AudioParameters& params) final {
  126. return create_graph_input_cb_.Run(params);
  127. }
  128. MOCK_METHOD4(OnMoreData,
  129. int(base::TimeDelta delay,
  130. base::TimeTicks delay_timestamp,
  131. int prior_frames_skipped,
  132. media::AudioBus* dest));
  133. void OnError(AudioOutputStream::AudioSourceCallback::ErrorType type) final {
  134. on_error_cb_.Run(type);
  135. }
  136. void SimulateOnMoreData() {
  137. auto audio_bus = media::AudioBus::Create(2, 480);
  138. on_more_data_cb_.Run(*audio_bus.get(), base::TimeDelta());
  139. }
  140. private:
  141. MOCK_METHOD1(AddInput, void(MixingGraph::Input* input));
  142. MOCK_METHOD1(RemoveInput, void(MixingGraph::Input* input));
  143. CreateGraphInputCallback create_graph_input_cb_;
  144. MixingGraph::OnMoreDataCallback on_more_data_cb_;
  145. MixingGraph::OnErrorCallback on_error_cb_;
  146. };
  147. class OutputDeviceMixerImplTestBase {
  148. protected:
  149. enum class PlaybackMode { kMixing, kIndependent };
  150. // Holds all the mocks associated with a given audio output.
  151. struct MixTrackMock {
  152. explicit MixTrackMock(int frames_per_buffer)
  153. : params(media::AudioParameters::AUDIO_PCM_LOW_LATENCY,
  154. media::CHANNEL_LAYOUT_STEREO,
  155. 48000,
  156. frames_per_buffer) {}
  157. StrictMock<MockMixingGraphInput> graph_input;
  158. StrictMock<MockAudioOutputStream> rendering_stream;
  159. const media::AudioParameters params;
  160. StrictMock<MockAudioSourceCallback> source_callback;
  161. // Set to true when independent rendering started successfully for the first
  162. // time.
  163. bool independent_rendering_stream_was_open = false;
  164. };
  165. // Helper.
  166. struct StreamUnderTest {
  167. // MixableOutputStream produced by OutputMixerImpl.
  168. AudioOutputStream* mixable_stream;
  169. // All the mocks associated with it.
  170. MixTrackMock* mix_track_mock;
  171. };
  172. OutputDeviceMixerImplTestBase() {
  173. ON_CALL(*this, MockCreateOutputStream).WillByDefault(Return(true));
  174. }
  175. // Registers physical output stream creation.
  176. MOCK_METHOD1(MockCreateOutputStream,
  177. bool(const media::AudioParameters& params));
  178. // Creates the mixer for testing, passing callbacks to produce mock
  179. // MixingGraph and mock physical output stream_under_test.
  180. std::unique_ptr<OutputDeviceMixer> CreateMixerUnderTest(
  181. const std::string& device_id = kDeviceId) {
  182. auto mixer = std::make_unique<OutputDeviceMixerImpl>(
  183. device_id, mixer_output_params_,
  184. base::BindOnce(&OutputDeviceMixerImplTestBase::CreateMockMixingGraph,
  185. base::Unretained(this)),
  186. base::BindRepeating(&OutputDeviceMixerImplTestBase::CreateOutputStream,
  187. base::Unretained(this), device_id));
  188. return mixer;
  189. }
  190. // Helper which calls the mixer to create an output stream
  191. // (MixabeOutputStream) and associates the result output stream with its
  192. // corresponding set of mocks.
  193. StreamUnderTest CreateNextStreamUnderTest(OutputDeviceMixer* mixer) {
  194. EXPECT_LE(mix_track_mocks_in_use_count_, mix_track_mocks_.size() - 1);
  195. const media::AudioParameters params =
  196. mix_track_mocks_[mix_track_mocks_in_use_count_].params;
  197. return {mixer->MakeMixableStream(
  198. params,
  199. base::BindOnce(
  200. &OutputDeviceMixerImplTestBase::OnDeviceChangeForMixMember,
  201. base::Unretained(this), params)),
  202. &mix_track_mocks_[mix_track_mocks_in_use_count_++]};
  203. }
  204. void ExpectIndependentRenderingStreamStreamClosedIfItWasOpen(
  205. StreamUnderTest& stream_under_test) {
  206. if (stream_under_test.mix_track_mock
  207. ->independent_rendering_stream_was_open) {
  208. EXPECT_CALL(stream_under_test.mix_track_mock->rendering_stream, Close());
  209. }
  210. }
  211. // Opens a MixabeOutputStream created by the mixer under test and sets
  212. // expectations on associated mocks.
  213. void OpenAndVerifyStreamUnderTest(StreamUnderTest& stream_under_test,
  214. PlaybackMode playback_mode) {
  215. if (playback_mode == PlaybackMode::kIndependent) {
  216. SetIndependentRenderingStreamOpenExpectations(
  217. stream_under_test.mix_track_mock, /*open_success=*/true);
  218. }
  219. EXPECT_TRUE(stream_under_test.mixable_stream->Open());
  220. VerifyAndClearAllExpectations();
  221. }
  222. // Closes a MixabeOutputStream created by the mixer under test and sets
  223. // expectations on associated mocks.
  224. void CloseAndVerifyStreamUnderTest(StreamUnderTest& stream_under_test) {
  225. ExpectIndependentRenderingStreamStreamClosedIfItWasOpen(stream_under_test);
  226. stream_under_test.mixable_stream->Close();
  227. VerifyAndClearAllExpectations();
  228. }
  229. // Starts a MixabeOutputStream created by the mixer under test and sets
  230. // expectations on associated mocks. |playback_mode| is the mode
  231. // OutputMixerImpl is expected to be in at the moment.
  232. void StartAndVerifyStreamUnderTest(StreamUnderTest& stream_under_test,
  233. PlaybackMode playback_mode) {
  234. ExpectPlaybackStarted(stream_under_test.mix_track_mock, playback_mode);
  235. stream_under_test.mixable_stream->Start(
  236. &stream_under_test.mix_track_mock->source_callback);
  237. VerifyAndClearAllExpectations();
  238. }
  239. // Stops a MixabeOutputStream created by the mixer under test and sets
  240. // expectations on associated mocks. |playback_mode| is the mode
  241. // OutputMixerImpl is expected to be in at the moment.
  242. void StopAndVerifyStreamUnderTest(StreamUnderTest& stream_under_test,
  243. PlaybackMode playback_mode) {
  244. ExpectPlaybackStopped(stream_under_test.mix_track_mock, playback_mode);
  245. stream_under_test.mixable_stream->Stop();
  246. VerifyAndClearAllExpectations();
  247. }
  248. // Sets expectations for the mixer to open the mixing stream.
  249. void ExpectMixingGraphOutputStreamOpen() {
  250. EXPECT_CALL(*this,
  251. MockCreateOutputStream(AudioParamsEq(mixer_output_params_)));
  252. EXPECT_CALL(mock_mixing_graph_output_stream_, Open())
  253. .WillOnce(Return(true));
  254. }
  255. void ExpectMixingGraphOutputStreamClosed() {
  256. EXPECT_CALL(mock_mixing_graph_output_stream_, Close());
  257. }
  258. // Sets expectations for the mixer to start rendering mixed audio.
  259. void ExpectMixingGraphOutputStreamStarted() {
  260. EXPECT_CALL(mock_mixing_graph_output_stream_, StartCalled());
  261. mixing_graph_output_stream_not_running_ = false;
  262. }
  263. // Sets expectations for the mixer to stop rendering mixed audio.
  264. void ExpectMixingGraphOutputStreamStopped() {
  265. EXPECT_CALL(mock_mixing_graph_output_stream_, Stop);
  266. mixing_graph_output_stream_not_running_ = true;
  267. }
  268. void SetIndependentRenderingStreamOpenExpectations(
  269. MixTrackMock* mix_track_mock,
  270. bool open_success) {
  271. ASSERT_FALSE(mix_track_mock->independent_rendering_stream_was_open);
  272. EXPECT_CALL(*this,
  273. MockCreateOutputStream(AudioParamsEq(mix_track_mock->params)));
  274. EXPECT_CALL(mix_track_mock->rendering_stream, Open())
  275. .WillOnce(Return(open_success));
  276. if (!open_success) {
  277. EXPECT_CALL(mix_track_mock->rendering_stream, Close());
  278. }
  279. mix_track_mock->independent_rendering_stream_was_open = open_success;
  280. }
  281. void ExpectPlaybackStarted(MixTrackMock* mix_track_mock,
  282. PlaybackMode playback_mode) {
  283. if (playback_mode == PlaybackMode::kIndependent) {
  284. if (!mix_track_mock->independent_rendering_stream_was_open) {
  285. // If opening rendering stream during creation failed, it must be open
  286. // on first start.
  287. SetIndependentRenderingStreamOpenExpectations(mix_track_mock,
  288. /*open_success=*/true);
  289. }
  290. EXPECT_CALL(mix_track_mock->rendering_stream, StartCalled());
  291. } else {
  292. EXPECT_CALL(mix_track_mock->graph_input,
  293. Start(&mix_track_mock->source_callback));
  294. if (mixing_graph_output_stream_not_running_) {
  295. ExpectMixingGraphOutputStreamStarted();
  296. }
  297. }
  298. }
  299. void ExpectPlaybackStopped(MixTrackMock* mix_track_mock,
  300. PlaybackMode playback_mode) {
  301. if (playback_mode == PlaybackMode::kIndependent) {
  302. if (mix_track_mock->independent_rendering_stream_was_open) {
  303. EXPECT_CALL(mix_track_mock->rendering_stream, Stop);
  304. }
  305. } else {
  306. EXPECT_CALL(mix_track_mock->graph_input, Stop);
  307. }
  308. }
  309. // Sets "start mixing" expectations for a given set of mocks.
  310. void ExpectMixingStarted(const std::set<MixTrackMock*>& mocks) {
  311. for (MixTrackMock* mock : mocks)
  312. EXPECT_CALL(mock->graph_input, Start(&mock->source_callback));
  313. if (mocks.size() && mixing_graph_output_stream_not_running_)
  314. ExpectMixingGraphOutputStreamStarted();
  315. }
  316. // Sets "stop mixing" expectations for a given set of mocks.
  317. void ExpectMixingStopped(const std::set<MixTrackMock*>& mocks) {
  318. for (MixTrackMock* mock : mocks)
  319. EXPECT_CALL(mock->graph_input, Stop);
  320. if (mocks.size() && !mixing_graph_output_stream_not_running_)
  321. ExpectMixingGraphOutputStreamStopped();
  322. }
  323. // Sets "start playing independently" expectations for a given set of mocks.
  324. void ExpectIndependentPlaybackStarted(const std::set<MixTrackMock*>& mocks) {
  325. for (MixTrackMock* mock : mocks)
  326. ExpectPlaybackStarted(mock, PlaybackMode::kIndependent);
  327. }
  328. // Sets "stop playing independently" expectations for a given set of mocks.
  329. void ExpectIndependentPlaybackStopped(const std::set<MixTrackMock*>& mocks) {
  330. for (MixTrackMock* mock : mocks)
  331. ExpectPlaybackStopped(mock, PlaybackMode::kIndependent);
  332. }
  333. // Sets "no playback change" expectations for a given set of mocks.
  334. void ExpectNoPlaybackModeChange(const std::set<MixTrackMock*>& mocks) {
  335. EXPECT_CALL(mock_mixing_graph_output_stream_, Stop).Times(0);
  336. EXPECT_CALL(mock_mixing_graph_output_stream_, StartCalled()).Times(0);
  337. for (MixTrackMock* mock : mocks) {
  338. EXPECT_CALL(mock->graph_input, Stop).Times(0);
  339. EXPECT_CALL(mock->rendering_stream, StartCalled()).Times(0);
  340. EXPECT_CALL(mock->graph_input, Start(_)).Times(0);
  341. EXPECT_CALL(mock->rendering_stream, Stop).Times(0);
  342. }
  343. }
  344. // Verifies and clears expectations on all mocks.
  345. void VerifyAndClearAllExpectations() {
  346. for (auto& mix_member_mock : mix_track_mocks_) {
  347. Mock::VerifyAndClearExpectations(&mix_member_mock.graph_input);
  348. Mock::VerifyAndClearExpectations(&mix_member_mock.rendering_stream);
  349. Mock::VerifyAndClearExpectations(&mix_member_mock.source_callback);
  350. }
  351. Mock::VerifyAndClearExpectations(&mock_mixing_graph_output_stream_);
  352. Mock::VerifyAndClearExpectations(this);
  353. }
  354. // Called when device change callback of a MixTrack is called.
  355. MOCK_METHOD1(OnDeviceChangeForMixMember,
  356. void(const media::AudioParameters& params));
  357. // Fast-forward to the point when delayed switch to unmixed playback must have
  358. // happened (if it was scheduled).
  359. void FastForwardToUnmixedPlayback() {
  360. task_environment_.FastForwardBy(
  361. OutputDeviceMixerImpl::kSwitchToUnmixedPlaybackDelay * 2);
  362. }
  363. raw_ptr<MockMixingGraph> mock_mixing_graph_ = nullptr;
  364. StrictMock<MockAudioOutputStream> mock_mixing_graph_output_stream_;
  365. const media::AudioParameters mixer_output_params_{
  366. media::AudioParameters::AUDIO_PCM_LOW_LATENCY,
  367. media::CHANNEL_LAYOUT_STEREO, 48000, 5};
  368. private:
  369. AudioOutputStream* CreateOutputStream(const std::string& expected_device_id,
  370. const std::string& device_id,
  371. const media::AudioParameters& params) {
  372. EXPECT_EQ(device_id, expected_device_id);
  373. if (!MockCreateOutputStream(params))
  374. return nullptr; // Fail stream creation.
  375. if (params.Equals(mixer_output_params_))
  376. return &mock_mixing_graph_output_stream_;
  377. return &(FindMixTrackMock(params)->rendering_stream);
  378. }
  379. // Passed into OutputMixerImpl as a callback producing MixingGraph.
  380. std::unique_ptr<MixingGraph> CreateMockMixingGraph(
  381. const media::AudioParameters& output_params,
  382. MixingGraph::OnMoreDataCallback on_more_data_cb,
  383. MixingGraph::OnErrorCallback on_error_cb) {
  384. auto mock_mixing_graph = std::make_unique<StrictMock<MockMixingGraph>>(
  385. base::BindRepeating(
  386. &OutputDeviceMixerImplTestBase::CreateMockGraphInput,
  387. base::Unretained(this)),
  388. std::move(on_more_data_cb), std::move(on_error_cb));
  389. mock_mixing_graph_ = mock_mixing_graph.get();
  390. return mock_mixing_graph;
  391. }
  392. // Passed into MockMixingGraph as a callback producing MixingGraph::Input
  393. // instances.
  394. std::unique_ptr<MixingGraph::Input> CreateMockGraphInput(
  395. const media::AudioParameters& params) {
  396. return std::make_unique<FakeMixingGraphInput>(
  397. params, &(FindMixTrackMock(params)->graph_input));
  398. }
  399. // Finds the mocks for MixableOutputStream created with given |params|.
  400. MixTrackMock* FindMixTrackMock(const media::AudioParameters& params) {
  401. for (auto& track_mock : mix_track_mocks_) {
  402. if (track_mock.params.Equals(params))
  403. return &track_mock;
  404. }
  405. DCHECK(false);
  406. return nullptr;
  407. }
  408. base::test::SingleThreadTaskEnvironment task_environment_{
  409. base::test::SingleThreadTaskEnvironment::TimeSource::MOCK_TIME};
  410. // A set of mocks for the data associated with MixableOutputStream; each mock
  411. // is identfied by its MixTrackMock::|params|.frames_per_buffer().
  412. // To create mixable_stream output streams_under_test the tests call
  413. // OutputDeviceMixerImpl::MakeMixableStream with MixTrackMock::|params|
  414. // parameters, thus building an association between a MixableOutputStream and
  415. // MixTrackMock.
  416. std::array<MixTrackMock, 3> mix_track_mocks_{
  417. MixTrackMock(10), MixTrackMock(20), MixTrackMock(30)};
  418. // How many elements of |mix_track_mocks_| are already in use.
  419. size_t mix_track_mocks_in_use_count_ = 0;
  420. // Helps to correctly set expectations for |mock_mixing_graph_output_stream_|.
  421. bool mixing_graph_output_stream_not_running_ = true;
  422. };
  423. class OutputDeviceMixerImplTest : public OutputDeviceMixerImplTestBase,
  424. public testing::TestWithParam<int> {};
  425. class OutputDeviceMixerImplTestWithDefault
  426. : public OutputDeviceMixerImplTestBase,
  427. public testing::TestWithParam<std::string> {};
  428. TEST_P(OutputDeviceMixerImplTestWithDefault, OneUmixedStream_CreateClose) {
  429. std::unique_ptr<OutputDeviceMixer> mixer = CreateMixerUnderTest(GetParam());
  430. StreamUnderTest stream_under_test = CreateNextStreamUnderTest(mixer.get());
  431. // Physical output streams are created only on Open().
  432. EXPECT_CALL(*this, MockCreateOutputStream(_)).Times(0);
  433. EXPECT_CALL(stream_under_test.mix_track_mock->rendering_stream, Open())
  434. .Times(0);
  435. EXPECT_CALL(mock_mixing_graph_output_stream_, Open()).Times(0);
  436. EXPECT_CALL(stream_under_test.mix_track_mock->rendering_stream, Close())
  437. .Times(0);
  438. EXPECT_CALL(mock_mixing_graph_output_stream_, Close()).Times(0);
  439. CloseAndVerifyStreamUnderTest(stream_under_test);
  440. }
  441. TEST_F(OutputDeviceMixerImplTest, OneUmixedStream_PhysicalStreamCreateFailed) {
  442. std::unique_ptr<OutputDeviceMixer> mixer = CreateMixerUnderTest();
  443. StreamUnderTest stream_under_test = CreateNextStreamUnderTest(mixer.get());
  444. // Fail physical stream creation for the mix member. Open() fails, physical
  445. // stream for independent rendering is not created.
  446. EXPECT_CALL(*this, MockCreateOutputStream(AudioParamsEq(
  447. stream_under_test.mix_track_mock->params)))
  448. .WillOnce(Return(false));
  449. EXPECT_CALL(stream_under_test.mix_track_mock->rendering_stream, Open())
  450. .Times(0);
  451. EXPECT_CALL(stream_under_test.mix_track_mock->rendering_stream, Close())
  452. .Times(0);
  453. EXPECT_CALL(*this,
  454. MockCreateOutputStream(AudioParamsEq(mixer_output_params_)))
  455. .Times(0);
  456. EXPECT_CALL(mock_mixing_graph_output_stream_, Open()).Times(0);
  457. EXPECT_CALL(mock_mixing_graph_output_stream_, Close()).Times(0);
  458. EXPECT_FALSE(stream_under_test.mixable_stream->Open());
  459. CloseAndVerifyStreamUnderTest(stream_under_test);
  460. }
  461. TEST_F(OutputDeviceMixerImplTest, OneUmixedStream_PhysicalStreamOpenFailed) {
  462. std::unique_ptr<OutputDeviceMixer> mixer = CreateMixerUnderTest();
  463. StreamUnderTest stream_under_test = CreateNextStreamUnderTest(mixer.get());
  464. // Fail opening physical stream for the mix track. Open() fails, physical
  465. // stream for independent rendering is not created.
  466. SetIndependentRenderingStreamOpenExpectations(
  467. stream_under_test.mix_track_mock,
  468. /*open_success=*/false);
  469. EXPECT_CALL(mock_mixing_graph_output_stream_, Open()).Times(0);
  470. EXPECT_CALL(mock_mixing_graph_output_stream_, Close()).Times(0);
  471. EXPECT_FALSE(stream_under_test.mixable_stream->Open());
  472. CloseAndVerifyStreamUnderTest(stream_under_test);
  473. }
  474. TEST_P(OutputDeviceMixerImplTestWithDefault, OneUmixedStream_CreateOpenClose) {
  475. std::unique_ptr<OutputDeviceMixer> mixer = CreateMixerUnderTest(GetParam());
  476. StreamUnderTest stream_under_test = CreateNextStreamUnderTest(mixer.get());
  477. OpenAndVerifyStreamUnderTest(stream_under_test, PlaybackMode::kIndependent);
  478. CloseAndVerifyStreamUnderTest(stream_under_test);
  479. }
  480. TEST_F(OutputDeviceMixerImplTest, TwoUmixedStream_CreateOpenClose) {
  481. std::unique_ptr<OutputDeviceMixer> mixer = CreateMixerUnderTest();
  482. StreamUnderTest stream_under_test1 = CreateNextStreamUnderTest(mixer.get());
  483. StreamUnderTest stream_under_test2 = CreateNextStreamUnderTest(mixer.get());
  484. OpenAndVerifyStreamUnderTest(stream_under_test1, PlaybackMode::kIndependent);
  485. OpenAndVerifyStreamUnderTest(stream_under_test2, PlaybackMode::kIndependent);
  486. CloseAndVerifyStreamUnderTest(stream_under_test2);
  487. CloseAndVerifyStreamUnderTest(stream_under_test1);
  488. }
  489. TEST_F(OutputDeviceMixerImplTest,
  490. TwoUmixedStream_SecondOpenFailureDoesNotAffectMixerStream) {
  491. std::unique_ptr<OutputDeviceMixer> mixer = CreateMixerUnderTest();
  492. StreamUnderTest stream_under_test1 = CreateNextStreamUnderTest(mixer.get());
  493. StreamUnderTest stream_under_test2 = CreateNextStreamUnderTest(mixer.get());
  494. OpenAndVerifyStreamUnderTest(stream_under_test1, PlaybackMode::kIndependent);
  495. StartAndVerifyStreamUnderTest(stream_under_test1, PlaybackMode::kIndependent);
  496. // Failing to open stream_under_test2 does not affect stream_under_test2.
  497. SetIndependentRenderingStreamOpenExpectations(
  498. stream_under_test2.mix_track_mock, /*open_success=*/false);
  499. EXPECT_FALSE(stream_under_test2.mixable_stream->Open());
  500. VerifyAndClearAllExpectations();
  501. CloseAndVerifyStreamUnderTest(stream_under_test2);
  502. StopAndVerifyStreamUnderTest(stream_under_test1, PlaybackMode::kIndependent);
  503. CloseAndVerifyStreamUnderTest(stream_under_test1);
  504. }
  505. TEST_F(OutputDeviceMixerImplTest, OneUmixedStream_SetVolumeIsPropagated) {
  506. std::unique_ptr<OutputDeviceMixer> mixer = CreateMixerUnderTest();
  507. StreamUnderTest stream_under_test = CreateNextStreamUnderTest(mixer.get());
  508. double volume1 = 0.1;
  509. double volume2 = 0.2;
  510. double volume3 = 0.3;
  511. double volume4 = 0.3;
  512. double volume_result = 0;
  513. // Volume is propagated before MixableOutputStream::Open().
  514. stream_under_test.mixable_stream->SetVolume(volume1);
  515. stream_under_test.mixable_stream->GetVolume(&volume_result);
  516. EXPECT_EQ(volume_result, volume1);
  517. EXPECT_EQ(stream_under_test.mix_track_mock->graph_input.GetVolume(), volume1);
  518. stream_under_test.mixable_stream->SetVolume(volume2);
  519. stream_under_test.mixable_stream->GetVolume(&volume_result);
  520. EXPECT_EQ(volume_result, volume2);
  521. EXPECT_EQ(stream_under_test.mix_track_mock->graph_input.GetVolume(), volume2);
  522. OpenAndVerifyStreamUnderTest(stream_under_test, PlaybackMode::kIndependent);
  523. // Volume is propagated after MixableOutputStream::Open().
  524. stream_under_test.mixable_stream->GetVolume(&volume_result);
  525. EXPECT_EQ(volume_result, volume2);
  526. EXPECT_EQ(stream_under_test.mix_track_mock->graph_input.GetVolume(), volume2);
  527. StartAndVerifyStreamUnderTest(stream_under_test, PlaybackMode::kIndependent);
  528. // Volume is applied to the independent rendering stream of the MixTrack.
  529. EXPECT_EQ(stream_under_test.mix_track_mock->rendering_stream.GetVolume(),
  530. volume2);
  531. // Now when the stream is open, the volume is propagated to both the mixer
  532. // input and the independent rendering tream of the MixTrack.
  533. stream_under_test.mixable_stream->SetVolume(volume3);
  534. stream_under_test.mixable_stream->GetVolume(&volume_result);
  535. EXPECT_EQ(volume_result, volume3);
  536. EXPECT_EQ(stream_under_test.mix_track_mock->graph_input.GetVolume(), volume3);
  537. EXPECT_EQ(stream_under_test.mix_track_mock->rendering_stream.GetVolume(),
  538. volume3);
  539. StopAndVerifyStreamUnderTest(stream_under_test, PlaybackMode::kIndependent);
  540. stream_under_test.mixable_stream->SetVolume(volume4);
  541. stream_under_test.mixable_stream->GetVolume(&volume_result);
  542. EXPECT_EQ(volume_result, volume4);
  543. EXPECT_EQ(stream_under_test.mix_track_mock->graph_input.GetVolume(), volume4);
  544. EXPECT_EQ(stream_under_test.mix_track_mock->rendering_stream.GetVolume(),
  545. volume4);
  546. CloseAndVerifyStreamUnderTest(stream_under_test);
  547. }
  548. TEST_F(OutputDeviceMixerImplTest,
  549. OneUmixedStream_CreateOpenPlayOnErrorStopClose) {
  550. std::unique_ptr<OutputDeviceMixer> mixer = CreateMixerUnderTest();
  551. StreamUnderTest stream_under_test = CreateNextStreamUnderTest(mixer.get());
  552. OpenAndVerifyStreamUnderTest(stream_under_test, PlaybackMode::kIndependent);
  553. {
  554. InSequence s;
  555. StartAndVerifyStreamUnderTest(stream_under_test,
  556. PlaybackMode::kIndependent);
  557. EXPECT_CALL(stream_under_test.mix_track_mock->source_callback,
  558. OnMoreData(_, _, _, _))
  559. .Times(1);
  560. EXPECT_CALL(stream_under_test.mix_track_mock->source_callback, OnError(_))
  561. .Times(1);
  562. stream_under_test.mix_track_mock->rendering_stream.SimulateOnMoreData();
  563. stream_under_test.mix_track_mock->rendering_stream.SimulateError();
  564. VerifyAndClearAllExpectations();
  565. StopAndVerifyStreamUnderTest(stream_under_test, PlaybackMode::kIndependent);
  566. }
  567. // Make sure it works after restart as well.
  568. {
  569. InSequence s;
  570. StartAndVerifyStreamUnderTest(stream_under_test,
  571. PlaybackMode::kIndependent);
  572. EXPECT_CALL(stream_under_test.mix_track_mock->source_callback,
  573. OnMoreData(_, _, _, _))
  574. .Times(1);
  575. EXPECT_CALL(stream_under_test.mix_track_mock->source_callback, OnError(_))
  576. .Times(1);
  577. stream_under_test.mix_track_mock->rendering_stream.SimulateOnMoreData();
  578. stream_under_test.mix_track_mock->rendering_stream.SimulateError();
  579. VerifyAndClearAllExpectations();
  580. StopAndVerifyStreamUnderTest(stream_under_test, PlaybackMode::kIndependent);
  581. }
  582. CloseAndVerifyStreamUnderTest(stream_under_test);
  583. }
  584. TEST_P(OutputDeviceMixerImplTest,
  585. NStreamsOpen_StartStopListeningDoesNotStartMixing) {
  586. std::unique_ptr<OutputDeviceMixer> mixer = CreateMixerUnderTest();
  587. int stream_count = GetParam();
  588. std::vector<StreamUnderTest> streams_under_test;
  589. std::set<MixTrackMock*> playing_stream_mocks;
  590. for (int i = 0; i < stream_count; ++i) {
  591. streams_under_test.push_back(CreateNextStreamUnderTest(mixer.get()));
  592. OpenAndVerifyStreamUnderTest(streams_under_test.back(),
  593. PlaybackMode::kIndependent);
  594. }
  595. // The mixer may have streams open, but they are not playing, so
  596. // Start/StopListening has no effect.
  597. MockListener listener;
  598. ExpectMixingGraphOutputStreamOpen();
  599. mixer->StartListening(&listener);
  600. VerifyAndClearAllExpectations();
  601. ExpectMixingGraphOutputStreamClosed();
  602. mixer->StopListening(&listener);
  603. VerifyAndClearAllExpectations();
  604. FastForwardToUnmixedPlayback();
  605. for (auto& stream_under_test : streams_under_test) {
  606. CloseAndVerifyStreamUnderTest(stream_under_test);
  607. }
  608. }
  609. TEST_P(OutputDeviceMixerImplTest, NStreamsPlaying_StartStopTwoListeners) {
  610. std::unique_ptr<OutputDeviceMixer> mixer = CreateMixerUnderTest();
  611. int stream_count = GetParam();
  612. if (!stream_count)
  613. return; // Not interesting.
  614. std::vector<StreamUnderTest> streams_under_test;
  615. std::set<MixTrackMock*> playing_stream_mocks;
  616. for (int i = 0; i < stream_count; ++i) {
  617. streams_under_test.push_back(CreateNextStreamUnderTest(mixer.get()));
  618. OpenAndVerifyStreamUnderTest(streams_under_test.back(),
  619. PlaybackMode::kIndependent);
  620. StartAndVerifyStreamUnderTest(streams_under_test.back(),
  621. PlaybackMode::kIndependent);
  622. playing_stream_mocks.insert((&streams_under_test.back())->mix_track_mock);
  623. }
  624. MockListener listener1;
  625. MockListener listener2;
  626. // We are playing at least one stream.
  627. // Expect switch to mixing when the first listener comes.
  628. ExpectIndependentPlaybackStopped(playing_stream_mocks);
  629. ExpectMixingGraphOutputStreamOpen();
  630. ExpectMixingStarted(playing_stream_mocks);
  631. mixer->StartListening(&listener1);
  632. FastForwardToUnmixedPlayback();
  633. VerifyAndClearAllExpectations();
  634. // Nothing should change when the second listener comes.
  635. ExpectNoPlaybackModeChange(playing_stream_mocks);
  636. mixer->StartListening(&listener2);
  637. FastForwardToUnmixedPlayback();
  638. VerifyAndClearAllExpectations();
  639. // First listener leaves: we still should be mixing.
  640. ExpectNoPlaybackModeChange(playing_stream_mocks);
  641. mixer->StopListening(&listener1);
  642. FastForwardToUnmixedPlayback();
  643. VerifyAndClearAllExpectations();
  644. // Second listener leaves: switching to unmixed playback is delayed, so we do
  645. // not expect it to happen immediately.
  646. ExpectNoPlaybackModeChange(playing_stream_mocks);
  647. mixer->StopListening(&listener2);
  648. VerifyAndClearAllExpectations();
  649. // Expect switching to unmixed playback after we fast-forward to the future.
  650. ExpectMixingGraphOutputStreamClosed();
  651. ExpectMixingStopped(playing_stream_mocks);
  652. ExpectIndependentPlaybackStarted(playing_stream_mocks);
  653. FastForwardToUnmixedPlayback();
  654. VerifyAndClearAllExpectations();
  655. for (auto& stream_under_test : streams_under_test) {
  656. StopAndVerifyStreamUnderTest(stream_under_test, PlaybackMode::kIndependent);
  657. CloseAndVerifyStreamUnderTest(stream_under_test);
  658. }
  659. }
  660. TEST_P(OutputDeviceMixerImplTest,
  661. NStreamsPlaying_StopStartListening_DoesNotStopMixing) {
  662. std::unique_ptr<OutputDeviceMixer> mixer = CreateMixerUnderTest();
  663. int stream_count = GetParam();
  664. if (!stream_count)
  665. return; // Not interesting.
  666. std::vector<StreamUnderTest> streams_under_test;
  667. std::set<MixTrackMock*> playing_stream_mocks;
  668. for (int i = 0; i < stream_count; ++i) {
  669. streams_under_test.push_back(CreateNextStreamUnderTest(mixer.get()));
  670. OpenAndVerifyStreamUnderTest(streams_under_test.back(),
  671. PlaybackMode::kIndependent);
  672. StartAndVerifyStreamUnderTest(streams_under_test.back(),
  673. PlaybackMode::kIndependent);
  674. playing_stream_mocks.insert((&streams_under_test.back())->mix_track_mock);
  675. }
  676. MockListener listener;
  677. // We are playing at least one stream.
  678. // Expect switch to mixing when the listener comes.
  679. ExpectIndependentPlaybackStopped(playing_stream_mocks);
  680. ExpectMixingGraphOutputStreamOpen();
  681. ExpectMixingStarted(playing_stream_mocks);
  682. mixer->StartListening(&listener);
  683. FastForwardToUnmixedPlayback();
  684. VerifyAndClearAllExpectations();
  685. // If the listener stops listening and then starts again immediately, we do
  686. // not switch to unmixed playback even after the timeout.
  687. ExpectNoPlaybackModeChange(playing_stream_mocks);
  688. mixer->StopListening(&listener);
  689. mixer->StartListening(&listener);
  690. FastForwardToUnmixedPlayback();
  691. VerifyAndClearAllExpectations();
  692. // Stop listening and expect the switch to unmixed playback upon the timeout.
  693. ExpectMixingStopped(playing_stream_mocks);
  694. ExpectMixingGraphOutputStreamClosed();
  695. ExpectIndependentPlaybackStarted(playing_stream_mocks);
  696. mixer->StopListening(&listener);
  697. FastForwardToUnmixedPlayback();
  698. VerifyAndClearAllExpectations();
  699. for (auto& stream_under_test : streams_under_test) {
  700. StopAndVerifyStreamUnderTest(stream_under_test, PlaybackMode::kIndependent);
  701. CloseAndVerifyStreamUnderTest(stream_under_test);
  702. }
  703. }
  704. TEST_P(OutputDeviceMixerImplTest,
  705. StartStopNStreamsWhileListening_MixedPlaybackUntilListenerGone) {
  706. std::unique_ptr<OutputDeviceMixer> mixer = CreateMixerUnderTest();
  707. int stream_count = GetParam();
  708. if (!stream_count)
  709. return; // Not interesting.
  710. MockListener listener;
  711. ExpectMixingGraphOutputStreamOpen();
  712. mixer->StartListening(&listener);
  713. VerifyAndClearAllExpectations();
  714. std::vector<StreamUnderTest> streams_under_test;
  715. for (int i = 0; i < stream_count; ++i) {
  716. streams_under_test.push_back(CreateNextStreamUnderTest(mixer.get()));
  717. OpenAndVerifyStreamUnderTest(streams_under_test.back(),
  718. PlaybackMode::kMixing);
  719. StartAndVerifyStreamUnderTest(streams_under_test.back(),
  720. PlaybackMode::kMixing);
  721. }
  722. // Stopping all playback does not stop rendering of the mixing graph.
  723. for (auto& stream_under_test : streams_under_test) {
  724. StopAndVerifyStreamUnderTest(stream_under_test, PlaybackMode::kMixing);
  725. FastForwardToUnmixedPlayback();
  726. VerifyAndClearAllExpectations();
  727. }
  728. // Restarting playback.
  729. for (auto& stream_under_test : streams_under_test) {
  730. StartAndVerifyStreamUnderTest(stream_under_test, PlaybackMode::kMixing);
  731. FastForwardToUnmixedPlayback();
  732. VerifyAndClearAllExpectations();
  733. }
  734. // Stopping and closing all the streams does not stop rendering of the mixing
  735. // graph.
  736. for (auto& stream_under_test : streams_under_test) {
  737. StopAndVerifyStreamUnderTest(stream_under_test, PlaybackMode::kMixing);
  738. CloseAndVerifyStreamUnderTest(stream_under_test);
  739. }
  740. FastForwardToUnmixedPlayback();
  741. VerifyAndClearAllExpectations();
  742. // Now when we stop the listener, rendering of the mixing graph should
  743. // stop immediately. Mixing graph output stream will be closed.
  744. ExpectMixingGraphOutputStreamStopped();
  745. ExpectMixingGraphOutputStreamClosed();
  746. mixer->StopListening(&listener);
  747. VerifyAndClearAllExpectations();
  748. }
  749. TEST_P(OutputDeviceMixerImplTest, StartStopNStreamsWhileListening_DeleteMixer) {
  750. std::unique_ptr<OutputDeviceMixer> mixer = CreateMixerUnderTest();
  751. MockListener listener;
  752. ExpectMixingGraphOutputStreamOpen();
  753. mixer->StartListening(&listener);
  754. VerifyAndClearAllExpectations();
  755. int stream_count = GetParam();
  756. std::vector<StreamUnderTest> streams_under_test;
  757. for (int i = 0; i < stream_count; ++i) {
  758. streams_under_test.push_back(CreateNextStreamUnderTest(mixer.get()));
  759. OpenAndVerifyStreamUnderTest(streams_under_test.back(),
  760. PlaybackMode::kMixing);
  761. StartAndVerifyStreamUnderTest(streams_under_test.back(),
  762. PlaybackMode::kMixing);
  763. }
  764. for (auto& stream_under_test : streams_under_test) {
  765. StopAndVerifyStreamUnderTest(stream_under_test, PlaybackMode::kMixing);
  766. CloseAndVerifyStreamUnderTest(stream_under_test);
  767. }
  768. if (stream_count)
  769. ExpectMixingGraphOutputStreamStopped();
  770. ExpectMixingGraphOutputStreamClosed();
  771. mixer->StopListening(&listener);
  772. mixer = nullptr;
  773. // Mixer output stream must be closed immediately.
  774. VerifyAndClearAllExpectations();
  775. }
  776. TEST_F(OutputDeviceMixerImplTest,
  777. DeleteMixer_WhileGraphOutputStreamStopIsDelayed) {
  778. std::unique_ptr<OutputDeviceMixer> mixer = CreateMixerUnderTest();
  779. MockListener listener;
  780. ExpectMixingGraphOutputStreamOpen();
  781. mixer->StartListening(&listener);
  782. VerifyAndClearAllExpectations();
  783. auto stream_under_test = CreateNextStreamUnderTest(mixer.get());
  784. OpenAndVerifyStreamUnderTest(stream_under_test, PlaybackMode::kMixing);
  785. StartAndVerifyStreamUnderTest(stream_under_test, PlaybackMode::kMixing);
  786. mixer->StopListening(&listener);
  787. // Since there are no listeners left, mixing playback must be stopped as soon
  788. // as the stream is gone.
  789. ExpectMixingGraphOutputStreamStopped();
  790. ExpectMixingGraphOutputStreamClosed();
  791. StopAndVerifyStreamUnderTest(stream_under_test, PlaybackMode::kMixing);
  792. CloseAndVerifyStreamUnderTest(stream_under_test);
  793. mixer = nullptr;
  794. VerifyAndClearAllExpectations();
  795. }
  796. TEST_P(OutputDeviceMixerImplTest, NStreamsMixing_OnMixingStreamError) {
  797. std::unique_ptr<OutputDeviceMixer> mixer = CreateMixerUnderTest();
  798. int stream_count = GetParam();
  799. if (!stream_count)
  800. return; // Not interesting.
  801. MockListener listener;
  802. ExpectMixingGraphOutputStreamOpen();
  803. mixer->StartListening(&listener);
  804. VerifyAndClearAllExpectations();
  805. std::vector<StreamUnderTest> streams_under_test;
  806. std::set<MixTrackMock*> playing_stream_mocks;
  807. for (int i = 0; i < stream_count; ++i) {
  808. streams_under_test.push_back(CreateNextStreamUnderTest(mixer.get()));
  809. OpenAndVerifyStreamUnderTest(streams_under_test.back(),
  810. PlaybackMode::kMixing);
  811. StartAndVerifyStreamUnderTest(streams_under_test.back(),
  812. PlaybackMode::kMixing);
  813. playing_stream_mocks.insert((&streams_under_test.back())->mix_track_mock);
  814. }
  815. for (auto& stream_under_test : streams_under_test)
  816. EXPECT_CALL(stream_under_test.mix_track_mock->source_callback, OnError(_));
  817. ExpectMixingStopped(playing_stream_mocks);
  818. ExpectMixingGraphOutputStreamClosed(); // To be able to recover in the
  819. // future.
  820. mock_mixing_graph_output_stream_.SimulateError();
  821. VerifyAndClearAllExpectations();
  822. for (auto& stream_under_test : streams_under_test) {
  823. StopAndVerifyStreamUnderTest(stream_under_test, PlaybackMode::kIndependent);
  824. }
  825. mixer->StopListening(&listener);
  826. for (auto& stream_under_test : streams_under_test) {
  827. CloseAndVerifyStreamUnderTest(stream_under_test);
  828. }
  829. mixer.reset();
  830. VerifyAndClearAllExpectations();
  831. }
  832. TEST_F(OutputDeviceMixerImplTest, OnMixingStreamError_Recovers) {
  833. std::unique_ptr<OutputDeviceMixer> mixer = CreateMixerUnderTest();
  834. MockListener listener;
  835. ExpectMixingGraphOutputStreamOpen();
  836. mixer->StartListening(&listener);
  837. VerifyAndClearAllExpectations();
  838. std::vector<StreamUnderTest> streams_under_test;
  839. std::set<MixTrackMock*> playing_stream_mocks;
  840. for (int i = 0; i < 2; ++i) {
  841. streams_under_test.push_back(CreateNextStreamUnderTest(mixer.get()));
  842. OpenAndVerifyStreamUnderTest(streams_under_test.back(),
  843. PlaybackMode::kMixing);
  844. StartAndVerifyStreamUnderTest(streams_under_test.back(),
  845. PlaybackMode::kMixing);
  846. playing_stream_mocks.insert((&streams_under_test.back())->mix_track_mock);
  847. }
  848. // Simulate the mixing stream error.
  849. for (auto& stream_under_test : streams_under_test)
  850. EXPECT_CALL(stream_under_test.mix_track_mock->source_callback, OnError(_));
  851. ExpectMixingStopped(playing_stream_mocks);
  852. ExpectMixingGraphOutputStreamClosed();
  853. mock_mixing_graph_output_stream_.SimulateError();
  854. VerifyAndClearAllExpectations();
  855. // Opening and starting a new stream: mixing should retry and start
  856. // successfully.
  857. streams_under_test.push_back(CreateNextStreamUnderTest(mixer.get()));
  858. OpenAndVerifyStreamUnderTest(streams_under_test.back(),
  859. PlaybackMode::kMixing);
  860. // Mixing should restart now.
  861. ExpectMixingGraphOutputStreamOpen();
  862. ExpectMixingStarted(playing_stream_mocks);
  863. StartAndVerifyStreamUnderTest(streams_under_test.back(),
  864. PlaybackMode::kMixing);
  865. VerifyAndClearAllExpectations();
  866. for (auto& stream_under_test : streams_under_test) {
  867. StopAndVerifyStreamUnderTest(stream_under_test, PlaybackMode::kMixing);
  868. }
  869. // No playback, the listener is gone - we should stop mixing.
  870. ExpectMixingGraphOutputStreamStopped();
  871. ExpectMixingGraphOutputStreamClosed();
  872. mixer->StopListening(&listener);
  873. VerifyAndClearAllExpectations();
  874. for (auto& stream_under_test : streams_under_test) {
  875. CloseAndVerifyStreamUnderTest(stream_under_test);
  876. }
  877. }
  878. TEST_P(OutputDeviceMixerImplTest, NStreamsPlayingUmixed_DeviceChange) {
  879. std::unique_ptr<OutputDeviceMixer> mixer = CreateMixerUnderTest();
  880. int stream_count = GetParam();
  881. std::vector<StreamUnderTest> streams_under_test;
  882. for (int i = 0; i < stream_count; ++i) {
  883. streams_under_test.push_back(CreateNextStreamUnderTest(mixer.get()));
  884. OpenAndVerifyStreamUnderTest(streams_under_test.back(),
  885. PlaybackMode::kIndependent);
  886. if (i) { // Leave one stream just open.
  887. StartAndVerifyStreamUnderTest(streams_under_test.back(),
  888. PlaybackMode::kIndependent);
  889. }
  890. }
  891. for (int i = 0; i < stream_count; ++i) {
  892. if (i) {
  893. EXPECT_CALL(streams_under_test[i].mix_track_mock->rendering_stream, Stop);
  894. }
  895. ExpectIndependentRenderingStreamStreamClosedIfItWasOpen(
  896. streams_under_test[i]);
  897. EXPECT_CALL(*this, OnDeviceChangeForMixMember(AudioParamsEq(
  898. streams_under_test[i].mix_track_mock->params)));
  899. }
  900. mixer->ProcessDeviceChange();
  901. VerifyAndClearAllExpectations();
  902. // Stop() and Close() operations on streams are no-op now.
  903. for (int i = 0; i < stream_count; ++i) {
  904. if (i) {
  905. streams_under_test[i].mixable_stream->Stop();
  906. }
  907. streams_under_test[i].mixable_stream->Close();
  908. }
  909. }
  910. TEST_P(OutputDeviceMixerImplTest, NStreamsPlayingMixed_DeviceChange) {
  911. std::unique_ptr<OutputDeviceMixer> mixer = CreateMixerUnderTest();
  912. int stream_count = GetParam();
  913. MockListener listener;
  914. ExpectMixingGraphOutputStreamOpen();
  915. mixer->StartListening(&listener);
  916. VerifyAndClearAllExpectations();
  917. std::vector<StreamUnderTest> streams_under_test;
  918. for (int i = 0; i < stream_count; ++i) {
  919. streams_under_test.push_back(CreateNextStreamUnderTest(mixer.get()));
  920. OpenAndVerifyStreamUnderTest(streams_under_test.back(),
  921. PlaybackMode::kMixing);
  922. if (i) { // Leave one stream just open.
  923. StartAndVerifyStreamUnderTest(streams_under_test.back(),
  924. PlaybackMode::kMixing);
  925. }
  926. }
  927. for (int i = 0; i < stream_count; ++i) {
  928. if (i) {
  929. EXPECT_CALL(streams_under_test[i].mix_track_mock->graph_input, Stop);
  930. }
  931. ExpectIndependentRenderingStreamStreamClosedIfItWasOpen(
  932. streams_under_test[i]);
  933. EXPECT_CALL(*this, OnDeviceChangeForMixMember(AudioParamsEq(
  934. streams_under_test[i].mix_track_mock->params)));
  935. }
  936. if (stream_count > 1) // Since we do not start the first stream.
  937. ExpectMixingGraphOutputStreamStopped();
  938. ExpectMixingGraphOutputStreamClosed();
  939. mixer->ProcessDeviceChange();
  940. VerifyAndClearAllExpectations();
  941. // Stop() and Close() operations on streams are no-op now.
  942. for (int i = 0; i < stream_count; ++i) {
  943. if (i) {
  944. streams_under_test[i].mixable_stream->Stop();
  945. }
  946. streams_under_test[i].mixable_stream->Close();
  947. }
  948. }
  949. TEST_F(OutputDeviceMixerImplTest, OnMoreDataDeliversCallbacks) {
  950. std::unique_ptr<OutputDeviceMixer> mixer = CreateMixerUnderTest();
  951. MockListener listener1;
  952. MockListener listener2;
  953. ExpectMixingGraphOutputStreamOpen();
  954. mixer->StartListening(&listener1);
  955. VerifyAndClearAllExpectations();
  956. StreamUnderTest stream_under_test = CreateNextStreamUnderTest(mixer.get());
  957. OpenAndVerifyStreamUnderTest(stream_under_test, PlaybackMode::kMixing);
  958. StartAndVerifyStreamUnderTest(stream_under_test, PlaybackMode::kMixing);
  959. EXPECT_CALL(listener1, OnPlayoutData(_, _, _)).Times(1);
  960. mock_mixing_graph_->SimulateOnMoreData();
  961. VerifyAndClearAllExpectations();
  962. mixer->StartListening(&listener2);
  963. EXPECT_CALL(listener1, OnPlayoutData(_, _, _)).Times(1);
  964. EXPECT_CALL(listener2, OnPlayoutData(_, _, _)).Times(1);
  965. mock_mixing_graph_->SimulateOnMoreData();
  966. VerifyAndClearAllExpectations();
  967. mixer->StopListening(&listener1);
  968. EXPECT_CALL(listener2, OnPlayoutData(_, _, _)).Times(1);
  969. mock_mixing_graph_->SimulateOnMoreData();
  970. VerifyAndClearAllExpectations();
  971. StopAndVerifyStreamUnderTest(stream_under_test, PlaybackMode::kMixing);
  972. CloseAndVerifyStreamUnderTest(stream_under_test);
  973. ExpectMixingGraphOutputStreamStopped();
  974. ExpectMixingGraphOutputStreamClosed();
  975. mixer->StopListening(&listener2);
  976. }
  977. TEST_F(OutputDeviceMixerImplTest,
  978. MixingStreamCreationFailureHandledOnMixingPlaybackStart) {
  979. std::unique_ptr<OutputDeviceMixer> mixer = CreateMixerUnderTest();
  980. MockListener listener;
  981. // Fail creating the mixing stream.
  982. EXPECT_CALL(*this,
  983. MockCreateOutputStream(AudioParamsEq(mixer_output_params_)))
  984. .WillOnce(Return(false));
  985. mixer->StartListening(&listener);
  986. VerifyAndClearAllExpectations();
  987. StreamUnderTest stream_under_test = CreateNextStreamUnderTest(mixer.get());
  988. OpenAndVerifyStreamUnderTest(stream_under_test, PlaybackMode::kMixing);
  989. // Since the previous attempt to create the mixing stream failed, it will
  990. // retry now when starting mixing playback. Fail it again.
  991. EXPECT_CALL(*this,
  992. MockCreateOutputStream(AudioParamsEq(mixer_output_params_)))
  993. .WillOnce(Return(false));
  994. EXPECT_CALL(stream_under_test.mix_track_mock->source_callback, OnError(_));
  995. stream_under_test.mixable_stream->Start(
  996. &stream_under_test.mix_track_mock->source_callback);
  997. VerifyAndClearAllExpectations();
  998. // Since mixing has not started, the mixer considers it as independent
  999. // playback and will stop the independent rendering stream. It's ok:
  1000. // media::AudioOutputStream can be closed multiple times.
  1001. StopAndVerifyStreamUnderTest(stream_under_test, PlaybackMode::kIndependent);
  1002. CloseAndVerifyStreamUnderTest(stream_under_test);
  1003. mixer->StopListening(&listener);
  1004. }
  1005. TEST_F(OutputDeviceMixerImplTest,
  1006. MixingStreamOpenFailureHandled_ListenerPresent) {
  1007. std::unique_ptr<OutputDeviceMixer> mixer = CreateMixerUnderTest();
  1008. MockListener listener;
  1009. // Fail opening the mixing stream.
  1010. EXPECT_CALL(*this,
  1011. MockCreateOutputStream(AudioParamsEq(mixer_output_params_)));
  1012. EXPECT_CALL(mock_mixing_graph_output_stream_, Open()).WillOnce(Return(false));
  1013. EXPECT_CALL(mock_mixing_graph_output_stream_, Close());
  1014. mixer->StartListening(&listener);
  1015. VerifyAndClearAllExpectations();
  1016. StreamUnderTest stream_under_test = CreateNextStreamUnderTest(mixer.get());
  1017. OpenAndVerifyStreamUnderTest(stream_under_test, PlaybackMode::kMixing);
  1018. // Since the previous attempt to create the mixing stream failed, it will
  1019. // retry now when starting mixing playback. Fail it again.
  1020. EXPECT_CALL(*this,
  1021. MockCreateOutputStream(AudioParamsEq(mixer_output_params_)));
  1022. EXPECT_CALL(mock_mixing_graph_output_stream_, Open()).WillOnce(Return(false));
  1023. EXPECT_CALL(mock_mixing_graph_output_stream_, Close());
  1024. EXPECT_CALL(stream_under_test.mix_track_mock->source_callback, OnError(_));
  1025. stream_under_test.mixable_stream->Start(
  1026. &stream_under_test.mix_track_mock->source_callback);
  1027. VerifyAndClearAllExpectations();
  1028. // Since mixing has not started, the mixer considers it as independent
  1029. // playback and will stop the independent rendering stream. It's ok:
  1030. // media::AudioOutputStream can be closed multiple times.
  1031. StopAndVerifyStreamUnderTest(stream_under_test, PlaybackMode::kIndependent);
  1032. CloseAndVerifyStreamUnderTest(stream_under_test);
  1033. mixer->StopListening(&listener);
  1034. }
  1035. TEST_F(OutputDeviceMixerImplTest,
  1036. MixingStreamOpenFailureHandled_WhenStartListening) {
  1037. std::unique_ptr<OutputDeviceMixer> mixer = CreateMixerUnderTest();
  1038. MockListener listener;
  1039. StreamUnderTest stream_under_test = CreateNextStreamUnderTest(mixer.get());
  1040. OpenAndVerifyStreamUnderTest(stream_under_test, PlaybackMode::kIndependent);
  1041. StartAndVerifyStreamUnderTest(stream_under_test, PlaybackMode::kIndependent);
  1042. EXPECT_CALL(*this,
  1043. MockCreateOutputStream(AudioParamsEq(mixer_output_params_)));
  1044. EXPECT_CALL(mock_mixing_graph_output_stream_, Open()).WillOnce(Return(false));
  1045. EXPECT_CALL(mock_mixing_graph_output_stream_, Close());
  1046. EXPECT_CALL(stream_under_test.mix_track_mock->rendering_stream, Stop);
  1047. EXPECT_CALL(stream_under_test.mix_track_mock->source_callback, OnError(_));
  1048. mixer->StartListening(&listener);
  1049. VerifyAndClearAllExpectations();
  1050. // Since mixing has not started, the mixer considers it as independent
  1051. // playback and will stop the independent rendering stream. It's ok:
  1052. // media::AudioOutputStream can be closed multiple times.
  1053. StopAndVerifyStreamUnderTest(stream_under_test, PlaybackMode::kIndependent);
  1054. CloseAndVerifyStreamUnderTest(stream_under_test);
  1055. mixer->StopListening(&listener);
  1056. }
  1057. TEST_F(OutputDeviceMixerImplTest,
  1058. MixingStreamCreationFailureHandled_NextMixingSuccessful) {
  1059. std::unique_ptr<OutputDeviceMixer> mixer = CreateMixerUnderTest();
  1060. MockListener listener;
  1061. // Fail creating the mixing stream.
  1062. EXPECT_CALL(*this,
  1063. MockCreateOutputStream(AudioParamsEq(mixer_output_params_)))
  1064. .WillOnce(Return(false));
  1065. mixer->StartListening(&listener);
  1066. VerifyAndClearAllExpectations();
  1067. StreamUnderTest stream_under_test1 = CreateNextStreamUnderTest(mixer.get());
  1068. OpenAndVerifyStreamUnderTest(stream_under_test1, PlaybackMode::kMixing);
  1069. // Fail creating the mixing stream again.
  1070. EXPECT_CALL(*this,
  1071. MockCreateOutputStream(AudioParamsEq(mixer_output_params_)))
  1072. .WillOnce(Return(false));
  1073. EXPECT_CALL(stream_under_test1.mix_track_mock->source_callback, OnError(_));
  1074. stream_under_test1.mixable_stream->Start(
  1075. &stream_under_test1.mix_track_mock->source_callback);
  1076. VerifyAndClearAllExpectations();
  1077. // Since mixing has not started, the mixer considers it as independent
  1078. // playback and will stop the independent rendering stream. It's ok:
  1079. // media::AudioOutputStream can be closed multiple times.
  1080. StopAndVerifyStreamUnderTest(stream_under_test1, PlaybackMode::kIndependent);
  1081. CloseAndVerifyStreamUnderTest(stream_under_test1);
  1082. // This time mixing should be successful.
  1083. StreamUnderTest stream_under_test2 = CreateNextStreamUnderTest(mixer.get());
  1084. OpenAndVerifyStreamUnderTest(stream_under_test2, PlaybackMode::kMixing);
  1085. ExpectMixingGraphOutputStreamOpen();
  1086. StartAndVerifyStreamUnderTest(stream_under_test2, PlaybackMode::kMixing);
  1087. StopAndVerifyStreamUnderTest(stream_under_test2, PlaybackMode::kMixing);
  1088. CloseAndVerifyStreamUnderTest(stream_under_test2);
  1089. ExpectMixingGraphOutputStreamStopped();
  1090. ExpectMixingGraphOutputStreamClosed();
  1091. mixer->StopListening(&listener);
  1092. }
  1093. TEST_F(OutputDeviceMixerImplTest,
  1094. StartListening_OpenStream_StopListening_StartIndependentPlayback) {
  1095. std::unique_ptr<OutputDeviceMixer> mixer = CreateMixerUnderTest();
  1096. MockListener listener;
  1097. ExpectMixingGraphOutputStreamOpen();
  1098. mixer->StartListening(&listener);
  1099. VerifyAndClearAllExpectations();
  1100. StreamUnderTest stream_under_test = CreateNextStreamUnderTest(mixer.get());
  1101. OpenAndVerifyStreamUnderTest(stream_under_test, PlaybackMode::kMixing);
  1102. ExpectMixingGraphOutputStreamClosed();
  1103. mixer->StopListening(&listener);
  1104. VerifyAndClearAllExpectations();
  1105. // Since there were listeners attached when |stream_under_test| was open, its
  1106. // physical rendering stream is not open yet.
  1107. SetIndependentRenderingStreamOpenExpectations(
  1108. stream_under_test.mix_track_mock,
  1109. /*open_success=*/true);
  1110. StartAndVerifyStreamUnderTest(stream_under_test, PlaybackMode::kIndependent);
  1111. StopAndVerifyStreamUnderTest(stream_under_test, PlaybackMode::kIndependent);
  1112. CloseAndVerifyStreamUnderTest(stream_under_test);
  1113. }
  1114. INSTANTIATE_TEST_SUITE_P(,
  1115. OutputDeviceMixerImplTest,
  1116. testing::Values(0, 1, 2, 3));
  1117. INSTANTIATE_TEST_SUITE_P(,
  1118. OutputDeviceMixerImplTestWithDefault,
  1119. testing::Values(kDeviceId, ""));
  1120. } // namespace
  1121. } // namespace audio