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/transmit_mixer.h" 12 13 #include "webrtc/modules/utility/interface/audio_frame_operations.h" 14 #include "webrtc/system_wrappers/interface/critical_section_wrapper.h" 15 #include "webrtc/system_wrappers/interface/event_wrapper.h" 16 #include "webrtc/system_wrappers/interface/logging.h" 17 #include "webrtc/system_wrappers/interface/trace.h" 18 #include "webrtc/voice_engine/channel.h" 19 #include "webrtc/voice_engine/channel_manager.h" 20 #include "webrtc/voice_engine/include/voe_external_media.h" 21 #include "webrtc/voice_engine/statistics.h" 22 #include "webrtc/voice_engine/utility.h" 23 #include "webrtc/voice_engine/voe_base_impl.h" 24 25 #define WEBRTC_ABS(a) (((a) < 0) ? -(a) : (a)) 26 27 namespace webrtc { 28 namespace voe { 29 30 // TODO(ajm): The thread safety of this is dubious... 31 void 32 TransmitMixer::OnPeriodicProcess() 33 { 34 WEBRTC_TRACE(kTraceStream, kTraceVoice, VoEId(_instanceId, -1), 35 "TransmitMixer::OnPeriodicProcess()"); 36 37 #if defined(WEBRTC_VOICE_ENGINE_TYPING_DETECTION) 38 if (_typingNoiseWarningPending) 39 { 40 CriticalSectionScoped cs(&_callbackCritSect); 41 if (_voiceEngineObserverPtr) 42 { 43 if (_typingNoiseDetected) { 44 WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, -1), 45 "TransmitMixer::OnPeriodicProcess() => " 46 "CallbackOnError(VE_TYPING_NOISE_WARNING)"); 47 _voiceEngineObserverPtr->CallbackOnError( 48 -1, 49 VE_TYPING_NOISE_WARNING); 50 } else { 51 WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, -1), 52 "TransmitMixer::OnPeriodicProcess() => " 53 "CallbackOnError(VE_TYPING_NOISE_OFF_WARNING)"); 54 _voiceEngineObserverPtr->CallbackOnError( 55 -1, 56 VE_TYPING_NOISE_OFF_WARNING); 57 } 58 } 59 _typingNoiseWarningPending = false; 60 } 61 #endif 62 63 bool saturationWarning = false; 64 { 65 // Modify |_saturationWarning| under lock to avoid conflict with write op 66 // in ProcessAudio and also ensure that we don't hold the lock during the 67 // callback. 68 CriticalSectionScoped cs(&_critSect); 69 saturationWarning = _saturationWarning; 70 if (_saturationWarning) 71 _saturationWarning = false; 72 } 73 74 if (saturationWarning) 75 { 76 CriticalSectionScoped cs(&_callbackCritSect); 77 if (_voiceEngineObserverPtr) 78 { 79 WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, -1), 80 "TransmitMixer::OnPeriodicProcess() =>" 81 " CallbackOnError(VE_SATURATION_WARNING)"); 82 _voiceEngineObserverPtr->CallbackOnError(-1, VE_SATURATION_WARNING); 83 } 84 } 85 } 86 87 88 void TransmitMixer::PlayNotification(int32_t id, 89 uint32_t durationMs) 90 { 91 WEBRTC_TRACE(kTraceStream, kTraceVoice, VoEId(_instanceId, -1), 92 "TransmitMixer::PlayNotification(id=%d, durationMs=%d)", 93 id, durationMs); 94 95 // Not implement yet 96 } 97 98 void TransmitMixer::RecordNotification(int32_t id, 99 uint32_t durationMs) 100 { 101 WEBRTC_TRACE(kTraceStream, kTraceVoice, VoEId(_instanceId,-1), 102 "TransmitMixer::RecordNotification(id=%d, durationMs=%d)", 103 id, durationMs); 104 105 // Not implement yet 106 } 107 108 void TransmitMixer::PlayFileEnded(int32_t id) 109 { 110 WEBRTC_TRACE(kTraceStream, kTraceVoice, VoEId(_instanceId, -1), 111 "TransmitMixer::PlayFileEnded(id=%d)", id); 112 113 assert(id == _filePlayerId); 114 115 CriticalSectionScoped cs(&_critSect); 116 117 _filePlaying = false; 118 WEBRTC_TRACE(kTraceStateInfo, kTraceVoice, VoEId(_instanceId, -1), 119 "TransmitMixer::PlayFileEnded() =>" 120 "file player module is shutdown"); 121 } 122 123 void 124 TransmitMixer::RecordFileEnded(int32_t id) 125 { 126 WEBRTC_TRACE(kTraceStream, kTraceVoice, VoEId(_instanceId, -1), 127 "TransmitMixer::RecordFileEnded(id=%d)", id); 128 129 if (id == _fileRecorderId) 130 { 131 CriticalSectionScoped cs(&_critSect); 132 _fileRecording = false; 133 WEBRTC_TRACE(kTraceStateInfo, kTraceVoice, VoEId(_instanceId, -1), 134 "TransmitMixer::RecordFileEnded() => fileRecorder module" 135 "is shutdown"); 136 } else if (id == _fileCallRecorderId) 137 { 138 CriticalSectionScoped cs(&_critSect); 139 _fileCallRecording = false; 140 WEBRTC_TRACE(kTraceStateInfo, kTraceVoice, VoEId(_instanceId, -1), 141 "TransmitMixer::RecordFileEnded() => fileCallRecorder" 142 "module is shutdown"); 143 } 144 } 145 146 int32_t 147 TransmitMixer::Create(TransmitMixer*& mixer, uint32_t instanceId) 148 { 149 WEBRTC_TRACE(kTraceMemory, kTraceVoice, VoEId(instanceId, -1), 150 "TransmitMixer::Create(instanceId=%d)", instanceId); 151 mixer = new TransmitMixer(instanceId); 152 if (mixer == NULL) 153 { 154 WEBRTC_TRACE(kTraceMemory, kTraceVoice, VoEId(instanceId, -1), 155 "TransmitMixer::Create() unable to allocate memory" 156 "for mixer"); 157 return -1; 158 } 159 return 0; 160 } 161 162 void 163 TransmitMixer::Destroy(TransmitMixer*& mixer) 164 { 165 if (mixer) 166 { 167 delete mixer; 168 mixer = NULL; 169 } 170 } 171 172 TransmitMixer::TransmitMixer(uint32_t instanceId) : 173 _engineStatisticsPtr(NULL), 174 _channelManagerPtr(NULL), 175 audioproc_(NULL), 176 _voiceEngineObserverPtr(NULL), 177 _processThreadPtr(NULL), 178 _filePlayerPtr(NULL), 179 _fileRecorderPtr(NULL), 180 _fileCallRecorderPtr(NULL), 181 // Avoid conflict with other channels by adding 1024 - 1026, 182 // won't use as much as 1024 channels. 183 _filePlayerId(instanceId + 1024), 184 _fileRecorderId(instanceId + 1025), 185 _fileCallRecorderId(instanceId + 1026), 186 _filePlaying(false), 187 _fileRecording(false), 188 _fileCallRecording(false), 189 _audioLevel(), 190 _critSect(*CriticalSectionWrapper::CreateCriticalSection()), 191 _callbackCritSect(*CriticalSectionWrapper::CreateCriticalSection()), 192 #ifdef WEBRTC_VOICE_ENGINE_TYPING_DETECTION 193 _typingNoiseWarningPending(false), 194 _typingNoiseDetected(false), 195 #endif 196 _saturationWarning(false), 197 _instanceId(instanceId), 198 _mixFileWithMicrophone(false), 199 _captureLevel(0), 200 external_postproc_ptr_(NULL), 201 external_preproc_ptr_(NULL), 202 _mute(false), 203 _remainingMuteMicTimeMs(0), 204 stereo_codec_(false), 205 swap_stereo_channels_(false) 206 { 207 WEBRTC_TRACE(kTraceMemory, kTraceVoice, VoEId(_instanceId, -1), 208 "TransmitMixer::TransmitMixer() - ctor"); 209 } 210 211 TransmitMixer::~TransmitMixer() 212 { 213 WEBRTC_TRACE(kTraceMemory, kTraceVoice, VoEId(_instanceId, -1), 214 "TransmitMixer::~TransmitMixer() - dtor"); 215 _monitorModule.DeRegisterObserver(); 216 if (_processThreadPtr) 217 { 218 _processThreadPtr->DeRegisterModule(&_monitorModule); 219 } 220 DeRegisterExternalMediaProcessing(kRecordingAllChannelsMixed); 221 DeRegisterExternalMediaProcessing(kRecordingPreprocessing); 222 { 223 CriticalSectionScoped cs(&_critSect); 224 if (_fileRecorderPtr) 225 { 226 _fileRecorderPtr->RegisterModuleFileCallback(NULL); 227 _fileRecorderPtr->StopRecording(); 228 FileRecorder::DestroyFileRecorder(_fileRecorderPtr); 229 _fileRecorderPtr = NULL; 230 } 231 if (_fileCallRecorderPtr) 232 { 233 _fileCallRecorderPtr->RegisterModuleFileCallback(NULL); 234 _fileCallRecorderPtr->StopRecording(); 235 FileRecorder::DestroyFileRecorder(_fileCallRecorderPtr); 236 _fileCallRecorderPtr = NULL; 237 } 238 if (_filePlayerPtr) 239 { 240 _filePlayerPtr->RegisterModuleFileCallback(NULL); 241 _filePlayerPtr->StopPlayingFile(); 242 FilePlayer::DestroyFilePlayer(_filePlayerPtr); 243 _filePlayerPtr = NULL; 244 } 245 } 246 delete &_critSect; 247 delete &_callbackCritSect; 248 } 249 250 int32_t 251 TransmitMixer::SetEngineInformation(ProcessThread& processThread, 252 Statistics& engineStatistics, 253 ChannelManager& channelManager) 254 { 255 WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, -1), 256 "TransmitMixer::SetEngineInformation()"); 257 258 _processThreadPtr = &processThread; 259 _engineStatisticsPtr = &engineStatistics; 260 _channelManagerPtr = &channelManager; 261 262 if (_processThreadPtr->RegisterModule(&_monitorModule) == -1) 263 { 264 WEBRTC_TRACE(kTraceWarning, kTraceVoice, VoEId(_instanceId, -1), 265 "TransmitMixer::SetEngineInformation() failed to" 266 "register the monitor module"); 267 } else 268 { 269 _monitorModule.RegisterObserver(*this); 270 } 271 272 return 0; 273 } 274 275 int32_t 276 TransmitMixer::RegisterVoiceEngineObserver(VoiceEngineObserver& observer) 277 { 278 WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, -1), 279 "TransmitMixer::RegisterVoiceEngineObserver()"); 280 CriticalSectionScoped cs(&_callbackCritSect); 281 282 if (_voiceEngineObserverPtr) 283 { 284 _engineStatisticsPtr->SetLastError( 285 VE_INVALID_OPERATION, kTraceError, 286 "RegisterVoiceEngineObserver() observer already enabled"); 287 return -1; 288 } 289 _voiceEngineObserverPtr = &observer; 290 return 0; 291 } 292 293 int32_t 294 TransmitMixer::SetAudioProcessingModule(AudioProcessing* audioProcessingModule) 295 { 296 WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, -1), 297 "TransmitMixer::SetAudioProcessingModule(" 298 "audioProcessingModule=0x%x)", 299 audioProcessingModule); 300 audioproc_ = audioProcessingModule; 301 return 0; 302 } 303 304 void TransmitMixer::GetSendCodecInfo(int* max_sample_rate, int* max_channels) { 305 *max_sample_rate = 8000; 306 *max_channels = 1; 307 for (ChannelManager::Iterator it(_channelManagerPtr); it.IsValid(); 308 it.Increment()) { 309 Channel* channel = it.GetChannel(); 310 if (channel->Sending()) { 311 CodecInst codec; 312 channel->GetSendCodec(codec); 313 *max_sample_rate = std::max(*max_sample_rate, codec.plfreq); 314 *max_channels = std::max(*max_channels, codec.channels); 315 } 316 } 317 } 318 319 int32_t 320 TransmitMixer::PrepareDemux(const void* audioSamples, 321 uint32_t nSamples, 322 uint8_t nChannels, 323 uint32_t samplesPerSec, 324 uint16_t totalDelayMS, 325 int32_t clockDrift, 326 uint16_t currentMicLevel, 327 bool keyPressed) 328 { 329 WEBRTC_TRACE(kTraceStream, kTraceVoice, VoEId(_instanceId, -1), 330 "TransmitMixer::PrepareDemux(nSamples=%u, nChannels=%u," 331 "samplesPerSec=%u, totalDelayMS=%u, clockDrift=%d," 332 "currentMicLevel=%u)", nSamples, nChannels, samplesPerSec, 333 totalDelayMS, clockDrift, currentMicLevel); 334 335 // --- Resample input audio and create/store the initial audio frame 336 GenerateAudioFrame(static_cast<const int16_t*>(audioSamples), 337 nSamples, 338 nChannels, 339 samplesPerSec); 340 341 { 342 CriticalSectionScoped cs(&_callbackCritSect); 343 if (external_preproc_ptr_) { 344 external_preproc_ptr_->Process(-1, kRecordingPreprocessing, 345 _audioFrame.data_, 346 _audioFrame.samples_per_channel_, 347 _audioFrame.sample_rate_hz_, 348 _audioFrame.num_channels_ == 2); 349 } 350 } 351 352 // --- Near-end audio processing. 353 ProcessAudio(totalDelayMS, clockDrift, currentMicLevel, keyPressed); 354 355 if (swap_stereo_channels_ && stereo_codec_) 356 // Only bother swapping if we're using a stereo codec. 357 AudioFrameOperations::SwapStereoChannels(&_audioFrame); 358 359 // --- Annoying typing detection (utilizes the APM/VAD decision) 360 #ifdef WEBRTC_VOICE_ENGINE_TYPING_DETECTION 361 TypingDetection(keyPressed); 362 #endif 363 364 // --- Mute during DTMF tone if direct feedback is enabled 365 if (_remainingMuteMicTimeMs > 0) 366 { 367 AudioFrameOperations::Mute(_audioFrame); 368 _remainingMuteMicTimeMs -= 10; 369 if (_remainingMuteMicTimeMs < 0) 370 { 371 _remainingMuteMicTimeMs = 0; 372 } 373 } 374 375 // --- Mute signal 376 if (_mute) 377 { 378 AudioFrameOperations::Mute(_audioFrame); 379 } 380 381 // --- Mix with file (does not affect the mixing frequency) 382 if (_filePlaying) 383 { 384 MixOrReplaceAudioWithFile(_audioFrame.sample_rate_hz_); 385 } 386 387 // --- Record to file 388 bool file_recording = false; 389 { 390 CriticalSectionScoped cs(&_critSect); 391 file_recording = _fileRecording; 392 } 393 if (file_recording) 394 { 395 RecordAudioToFile(_audioFrame.sample_rate_hz_); 396 } 397 398 { 399 CriticalSectionScoped cs(&_callbackCritSect); 400 if (external_postproc_ptr_) { 401 external_postproc_ptr_->Process(-1, kRecordingAllChannelsMixed, 402 _audioFrame.data_, 403 _audioFrame.samples_per_channel_, 404 _audioFrame.sample_rate_hz_, 405 _audioFrame.num_channels_ == 2); 406 } 407 } 408 409 // --- Measure audio level of speech after all processing. 410 _audioLevel.ComputeLevel(_audioFrame); 411 return 0; 412 } 413 414 int32_t 415 TransmitMixer::DemuxAndMix() 416 { 417 WEBRTC_TRACE(kTraceStream, kTraceVoice, VoEId(_instanceId, -1), 418 "TransmitMixer::DemuxAndMix()"); 419 420 for (ChannelManager::Iterator it(_channelManagerPtr); it.IsValid(); 421 it.Increment()) 422 { 423 Channel* channelPtr = it.GetChannel(); 424 if (channelPtr->Sending()) 425 { 426 // Demultiplex makes a copy of its input. 427 channelPtr->Demultiplex(_audioFrame); 428 channelPtr->PrepareEncodeAndSend(_audioFrame.sample_rate_hz_); 429 } 430 } 431 return 0; 432 } 433 434 void TransmitMixer::DemuxAndMix(const int voe_channels[], 435 int number_of_voe_channels) { 436 for (int i = 0; i < number_of_voe_channels; ++i) { 437 voe::ChannelOwner ch = _channelManagerPtr->GetChannel(voe_channels[i]); 438 voe::Channel* channel_ptr = ch.channel(); 439 if (channel_ptr) { 440 if (channel_ptr->Sending()) { 441 // Demultiplex makes a copy of its input. 442 channel_ptr->Demultiplex(_audioFrame); 443 channel_ptr->PrepareEncodeAndSend(_audioFrame.sample_rate_hz_); 444 } 445 } 446 } 447 } 448 449 int32_t 450 TransmitMixer::EncodeAndSend() 451 { 452 WEBRTC_TRACE(kTraceStream, kTraceVoice, VoEId(_instanceId, -1), 453 "TransmitMixer::EncodeAndSend()"); 454 455 for (ChannelManager::Iterator it(_channelManagerPtr); it.IsValid(); 456 it.Increment()) 457 { 458 Channel* channelPtr = it.GetChannel(); 459 if (channelPtr->Sending()) 460 { 461 channelPtr->EncodeAndSend(); 462 } 463 } 464 return 0; 465 } 466 467 void TransmitMixer::EncodeAndSend(const int voe_channels[], 468 int number_of_voe_channels) { 469 for (int i = 0; i < number_of_voe_channels; ++i) { 470 voe::ChannelOwner ch = _channelManagerPtr->GetChannel(voe_channels[i]); 471 voe::Channel* channel_ptr = ch.channel(); 472 if (channel_ptr && channel_ptr->Sending()) 473 channel_ptr->EncodeAndSend(); 474 } 475 } 476 477 uint32_t TransmitMixer::CaptureLevel() const 478 { 479 return _captureLevel; 480 } 481 482 void 483 TransmitMixer::UpdateMuteMicrophoneTime(uint32_t lengthMs) 484 { 485 WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, -1), 486 "TransmitMixer::UpdateMuteMicrophoneTime(lengthMs=%d)", 487 lengthMs); 488 _remainingMuteMicTimeMs = lengthMs; 489 } 490 491 int32_t 492 TransmitMixer::StopSend() 493 { 494 WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, -1), 495 "TransmitMixer::StopSend()"); 496 _audioLevel.Clear(); 497 return 0; 498 } 499 500 int TransmitMixer::StartPlayingFileAsMicrophone(const char* fileName, 501 bool loop, 502 FileFormats format, 503 int startPosition, 504 float volumeScaling, 505 int stopPosition, 506 const CodecInst* codecInst) 507 { 508 WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, -1), 509 "TransmitMixer::StartPlayingFileAsMicrophone(" 510 "fileNameUTF8[]=%s,loop=%d, format=%d, volumeScaling=%5.3f," 511 " startPosition=%d, stopPosition=%d)", fileName, loop, 512 format, volumeScaling, startPosition, stopPosition); 513 514 if (_filePlaying) 515 { 516 _engineStatisticsPtr->SetLastError( 517 VE_ALREADY_PLAYING, kTraceWarning, 518 "StartPlayingFileAsMicrophone() is already playing"); 519 return 0; 520 } 521 522 CriticalSectionScoped cs(&_critSect); 523 524 // Destroy the old instance 525 if (_filePlayerPtr) 526 { 527 _filePlayerPtr->RegisterModuleFileCallback(NULL); 528 FilePlayer::DestroyFilePlayer(_filePlayerPtr); 529 _filePlayerPtr = NULL; 530 } 531 532 // Dynamically create the instance 533 _filePlayerPtr 534 = FilePlayer::CreateFilePlayer(_filePlayerId, 535 (const FileFormats) format); 536 537 if (_filePlayerPtr == NULL) 538 { 539 _engineStatisticsPtr->SetLastError( 540 VE_INVALID_ARGUMENT, kTraceError, 541 "StartPlayingFileAsMicrophone() filePlayer format isnot correct"); 542 return -1; 543 } 544 545 const uint32_t notificationTime(0); 546 547 if (_filePlayerPtr->StartPlayingFile( 548 fileName, 549 loop, 550 startPosition, 551 volumeScaling, 552 notificationTime, 553 stopPosition, 554 (const CodecInst*) codecInst) != 0) 555 { 556 _engineStatisticsPtr->SetLastError( 557 VE_BAD_FILE, kTraceError, 558 "StartPlayingFile() failed to start file playout"); 559 _filePlayerPtr->StopPlayingFile(); 560 FilePlayer::DestroyFilePlayer(_filePlayerPtr); 561 _filePlayerPtr = NULL; 562 return -1; 563 } 564 565 _filePlayerPtr->RegisterModuleFileCallback(this); 566 _filePlaying = true; 567 568 return 0; 569 } 570 571 int TransmitMixer::StartPlayingFileAsMicrophone(InStream* stream, 572 FileFormats format, 573 int startPosition, 574 float volumeScaling, 575 int stopPosition, 576 const CodecInst* codecInst) 577 { 578 WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,-1), 579 "TransmitMixer::StartPlayingFileAsMicrophone(format=%d," 580 " volumeScaling=%5.3f, startPosition=%d, stopPosition=%d)", 581 format, volumeScaling, startPosition, stopPosition); 582 583 if (stream == NULL) 584 { 585 _engineStatisticsPtr->SetLastError( 586 VE_BAD_FILE, kTraceError, 587 "StartPlayingFileAsMicrophone() NULL as input stream"); 588 return -1; 589 } 590 591 if (_filePlaying) 592 { 593 _engineStatisticsPtr->SetLastError( 594 VE_ALREADY_PLAYING, kTraceWarning, 595 "StartPlayingFileAsMicrophone() is already playing"); 596 return 0; 597 } 598 599 CriticalSectionScoped cs(&_critSect); 600 601 // Destroy the old instance 602 if (_filePlayerPtr) 603 { 604 _filePlayerPtr->RegisterModuleFileCallback(NULL); 605 FilePlayer::DestroyFilePlayer(_filePlayerPtr); 606 _filePlayerPtr = NULL; 607 } 608 609 // Dynamically create the instance 610 _filePlayerPtr 611 = FilePlayer::CreateFilePlayer(_filePlayerId, 612 (const FileFormats) format); 613 614 if (_filePlayerPtr == NULL) 615 { 616 _engineStatisticsPtr->SetLastError( 617 VE_INVALID_ARGUMENT, kTraceWarning, 618 "StartPlayingFileAsMicrophone() filePlayer format isnot correct"); 619 return -1; 620 } 621 622 const uint32_t notificationTime(0); 623 624 if (_filePlayerPtr->StartPlayingFile( 625 (InStream&) *stream, 626 startPosition, 627 volumeScaling, 628 notificationTime, 629 stopPosition, 630 (const CodecInst*) codecInst) != 0) 631 { 632 _engineStatisticsPtr->SetLastError( 633 VE_BAD_FILE, kTraceError, 634 "StartPlayingFile() failed to start file playout"); 635 _filePlayerPtr->StopPlayingFile(); 636 FilePlayer::DestroyFilePlayer(_filePlayerPtr); 637 _filePlayerPtr = NULL; 638 return -1; 639 } 640 _filePlayerPtr->RegisterModuleFileCallback(this); 641 _filePlaying = true; 642 643 return 0; 644 } 645 646 int TransmitMixer::StopPlayingFileAsMicrophone() 647 { 648 WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,-1), 649 "TransmitMixer::StopPlayingFileAsMicrophone()"); 650 651 if (!_filePlaying) 652 { 653 _engineStatisticsPtr->SetLastError( 654 VE_INVALID_OPERATION, kTraceWarning, 655 "StopPlayingFileAsMicrophone() isnot playing"); 656 return 0; 657 } 658 659 CriticalSectionScoped cs(&_critSect); 660 661 if (_filePlayerPtr->StopPlayingFile() != 0) 662 { 663 _engineStatisticsPtr->SetLastError( 664 VE_CANNOT_STOP_PLAYOUT, kTraceError, 665 "StopPlayingFile() couldnot stop playing file"); 666 return -1; 667 } 668 669 _filePlayerPtr->RegisterModuleFileCallback(NULL); 670 FilePlayer::DestroyFilePlayer(_filePlayerPtr); 671 _filePlayerPtr = NULL; 672 _filePlaying = false; 673 674 return 0; 675 } 676 677 int TransmitMixer::IsPlayingFileAsMicrophone() const 678 { 679 WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, -1), 680 "TransmitMixer::IsPlayingFileAsMicrophone()"); 681 return _filePlaying; 682 } 683 684 int TransmitMixer::StartRecordingMicrophone(const char* fileName, 685 const CodecInst* codecInst) 686 { 687 WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, -1), 688 "TransmitMixer::StartRecordingMicrophone(fileName=%s)", 689 fileName); 690 691 CriticalSectionScoped cs(&_critSect); 692 693 if (_fileRecording) 694 { 695 WEBRTC_TRACE(kTraceWarning, kTraceVoice, VoEId(_instanceId, -1), 696 "StartRecordingMicrophone() is already recording"); 697 return 0; 698 } 699 700 FileFormats format; 701 const uint32_t notificationTime(0); // Not supported in VoE 702 CodecInst dummyCodec = { 100, "L16", 16000, 320, 1, 320000 }; 703 704 if (codecInst != NULL && 705 (codecInst->channels < 0 || codecInst->channels > 2)) 706 { 707 _engineStatisticsPtr->SetLastError( 708 VE_BAD_ARGUMENT, kTraceError, 709 "StartRecordingMicrophone() invalid compression"); 710 return (-1); 711 } 712 if (codecInst == NULL) 713 { 714 format = kFileFormatPcm16kHzFile; 715 codecInst = &dummyCodec; 716 } else if ((STR_CASE_CMP(codecInst->plname,"L16") == 0) || 717 (STR_CASE_CMP(codecInst->plname,"PCMU") == 0) || 718 (STR_CASE_CMP(codecInst->plname,"PCMA") == 0)) 719 { 720 format = kFileFormatWavFile; 721 } else 722 { 723 format = kFileFormatCompressedFile; 724 } 725 726 // Destroy the old instance 727 if (_fileRecorderPtr) 728 { 729 _fileRecorderPtr->RegisterModuleFileCallback(NULL); 730 FileRecorder::DestroyFileRecorder(_fileRecorderPtr); 731 _fileRecorderPtr = NULL; 732 } 733 734 _fileRecorderPtr = 735 FileRecorder::CreateFileRecorder(_fileRecorderId, 736 (const FileFormats) format); 737 if (_fileRecorderPtr == NULL) 738 { 739 _engineStatisticsPtr->SetLastError( 740 VE_INVALID_ARGUMENT, kTraceError, 741 "StartRecordingMicrophone() fileRecorder format isnot correct"); 742 return -1; 743 } 744 745 if (_fileRecorderPtr->StartRecordingAudioFile( 746 fileName, 747 (const CodecInst&) *codecInst, 748 notificationTime) != 0) 749 { 750 _engineStatisticsPtr->SetLastError( 751 VE_BAD_FILE, kTraceError, 752 "StartRecordingAudioFile() failed to start file recording"); 753 _fileRecorderPtr->StopRecording(); 754 FileRecorder::DestroyFileRecorder(_fileRecorderPtr); 755 _fileRecorderPtr = NULL; 756 return -1; 757 } 758 _fileRecorderPtr->RegisterModuleFileCallback(this); 759 _fileRecording = true; 760 761 return 0; 762 } 763 764 int TransmitMixer::StartRecordingMicrophone(OutStream* stream, 765 const CodecInst* codecInst) 766 { 767 WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, -1), 768 "TransmitMixer::StartRecordingMicrophone()"); 769 770 CriticalSectionScoped cs(&_critSect); 771 772 if (_fileRecording) 773 { 774 WEBRTC_TRACE(kTraceWarning, kTraceVoice, VoEId(_instanceId, -1), 775 "StartRecordingMicrophone() is already recording"); 776 return 0; 777 } 778 779 FileFormats format; 780 const uint32_t notificationTime(0); // Not supported in VoE 781 CodecInst dummyCodec = { 100, "L16", 16000, 320, 1, 320000 }; 782 783 if (codecInst != NULL && codecInst->channels != 1) 784 { 785 _engineStatisticsPtr->SetLastError( 786 VE_BAD_ARGUMENT, kTraceError, 787 "StartRecordingMicrophone() invalid compression"); 788 return (-1); 789 } 790 if (codecInst == NULL) 791 { 792 format = kFileFormatPcm16kHzFile; 793 codecInst = &dummyCodec; 794 } else if ((STR_CASE_CMP(codecInst->plname,"L16") == 0) || 795 (STR_CASE_CMP(codecInst->plname,"PCMU") == 0) || 796 (STR_CASE_CMP(codecInst->plname,"PCMA") == 0)) 797 { 798 format = kFileFormatWavFile; 799 } else 800 { 801 format = kFileFormatCompressedFile; 802 } 803 804 // Destroy the old instance 805 if (_fileRecorderPtr) 806 { 807 _fileRecorderPtr->RegisterModuleFileCallback(NULL); 808 FileRecorder::DestroyFileRecorder(_fileRecorderPtr); 809 _fileRecorderPtr = NULL; 810 } 811 812 _fileRecorderPtr = 813 FileRecorder::CreateFileRecorder(_fileRecorderId, 814 (const FileFormats) format); 815 if (_fileRecorderPtr == NULL) 816 { 817 _engineStatisticsPtr->SetLastError( 818 VE_INVALID_ARGUMENT, kTraceError, 819 "StartRecordingMicrophone() fileRecorder format isnot correct"); 820 return -1; 821 } 822 823 if (_fileRecorderPtr->StartRecordingAudioFile(*stream, 824 *codecInst, 825 notificationTime) != 0) 826 { 827 _engineStatisticsPtr->SetLastError(VE_BAD_FILE, kTraceError, 828 "StartRecordingAudioFile() failed to start file recording"); 829 _fileRecorderPtr->StopRecording(); 830 FileRecorder::DestroyFileRecorder(_fileRecorderPtr); 831 _fileRecorderPtr = NULL; 832 return -1; 833 } 834 835 _fileRecorderPtr->RegisterModuleFileCallback(this); 836 _fileRecording = true; 837 838 return 0; 839 } 840 841 842 int TransmitMixer::StopRecordingMicrophone() 843 { 844 WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, -1), 845 "TransmitMixer::StopRecordingMicrophone()"); 846 847 CriticalSectionScoped cs(&_critSect); 848 849 if (!_fileRecording) 850 { 851 WEBRTC_TRACE(kTraceWarning, kTraceVoice, VoEId(_instanceId, -1), 852 "StopRecordingMicrophone() isnot recording"); 853 return 0; 854 } 855 856 if (_fileRecorderPtr->StopRecording() != 0) 857 { 858 _engineStatisticsPtr->SetLastError( 859 VE_STOP_RECORDING_FAILED, kTraceError, 860 "StopRecording(), could not stop recording"); 861 return -1; 862 } 863 _fileRecorderPtr->RegisterModuleFileCallback(NULL); 864 FileRecorder::DestroyFileRecorder(_fileRecorderPtr); 865 _fileRecorderPtr = NULL; 866 _fileRecording = false; 867 868 return 0; 869 } 870 871 int TransmitMixer::StartRecordingCall(const char* fileName, 872 const CodecInst* codecInst) 873 { 874 WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, -1), 875 "TransmitMixer::StartRecordingCall(fileName=%s)", fileName); 876 877 if (_fileCallRecording) 878 { 879 WEBRTC_TRACE(kTraceWarning, kTraceVoice, VoEId(_instanceId, -1), 880 "StartRecordingCall() is already recording"); 881 return 0; 882 } 883 884 FileFormats format; 885 const uint32_t notificationTime(0); // Not supported in VoE 886 CodecInst dummyCodec = { 100, "L16", 16000, 320, 1, 320000 }; 887 888 if (codecInst != NULL && codecInst->channels != 1) 889 { 890 _engineStatisticsPtr->SetLastError( 891 VE_BAD_ARGUMENT, kTraceError, 892 "StartRecordingCall() invalid compression"); 893 return (-1); 894 } 895 if (codecInst == NULL) 896 { 897 format = kFileFormatPcm16kHzFile; 898 codecInst = &dummyCodec; 899 } else if ((STR_CASE_CMP(codecInst->plname,"L16") == 0) || 900 (STR_CASE_CMP(codecInst->plname,"PCMU") == 0) || 901 (STR_CASE_CMP(codecInst->plname,"PCMA") == 0)) 902 { 903 format = kFileFormatWavFile; 904 } else 905 { 906 format = kFileFormatCompressedFile; 907 } 908 909 CriticalSectionScoped cs(&_critSect); 910 911 // Destroy the old instance 912 if (_fileCallRecorderPtr) 913 { 914 _fileCallRecorderPtr->RegisterModuleFileCallback(NULL); 915 FileRecorder::DestroyFileRecorder(_fileCallRecorderPtr); 916 _fileCallRecorderPtr = NULL; 917 } 918 919 _fileCallRecorderPtr 920 = FileRecorder::CreateFileRecorder(_fileCallRecorderId, 921 (const FileFormats) format); 922 if (_fileCallRecorderPtr == NULL) 923 { 924 _engineStatisticsPtr->SetLastError( 925 VE_INVALID_ARGUMENT, kTraceError, 926 "StartRecordingCall() fileRecorder format isnot correct"); 927 return -1; 928 } 929 930 if (_fileCallRecorderPtr->StartRecordingAudioFile( 931 fileName, 932 (const CodecInst&) *codecInst, 933 notificationTime) != 0) 934 { 935 _engineStatisticsPtr->SetLastError( 936 VE_BAD_FILE, kTraceError, 937 "StartRecordingAudioFile() failed to start file recording"); 938 _fileCallRecorderPtr->StopRecording(); 939 FileRecorder::DestroyFileRecorder(_fileCallRecorderPtr); 940 _fileCallRecorderPtr = NULL; 941 return -1; 942 } 943 _fileCallRecorderPtr->RegisterModuleFileCallback(this); 944 _fileCallRecording = true; 945 946 return 0; 947 } 948 949 int TransmitMixer::StartRecordingCall(OutStream* stream, 950 const CodecInst* codecInst) 951 { 952 WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, -1), 953 "TransmitMixer::StartRecordingCall()"); 954 955 if (_fileCallRecording) 956 { 957 WEBRTC_TRACE(kTraceWarning, kTraceVoice, VoEId(_instanceId, -1), 958 "StartRecordingCall() is already recording"); 959 return 0; 960 } 961 962 FileFormats format; 963 const uint32_t notificationTime(0); // Not supported in VoE 964 CodecInst dummyCodec = { 100, "L16", 16000, 320, 1, 320000 }; 965 966 if (codecInst != NULL && codecInst->channels != 1) 967 { 968 _engineStatisticsPtr->SetLastError( 969 VE_BAD_ARGUMENT, kTraceError, 970 "StartRecordingCall() invalid compression"); 971 return (-1); 972 } 973 if (codecInst == NULL) 974 { 975 format = kFileFormatPcm16kHzFile; 976 codecInst = &dummyCodec; 977 } else if ((STR_CASE_CMP(codecInst->plname,"L16") == 0) || 978 (STR_CASE_CMP(codecInst->plname,"PCMU") == 0) || 979 (STR_CASE_CMP(codecInst->plname,"PCMA") == 0)) 980 { 981 format = kFileFormatWavFile; 982 } else 983 { 984 format = kFileFormatCompressedFile; 985 } 986 987 CriticalSectionScoped cs(&_critSect); 988 989 // Destroy the old instance 990 if (_fileCallRecorderPtr) 991 { 992 _fileCallRecorderPtr->RegisterModuleFileCallback(NULL); 993 FileRecorder::DestroyFileRecorder(_fileCallRecorderPtr); 994 _fileCallRecorderPtr = NULL; 995 } 996 997 _fileCallRecorderPtr = 998 FileRecorder::CreateFileRecorder(_fileCallRecorderId, 999 (const FileFormats) format); 1000 if (_fileCallRecorderPtr == NULL) 1001 { 1002 _engineStatisticsPtr->SetLastError( 1003 VE_INVALID_ARGUMENT, kTraceError, 1004 "StartRecordingCall() fileRecorder format isnot correct"); 1005 return -1; 1006 } 1007 1008 if (_fileCallRecorderPtr->StartRecordingAudioFile(*stream, 1009 *codecInst, 1010 notificationTime) != 0) 1011 { 1012 _engineStatisticsPtr->SetLastError(VE_BAD_FILE, kTraceError, 1013 "StartRecordingAudioFile() failed to start file recording"); 1014 _fileCallRecorderPtr->StopRecording(); 1015 FileRecorder::DestroyFileRecorder(_fileCallRecorderPtr); 1016 _fileCallRecorderPtr = NULL; 1017 return -1; 1018 } 1019 1020 _fileCallRecorderPtr->RegisterModuleFileCallback(this); 1021 _fileCallRecording = true; 1022 1023 return 0; 1024 } 1025 1026 int TransmitMixer::StopRecordingCall() 1027 { 1028 WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, -1), 1029 "TransmitMixer::StopRecordingCall()"); 1030 1031 if (!_fileCallRecording) 1032 { 1033 WEBRTC_TRACE(kTraceError, kTraceVoice, VoEId(_instanceId, -1), 1034 "StopRecordingCall() file isnot recording"); 1035 return -1; 1036 } 1037 1038 CriticalSectionScoped cs(&_critSect); 1039 1040 if (_fileCallRecorderPtr->StopRecording() != 0) 1041 { 1042 _engineStatisticsPtr->SetLastError( 1043 VE_STOP_RECORDING_FAILED, kTraceError, 1044 "StopRecording(), could not stop recording"); 1045 return -1; 1046 } 1047 1048 _fileCallRecorderPtr->RegisterModuleFileCallback(NULL); 1049 FileRecorder::DestroyFileRecorder(_fileCallRecorderPtr); 1050 _fileCallRecorderPtr = NULL; 1051 _fileCallRecording = false; 1052 1053 return 0; 1054 } 1055 1056 void 1057 TransmitMixer::SetMixWithMicStatus(bool mix) 1058 { 1059 _mixFileWithMicrophone = mix; 1060 } 1061 1062 int TransmitMixer::RegisterExternalMediaProcessing( 1063 VoEMediaProcess* object, 1064 ProcessingTypes type) { 1065 WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, -1), 1066 "TransmitMixer::RegisterExternalMediaProcessing()"); 1067 1068 CriticalSectionScoped cs(&_callbackCritSect); 1069 if (!object) { 1070 return -1; 1071 } 1072 1073 // Store the callback object according to the processing type. 1074 if (type == kRecordingAllChannelsMixed) { 1075 external_postproc_ptr_ = object; 1076 } else if (type == kRecordingPreprocessing) { 1077 external_preproc_ptr_ = object; 1078 } else { 1079 return -1; 1080 } 1081 return 0; 1082 } 1083 1084 int TransmitMixer::DeRegisterExternalMediaProcessing(ProcessingTypes type) { 1085 WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, -1), 1086 "TransmitMixer::DeRegisterExternalMediaProcessing()"); 1087 1088 CriticalSectionScoped cs(&_callbackCritSect); 1089 if (type == kRecordingAllChannelsMixed) { 1090 external_postproc_ptr_ = NULL; 1091 } else if (type == kRecordingPreprocessing) { 1092 external_preproc_ptr_ = NULL; 1093 } else { 1094 return -1; 1095 } 1096 return 0; 1097 } 1098 1099 int 1100 TransmitMixer::SetMute(bool enable) 1101 { 1102 WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, -1), 1103 "TransmitMixer::SetMute(enable=%d)", enable); 1104 _mute = enable; 1105 return 0; 1106 } 1107 1108 bool 1109 TransmitMixer::Mute() const 1110 { 1111 return _mute; 1112 } 1113 1114 int8_t TransmitMixer::AudioLevel() const 1115 { 1116 // Speech + file level [0,9] 1117 return _audioLevel.Level(); 1118 } 1119 1120 int16_t TransmitMixer::AudioLevelFullRange() const 1121 { 1122 // Speech + file level [0,32767] 1123 return _audioLevel.LevelFullRange(); 1124 } 1125 1126 bool TransmitMixer::IsRecordingCall() 1127 { 1128 return _fileCallRecording; 1129 } 1130 1131 bool TransmitMixer::IsRecordingMic() 1132 { 1133 CriticalSectionScoped cs(&_critSect); 1134 return _fileRecording; 1135 } 1136 1137 void TransmitMixer::GenerateAudioFrame(const int16_t* audio, 1138 int samples_per_channel, 1139 int num_channels, 1140 int sample_rate_hz) { 1141 int codec_rate; 1142 int num_codec_channels; 1143 GetSendCodecInfo(&codec_rate, &num_codec_channels); 1144 // TODO(ajm): This currently restricts the sample rate to 32 kHz. 1145 // See: https://code.google.com/p/webrtc/issues/detail?id=3146 1146 // When 48 kHz is supported natively by AudioProcessing, this will have 1147 // to be changed to handle 44.1 kHz. 1148 int max_sample_rate_hz = kAudioProcMaxNativeSampleRateHz; 1149 if (audioproc_->echo_control_mobile()->is_enabled()) { 1150 // AECM only supports 8 and 16 kHz. 1151 max_sample_rate_hz = 16000; 1152 } 1153 codec_rate = std::min(codec_rate, max_sample_rate_hz); 1154 stereo_codec_ = num_codec_channels == 2; 1155 1156 if (!mono_buffer_.get()) { 1157 // Temporary space for DownConvertToCodecFormat. 1158 mono_buffer_.reset(new int16_t[kMaxMonoDataSizeSamples]); 1159 } 1160 DownConvertToCodecFormat(audio, 1161 samples_per_channel, 1162 num_channels, 1163 sample_rate_hz, 1164 num_codec_channels, 1165 codec_rate, 1166 mono_buffer_.get(), 1167 &resampler_, 1168 &_audioFrame); 1169 } 1170 1171 int32_t TransmitMixer::RecordAudioToFile( 1172 uint32_t mixingFrequency) 1173 { 1174 CriticalSectionScoped cs(&_critSect); 1175 if (_fileRecorderPtr == NULL) 1176 { 1177 WEBRTC_TRACE(kTraceWarning, kTraceVoice, VoEId(_instanceId, -1), 1178 "TransmitMixer::RecordAudioToFile() filerecorder doesnot" 1179 "exist"); 1180 return -1; 1181 } 1182 1183 if (_fileRecorderPtr->RecordAudioToFile(_audioFrame) != 0) 1184 { 1185 WEBRTC_TRACE(kTraceWarning, kTraceVoice, VoEId(_instanceId, -1), 1186 "TransmitMixer::RecordAudioToFile() file recording" 1187 "failed"); 1188 return -1; 1189 } 1190 1191 return 0; 1192 } 1193 1194 int32_t TransmitMixer::MixOrReplaceAudioWithFile( 1195 int mixingFrequency) 1196 { 1197 scoped_ptr<int16_t[]> fileBuffer(new int16_t[640]); 1198 1199 int fileSamples(0); 1200 { 1201 CriticalSectionScoped cs(&_critSect); 1202 if (_filePlayerPtr == NULL) 1203 { 1204 WEBRTC_TRACE(kTraceWarning, kTraceVoice, 1205 VoEId(_instanceId, -1), 1206 "TransmitMixer::MixOrReplaceAudioWithFile()" 1207 "fileplayer doesnot exist"); 1208 return -1; 1209 } 1210 1211 if (_filePlayerPtr->Get10msAudioFromFile(fileBuffer.get(), 1212 fileSamples, 1213 mixingFrequency) == -1) 1214 { 1215 WEBRTC_TRACE(kTraceWarning, kTraceVoice, VoEId(_instanceId, -1), 1216 "TransmitMixer::MixOrReplaceAudioWithFile() file" 1217 " mixing failed"); 1218 return -1; 1219 } 1220 } 1221 1222 assert(_audioFrame.samples_per_channel_ == fileSamples); 1223 1224 if (_mixFileWithMicrophone) 1225 { 1226 // Currently file stream is always mono. 1227 // TODO(xians): Change the code when FilePlayer supports real stereo. 1228 MixWithSat(_audioFrame.data_, 1229 _audioFrame.num_channels_, 1230 fileBuffer.get(), 1231 1, 1232 fileSamples); 1233 } else 1234 { 1235 // Replace ACM audio with file. 1236 // Currently file stream is always mono. 1237 // TODO(xians): Change the code when FilePlayer supports real stereo. 1238 _audioFrame.UpdateFrame(-1, 1239 0xFFFFFFFF, 1240 fileBuffer.get(), 1241 fileSamples, 1242 mixingFrequency, 1243 AudioFrame::kNormalSpeech, 1244 AudioFrame::kVadUnknown, 1245 1); 1246 } 1247 return 0; 1248 } 1249 1250 void TransmitMixer::ProcessAudio(int delay_ms, int clock_drift, 1251 int current_mic_level, bool key_pressed) { 1252 if (audioproc_->set_stream_delay_ms(delay_ms) != 0) { 1253 // A redundant warning is reported in AudioDevice, which we've throttled 1254 // to avoid flooding the logs. Relegate this one to LS_VERBOSE to avoid 1255 // repeating the problem here. 1256 LOG_FERR1(LS_VERBOSE, set_stream_delay_ms, delay_ms); 1257 } 1258 1259 GainControl* agc = audioproc_->gain_control(); 1260 if (agc->set_stream_analog_level(current_mic_level) != 0) { 1261 LOG_FERR1(LS_ERROR, set_stream_analog_level, current_mic_level); 1262 assert(false); 1263 } 1264 1265 EchoCancellation* aec = audioproc_->echo_cancellation(); 1266 if (aec->is_drift_compensation_enabled()) { 1267 aec->set_stream_drift_samples(clock_drift); 1268 } 1269 1270 audioproc_->set_stream_key_pressed(key_pressed); 1271 1272 int err = audioproc_->ProcessStream(&_audioFrame); 1273 if (err != 0) { 1274 LOG(LS_ERROR) << "ProcessStream() error: " << err; 1275 assert(false); 1276 } 1277 1278 // Store new capture level. Only updated when analog AGC is enabled. 1279 _captureLevel = agc->stream_analog_level(); 1280 1281 CriticalSectionScoped cs(&_critSect); 1282 // Triggers a callback in OnPeriodicProcess(). 1283 _saturationWarning |= agc->stream_is_saturated(); 1284 } 1285 1286 #ifdef WEBRTC_VOICE_ENGINE_TYPING_DETECTION 1287 void TransmitMixer::TypingDetection(bool keyPressed) 1288 { 1289 // We let the VAD determine if we're using this feature or not. 1290 if (_audioFrame.vad_activity_ == AudioFrame::kVadUnknown) { 1291 return; 1292 } 1293 1294 bool vadActive = _audioFrame.vad_activity_ == AudioFrame::kVadActive; 1295 if (_typingDetection.Process(keyPressed, vadActive)) { 1296 _typingNoiseWarningPending = true; 1297 _typingNoiseDetected = true; 1298 } else { 1299 // If there is already a warning pending, do not change the state. 1300 // Otherwise set a warning pending if last callback was for noise detected. 1301 if (!_typingNoiseWarningPending && _typingNoiseDetected) { 1302 _typingNoiseWarningPending = true; 1303 _typingNoiseDetected = false; 1304 } 1305 } 1306 } 1307 #endif 1308 1309 int TransmitMixer::GetMixingFrequency() 1310 { 1311 assert(_audioFrame.sample_rate_hz_ != 0); 1312 return _audioFrame.sample_rate_hz_; 1313 } 1314 1315 #ifdef WEBRTC_VOICE_ENGINE_TYPING_DETECTION 1316 int TransmitMixer::TimeSinceLastTyping(int &seconds) 1317 { 1318 // We check in VoEAudioProcessingImpl that this is only called when 1319 // typing detection is active. 1320 seconds = _typingDetection.TimeSinceLastDetectionInSeconds(); 1321 return 0; 1322 } 1323 #endif 1324 1325 #ifdef WEBRTC_VOICE_ENGINE_TYPING_DETECTION 1326 int TransmitMixer::SetTypingDetectionParameters(int timeWindow, 1327 int costPerTyping, 1328 int reportingThreshold, 1329 int penaltyDecay, 1330 int typeEventDelay) 1331 { 1332 _typingDetection.SetParameters(timeWindow, 1333 costPerTyping, 1334 reportingThreshold, 1335 penaltyDecay, 1336 typeEventDelay, 1337 0); 1338 return 0; 1339 } 1340 #endif 1341 1342 void TransmitMixer::EnableStereoChannelSwapping(bool enable) { 1343 swap_stereo_channels_ = enable; 1344 } 1345 1346 bool TransmitMixer::IsStereoChannelSwappingEnabled() { 1347 return swap_stereo_channels_; 1348 } 1349 1350 } // namespace voe 1351 } // namespace webrtc 1352
