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 #ifndef WEBRTC_VOICE_ENGINE_CHANNEL_H_ 12 #define WEBRTC_VOICE_ENGINE_CHANNEL_H_ 13 14 #include "webrtc/common_audio/resampler/include/push_resampler.h" 15 #include "webrtc/common_types.h" 16 #include "webrtc/modules/audio_coding/main/interface/audio_coding_module.h" 17 #include "webrtc/modules/audio_conference_mixer/interface/audio_conference_mixer_defines.h" 18 #include "webrtc/modules/audio_processing/rms_level.h" 19 #include "webrtc/modules/bitrate_controller/include/bitrate_controller.h" 20 #include "webrtc/modules/rtp_rtcp/interface/rtp_header_parser.h" 21 #include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp.h" 22 #include "webrtc/modules/utility/interface/file_player.h" 23 #include "webrtc/modules/utility/interface/file_recorder.h" 24 #include "webrtc/system_wrappers/interface/scoped_ptr.h" 25 #include "webrtc/voice_engine/dtmf_inband.h" 26 #include "webrtc/voice_engine/dtmf_inband_queue.h" 27 #include "webrtc/voice_engine/include/voe_audio_processing.h" 28 #include "webrtc/voice_engine/include/voe_network.h" 29 #include "webrtc/voice_engine/level_indicator.h" 30 #include "webrtc/voice_engine/shared_data.h" 31 #include "webrtc/voice_engine/voice_engine_defines.h" 32 33 #ifdef WEBRTC_DTMF_DETECTION 34 // TelephoneEventDetectionMethods, TelephoneEventObserver 35 #include "webrtc/voice_engine/include/voe_dtmf.h" 36 #endif 37 38 namespace rtc { 39 40 class TimestampWrapAroundHandler; 41 } 42 43 namespace webrtc { 44 45 class AudioDeviceModule; 46 class Config; 47 class CriticalSectionWrapper; 48 class FileWrapper; 49 class ProcessThread; 50 class ReceiveStatistics; 51 class RemoteNtpTimeEstimator; 52 class RtpDump; 53 class RTPPayloadRegistry; 54 class RtpReceiver; 55 class RTPReceiverAudio; 56 class RtpRtcp; 57 class TelephoneEventHandler; 58 class ViENetwork; 59 class VoEMediaProcess; 60 class VoERTCPObserver; 61 class VoERTPObserver; 62 class VoiceEngineObserver; 63 64 struct CallStatistics; 65 struct ReportBlock; 66 struct SenderInfo; 67 68 namespace voe { 69 70 class Statistics; 71 class StatisticsProxy; 72 class TransmitMixer; 73 class OutputMixer; 74 75 // Helper class to simplify locking scheme for members that are accessed from 76 // multiple threads. 77 // Example: a member can be set on thread T1 and read by an internal audio 78 // thread T2. Accessing the member via this class ensures that we are 79 // safe and also avoid TSan v2 warnings. 80 class ChannelState { 81 public: 82 struct State { StateState83 State() : rx_apm_is_enabled(false), 84 input_external_media(false), 85 output_file_playing(false), 86 input_file_playing(false), 87 playing(false), 88 sending(false), 89 receiving(false) {} 90 91 bool rx_apm_is_enabled; 92 bool input_external_media; 93 bool output_file_playing; 94 bool input_file_playing; 95 bool playing; 96 bool sending; 97 bool receiving; 98 }; 99 ChannelState()100 ChannelState() : lock_(CriticalSectionWrapper::CreateCriticalSection()) { 101 } ~ChannelState()102 virtual ~ChannelState() {} 103 Reset()104 void Reset() { 105 CriticalSectionScoped lock(lock_.get()); 106 state_ = State(); 107 } 108 Get()109 State Get() const { 110 CriticalSectionScoped lock(lock_.get()); 111 return state_; 112 } 113 SetRxApmIsEnabled(bool enable)114 void SetRxApmIsEnabled(bool enable) { 115 CriticalSectionScoped lock(lock_.get()); 116 state_.rx_apm_is_enabled = enable; 117 } 118 SetInputExternalMedia(bool enable)119 void SetInputExternalMedia(bool enable) { 120 CriticalSectionScoped lock(lock_.get()); 121 state_.input_external_media = enable; 122 } 123 SetOutputFilePlaying(bool enable)124 void SetOutputFilePlaying(bool enable) { 125 CriticalSectionScoped lock(lock_.get()); 126 state_.output_file_playing = enable; 127 } 128 SetInputFilePlaying(bool enable)129 void SetInputFilePlaying(bool enable) { 130 CriticalSectionScoped lock(lock_.get()); 131 state_.input_file_playing = enable; 132 } 133 SetPlaying(bool enable)134 void SetPlaying(bool enable) { 135 CriticalSectionScoped lock(lock_.get()); 136 state_.playing = enable; 137 } 138 SetSending(bool enable)139 void SetSending(bool enable) { 140 CriticalSectionScoped lock(lock_.get()); 141 state_.sending = enable; 142 } 143 SetReceiving(bool enable)144 void SetReceiving(bool enable) { 145 CriticalSectionScoped lock(lock_.get()); 146 state_.receiving = enable; 147 } 148 149 private: 150 scoped_ptr<CriticalSectionWrapper> lock_; 151 State state_; 152 }; 153 154 class Channel: 155 public RtpData, 156 public RtpFeedback, 157 public RtcpFeedback, 158 public FileCallback, // receiving notification from file player & recorder 159 public Transport, 160 public RtpAudioFeedback, 161 public AudioPacketizationCallback, // receive encoded packets from the ACM 162 public ACMVADCallback, // receive voice activity from the ACM 163 public MixerParticipant // supplies output mixer with audio frames 164 { 165 public: 166 enum {KNumSocketThreads = 1}; 167 enum {KNumberOfSocketBuffers = 8}; 168 virtual ~Channel(); 169 static int32_t CreateChannel(Channel*& channel, 170 int32_t channelId, 171 uint32_t instanceId, 172 const Config& config); 173 Channel(int32_t channelId, uint32_t instanceId, const Config& config); 174 int32_t Init(); 175 int32_t SetEngineInformation( 176 Statistics& engineStatistics, 177 OutputMixer& outputMixer, 178 TransmitMixer& transmitMixer, 179 ProcessThread& moduleProcessThread, 180 AudioDeviceModule& audioDeviceModule, 181 VoiceEngineObserver* voiceEngineObserver, 182 CriticalSectionWrapper* callbackCritSect); 183 int32_t UpdateLocalTimeStamp(); 184 185 // API methods 186 187 // VoEBase 188 int32_t StartPlayout(); 189 int32_t StopPlayout(); 190 int32_t StartSend(); 191 int32_t StopSend(); 192 int32_t StartReceiving(); 193 int32_t StopReceiving(); 194 195 int32_t SetNetEQPlayoutMode(NetEqModes mode); 196 int32_t GetNetEQPlayoutMode(NetEqModes& mode); 197 int32_t RegisterVoiceEngineObserver(VoiceEngineObserver& observer); 198 int32_t DeRegisterVoiceEngineObserver(); 199 200 // VoECodec 201 int32_t GetSendCodec(CodecInst& codec); 202 int32_t GetRecCodec(CodecInst& codec); 203 int32_t SetSendCodec(const CodecInst& codec); 204 int32_t SetVADStatus(bool enableVAD, ACMVADMode mode, bool disableDTX); 205 int32_t GetVADStatus(bool& enabledVAD, ACMVADMode& mode, bool& disabledDTX); 206 int32_t SetRecPayloadType(const CodecInst& codec); 207 int32_t GetRecPayloadType(CodecInst& codec); 208 int32_t SetSendCNPayloadType(int type, PayloadFrequencies frequency); 209 210 // VoE dual-streaming. 211 int SetSecondarySendCodec(const CodecInst& codec, int red_payload_type); 212 void RemoveSecondarySendCodec(); 213 int GetSecondarySendCodec(CodecInst* codec); 214 215 // VoENetwork 216 int32_t RegisterExternalTransport(Transport& transport); 217 int32_t DeRegisterExternalTransport(); 218 int32_t ReceivedRTPPacket(const int8_t* data, int32_t length, 219 const PacketTime& packet_time); 220 int32_t ReceivedRTCPPacket(const int8_t* data, int32_t length); 221 222 // VoEFile 223 int StartPlayingFileLocally(const char* fileName, bool loop, 224 FileFormats format, 225 int startPosition, 226 float volumeScaling, 227 int stopPosition, 228 const CodecInst* codecInst); 229 int StartPlayingFileLocally(InStream* stream, FileFormats format, 230 int startPosition, 231 float volumeScaling, 232 int stopPosition, 233 const CodecInst* codecInst); 234 int StopPlayingFileLocally(); 235 int IsPlayingFileLocally() const; 236 int RegisterFilePlayingToMixer(); 237 int StartPlayingFileAsMicrophone(const char* fileName, bool loop, 238 FileFormats format, 239 int startPosition, 240 float volumeScaling, 241 int stopPosition, 242 const CodecInst* codecInst); 243 int StartPlayingFileAsMicrophone(InStream* stream, 244 FileFormats format, 245 int startPosition, 246 float volumeScaling, 247 int stopPosition, 248 const CodecInst* codecInst); 249 int StopPlayingFileAsMicrophone(); 250 int IsPlayingFileAsMicrophone() const; 251 int StartRecordingPlayout(const char* fileName, const CodecInst* codecInst); 252 int StartRecordingPlayout(OutStream* stream, const CodecInst* codecInst); 253 int StopRecordingPlayout(); 254 255 void SetMixWithMicStatus(bool mix); 256 257 // VoEExternalMediaProcessing 258 int RegisterExternalMediaProcessing(ProcessingTypes type, 259 VoEMediaProcess& processObject); 260 int DeRegisterExternalMediaProcessing(ProcessingTypes type); 261 int SetExternalMixing(bool enabled); 262 263 // VoEVolumeControl 264 int GetSpeechOutputLevel(uint32_t& level) const; 265 int GetSpeechOutputLevelFullRange(uint32_t& level) const; 266 int SetMute(bool enable); 267 bool Mute() const; 268 int SetOutputVolumePan(float left, float right); 269 int GetOutputVolumePan(float& left, float& right) const; 270 int SetChannelOutputVolumeScaling(float scaling); 271 int GetChannelOutputVolumeScaling(float& scaling) const; 272 273 // VoENetEqStats 274 int GetNetworkStatistics(NetworkStatistics& stats); 275 void GetDecodingCallStatistics(AudioDecodingCallStats* stats) const; 276 277 // VoEVideoSync 278 bool GetDelayEstimate(int* jitter_buffer_delay_ms, 279 int* playout_buffer_delay_ms) const; least_required_delay_ms()280 int least_required_delay_ms() const { return least_required_delay_ms_; } 281 int SetInitialPlayoutDelay(int delay_ms); 282 int SetMinimumPlayoutDelay(int delayMs); 283 int GetPlayoutTimestamp(unsigned int& timestamp); 284 void UpdatePlayoutTimestamp(bool rtcp); 285 int SetInitTimestamp(unsigned int timestamp); 286 int SetInitSequenceNumber(short sequenceNumber); 287 288 // VoEVideoSyncExtended 289 int GetRtpRtcp(RtpRtcp** rtpRtcpModule, RtpReceiver** rtp_receiver) const; 290 291 // VoEDtmf 292 int SendTelephoneEventOutband(unsigned char eventCode, int lengthMs, 293 int attenuationDb, bool playDtmfEvent); 294 int SendTelephoneEventInband(unsigned char eventCode, int lengthMs, 295 int attenuationDb, bool playDtmfEvent); 296 int SetDtmfPlayoutStatus(bool enable); 297 bool DtmfPlayoutStatus() const; 298 int SetSendTelephoneEventPayloadType(unsigned char type); 299 int GetSendTelephoneEventPayloadType(unsigned char& type); 300 301 // VoEAudioProcessingImpl 302 int UpdateRxVadDetection(AudioFrame& audioFrame); 303 int RegisterRxVadObserver(VoERxVadCallback &observer); 304 int DeRegisterRxVadObserver(); 305 int VoiceActivityIndicator(int &activity); 306 #ifdef WEBRTC_VOICE_ENGINE_AGC 307 int SetRxAgcStatus(bool enable, AgcModes mode); 308 int GetRxAgcStatus(bool& enabled, AgcModes& mode); 309 int SetRxAgcConfig(AgcConfig config); 310 int GetRxAgcConfig(AgcConfig& config); 311 #endif 312 #ifdef WEBRTC_VOICE_ENGINE_NR 313 int SetRxNsStatus(bool enable, NsModes mode); 314 int GetRxNsStatus(bool& enabled, NsModes& mode); 315 #endif 316 317 // VoERTP_RTCP 318 int RegisterRTCPObserver(VoERTCPObserver& observer); 319 int DeRegisterRTCPObserver(); 320 int SetLocalSSRC(unsigned int ssrc); 321 int GetLocalSSRC(unsigned int& ssrc); 322 int GetRemoteSSRC(unsigned int& ssrc); 323 int SetSendAudioLevelIndicationStatus(bool enable, unsigned char id); 324 int SetReceiveAudioLevelIndicationStatus(bool enable, unsigned char id); 325 int SetSendAbsoluteSenderTimeStatus(bool enable, unsigned char id); 326 int SetReceiveAbsoluteSenderTimeStatus(bool enable, unsigned char id); 327 int SetRTCPStatus(bool enable); 328 int GetRTCPStatus(bool& enabled); 329 int SetRTCP_CNAME(const char cName[256]); 330 int GetRTCP_CNAME(char cName[256]); 331 int GetRemoteRTCP_CNAME(char cName[256]); 332 int GetRemoteRTCPData(unsigned int& NTPHigh, unsigned int& NTPLow, 333 unsigned int& timestamp, 334 unsigned int& playoutTimestamp, unsigned int* jitter, 335 unsigned short* fractionLost); 336 int SendApplicationDefinedRTCPPacket(unsigned char subType, 337 unsigned int name, const char* data, 338 unsigned short dataLengthInBytes); 339 int GetRTPStatistics(unsigned int& averageJitterMs, 340 unsigned int& maxJitterMs, 341 unsigned int& discardedPackets); 342 int GetRemoteRTCPReportBlocks(std::vector<ReportBlock>* report_blocks); 343 int GetRTPStatistics(CallStatistics& stats); 344 int SetREDStatus(bool enable, int redPayloadtype); 345 int GetREDStatus(bool& enabled, int& redPayloadtype); 346 int SetCodecFECStatus(bool enable); 347 bool GetCodecFECStatus(); 348 void SetNACKStatus(bool enable, int maxNumberOfPackets); 349 int StartRTPDump(const char fileNameUTF8[1024], RTPDirections direction); 350 int StopRTPDump(RTPDirections direction); 351 bool RTPDumpIsActive(RTPDirections direction); 352 // Takes ownership of the ViENetwork. 353 void SetVideoEngineBWETarget(ViENetwork* vie_network, int video_channel); 354 355 // From AudioPacketizationCallback in the ACM 356 int32_t SendData(FrameType frameType, 357 uint8_t payloadType, 358 uint32_t timeStamp, 359 const uint8_t* payloadData, 360 uint16_t payloadSize, 361 const RTPFragmentationHeader* fragmentation); 362 // From ACMVADCallback in the ACM 363 int32_t InFrameType(int16_t frameType); 364 365 int32_t OnRxVadDetected(int vadDecision); 366 367 // From RtpData in the RTP/RTCP module 368 int32_t OnReceivedPayloadData(const uint8_t* payloadData, 369 uint16_t payloadSize, 370 const WebRtcRTPHeader* rtpHeader); 371 372 bool OnRecoveredPacket(const uint8_t* packet, int packet_length); 373 374 // From RtpFeedback in the RTP/RTCP module 375 int32_t OnInitializeDecoder( 376 int32_t id, 377 int8_t payloadType, 378 const char payloadName[RTP_PAYLOAD_NAME_SIZE], 379 int frequency, 380 uint8_t channels, 381 uint32_t rate); 382 383 void OnPacketTimeout(int32_t id); 384 385 void OnReceivedPacket(int32_t id, RtpRtcpPacketType packetType); 386 387 void OnPeriodicDeadOrAlive(int32_t id, 388 RTPAliveType alive); 389 390 void OnIncomingSSRCChanged(int32_t id, 391 uint32_t ssrc); 392 393 void OnIncomingCSRCChanged(int32_t id, 394 uint32_t CSRC, bool added); 395 396 void ResetStatistics(uint32_t ssrc); 397 398 // From RtcpFeedback in the RTP/RTCP module 399 void OnApplicationDataReceived(int32_t id, 400 uint8_t subType, 401 uint32_t name, 402 uint16_t length, 403 const uint8_t* data); 404 405 // From RtpAudioFeedback in the RTP/RTCP module 406 void OnReceivedTelephoneEvent(int32_t id, 407 uint8_t event, 408 bool endOfEvent); 409 410 void OnPlayTelephoneEvent(int32_t id, 411 uint8_t event, 412 uint16_t lengthMs, 413 uint8_t volume); 414 415 // From Transport (called by the RTP/RTCP module) 416 int SendPacket(int /*channel*/, const void *data, int len); 417 int SendRTCPPacket(int /*channel*/, const void *data, int len); 418 419 // From MixerParticipant 420 int32_t GetAudioFrame(int32_t id, AudioFrame& audioFrame); 421 int32_t NeededFrequency(int32_t id); 422 423 // From MonitorObserver 424 void OnPeriodicProcess(); 425 426 // From FileCallback 427 void PlayNotification(int32_t id, 428 uint32_t durationMs); 429 void RecordNotification(int32_t id, 430 uint32_t durationMs); 431 void PlayFileEnded(int32_t id); 432 void RecordFileEnded(int32_t id); 433 InstanceId()434 uint32_t InstanceId() const 435 { 436 return _instanceId; 437 } ChannelId()438 int32_t ChannelId() const 439 { 440 return _channelId; 441 } Playing()442 bool Playing() const 443 { 444 return channel_state_.Get().playing; 445 } Sending()446 bool Sending() const 447 { 448 return channel_state_.Get().sending; 449 } Receiving()450 bool Receiving() const 451 { 452 return channel_state_.Get().receiving; 453 } ExternalTransport()454 bool ExternalTransport() const 455 { 456 CriticalSectionScoped cs(&_callbackCritSect); 457 return _externalTransport; 458 } ExternalMixing()459 bool ExternalMixing() const 460 { 461 return _externalMixing; 462 } RtpRtcpModulePtr()463 RtpRtcp* RtpRtcpModulePtr() const 464 { 465 return _rtpRtcpModule.get(); 466 } OutputEnergyLevel()467 int8_t OutputEnergyLevel() const 468 { 469 return _outputAudioLevel.Level(); 470 } 471 uint32_t Demultiplex(const AudioFrame& audioFrame); 472 // Demultiplex the data to the channel's |_audioFrame|. The difference 473 // between this method and the overloaded method above is that |audio_data| 474 // does not go through transmit_mixer and APM. 475 void Demultiplex(const int16_t* audio_data, 476 int sample_rate, 477 int number_of_frames, 478 int number_of_channels); 479 uint32_t PrepareEncodeAndSend(int mixingFrequency); 480 uint32_t EncodeAndSend(); 481 482 // From BitrateObserver (called by the RTP/RTCP module). 483 void OnNetworkChanged(const uint32_t bitrate_bps, 484 const uint8_t fraction_lost, // 0 - 255. 485 const uint32_t rtt); 486 487 private: 488 bool ReceivePacket(const uint8_t* packet, int packet_length, 489 const RTPHeader& header, bool in_order); 490 bool HandleEncapsulation(const uint8_t* packet, 491 int packet_length, 492 const RTPHeader& header); 493 bool IsPacketInOrder(const RTPHeader& header) const; 494 bool IsPacketRetransmitted(const RTPHeader& header, bool in_order) const; 495 int ResendPackets(const uint16_t* sequence_numbers, int length); 496 int InsertInbandDtmfTone(); 497 int32_t MixOrReplaceAudioWithFile(int mixingFrequency); 498 int32_t MixAudioWithFile(AudioFrame& audioFrame, int mixingFrequency); 499 int32_t SendPacketRaw(const void *data, int len, bool RTCP); 500 void UpdatePacketDelay(uint32_t timestamp, 501 uint16_t sequenceNumber); 502 void RegisterReceiveCodecsToRTPModule(); 503 504 int SetRedPayloadType(int red_payload_type); 505 int SetSendRtpHeaderExtension(bool enable, RTPExtensionType type, 506 unsigned char id); 507 508 int32_t GetPlayoutFrequency(); 509 510 CriticalSectionWrapper& _fileCritSect; 511 CriticalSectionWrapper& _callbackCritSect; 512 CriticalSectionWrapper& volume_settings_critsect_; 513 uint32_t _instanceId; 514 int32_t _channelId; 515 516 ChannelState channel_state_; 517 518 scoped_ptr<RtpHeaderParser> rtp_header_parser_; 519 scoped_ptr<RTPPayloadRegistry> rtp_payload_registry_; 520 scoped_ptr<ReceiveStatistics> rtp_receive_statistics_; 521 scoped_ptr<StatisticsProxy> statistics_proxy_; 522 scoped_ptr<RtpReceiver> rtp_receiver_; 523 TelephoneEventHandler* telephone_event_handler_; 524 scoped_ptr<RtpRtcp> _rtpRtcpModule; 525 scoped_ptr<AudioCodingModule> audio_coding_; 526 RtpDump& _rtpDumpIn; 527 RtpDump& _rtpDumpOut; 528 AudioLevel _outputAudioLevel; 529 bool _externalTransport; 530 AudioFrame _audioFrame; 531 scoped_ptr<int16_t[]> mono_recording_audio_; 532 // Downsamples to the codec rate if necessary. 533 PushResampler<int16_t> input_resampler_; 534 uint8_t _audioLevel_dBov; 535 FilePlayer* _inputFilePlayerPtr; 536 FilePlayer* _outputFilePlayerPtr; 537 FileRecorder* _outputFileRecorderPtr; 538 int _inputFilePlayerId; 539 int _outputFilePlayerId; 540 int _outputFileRecorderId; 541 bool _outputFileRecording; 542 DtmfInbandQueue _inbandDtmfQueue; 543 DtmfInband _inbandDtmfGenerator; 544 bool _outputExternalMedia; 545 VoEMediaProcess* _inputExternalMediaCallbackPtr; 546 VoEMediaProcess* _outputExternalMediaCallbackPtr; 547 uint32_t _timeStamp; 548 uint8_t _sendTelephoneEventPayloadType; 549 550 scoped_ptr<RemoteNtpTimeEstimator> ntp_estimator_; 551 552 // Timestamp of the audio pulled from NetEq. 553 uint32_t jitter_buffer_playout_timestamp_; 554 uint32_t playout_timestamp_rtp_; 555 uint32_t playout_timestamp_rtcp_; 556 uint32_t playout_delay_ms_; 557 uint32_t _numberOfDiscardedPackets; 558 uint16_t send_sequence_number_; 559 uint8_t restored_packet_[kVoiceEngineMaxIpPacketSizeBytes]; 560 561 scoped_ptr<CriticalSectionWrapper> ts_stats_lock_; 562 563 scoped_ptr<rtc::TimestampWrapAroundHandler> rtp_ts_wraparound_handler_; 564 // The rtp timestamp of the first played out audio frame. 565 int64_t capture_start_rtp_time_stamp_; 566 // The capture ntp time (in local timebase) of the first played out audio 567 // frame. 568 int64_t capture_start_ntp_time_ms_; 569 570 // uses 571 Statistics* _engineStatisticsPtr; 572 OutputMixer* _outputMixerPtr; 573 TransmitMixer* _transmitMixerPtr; 574 ProcessThread* _moduleProcessThreadPtr; 575 AudioDeviceModule* _audioDeviceModulePtr; 576 VoiceEngineObserver* _voiceEngineObserverPtr; // owned by base 577 CriticalSectionWrapper* _callbackCritSectPtr; // owned by base 578 Transport* _transportPtr; // WebRtc socket or external transport 579 RMSLevel rms_level_; 580 scoped_ptr<AudioProcessing> rx_audioproc_; // far end AudioProcessing 581 VoERxVadCallback* _rxVadObserverPtr; 582 int32_t _oldVadDecision; 583 int32_t _sendFrameType; // Send data is voice, 1-voice, 0-otherwise 584 VoERTCPObserver* _rtcpObserverPtr; 585 // VoEBase 586 bool _externalPlayout; 587 bool _externalMixing; 588 bool _mixFileWithMicrophone; 589 bool _rtcpObserver; 590 // VoEVolumeControl 591 bool _mute; 592 float _panLeft; 593 float _panRight; 594 float _outputGain; 595 // VoEDtmf 596 bool _playOutbandDtmfEvent; 597 bool _playInbandDtmfEvent; 598 // VoeRTP_RTCP 599 uint32_t _lastLocalTimeStamp; 600 int8_t _lastPayloadType; 601 bool _includeAudioLevelIndication; 602 // VoENetwork 603 bool _rtpPacketTimedOut; 604 bool _rtpPacketTimeOutIsEnabled; 605 uint32_t _rtpTimeOutSeconds; 606 bool _connectionObserver; 607 VoEConnectionObserver* _connectionObserverPtr; 608 AudioFrame::SpeechType _outputSpeechType; 609 ViENetwork* vie_network_; 610 int video_channel_; 611 // VoEVideoSync 612 uint32_t _average_jitter_buffer_delay_us; 613 int least_required_delay_ms_; 614 uint32_t _previousTimestamp; 615 uint16_t _recPacketDelayMs; 616 // VoEAudioProcessing 617 bool _RxVadDetection; 618 bool _rxAgcIsEnabled; 619 bool _rxNsIsEnabled; 620 bool restored_packet_in_use_; 621 // RtcpBandwidthObserver 622 scoped_ptr<BitrateController> bitrate_controller_; 623 scoped_ptr<RtcpBandwidthObserver> rtcp_bandwidth_observer_; 624 scoped_ptr<BitrateObserver> send_bitrate_observer_; 625 }; 626 627 } // namespace voe 628 } // namespace webrtc 629 630 #endif // WEBRTC_VOICE_ENGINE_CHANNEL_H_ 631