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/remote_ntp_time_estimator.h" 21 #include "webrtc/modules/rtp_rtcp/interface/rtp_header_parser.h" 22 #include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp.h" 23 #include "webrtc/modules/utility/interface/file_player.h" 24 #include "webrtc/modules/utility/interface/file_recorder.h" 25 #include "webrtc/system_wrappers/interface/scoped_ptr.h" 26 #include "webrtc/voice_engine/dtmf_inband.h" 27 #include "webrtc/voice_engine/dtmf_inband_queue.h" 28 #include "webrtc/voice_engine/include/voe_audio_processing.h" 29 #include "webrtc/voice_engine/include/voe_network.h" 30 #include "webrtc/voice_engine/level_indicator.h" 31 #include "webrtc/voice_engine/network_predictor.h" 32 #include "webrtc/voice_engine/shared_data.h" 33 #include "webrtc/voice_engine/voice_engine_defines.h" 34 35 #ifdef WEBRTC_DTMF_DETECTION 36 // TelephoneEventDetectionMethods, TelephoneEventObserver 37 #include "webrtc/voice_engine/include/voe_dtmf.h" 38 #endif 39 40 namespace rtc { 41 42 class TimestampWrapAroundHandler; 43 } 44 45 namespace webrtc { 46 47 class AudioDeviceModule; 48 class Config; 49 class CriticalSectionWrapper; 50 class FileWrapper; 51 class ProcessThread; 52 class ReceiveStatistics; 53 class RemoteNtpTimeEstimator; 54 class RtpDump; 55 class RTPPayloadRegistry; 56 class RtpReceiver; 57 class RTPReceiverAudio; 58 class RtpRtcp; 59 class TelephoneEventHandler; 60 class ViENetwork; 61 class VoEMediaProcess; 62 class VoERTCPObserver; 63 class VoERTPObserver; 64 class VoiceEngineObserver; 65 66 struct CallStatistics; 67 struct ReportBlock; 68 struct SenderInfo; 69 70 namespace voe { 71 72 class Statistics; 73 class StatisticsProxy; 74 class TransmitMixer; 75 class OutputMixer; 76 77 // Helper class to simplify locking scheme for members that are accessed from 78 // multiple threads. 79 // Example: a member can be set on thread T1 and read by an internal audio 80 // thread T2. Accessing the member via this class ensures that we are 81 // safe and also avoid TSan v2 warnings. 82 class ChannelState { 83 public: 84 struct State { 85 State() : rx_apm_is_enabled(false), 86 input_external_media(false), 87 output_file_playing(false), 88 input_file_playing(false), 89 playing(false), 90 sending(false), 91 receiving(false) {} 92 93 bool rx_apm_is_enabled; 94 bool input_external_media; 95 bool output_file_playing; 96 bool input_file_playing; 97 bool playing; 98 bool sending; 99 bool receiving; 100 }; 101 102 ChannelState() : lock_(CriticalSectionWrapper::CreateCriticalSection()) { 103 } 104 virtual ~ChannelState() {} 105 106 void Reset() { 107 CriticalSectionScoped lock(lock_.get()); 108 state_ = State(); 109 } 110 111 State Get() const { 112 CriticalSectionScoped lock(lock_.get()); 113 return state_; 114 } 115 116 void SetRxApmIsEnabled(bool enable) { 117 CriticalSectionScoped lock(lock_.get()); 118 state_.rx_apm_is_enabled = enable; 119 } 120 121 void SetInputExternalMedia(bool enable) { 122 CriticalSectionScoped lock(lock_.get()); 123 state_.input_external_media = enable; 124 } 125 126 void SetOutputFilePlaying(bool enable) { 127 CriticalSectionScoped lock(lock_.get()); 128 state_.output_file_playing = enable; 129 } 130 131 void SetInputFilePlaying(bool enable) { 132 CriticalSectionScoped lock(lock_.get()); 133 state_.input_file_playing = enable; 134 } 135 136 void SetPlaying(bool enable) { 137 CriticalSectionScoped lock(lock_.get()); 138 state_.playing = enable; 139 } 140 141 void SetSending(bool enable) { 142 CriticalSectionScoped lock(lock_.get()); 143 state_.sending = enable; 144 } 145 146 void SetReceiving(bool enable) { 147 CriticalSectionScoped lock(lock_.get()); 148 state_.receiving = enable; 149 } 150 151 private: 152 scoped_ptr<CriticalSectionWrapper> lock_; 153 State state_; 154 }; 155 156 class Channel: 157 public RtpData, 158 public RtpFeedback, 159 public RtcpFeedback, 160 public FileCallback, // receiving notification from file player & recorder 161 public Transport, 162 public RtpAudioFeedback, 163 public AudioPacketizationCallback, // receive encoded packets from the ACM 164 public ACMVADCallback, // receive voice activity from the ACM 165 public MixerParticipant // supplies output mixer with audio frames 166 { 167 public: 168 enum {KNumSocketThreads = 1}; 169 enum {KNumberOfSocketBuffers = 8}; 170 virtual ~Channel(); 171 static int32_t CreateChannel(Channel*& channel, 172 int32_t channelId, 173 uint32_t instanceId, 174 const Config& config); 175 Channel(int32_t channelId, uint32_t instanceId, const Config& config); 176 int32_t Init(); 177 int32_t SetEngineInformation( 178 Statistics& engineStatistics, 179 OutputMixer& outputMixer, 180 TransmitMixer& transmitMixer, 181 ProcessThread& moduleProcessThread, 182 AudioDeviceModule& audioDeviceModule, 183 VoiceEngineObserver* voiceEngineObserver, 184 CriticalSectionWrapper* callbackCritSect); 185 int32_t UpdateLocalTimeStamp(); 186 187 // API methods 188 189 // VoEBase 190 int32_t StartPlayout(); 191 int32_t StopPlayout(); 192 int32_t StartSend(); 193 int32_t StopSend(); 194 int32_t StartReceiving(); 195 int32_t StopReceiving(); 196 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 int SetOpusMaxPlaybackRate(int frequency_hz); 210 211 // VoE dual-streaming. 212 int SetSecondarySendCodec(const CodecInst& codec, int red_payload_type); 213 void RemoveSecondarySendCodec(); 214 int GetSecondarySendCodec(CodecInst* codec); 215 216 // VoENetwork 217 int32_t RegisterExternalTransport(Transport& transport); 218 int32_t DeRegisterExternalTransport(); 219 int32_t ReceivedRTPPacket(const int8_t* data, int32_t length, 220 const PacketTime& packet_time); 221 int32_t ReceivedRTCPPacket(const int8_t* data, int32_t length); 222 223 // VoEFile 224 int StartPlayingFileLocally(const char* fileName, bool loop, 225 FileFormats format, 226 int startPosition, 227 float volumeScaling, 228 int stopPosition, 229 const CodecInst* codecInst); 230 int StartPlayingFileLocally(InStream* stream, FileFormats format, 231 int startPosition, 232 float volumeScaling, 233 int stopPosition, 234 const CodecInst* codecInst); 235 int StopPlayingFileLocally(); 236 int IsPlayingFileLocally() const; 237 int RegisterFilePlayingToMixer(); 238 int StartPlayingFileAsMicrophone(const char* fileName, bool loop, 239 FileFormats format, 240 int startPosition, 241 float volumeScaling, 242 int stopPosition, 243 const CodecInst* codecInst); 244 int StartPlayingFileAsMicrophone(InStream* stream, 245 FileFormats format, 246 int startPosition, 247 float volumeScaling, 248 int stopPosition, 249 const CodecInst* codecInst); 250 int StopPlayingFileAsMicrophone(); 251 int IsPlayingFileAsMicrophone() const; 252 int StartRecordingPlayout(const char* fileName, const CodecInst* codecInst); 253 int StartRecordingPlayout(OutStream* stream, const CodecInst* codecInst); 254 int StopRecordingPlayout(); 255 256 void SetMixWithMicStatus(bool mix); 257 258 // VoEExternalMediaProcessing 259 int RegisterExternalMediaProcessing(ProcessingTypes type, 260 VoEMediaProcess& processObject); 261 int DeRegisterExternalMediaProcessing(ProcessingTypes type); 262 int SetExternalMixing(bool enabled); 263 264 // VoEVolumeControl 265 int GetSpeechOutputLevel(uint32_t& level) const; 266 int GetSpeechOutputLevelFullRange(uint32_t& level) const; 267 int SetMute(bool enable); 268 bool Mute() const; 269 int SetOutputVolumePan(float left, float right); 270 int GetOutputVolumePan(float& left, float& right) const; 271 int SetChannelOutputVolumeScaling(float scaling); 272 int GetChannelOutputVolumeScaling(float& scaling) const; 273 274 // VoENetEqStats 275 int GetNetworkStatistics(NetworkStatistics& stats); 276 void GetDecodingCallStatistics(AudioDecodingCallStats* stats) const; 277 278 // VoEVideoSync 279 bool GetDelayEstimate(int* jitter_buffer_delay_ms, 280 int* playout_buffer_delay_ms) const; 281 int least_required_delay_ms() const { return least_required_delay_ms_; } 282 int SetInitialPlayoutDelay(int delay_ms); 283 int SetMinimumPlayoutDelay(int delayMs); 284 int GetPlayoutTimestamp(unsigned int& timestamp); 285 void UpdatePlayoutTimestamp(bool rtcp); 286 int SetInitTimestamp(unsigned int timestamp); 287 int SetInitSequenceNumber(short sequenceNumber); 288 289 // VoEVideoSyncExtended 290 int GetRtpRtcp(RtpRtcp** rtpRtcpModule, RtpReceiver** rtp_receiver) const; 291 292 // VoEDtmf 293 int SendTelephoneEventOutband(unsigned char eventCode, int lengthMs, 294 int attenuationDb, bool playDtmfEvent); 295 int SendTelephoneEventInband(unsigned char eventCode, int lengthMs, 296 int attenuationDb, bool playDtmfEvent); 297 int SetDtmfPlayoutStatus(bool enable); 298 bool DtmfPlayoutStatus() const; 299 int SetSendTelephoneEventPayloadType(unsigned char type); 300 int GetSendTelephoneEventPayloadType(unsigned char& type); 301 302 // VoEAudioProcessingImpl 303 int UpdateRxVadDetection(AudioFrame& audioFrame); 304 int RegisterRxVadObserver(VoERxVadCallback &observer); 305 int DeRegisterRxVadObserver(); 306 int VoiceActivityIndicator(int &activity); 307 #ifdef WEBRTC_VOICE_ENGINE_AGC 308 int SetRxAgcStatus(bool enable, AgcModes mode); 309 int GetRxAgcStatus(bool& enabled, AgcModes& mode); 310 int SetRxAgcConfig(AgcConfig config); 311 int GetRxAgcConfig(AgcConfig& config); 312 #endif 313 #ifdef WEBRTC_VOICE_ENGINE_NR 314 int SetRxNsStatus(bool enable, NsModes mode); 315 int GetRxNsStatus(bool& enabled, NsModes& mode); 316 #endif 317 318 // VoERTP_RTCP 319 int RegisterRTCPObserver(VoERTCPObserver& observer); 320 int DeRegisterRTCPObserver(); 321 int SetLocalSSRC(unsigned int ssrc); 322 int GetLocalSSRC(unsigned int& ssrc); 323 int GetRemoteSSRC(unsigned int& ssrc); 324 int SetSendAudioLevelIndicationStatus(bool enable, unsigned char id); 325 int SetReceiveAudioLevelIndicationStatus(bool enable, unsigned char id); 326 int SetSendAbsoluteSenderTimeStatus(bool enable, unsigned char id); 327 int SetReceiveAbsoluteSenderTimeStatus(bool enable, unsigned char id); 328 int SetRTCPStatus(bool enable); 329 int GetRTCPStatus(bool& enabled); 330 int SetRTCP_CNAME(const 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 434 uint32_t InstanceId() const 435 { 436 return _instanceId; 437 } 438 int32_t ChannelId() const 439 { 440 return _channelId; 441 } 442 bool Playing() const 443 { 444 return channel_state_.Get().playing; 445 } 446 bool Sending() const 447 { 448 return channel_state_.Get().sending; 449 } 450 bool Receiving() const 451 { 452 return channel_state_.Get().receiving; 453 } 454 bool ExternalTransport() const 455 { 456 CriticalSectionScoped cs(&_callbackCritSect); 457 return _externalTransport; 458 } 459 bool ExternalMixing() const 460 { 461 return _externalMixing; 462 } 463 RtpRtcp* RtpRtcpModulePtr() const 464 { 465 return _rtpRtcpModule.get(); 466 } 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 int GetRTT() const; 510 511 CriticalSectionWrapper& _fileCritSect; 512 CriticalSectionWrapper& _callbackCritSect; 513 CriticalSectionWrapper& volume_settings_critsect_; 514 uint32_t _instanceId; 515 int32_t _channelId; 516 517 ChannelState channel_state_; 518 519 scoped_ptr<RtpHeaderParser> rtp_header_parser_; 520 scoped_ptr<RTPPayloadRegistry> rtp_payload_registry_; 521 scoped_ptr<ReceiveStatistics> rtp_receive_statistics_; 522 scoped_ptr<StatisticsProxy> statistics_proxy_; 523 scoped_ptr<RtpReceiver> rtp_receiver_; 524 TelephoneEventHandler* telephone_event_handler_; 525 scoped_ptr<RtpRtcp> _rtpRtcpModule; 526 scoped_ptr<AudioCodingModule> audio_coding_; 527 RtpDump& _rtpDumpIn; 528 RtpDump& _rtpDumpOut; 529 AudioLevel _outputAudioLevel; 530 bool _externalTransport; 531 AudioFrame _audioFrame; 532 scoped_ptr<int16_t[]> mono_recording_audio_; 533 // Downsamples to the codec rate if necessary. 534 PushResampler<int16_t> input_resampler_; 535 uint8_t _audioLevel_dBov; 536 FilePlayer* _inputFilePlayerPtr; 537 FilePlayer* _outputFilePlayerPtr; 538 FileRecorder* _outputFileRecorderPtr; 539 int _inputFilePlayerId; 540 int _outputFilePlayerId; 541 int _outputFileRecorderId; 542 bool _outputFileRecording; 543 DtmfInbandQueue _inbandDtmfQueue; 544 DtmfInband _inbandDtmfGenerator; 545 bool _outputExternalMedia; 546 VoEMediaProcess* _inputExternalMediaCallbackPtr; 547 VoEMediaProcess* _outputExternalMediaCallbackPtr; 548 uint32_t _timeStamp; 549 uint8_t _sendTelephoneEventPayloadType; 550 551 RemoteNtpTimeEstimator ntp_estimator_ GUARDED_BY(ts_stats_lock_); 552 553 // Timestamp of the audio pulled from NetEq. 554 uint32_t jitter_buffer_playout_timestamp_; 555 uint32_t playout_timestamp_rtp_; 556 uint32_t playout_timestamp_rtcp_; 557 uint32_t playout_delay_ms_; 558 uint32_t _numberOfDiscardedPackets; 559 uint16_t send_sequence_number_; 560 uint8_t restored_packet_[kVoiceEngineMaxIpPacketSizeBytes]; 561 562 scoped_ptr<CriticalSectionWrapper> ts_stats_lock_; 563 564 scoped_ptr<rtc::TimestampWrapAroundHandler> rtp_ts_wraparound_handler_; 565 // The rtp timestamp of the first played out audio frame. 566 int64_t capture_start_rtp_time_stamp_; 567 // The capture ntp time (in local timebase) of the first played out audio 568 // frame. 569 int64_t capture_start_ntp_time_ms_ GUARDED_BY(ts_stats_lock_); 570 571 // uses 572 Statistics* _engineStatisticsPtr; 573 OutputMixer* _outputMixerPtr; 574 TransmitMixer* _transmitMixerPtr; 575 ProcessThread* _moduleProcessThreadPtr; 576 AudioDeviceModule* _audioDeviceModulePtr; 577 VoiceEngineObserver* _voiceEngineObserverPtr; // owned by base 578 CriticalSectionWrapper* _callbackCritSectPtr; // owned by base 579 Transport* _transportPtr; // WebRtc socket or external transport 580 RMSLevel rms_level_; 581 scoped_ptr<AudioProcessing> rx_audioproc_; // far end AudioProcessing 582 VoERxVadCallback* _rxVadObserverPtr; 583 int32_t _oldVadDecision; 584 int32_t _sendFrameType; // Send data is voice, 1-voice, 0-otherwise 585 VoERTCPObserver* _rtcpObserverPtr; 586 // VoEBase 587 bool _externalPlayout; 588 bool _externalMixing; 589 bool _mixFileWithMicrophone; 590 bool _rtcpObserver; 591 // VoEVolumeControl 592 bool _mute; 593 float _panLeft; 594 float _panRight; 595 float _outputGain; 596 // VoEDtmf 597 bool _playOutbandDtmfEvent; 598 bool _playInbandDtmfEvent; 599 // VoeRTP_RTCP 600 uint32_t _lastLocalTimeStamp; 601 int8_t _lastPayloadType; 602 bool _includeAudioLevelIndication; 603 // VoENetwork 604 bool _rtpPacketTimedOut; 605 bool _rtpPacketTimeOutIsEnabled; 606 uint32_t _rtpTimeOutSeconds; 607 bool _connectionObserver; 608 VoEConnectionObserver* _connectionObserverPtr; 609 AudioFrame::SpeechType _outputSpeechType; 610 ViENetwork* vie_network_; 611 int video_channel_; 612 // VoEVideoSync 613 uint32_t _average_jitter_buffer_delay_us; 614 int least_required_delay_ms_; 615 uint32_t _previousTimestamp; 616 uint16_t _recPacketDelayMs; 617 // VoEAudioProcessing 618 bool _RxVadDetection; 619 bool _rxAgcIsEnabled; 620 bool _rxNsIsEnabled; 621 bool restored_packet_in_use_; 622 // RtcpBandwidthObserver 623 scoped_ptr<BitrateController> bitrate_controller_; 624 scoped_ptr<RtcpBandwidthObserver> rtcp_bandwidth_observer_; 625 scoped_ptr<BitrateObserver> send_bitrate_observer_; 626 scoped_ptr<NetworkPredictor> network_predictor_; 627 }; 628 629 } // namespace voe 630 } // namespace webrtc 631 632 #endif // WEBRTC_VOICE_ENGINE_CHANNEL_H_ 633
