| /* |
| * Copyright (c) 2013 The WebRTC project authors. All Rights Reserved. |
| * |
| * Use of this source code is governed by a BSD-style license |
| * that can be found in the LICENSE file in the root of the source |
| * tree. An additional intellectual property rights grant can be found |
| * in the file PATENTS. All contributing project authors may |
| * be found in the AUTHORS file in the root of the source tree. |
| */ |
| |
| #include "modules/audio_coding/acm2/acm_receiver.h" |
| |
| #include <stdlib.h> |
| #include <string.h> |
| #include <cstdint> |
| #include <vector> |
| |
| #include "absl/strings/match.h" |
| #include "api/audio/audio_frame.h" |
| #include "api/audio_codecs/audio_decoder.h" |
| #include "modules/audio_coding/acm2/acm_resampler.h" |
| #include "modules/audio_coding/acm2/call_statistics.h" |
| #include "modules/audio_coding/neteq/include/neteq.h" |
| #include "modules/include/module_common_types.h" |
| #include "rtc_base/checks.h" |
| #include "rtc_base/logging.h" |
| #include "rtc_base/numerics/safe_conversions.h" |
| #include "rtc_base/strings/audio_format_to_string.h" |
| #include "system_wrappers/include/clock.h" |
| |
| namespace webrtc { |
| |
| namespace acm2 { |
| |
| AcmReceiver::AcmReceiver(const AudioCodingModule::Config& config) |
| : last_audio_buffer_(new int16_t[AudioFrame::kMaxDataSizeSamples]), |
| neteq_(NetEq::Create(config.neteq_config, config.decoder_factory)), |
| clock_(config.clock), |
| resampled_last_output_frame_(true) { |
| RTC_DCHECK(clock_); |
| memset(last_audio_buffer_.get(), 0, |
| sizeof(int16_t) * AudioFrame::kMaxDataSizeSamples); |
| } |
| |
| AcmReceiver::~AcmReceiver() = default; |
| |
| int AcmReceiver::SetMinimumDelay(int delay_ms) { |
| if (neteq_->SetMinimumDelay(delay_ms)) |
| return 0; |
| RTC_LOG(LERROR) << "AcmReceiver::SetExtraDelay " << delay_ms; |
| return -1; |
| } |
| |
| int AcmReceiver::SetMaximumDelay(int delay_ms) { |
| if (neteq_->SetMaximumDelay(delay_ms)) |
| return 0; |
| RTC_LOG(LERROR) << "AcmReceiver::SetExtraDelay " << delay_ms; |
| return -1; |
| } |
| |
| absl::optional<int> AcmReceiver::last_packet_sample_rate_hz() const { |
| rtc::CritScope lock(&crit_sect_); |
| if (!last_decoder_) { |
| return absl::nullopt; |
| } |
| return last_decoder_->second.clockrate_hz; |
| } |
| |
| int AcmReceiver::last_output_sample_rate_hz() const { |
| return neteq_->last_output_sample_rate_hz(); |
| } |
| |
| int AcmReceiver::InsertPacket(const WebRtcRTPHeader& rtp_header, |
| rtc::ArrayView<const uint8_t> incoming_payload) { |
| if (incoming_payload.empty()) { |
| neteq_->InsertEmptyPacket(rtp_header.header); |
| return 0; |
| } |
| |
| const RTPHeader& header = rtp_header.header; // Just a shorthand. |
| int payload_type = header.payloadType; |
| auto format = neteq_->GetDecoderFormat(payload_type); |
| if (format && absl::EqualsIgnoreCase(format->name, "red")) { |
| // This is a RED packet. Get the format of the audio codec. |
| payload_type = incoming_payload[0] & 0x7f; |
| format = neteq_->GetDecoderFormat(payload_type); |
| } |
| if (!format) { |
| RTC_LOG_F(LS_ERROR) << "Payload-type " |
| << payload_type |
| << " is not registered."; |
| return -1; |
| } |
| |
| { |
| rtc::CritScope lock(&crit_sect_); |
| if (absl::EqualsIgnoreCase(format->name, "cn")) { |
| if (last_decoder_ && last_decoder_->second.num_channels > 1) { |
| // This is a CNG and the audio codec is not mono, so skip pushing in |
| // packets into NetEq. |
| return 0; |
| } |
| } else { |
| RTC_DCHECK(format); |
| last_decoder_ = std::make_pair(payload_type, *format); |
| } |
| } // |crit_sect_| is released. |
| |
| uint32_t receive_timestamp = NowInTimestamp(format->clockrate_hz); |
| if (neteq_->InsertPacket(header, incoming_payload, receive_timestamp) < 0) { |
| RTC_LOG(LERROR) << "AcmReceiver::InsertPacket " |
| << static_cast<int>(header.payloadType) |
| << " Failed to insert packet"; |
| return -1; |
| } |
| return 0; |
| } |
| |
| int AcmReceiver::GetAudio(int desired_freq_hz, |
| AudioFrame* audio_frame, |
| bool* muted) { |
| RTC_DCHECK(muted); |
| // Accessing members, take the lock. |
| rtc::CritScope lock(&crit_sect_); |
| |
| if (neteq_->GetAudio(audio_frame, muted) != NetEq::kOK) { |
| RTC_LOG(LERROR) << "AcmReceiver::GetAudio - NetEq Failed."; |
| return -1; |
| } |
| |
| const int current_sample_rate_hz = neteq_->last_output_sample_rate_hz(); |
| |
| // Update if resampling is required. |
| const bool need_resampling = |
| (desired_freq_hz != -1) && (current_sample_rate_hz != desired_freq_hz); |
| |
| if (need_resampling && !resampled_last_output_frame_) { |
| // Prime the resampler with the last frame. |
| int16_t temp_output[AudioFrame::kMaxDataSizeSamples]; |
| int samples_per_channel_int = resampler_.Resample10Msec( |
| last_audio_buffer_.get(), current_sample_rate_hz, desired_freq_hz, |
| audio_frame->num_channels_, AudioFrame::kMaxDataSizeSamples, |
| temp_output); |
| if (samples_per_channel_int < 0) { |
| RTC_LOG(LERROR) << "AcmReceiver::GetAudio - " |
| "Resampling last_audio_buffer_ failed."; |
| return -1; |
| } |
| } |
| |
| // TODO(henrik.lundin) Glitches in the output may appear if the output rate |
| // from NetEq changes. See WebRTC issue 3923. |
| if (need_resampling) { |
| // TODO(yujo): handle this more efficiently for muted frames. |
| int samples_per_channel_int = resampler_.Resample10Msec( |
| audio_frame->data(), current_sample_rate_hz, desired_freq_hz, |
| audio_frame->num_channels_, AudioFrame::kMaxDataSizeSamples, |
| audio_frame->mutable_data()); |
| if (samples_per_channel_int < 0) { |
| RTC_LOG(LERROR) |
| << "AcmReceiver::GetAudio - Resampling audio_buffer_ failed."; |
| return -1; |
| } |
| audio_frame->samples_per_channel_ = |
| static_cast<size_t>(samples_per_channel_int); |
| audio_frame->sample_rate_hz_ = desired_freq_hz; |
| RTC_DCHECK_EQ( |
| audio_frame->sample_rate_hz_, |
| rtc::dchecked_cast<int>(audio_frame->samples_per_channel_ * 100)); |
| resampled_last_output_frame_ = true; |
| } else { |
| resampled_last_output_frame_ = false; |
| // We might end up here ONLY if codec is changed. |
| } |
| |
| // Store current audio in |last_audio_buffer_| for next time. |
| memcpy(last_audio_buffer_.get(), audio_frame->data(), |
| sizeof(int16_t) * audio_frame->samples_per_channel_ * |
| audio_frame->num_channels_); |
| |
| call_stats_.DecodedByNetEq(audio_frame->speech_type_, *muted); |
| return 0; |
| } |
| |
| void AcmReceiver::SetCodecs(const std::map<int, SdpAudioFormat>& codecs) { |
| neteq_->SetCodecs(codecs); |
| } |
| |
| void AcmReceiver::FlushBuffers() { |
| neteq_->FlushBuffers(); |
| } |
| |
| void AcmReceiver::RemoveAllCodecs() { |
| rtc::CritScope lock(&crit_sect_); |
| neteq_->RemoveAllPayloadTypes(); |
| last_decoder_ = absl::nullopt; |
| } |
| |
| absl::optional<uint32_t> AcmReceiver::GetPlayoutTimestamp() { |
| return neteq_->GetPlayoutTimestamp(); |
| } |
| |
| int AcmReceiver::FilteredCurrentDelayMs() const { |
| return neteq_->FilteredCurrentDelayMs(); |
| } |
| |
| int AcmReceiver::TargetDelayMs() const { |
| return neteq_->TargetDelayMs(); |
| } |
| |
| absl::optional<std::pair<int, SdpAudioFormat>> |
| AcmReceiver::LastDecoder() const { |
| rtc::CritScope lock(&crit_sect_); |
| if (!last_decoder_) { |
| return absl::nullopt; |
| } |
| RTC_DCHECK_NE(-1, last_decoder_->first); // Payload type should be valid. |
| return last_decoder_; |
| } |
| |
| void AcmReceiver::GetNetworkStatistics(NetworkStatistics* acm_stat) { |
| NetEqNetworkStatistics neteq_stat; |
| // NetEq function always returns zero, so we don't check the return value. |
| neteq_->NetworkStatistics(&neteq_stat); |
| |
| acm_stat->currentBufferSize = neteq_stat.current_buffer_size_ms; |
| acm_stat->preferredBufferSize = neteq_stat.preferred_buffer_size_ms; |
| acm_stat->jitterPeaksFound = neteq_stat.jitter_peaks_found ? true : false; |
| acm_stat->currentPacketLossRate = neteq_stat.packet_loss_rate; |
| acm_stat->currentExpandRate = neteq_stat.expand_rate; |
| acm_stat->currentSpeechExpandRate = neteq_stat.speech_expand_rate; |
| acm_stat->currentPreemptiveRate = neteq_stat.preemptive_rate; |
| acm_stat->currentAccelerateRate = neteq_stat.accelerate_rate; |
| acm_stat->currentSecondaryDecodedRate = neteq_stat.secondary_decoded_rate; |
| acm_stat->currentSecondaryDiscardedRate = neteq_stat.secondary_discarded_rate; |
| acm_stat->clockDriftPPM = neteq_stat.clockdrift_ppm; |
| acm_stat->addedSamples = neteq_stat.added_zero_samples; |
| acm_stat->meanWaitingTimeMs = neteq_stat.mean_waiting_time_ms; |
| acm_stat->medianWaitingTimeMs = neteq_stat.median_waiting_time_ms; |
| acm_stat->minWaitingTimeMs = neteq_stat.min_waiting_time_ms; |
| acm_stat->maxWaitingTimeMs = neteq_stat.max_waiting_time_ms; |
| |
| NetEqLifetimeStatistics neteq_lifetime_stat = neteq_->GetLifetimeStatistics(); |
| acm_stat->totalSamplesReceived = neteq_lifetime_stat.total_samples_received; |
| acm_stat->concealedSamples = neteq_lifetime_stat.concealed_samples; |
| acm_stat->concealmentEvents = neteq_lifetime_stat.concealment_events; |
| acm_stat->jitterBufferDelayMs = neteq_lifetime_stat.jitter_buffer_delay_ms; |
| acm_stat->delayedPacketOutageSamples = |
| neteq_lifetime_stat.delayed_packet_outage_samples; |
| |
| NetEqOperationsAndState neteq_operations_and_state = |
| neteq_->GetOperationsAndState(); |
| acm_stat->packetBufferFlushes = |
| neteq_operations_and_state.packet_buffer_flushes; |
| } |
| |
| int AcmReceiver::EnableNack(size_t max_nack_list_size) { |
| neteq_->EnableNack(max_nack_list_size); |
| return 0; |
| } |
| |
| void AcmReceiver::DisableNack() { |
| neteq_->DisableNack(); |
| } |
| |
| std::vector<uint16_t> AcmReceiver::GetNackList( |
| int64_t round_trip_time_ms) const { |
| return neteq_->GetNackList(round_trip_time_ms); |
| } |
| |
| void AcmReceiver::ResetInitialDelay() { |
| neteq_->SetMinimumDelay(0); |
| // TODO(turajs): Should NetEq Buffer be flushed? |
| } |
| |
| uint32_t AcmReceiver::NowInTimestamp(int decoder_sampling_rate) const { |
| // Down-cast the time to (32-6)-bit since we only care about |
| // the least significant bits. (32-6) bits cover 2^(32-6) = 67108864 ms. |
| // We masked 6 most significant bits of 32-bit so there is no overflow in |
| // the conversion from milliseconds to timestamp. |
| const uint32_t now_in_ms = |
| static_cast<uint32_t>(clock_->TimeInMilliseconds() & 0x03ffffff); |
| return static_cast<uint32_t>((decoder_sampling_rate / 1000) * now_in_ms); |
| } |
| |
| void AcmReceiver::GetDecodingCallStatistics( |
| AudioDecodingCallStats* stats) const { |
| rtc::CritScope lock(&crit_sect_); |
| *stats = call_stats_.GetDecodingStatistics(); |
| } |
| |
| } // namespace acm2 |
| |
| } // namespace webrtc |