OLD | NEW |
---|---|
(Empty) | |
1 // Copyright 2016 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 | |
5 #include "content/renderer/media/renderer_webaudiodevice_impl.h" | |
6 | |
7 #include "base/bind.h" | |
8 #include "content/renderer/media/audio_device_factory.h" | |
9 #include "media/base/audio_capturer_source.h" | |
10 #include "media/base/mock_audio_renderer_sink.h" | |
11 #include "testing/gmock/include/gmock/gmock.h" | |
12 #include "testing/gtest/include/gtest/gtest.h" | |
13 | |
14 using testing::_; | |
15 | |
16 namespace content { | |
17 | |
18 namespace { | |
19 | |
20 const int kHardwareSampleRate = 44100; | |
21 const int kHardwareBufferSize = 128; | |
22 const int kRenderFrameId = 100; | |
23 | |
24 int MockFrameIdFromCurrentContext() { | |
25 return kRenderFrameId; | |
26 } | |
27 | |
28 media::AudioParameters MockGetOutputDeviceParameters( | |
29 int frame_id, | |
30 int session_id, | |
31 const std::string& device_id, | |
32 const url::Origin& security_origin) { | |
33 return media::AudioParameters(media::AudioParameters::AUDIO_PCM_LOW_LATENCY, | |
34 media::CHANNEL_LAYOUT_STEREO, | |
35 kHardwareSampleRate, 16, kHardwareBufferSize); | |
36 } | |
37 | |
38 class RendererWebAudioDeviceImplUnderTest : public RendererWebAudioDeviceImpl { | |
39 public: | |
40 RendererWebAudioDeviceImplUnderTest( | |
41 media::ChannelLayout layout, | |
42 const blink::WebAudioLatencyHint& latency_hint, | |
43 blink::WebAudioDevice::RenderCallback* callback, | |
44 int session_id, | |
45 const url::Origin& security_origin) | |
46 : RendererWebAudioDeviceImpl(layout, | |
47 latency_hint, | |
48 callback, | |
49 session_id, | |
50 security_origin, | |
51 base::Bind(&MockGetOutputDeviceParameters), | |
52 base::Bind(&MockFrameIdFromCurrentContext)) { | |
53 } | |
54 }; | |
55 | |
56 } // namespace | |
57 | |
58 class RendererWebAudioDeviceImplTest | |
59 : public blink::WebAudioDevice::RenderCallback, | |
60 public AudioDeviceFactory, | |
61 public testing::Test { | |
62 public: | |
63 MOCK_METHOD3(render, | |
64 void(const blink::WebVector<float*>& sourceData, | |
65 const blink::WebVector<float*>& destinationData, | |
66 size_t numberOfFrames)); | |
67 | |
68 protected: | |
69 RendererWebAudioDeviceImplTest() {} | |
70 | |
71 void SetupDevice(blink::WebAudioLatencyHint latencyHint) { | |
72 webaudio_device_.reset(new RendererWebAudioDeviceImplUnderTest( | |
73 media::CHANNEL_LAYOUT_MONO, latencyHint, this, 0, url::Origin())); | |
74 } | |
75 | |
76 MOCK_METHOD1(CreateAudioCapturerSource, | |
77 scoped_refptr<media::AudioCapturerSource>(int)); | |
78 MOCK_METHOD4(CreateFinalAudioRendererSink, | |
79 scoped_refptr<media::AudioRendererSink>(int, | |
80 int, | |
81 const std::string&, | |
82 const url::Origin&)); | |
83 MOCK_METHOD5( | |
84 CreateSwitchableAudioRendererSink, | |
85 scoped_refptr<media::SwitchableAudioRendererSink>(SourceType, | |
86 int, | |
87 int, | |
88 const std::string&, | |
89 const url::Origin&)); | |
90 | |
91 scoped_refptr<media::AudioRendererSink> CreateAudioRendererSink( | |
92 SourceType source_type, | |
93 int render_frame_id, | |
94 int session_id, | |
95 const std::string& device_id, | |
96 const url::Origin& security_origin) { | |
97 mock_sink_ = new media::MockAudioRendererSink( | |
98 device_id, media::OUTPUT_DEVICE_STATUS_OK, | |
99 MockGetOutputDeviceParameters(render_frame_id, session_id, device_id, | |
100 security_origin)); | |
101 | |
102 EXPECT_CALL(*mock_sink_.get(), Start()); | |
103 EXPECT_CALL(*mock_sink_.get(), Play()); | |
104 EXPECT_CALL(*mock_sink_.get(), Stop()); | |
105 | |
106 return mock_sink_; | |
107 } | |
108 | |
109 void TearDown() override { | |
110 webaudio_device_.reset(); | |
111 mock_sink_ = nullptr; | |
112 } | |
113 | |
114 std::unique_ptr<RendererWebAudioDeviceImpl> webaudio_device_; | |
115 scoped_refptr<media::MockAudioRendererSink> mock_sink_; | |
116 }; | |
117 | |
118 TEST_F(RendererWebAudioDeviceImplTest, TestLatencyHint) { | |
119 SetupDevice(blink::WebAudioLatencyHint( | |
120 blink::WebAudioLatencyHint::CategoryInteractive)); | |
121 int interactive_frames = webaudio_device_->framesPerBuffer(); | |
122 media::AudioLatency::LatencyType interactive_latency = | |
123 webaudio_device_->latencyType(); | |
124 | |
125 SetupDevice( | |
126 blink::WebAudioLatencyHint(blink::WebAudioLatencyHint::CategoryBalanced)); | |
127 int balanced_frames = webaudio_device_->framesPerBuffer(); | |
128 media::AudioLatency::LatencyType balanced_latency = | |
129 webaudio_device_->latencyType(); | |
130 | |
131 SetupDevice( | |
132 blink::WebAudioLatencyHint(blink::WebAudioLatencyHint::CategoryPlayback)); | |
133 int playback_frames = webaudio_device_->framesPerBuffer(); | |
134 media::AudioLatency::LatencyType playback_latency = | |
135 webaudio_device_->latencyType(); | |
136 | |
137 EXPECT_GE(playback_frames, balanced_frames); | |
138 EXPECT_GE(balanced_frames, interactive_frames); | |
139 | |
140 EXPECT_GT(playback_latency, balanced_latency); | |
141 EXPECT_GT(balanced_latency, interactive_latency); | |
142 } | |
143 | |
144 TEST_F(RendererWebAudioDeviceImplTest, TestStartStopValues) { | |
145 SetupDevice(blink::WebAudioLatencyHint( | |
146 blink::WebAudioLatencyHint::CategoryInteractive)); | |
147 EXPECT_EQ(webaudio_device_->sampleRate(), kHardwareSampleRate); | |
148 EXPECT_EQ(webaudio_device_->framesPerBuffer(), kHardwareBufferSize); | |
o1ka
2016/12/08 10:57:19
Here and below: shouldn't WAD return latency-depen
Andrew MacPherson
2016/12/08 12:22:54
Yes you're right, I was cutting a corner since the
o1ka
2016/12/08 13:10:16
Could you check it for each latency type, so that
Andrew MacPherson
2016/12/08 13:53:53
No problem, done. The code for checking each type
| |
149 | |
150 webaudio_device_->start(); | |
151 EXPECT_EQ(webaudio_device_->sampleRate(), kHardwareSampleRate); | |
152 EXPECT_EQ(webaudio_device_->framesPerBuffer(), kHardwareBufferSize); | |
153 | |
154 webaudio_device_->stop(); | |
155 EXPECT_EQ(webaudio_device_->sampleRate(), kHardwareSampleRate); | |
156 EXPECT_EQ(webaudio_device_->framesPerBuffer(), kHardwareBufferSize); | |
157 | |
158 webaudio_device_->start(); | |
159 EXPECT_EQ(webaudio_device_->sampleRate(), kHardwareSampleRate); | |
160 EXPECT_EQ(webaudio_device_->framesPerBuffer(), kHardwareBufferSize); | |
161 | |
162 webaudio_device_->stop(); | |
163 EXPECT_EQ(webaudio_device_->sampleRate(), kHardwareSampleRate); | |
164 EXPECT_EQ(webaudio_device_->framesPerBuffer(), kHardwareBufferSize); | |
165 } | |
166 | |
167 } // namespace content | |
OLD | NEW |