test_audio_device_unittest.cc (21613B)
1 /* 2 * Copyright (c) 2017 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 "modules/audio_device/include/test_audio_device.h" 12 13 #include <stdio.h> 14 15 #include <algorithm> 16 #include <cstddef> 17 #include <cstdint> 18 #include <cstdio> 19 #include <cstdlib> 20 #include <cstring> 21 #include <memory> 22 #include <optional> 23 #include <string> 24 #include <utility> 25 #include <vector> 26 27 #include "api/array_view.h" 28 #include "api/audio/audio_device.h" 29 #include "api/audio/audio_device_defines.h" 30 #include "api/environment/environment.h" 31 #include "api/environment/environment_factory.h" 32 #include "api/scoped_refptr.h" 33 #include "api/units/time_delta.h" 34 #include "api/units/timestamp.h" 35 #include "common_audio/wav_file.h" 36 #include "rtc_base/buffer.h" 37 #include "rtc_base/checks.h" 38 #include "rtc_base/synchronization/mutex.h" 39 #include "rtc_base/thread_annotations.h" 40 #include "test/gmock.h" 41 #include "test/gtest.h" 42 #include "test/testsupport/file_utils.h" 43 #include "test/time_controller/simulated_time_controller.h" 44 45 namespace webrtc { 46 namespace { 47 48 void RunWavTest(const std::vector<int16_t>& input_samples, 49 const std::vector<int16_t>& expected_samples) { 50 const ::testing::TestInfo* const test_info = 51 ::testing::UnitTest::GetInstance()->current_test_info(); 52 53 const std::string output_filename = test::OutputPathWithRandomDirectory() + 54 "BoundedWavFileWriterTest_" + 55 test_info->name() + ".wav"; 56 57 static const size_t kSamplesPerFrame = 8; 58 static const int kSampleRate = kSamplesPerFrame * 100; 59 EXPECT_EQ(TestAudioDeviceModule::SamplesPerFrame(kSampleRate), 60 kSamplesPerFrame); 61 62 // Test through file name API. 63 { 64 std::unique_ptr<TestAudioDeviceModule::Renderer> writer = 65 TestAudioDeviceModule::CreateBoundedWavFileWriter(output_filename, 800); 66 67 for (size_t i = 0; i < input_samples.size(); i += kSamplesPerFrame) { 68 EXPECT_TRUE(writer->Render(ArrayView<const int16_t>( 69 &input_samples[i], 70 std::min(kSamplesPerFrame, input_samples.size() - i)))); 71 } 72 } 73 74 { 75 WavReader reader(output_filename); 76 std::vector<int16_t> read_samples(expected_samples.size()); 77 EXPECT_EQ(expected_samples.size(), 78 reader.ReadSamples(read_samples.size(), read_samples.data())); 79 EXPECT_EQ(expected_samples, read_samples); 80 81 EXPECT_EQ(0u, reader.ReadSamples(read_samples.size(), read_samples.data())); 82 } 83 84 remove(output_filename.c_str()); 85 } 86 87 TEST(BoundedWavFileWriterTest, NoSilence) { 88 static const std::vector<int16_t> kInputSamples = { 89 75, 1234, 243, -1231, -22222, 0, 3, 88, 90 1222, -1213, -13222, -7, -3525, 5787, -25247, 8}; 91 static const std::vector<int16_t> kExpectedSamples = kInputSamples; 92 RunWavTest(kInputSamples, kExpectedSamples); 93 } 94 95 TEST(BoundedWavFileWriterTest, SomeStartSilence) { 96 static const std::vector<int16_t> kInputSamples = { 97 0, 0, 0, 0, 3, 0, 0, 0, 0, 3, -13222, -7, -3525, 5787, -25247, 8}; 98 static const std::vector<int16_t> kExpectedSamples(kInputSamples.begin() + 10, 99 kInputSamples.end()); 100 RunWavTest(kInputSamples, kExpectedSamples); 101 } 102 103 TEST(BoundedWavFileWriterTest, NegativeStartSilence) { 104 static const std::vector<int16_t> kInputSamples = { 105 0, -4, -6, 0, 3, 0, 0, 0, 0, 3, -13222, -7, -3525, 5787, -25247, 8}; 106 static const std::vector<int16_t> kExpectedSamples(kInputSamples.begin() + 2, 107 kInputSamples.end()); 108 RunWavTest(kInputSamples, kExpectedSamples); 109 } 110 111 TEST(BoundedWavFileWriterTest, SomeEndSilence) { 112 static const std::vector<int16_t> kInputSamples = { 113 75, 1234, 243, -1231, -22222, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0}; 114 static const std::vector<int16_t> kExpectedSamples(kInputSamples.begin(), 115 kInputSamples.end() - 9); 116 RunWavTest(kInputSamples, kExpectedSamples); 117 } 118 119 TEST(BoundedWavFileWriterTest, DoubleEndSilence) { 120 static const std::vector<int16_t> kInputSamples = { 121 75, 1234, 243, -1231, -22222, 0, 0, 0, 122 0, -1213, -13222, -7, -3525, 5787, 0, 0}; 123 static const std::vector<int16_t> kExpectedSamples(kInputSamples.begin(), 124 kInputSamples.end() - 2); 125 RunWavTest(kInputSamples, kExpectedSamples); 126 } 127 128 TEST(BoundedWavFileWriterTest, DoubleSilence) { 129 static const std::vector<int16_t> kInputSamples = {0, -1213, -13222, -7, 130 -3525, 5787, 0, 0}; 131 static const std::vector<int16_t> kExpectedSamples(kInputSamples.begin() + 1, 132 kInputSamples.end() - 2); 133 RunWavTest(kInputSamples, kExpectedSamples); 134 } 135 136 TEST(BoundedWavFileWriterTest, EndSilenceCutoff) { 137 static const std::vector<int16_t> kInputSamples = { 138 75, 1234, 243, -1231, -22222, 0, 1, 0, 0, 0, 0}; 139 static const std::vector<int16_t> kExpectedSamples(kInputSamples.begin(), 140 kInputSamples.end() - 4); 141 RunWavTest(kInputSamples, kExpectedSamples); 142 } 143 144 TEST(WavFileReaderTest, RepeatedTrueWithSingleFrameFileReadTwice) { 145 static const std::vector<int16_t> kInputSamples = {75, 1234, 243, -1231, 146 -22222, 0, 3, 88}; 147 static const BufferT<int16_t> kExpectedSamples(kInputSamples.data(), 148 kInputSamples.size()); 149 150 const std::string output_filename = test::OutputPathWithRandomDirectory() + 151 "WavFileReaderTest_RepeatedTrue_" + 152 ".wav"; 153 154 static const size_t kSamplesPerFrame = 8; 155 static const int kSampleRate = kSamplesPerFrame * 100; 156 EXPECT_EQ(TestAudioDeviceModule::SamplesPerFrame(kSampleRate), 157 kSamplesPerFrame); 158 159 // Create raw file to read. 160 { 161 std::unique_ptr<TestAudioDeviceModule::Renderer> writer = 162 TestAudioDeviceModule::CreateWavFileWriter(output_filename, 800); 163 164 for (size_t i = 0; i < kInputSamples.size(); i += kSamplesPerFrame) { 165 EXPECT_TRUE(writer->Render(ArrayView<const int16_t>( 166 &kInputSamples[i], 167 std::min(kSamplesPerFrame, kInputSamples.size() - i)))); 168 } 169 } 170 171 { 172 std::unique_ptr<TestAudioDeviceModule::Capturer> reader = 173 TestAudioDeviceModule::CreateWavFileReader(output_filename, true); 174 BufferT<int16_t> buffer(kExpectedSamples.size()); 175 EXPECT_TRUE(reader->Capture(&buffer)); 176 EXPECT_EQ(kExpectedSamples, buffer); 177 EXPECT_TRUE(reader->Capture(&buffer)); 178 EXPECT_EQ(kExpectedSamples, buffer); 179 } 180 181 remove(output_filename.c_str()); 182 } 183 184 void RunRawTestNoRepeat(const std::vector<int16_t>& input_samples, 185 const std::vector<int16_t>& expected_samples) { 186 const ::testing::TestInfo* const test_info = 187 ::testing::UnitTest::GetInstance()->current_test_info(); 188 189 const std::string output_filename = test::OutputPathWithRandomDirectory() + 190 "RawFileTest_" + test_info->name() + 191 ".raw"; 192 193 static const size_t kSamplesPerFrame = 8; 194 static const int kSampleRate = kSamplesPerFrame * 100; 195 EXPECT_EQ(TestAudioDeviceModule::SamplesPerFrame(kSampleRate), 196 kSamplesPerFrame); 197 198 // Test through file name API. 199 { 200 std::unique_ptr<TestAudioDeviceModule::Renderer> writer = 201 TestAudioDeviceModule::CreateRawFileWriter( 202 output_filename, /*sampling_frequency_in_hz=*/800); 203 204 for (size_t i = 0; i < input_samples.size(); i += kSamplesPerFrame) { 205 EXPECT_TRUE(writer->Render(ArrayView<const int16_t>( 206 &input_samples[i], 207 std::min(kSamplesPerFrame, input_samples.size() - i)))); 208 } 209 } 210 211 { 212 std::unique_ptr<TestAudioDeviceModule::Capturer> reader = 213 TestAudioDeviceModule::CreateRawFileReader( 214 output_filename, /*sampling_frequency_in_hz=*/800, 215 /*num_channels=*/2, /*repeat=*/false); 216 BufferT<int16_t> buffer(expected_samples.size()); 217 BufferT<int16_t> expected_buffer(expected_samples.size()); 218 expected_buffer.SetData(expected_samples); 219 EXPECT_TRUE(reader->Capture(&buffer)); 220 EXPECT_EQ(expected_buffer, buffer); 221 EXPECT_FALSE(reader->Capture(&buffer)); 222 EXPECT_TRUE(buffer.empty()); 223 } 224 225 remove(output_filename.c_str()); 226 } 227 228 TEST(RawFileWriterTest, NoSilence) { 229 static const std::vector<int16_t> kInputSamples = { 230 75, 1234, 243, -1231, -22222, 0, 3, 88, 231 1222, -1213, -13222, -7, -3525, 5787, -25247, 8}; 232 static const std::vector<int16_t> kExpectedSamples = kInputSamples; 233 RunRawTestNoRepeat(kInputSamples, kExpectedSamples); 234 } 235 236 TEST(RawFileWriterTest, SomeStartSilence) { 237 static const std::vector<int16_t> kInputSamples = { 238 0, 0, 0, 0, 3, 0, 0, 0, 0, 3, -13222, -7, -3525, 5787, -25247, 8}; 239 static const std::vector<int16_t> kExpectedSamples(kInputSamples.begin() + 10, 240 kInputSamples.end()); 241 RunRawTestNoRepeat(kInputSamples, kExpectedSamples); 242 } 243 244 TEST(RawFileWriterTest, NegativeStartSilence) { 245 static const std::vector<int16_t> kInputSamples = { 246 0, -4, -6, 0, 3, 0, 0, 0, 0, 3, -13222, -7, -3525, 5787, -25247, 8}; 247 static const std::vector<int16_t> kExpectedSamples(kInputSamples.begin() + 2, 248 kInputSamples.end()); 249 RunRawTestNoRepeat(kInputSamples, kExpectedSamples); 250 } 251 252 TEST(RawFileWriterTest, SomeEndSilence) { 253 static const std::vector<int16_t> kInputSamples = { 254 75, 1234, 243, -1231, -22222, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0}; 255 static const std::vector<int16_t> kExpectedSamples(kInputSamples.begin(), 256 kInputSamples.end() - 9); 257 RunRawTestNoRepeat(kInputSamples, kExpectedSamples); 258 } 259 260 TEST(RawFileWriterTest, DoubleEndSilence) { 261 static const std::vector<int16_t> kInputSamples = { 262 75, 1234, 243, -1231, -22222, 0, 0, 0, 263 0, -1213, -13222, -7, -3525, 5787, 0, 0}; 264 static const std::vector<int16_t> kExpectedSamples(kInputSamples.begin(), 265 kInputSamples.end() - 2); 266 RunRawTestNoRepeat(kInputSamples, kExpectedSamples); 267 } 268 269 TEST(RawFileWriterTest, DoubleSilence) { 270 static const std::vector<int16_t> kInputSamples = {0, -1213, -13222, -7, 271 -3525, 5787, 0, 0}; 272 static const std::vector<int16_t> kExpectedSamples(kInputSamples.begin() + 1, 273 kInputSamples.end() - 2); 274 RunRawTestNoRepeat(kInputSamples, kExpectedSamples); 275 } 276 277 TEST(RawFileWriterTest, EndSilenceCutoff) { 278 static const std::vector<int16_t> kInputSamples = { 279 75, 1234, 243, -1231, -22222, 0, 1, 0, 0, 0, 0}; 280 static const std::vector<int16_t> kExpectedSamples(kInputSamples.begin(), 281 kInputSamples.end() - 4); 282 RunRawTestNoRepeat(kInputSamples, kExpectedSamples); 283 } 284 285 TEST(RawFileWriterTest, Repeat) { 286 static const std::vector<int16_t> kInputSamples = { 287 75, 1234, 243, -1231, -22222, 0, 3, 88, 288 1222, -1213, -13222, -7, -3525, 5787, -25247, 8}; 289 static const BufferT<int16_t> kExpectedSamples(kInputSamples.data(), 290 kInputSamples.size()); 291 292 const ::testing::TestInfo* const test_info = 293 ::testing::UnitTest::GetInstance()->current_test_info(); 294 295 const std::string output_filename = test::OutputPathWithRandomDirectory() + 296 "RawFileTest_" + test_info->name() + "_" + 297 std::to_string(std::rand()) + ".raw"; 298 299 static const size_t kSamplesPerFrame = 8; 300 static const int kSampleRate = kSamplesPerFrame * 100; 301 EXPECT_EQ(TestAudioDeviceModule::SamplesPerFrame(kSampleRate), 302 kSamplesPerFrame); 303 304 // Test through file name API. 305 { 306 std::unique_ptr<TestAudioDeviceModule::Renderer> writer = 307 TestAudioDeviceModule::CreateRawFileWriter( 308 output_filename, /*sampling_frequency_in_hz=*/800); 309 310 for (size_t i = 0; i < kInputSamples.size(); i += kSamplesPerFrame) { 311 EXPECT_TRUE(writer->Render(ArrayView<const int16_t>( 312 &kInputSamples[i], 313 std::min(kSamplesPerFrame, kInputSamples.size() - i)))); 314 } 315 } 316 317 { 318 std::unique_ptr<TestAudioDeviceModule::Capturer> reader = 319 TestAudioDeviceModule::CreateRawFileReader( 320 output_filename, /*sampling_frequency_in_hz=*/800, 321 /*num_channels=*/2, /*repeat=*/true); 322 BufferT<int16_t> buffer(kExpectedSamples.size()); 323 EXPECT_TRUE(reader->Capture(&buffer)); 324 EXPECT_EQ(kExpectedSamples, buffer); 325 EXPECT_TRUE(reader->Capture(&buffer)); 326 EXPECT_EQ(kExpectedSamples, buffer); 327 } 328 329 remove(output_filename.c_str()); 330 } 331 332 TEST(PulsedNoiseCapturerTest, SetMaxAmplitude) { 333 const int16_t kAmplitude = 50; 334 std::unique_ptr<TestAudioDeviceModule::PulsedNoiseCapturer> capturer = 335 TestAudioDeviceModule::CreatePulsedNoiseCapturer( 336 kAmplitude, /*sampling_frequency_in_hz=*/8000); 337 BufferT<int16_t> recording_buffer; 338 339 // Verify that the capturer doesn't create entries louder than than 340 // kAmplitude. Since the pulse generator alternates between writing 341 // zeroes and actual entries, we need to do the capturing twice. 342 capturer->Capture(&recording_buffer); 343 capturer->Capture(&recording_buffer); 344 int16_t max_sample = 345 *std::max_element(recording_buffer.begin(), recording_buffer.end()); 346 EXPECT_LE(max_sample, kAmplitude); 347 348 // Increase the amplitude and verify that the samples can now be louder 349 // than the previous max. 350 capturer->SetMaxAmplitude(kAmplitude * 2); 351 capturer->Capture(&recording_buffer); 352 capturer->Capture(&recording_buffer); 353 max_sample = 354 *std::max_element(recording_buffer.begin(), recording_buffer.end()); 355 EXPECT_GT(max_sample, kAmplitude); 356 } 357 358 using ::testing::ElementsAre; 359 360 constexpr Timestamp kStartTime = Timestamp::Millis(10000); 361 362 class TestAudioTransport : public AudioTransport { 363 public: 364 enum class Mode { kPlaying, kRecording }; 365 366 explicit TestAudioTransport(Mode mode) : mode_(mode) {} 367 ~TestAudioTransport() override = default; 368 369 int32_t RecordedDataIsAvailable( 370 const void* /* audioSamples */, 371 size_t samples_per_channel, 372 size_t bytes_per_sample, 373 size_t number_of_channels, 374 uint32_t samples_per_second, 375 uint32_t /* total_delay_ms */, 376 int32_t /* clock_drift */, 377 uint32_t /* current_mic_level */, 378 bool /* key_pressed */, 379 uint32_t& new_mic_level, 380 std::optional<int64_t> /* estimated_capture_time_ns */) override { 381 new_mic_level = 1; 382 383 if (mode_ != Mode::kRecording) { 384 EXPECT_TRUE(false) 385 << "NeedMorePlayData mustn't be called when mode isn't kRecording"; 386 return -1; 387 } 388 389 MutexLock lock(&mutex_); 390 samples_per_channel_.push_back(samples_per_channel); 391 number_of_channels_.push_back(number_of_channels); 392 bytes_per_sample_.push_back(bytes_per_sample); 393 samples_per_second_.push_back(samples_per_second); 394 return 0; 395 } 396 397 int32_t NeedMorePlayData(size_t samples_per_channel, 398 size_t bytes_per_sample, 399 size_t number_of_channels, 400 uint32_t samples_per_second, 401 void* audio_samples, 402 size_t& samples_out, 403 int64_t* elapsed_time_ms, 404 int64_t* ntp_time_ms) override { 405 const size_t num_bytes = samples_per_channel * number_of_channels; 406 std::memset(audio_samples, 1, num_bytes); 407 samples_out = samples_per_channel * number_of_channels; 408 *elapsed_time_ms = 0; 409 *ntp_time_ms = 0; 410 411 if (mode_ != Mode::kPlaying) { 412 EXPECT_TRUE(false) 413 << "NeedMorePlayData mustn't be called when mode isn't kPlaying"; 414 return -1; 415 } 416 417 MutexLock lock(&mutex_); 418 samples_per_channel_.push_back(samples_per_channel); 419 number_of_channels_.push_back(number_of_channels); 420 bytes_per_sample_.push_back(bytes_per_sample); 421 samples_per_second_.push_back(samples_per_second); 422 return 0; 423 } 424 425 int32_t RecordedDataIsAvailable(const void* /* audio_samples */, 426 size_t /* samples_per_channel */, 427 size_t /* bytes_per_sample */, 428 size_t /* number_of_channels */, 429 uint32_t /* samples_per_second */, 430 uint32_t /* total_delay_ms */, 431 int32_t /* clockDrift */, 432 uint32_t /* current_mic_level */, 433 bool /* key_pressed */, 434 uint32_t& /* new_mic_level */) override { 435 RTC_CHECK(false) << "This methods should be never executed"; 436 } 437 438 void PullRenderData(int /* bits_per_sample */, 439 int /* sample_rate */, 440 size_t /* number_of_channels */, 441 size_t /* number_of_frames */, 442 void* /* audio_data */, 443 int64_t* /* elapsed_time_ms */, 444 int64_t* /* ntp_time_ms */) override { 445 RTC_CHECK(false) << "This methods should be never executed"; 446 } 447 448 std::vector<size_t> samples_per_channel() const { 449 MutexLock lock(&mutex_); 450 return samples_per_channel_; 451 } 452 std::vector<size_t> number_of_channels() const { 453 MutexLock lock(&mutex_); 454 return number_of_channels_; 455 } 456 std::vector<size_t> bytes_per_sample() const { 457 MutexLock lock(&mutex_); 458 return bytes_per_sample_; 459 } 460 std::vector<size_t> samples_per_second() const { 461 MutexLock lock(&mutex_); 462 return samples_per_second_; 463 } 464 465 private: 466 const Mode mode_; 467 468 mutable Mutex mutex_; 469 std::vector<size_t> samples_per_channel_ RTC_GUARDED_BY(mutex_); 470 std::vector<size_t> number_of_channels_ RTC_GUARDED_BY(mutex_); 471 std::vector<size_t> bytes_per_sample_ RTC_GUARDED_BY(mutex_); 472 std::vector<size_t> samples_per_second_ RTC_GUARDED_BY(mutex_); 473 }; 474 475 TEST(TestAudioDeviceModuleTest, CreatedADMCanRecord) { 476 GlobalSimulatedTimeController time_controller(kStartTime); 477 const Environment env = CreateEnvironment( 478 time_controller.GetClock(), time_controller.GetTaskQueueFactory()); 479 TestAudioTransport audio_transport(TestAudioTransport::Mode::kRecording); 480 std::unique_ptr<TestAudioDeviceModule::PulsedNoiseCapturer> capturer = 481 TestAudioDeviceModule::CreatePulsedNoiseCapturer( 482 /*max_amplitude=*/1000, 483 /*sampling_frequency_in_hz=*/48000, /*num_channels=*/2); 484 485 scoped_refptr<AudioDeviceModule> adm = 486 TestAudioDeviceModule::Create(env, std::move(capturer), 487 /*renderer=*/nullptr); 488 489 ASSERT_EQ(adm->RegisterAudioCallback(&audio_transport), 0); 490 ASSERT_EQ(adm->Init(), 0); 491 492 EXPECT_FALSE(adm->RecordingIsInitialized()); 493 ASSERT_EQ(adm->InitRecording(), 0); 494 EXPECT_TRUE(adm->RecordingIsInitialized()); 495 ASSERT_EQ(adm->StartRecording(), 0); 496 time_controller.AdvanceTime(TimeDelta::Millis(10)); 497 ASSERT_TRUE(adm->Recording()); 498 time_controller.AdvanceTime(TimeDelta::Millis(10)); 499 ASSERT_EQ(adm->StopRecording(), 0); 500 501 EXPECT_THAT(audio_transport.samples_per_channel(), 502 ElementsAre(480, 480, 480)); 503 EXPECT_THAT(audio_transport.number_of_channels(), ElementsAre(2, 2, 2)); 504 EXPECT_THAT(audio_transport.bytes_per_sample(), ElementsAre(4, 4, 4)); 505 EXPECT_THAT(audio_transport.samples_per_second(), 506 ElementsAre(48000, 48000, 48000)); 507 } 508 509 TEST(TestAudioDeviceModuleTest, CreatedADMCanPlay) { 510 GlobalSimulatedTimeController time_controller(kStartTime); 511 const Environment env = CreateEnvironment( 512 time_controller.GetClock(), time_controller.GetTaskQueueFactory()); 513 TestAudioTransport audio_transport(TestAudioTransport::Mode::kPlaying); 514 std::unique_ptr<TestAudioDeviceModule::Renderer> renderer = 515 TestAudioDeviceModule::CreateDiscardRenderer( 516 /*sampling_frequency_in_hz=*/48000, /*num_channels=*/2); 517 518 scoped_refptr<AudioDeviceModule> adm = 519 TestAudioDeviceModule::Create(env, 520 /*capturer=*/nullptr, std::move(renderer)); 521 522 ASSERT_EQ(adm->RegisterAudioCallback(&audio_transport), 0); 523 ASSERT_EQ(adm->Init(), 0); 524 525 EXPECT_FALSE(adm->PlayoutIsInitialized()); 526 ASSERT_EQ(adm->InitPlayout(), 0); 527 EXPECT_TRUE(adm->PlayoutIsInitialized()); 528 ASSERT_EQ(adm->StartPlayout(), 0); 529 time_controller.AdvanceTime(TimeDelta::Millis(10)); 530 ASSERT_TRUE(adm->Playing()); 531 time_controller.AdvanceTime(TimeDelta::Millis(10)); 532 ASSERT_EQ(adm->StopPlayout(), 0); 533 534 EXPECT_THAT(audio_transport.samples_per_channel(), 535 ElementsAre(480, 480, 480)); 536 EXPECT_THAT(audio_transport.number_of_channels(), ElementsAre(2, 2, 2)); 537 EXPECT_THAT(audio_transport.bytes_per_sample(), ElementsAre(4, 4, 4)); 538 EXPECT_THAT(audio_transport.samples_per_second(), 539 ElementsAre(48000, 48000, 48000)); 540 } 541 542 } // namespace 543 } // namespace webrtc