From b93af8543df5e4eb64a449b7c8f710f422ab3128 Mon Sep 17 00:00:00 2001 From: Jakob Ivarsson Date: Thu, 27 Jun 2019 08:07:06 +0000 Subject: [PATCH] Revert "Reland "Change buffer level filter to store current level in number of samples."" This reverts commit 0ded32d5a3d7acb9a00c3a1d9941e539aa94eee5. Reason for revert: breaks downstream projects. Original change's description: > Reland "Change buffer level filter to store current level in number of samples." > > This is a reland of 87977dd06e702ed517f26235c12e37bd927527c7 > > Original change's description: > > Change buffer level filter to store current level in number of samples. > > > > The buffer level should not be converted back and forth between samples and packets in case of variable packet lengths. > > > > Bug: webrtc:10736 > > Change-Id: Ia08dcfac3d8104dc79fbad0704a5f6f12a050a01 > > Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/142178 > > Reviewed-by: Minyue Li > > Commit-Queue: Jakob Ivarsson > > Cr-Commit-Position: refs/heads/master@{#28368} > > Bug: webrtc:10736 > Change-Id: I1ff603e65cdd31c7429f36b035dcc00a17b68f3b > Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/143787 > Commit-Queue: Minyue Li > Reviewed-by: Minyue Li > Cr-Commit-Position: refs/heads/master@{#28393} TBR=henrik.lundin@webrtc.org,minyue@webrtc.org,jakobi@webrtc.org Change-Id: I570c83ec3a88a24d7a1f883a351748dd71bea015 No-Presubmit: true No-Tree-Checks: true No-Try: true Bug: webrtc:10736 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/144022 Reviewed-by: Jakob Ivarsson Commit-Queue: Jakob Ivarsson Cr-Commit-Position: refs/heads/master@{#28397} --- .../acm2/audio_coding_module_unittest.cc | 50 +++++------ .../audio_coding/neteq/buffer_level_filter.cc | 34 +++++--- .../audio_coding/neteq/buffer_level_filter.h | 20 ++--- .../neteq/buffer_level_filter_unittest.cc | 85 ++++++++++++++----- modules/audio_coding/neteq/decision_logic.cc | 51 +++++------ modules/audio_coding/neteq/decision_logic.h | 4 +- .../neteq/mock/mock_buffer_level_filter.h | 6 +- modules/audio_coding/neteq/neteq_impl.cc | 14 ++- modules/audio_coding/neteq/neteq_unittest.cc | 34 ++++---- 9 files changed, 184 insertions(+), 114 deletions(-) diff --git a/modules/audio_coding/acm2/audio_coding_module_unittest.cc b/modules/audio_coding/acm2/audio_coding_module_unittest.cc index f30deed7a2..c95091f1c3 100644 --- a/modules/audio_coding/acm2/audio_coding_module_unittest.cc +++ b/modules/audio_coding/acm2/audio_coding_module_unittest.cc @@ -994,35 +994,35 @@ class AcmReceiverBitExactnessOldApi : public ::testing::Test { #if (defined(WEBRTC_CODEC_ISAC) || defined(WEBRTC_CODEC_ISACFX)) && \ defined(WEBRTC_CODEC_ILBC) TEST_F(AcmReceiverBitExactnessOldApi, 8kHzOutput) { - Run(8000, PlatformChecksum("73e82368b90b0708bd970da1f357f71d", - "e777abcc66fccf8e86ac18450ad8b23c", - "5a668d4075a39cd07a2db82ec3bf19ba", + Run(8000, PlatformChecksum("bcfbe2e89b4317b22e29557168edf187", + "af15addb648cf7f032d6415672365fb3", + "54a0008eb79537dee1d8fdaa5bc29f4b", "4598140b5e4f7ee66c5adad609e65a3e", - "99d17cc50d41232a4f96c976231cb59b")); + "3155d7f2593a3276986f36221a61783c")); } TEST_F(AcmReceiverBitExactnessOldApi, 16kHzOutput) { - Run(16000, PlatformChecksum("f0b9d6961c243a3397b0bb95191b189b", - "c73877b73a7ae2687eabc88de3d3f5bc", - "70d24360be8290abbd0e56c38f83cdef", + Run(16000, PlatformChecksum("1737deef193e6c90e139ce82b7361ae4", + "9e2a9f7728c71d6559ce3a32d2b10a5d", + "114958862099142ac78b12100c21cb8d", "f2aad418af974a3b1694d5ae5cc2c3c7", - "564b1b5d2d9bcace5285623cd9822b57")); + "af2889a5ca84fb40c9aa209b9318ee7a")); } TEST_F(AcmReceiverBitExactnessOldApi, 32kHzOutput) { - Run(32000, PlatformChecksum("881a799ad91f845b1cd833e4e42d1791", - "90e478af57f11bcf678b72ed1ba87765", - "774657761e20fdec6d325d7d4b4101a7", + Run(32000, PlatformChecksum("1bf40ff024c6aa5b832d1d242c29cb3b", + "3c9690cd136e9ecd1b26a22f70fe1d5c", + "a1a3a01d8e25fcd11f1cedcd02e968b8", "100869c8dcde51346c2073e52a272d98", - "4b77795ba2581097dc8e4db6e6a3a921")); + "33695077e9ec6bca80819ce2ba263a78")); } TEST_F(AcmReceiverBitExactnessOldApi, 48kHzOutput) { - Run(48000, PlatformChecksum("991b729aef7f08eca75d4c9ece848264", - "0334f53d4e96156edc302e46ff5cfaec", - "a578705020fe94ebde31b27d61035299", + Run(48000, PlatformChecksum("bf92db1e502deff5adf6fd2e6ab9a2e5", + "c37b110ab50d87620972daee5d1eaf31", + "5d55b68be7bcf39b60fcc74519363fb4", "bd44bf97e7899186532f91235cef444d", - "c0d4185eacde6cd470c1a2ce4cd45318")); + "32eec738698ffe62b9777d6a349cd596")); } TEST_F(AcmReceiverBitExactnessOldApi, 48kHzOutputExternalDecoder) { @@ -1105,11 +1105,11 @@ TEST_F(AcmReceiverBitExactnessOldApi, 48kHzOutputExternalDecoder) { rtc::scoped_refptr> factory( new rtc::RefCountedObject); Run(48000, - PlatformChecksum("991b729aef7f08eca75d4c9ece848264", - "0334f53d4e96156edc302e46ff5cfaec", - "a578705020fe94ebde31b27d61035299", + PlatformChecksum("bf92db1e502deff5adf6fd2e6ab9a2e5", + "c37b110ab50d87620972daee5d1eaf31", + "5d55b68be7bcf39b60fcc74519363fb4", "bd44bf97e7899186532f91235cef444d", - "c0d4185eacde6cd470c1a2ce4cd45318"), + "32eec738698ffe62b9777d6a349cd596"), factory, [](AudioCodingModule* acm) { acm->SetReceiveCodecs({{0, {"MockPCMu", 8000, 1}}, {103, {"ISAC", 16000, 1}}, @@ -1328,7 +1328,7 @@ TEST_F(AcmSenderBitExactnessOldApi, IsacWb30ms) { Run(AcmReceiverBitExactnessOldApi::PlatformChecksum( "2c9cb15d4ed55b5a0cadd04883bc73b0", "9336a9b993cbd8a751f0e8958e66c89c", - "5c2eb46199994506236f68b2c8e51b0d", + "bd4682225f7c4ad5f2049f6769713ac2", "343f1f42be0607c61e6516aece424609", "2c9cb15d4ed55b5a0cadd04883bc73b0"), AcmReceiverBitExactnessOldApi::PlatformChecksum( @@ -1343,11 +1343,11 @@ TEST_F(AcmSenderBitExactnessOldApi, IsacWb30ms) { TEST_F(AcmSenderBitExactnessOldApi, IsacWb60ms) { ASSERT_NO_FATAL_FAILURE(SetUpTest("ISAC", 16000, 1, 103, 960, 960)); Run(AcmReceiverBitExactnessOldApi::PlatformChecksum( - "f59760fa000991ee5fa81f2e607db254", - "986aa16d7097a26e32e212e39ec58517", - "9a81e467eb1485f84aca796f8ea65011", + "1ad29139a04782a33daad8c2b9b35875", + "14d63c5f08127d280e722e3191b73bdd", + "edcf26694c289e3d9691faf79b74f09f", "ef75e900e6f375e3061163c53fd09a63", - "f59760fa000991ee5fa81f2e607db254"), + "1ad29139a04782a33daad8c2b9b35875"), AcmReceiverBitExactnessOldApi::PlatformChecksum( "9e0a0ab743ad987b55b8e14802769c56", "ebe04a819d3a9d83a83a17f271e1139a", diff --git a/modules/audio_coding/neteq/buffer_level_filter.cc b/modules/audio_coding/neteq/buffer_level_filter.cc index 0d75a47144..2f96618536 100644 --- a/modules/audio_coding/neteq/buffer_level_filter.cc +++ b/modules/audio_coding/neteq/buffer_level_filter.cc @@ -26,22 +26,32 @@ void BufferLevelFilter::Reset() { level_factor_ = 253; } -void BufferLevelFilter::Update(size_t buffer_size_samples, - int time_stretched_samples) { +void BufferLevelFilter::Update(size_t buffer_size_packets, + int time_stretched_samples, + size_t packet_len_samples) { // Filter: // |filtered_current_level_| = |level_factor_| * |filtered_current_level_| + - // (1 - |level_factor_|) * |buffer_size_samples| + // (1 - |level_factor_|) * |buffer_size_packets| // |level_factor_| and |filtered_current_level_| are in Q8. - // |buffer_size_samples| is in Q0. + // |buffer_size_packets| is in Q0. filtered_current_level_ = ((level_factor_ * filtered_current_level_) >> 8) + - ((256 - level_factor_) * rtc::dchecked_cast(buffer_size_samples)); + ((256 - level_factor_) * rtc::dchecked_cast(buffer_size_packets)); - // Account for time-scale operations (accelerate and pre-emptive expand) and - // make sure that the filtered value remains non-negative. - filtered_current_level_ = rtc::saturated_cast(std::max( - 0, - filtered_current_level_ - (int64_t{time_stretched_samples} * (1 << 8)))); + // Account for time-scale operations (accelerate and pre-emptive expand). + if (time_stretched_samples && packet_len_samples > 0) { + // Time-scaling has been performed since last filter update. Subtract the + // value of |time_stretched_samples| from |filtered_current_level_| after + // converting |time_stretched_samples| from samples to packets in Q8. + // Make sure that the filtered value remains non-negative. + + int64_t time_stretched_packets = + (int64_t{time_stretched_samples} * (1 << 8)) / + rtc::dchecked_cast(packet_len_samples); + + filtered_current_level_ = rtc::saturated_cast( + std::max(0, filtered_current_level_ - time_stretched_packets)); + } } void BufferLevelFilter::SetTargetBufferLevel(int target_buffer_level) { @@ -56,4 +66,8 @@ void BufferLevelFilter::SetTargetBufferLevel(int target_buffer_level) { } } +int BufferLevelFilter::filtered_current_level() const { + return filtered_current_level_; +} + } // namespace webrtc diff --git a/modules/audio_coding/neteq/buffer_level_filter.h b/modules/audio_coding/neteq/buffer_level_filter.h index 6dd424991b..83388fb4f5 100644 --- a/modules/audio_coding/neteq/buffer_level_filter.h +++ b/modules/audio_coding/neteq/buffer_level_filter.h @@ -24,20 +24,20 @@ class BufferLevelFilter { virtual void Reset(); // Updates the filter. Current buffer size is |buffer_size_packets| (Q0). - // |time_stretched_samples| is subtracted from the filtered value (thus - // bypassing the filter operation). - virtual void Update(size_t buffer_size_samples, int time_stretched_samples); + // If |time_stretched_samples| is non-zero, the value is converted to the + // corresponding number of packets, and is subtracted from the filtered + // value (thus bypassing the filter operation). |packet_len_samples| is the + // number of audio samples carried in each incoming packet. + virtual void Update(size_t buffer_size_packets, + int time_stretched_samples, + size_t packet_len_samples); - // Set the current target buffer level in number of packets (obtained from + // Set the current target buffer level (obtained from // DelayManager::base_target_level()). Used to select the appropriate // filter coefficient. - virtual void SetTargetBufferLevel(int target_buffer_level_packets); + virtual void SetTargetBufferLevel(int target_buffer_level); - // Returns filtered current level in number of samples. - virtual int filtered_current_level() const { - // Round to nearest whole sample. - return (filtered_current_level_ + (1 << 7)) >> 8; - } + virtual int filtered_current_level() const; private: int level_factor_; // Filter factor for the buffer level filter in Q8. diff --git a/modules/audio_coding/neteq/buffer_level_filter_unittest.cc b/modules/audio_coding/neteq/buffer_level_filter_unittest.cc index bc42595cd1..1f12e73d10 100644 --- a/modules/audio_coding/neteq/buffer_level_filter_unittest.cc +++ b/modules/audio_coding/neteq/buffer_level_filter_unittest.cc @@ -35,17 +35,18 @@ TEST(BufferLevelFilter, ConvergenceTest) { ss << "times = " << times << ", value = " << value; SCOPED_TRACE(ss.str()); // Print out the parameter values on failure. for (int i = 0; i < times; ++i) { - filter.Update(value, 0 /* time_stretched_samples */); + filter.Update(value, 0 /* time_stretched_samples */, + 160 /* packet_len_samples */); } // Expect the filtered value to be (theoretically) // (1 - (251/256) ^ |times|) * |value|. double expected_value_double = (1 - pow(251.0 / 256.0, times)) * value; int expected_value = static_cast(expected_value_double); - + // filtered_current_level() returns the value in Q8. // The actual value may differ slightly from the expected value due to // intermediate-stage rounding errors in the filter implementation. // This is why we have to use EXPECT_NEAR with a tolerance of +/-1. - EXPECT_NEAR(expected_value, filter.filtered_current_level(), 1); + EXPECT_NEAR(expected_value, filter.filtered_current_level() >> 8, 1); } } } @@ -59,32 +60,38 @@ TEST(BufferLevelFilter, FilterFactor) { filter.SetTargetBufferLevel(3); // Makes filter coefficient 252/256. for (int i = 0; i < kTimes; ++i) { - filter.Update(kValue, 0 /* time_stretched_samples */); + filter.Update(kValue, 0 /* time_stretched_samples */, + 160 /* packet_len_samples */); } // Expect the filtered value to be // (1 - (252/256) ^ |kTimes|) * |kValue|. - int expected_value = 15; - EXPECT_EQ(expected_value, filter.filtered_current_level()); + int expected_value = 14; + // filtered_current_level() returns the value in Q8. + EXPECT_EQ(expected_value, filter.filtered_current_level() >> 8); filter.Reset(); filter.SetTargetBufferLevel(7); // Makes filter coefficient 253/256. for (int i = 0; i < kTimes; ++i) { - filter.Update(kValue, 0 /* time_stretched_samples */); + filter.Update(kValue, 0 /* time_stretched_samples */, + 160 /* packet_len_samples */); } // Expect the filtered value to be // (1 - (253/256) ^ |kTimes|) * |kValue|. expected_value = 11; - EXPECT_EQ(expected_value, filter.filtered_current_level()); + // filtered_current_level() returns the value in Q8. + EXPECT_EQ(expected_value, filter.filtered_current_level() >> 8); filter.Reset(); filter.SetTargetBufferLevel(8); // Makes filter coefficient 254/256. for (int i = 0; i < kTimes; ++i) { - filter.Update(kValue, 0 /* time_stretched_samples */); + filter.Update(kValue, 0 /* time_stretched_samples */, + 160 /* packet_len_samples */); } // Expect the filtered value to be // (1 - (254/256) ^ |kTimes|) * |kValue|. - expected_value = 8; - EXPECT_EQ(expected_value, filter.filtered_current_level()); + expected_value = 7; + // filtered_current_level() returns the value in Q8. + EXPECT_EQ(expected_value, filter.filtered_current_level() >> 8); } TEST(BufferLevelFilter, TimeStretchedSamples) { @@ -93,24 +100,62 @@ TEST(BufferLevelFilter, TimeStretchedSamples) { // Update 10 times with value 100. const int kTimes = 10; const int kValue = 100; - const int kTimeStretchedSamples = 3; + const int kPacketSizeSamples = 160; + const int kNumPacketsStretched = 2; + const int kTimeStretchedSamples = kNumPacketsStretched * kPacketSizeSamples; for (int i = 0; i < kTimes; ++i) { - filter.Update(kValue, 0); + // Packet size set to 0. Do not expect the parameter + // |kTimeStretchedSamples| to have any effect. + filter.Update(kValue, kTimeStretchedSamples, 0 /* packet_len_samples */); } // Expect the filtered value to be // (1 - (251/256) ^ |kTimes|) * |kValue|. - const int kExpectedValue = 18; - EXPECT_EQ(kExpectedValue, filter.filtered_current_level()); + const int kExpectedValue = 17; + // filtered_current_level() returns the value in Q8. + EXPECT_EQ(kExpectedValue, filter.filtered_current_level() >> 8); // Update filter again, now with non-zero value for packet length. // Set the current filtered value to be the input, in order to isolate the // impact of |kTimeStretchedSamples|. - filter.Update(filter.filtered_current_level(), kTimeStretchedSamples); - EXPECT_EQ(kExpectedValue - kTimeStretchedSamples, - filter.filtered_current_level()); + filter.Update(filter.filtered_current_level() >> 8, kTimeStretchedSamples, + kPacketSizeSamples); + EXPECT_EQ(kExpectedValue - kNumPacketsStretched, + filter.filtered_current_level() >> 8); // Try negative value and verify that we come back to the previous result. - filter.Update(filter.filtered_current_level(), -kTimeStretchedSamples); - EXPECT_EQ(kExpectedValue, filter.filtered_current_level()); + filter.Update(filter.filtered_current_level() >> 8, -kTimeStretchedSamples, + kPacketSizeSamples); + EXPECT_EQ(kExpectedValue, filter.filtered_current_level() >> 8); +} + +TEST(BufferLevelFilter, TimeStretchedSamplesNegativeUnevenFrames) { + BufferLevelFilter filter; + filter.SetTargetBufferLevel(1); // Makes filter coefficient 251/256. + // Update 10 times with value 100. + const int kTimes = 10; + const int kValue = 100; + const int kPacketSizeSamples = 160; + const int kTimeStretchedSamples = -3.1415 * kPacketSizeSamples; + for (int i = 0; i < kTimes; ++i) { + // Packet size set to 0. Do not expect the parameter + // |kTimeStretchedSamples| to have any effect. + filter.Update(kValue, kTimeStretchedSamples, 0 /* packet_len_samples */); + } + // Expect the filtered value to be + // (1 - (251/256) ^ |kTimes|) * |kValue|. + const int kExpectedValue = 17; + // filtered_current_level() returns the value in Q8. + EXPECT_EQ(kExpectedValue, filter.filtered_current_level() >> 8); + + // Update filter again, now with non-zero value for packet length. + // Set the current filtered value to be the input, in order to isolate the + // impact of |kTimeStretchedSamples|. + filter.Update(filter.filtered_current_level() >> 8, kTimeStretchedSamples, + kPacketSizeSamples); + EXPECT_EQ(21, filter.filtered_current_level() >> 8); + // Try negative value and verify that we come back to the previous result. + filter.Update(filter.filtered_current_level() >> 8, -kTimeStretchedSamples, + kPacketSizeSamples); + EXPECT_EQ(kExpectedValue, filter.filtered_current_level() >> 8); } } // namespace webrtc diff --git a/modules/audio_coding/neteq/decision_logic.cc b/modules/audio_coding/neteq/decision_logic.cc index f9f420af0e..40e421d672 100644 --- a/modules/audio_coding/neteq/decision_logic.cc +++ b/modules/audio_coding/neteq/decision_logic.cc @@ -113,9 +113,11 @@ Operations DecisionLogic::GetDecision(const SyncBuffer& sync_buffer, cng_state_ = kCngInternalOn; } + const size_t samples_left = + sync_buffer.FutureLength() - expand.overlap_length(); // TODO(jakobi): Use buffer span instead of num samples. const size_t cur_size_samples = - packet_buffer_.NumSamplesInBuffer(decoder_frame_length); + samples_left + packet_buffer_.NumSamplesInBuffer(decoder_frame_length); prev_time_scale_ = prev_time_scale_ && (prev_mode == kModeAccelerateSuccess || @@ -173,7 +175,8 @@ Operations DecisionLogic::GetDecision(const SyncBuffer& sync_buffer, // if the mute factor is low enough (otherwise the expansion was short enough // to not be noticable). // Note that the MuteFactor is in Q14, so a value of 16384 corresponds to 1. - size_t current_span = packet_buffer_.GetSpanSamples(decoder_frame_length); + size_t current_span = + samples_left + packet_buffer_.GetSpanSamples(decoder_frame_length); if ((prev_mode == kModeExpand || prev_mode == kModeCodecPlc) && expand.MuteFactor(0) < 16384 / 2 && current_span < static_cast(delay_manager_->TargetLevel() * @@ -190,9 +193,9 @@ Operations DecisionLogic::GetDecision(const SyncBuffer& sync_buffer, return ExpectedPacketAvailable(prev_mode, play_dtmf); } else if (!PacketBuffer::IsObsoleteTimestamp( available_timestamp, target_timestamp, five_seconds_samples)) { - return FuturePacketAvailable(decoder_frame_length, prev_mode, - target_timestamp, available_timestamp, - play_dtmf, generated_noise_samples); + return FuturePacketAvailable( + sync_buffer, expand, decoder_frame_length, prev_mode, target_timestamp, + available_timestamp, play_dtmf, generated_noise_samples); } else { // This implies that available_timestamp < target_timestamp, which can // happen when a new stream or codec is received. Signal for a reset. @@ -212,13 +215,19 @@ void DecisionLogic::FilterBufferLevel(size_t buffer_size_samples) { buffer_level_filter_->SetTargetBufferLevel( delay_manager_->base_target_level()); + size_t buffer_size_packets = 0; + if (packet_length_samples_ > 0) { + // Calculate size in packets. + buffer_size_packets = buffer_size_samples / packet_length_samples_; + } int sample_memory_local = 0; if (prev_time_scale_) { sample_memory_local = sample_memory_; timescale_countdown_ = tick_timer_->GetNewCountdown(kMinTimescaleInterval); } - buffer_level_filter_->Update(buffer_size_samples, sample_memory_local); + buffer_level_filter_->Update(buffer_size_packets, sample_memory_local, + packet_length_samples_); prev_time_scale_ = false; } @@ -274,22 +283,15 @@ Operations DecisionLogic::NoPacket(bool play_dtmf) { Operations DecisionLogic::ExpectedPacketAvailable(Modes prev_mode, bool play_dtmf) { if (!disallow_time_stretching_ && prev_mode != kModeExpand && !play_dtmf) { - // Check criterion for time-stretching. The values are in number of packets - // in Q8. + // Check criterion for time-stretching. int low_limit, high_limit; delay_manager_->BufferLimits(&low_limit, &high_limit); - int buffer_level_packets = 0; - if (packet_length_samples_ > 0) { - buffer_level_packets = - ((1 << 8) * buffer_level_filter_->filtered_current_level()) / - packet_length_samples_; - } - if (buffer_level_packets >= high_limit << 2) + if (buffer_level_filter_->filtered_current_level() >= high_limit << 2) return kFastAccelerate; if (TimescaleAllowed()) { - if (buffer_level_packets >= high_limit) + if (buffer_level_filter_->filtered_current_level() >= high_limit) return kAccelerate; - if (buffer_level_packets < low_limit) + if (buffer_level_filter_->filtered_current_level() < low_limit) return kPreemptiveExpand; } } @@ -297,6 +299,8 @@ Operations DecisionLogic::ExpectedPacketAvailable(Modes prev_mode, } Operations DecisionLogic::FuturePacketAvailable( + const SyncBuffer& sync_buffer, + const Expand& expand, size_t decoder_frame_length, Modes prev_mode, uint32_t target_timestamp, @@ -323,8 +327,10 @@ Operations DecisionLogic::FuturePacketAvailable( return kNormal; } + const size_t samples_left = + sync_buffer.FutureLength() - expand.overlap_length(); const size_t cur_size_samples = - packet_buffer_.NumPacketsInBuffer() * decoder_frame_length; + samples_left + packet_buffer_.NumPacketsInBuffer() * decoder_frame_length; // If previous was comfort noise, then no merge is needed. if (prev_mode == kModeRfc3389Cng || prev_mode == kModeCodecInternalCng) { @@ -359,13 +365,8 @@ Operations DecisionLogic::FuturePacketAvailable( } bool DecisionLogic::UnderTargetLevel() const { - int buffer_level_packets = 0; - if (packet_length_samples_ > 0) { - buffer_level_packets = - ((1 << 8) * buffer_level_filter_->filtered_current_level()) / - packet_length_samples_; - } - return buffer_level_packets <= delay_manager_->TargetLevel(); + return buffer_level_filter_->filtered_current_level() <= + delay_manager_->TargetLevel(); } bool DecisionLogic::ReinitAfterExpands(uint32_t timestamp_leap) const { diff --git a/modules/audio_coding/neteq/decision_logic.h b/modules/audio_coding/neteq/decision_logic.h index 49020b0aab..2414e8cc25 100644 --- a/modules/audio_coding/neteq/decision_logic.h +++ b/modules/audio_coding/neteq/decision_logic.h @@ -134,7 +134,9 @@ class DecisionLogic final { // Returns the operation to do given that the expected packet is not // available, but a packet further into the future is at hand. - Operations FuturePacketAvailable(size_t decoder_frame_length, + Operations FuturePacketAvailable(const SyncBuffer& sync_buffer, + const Expand& expand, + size_t decoder_frame_length, Modes prev_mode, uint32_t target_timestamp, uint32_t available_timestamp, diff --git a/modules/audio_coding/neteq/mock/mock_buffer_level_filter.h b/modules/audio_coding/neteq/mock/mock_buffer_level_filter.h index 031195cd0f..bf9fd59c9a 100644 --- a/modules/audio_coding/neteq/mock/mock_buffer_level_filter.h +++ b/modules/audio_coding/neteq/mock/mock_buffer_level_filter.h @@ -22,8 +22,10 @@ class MockBufferLevelFilter : public BufferLevelFilter { virtual ~MockBufferLevelFilter() { Die(); } MOCK_METHOD0(Die, void()); MOCK_METHOD0(Reset, void()); - MOCK_METHOD2(Update, - void(size_t buffer_size_samples, int time_stretched_samples)); + MOCK_METHOD3(Update, + void(size_t buffer_size_packets, + int time_stretched_samples, + size_t packet_len_samples)); MOCK_METHOD1(SetTargetBufferLevel, void(int target_buffer_level)); MOCK_CONST_METHOD0(filtered_current_level, int()); }; diff --git a/modules/audio_coding/neteq/neteq_impl.cc b/modules/audio_coding/neteq/neteq_impl.cc index 82ec18db17..ad6becc90e 100644 --- a/modules/audio_coding/neteq/neteq_impl.cc +++ b/modules/audio_coding/neteq/neteq_impl.cc @@ -310,12 +310,18 @@ int NetEqImpl::TargetDelayMs() const { int NetEqImpl::FilteredCurrentDelayMs() const { rtc::CritScope lock(&crit_sect_); + // Calculate the filtered packet buffer level in samples. The value from + // |buffer_level_filter_| is in number of packets, represented in Q8. + const size_t packet_buffer_samples = + (buffer_level_filter_->filtered_current_level() * + decoder_frame_length_) >> + 8; // Sum up the filtered packet buffer level with the future length of the sync - // buffer. - const int delay_samples = buffer_level_filter_->filtered_current_level() + - sync_buffer_->FutureLength(); + // buffer, and divide the sum by the sample rate. + const size_t delay_samples = + packet_buffer_samples + sync_buffer_->FutureLength(); // The division below will truncate. The return value is in ms. - return delay_samples / rtc::CheckedDivExact(fs_hz_, 1000); + return static_cast(delay_samples) / rtc::CheckedDivExact(fs_hz_, 1000); } int NetEqImpl::NetworkStatistics(NetEqNetworkStatistics* stats) { diff --git a/modules/audio_coding/neteq/neteq_unittest.cc b/modules/audio_coding/neteq/neteq_unittest.cc index a89d248826..6c67ca8ea0 100644 --- a/modules/audio_coding/neteq/neteq_unittest.cc +++ b/modules/audio_coding/neteq/neteq_unittest.cc @@ -458,16 +458,16 @@ TEST_F(NetEqDecodingTest, MAYBE_TestBitExactness) { webrtc::test::ResourcePath("audio_coding/neteq_universal_new", "rtp"); const std::string output_checksum = - PlatformChecksum("998be2e5a707e636af0b6298f54bedfabe72aae1", - "61e238ece4cd3b67d66a0b7047e06b20607dcb79", "not used", - "998be2e5a707e636af0b6298f54bedfabe72aae1", - "4116ac2a6e75baac3194b712d6fabe28b384275e"); + PlatformChecksum("9652cee1d6771a9cbfda821ae1bbdb41b0dd4dee", + "54a7e32f163663c0af35bf70bf45cefc24ad62ef", "not used", + "9652cee1d6771a9cbfda821ae1bbdb41b0dd4dee", + "79496b0a1ef0a3824f3ee04789748a461bed643f"); const std::string network_stats_checksum = - PlatformChecksum("3689c9f0ab9e50cefab3e44c37c3d7aa0de82ca4", - "0a596217fccd8d90eff7d1666b8cc63143eeda12", "not used", - "3689c9f0ab9e50cefab3e44c37c3d7aa0de82ca4", - "3689c9f0ab9e50cefab3e44c37c3d7aa0de82ca4"); + PlatformChecksum("c59b1f9f282b6d8733cdff975e3c150ca4a47d51", + "bca95e565996a4ffd6e2ac15736e08843bdca93b", "not used", + "c59b1f9f282b6d8733cdff975e3c150ca4a47d51", + "c59b1f9f282b6d8733cdff975e3c150ca4a47d51"); DecodeAndCompare(input_rtp_file, output_checksum, network_stats_checksum, FLAG_gen_ref); @@ -486,17 +486,17 @@ TEST_F(NetEqDecodingTest, MAYBE_TestOpusBitExactness) { // Checksum depends on libopus being compiled with or without SSE. const std::string maybe_sse = "14a63b3c7b925c82296be4bafc71bec85f2915c2|" - "eb0b68bddcac00fc85403df64f83126f8ea9bc93"; + "2c05677daa968d6c68b92adf4affb7cd9bb4d363"; const std::string output_checksum = PlatformChecksum( - maybe_sse, "f95f2a220c9ca5d60b81c4653d46e0de2bee159f", - "6f288a03d34958f62496f18fa85655593eef4dbe", maybe_sse, maybe_sse); + maybe_sse, "b7b7ed802b0e18ee416973bf3b9ae98599b0181d", + "5876e52dda90d5ca433c3726555b907b97c86374", maybe_sse, maybe_sse); const std::string network_stats_checksum = - PlatformChecksum("0b3d34baffaf651812ffaf06ea1b5ce45ea1c47a", - "a71dce66c7bea85ba22d4e29a5298f606f810444", - "7c64e1e915bace7c4bf583484efd64eaf234552f", - "0b3d34baffaf651812ffaf06ea1b5ce45ea1c47a", - "0b3d34baffaf651812ffaf06ea1b5ce45ea1c47a"); + PlatformChecksum("adb3272498e436d1c019cbfd71610e9510c54497", + "fa935a91abc7291db47428a2d7c5361b98713a92", + "42106aa5267300f709f63737707ef07afd9dac61", + "adb3272498e436d1c019cbfd71610e9510c54497", + "adb3272498e436d1c019cbfd71610e9510c54497"); DecodeAndCompare(input_rtp_file, output_checksum, network_stats_checksum, FLAG_gen_ref); @@ -796,7 +796,7 @@ TEST_F(NetEqDecodingTest, LongCngWithNegativeClockDriftNetworkFreeze) { const double kDriftFactor = 1000.0 / (1000.0 + 25.0); const double kNetworkFreezeTimeMs = 5000.0; const bool kGetAudioDuringFreezeRecovery = false; - const int kDelayToleranceMs = 60; + const int kDelayToleranceMs = 50; const int kMaxTimeToSpeechMs = 200; LongCngWithClockDrift(kDriftFactor, kNetworkFreezeTimeMs, kGetAudioDuringFreezeRecovery, kDelayToleranceMs,