commit f6e100b5ee57b335766addb66ab43c99a0939e22
author Rasmus Brandt <brandtr@webrtc.org> Mon Oct 13 07:42:36 2025
committer WebRTC LUCI CQ <webrtc-scoped@luci-project-accounts.iam.gserviceaccount.com> Mon Oct 13 14:42:21 2025
tree d7eefcda229836dec762cfb9bfa8e2d57937bc50
parent 7214d365923e5202feb306ebd3bb9f655579faf2

Enable outlier rejection by default in TimestampExtrapolator.

The new reordering logic in `TimestampExtrapolator` made
`VideoReceiveStream2Test.FramesScheduledInOrder` fail, due to slight
changes in timing. By updating the `AdvanceTime` calls to make more
sense (splitting expected inter-frame duration `AdvanceTime` from
waiting for rendering `AdvanceTime`), it now passes. Note that the
underlying expectations remain the same though: reordered frames are
still decoded and rendered in order. The timing of those are just
slightly different.

Bug: b/439767978, b/422493053
Change-Id: I5096d7611c4ab4be2fc7882bdbc3d317f0533fe7
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/415840
Reviewed-by: Åsa Persson <asapersson@webrtc.org>
Commit-Queue: Rasmus Brandt <brandtr@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#45920}

video/video_receive_stream2_unittest.cc

diff --git a/video/video_receive_stream2_unittest.cc b/video/video_receive_stream2_unittest.cc
index ca8772b..9e11bbe 100644
--- a/video/video_receive_stream2_unittest.cc
+++ b/video/video_receive_stream2_unittest.cc
@@ -11,9 +11,7 @@
 #include "video/video_receive_stream2.h"
 
 #include <algorithm>
-#include <cstddef>
 #include <cstdint>
-#include <cstring>
 #include <deque>
 #include <limits>
 #include <memory>
@@ -913,18 +911,31 @@
   EXPECT_CALL(mock_decoder_,
               Decode(test::RtpTimestamp(RtpTimestampForFrame(2)), _))
       .Times(1);
+
+  // `key_frame` arrives at the start time...
   key_frame->SetReceivedTime(env_.clock().CurrentTime().ms());
   video_receive_stream_->OnCompleteFrame(std::move(key_frame));
+  // ...and it is decoded and rendered right away.
   EXPECT_THAT(fake_renderer_.WaitForFrame(TimeDelta::Zero()), RenderedFrame());
 
-  delta_frame2->SetReceivedTime(env_.clock().CurrentTime().ms());
+  // `delta_frame2` arrives on time, which is two inter-frame durations later...
+  time_controller_.AdvanceTime(2 * k30FpsDelay);
+  int64_t delta_frame2_received_time_ms = env_.clock().CurrentTime().ms();
+  delta_frame2->SetReceivedTime(delta_frame2_received_time_ms);
   video_receive_stream_->OnCompleteFrame(std::move(delta_frame2));
-  EXPECT_THAT(fake_renderer_.WaitForFrame(k30FpsDelay), DidNotReceiveFrame());
-  // `delta_frame1` arrives late.
+  // ...but it doesn't render, since it is not yet decodable.
+  EXPECT_THAT(fake_renderer_.WaitForFrame(TimeDelta::Zero()),
+              DidNotReceiveFrame());
+
+  // `delta_frame1` arrives back-to-back with `delta_frame2`...
   delta_frame1->SetReceivedTime(env_.clock().CurrentTime().ms());
+  EXPECT_EQ(delta_frame1->ReceivedTime(), delta_frame2_received_time_ms);
   video_receive_stream_->OnCompleteFrame(std::move(delta_frame1));
+  // ...so it is decoded and rendered right away (since it is late).
+  EXPECT_THAT(fake_renderer_.WaitForFrame(TimeDelta::Zero()), RenderedFrame());
+  // And then a bit later, `delta_frame2` is decoded and rendered.
   EXPECT_THAT(fake_renderer_.WaitForFrame(k30FpsDelay), RenderedFrame());
-  EXPECT_THAT(fake_renderer_.WaitForFrame(k30FpsDelay * 2), RenderedFrame());
+
   video_receive_stream_->Stop();
 }