1 /*
2  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
3  *
4  *  Use of this source code is governed by a BSD-style license
5  *  that can be found in the LICENSE file in the root of the source
6  *  tree. An additional intellectual property rights grant can be found
7  *  in the file PATENTS.  All contributing project authors may
8  *  be found in the AUTHORS file in the root of the source tree.
9  */
10 
11 #include "webrtc/voice_engine/test/auto_test/fixtures/after_streaming_fixture.h"
12 
13 namespace {
14 
ExpectVolumeNear(int expected,int actual)15 void ExpectVolumeNear(int expected, int actual) {
16   // The hardware volume may be more coarsely quantized than [0, 255], so
17   // it is not always reasonable to expect to get exactly what we set. This
18   // allows for some error.
19   const int kMaxVolumeError = 10;
20   EXPECT_NEAR(expected, actual, kMaxVolumeError);
21   EXPECT_GE(actual, 0);
22   EXPECT_LE(actual, 255);
23 }
24 
25 }  // namespace
26 
27 class VolumeTest : public AfterStreamingFixture {
28  public:
SetAndVerifyMicVolume(unsigned int volume)29   void SetAndVerifyMicVolume(unsigned int volume) {
30     bool success = voe_volume_control_->SetMicVolume(volume) == 0;
31 #if !defined(WEBRTC_LINUX)
32     EXPECT_TRUE(success);
33 #endif
34     if (!success) {
35       TEST_LOG("Failed to set microphone volume to %u.\n", volume);
36       return;
37     }
38 
39     unsigned int test_volume = 1000;
40     success = voe_volume_control_->GetMicVolume(test_volume) == 0;
41 #if !defined(WEBRTC_LINUX)
42     EXPECT_TRUE(success);
43 #endif
44     if (success) {
45       EXPECT_EQ(volume, test_volume);
46     } else {
47       TEST_LOG("Failed to get the microphone volume.");
48       EXPECT_EQ(1000u, test_volume);
49     }
50   }
51 
SetAndVerifyInputMute(bool enable)52   void SetAndVerifyInputMute(bool enable) {
53     bool success = voe_volume_control_->SetInputMute(channel_, enable) == 0;
54 #if !defined(WEBRTC_LINUX)
55     EXPECT_TRUE(success);
56 #endif
57     if (!success) {
58       TEST_LOG("Failed to %smute input.\n", enable ? "" : "un");
59       return;
60     }
61 
62     bool is_muted = !enable;
63     success = voe_volume_control_->GetInputMute(channel_, is_muted) == 0;
64 #if !defined(WEBRTC_LINUX)
65     EXPECT_TRUE(success);
66 #endif
67     if (success) {
68       EXPECT_EQ(enable, is_muted);
69     } else {
70       TEST_LOG("Failed to mute the input.");
71       EXPECT_NE(enable, is_muted);
72     }
73   }
74 };
75 
76 // Some tests are flaky on Linux (Pulse Audio), which boils down to some system
77 // values not being acquired in time. In Pulse Audio we make one retry if
78 // needed, but if we fail then, a -1 is returned propagating up through VoE.
79 // To avoid possible bugs slipping through on other platforms we make adequate
80 // changes on Linux only.
TEST_F(VolumeTest,VerifyCorrectErrorReturns)81 TEST_F(VolumeTest, VerifyCorrectErrorReturns) {
82   // All tests run on correct initialization which eliminates one possible error
83   // return. In addition, we assume the audio_device returning values without
84   // error, which eliminates another potential error.
85   // Left to verify are sanity checks of set parameters.
86 
87   // Valid volume range: [0, 255]
88   EXPECT_EQ(-1, voe_volume_control_->SetSpeakerVolume(256));
89   EXPECT_EQ(-1, voe_volume_control_->SetMicVolume(256));
90 
91   // Valid panning rage: [0, 1]
92   EXPECT_EQ(-1, voe_volume_control_->SetOutputVolumePan(channel_, -0.1f, 0.5f));
93   EXPECT_EQ(-1, voe_volume_control_->SetOutputVolumePan(channel_, 1.1f, 0.5f));
94   EXPECT_EQ(-1, voe_volume_control_->SetOutputVolumePan(channel_, 0.5f, -0.1f));
95   EXPECT_EQ(-1, voe_volume_control_->SetOutputVolumePan(channel_, 0.5f, 1.1f));
96 }
97 
TEST_F(VolumeTest,DefaultSpeakerVolumeIsAtMost255)98 TEST_F(VolumeTest, DefaultSpeakerVolumeIsAtMost255) {
99   unsigned int volume = 1000;
100   EXPECT_EQ(0, voe_volume_control_->GetSpeakerVolume(volume));
101   EXPECT_LE(volume, 255u);
102 }
103 
TEST_F(VolumeTest,SetVolumeBeforePlayoutWorks)104 TEST_F(VolumeTest, SetVolumeBeforePlayoutWorks) {
105   // This is a rather specialized test, intended to exercise some PulseAudio
106   // code. However, these conditions should be satisfied on any platform.
107   unsigned int original_volume = 0;
108   EXPECT_EQ(0, voe_volume_control_->GetSpeakerVolume(original_volume));
109   Sleep(1000);
110 
111   EXPECT_EQ(0, voe_volume_control_->SetSpeakerVolume(200));
112   unsigned int volume;
113   EXPECT_EQ(0, voe_volume_control_->GetSpeakerVolume(volume));
114   ExpectVolumeNear(200u, volume);
115 
116   PausePlaying();
117   ResumePlaying();
118   EXPECT_EQ(0, voe_volume_control_->GetSpeakerVolume(volume));
119   // Ensure the volume has not changed after resuming playout.
120   ExpectVolumeNear(200u, volume);
121 
122   PausePlaying();
123   EXPECT_EQ(0, voe_volume_control_->SetSpeakerVolume(100));
124   ResumePlaying();
125   // Ensure the volume set while paused is retained.
126   EXPECT_EQ(0, voe_volume_control_->GetSpeakerVolume(volume));
127   ExpectVolumeNear(100u, volume);
128 
129   EXPECT_EQ(0, voe_volume_control_->SetSpeakerVolume(original_volume));
130 }
131 
TEST_F(VolumeTest,ManualSetVolumeWorks)132 TEST_F(VolumeTest, ManualSetVolumeWorks) {
133   unsigned int original_volume = 0;
134   EXPECT_EQ(0, voe_volume_control_->GetSpeakerVolume(original_volume));
135   Sleep(1000);
136 
137   TEST_LOG("Setting speaker volume to 0 out of 255.\n");
138   EXPECT_EQ(0, voe_volume_control_->SetSpeakerVolume(0));
139   unsigned int volume;
140   EXPECT_EQ(0, voe_volume_control_->GetSpeakerVolume(volume));
141   ExpectVolumeNear(0u, volume);
142   Sleep(1000);
143 
144   TEST_LOG("Setting speaker volume to 100 out of 255.\n");
145   EXPECT_EQ(0, voe_volume_control_->SetSpeakerVolume(100));
146   EXPECT_EQ(0, voe_volume_control_->GetSpeakerVolume(volume));
147   ExpectVolumeNear(100u, volume);
148   Sleep(1000);
149 
150   // Set the volume to 255 very briefly so we don't blast the poor user
151   // listening to this. This is just to test the call succeeds.
152   EXPECT_EQ(0, voe_volume_control_->SetSpeakerVolume(255));
153   EXPECT_EQ(0, voe_volume_control_->GetSpeakerVolume(volume));
154   ExpectVolumeNear(255u, volume);
155 
156   TEST_LOG("Setting speaker volume to the original %d out of 255.\n",
157       original_volume);
158   EXPECT_EQ(0, voe_volume_control_->SetSpeakerVolume(original_volume));
159   Sleep(1000);
160 }
161 
TEST_F(VolumeTest,DefaultMicrophoneVolumeIsAtMost255)162 TEST_F(VolumeTest, DefaultMicrophoneVolumeIsAtMost255) {
163   unsigned int volume = 1000;
164   bool could_get_mic_volume = voe_volume_control_->GetMicVolume(volume) == 0;
165 #if !defined(WEBRTC_LINUX)
166   EXPECT_TRUE(could_get_mic_volume);
167 #endif
168   if (could_get_mic_volume) {
169     EXPECT_LE(volume, 255u);
170   } else {
171     TEST_LOG("Failed to get the microphone volume.");
172     EXPECT_EQ(1000u, volume);
173   }
174 }
175 
TEST_F(VolumeTest,ManualRequiresMicrophoneCanSetMicrophoneVolumeWithAgcOff)176 TEST_F(VolumeTest, ManualRequiresMicrophoneCanSetMicrophoneVolumeWithAgcOff) {
177   SwitchToManualMicrophone();
178   EXPECT_EQ(0, voe_apm_->SetAgcStatus(false));
179 
180   unsigned int original_volume = 0;
181   bool could_get_mic_volume =
182       (voe_volume_control_->GetMicVolume(original_volume) == 0);
183 #if !defined(WEBRTC_LINUX)
184   EXPECT_TRUE(could_get_mic_volume);
185 #endif
186   if (could_get_mic_volume)
187     TEST_LOG("Current microphone volume is %u.\n", original_volume);
188   else
189     TEST_LOG("Failed to fetch current microphone volume.\n");
190 
191   TEST_LOG("Setting microphone volume to 0.\n");
192   SetAndVerifyMicVolume(0);
193   Sleep(1000);
194   TEST_LOG("Setting microphone volume to 255.\n");
195   SetAndVerifyMicVolume(255);
196   Sleep(1000);
197   if (could_get_mic_volume) {
198     TEST_LOG("Setting microphone volume back to %u.\n", original_volume);
199     SetAndVerifyMicVolume(original_volume);
200     Sleep(1000);
201   }
202 }
203 
TEST_F(VolumeTest,ChannelScalingIsOneByDefault)204 TEST_F(VolumeTest, ChannelScalingIsOneByDefault) {
205   float scaling = -1.0f;
206 
207   EXPECT_EQ(0, voe_volume_control_->GetChannelOutputVolumeScaling(
208       channel_, scaling));
209   EXPECT_FLOAT_EQ(1.0f, scaling);
210 }
211 
TEST_F(VolumeTest,ManualCanSetChannelScaling)212 TEST_F(VolumeTest, ManualCanSetChannelScaling) {
213   EXPECT_EQ(0, voe_volume_control_->SetChannelOutputVolumeScaling(
214       channel_, 0.1f));
215 
216   float scaling = 1.0f;
217   EXPECT_EQ(0, voe_volume_control_->GetChannelOutputVolumeScaling(
218       channel_, scaling));
219 
220   EXPECT_FLOAT_EQ(0.1f, scaling);
221 
222   TEST_LOG("Channel scaling set to 0.1: audio should be barely audible.\n");
223   Sleep(2000);
224 }
225 
TEST_F(VolumeTest,InputMutingIsNotEnabledByDefault)226 TEST_F(VolumeTest, InputMutingIsNotEnabledByDefault) {
227   bool is_muted = true;
228   EXPECT_EQ(0, voe_volume_control_->GetInputMute(channel_, is_muted));
229   EXPECT_FALSE(is_muted);
230 }
231 
TEST_F(VolumeTest,ManualInputMutingMutesMicrophone)232 TEST_F(VolumeTest, ManualInputMutingMutesMicrophone) {
233   SwitchToManualMicrophone();
234   // Enable muting.
235   SetAndVerifyInputMute(true);
236   TEST_LOG("Muted: talk into microphone and verify you can't hear yourself.\n");
237   Sleep(2000);
238 
239   // Test that we can disable muting.
240   SetAndVerifyInputMute(false);
241   TEST_LOG("Unmuted: talk into microphone and verify you can hear yourself.\n");
242   Sleep(2000);
243 }
244 
TEST_F(VolumeTest,ManualTestInputAndOutputLevels)245 TEST_F(VolumeTest, ManualTestInputAndOutputLevels) {
246   SwitchToManualMicrophone();
247 
248   TEST_LOG("Speak and verify that the following levels look right:\n");
249   for (int i = 0; i < 5; i++) {
250     Sleep(1000);
251     unsigned int input_level = 0;
252     unsigned int output_level = 0;
253     unsigned int input_level_full_range = 0;
254     unsigned int output_level_full_range = 0;
255 
256     EXPECT_EQ(0, voe_volume_control_->GetSpeechInputLevel(
257         input_level));
258     EXPECT_EQ(0, voe_volume_control_->GetSpeechOutputLevel(
259         channel_, output_level));
260     EXPECT_EQ(0, voe_volume_control_->GetSpeechInputLevelFullRange(
261         input_level_full_range));
262     EXPECT_EQ(0, voe_volume_control_->GetSpeechOutputLevelFullRange(
263         channel_, output_level_full_range));
264 
265     TEST_LOG("    warped levels (0-9)    : in=%5d, out=%5d\n",
266         input_level, output_level);
267     TEST_LOG("    linear levels (0-32768): in=%5d, out=%5d\n",
268         input_level_full_range, output_level_full_range);
269   }
270 }
271 
TEST_F(VolumeTest,ChannelsAreNotPannedByDefault)272 TEST_F(VolumeTest, ChannelsAreNotPannedByDefault) {
273   float left = -1.0;
274   float right = -1.0;
275 
276   EXPECT_EQ(0, voe_volume_control_->GetOutputVolumePan(channel_, left, right));
277   EXPECT_FLOAT_EQ(1.0, left);
278   EXPECT_FLOAT_EQ(1.0, right);
279 }
280 
TEST_F(VolumeTest,ManualTestChannelPanning)281 TEST_F(VolumeTest, ManualTestChannelPanning) {
282   TEST_LOG("Panning left.\n");
283   EXPECT_EQ(0, voe_volume_control_->SetOutputVolumePan(channel_, 0.8f, 0.1f));
284   Sleep(1000);
285 
286   TEST_LOG("Back to center.\n");
287   EXPECT_EQ(0, voe_volume_control_->SetOutputVolumePan(channel_, 1.0f, 1.0f));
288   Sleep(1000);
289 
290   TEST_LOG("Panning right.\n");
291   EXPECT_EQ(0, voe_volume_control_->SetOutputVolumePan(channel_, 0.1f, 0.8f));
292   Sleep(1000);
293 
294   // To finish, verify that the getter works.
295   float left = 0.0f;
296   float right = 0.0f;
297 
298   EXPECT_EQ(0, voe_volume_control_->GetOutputVolumePan(channel_, left, right));
299   EXPECT_FLOAT_EQ(0.1f, left);
300   EXPECT_FLOAT_EQ(0.8f, right);
301 }
302