Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(301)

Side by Side Diff: webrtc/api/test/fakeaudiocapturemodule.cc

Issue 2514883002: Create //webrtc/api:libjingle_peerconnection_api + refactorings. (Closed)
Patch Set: Rebase Created 3 years, 11 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
(Empty)
1 /*
2 * Copyright 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/api/test/fakeaudiocapturemodule.h"
12
13 #include "webrtc/base/checks.h"
14 #include "webrtc/base/common.h"
15 #include "webrtc/base/refcount.h"
16 #include "webrtc/base/thread.h"
17 #include "webrtc/base/timeutils.h"
18
19 // Audio sample value that is high enough that it doesn't occur naturally when
20 // frames are being faked. E.g. NetEq will not generate this large sample value
21 // unless it has received an audio frame containing a sample of this value.
22 // Even simpler buffers would likely just contain audio sample values of 0.
23 static const int kHighSampleValue = 10000;
24
25 // Same value as src/modules/audio_device/main/source/audio_device_config.h in
26 // https://code.google.com/p/webrtc/
27 static const int kAdmMaxIdleTimeProcess = 1000;
28
29 // Constants here are derived by running VoE using a real ADM.
30 // The constants correspond to 10ms of mono audio at 44kHz.
31 static const int kTimePerFrameMs = 10;
32 static const uint8_t kNumberOfChannels = 1;
33 static const int kSamplesPerSecond = 44000;
34 static const int kTotalDelayMs = 0;
35 static const int kClockDriftMs = 0;
36 static const uint32_t kMaxVolume = 14392;
37
38 enum {
39 MSG_START_PROCESS,
40 MSG_RUN_PROCESS,
41 };
42
43 FakeAudioCaptureModule::FakeAudioCaptureModule()
44 : last_process_time_ms_(0),
45 audio_callback_(nullptr),
46 recording_(false),
47 playing_(false),
48 play_is_initialized_(false),
49 rec_is_initialized_(false),
50 current_mic_level_(kMaxVolume),
51 started_(false),
52 next_frame_time_(0),
53 frames_received_(0) {
54 }
55
56 FakeAudioCaptureModule::~FakeAudioCaptureModule() {
57 if (process_thread_) {
58 process_thread_->Stop();
59 }
60 }
61
62 rtc::scoped_refptr<FakeAudioCaptureModule> FakeAudioCaptureModule::Create() {
63 rtc::scoped_refptr<FakeAudioCaptureModule> capture_module(
64 new rtc::RefCountedObject<FakeAudioCaptureModule>());
65 if (!capture_module->Initialize()) {
66 return nullptr;
67 }
68 return capture_module;
69 }
70
71 int FakeAudioCaptureModule::frames_received() const {
72 rtc::CritScope cs(&crit_);
73 return frames_received_;
74 }
75
76 int64_t FakeAudioCaptureModule::TimeUntilNextProcess() {
77 const int64_t current_time = rtc::TimeMillis();
78 if (current_time < last_process_time_ms_) {
79 // TODO: wraparound could be handled more gracefully.
80 return 0;
81 }
82 const int64_t elapsed_time = current_time - last_process_time_ms_;
83 if (kAdmMaxIdleTimeProcess < elapsed_time) {
84 return 0;
85 }
86 return kAdmMaxIdleTimeProcess - elapsed_time;
87 }
88
89 void FakeAudioCaptureModule::Process() {
90 last_process_time_ms_ = rtc::TimeMillis();
91 }
92
93 int32_t FakeAudioCaptureModule::ActiveAudioLayer(
94 AudioLayer* /*audio_layer*/) const {
95 RTC_NOTREACHED();
96 return 0;
97 }
98
99 webrtc::AudioDeviceModule::ErrorCode FakeAudioCaptureModule::LastError() const {
100 RTC_NOTREACHED();
101 return webrtc::AudioDeviceModule::kAdmErrNone;
102 }
103
104 int32_t FakeAudioCaptureModule::RegisterEventObserver(
105 webrtc::AudioDeviceObserver* /*event_callback*/) {
106 // Only used to report warnings and errors. This fake implementation won't
107 // generate any so discard this callback.
108 return 0;
109 }
110
111 int32_t FakeAudioCaptureModule::RegisterAudioCallback(
112 webrtc::AudioTransport* audio_callback) {
113 rtc::CritScope cs(&crit_callback_);
114 audio_callback_ = audio_callback;
115 return 0;
116 }
117
118 int32_t FakeAudioCaptureModule::Init() {
119 // Initialize is called by the factory method. Safe to ignore this Init call.
120 return 0;
121 }
122
123 int32_t FakeAudioCaptureModule::Terminate() {
124 // Clean up in the destructor. No action here, just success.
125 return 0;
126 }
127
128 bool FakeAudioCaptureModule::Initialized() const {
129 RTC_NOTREACHED();
130 return 0;
131 }
132
133 int16_t FakeAudioCaptureModule::PlayoutDevices() {
134 RTC_NOTREACHED();
135 return 0;
136 }
137
138 int16_t FakeAudioCaptureModule::RecordingDevices() {
139 RTC_NOTREACHED();
140 return 0;
141 }
142
143 int32_t FakeAudioCaptureModule::PlayoutDeviceName(
144 uint16_t /*index*/,
145 char /*name*/[webrtc::kAdmMaxDeviceNameSize],
146 char /*guid*/[webrtc::kAdmMaxGuidSize]) {
147 RTC_NOTREACHED();
148 return 0;
149 }
150
151 int32_t FakeAudioCaptureModule::RecordingDeviceName(
152 uint16_t /*index*/,
153 char /*name*/[webrtc::kAdmMaxDeviceNameSize],
154 char /*guid*/[webrtc::kAdmMaxGuidSize]) {
155 RTC_NOTREACHED();
156 return 0;
157 }
158
159 int32_t FakeAudioCaptureModule::SetPlayoutDevice(uint16_t /*index*/) {
160 // No playout device, just playing from file. Return success.
161 return 0;
162 }
163
164 int32_t FakeAudioCaptureModule::SetPlayoutDevice(WindowsDeviceType /*device*/) {
165 if (play_is_initialized_) {
166 return -1;
167 }
168 return 0;
169 }
170
171 int32_t FakeAudioCaptureModule::SetRecordingDevice(uint16_t /*index*/) {
172 // No recording device, just dropping audio. Return success.
173 return 0;
174 }
175
176 int32_t FakeAudioCaptureModule::SetRecordingDevice(
177 WindowsDeviceType /*device*/) {
178 if (rec_is_initialized_) {
179 return -1;
180 }
181 return 0;
182 }
183
184 int32_t FakeAudioCaptureModule::PlayoutIsAvailable(bool* /*available*/) {
185 RTC_NOTREACHED();
186 return 0;
187 }
188
189 int32_t FakeAudioCaptureModule::InitPlayout() {
190 play_is_initialized_ = true;
191 return 0;
192 }
193
194 bool FakeAudioCaptureModule::PlayoutIsInitialized() const {
195 return play_is_initialized_;
196 }
197
198 int32_t FakeAudioCaptureModule::RecordingIsAvailable(bool* /*available*/) {
199 RTC_NOTREACHED();
200 return 0;
201 }
202
203 int32_t FakeAudioCaptureModule::InitRecording() {
204 rec_is_initialized_ = true;
205 return 0;
206 }
207
208 bool FakeAudioCaptureModule::RecordingIsInitialized() const {
209 return rec_is_initialized_;
210 }
211
212 int32_t FakeAudioCaptureModule::StartPlayout() {
213 if (!play_is_initialized_) {
214 return -1;
215 }
216 {
217 rtc::CritScope cs(&crit_);
218 playing_ = true;
219 }
220 bool start = true;
221 UpdateProcessing(start);
222 return 0;
223 }
224
225 int32_t FakeAudioCaptureModule::StopPlayout() {
226 bool start = false;
227 {
228 rtc::CritScope cs(&crit_);
229 playing_ = false;
230 start = ShouldStartProcessing();
231 }
232 UpdateProcessing(start);
233 return 0;
234 }
235
236 bool FakeAudioCaptureModule::Playing() const {
237 rtc::CritScope cs(&crit_);
238 return playing_;
239 }
240
241 int32_t FakeAudioCaptureModule::StartRecording() {
242 if (!rec_is_initialized_) {
243 return -1;
244 }
245 {
246 rtc::CritScope cs(&crit_);
247 recording_ = true;
248 }
249 bool start = true;
250 UpdateProcessing(start);
251 return 0;
252 }
253
254 int32_t FakeAudioCaptureModule::StopRecording() {
255 bool start = false;
256 {
257 rtc::CritScope cs(&crit_);
258 recording_ = false;
259 start = ShouldStartProcessing();
260 }
261 UpdateProcessing(start);
262 return 0;
263 }
264
265 bool FakeAudioCaptureModule::Recording() const {
266 rtc::CritScope cs(&crit_);
267 return recording_;
268 }
269
270 int32_t FakeAudioCaptureModule::SetAGC(bool /*enable*/) {
271 // No AGC but not needed since audio is pregenerated. Return success.
272 return 0;
273 }
274
275 bool FakeAudioCaptureModule::AGC() const {
276 RTC_NOTREACHED();
277 return 0;
278 }
279
280 int32_t FakeAudioCaptureModule::SetWaveOutVolume(uint16_t /*volume_left*/,
281 uint16_t /*volume_right*/) {
282 RTC_NOTREACHED();
283 return 0;
284 }
285
286 int32_t FakeAudioCaptureModule::WaveOutVolume(
287 uint16_t* /*volume_left*/,
288 uint16_t* /*volume_right*/) const {
289 RTC_NOTREACHED();
290 return 0;
291 }
292
293 int32_t FakeAudioCaptureModule::InitSpeaker() {
294 // No speaker, just playing from file. Return success.
295 return 0;
296 }
297
298 bool FakeAudioCaptureModule::SpeakerIsInitialized() const {
299 RTC_NOTREACHED();
300 return 0;
301 }
302
303 int32_t FakeAudioCaptureModule::InitMicrophone() {
304 // No microphone, just playing from file. Return success.
305 return 0;
306 }
307
308 bool FakeAudioCaptureModule::MicrophoneIsInitialized() const {
309 RTC_NOTREACHED();
310 return 0;
311 }
312
313 int32_t FakeAudioCaptureModule::SpeakerVolumeIsAvailable(bool* /*available*/) {
314 RTC_NOTREACHED();
315 return 0;
316 }
317
318 int32_t FakeAudioCaptureModule::SetSpeakerVolume(uint32_t /*volume*/) {
319 RTC_NOTREACHED();
320 return 0;
321 }
322
323 int32_t FakeAudioCaptureModule::SpeakerVolume(uint32_t* /*volume*/) const {
324 RTC_NOTREACHED();
325 return 0;
326 }
327
328 int32_t FakeAudioCaptureModule::MaxSpeakerVolume(
329 uint32_t* /*max_volume*/) const {
330 RTC_NOTREACHED();
331 return 0;
332 }
333
334 int32_t FakeAudioCaptureModule::MinSpeakerVolume(
335 uint32_t* /*min_volume*/) const {
336 RTC_NOTREACHED();
337 return 0;
338 }
339
340 int32_t FakeAudioCaptureModule::SpeakerVolumeStepSize(
341 uint16_t* /*step_size*/) const {
342 RTC_NOTREACHED();
343 return 0;
344 }
345
346 int32_t FakeAudioCaptureModule::MicrophoneVolumeIsAvailable(
347 bool* /*available*/) {
348 RTC_NOTREACHED();
349 return 0;
350 }
351
352 int32_t FakeAudioCaptureModule::SetMicrophoneVolume(uint32_t volume) {
353 rtc::CritScope cs(&crit_);
354 current_mic_level_ = volume;
355 return 0;
356 }
357
358 int32_t FakeAudioCaptureModule::MicrophoneVolume(uint32_t* volume) const {
359 rtc::CritScope cs(&crit_);
360 *volume = current_mic_level_;
361 return 0;
362 }
363
364 int32_t FakeAudioCaptureModule::MaxMicrophoneVolume(
365 uint32_t* max_volume) const {
366 *max_volume = kMaxVolume;
367 return 0;
368 }
369
370 int32_t FakeAudioCaptureModule::MinMicrophoneVolume(
371 uint32_t* /*min_volume*/) const {
372 RTC_NOTREACHED();
373 return 0;
374 }
375
376 int32_t FakeAudioCaptureModule::MicrophoneVolumeStepSize(
377 uint16_t* /*step_size*/) const {
378 RTC_NOTREACHED();
379 return 0;
380 }
381
382 int32_t FakeAudioCaptureModule::SpeakerMuteIsAvailable(bool* /*available*/) {
383 RTC_NOTREACHED();
384 return 0;
385 }
386
387 int32_t FakeAudioCaptureModule::SetSpeakerMute(bool /*enable*/) {
388 RTC_NOTREACHED();
389 return 0;
390 }
391
392 int32_t FakeAudioCaptureModule::SpeakerMute(bool* /*enabled*/) const {
393 RTC_NOTREACHED();
394 return 0;
395 }
396
397 int32_t FakeAudioCaptureModule::MicrophoneMuteIsAvailable(bool* /*available*/) {
398 RTC_NOTREACHED();
399 return 0;
400 }
401
402 int32_t FakeAudioCaptureModule::SetMicrophoneMute(bool /*enable*/) {
403 RTC_NOTREACHED();
404 return 0;
405 }
406
407 int32_t FakeAudioCaptureModule::MicrophoneMute(bool* /*enabled*/) const {
408 RTC_NOTREACHED();
409 return 0;
410 }
411
412 int32_t FakeAudioCaptureModule::MicrophoneBoostIsAvailable(
413 bool* /*available*/) {
414 RTC_NOTREACHED();
415 return 0;
416 }
417
418 int32_t FakeAudioCaptureModule::SetMicrophoneBoost(bool /*enable*/) {
419 RTC_NOTREACHED();
420 return 0;
421 }
422
423 int32_t FakeAudioCaptureModule::MicrophoneBoost(bool* /*enabled*/) const {
424 RTC_NOTREACHED();
425 return 0;
426 }
427
428 int32_t FakeAudioCaptureModule::StereoPlayoutIsAvailable(
429 bool* available) const {
430 // No recording device, just dropping audio. Stereo can be dropped just
431 // as easily as mono.
432 *available = true;
433 return 0;
434 }
435
436 int32_t FakeAudioCaptureModule::SetStereoPlayout(bool /*enable*/) {
437 // No recording device, just dropping audio. Stereo can be dropped just
438 // as easily as mono.
439 return 0;
440 }
441
442 int32_t FakeAudioCaptureModule::StereoPlayout(bool* /*enabled*/) const {
443 RTC_NOTREACHED();
444 return 0;
445 }
446
447 int32_t FakeAudioCaptureModule::StereoRecordingIsAvailable(
448 bool* available) const {
449 // Keep thing simple. No stereo recording.
450 *available = false;
451 return 0;
452 }
453
454 int32_t FakeAudioCaptureModule::SetStereoRecording(bool enable) {
455 if (!enable) {
456 return 0;
457 }
458 return -1;
459 }
460
461 int32_t FakeAudioCaptureModule::StereoRecording(bool* /*enabled*/) const {
462 RTC_NOTREACHED();
463 return 0;
464 }
465
466 int32_t FakeAudioCaptureModule::SetRecordingChannel(
467 const ChannelType channel) {
468 if (channel != AudioDeviceModule::kChannelBoth) {
469 // There is no right or left in mono. I.e. kChannelBoth should be used for
470 // mono.
471 RTC_NOTREACHED();
472 return -1;
473 }
474 return 0;
475 }
476
477 int32_t FakeAudioCaptureModule::RecordingChannel(ChannelType* channel) const {
478 // Stereo recording not supported. However, WebRTC ADM returns kChannelBoth
479 // in that case. Do the same here.
480 *channel = AudioDeviceModule::kChannelBoth;
481 return 0;
482 }
483
484 int32_t FakeAudioCaptureModule::SetPlayoutBuffer(const BufferType /*type*/,
485 uint16_t /*size_ms*/) {
486 RTC_NOTREACHED();
487 return 0;
488 }
489
490 int32_t FakeAudioCaptureModule::PlayoutBuffer(BufferType* /*type*/,
491 uint16_t* /*size_ms*/) const {
492 RTC_NOTREACHED();
493 return 0;
494 }
495
496 int32_t FakeAudioCaptureModule::PlayoutDelay(uint16_t* delay_ms) const {
497 // No delay since audio frames are dropped.
498 *delay_ms = 0;
499 return 0;
500 }
501
502 int32_t FakeAudioCaptureModule::RecordingDelay(uint16_t* /*delay_ms*/) const {
503 RTC_NOTREACHED();
504 return 0;
505 }
506
507 int32_t FakeAudioCaptureModule::CPULoad(uint16_t* /*load*/) const {
508 RTC_NOTREACHED();
509 return 0;
510 }
511
512 int32_t FakeAudioCaptureModule::StartRawOutputFileRecording(
513 const char /*pcm_file_name_utf8*/[webrtc::kAdmMaxFileNameSize]) {
514 RTC_NOTREACHED();
515 return 0;
516 }
517
518 int32_t FakeAudioCaptureModule::StopRawOutputFileRecording() {
519 RTC_NOTREACHED();
520 return 0;
521 }
522
523 int32_t FakeAudioCaptureModule::StartRawInputFileRecording(
524 const char /*pcm_file_name_utf8*/[webrtc::kAdmMaxFileNameSize]) {
525 RTC_NOTREACHED();
526 return 0;
527 }
528
529 int32_t FakeAudioCaptureModule::StopRawInputFileRecording() {
530 RTC_NOTREACHED();
531 return 0;
532 }
533
534 int32_t FakeAudioCaptureModule::SetRecordingSampleRate(
535 const uint32_t /*samples_per_sec*/) {
536 RTC_NOTREACHED();
537 return 0;
538 }
539
540 int32_t FakeAudioCaptureModule::RecordingSampleRate(
541 uint32_t* /*samples_per_sec*/) const {
542 RTC_NOTREACHED();
543 return 0;
544 }
545
546 int32_t FakeAudioCaptureModule::SetPlayoutSampleRate(
547 const uint32_t /*samples_per_sec*/) {
548 RTC_NOTREACHED();
549 return 0;
550 }
551
552 int32_t FakeAudioCaptureModule::PlayoutSampleRate(
553 uint32_t* /*samples_per_sec*/) const {
554 RTC_NOTREACHED();
555 return 0;
556 }
557
558 int32_t FakeAudioCaptureModule::ResetAudioDevice() {
559 RTC_NOTREACHED();
560 return 0;
561 }
562
563 int32_t FakeAudioCaptureModule::SetLoudspeakerStatus(bool /*enable*/) {
564 RTC_NOTREACHED();
565 return 0;
566 }
567
568 int32_t FakeAudioCaptureModule::GetLoudspeakerStatus(bool* /*enabled*/) const {
569 RTC_NOTREACHED();
570 return 0;
571 }
572
573 void FakeAudioCaptureModule::OnMessage(rtc::Message* msg) {
574 switch (msg->message_id) {
575 case MSG_START_PROCESS:
576 StartProcessP();
577 break;
578 case MSG_RUN_PROCESS:
579 ProcessFrameP();
580 break;
581 default:
582 // All existing messages should be caught. Getting here should never
583 // happen.
584 RTC_NOTREACHED();
585 }
586 }
587
588 bool FakeAudioCaptureModule::Initialize() {
589 // Set the send buffer samples high enough that it would not occur on the
590 // remote side unless a packet containing a sample of that magnitude has been
591 // sent to it. Note that the audio processing pipeline will likely distort the
592 // original signal.
593 SetSendBuffer(kHighSampleValue);
594 last_process_time_ms_ = rtc::TimeMillis();
595 return true;
596 }
597
598 void FakeAudioCaptureModule::SetSendBuffer(int value) {
599 Sample* buffer_ptr = reinterpret_cast<Sample*>(send_buffer_);
600 const size_t buffer_size_in_samples =
601 sizeof(send_buffer_) / kNumberBytesPerSample;
602 for (size_t i = 0; i < buffer_size_in_samples; ++i) {
603 buffer_ptr[i] = value;
604 }
605 }
606
607 void FakeAudioCaptureModule::ResetRecBuffer() {
608 memset(rec_buffer_, 0, sizeof(rec_buffer_));
609 }
610
611 bool FakeAudioCaptureModule::CheckRecBuffer(int value) {
612 const Sample* buffer_ptr = reinterpret_cast<const Sample*>(rec_buffer_);
613 const size_t buffer_size_in_samples =
614 sizeof(rec_buffer_) / kNumberBytesPerSample;
615 for (size_t i = 0; i < buffer_size_in_samples; ++i) {
616 if (buffer_ptr[i] >= value) return true;
617 }
618 return false;
619 }
620
621 bool FakeAudioCaptureModule::ShouldStartProcessing() {
622 return recording_ || playing_;
623 }
624
625 void FakeAudioCaptureModule::UpdateProcessing(bool start) {
626 if (start) {
627 if (!process_thread_) {
628 process_thread_.reset(new rtc::Thread());
629 process_thread_->Start();
630 }
631 process_thread_->Post(RTC_FROM_HERE, this, MSG_START_PROCESS);
632 } else {
633 if (process_thread_) {
634 process_thread_->Stop();
635 process_thread_.reset(nullptr);
636 }
637 started_ = false;
638 }
639 }
640
641 void FakeAudioCaptureModule::StartProcessP() {
642 RTC_CHECK(process_thread_->IsCurrent());
643 if (started_) {
644 // Already started.
645 return;
646 }
647 ProcessFrameP();
648 }
649
650 void FakeAudioCaptureModule::ProcessFrameP() {
651 RTC_CHECK(process_thread_->IsCurrent());
652 if (!started_) {
653 next_frame_time_ = rtc::TimeMillis();
654 started_ = true;
655 }
656
657 {
658 rtc::CritScope cs(&crit_);
659 // Receive and send frames every kTimePerFrameMs.
660 if (playing_) {
661 ReceiveFrameP();
662 }
663 if (recording_) {
664 SendFrameP();
665 }
666 }
667
668 next_frame_time_ += kTimePerFrameMs;
669 const int64_t current_time = rtc::TimeMillis();
670 const int64_t wait_time =
671 (next_frame_time_ > current_time) ? next_frame_time_ - current_time : 0;
672 process_thread_->PostDelayed(RTC_FROM_HERE, wait_time, this, MSG_RUN_PROCESS);
673 }
674
675 void FakeAudioCaptureModule::ReceiveFrameP() {
676 RTC_CHECK(process_thread_->IsCurrent());
677 {
678 rtc::CritScope cs(&crit_callback_);
679 if (!audio_callback_) {
680 return;
681 }
682 ResetRecBuffer();
683 size_t nSamplesOut = 0;
684 int64_t elapsed_time_ms = 0;
685 int64_t ntp_time_ms = 0;
686 if (audio_callback_->NeedMorePlayData(kNumberSamples, kNumberBytesPerSample,
687 kNumberOfChannels, kSamplesPerSecond,
688 rec_buffer_, nSamplesOut,
689 &elapsed_time_ms, &ntp_time_ms) != 0) {
690 RTC_NOTREACHED();
691 }
692 RTC_CHECK(nSamplesOut == kNumberSamples);
693 }
694 // The SetBuffer() function ensures that after decoding, the audio buffer
695 // should contain samples of similar magnitude (there is likely to be some
696 // distortion due to the audio pipeline). If one sample is detected to
697 // have the same or greater magnitude somewhere in the frame, an actual frame
698 // has been received from the remote side (i.e. faked frames are not being
699 // pulled).
700 if (CheckRecBuffer(kHighSampleValue)) {
701 rtc::CritScope cs(&crit_);
702 ++frames_received_;
703 }
704 }
705
706 void FakeAudioCaptureModule::SendFrameP() {
707 RTC_CHECK(process_thread_->IsCurrent());
708 rtc::CritScope cs(&crit_callback_);
709 if (!audio_callback_) {
710 return;
711 }
712 bool key_pressed = false;
713 uint32_t current_mic_level = 0;
714 MicrophoneVolume(&current_mic_level);
715 if (audio_callback_->RecordedDataIsAvailable(send_buffer_, kNumberSamples,
716 kNumberBytesPerSample,
717 kNumberOfChannels,
718 kSamplesPerSecond, kTotalDelayMs,
719 kClockDriftMs, current_mic_level,
720 key_pressed,
721 current_mic_level) != 0) {
722 RTC_NOTREACHED();
723 }
724 SetMicrophoneVolume(current_mic_level);
725 }
OLDNEW
« no previous file with comments | « webrtc/api/test/fakeaudiocapturemodule.h ('k') | webrtc/api/test/fakeaudiocapturemodule_unittest.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698