generic-library/webrtc
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

NetEq4: Making a few more members scoped_ptrs

Browse Source 
This CL converts a few members in NetEqImpl form regular pointers
to scoped_ptrs.

R=andrew@webrtc.org

Review URL: https://webrtc-codereview.appspot.com/2245004

git-svn-id: http://webrtc.googlecode.com/svn/trunk@4783 4adac7df-926f-26a2-2b94-8c16560cd09d
This commit is contained in:
henrik.lundin@webrtc.org
2013-09-18 21:12:38 +00:00
parent 5a43370cdb
commit 0d5da25e6c
2 changed files with 55 additions and 76 deletions
Download Patch File Download Diff File Expand all files Collapse all files

117
webrtc/modules/audio_coding/neteq4/neteq_impl.cc
View File

@@ -117,19 +117,13 @@ NetEqImpl::NetEqImpl(int fs,
NetEqImpl::~NetEqImpl() { NetEqImpl::~NetEqImpl() {
LOG(LS_INFO) << "Deleting NetEqImpl object."; LOG(LS_INFO) << "Deleting NetEqImpl object.";
delete algorithm_buffer_;
delete sync_buffer_;
delete background_noise_;
delete expand_;
delete comfort_noise_;
delete crit_sect_;
} }
int NetEqImpl::InsertPacket(const WebRtcRTPHeader& rtp_header, int NetEqImpl::InsertPacket(const WebRtcRTPHeader& rtp_header,
const uint8_t* payload, const uint8_t* payload,
int length_bytes, int length_bytes,
uint32_t receive_timestamp) { uint32_t receive_timestamp) {
CriticalSectionScoped lock(crit_sect_); CriticalSectionScoped lock(crit_sect_.get());
NETEQ_LOG_VERBOSE << "InsertPacket: ts=" << rtp_header.header.timestamp << NETEQ_LOG_VERBOSE << "InsertPacket: ts=" << rtp_header.header.timestamp <<
", sn=" << rtp_header.header.sequenceNumber << ", sn=" << rtp_header.header.sequenceNumber <<
", pt=" << static_cast<int>(rtp_header.header.payloadType) << ", pt=" << static_cast<int>(rtp_header.header.payloadType) <<
@@ -148,7 +142,7 @@ int NetEqImpl::InsertPacket(const WebRtcRTPHeader& rtp_header,
int NetEqImpl::GetAudio(size_t max_length, int16_t* output_audio, int NetEqImpl::GetAudio(size_t max_length, int16_t* output_audio,
int* samples_per_channel, int* num_channels, int* samples_per_channel, int* num_channels,
NetEqOutputType* type) { NetEqOutputType* type) {
CriticalSectionScoped lock(crit_sect_); CriticalSectionScoped lock(crit_sect_.get());
NETEQ_LOG_VERBOSE << "GetAudio"; NETEQ_LOG_VERBOSE << "GetAudio";
int error = GetAudioInternal(max_length, output_audio, samples_per_channel, int error = GetAudioInternal(max_length, output_audio, samples_per_channel,
num_channels); num_channels);
@@ -167,7 +161,7 @@ int NetEqImpl::GetAudio(size_t max_length, int16_t* output_audio,
int NetEqImpl::RegisterPayloadType(enum NetEqDecoder codec, int NetEqImpl::RegisterPayloadType(enum NetEqDecoder codec,
uint8_t rtp_payload_type) { uint8_t rtp_payload_type) {
CriticalSectionScoped lock(crit_sect_); CriticalSectionScoped lock(crit_sect_.get());
LOG_API2(static_cast<int>(rtp_payload_type), codec); LOG_API2(static_cast<int>(rtp_payload_type), codec);
int ret = decoder_database_->RegisterPayload(rtp_payload_type, codec); int ret = decoder_database_->RegisterPayload(rtp_payload_type, codec);
if (ret != DecoderDatabase::kOK) { if (ret != DecoderDatabase::kOK) {
@@ -194,7 +188,7 @@ int NetEqImpl::RegisterExternalDecoder(AudioDecoder* decoder,
enum NetEqDecoder codec, enum NetEqDecoder codec,
int sample_rate_hz, int sample_rate_hz,
uint8_t rtp_payload_type) { uint8_t rtp_payload_type) {
CriticalSectionScoped lock(crit_sect_); CriticalSectionScoped lock(crit_sect_.get());
LOG_API2(static_cast<int>(rtp_payload_type), codec); LOG_API2(static_cast<int>(rtp_payload_type), codec);
if (!decoder) { if (!decoder) {
LOG(LS_ERROR) << "Cannot register external decoder with NULL pointer"; LOG(LS_ERROR) << "Cannot register external decoder with NULL pointer";
@@ -230,7 +224,7 @@ int NetEqImpl::RegisterExternalDecoder(AudioDecoder* decoder,
} }
int NetEqImpl::RemovePayloadType(uint8_t rtp_payload_type) { int NetEqImpl::RemovePayloadType(uint8_t rtp_payload_type) {
CriticalSectionScoped lock(crit_sect_); CriticalSectionScoped lock(crit_sect_.get());
LOG_API1(static_cast<int>(rtp_payload_type)); LOG_API1(static_cast<int>(rtp_payload_type));
int ret = decoder_database_->Remove(rtp_payload_type); int ret = decoder_database_->Remove(rtp_payload_type);
if (ret == DecoderDatabase::kOK) { if (ret == DecoderDatabase::kOK) {
@@ -245,7 +239,7 @@ int NetEqImpl::RemovePayloadType(uint8_t rtp_payload_type) {
} }
bool NetEqImpl::SetMinimumDelay(int delay_ms) { bool NetEqImpl::SetMinimumDelay(int delay_ms) {
CriticalSectionScoped lock(crit_sect_); CriticalSectionScoped lock(crit_sect_.get());
if (delay_ms >= 0 && delay_ms < 10000) { if (delay_ms >= 0 && delay_ms < 10000) {
assert(delay_manager_.get()); assert(delay_manager_.get());
return delay_manager_->SetMinimumDelay(delay_ms); return delay_manager_->SetMinimumDelay(delay_ms);
@@ -254,7 +248,7 @@ bool NetEqImpl::SetMinimumDelay(int delay_ms) {
} }
bool NetEqImpl::SetMaximumDelay(int delay_ms) { bool NetEqImpl::SetMaximumDelay(int delay_ms) {
CriticalSectionScoped lock(crit_sect_); CriticalSectionScoped lock(crit_sect_.get());
if (delay_ms >= 0 && delay_ms < 10000) { if (delay_ms >= 0 && delay_ms < 10000) {
assert(delay_manager_.get()); assert(delay_manager_.get());
return delay_manager_->SetMaximumDelay(delay_ms); return delay_manager_->SetMaximumDelay(delay_ms);
@@ -263,13 +257,13 @@ bool NetEqImpl::SetMaximumDelay(int delay_ms) {
} }
int NetEqImpl::LeastRequiredDelayMs() const { int NetEqImpl::LeastRequiredDelayMs() const {
CriticalSectionScoped lock(crit_sect_); CriticalSectionScoped lock(crit_sect_.get());
assert(delay_manager_.get()); assert(delay_manager_.get());
return delay_manager_->least_required_delay_ms(); return delay_manager_->least_required_delay_ms();
} }
void NetEqImpl::SetPlayoutMode(NetEqPlayoutMode mode) { void NetEqImpl::SetPlayoutMode(NetEqPlayoutMode mode) {
CriticalSectionScoped lock(crit_sect_); CriticalSectionScoped lock(crit_sect_.get());
if (!decision_logic_.get() || mode != decision_logic_->playout_mode()) { if (!decision_logic_.get() || mode != decision_logic_->playout_mode()) {
// The reset() method calls delete for the old object. // The reset() method calls delete for the old object.
decision_logic_.reset(DecisionLogic::Create(fs_hz_, output_size_samples_, decision_logic_.reset(DecisionLogic::Create(fs_hz_, output_size_samples_,
@@ -282,13 +276,13 @@ void NetEqImpl::SetPlayoutMode(NetEqPlayoutMode mode) {
} }
NetEqPlayoutMode NetEqImpl::PlayoutMode() const { NetEqPlayoutMode NetEqImpl::PlayoutMode() const {
CriticalSectionScoped lock(crit_sect_); CriticalSectionScoped lock(crit_sect_.get());
assert(decision_logic_.get()); assert(decision_logic_.get());
return decision_logic_->playout_mode(); return decision_logic_->playout_mode();
} }
int NetEqImpl::NetworkStatistics(NetEqNetworkStatistics* stats) { int NetEqImpl::NetworkStatistics(NetEqNetworkStatistics* stats) {
CriticalSectionScoped lock(crit_sect_); CriticalSectionScoped lock(crit_sect_.get());
assert(decoder_database_.get()); assert(decoder_database_.get());
const int total_samples_in_buffers = packet_buffer_->NumSamplesInBuffer( const int total_samples_in_buffers = packet_buffer_->NumSamplesInBuffer(
decoder_database_.get(), decoder_frame_length_) + decoder_database_.get(), decoder_frame_length_) +
@@ -302,57 +296,57 @@ int NetEqImpl::NetworkStatistics(NetEqNetworkStatistics* stats) {
} }
void NetEqImpl::WaitingTimes(std::vector<int>* waiting_times) { void NetEqImpl::WaitingTimes(std::vector<int>* waiting_times) {
CriticalSectionScoped lock(crit_sect_); CriticalSectionScoped lock(crit_sect_.get());
stats_.WaitingTimes(waiting_times); stats_.WaitingTimes(waiting_times);
} }
void NetEqImpl::GetRtcpStatistics(RtcpStatistics* stats) { void NetEqImpl::GetRtcpStatistics(RtcpStatistics* stats) {
CriticalSectionScoped lock(crit_sect_); CriticalSectionScoped lock(crit_sect_.get());
if (stats) { if (stats) {
rtcp_.GetStatistics(false, stats); rtcp_.GetStatistics(false, stats);
} }
} }
void NetEqImpl::GetRtcpStatisticsNoReset(RtcpStatistics* stats) { void NetEqImpl::GetRtcpStatisticsNoReset(RtcpStatistics* stats) {
CriticalSectionScoped lock(crit_sect_); CriticalSectionScoped lock(crit_sect_.get());
if (stats) { if (stats) {
rtcp_.GetStatistics(true, stats); rtcp_.GetStatistics(true, stats);
} }
} }
void NetEqImpl::EnableVad() { void NetEqImpl::EnableVad() {
CriticalSectionScoped lock(crit_sect_); CriticalSectionScoped lock(crit_sect_.get());
assert(vad_.get()); assert(vad_.get());
vad_->Enable(); vad_->Enable();
} }
void NetEqImpl::DisableVad() { void NetEqImpl::DisableVad() {
CriticalSectionScoped lock(crit_sect_); CriticalSectionScoped lock(crit_sect_.get());
assert(vad_.get()); assert(vad_.get());
vad_->Disable(); vad_->Disable();
} }
uint32_t NetEqImpl::PlayoutTimestamp() { uint32_t NetEqImpl::PlayoutTimestamp() {
CriticalSectionScoped lock(crit_sect_); CriticalSectionScoped lock(crit_sect_.get());
return timestamp_scaler_->ToExternal(playout_timestamp_); return timestamp_scaler_->ToExternal(playout_timestamp_);
} }
int NetEqImpl::LastError() { int NetEqImpl::LastError() {
CriticalSectionScoped lock(crit_sect_); CriticalSectionScoped lock(crit_sect_.get());
return error_code_; return error_code_;
} }
int NetEqImpl::LastDecoderError() { int NetEqImpl::LastDecoderError() {
CriticalSectionScoped lock(crit_sect_); CriticalSectionScoped lock(crit_sect_.get());
return decoder_error_code_; return decoder_error_code_;
} }
void NetEqImpl::FlushBuffers() { void NetEqImpl::FlushBuffers() {
CriticalSectionScoped lock(crit_sect_); CriticalSectionScoped lock(crit_sect_.get());
LOG_API0(); LOG_API0();
packet_buffer_->Flush(); packet_buffer_->Flush();
assert(sync_buffer_); assert(sync_buffer_.get());
assert(expand_); assert(expand_.get());
sync_buffer_->Flush(); sync_buffer_->Flush();
sync_buffer_->set_next_index(sync_buffer_->next_index() - sync_buffer_->set_next_index(sync_buffer_->next_index() -
expand_->overlap_length()); expand_->overlap_length());
@@ -364,13 +358,13 @@ void NetEqImpl::PacketBufferStatistics(int* current_num_packets,
int* max_num_packets, int* max_num_packets,
int* current_memory_size_bytes, int* current_memory_size_bytes,
int* max_memory_size_bytes) const { int* max_memory_size_bytes) const {
CriticalSectionScoped lock(crit_sect_); CriticalSectionScoped lock(crit_sect_.get());
packet_buffer_->BufferStat(current_num_packets, max_num_packets, packet_buffer_->BufferStat(current_num_packets, max_num_packets,
current_memory_size_bytes, max_memory_size_bytes); current_memory_size_bytes, max_memory_size_bytes);
} }
int NetEqImpl::DecodedRtpInfo(int* sequence_number, uint32_t* timestamp) { int NetEqImpl::DecodedRtpInfo(int* sequence_number, uint32_t* timestamp) {
CriticalSectionScoped lock(crit_sect_); CriticalSectionScoped lock(crit_sect_.get());
if (decoded_packet_sequence_number_ < 0) if (decoded_packet_sequence_number_ < 0)
return -1; return -1;
*sequence_number = decoded_packet_sequence_number_; *sequence_number = decoded_packet_sequence_number_;
@@ -799,7 +793,7 @@ int NetEqImpl::GetDecision(Operations* operation,
packet_buffer_->IncrementWaitingTimes(); packet_buffer_->IncrementWaitingTimes();
stats_.IncreaseCounter(output_size_samples_, fs_hz_); stats_.IncreaseCounter(output_size_samples_, fs_hz_);
assert(sync_buffer_); assert(sync_buffer_.get());
uint32_t end_timestamp = sync_buffer_->end_timestamp(); uint32_t end_timestamp = sync_buffer_->end_timestamp();
if (!new_codec_) { if (!new_codec_) {
packet_buffer_->DiscardOldPackets(end_timestamp); packet_buffer_->DiscardOldPackets(end_timestamp);
@@ -826,7 +820,7 @@ int NetEqImpl::GetDecision(Operations* operation,
} }
} }
assert(expand_); assert(expand_.get());
const int samples_left = sync_buffer_->FutureLength() - const int samples_left = sync_buffer_->FutureLength() -
expand_->overlap_length(); expand_->overlap_length();
if (last_mode_ == kModeAccelerateSuccess || if (last_mode_ == kModeAccelerateSuccess ||
@@ -845,8 +839,8 @@ int NetEqImpl::GetDecision(Operations* operation,
} }
// Get instruction. // Get instruction.
assert(sync_buffer_); assert(sync_buffer_.get());
assert(expand_); assert(expand_.get());
*operation = decision_logic_->GetDecision(*sync_buffer_, *operation = decision_logic_->GetDecision(*sync_buffer_,
*expand_, *expand_,
decoder_frame_length_, decoder_frame_length_,
@@ -1223,7 +1217,7 @@ void NetEqImpl::DoNormal(const int16_t* decoded_buffer, size_t decoded_length,
assert(normal_.get()); assert(normal_.get());
assert(mute_factor_array_.get()); assert(mute_factor_array_.get());
normal_->Process(decoded_buffer, decoded_length, last_mode_, normal_->Process(decoded_buffer, decoded_length, last_mode_,
mute_factor_array_.get(), algorithm_buffer_); mute_factor_array_.get(), algorithm_buffer_.get());
if (decoded_length != 0) { if (decoded_length != 0) {
last_mode_ = kModeNormal; last_mode_ = kModeNormal;
} }
@@ -1246,7 +1240,8 @@ void NetEqImpl::DoMerge(int16_t* decoded_buffer, size_t decoded_length,
assert(mute_factor_array_.get()); assert(mute_factor_array_.get());
assert(merge_.get()); assert(merge_.get());
int new_length = merge_->Process(decoded_buffer, decoded_length, int new_length = merge_->Process(decoded_buffer, decoded_length,
mute_factor_array_.get(), algorithm_buffer_); mute_factor_array_.get(),
algorithm_buffer_.get());
// Update in-call and post-call statistics. // Update in-call and post-call statistics.
if (expand_->MuteFactor(0) == 0) { if (expand_->MuteFactor(0) == 0) {
@@ -1272,7 +1267,7 @@ int NetEqImpl::DoExpand(bool play_dtmf) {
while ((sync_buffer_->FutureLength() - expand_->overlap_length()) < while ((sync_buffer_->FutureLength() - expand_->overlap_length()) <
static_cast<size_t>(output_size_samples_)) { static_cast<size_t>(output_size_samples_)) {
algorithm_buffer_->Clear(); algorithm_buffer_->Clear();
int return_value = expand_->Process(algorithm_buffer_); int return_value = expand_->Process(algorithm_buffer_.get());
int length = algorithm_buffer_->Size(); int length = algorithm_buffer_->Size();
// Update in-call and post-call statistics. // Update in-call and post-call statistics.
@@ -1319,9 +1314,8 @@ int NetEqImpl::DoAccelerate(int16_t* decoded_buffer, size_t decoded_length,
} }
int16_t samples_removed; int16_t samples_removed;
Accelerate::ReturnCodes return_code = accelerate_->Process(decoded_buffer, Accelerate::ReturnCodes return_code = accelerate_->Process(
decoded_length, decoded_buffer, decoded_length, algorithm_buffer_.get(),
algorithm_buffer_,
&samples_removed); &samples_removed);
stats_.AcceleratedSamples(samples_removed); stats_.AcceleratedSamples(samples_removed);
switch (return_code) { switch (return_code) {
@@ -1401,7 +1395,7 @@ int NetEqImpl::DoPreemptiveExpand(int16_t* decoded_buffer,
int16_t samples_added; int16_t samples_added;
PreemptiveExpand::ReturnCodes return_code = preemptive_expand_->Process( PreemptiveExpand::ReturnCodes return_code = preemptive_expand_->Process(
decoded_buffer, decoded_length, old_borrowed_samples_per_channel, decoded_buffer, decoded_length, old_borrowed_samples_per_channel,
algorithm_buffer_, &samples_added); algorithm_buffer_.get(), &samples_added);
stats_.PreemptiveExpandedSamples(samples_added); stats_.PreemptiveExpandedSamples(samples_added);
switch (return_code) { switch (return_code) {
case PreemptiveExpand::kSuccess: case PreemptiveExpand::kSuccess:
@@ -1478,7 +1472,7 @@ int NetEqImpl::DoRfc3389Cng(PacketList* packet_list, bool play_dtmf) {
} }
} }
int cn_return = comfort_noise_->Generate(output_size_samples_, int cn_return = comfort_noise_->Generate(output_size_samples_,
algorithm_buffer_); algorithm_buffer_.get());
expand_->Reset(); expand_->Reset();
last_mode_ = kModeRfc3389Cng; last_mode_ = kModeRfc3389Cng;
if (!play_dtmf) { if (!play_dtmf) {
@@ -1507,7 +1501,7 @@ void NetEqImpl::DoCodecInternalCng() {
} }
assert(mute_factor_array_.get()); assert(mute_factor_array_.get());
normal_->Process(decoded_buffer, length, last_mode_, mute_factor_array_.get(), normal_->Process(decoded_buffer, length, last_mode_, mute_factor_array_.get(),
algorithm_buffer_); algorithm_buffer_.get());
last_mode_ = kModeCodecInternalCng; last_mode_ = kModeCodecInternalCng;
expand_->Reset(); expand_->Reset();
} }
@@ -1540,7 +1534,7 @@ int NetEqImpl::DoDtmf(const DtmfEvent& dtmf_event, bool* play_dtmf) {
if (dtmf_return_value == 0) { if (dtmf_return_value == 0) {
// Generate DTMF signal. // Generate DTMF signal.
dtmf_return_value = dtmf_tone_generator_->Generate(output_size_samples_, dtmf_return_value = dtmf_tone_generator_->Generate(output_size_samples_,
algorithm_buffer_); algorithm_buffer_.get());
} }
if (dtmf_return_value < 0) { if (dtmf_return_value < 0) {
@@ -1756,49 +1750,34 @@ void NetEqImpl::SetSampleRateAndChannels(int fs_hz, size_t channels) {
vad_->Init(); vad_->Init();
// Delete algorithm buffer and create a new one. // Delete algorithm buffer and create a new one.
if (algorithm_buffer_) { algorithm_buffer_.reset(new AudioMultiVector<int16_t>(channels));
delete algorithm_buffer_;
}
algorithm_buffer_ = new AudioMultiVector<int16_t>(channels);
// Delete sync buffer and create a new one. // Delete sync buffer and create a new one.
if (sync_buffer_) { sync_buffer_.reset(new SyncBuffer(channels, kSyncBufferSize * fs_mult_));
delete sync_buffer_;
}
sync_buffer_ = new SyncBuffer(channels, kSyncBufferSize * fs_mult_);
// Delete BackgroundNoise object and create a new one. // Delete BackgroundNoise object and create a new one.
if (background_noise_) { background_noise_.reset(new BackgroundNoise(channels));
delete background_noise_;
}
background_noise_ = new BackgroundNoise(channels);
// Reset random vector. // Reset random vector.
random_vector_.Reset(); random_vector_.Reset();
// Delete Expand object and create a new one. // Delete Expand object and create a new one.
if (expand_) { expand_.reset(new Expand(background_noise_.get(), sync_buffer_.get(),
delete expand_; &random_vector_, fs_hz, channels));
}
expand_ = new Expand(background_noise_, sync_buffer_, &random_vector_, fs_hz,
channels);
// Move index so that we create a small set of future samples (all 0). // Move index so that we create a small set of future samples (all 0).
sync_buffer_->set_next_index(sync_buffer_->next_index() - sync_buffer_->set_next_index(sync_buffer_->next_index() -
expand_->overlap_length()); expand_->overlap_length());
normal_.reset(new Normal(fs_hz, decoder_database_.get(), *background_noise_, normal_.reset(new Normal(fs_hz, decoder_database_.get(), *background_noise_,
expand_)); expand_.get()));
merge_.reset(new Merge(fs_hz, channels, expand_, sync_buffer_)); merge_.reset(new Merge(fs_hz, channels, expand_.get(), sync_buffer_.get()));
accelerate_.reset(new Accelerate(fs_hz, channels, *background_noise_)); accelerate_.reset(new Accelerate(fs_hz, channels, *background_noise_));
preemptive_expand_.reset(new PreemptiveExpand(fs_hz, channels, preemptive_expand_.reset(new PreemptiveExpand(fs_hz, channels,
*background_noise_)); *background_noise_));
// Delete ComfortNoise object and create a new one. // Delete ComfortNoise object and create a new one.
if (comfort_noise_) { comfort_noise_.reset(new ComfortNoise(fs_hz, decoder_database_.get(),
delete comfort_noise_; sync_buffer_.get()));
}
comfort_noise_ = new ComfortNoise(fs_hz, decoder_database_.get(),
sync_buffer_);
// Verify that |decoded_buffer_| is long enough. // Verify that |decoded_buffer_| is long enough.
if (decoded_buffer_length_ < kMaxFrameSize * channels) { if (decoded_buffer_length_ < kMaxFrameSize * channels) {
@@ -1814,7 +1793,7 @@ void NetEqImpl::SetSampleRateAndChannels(int fs_hz, size_t channels) {
NetEqOutputType NetEqImpl::LastOutputType() { NetEqOutputType NetEqImpl::LastOutputType() {
assert(vad_.get()); assert(vad_.get());
assert(expand_); assert(expand_.get());
if (last_mode_ == kModeCodecInternalCng || last_mode_ == kModeRfc3389Cng) { if (last_mode_ == kModeCodecInternalCng || last_mode_ == kModeRfc3389Cng) {
return kOutputCNG; return kOutputCNG;
} else if (vad_->running() && !vad_->active_speech()) { } else if (vad_->running() && !vad_->active_speech()) {

12
webrtc/modules/audio_coding/neteq4/neteq_impl.h
View File

@@ -288,7 +288,7 @@ class NetEqImpl : public webrtc::NetEq {
// GetAudio(). // GetAudio().
NetEqOutputType LastOutputType(); NetEqOutputType LastOutputType();
BackgroundNoise* background_noise_; scoped_ptr<BackgroundNoise> background_noise_;
scoped_ptr<BufferLevelFilter> buffer_level_filter_; scoped_ptr<BufferLevelFilter> buffer_level_filter_;
scoped_ptr<DecoderDatabase> decoder_database_; scoped_ptr<DecoderDatabase> decoder_database_;
scoped_ptr<DelayManager> delay_manager_; scoped_ptr<DelayManager> delay_manager_;
@@ -300,15 +300,15 @@ class NetEqImpl : public webrtc::NetEq {
scoped_ptr<TimestampScaler> timestamp_scaler_; scoped_ptr<TimestampScaler> timestamp_scaler_;
scoped_ptr<DecisionLogic> decision_logic_; scoped_ptr<DecisionLogic> decision_logic_;
scoped_ptr<PostDecodeVad> vad_; scoped_ptr<PostDecodeVad> vad_;
AudioMultiVector<int16_t>* algorithm_buffer_; scoped_ptr<AudioMultiVector<int16_t> > algorithm_buffer_;
SyncBuffer* sync_buffer_; scoped_ptr<SyncBuffer> sync_buffer_;
Expand* expand_; scoped_ptr<Expand> expand_;
scoped_ptr<Normal> normal_; scoped_ptr<Normal> normal_;
scoped_ptr<Merge> merge_; scoped_ptr<Merge> merge_;
scoped_ptr<Accelerate> accelerate_; scoped_ptr<Accelerate> accelerate_;
scoped_ptr<PreemptiveExpand> preemptive_expand_; scoped_ptr<PreemptiveExpand> preemptive_expand_;
RandomVector random_vector_; RandomVector random_vector_;
ComfortNoise* comfort_noise_; scoped_ptr<ComfortNoise> comfort_noise_;
Rtcp rtcp_; Rtcp rtcp_;
StatisticsCalculator stats_; StatisticsCalculator stats_;
int fs_hz_; int fs_hz_;
@@ -329,7 +329,7 @@ class NetEqImpl : public webrtc::NetEq {
bool first_packet_; bool first_packet_;
int error_code_; // Store last error code. int error_code_; // Store last error code.
int decoder_error_code_; int decoder_error_code_;
CriticalSectionWrapper* crit_sect_; scoped_ptr<CriticalSectionWrapper> crit_sect_;
// These values are used by NACK module to estimate time-to-play of // These values are used by NACK module to estimate time-to-play of
// a missing packet. Occasionally, NetEq might decide to decode more // a missing packet. Occasionally, NetEq might decide to decode more