henrik.lundin@webrtc.org | 9a40081 | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 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_MODULES_AUDIO_CODING_NETEQ4_NETEQ_IMPL_H_ |
| 12 | #define WEBRTC_MODULES_AUDIO_CODING_NETEQ4_NETEQ_IMPL_H_ |
| 13 | |
| 14 | #include <vector> |
| 15 | |
| 16 | #include "webrtc/modules/audio_coding/neteq4/audio_multi_vector.h" |
| 17 | #include "webrtc/modules/audio_coding/neteq4/defines.h" |
| 18 | #include "webrtc/modules/audio_coding/neteq4/interface/neteq.h" |
| 19 | #include "webrtc/modules/audio_coding/neteq4/packet.h" // Declare PacketList. |
| 20 | #include "webrtc/modules/audio_coding/neteq4/random_vector.h" |
| 21 | #include "webrtc/modules/audio_coding/neteq4/rtcp.h" |
| 22 | #include "webrtc/modules/audio_coding/neteq4/statistics_calculator.h" |
mcasas@webrtc.org | 0a9ed7c | 2014-05-21 11:07:29 +0000 | [diff] [blame^] | 23 | #include "webrtc/system_wrappers/interface/constructor_magic.h" |
henrik.lundin@webrtc.org | 9a40081 | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 24 | #include "webrtc/system_wrappers/interface/scoped_ptr.h" |
henrik.lundin@webrtc.org | c4c3021 | 2014-03-18 11:49:22 +0000 | [diff] [blame] | 25 | #include "webrtc/system_wrappers/interface/thread_annotations.h" |
henrik.lundin@webrtc.org | 9a40081 | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 26 | #include "webrtc/typedefs.h" |
| 27 | |
| 28 | namespace webrtc { |
| 29 | |
| 30 | // Forward declarations. |
henrik.lundin@webrtc.org | 671d90b | 2013-09-18 12:19:50 +0000 | [diff] [blame] | 31 | class Accelerate; |
henrik.lundin@webrtc.org | 9a40081 | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 32 | class BackgroundNoise; |
| 33 | class BufferLevelFilter; |
| 34 | class ComfortNoise; |
| 35 | class CriticalSectionWrapper; |
| 36 | class DecisionLogic; |
| 37 | class DecoderDatabase; |
| 38 | class DelayManager; |
| 39 | class DelayPeakDetector; |
| 40 | class DtmfBuffer; |
| 41 | class DtmfToneGenerator; |
| 42 | class Expand; |
henrik.lundin@webrtc.org | 671d90b | 2013-09-18 12:19:50 +0000 | [diff] [blame] | 43 | class Merge; |
| 44 | class Normal; |
henrik.lundin@webrtc.org | 9a40081 | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 45 | class PacketBuffer; |
| 46 | class PayloadSplitter; |
| 47 | class PostDecodeVad; |
henrik.lundin@webrtc.org | 671d90b | 2013-09-18 12:19:50 +0000 | [diff] [blame] | 48 | class PreemptiveExpand; |
henrik.lundin@webrtc.org | 9a40081 | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 49 | class RandomVector; |
| 50 | class SyncBuffer; |
| 51 | class TimestampScaler; |
henrik.lundin@webrtc.org | 37fb66d | 2014-01-14 10:18:45 +0000 | [diff] [blame] | 52 | struct AccelerateFactory; |
henrik.lundin@webrtc.org | 9a40081 | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 53 | struct DtmfEvent; |
henrik.lundin@webrtc.org | 37fb66d | 2014-01-14 10:18:45 +0000 | [diff] [blame] | 54 | struct ExpandFactory; |
| 55 | struct PreemptiveExpandFactory; |
henrik.lundin@webrtc.org | 9a40081 | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 56 | |
| 57 | class NetEqImpl : public webrtc::NetEq { |
| 58 | public: |
| 59 | // Creates a new NetEqImpl object. The object will assume ownership of all |
| 60 | // injected dependencies, and will delete them when done. |
| 61 | NetEqImpl(int fs, |
| 62 | BufferLevelFilter* buffer_level_filter, |
| 63 | DecoderDatabase* decoder_database, |
| 64 | DelayManager* delay_manager, |
| 65 | DelayPeakDetector* delay_peak_detector, |
| 66 | DtmfBuffer* dtmf_buffer, |
| 67 | DtmfToneGenerator* dtmf_tone_generator, |
| 68 | PacketBuffer* packet_buffer, |
| 69 | PayloadSplitter* payload_splitter, |
henrik.lundin@webrtc.org | 37fb66d | 2014-01-14 10:18:45 +0000 | [diff] [blame] | 70 | TimestampScaler* timestamp_scaler, |
| 71 | AccelerateFactory* accelerate_factory, |
| 72 | ExpandFactory* expand_factory, |
turaj@webrtc.org | c1caa69 | 2014-04-11 18:47:55 +0000 | [diff] [blame] | 73 | PreemptiveExpandFactory* preemptive_expand_factory, |
| 74 | bool create_components = true); |
henrik.lundin@webrtc.org | 9a40081 | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 75 | |
| 76 | virtual ~NetEqImpl(); |
| 77 | |
| 78 | // Inserts a new packet into NetEq. The |receive_timestamp| is an indication |
| 79 | // of the time when the packet was received, and should be measured with |
| 80 | // the same tick rate as the RTP timestamp of the current payload. |
| 81 | // Returns 0 on success, -1 on failure. |
| 82 | virtual int InsertPacket(const WebRtcRTPHeader& rtp_header, |
| 83 | const uint8_t* payload, |
| 84 | int length_bytes, |
| 85 | uint32_t receive_timestamp); |
| 86 | |
turaj@webrtc.org | 2f0a942 | 2013-09-26 00:27:56 +0000 | [diff] [blame] | 87 | // Inserts a sync-packet into packet queue. Sync-packets are decoded to |
| 88 | // silence and are intended to keep AV-sync intact in an event of long packet |
| 89 | // losses when Video NACK is enabled but Audio NACK is not. Clients of NetEq |
| 90 | // might insert sync-packet when they observe that buffer level of NetEq is |
| 91 | // decreasing below a certain threshold, defined by the application. |
| 92 | // Sync-packets should have the same payload type as the last audio payload |
| 93 | // type, i.e. they cannot have DTMF or CNG payload type, nor a codec change |
| 94 | // can be implied by inserting a sync-packet. |
| 95 | // Returns kOk on success, kFail on failure. |
| 96 | virtual int InsertSyncPacket(const WebRtcRTPHeader& rtp_header, |
| 97 | uint32_t receive_timestamp); |
| 98 | |
henrik.lundin@webrtc.org | 9a40081 | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 99 | // Instructs NetEq to deliver 10 ms of audio data. The data is written to |
| 100 | // |output_audio|, which can hold (at least) |max_length| elements. |
| 101 | // The number of channels that were written to the output is provided in |
| 102 | // the output variable |num_channels|, and each channel contains |
| 103 | // |samples_per_channel| elements. If more than one channel is written, |
| 104 | // the samples are interleaved. |
| 105 | // The speech type is written to |type|, if |type| is not NULL. |
| 106 | // Returns kOK on success, or kFail in case of an error. |
| 107 | virtual int GetAudio(size_t max_length, int16_t* output_audio, |
| 108 | int* samples_per_channel, int* num_channels, |
| 109 | NetEqOutputType* type); |
| 110 | |
| 111 | // Associates |rtp_payload_type| with |codec| and stores the information in |
| 112 | // the codec database. Returns kOK on success, kFail on failure. |
| 113 | virtual int RegisterPayloadType(enum NetEqDecoder codec, |
| 114 | uint8_t rtp_payload_type); |
| 115 | |
| 116 | // Provides an externally created decoder object |decoder| to insert in the |
| 117 | // decoder database. The decoder implements a decoder of type |codec| and |
turaj@webrtc.org | d084db9 | 2014-04-17 23:30:49 +0000 | [diff] [blame] | 118 | // associates it with |rtp_payload_type|. Returns kOK on success, kFail on |
| 119 | // failure. |
henrik.lundin@webrtc.org | 9a40081 | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 120 | virtual int RegisterExternalDecoder(AudioDecoder* decoder, |
| 121 | enum NetEqDecoder codec, |
henrik.lundin@webrtc.org | 9a40081 | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 122 | uint8_t rtp_payload_type); |
| 123 | |
| 124 | // Removes |rtp_payload_type| from the codec database. Returns 0 on success, |
| 125 | // -1 on failure. |
| 126 | virtual int RemovePayloadType(uint8_t rtp_payload_type); |
| 127 | |
turaj@webrtc.org | 662ded4 | 2013-08-16 23:44:24 +0000 | [diff] [blame] | 128 | virtual bool SetMinimumDelay(int delay_ms); |
| 129 | |
| 130 | virtual bool SetMaximumDelay(int delay_ms); |
| 131 | |
| 132 | virtual int LeastRequiredDelayMs() const; |
henrik.lundin@webrtc.org | 9a40081 | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 133 | |
| 134 | virtual int SetTargetDelay() { return kNotImplemented; } |
| 135 | |
| 136 | virtual int TargetDelay() { return kNotImplemented; } |
| 137 | |
| 138 | virtual int CurrentDelay() { return kNotImplemented; } |
| 139 | |
henrik.lundin@webrtc.org | 9a40081 | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 140 | // Sets the playout mode to |mode|. |
| 141 | virtual void SetPlayoutMode(NetEqPlayoutMode mode); |
| 142 | |
| 143 | // Returns the current playout mode. |
| 144 | virtual NetEqPlayoutMode PlayoutMode() const; |
| 145 | |
| 146 | // Writes the current network statistics to |stats|. The statistics are reset |
| 147 | // after the call. |
| 148 | virtual int NetworkStatistics(NetEqNetworkStatistics* stats); |
| 149 | |
| 150 | // Writes the last packet waiting times (in ms) to |waiting_times|. The number |
| 151 | // of values written is no more than 100, but may be smaller if the interface |
| 152 | // is polled again before 100 packets has arrived. |
| 153 | virtual void WaitingTimes(std::vector<int>* waiting_times); |
| 154 | |
| 155 | // Writes the current RTCP statistics to |stats|. The statistics are reset |
| 156 | // and a new report period is started with the call. |
| 157 | virtual void GetRtcpStatistics(RtcpStatistics* stats); |
| 158 | |
| 159 | // Same as RtcpStatistics(), but does not reset anything. |
| 160 | virtual void GetRtcpStatisticsNoReset(RtcpStatistics* stats); |
| 161 | |
| 162 | // Enables post-decode VAD. When enabled, GetAudio() will return |
| 163 | // kOutputVADPassive when the signal contains no speech. |
| 164 | virtual void EnableVad(); |
| 165 | |
| 166 | // Disables post-decode VAD. |
| 167 | virtual void DisableVad(); |
| 168 | |
| 169 | // Returns the RTP timestamp for the last sample delivered by GetAudio(). |
| 170 | virtual uint32_t PlayoutTimestamp(); |
| 171 | |
| 172 | virtual int SetTargetNumberOfChannels() { return kNotImplemented; } |
| 173 | |
| 174 | virtual int SetTargetSampleRate() { return kNotImplemented; } |
| 175 | |
| 176 | // Returns the error code for the last occurred error. If no error has |
| 177 | // occurred, 0 is returned. |
| 178 | virtual int LastError(); |
| 179 | |
| 180 | // Returns the error code last returned by a decoder (audio or comfort noise). |
| 181 | // When LastError() returns kDecoderErrorCode or kComfortNoiseErrorCode, check |
| 182 | // this method to get the decoder's error code. |
| 183 | virtual int LastDecoderError(); |
| 184 | |
| 185 | // Flushes both the packet buffer and the sync buffer. |
| 186 | virtual void FlushBuffers(); |
| 187 | |
turaj@webrtc.org | 4b8077b | 2013-08-02 18:07:13 +0000 | [diff] [blame] | 188 | virtual void PacketBufferStatistics(int* current_num_packets, |
henrik.lundin@webrtc.org | cbfcdd7 | 2014-04-28 08:20:04 +0000 | [diff] [blame] | 189 | int* max_num_packets) const; |
turaj@webrtc.org | 4b8077b | 2013-08-02 18:07:13 +0000 | [diff] [blame] | 190 | |
minyue@webrtc.org | 42758b3 | 2013-08-29 00:58:14 +0000 | [diff] [blame] | 191 | // Get sequence number and timestamp of the latest RTP. |
| 192 | // This method is to facilitate NACK. |
turaj@webrtc.org | 6ca9e7d | 2013-09-25 00:07:27 +0000 | [diff] [blame] | 193 | virtual int DecodedRtpInfo(int* sequence_number, uint32_t* timestamp) const; |
| 194 | |
| 195 | // Sets background noise mode. |
| 196 | virtual void SetBackgroundNoiseMode(NetEqBackgroundNoiseMode mode); |
| 197 | |
| 198 | // Gets background noise mode. |
| 199 | virtual NetEqBackgroundNoiseMode BackgroundNoiseMode() const; |
minyue@webrtc.org | 42758b3 | 2013-08-29 00:58:14 +0000 | [diff] [blame] | 200 | |
henrik.lundin@webrtc.org | cef07f9 | 2014-04-07 21:21:45 +0000 | [diff] [blame] | 201 | // This accessor method is only intended for testing purposes. |
| 202 | virtual const SyncBuffer* sync_buffer_for_test() const; |
| 203 | |
turaj@webrtc.org | c1caa69 | 2014-04-11 18:47:55 +0000 | [diff] [blame] | 204 | protected: |
henrik.lundin@webrtc.org | 9a40081 | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 205 | static const int kOutputSizeMs = 10; |
| 206 | static const int kMaxFrameSize = 2880; // 60 ms @ 48 kHz. |
| 207 | // TODO(hlundin): Provide a better value for kSyncBufferSize. |
| 208 | static const int kSyncBufferSize = 2 * kMaxFrameSize; |
| 209 | |
| 210 | // Inserts a new packet into NetEq. This is used by the InsertPacket method |
| 211 | // above. Returns 0 on success, otherwise an error code. |
| 212 | // TODO(hlundin): Merge this with InsertPacket above? |
| 213 | int InsertPacketInternal(const WebRtcRTPHeader& rtp_header, |
| 214 | const uint8_t* payload, |
| 215 | int length_bytes, |
turaj@webrtc.org | 2f0a942 | 2013-09-26 00:27:56 +0000 | [diff] [blame] | 216 | uint32_t receive_timestamp, |
henrik.lundin@webrtc.org | c4c3021 | 2014-03-18 11:49:22 +0000 | [diff] [blame] | 217 | bool is_sync_packet) |
| 218 | EXCLUSIVE_LOCKS_REQUIRED(crit_sect_); |
henrik.lundin@webrtc.org | 9a40081 | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 219 | |
henrik.lundin@webrtc.org | c340881 | 2013-01-30 07:37:20 +0000 | [diff] [blame] | 220 | // Delivers 10 ms of audio data. The data is written to |output|, which can |
| 221 | // hold (at least) |max_length| elements. The number of channels that were |
| 222 | // written to the output is provided in the output variable |num_channels|, |
| 223 | // and each channel contains |samples_per_channel| elements. If more than one |
| 224 | // channel is written, the samples are interleaved. |
| 225 | // Returns 0 on success, otherwise an error code. |
henrik.lundin@webrtc.org | c4c3021 | 2014-03-18 11:49:22 +0000 | [diff] [blame] | 226 | int GetAudioInternal(size_t max_length, |
| 227 | int16_t* output, |
| 228 | int* samples_per_channel, |
| 229 | int* num_channels) EXCLUSIVE_LOCKS_REQUIRED(crit_sect_); |
henrik.lundin@webrtc.org | 9a40081 | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 230 | |
| 231 | // Provides a decision to the GetAudioInternal method. The decision what to |
| 232 | // do is written to |operation|. Packets to decode are written to |
| 233 | // |packet_list|, and a DTMF event to play is written to |dtmf_event|. When |
| 234 | // DTMF should be played, |play_dtmf| is set to true by the method. |
| 235 | // Returns 0 on success, otherwise an error code. |
| 236 | int GetDecision(Operations* operation, |
| 237 | PacketList* packet_list, |
| 238 | DtmfEvent* dtmf_event, |
henrik.lundin@webrtc.org | c4c3021 | 2014-03-18 11:49:22 +0000 | [diff] [blame] | 239 | bool* play_dtmf) EXCLUSIVE_LOCKS_REQUIRED(crit_sect_); |
henrik.lundin@webrtc.org | 9a40081 | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 240 | |
| 241 | // Decodes the speech packets in |packet_list|, and writes the results to |
| 242 | // |decoded_buffer|, which is allocated to hold |decoded_buffer_length| |
| 243 | // elements. The length of the decoded data is written to |decoded_length|. |
| 244 | // The speech type -- speech or (codec-internal) comfort noise -- is written |
| 245 | // to |speech_type|. If |packet_list| contains any SID frames for RFC 3389 |
| 246 | // comfort noise, those are not decoded. |
henrik.lundin@webrtc.org | c4c3021 | 2014-03-18 11:49:22 +0000 | [diff] [blame] | 247 | int Decode(PacketList* packet_list, |
| 248 | Operations* operation, |
| 249 | int* decoded_length, |
| 250 | AudioDecoder::SpeechType* speech_type) |
| 251 | EXCLUSIVE_LOCKS_REQUIRED(crit_sect_); |
henrik.lundin@webrtc.org | 9a40081 | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 252 | |
| 253 | // Sub-method to Decode(). Performs the actual decoding. |
henrik.lundin@webrtc.org | c4c3021 | 2014-03-18 11:49:22 +0000 | [diff] [blame] | 254 | int DecodeLoop(PacketList* packet_list, |
| 255 | Operations* operation, |
| 256 | AudioDecoder* decoder, |
| 257 | int* decoded_length, |
| 258 | AudioDecoder::SpeechType* speech_type) |
| 259 | EXCLUSIVE_LOCKS_REQUIRED(crit_sect_); |
henrik.lundin@webrtc.org | 9a40081 | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 260 | |
| 261 | // Sub-method which calls the Normal class to perform the normal operation. |
henrik.lundin@webrtc.org | c4c3021 | 2014-03-18 11:49:22 +0000 | [diff] [blame] | 262 | void DoNormal(const int16_t* decoded_buffer, |
| 263 | size_t decoded_length, |
| 264 | AudioDecoder::SpeechType speech_type, |
| 265 | bool play_dtmf) EXCLUSIVE_LOCKS_REQUIRED(crit_sect_); |
henrik.lundin@webrtc.org | 9a40081 | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 266 | |
| 267 | // Sub-method which calls the Merge class to perform the merge operation. |
henrik.lundin@webrtc.org | c4c3021 | 2014-03-18 11:49:22 +0000 | [diff] [blame] | 268 | void DoMerge(int16_t* decoded_buffer, |
| 269 | size_t decoded_length, |
| 270 | AudioDecoder::SpeechType speech_type, |
| 271 | bool play_dtmf) EXCLUSIVE_LOCKS_REQUIRED(crit_sect_); |
henrik.lundin@webrtc.org | 9a40081 | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 272 | |
| 273 | // Sub-method which calls the Expand class to perform the expand operation. |
henrik.lundin@webrtc.org | c4c3021 | 2014-03-18 11:49:22 +0000 | [diff] [blame] | 274 | int DoExpand(bool play_dtmf) EXCLUSIVE_LOCKS_REQUIRED(crit_sect_); |
henrik.lundin@webrtc.org | 9a40081 | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 275 | |
| 276 | // Sub-method which calls the Accelerate class to perform the accelerate |
| 277 | // operation. |
henrik.lundin@webrtc.org | c4c3021 | 2014-03-18 11:49:22 +0000 | [diff] [blame] | 278 | int DoAccelerate(int16_t* decoded_buffer, |
| 279 | size_t decoded_length, |
| 280 | AudioDecoder::SpeechType speech_type, |
| 281 | bool play_dtmf) EXCLUSIVE_LOCKS_REQUIRED(crit_sect_); |
henrik.lundin@webrtc.org | 9a40081 | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 282 | |
| 283 | // Sub-method which calls the PreemptiveExpand class to perform the |
| 284 | // preemtive expand operation. |
henrik.lundin@webrtc.org | c4c3021 | 2014-03-18 11:49:22 +0000 | [diff] [blame] | 285 | int DoPreemptiveExpand(int16_t* decoded_buffer, |
| 286 | size_t decoded_length, |
| 287 | AudioDecoder::SpeechType speech_type, |
| 288 | bool play_dtmf) EXCLUSIVE_LOCKS_REQUIRED(crit_sect_); |
henrik.lundin@webrtc.org | 9a40081 | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 289 | |
| 290 | // Sub-method which calls the ComfortNoise class to generate RFC 3389 comfort |
| 291 | // noise. |packet_list| can either contain one SID frame to update the |
| 292 | // noise parameters, or no payload at all, in which case the previously |
| 293 | // received parameters are used. |
henrik.lundin@webrtc.org | c4c3021 | 2014-03-18 11:49:22 +0000 | [diff] [blame] | 294 | int DoRfc3389Cng(PacketList* packet_list, bool play_dtmf) |
| 295 | EXCLUSIVE_LOCKS_REQUIRED(crit_sect_); |
henrik.lundin@webrtc.org | 9a40081 | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 296 | |
| 297 | // Calls the audio decoder to generate codec-internal comfort noise when |
| 298 | // no packet was received. |
henrik.lundin@webrtc.org | c4c3021 | 2014-03-18 11:49:22 +0000 | [diff] [blame] | 299 | void DoCodecInternalCng() EXCLUSIVE_LOCKS_REQUIRED(crit_sect_); |
henrik.lundin@webrtc.org | 9a40081 | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 300 | |
| 301 | // Calls the DtmfToneGenerator class to generate DTMF tones. |
henrik.lundin@webrtc.org | c4c3021 | 2014-03-18 11:49:22 +0000 | [diff] [blame] | 302 | int DoDtmf(const DtmfEvent& dtmf_event, bool* play_dtmf) |
| 303 | EXCLUSIVE_LOCKS_REQUIRED(crit_sect_); |
henrik.lundin@webrtc.org | 9a40081 | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 304 | |
| 305 | // Produces packet-loss concealment using alternative methods. If the codec |
| 306 | // has an internal PLC, it is called to generate samples. Otherwise, the |
| 307 | // method performs zero-stuffing. |
henrik.lundin@webrtc.org | c4c3021 | 2014-03-18 11:49:22 +0000 | [diff] [blame] | 308 | void DoAlternativePlc(bool increase_timestamp) |
| 309 | EXCLUSIVE_LOCKS_REQUIRED(crit_sect_); |
henrik.lundin@webrtc.org | 9a40081 | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 310 | |
| 311 | // Overdub DTMF on top of |output|. |
henrik.lundin@webrtc.org | c4c3021 | 2014-03-18 11:49:22 +0000 | [diff] [blame] | 312 | int DtmfOverdub(const DtmfEvent& dtmf_event, |
| 313 | size_t num_channels, |
| 314 | int16_t* output) const EXCLUSIVE_LOCKS_REQUIRED(crit_sect_); |
henrik.lundin@webrtc.org | 9a40081 | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 315 | |
| 316 | // Extracts packets from |packet_buffer_| to produce at least |
| 317 | // |required_samples| samples. The packets are inserted into |packet_list|. |
| 318 | // Returns the number of samples that the packets in the list will produce, or |
| 319 | // -1 in case of an error. |
henrik.lundin@webrtc.org | c4c3021 | 2014-03-18 11:49:22 +0000 | [diff] [blame] | 320 | int ExtractPackets(int required_samples, PacketList* packet_list) |
| 321 | EXCLUSIVE_LOCKS_REQUIRED(crit_sect_); |
henrik.lundin@webrtc.org | 9a40081 | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 322 | |
| 323 | // Resets various variables and objects to new values based on the sample rate |
| 324 | // |fs_hz| and |channels| number audio channels. |
henrik.lundin@webrtc.org | c4c3021 | 2014-03-18 11:49:22 +0000 | [diff] [blame] | 325 | void SetSampleRateAndChannels(int fs_hz, size_t channels) |
| 326 | EXCLUSIVE_LOCKS_REQUIRED(crit_sect_); |
henrik.lundin@webrtc.org | 9a40081 | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 327 | |
| 328 | // Returns the output type for the audio produced by the latest call to |
| 329 | // GetAudio(). |
henrik.lundin@webrtc.org | c4c3021 | 2014-03-18 11:49:22 +0000 | [diff] [blame] | 330 | NetEqOutputType LastOutputType() EXCLUSIVE_LOCKS_REQUIRED(crit_sect_); |
henrik.lundin@webrtc.org | 9a40081 | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 331 | |
turaj@webrtc.org | c1caa69 | 2014-04-11 18:47:55 +0000 | [diff] [blame] | 332 | // Updates Expand and Merge. |
| 333 | virtual void UpdatePlcComponents(int fs_hz, size_t channels) |
| 334 | EXCLUSIVE_LOCKS_REQUIRED(crit_sect_); |
| 335 | |
| 336 | // Creates DecisionLogic object for the given mode. |
turaj@webrtc.org | 6ca6896 | 2014-05-10 00:58:49 +0000 | [diff] [blame] | 337 | virtual void CreateDecisionLogic(NetEqPlayoutMode mode) |
turaj@webrtc.org | c1caa69 | 2014-04-11 18:47:55 +0000 | [diff] [blame] | 338 | EXCLUSIVE_LOCKS_REQUIRED(crit_sect_); |
| 339 | |
henrik.lundin@webrtc.org | c4c3021 | 2014-03-18 11:49:22 +0000 | [diff] [blame] | 340 | const scoped_ptr<BufferLevelFilter> buffer_level_filter_; |
| 341 | const scoped_ptr<DecoderDatabase> decoder_database_; |
| 342 | const scoped_ptr<DelayManager> delay_manager_; |
| 343 | const scoped_ptr<DelayPeakDetector> delay_peak_detector_; |
| 344 | const scoped_ptr<DtmfBuffer> dtmf_buffer_; |
| 345 | const scoped_ptr<DtmfToneGenerator> dtmf_tone_generator_; |
| 346 | const scoped_ptr<PacketBuffer> packet_buffer_; |
| 347 | const scoped_ptr<PayloadSplitter> payload_splitter_; |
| 348 | const scoped_ptr<TimestampScaler> timestamp_scaler_; |
| 349 | const scoped_ptr<PostDecodeVad> vad_; |
| 350 | const scoped_ptr<ExpandFactory> expand_factory_; |
| 351 | const scoped_ptr<AccelerateFactory> accelerate_factory_; |
| 352 | const scoped_ptr<PreemptiveExpandFactory> preemptive_expand_factory_; |
| 353 | |
| 354 | scoped_ptr<BackgroundNoise> background_noise_ GUARDED_BY(crit_sect_); |
| 355 | scoped_ptr<DecisionLogic> decision_logic_ GUARDED_BY(crit_sect_); |
| 356 | scoped_ptr<AudioMultiVector> algorithm_buffer_ GUARDED_BY(crit_sect_); |
| 357 | scoped_ptr<SyncBuffer> sync_buffer_ GUARDED_BY(crit_sect_); |
| 358 | scoped_ptr<Expand> expand_ GUARDED_BY(crit_sect_); |
| 359 | scoped_ptr<Normal> normal_ GUARDED_BY(crit_sect_); |
| 360 | scoped_ptr<Merge> merge_ GUARDED_BY(crit_sect_); |
| 361 | scoped_ptr<Accelerate> accelerate_ GUARDED_BY(crit_sect_); |
| 362 | scoped_ptr<PreemptiveExpand> preemptive_expand_ GUARDED_BY(crit_sect_); |
| 363 | RandomVector random_vector_ GUARDED_BY(crit_sect_); |
| 364 | scoped_ptr<ComfortNoise> comfort_noise_ GUARDED_BY(crit_sect_); |
| 365 | Rtcp rtcp_ GUARDED_BY(crit_sect_); |
| 366 | StatisticsCalculator stats_ GUARDED_BY(crit_sect_); |
| 367 | int fs_hz_ GUARDED_BY(crit_sect_); |
| 368 | int fs_mult_ GUARDED_BY(crit_sect_); |
| 369 | int output_size_samples_ GUARDED_BY(crit_sect_); |
| 370 | int decoder_frame_length_ GUARDED_BY(crit_sect_); |
| 371 | Modes last_mode_ GUARDED_BY(crit_sect_); |
andrew@webrtc.org | ba47616 | 2014-04-25 23:10:28 +0000 | [diff] [blame] | 372 | scoped_ptr<int16_t[]> mute_factor_array_ GUARDED_BY(crit_sect_); |
henrik.lundin@webrtc.org | c4c3021 | 2014-03-18 11:49:22 +0000 | [diff] [blame] | 373 | size_t decoded_buffer_length_ GUARDED_BY(crit_sect_); |
andrew@webrtc.org | ba47616 | 2014-04-25 23:10:28 +0000 | [diff] [blame] | 374 | scoped_ptr<int16_t[]> decoded_buffer_ GUARDED_BY(crit_sect_); |
henrik.lundin@webrtc.org | c4c3021 | 2014-03-18 11:49:22 +0000 | [diff] [blame] | 375 | uint32_t playout_timestamp_ GUARDED_BY(crit_sect_); |
| 376 | bool new_codec_ GUARDED_BY(crit_sect_); |
| 377 | uint32_t timestamp_ GUARDED_BY(crit_sect_); |
| 378 | bool reset_decoder_ GUARDED_BY(crit_sect_); |
| 379 | uint8_t current_rtp_payload_type_ GUARDED_BY(crit_sect_); |
| 380 | uint8_t current_cng_rtp_payload_type_ GUARDED_BY(crit_sect_); |
| 381 | uint32_t ssrc_ GUARDED_BY(crit_sect_); |
| 382 | bool first_packet_ GUARDED_BY(crit_sect_); |
| 383 | int error_code_ GUARDED_BY(crit_sect_); // Store last error code. |
| 384 | int decoder_error_code_ GUARDED_BY(crit_sect_); |
| 385 | const scoped_ptr<CriticalSectionWrapper> crit_sect_; |
henrik.lundin@webrtc.org | 9a40081 | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 386 | |
minyue@webrtc.org | 42758b3 | 2013-08-29 00:58:14 +0000 | [diff] [blame] | 387 | // These values are used by NACK module to estimate time-to-play of |
| 388 | // a missing packet. Occasionally, NetEq might decide to decode more |
| 389 | // than one packet. Therefore, these values store sequence number and |
| 390 | // timestamp of the first packet pulled from the packet buffer. In |
| 391 | // such cases, these values do not exactly represent the sequence number |
| 392 | // or timestamp associated with a 10ms audio pulled from NetEq. NACK |
| 393 | // module is designed to compensate for this. |
henrik.lundin@webrtc.org | c4c3021 | 2014-03-18 11:49:22 +0000 | [diff] [blame] | 394 | int decoded_packet_sequence_number_ GUARDED_BY(crit_sect_); |
| 395 | uint32_t decoded_packet_timestamp_ GUARDED_BY(crit_sect_); |
minyue@webrtc.org | 42758b3 | 2013-08-29 00:58:14 +0000 | [diff] [blame] | 396 | |
turaj@webrtc.org | c1caa69 | 2014-04-11 18:47:55 +0000 | [diff] [blame] | 397 | private: |
henrik.lundin@webrtc.org | 9a40081 | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 398 | DISALLOW_COPY_AND_ASSIGN(NetEqImpl); |
| 399 | }; |
| 400 | |
| 401 | } // namespace webrtc |
| 402 | #endif // WEBRTC_MODULES_AUDIO_CODING_NETEQ4_NETEQ_IMPL_H_ |