channel.h revision 167b6dfc73fc2f4c47713bcbd89b58c52612983b 
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/rtp_rtcp/interface/rtp_header_parser.h"
19#include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp.h"
20#include "webrtc/modules/utility/interface/file_player.h"
21#include "webrtc/modules/utility/interface/file_recorder.h"
22#include "webrtc/system_wrappers/interface/scoped_ptr.h"
23#include "webrtc/voice_engine/dtmf_inband.h"
24#include "webrtc/voice_engine/dtmf_inband_queue.h"
25#include "webrtc/voice_engine/include/voe_audio_processing.h"
26#include "webrtc/voice_engine/include/voe_network.h"
27#include "webrtc/voice_engine/level_indicator.h"
28#include "webrtc/voice_engine/shared_data.h"
29#include "webrtc/voice_engine/voice_engine_defines.h"
30
31#ifdef WEBRTC_DTMF_DETECTION
32// TelephoneEventDetectionMethods, TelephoneEventObserver
33#include "webrtc/voice_engine/include/voe_dtmf.h"
34#endif
35
36namespace webrtc {
37
38class AudioDeviceModule;
39class Config;
40class CriticalSectionWrapper;
41class FileWrapper;
42class ProcessThread;
43class ReceiveStatistics;
44class RtpDump;
45class RTPPayloadRegistry;
46class RtpReceiver;
47class RTPReceiverAudio;
48class RtpRtcp;
49class TelephoneEventHandler;
50class VoEMediaProcess;
51class VoERTCPObserver;
52class VoERTPObserver;
53class VoiceEngineObserver;
54
55struct CallStatistics;
56struct ReportBlock;
57struct SenderInfo;
58
59namespace voe {
60
61class Statistics;
62class TransmitMixer;
63class OutputMixer;
64
65
66class Channel:
67    public RtpData,
68    public RtpFeedback,
69    public RtcpFeedback,
70    public FileCallback, // receiving notification from file player & recorder
71    public Transport,
72    public RtpAudioFeedback,
73    public AudioPacketizationCallback, // receive encoded packets from the ACM
74    public ACMVADCallback, // receive voice activity from the ACM
75    public MixerParticipant // supplies output mixer with audio frames
76{
77public:
78    enum {KNumSocketThreads = 1};
79    enum {KNumberOfSocketBuffers = 8};
80    virtual ~Channel();
81    static int32_t CreateChannel(Channel*& channel,
82                                 int32_t channelId,
83                                 uint32_t instanceId,
84                                 const Config& config);
85    Channel(int32_t channelId, uint32_t instanceId, const Config& config);
86    int32_t Init();
87    int32_t SetEngineInformation(
88        Statistics& engineStatistics,
89        OutputMixer& outputMixer,
90        TransmitMixer& transmitMixer,
91        ProcessThread& moduleProcessThread,
92        AudioDeviceModule& audioDeviceModule,
93        VoiceEngineObserver* voiceEngineObserver,
94        CriticalSectionWrapper* callbackCritSect);
95    int32_t UpdateLocalTimeStamp();
96
97    // API methods
98
99    // VoEBase
100    int32_t StartPlayout();
101    int32_t StopPlayout();
102    int32_t StartSend();
103    int32_t StopSend();
104    int32_t StartReceiving();
105    int32_t StopReceiving();
106
107    int32_t SetNetEQPlayoutMode(NetEqModes mode);
108    int32_t GetNetEQPlayoutMode(NetEqModes& mode);
109    int32_t SetOnHoldStatus(bool enable, OnHoldModes mode);
110    int32_t GetOnHoldStatus(bool& enabled, OnHoldModes& mode);
111    int32_t RegisterVoiceEngineObserver(VoiceEngineObserver& observer);
112    int32_t DeRegisterVoiceEngineObserver();
113
114    // VoECodec
115    int32_t GetSendCodec(CodecInst& codec);
116    int32_t GetRecCodec(CodecInst& codec);
117    int32_t SetSendCodec(const CodecInst& codec);
118    int32_t SetVADStatus(bool enableVAD, ACMVADMode mode, bool disableDTX);
119    int32_t GetVADStatus(bool& enabledVAD, ACMVADMode& mode, bool& disabledDTX);
120    int32_t SetRecPayloadType(const CodecInst& codec);
121    int32_t GetRecPayloadType(CodecInst& codec);
122    int32_t SetAMREncFormat(AmrMode mode);
123    int32_t SetAMRDecFormat(AmrMode mode);
124    int32_t SetAMRWbEncFormat(AmrMode mode);
125    int32_t SetAMRWbDecFormat(AmrMode mode);
126    int32_t SetSendCNPayloadType(int type, PayloadFrequencies frequency);
127    int32_t SetISACInitTargetRate(int rateBps, bool useFixedFrameSize);
128    int32_t SetISACMaxRate(int rateBps);
129    int32_t SetISACMaxPayloadSize(int sizeBytes);
130
131    // VoE dual-streaming.
132    int SetSecondarySendCodec(const CodecInst& codec, int red_payload_type);
133    void RemoveSecondarySendCodec();
134    int GetSecondarySendCodec(CodecInst* codec);
135
136    // VoENetwork
137    int32_t RegisterExternalTransport(Transport& transport);
138    int32_t DeRegisterExternalTransport();
139    int32_t ReceivedRTPPacket(const int8_t* data, int32_t length);
140    int32_t ReceivedRTCPPacket(const int8_t* data, int32_t length);
141
142    // VoEFile
143    int StartPlayingFileLocally(const char* fileName, bool loop,
144                                FileFormats format,
145                                int startPosition,
146                                float volumeScaling,
147                                int stopPosition,
148                                const CodecInst* codecInst);
149    int StartPlayingFileLocally(InStream* stream, FileFormats format,
150                                int startPosition,
151                                float volumeScaling,
152                                int stopPosition,
153                                const CodecInst* codecInst);
154    int StopPlayingFileLocally();
155    int IsPlayingFileLocally() const;
156    int RegisterFilePlayingToMixer();
157    int ScaleLocalFilePlayout(float scale);
158    int GetLocalPlayoutPosition(int& positionMs);
159    int StartPlayingFileAsMicrophone(const char* fileName, bool loop,
160                                     FileFormats format,
161                                     int startPosition,
162                                     float volumeScaling,
163                                     int stopPosition,
164                                     const CodecInst* codecInst);
165    int StartPlayingFileAsMicrophone(InStream* stream,
166                                     FileFormats format,
167                                     int startPosition,
168                                     float volumeScaling,
169                                     int stopPosition,
170                                     const CodecInst* codecInst);
171    int StopPlayingFileAsMicrophone();
172    int IsPlayingFileAsMicrophone() const;
173    int ScaleFileAsMicrophonePlayout(float scale);
174    int StartRecordingPlayout(const char* fileName, const CodecInst* codecInst);
175    int StartRecordingPlayout(OutStream* stream, const CodecInst* codecInst);
176    int StopRecordingPlayout();
177
178    void SetMixWithMicStatus(bool mix);
179
180    // VoEExternalMediaProcessing
181    int RegisterExternalMediaProcessing(ProcessingTypes type,
182                                        VoEMediaProcess& processObject);
183    int DeRegisterExternalMediaProcessing(ProcessingTypes type);
184    int SetExternalMixing(bool enabled);
185
186    // VoEVolumeControl
187    int GetSpeechOutputLevel(uint32_t& level) const;
188    int GetSpeechOutputLevelFullRange(uint32_t& level) const;
189    int SetMute(bool enable);
190    bool Mute() const;
191    int SetOutputVolumePan(float left, float right);
192    int GetOutputVolumePan(float& left, float& right) const;
193    int SetChannelOutputVolumeScaling(float scaling);
194    int GetChannelOutputVolumeScaling(float& scaling) const;
195
196    // VoECallReport
197    void ResetDeadOrAliveCounters();
198    int ResetRTCPStatistics();
199    int GetRoundTripTimeSummary(StatVal& delaysMs) const;
200    int GetDeadOrAliveCounters(int& countDead, int& countAlive) const;
201
202    // VoENetEqStats
203    int GetNetworkStatistics(NetworkStatistics& stats);
204    void GetDecodingCallStatistics(AudioDecodingCallStats* stats) const;
205
206    // VoEVideoSync
207    bool GetDelayEstimate(int* jitter_buffer_delay_ms,
208                          int* playout_buffer_delay_ms) const;
209    int least_required_delay_ms() const { return least_required_delay_ms_; }
210    int SetInitialPlayoutDelay(int delay_ms);
211    int SetMinimumPlayoutDelay(int delayMs);
212    int GetPlayoutTimestamp(unsigned int& timestamp);
213    void UpdatePlayoutTimestamp(bool rtcp);
214    int SetInitTimestamp(unsigned int timestamp);
215    int SetInitSequenceNumber(short sequenceNumber);
216
217    // VoEVideoSyncExtended
218    int GetRtpRtcp(RtpRtcp** rtpRtcpModule, RtpReceiver** rtp_receiver) const;
219
220    // VoEEncryption
221    int RegisterExternalEncryption(Encryption& encryption);
222    int DeRegisterExternalEncryption();
223
224    // VoEDtmf
225    int SendTelephoneEventOutband(unsigned char eventCode, int lengthMs,
226                                  int attenuationDb, bool playDtmfEvent);
227    int SendTelephoneEventInband(unsigned char eventCode, int lengthMs,
228                                 int attenuationDb, bool playDtmfEvent);
229    int SetDtmfPlayoutStatus(bool enable);
230    bool DtmfPlayoutStatus() const;
231    int SetSendTelephoneEventPayloadType(unsigned char type);
232    int GetSendTelephoneEventPayloadType(unsigned char& type);
233
234    // VoEAudioProcessingImpl
235    int UpdateRxVadDetection(AudioFrame& audioFrame);
236    int RegisterRxVadObserver(VoERxVadCallback &observer);
237    int DeRegisterRxVadObserver();
238    int VoiceActivityIndicator(int &activity);
239#ifdef WEBRTC_VOICE_ENGINE_AGC
240    int SetRxAgcStatus(bool enable, AgcModes mode);
241    int GetRxAgcStatus(bool& enabled, AgcModes& mode);
242    int SetRxAgcConfig(AgcConfig config);
243    int GetRxAgcConfig(AgcConfig& config);
244#endif
245#ifdef WEBRTC_VOICE_ENGINE_NR
246    int SetRxNsStatus(bool enable, NsModes mode);
247    int GetRxNsStatus(bool& enabled, NsModes& mode);
248#endif
249
250    // VoERTP_RTCP
251    int RegisterRTPObserver(VoERTPObserver& observer);
252    int DeRegisterRTPObserver();
253    int RegisterRTCPObserver(VoERTCPObserver& observer);
254    int DeRegisterRTCPObserver();
255    int SetLocalSSRC(unsigned int ssrc);
256    int GetLocalSSRC(unsigned int& ssrc);
257    int GetRemoteSSRC(unsigned int& ssrc);
258    int GetRemoteCSRCs(unsigned int arrCSRC[15]);
259    int SetRTPAudioLevelIndicationStatus(bool enable, unsigned char ID);
260    int GetRTPAudioLevelIndicationStatus(bool& enable, unsigned char& ID);
261    int SetRTCPStatus(bool enable);
262    int GetRTCPStatus(bool& enabled);
263    int SetRTCP_CNAME(const char cName[256]);
264    int GetRTCP_CNAME(char cName[256]);
265    int GetRemoteRTCP_CNAME(char cName[256]);
266    int GetRemoteRTCPData(unsigned int& NTPHigh, unsigned int& NTPLow,
267                          unsigned int& timestamp,
268                          unsigned int& playoutTimestamp, unsigned int* jitter,
269                          unsigned short* fractionLost);
270    int SendApplicationDefinedRTCPPacket(unsigned char subType,
271                                         unsigned int name, const char* data,
272                                         unsigned short dataLengthInBytes);
273    int GetRTPStatistics(unsigned int& averageJitterMs,
274                         unsigned int& maxJitterMs,
275                         unsigned int& discardedPackets);
276    int GetRemoteRTCPSenderInfo(SenderInfo* sender_info);
277    int GetRemoteRTCPReportBlocks(std::vector<ReportBlock>* report_blocks);
278    int GetRTPStatistics(CallStatistics& stats);
279    int SetFECStatus(bool enable, int redPayloadtype);
280    int GetFECStatus(bool& enabled, int& redPayloadtype);
281    void SetNACKStatus(bool enable, int maxNumberOfPackets);
282    int StartRTPDump(const char fileNameUTF8[1024], RTPDirections direction);
283    int StopRTPDump(RTPDirections direction);
284    bool RTPDumpIsActive(RTPDirections direction);
285    int InsertExtraRTPPacket(unsigned char payloadType, bool markerBit,
286                             const char* payloadData,
287                             unsigned short payloadSize);
288    uint32_t LastRemoteTimeStamp() { return _lastRemoteTimeStamp; }
289
290    // From AudioPacketizationCallback in the ACM
291    int32_t SendData(FrameType frameType,
292                     uint8_t payloadType,
293                     uint32_t timeStamp,
294                     const uint8_t* payloadData,
295                     uint16_t payloadSize,
296                     const RTPFragmentationHeader* fragmentation);
297    // From ACMVADCallback in the ACM
298    int32_t InFrameType(int16_t frameType);
299
300    int32_t OnRxVadDetected(int vadDecision);
301
302    // From RtpData in the RTP/RTCP module
303    int32_t OnReceivedPayloadData(const uint8_t* payloadData,
304                                  uint16_t payloadSize,
305                                  const WebRtcRTPHeader* rtpHeader);
306
307    bool OnRecoveredPacket(const uint8_t* packet, int packet_length);
308
309    // From RtpFeedback in the RTP/RTCP module
310    int32_t OnInitializeDecoder(
311            int32_t id,
312            int8_t payloadType,
313            const char payloadName[RTP_PAYLOAD_NAME_SIZE],
314            int frequency,
315            uint8_t channels,
316            uint32_t rate);
317
318    void OnPacketTimeout(int32_t id);
319
320    void OnReceivedPacket(int32_t id, RtpRtcpPacketType packetType);
321
322    void OnPeriodicDeadOrAlive(int32_t id,
323                               RTPAliveType alive);
324
325    void OnIncomingSSRCChanged(int32_t id,
326                               uint32_t ssrc);
327
328    void OnIncomingCSRCChanged(int32_t id,
329                               uint32_t CSRC, bool added);
330
331    void ResetStatistics(uint32_t ssrc);
332
333    // From RtcpFeedback in the RTP/RTCP module
334    void OnApplicationDataReceived(int32_t id,
335                                   uint8_t subType,
336                                   uint32_t name,
337                                   uint16_t length,
338                                   const uint8_t* data);
339
340    // From RtpAudioFeedback in the RTP/RTCP module
341    void OnReceivedTelephoneEvent(int32_t id,
342                                  uint8_t event,
343                                  bool endOfEvent);
344
345    void OnPlayTelephoneEvent(int32_t id,
346                              uint8_t event,
347                              uint16_t lengthMs,
348                              uint8_t volume);
349
350    // From Transport (called by the RTP/RTCP module)
351    int SendPacket(int /*channel*/, const void *data, int len);
352    int SendRTCPPacket(int /*channel*/, const void *data, int len);
353
354    // From MixerParticipant
355    int32_t GetAudioFrame(int32_t id, AudioFrame& audioFrame);
356    int32_t NeededFrequency(int32_t id);
357
358    // From MonitorObserver
359    void OnPeriodicProcess();
360
361    // From FileCallback
362    void PlayNotification(int32_t id,
363                          uint32_t durationMs);
364    void RecordNotification(int32_t id,
365                            uint32_t durationMs);
366    void PlayFileEnded(int32_t id);
367    void RecordFileEnded(int32_t id);
368
369    uint32_t InstanceId() const
370    {
371        return _instanceId;
372    }
373    int32_t ChannelId() const
374    {
375        return _channelId;
376    }
377    bool Playing() const
378    {
379        return _playing;
380    }
381    bool Sending() const
382    {
383        // A lock is needed because |_sending| is accessed by both
384        // TransmitMixer::PrepareDemux() and StartSend()/StopSend(), which
385        // are called by different threads.
386        CriticalSectionScoped cs(&_callbackCritSect);
387        return _sending;
388    }
389    bool Receiving() const
390    {
391        return _receiving;
392    }
393    bool ExternalTransport() const
394    {
395        return _externalTransport;
396    }
397    bool ExternalMixing() const
398    {
399        return _externalMixing;
400    }
401    bool OutputIsOnHold() const
402    {
403        return _outputIsOnHold;
404    }
405    bool InputIsOnHold() const
406    {
407        return _inputIsOnHold;
408    }
409    RtpRtcp* RtpRtcpModulePtr() const
410    {
411        return _rtpRtcpModule.get();
412    }
413    int8_t OutputEnergyLevel() const
414    {
415        return _outputAudioLevel.Level();
416    }
417    uint32_t Demultiplex(const AudioFrame& audioFrame);
418    // Demultiplex the data to the channel's |_audioFrame|. The difference
419    // between this method and the overloaded method above is that |audio_data|
420    // does not go through transmit_mixer and APM.
421    void Demultiplex(const int16_t* audio_data,
422                     int sample_rate,
423                     int number_of_frames,
424                     int number_of_channels);
425    uint32_t PrepareEncodeAndSend(int mixingFrequency);
426    uint32_t EncodeAndSend();
427
428private:
429    bool ReceivePacket(const uint8_t* packet, int packet_length,
430                       const RTPHeader& header, bool in_order);
431    bool HandleEncapsulation(const uint8_t* packet,
432                             int packet_length,
433                             const RTPHeader& header);
434    bool IsPacketInOrder(const RTPHeader& header) const;
435    bool IsPacketRetransmitted(const RTPHeader& header, bool in_order) const;
436    int ResendPackets(const uint16_t* sequence_numbers, int length);
437    int InsertInbandDtmfTone();
438    int32_t MixOrReplaceAudioWithFile(int mixingFrequency);
439    int32_t MixAudioWithFile(AudioFrame& audioFrame, int mixingFrequency);
440    void UpdateDeadOrAliveCounters(bool alive);
441    int32_t SendPacketRaw(const void *data, int len, bool RTCP);
442    void UpdatePacketDelay(uint32_t timestamp,
443                           uint16_t sequenceNumber);
444    void RegisterReceiveCodecsToRTPModule();
445    int ApmProcessRx(AudioFrame& audioFrame);
446
447    int SetRedPayloadType(int red_payload_type);
448
449    CriticalSectionWrapper& _fileCritSect;
450    CriticalSectionWrapper& _callbackCritSect;
451    CriticalSectionWrapper& volume_settings_critsect_;
452    uint32_t _instanceId;
453    int32_t _channelId;
454
455    scoped_ptr<RtpHeaderParser> rtp_header_parser_;
456    scoped_ptr<RTPPayloadRegistry> rtp_payload_registry_;
457    scoped_ptr<ReceiveStatistics> rtp_receive_statistics_;
458    scoped_ptr<RtpReceiver> rtp_receiver_;
459    TelephoneEventHandler* telephone_event_handler_;
460    scoped_ptr<RtpRtcp> _rtpRtcpModule;
461    scoped_ptr<AudioCodingModule> audio_coding_;
462    RtpDump& _rtpDumpIn;
463    RtpDump& _rtpDumpOut;
464    AudioLevel _outputAudioLevel;
465    bool _externalTransport;
466    AudioFrame _audioFrame;
467    scoped_array<int16_t> mono_recording_audio_;
468    // Resampler is used when input data is stereo while codec is mono.
469    PushResampler input_resampler_;
470    uint8_t _audioLevel_dBov;
471    FilePlayer* _inputFilePlayerPtr;
472    FilePlayer* _outputFilePlayerPtr;
473    FileRecorder* _outputFileRecorderPtr;
474    int _inputFilePlayerId;
475    int _outputFilePlayerId;
476    int _outputFileRecorderId;
477    bool _inputFilePlaying;
478    bool _outputFilePlaying;
479    bool _outputFileRecording;
480    DtmfInbandQueue _inbandDtmfQueue;
481    DtmfInband _inbandDtmfGenerator;
482    bool _inputExternalMedia;
483    bool _outputExternalMedia;
484    VoEMediaProcess* _inputExternalMediaCallbackPtr;
485    VoEMediaProcess* _outputExternalMediaCallbackPtr;
486    uint8_t* _encryptionRTPBufferPtr;
487    uint8_t* _decryptionRTPBufferPtr;
488    uint8_t* _encryptionRTCPBufferPtr;
489    uint8_t* _decryptionRTCPBufferPtr;
490    uint32_t _timeStamp;
491    uint8_t _sendTelephoneEventPayloadType;
492
493    // Timestamp of the audio pulled from NetEq.
494    uint32_t jitter_buffer_playout_timestamp_;
495    uint32_t playout_timestamp_rtp_;
496    uint32_t playout_timestamp_rtcp_;
497    uint32_t playout_delay_ms_;
498    uint32_t _numberOfDiscardedPackets;
499    uint16_t send_sequence_number_;
500    uint8_t restored_packet_[kVoiceEngineMaxIpPacketSizeBytes];
501
502    // uses
503    Statistics* _engineStatisticsPtr;
504    OutputMixer* _outputMixerPtr;
505    TransmitMixer* _transmitMixerPtr;
506    ProcessThread* _moduleProcessThreadPtr;
507    AudioDeviceModule* _audioDeviceModulePtr;
508    VoiceEngineObserver* _voiceEngineObserverPtr; // owned by base
509    CriticalSectionWrapper* _callbackCritSectPtr; // owned by base
510    Transport* _transportPtr; // WebRtc socket or external transport
511    Encryption* _encryptionPtr; // WebRtc SRTP or external encryption
512    scoped_ptr<AudioProcessing> rtp_audioproc_;
513    scoped_ptr<AudioProcessing> rx_audioproc_; // far end AudioProcessing
514    VoERxVadCallback* _rxVadObserverPtr;
515    int32_t _oldVadDecision;
516    int32_t _sendFrameType; // Send data is voice, 1-voice, 0-otherwise
517    VoERTPObserver* _rtpObserverPtr;
518    VoERTCPObserver* _rtcpObserverPtr;
519    // VoEBase
520    bool _outputIsOnHold;
521    bool _externalPlayout;
522    bool _externalMixing;
523    bool _inputIsOnHold;
524    bool _playing;
525    bool _sending;
526    bool _receiving;
527    bool _mixFileWithMicrophone;
528    bool _rtpObserver;
529    bool _rtcpObserver;
530    // VoEVolumeControl
531    bool _mute;
532    float _panLeft;
533    float _panRight;
534    float _outputGain;
535    // VoEEncryption
536    bool _encrypting;
537    bool _decrypting;
538    // VoEDtmf
539    bool _playOutbandDtmfEvent;
540    bool _playInbandDtmfEvent;
541    // VoeRTP_RTCP
542    uint8_t _extraPayloadType;
543    bool _insertExtraRTPPacket;
544    bool _extraMarkerBit;
545    uint32_t _lastLocalTimeStamp;
546    uint32_t _lastRemoteTimeStamp;
547    int8_t _lastPayloadType;
548    bool _includeAudioLevelIndication;
549    // VoENetwork
550    bool _rtpPacketTimedOut;
551    bool _rtpPacketTimeOutIsEnabled;
552    uint32_t _rtpTimeOutSeconds;
553    bool _connectionObserver;
554    VoEConnectionObserver* _connectionObserverPtr;
555    uint32_t _countAliveDetections;
556    uint32_t _countDeadDetections;
557    AudioFrame::SpeechType _outputSpeechType;
558    // VoEVideoSync
559    uint32_t _average_jitter_buffer_delay_us;
560    int least_required_delay_ms_;
561    uint32_t _previousTimestamp;
562    uint16_t _recPacketDelayMs;
563    // VoEAudioProcessing
564    bool _RxVadDetection;
565    bool _rxApmIsEnabled;
566    bool _rxAgcIsEnabled;
567    bool _rxNsIsEnabled;
568    bool restored_packet_in_use_;
569};
570
571}  // namespace voe
572}  // namespace webrtc
573
574#endif  // WEBRTC_VOICE_ENGINE_CHANNEL_H
575