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
40namespace rtc {
41
42class TimestampWrapAroundHandler;
43}
44
45namespace webrtc {
46
47class AudioDeviceModule;
48class Config;
49class CriticalSectionWrapper;
50class FileWrapper;
51class ProcessThread;
52class ReceiveStatistics;
53class RemoteNtpTimeEstimator;
54class RtpDump;
55class RTPPayloadRegistry;
56class RtpReceiver;
57class RTPReceiverAudio;
58class RtpRtcp;
59class TelephoneEventHandler;
60class ViENetwork;
61class VoEMediaProcess;
62class VoERTCPObserver;
63class VoERTPObserver;
64class VoiceEngineObserver;
65
66struct CallStatistics;
67struct ReportBlock;
68struct SenderInfo;
69
70namespace voe {
71
72class Statistics;
73class StatisticsProxy;
74class TransmitMixer;
75class 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.
82class 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
151private:
152    scoped_ptr<CriticalSectionWrapper> lock_;
153    State state_;
154};
155
156class 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{
167public:
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
487private:
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