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