| /* |
| * Copyright (c) 2025 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 "video/timing/simulator/rendering_simulator.h" |
| |
| #include <memory> |
| #include <optional> |
| |
| #include "absl/algorithm/container.h" |
| #include "absl/strings/string_view.h" |
| #include "api/numerics/samples_stats_counter.h" |
| #include "api/units/data_size.h" |
| #include "api/units/time_delta.h" |
| #include "api/units/timestamp.h" |
| #include "logging/rtc_event_log/rtc_event_log_parser.h" |
| #include "test/gmock.h" |
| #include "test/gtest.h" |
| #include "video/timing/simulator/frame_base.h" |
| #include "video/timing/simulator/test/parsed_rtc_event_log_from_resources.h" |
| |
| namespace webrtc::video_timing_simulator { |
| namespace { |
| |
| using ::testing::AllOf; |
| using ::testing::Eq; |
| using ::testing::Field; |
| using ::testing::IsEmpty; |
| using ::testing::Matcher; |
| using ::testing::Ne; |
| using ::testing::Optional; |
| using ::testing::SizeIs; |
| |
| using Frame = RenderingSimulator::Frame; |
| using Stream = RenderingSimulator::Stream; |
| |
| TEST(RenderingSimulatorFrameTest, BufferDurationsAndMarginsForInTimeFrame) { |
| RenderingSimulator::Frame frame{ |
| .first_packet_arrival_timestamp = Timestamp::Zero(), |
| .assembled_timestamp = Timestamp::Millis(1), |
| .render_timestamp = |
| Timestamp::Millis(10) + RenderingSimulator::kRenderDelay, |
| .decoded_timestamp = Timestamp::Millis(9), |
| .rendered_timestamp = Timestamp::Millis(10)}; |
| |
| // Buffer durations. |
| EXPECT_THAT(frame.PacketBufferDuration(), Eq(TimeDelta::Millis(1))); |
| EXPECT_THAT(frame.FrameBufferDuration(), Eq(TimeDelta::Millis(8))); |
| EXPECT_THAT(frame.RenderBufferDuration(), Eq(TimeDelta::Millis(1))); |
| EXPECT_THAT(frame.TotalBufferDuration(), Eq(TimeDelta::Millis(10))); |
| |
| // Margins. |
| EXPECT_THAT(frame.AssembledMargin(), Eq(TimeDelta::Millis(9))); |
| EXPECT_THAT(frame.AssembledInTime(), Optional(true)); |
| EXPECT_THAT(frame.AssembledLate(), Optional(false)); |
| EXPECT_THAT(frame.AssembledMarginExcess(), Optional(TimeDelta::Millis(9))); |
| EXPECT_THAT(frame.AssembledMarginDeficit(), Eq(std::nullopt)); |
| EXPECT_THAT(frame.RenderedMargin(), Eq(TimeDelta::Zero())); |
| EXPECT_THAT(frame.RenderedInTime(), Optional(true)); |
| EXPECT_THAT(frame.RenderedLate(), Optional(false)); |
| EXPECT_THAT(frame.RenderedMarginExcess(), Optional(TimeDelta::Zero())); |
| EXPECT_THAT(frame.RenderedMarginDeficit(), Eq(std::nullopt)); |
| } |
| |
| TEST(RenderingSimulatorFrameTest, BufferDurationsAndMarginsForDelayedFrame) { |
| RenderingSimulator::Frame frame{ |
| .first_packet_arrival_timestamp = Timestamp::Millis(12), |
| .assembled_timestamp = Timestamp::Millis(12), |
| .render_timestamp = |
| Timestamp::Millis(10) + RenderingSimulator::kRenderDelay, |
| .decoded_timestamp = Timestamp::Millis(12), |
| .rendered_timestamp = Timestamp::Millis(12)}; |
| |
| // Buffer durations. |
| EXPECT_THAT(frame.PacketBufferDuration(), Eq(TimeDelta::Zero())); |
| EXPECT_THAT(frame.FrameBufferDuration(), Eq(TimeDelta::Zero())); |
| EXPECT_THAT(frame.RenderBufferDuration(), Eq(TimeDelta::Zero())); |
| EXPECT_THAT(frame.TotalBufferDuration(), Eq(TimeDelta::Zero())); |
| |
| // Margins. |
| EXPECT_THAT(frame.AssembledMargin(), Eq(TimeDelta::Millis(-2))); |
| EXPECT_THAT(frame.AssembledInTime(), Optional(false)); |
| EXPECT_THAT(frame.AssembledLate(), Optional(true)); |
| EXPECT_THAT(frame.AssembledMarginExcess(), Eq(std::nullopt)); |
| EXPECT_THAT(frame.AssembledMarginDeficit(), Optional(TimeDelta::Millis(-2))); |
| EXPECT_THAT(frame.RenderedMargin(), Eq(TimeDelta::Millis(-2))); |
| EXPECT_THAT(frame.AssembledInTime(), Optional(false)); |
| EXPECT_THAT(frame.AssembledLate(), Optional(true)); |
| EXPECT_THAT(frame.RenderedMarginExcess(), Eq(std::nullopt)); |
| EXPECT_THAT(frame.RenderedMarginDeficit(), Optional(TimeDelta::Millis(-2))); |
| } |
| |
| TEST(RenderingSimulatorFrameTest, |
| InTimeHelpersReturnTrueWhenRenderTimestampRoundedDownToMsPrecision) { |
| Timestamp processing_timestamp = Timestamp::Micros(10499); |
| |
| RenderingSimulator::Frame frame{.assembled_timestamp = processing_timestamp, |
| .rendered_timestamp = processing_timestamp}; |
| // Simulate the rounding down in `SetRenderTime(render_time.ms());` |
| frame.render_timestamp = Timestamp::Millis(processing_timestamp.ms()) + |
| RenderingSimulator::kRenderDelay; |
| EXPECT_EQ(frame.render_timestamp, |
| Timestamp::Millis(10) + RenderingSimulator::kRenderDelay); |
| |
| // Margins. |
| EXPECT_EQ(frame.AssembledMargin(), TimeDelta::Micros(-499)); |
| EXPECT_TRUE(frame.AssembledInTime()); |
| EXPECT_EQ(frame.RenderedMargin(), TimeDelta::Micros(-499)); |
| EXPECT_TRUE(frame.RenderedInTime()); |
| } |
| |
| TEST(RenderingSimulatorFrameTest, |
| InTimeHelpersReturnTrueWhenRenderTimestampRoundedUpToMsPrecision) { |
| Timestamp processing_timestamp = Timestamp::Micros(10500); |
| |
| RenderingSimulator::Frame frame{.assembled_timestamp = processing_timestamp, |
| .rendered_timestamp = processing_timestamp}; |
| // Simulate the rounding up in `SetRenderTime(render_time.ms());` |
| frame.render_timestamp = Timestamp::Millis(processing_timestamp.ms()) + |
| RenderingSimulator::kRenderDelay; |
| EXPECT_EQ(frame.render_timestamp, |
| Timestamp::Millis(11) + RenderingSimulator::kRenderDelay); |
| |
| // Margins. |
| EXPECT_EQ(frame.AssembledMargin(), TimeDelta::Micros(500)); |
| EXPECT_TRUE(frame.AssembledInTime()); |
| EXPECT_EQ(frame.RenderedMargin(), TimeDelta::Micros(500)); |
| EXPECT_TRUE(frame.RenderedInTime()); |
| } |
| |
| TEST(RenderingSimulatorStreamTest, NumAssembledInTimeAndLateFrames) { |
| RenderingSimulator::Stream stream{ |
| .frames = {{.assembled_timestamp = Timestamp::Millis(0)}, |
| {.assembled_timestamp = Timestamp::Millis(10), |
| .render_timestamp = |
| Timestamp::Millis(10) + RenderingSimulator::kRenderDelay}, |
| {.assembled_timestamp = Timestamp::Millis(30), |
| .render_timestamp = Timestamp::Millis(20) + |
| RenderingSimulator::kRenderDelay}}}; |
| |
| EXPECT_EQ(stream.NumAssembledFrames(), 3); |
| EXPECT_EQ(stream.NumAssembledInTimeFrames(), 1); |
| EXPECT_EQ(stream.NumAssembledLateFrames(), 1); |
| } |
| |
| TEST(RenderingSimulatorStreamTest, NumDecodedFrames) { |
| RenderingSimulator::Stream stream{ |
| .frames = {{}, {.decoded_timestamp = Timestamp::Millis(10)}}}; |
| |
| EXPECT_EQ(stream.NumDecodedFrames(), 1); |
| } |
| |
| TEST(RenderingSimulatorStreamTest, NumRenderedInTimeAndLateFrames) { |
| RenderingSimulator::Stream stream{ |
| .frames = {{}, |
| {.render_timestamp = |
| Timestamp::Millis(10) + RenderingSimulator::kRenderDelay, |
| .rendered_timestamp = Timestamp::Millis(10)}, |
| {.render_timestamp = |
| Timestamp::Millis(20) + RenderingSimulator::kRenderDelay, |
| .rendered_timestamp = Timestamp::Millis(30)}}}; |
| |
| EXPECT_EQ(stream.NumRenderedFrames(), 2); |
| EXPECT_EQ(stream.NumRenderedInTimeFrames(), 1); |
| EXPECT_EQ(stream.NumRenderedLateFrames(), 1); |
| } |
| |
| TEST(RenderingSimulatorStreamTest, NumDecoderDroppedFrames) { |
| RenderingSimulator::Stream stream{ |
| .frames = {{.frames_dropped = 1}, {.frames_dropped = 2}}}; |
| |
| EXPECT_EQ(stream.NumDecoderDroppedFrames(), 3); |
| } |
| |
| TEST(RenderingSimulatorStreamTest, InterFrameDurations) { |
| RenderingSimulator::Stream stream{ |
| .frames = {{.render_timestamp = Timestamp::Millis(1), |
| .decoded_timestamp = Timestamp::Millis(2), |
| .rendered_timestamp = Timestamp::Millis(3)}, |
| {.render_timestamp = Timestamp::Millis(11), |
| .decoded_timestamp = Timestamp::Millis(102), |
| .rendered_timestamp = Timestamp::Millis(1003)}}}; |
| |
| EXPECT_THAT( |
| stream.InterRenderTimeMs().GetTimedSamples(), |
| ElementsAre(Field(&SamplesStatsCounter::StatsSample::value, Eq(10)))); |
| EXPECT_THAT( |
| stream.InterDecodedTimeMs().GetTimedSamples(), |
| ElementsAre(Field(&SamplesStatsCounter::StatsSample::value, Eq(100)))); |
| EXPECT_THAT( |
| stream.InterRenderedTimeMs().GetTimedSamples(), |
| ElementsAre(Field(&SamplesStatsCounter::StatsSample::value, Eq(1000)))); |
| } |
| |
| TEST(RenderingSimulatorStreamTest, WebrtcStatsSamples) { |
| RenderingSimulator::Stream stream{ |
| .frames = {{.rendered_timestamp = Timestamp::Zero(), |
| .jitter_buffer_minimum_delay = TimeDelta::Millis(20), |
| .jitter_buffer_delay = TimeDelta::Millis(30)}}}; |
| |
| EXPECT_THAT( |
| stream.JitterBufferMinimumDelayMs().GetTimedSamples(), |
| ElementsAre(Field(&SamplesStatsCounter::StatsSample::value, Eq(20)))); |
| EXPECT_THAT( |
| stream.JitterBufferDelayMs().GetTimedSamples(), |
| ElementsAre(Field(&SamplesStatsCounter::StatsSample::value, Eq(30)))); |
| } |
| |
| TEST(RenderingSimulatorStreamTest, BufferDurations) { |
| RenderingSimulator::Stream stream{ |
| .frames = {{.first_packet_arrival_timestamp = Timestamp::Millis(1), |
| .assembled_timestamp = Timestamp::Millis(3), |
| .decoded_timestamp = Timestamp::Millis(7), |
| .rendered_timestamp = Timestamp::Millis(14)}}}; |
| |
| EXPECT_THAT( |
| stream.PacketBufferDurationMs().GetTimedSamples(), |
| ElementsAre(Field(&SamplesStatsCounter::StatsSample::value, Eq(2)))); |
| EXPECT_THAT( |
| stream.FrameBufferDurationMs().GetTimedSamples(), |
| ElementsAre(Field(&SamplesStatsCounter::StatsSample::value, Eq(4)))); |
| EXPECT_THAT( |
| stream.RenderBufferDurationMs().GetTimedSamples(), |
| ElementsAre(Field(&SamplesStatsCounter::StatsSample::value, Eq(7)))); |
| EXPECT_THAT( |
| stream.TotalBufferDurationMs().GetTimedSamples(), |
| ElementsAre(Field(&SamplesStatsCounter::StatsSample::value, Eq(13)))); |
| } |
| |
| TEST(RenderingSimulatorStreamTest, Margins) { |
| RenderingSimulator::Stream stream{ |
| .frames = {{.assembled_timestamp = Timestamp::Millis(0), |
| .render_timestamp = |
| Timestamp::Millis(10) + RenderingSimulator::kRenderDelay, |
| .rendered_timestamp = Timestamp::Millis(15)}}}; |
| |
| EXPECT_THAT( |
| stream.AssembledMarginMs().GetTimedSamples(), |
| ElementsAre(Field(&SamplesStatsCounter::StatsSample::value, Eq(10)))); |
| EXPECT_THAT( |
| stream.AssembledMarginExcessMs().GetTimedSamples(), |
| ElementsAre(Field(&SamplesStatsCounter::StatsSample::value, Eq(10)))); |
| EXPECT_THAT(stream.AssembledMarginDeficitMs().GetTimedSamples(), IsEmpty()); |
| |
| EXPECT_THAT( |
| stream.RenderedMarginMs().GetTimedSamples(), |
| ElementsAre(Field(&SamplesStatsCounter::StatsSample::value, Eq(-5)))); |
| EXPECT_THAT(stream.RenderedMarginExcessMs().GetTimedSamples(), IsEmpty()); |
| EXPECT_THAT( |
| stream.RenderedMarginDeficitMs().GetTimedSamples(), |
| ElementsAre(Field(&SamplesStatsCounter::StatsSample::value, Eq(-5)))); |
| } |
| |
| Matcher<const Frame&> EqualsFrame(const Frame& expected) { |
| return AllOf( |
| Field("num_packets", &Frame::num_packets, Eq(expected.num_packets)), |
| Field("size", &Frame::size, Eq(expected.size)), |
| |
| Field("payload_type", &Frame::payload_type, Eq(expected.payload_type)), |
| Field("rtp_timestamp", &Frame::rtp_timestamp, Eq(expected.rtp_timestamp)), |
| Field("unwrapped_rtp_timestamp", &Frame::unwrapped_rtp_timestamp, |
| Eq(expected.unwrapped_rtp_timestamp)), |
| |
| Field("frame_id", &Frame::frame_id, Eq(expected.frame_id)), |
| Field("spatial_id", &Frame::spatial_id, Eq(expected.spatial_id)), |
| Field("temporal_id", &Frame::temporal_id, Eq(expected.temporal_id)), |
| Field("num_references", &Frame::num_references, |
| Eq(expected.num_references)), |
| |
| Field("first_packet_arrival_timestamp", |
| &Frame::first_packet_arrival_timestamp, |
| Eq(expected.first_packet_arrival_timestamp)), |
| Field("last_packet_arrival_timestamp", |
| &Frame::last_packet_arrival_timestamp, |
| Eq(expected.last_packet_arrival_timestamp)), |
| |
| Field("assembled_timestamp", &Frame::assembled_timestamp, |
| Eq(expected.assembled_timestamp)), |
| Field("render_timestamp", &Frame::render_timestamp, |
| Eq(expected.render_timestamp)), |
| Field("decoded_timestamp", &Frame::decoded_timestamp, |
| Eq(expected.decoded_timestamp)), |
| Field("rendered_timestamp", &Frame::rendered_timestamp, |
| Eq(expected.rendered_timestamp)), |
| |
| Field("frames_dropped", &Frame::frames_dropped, |
| Eq(expected.frames_dropped)), |
| Field("jitter_buffer_minimum_delay", &Frame::jitter_buffer_minimum_delay, |
| Eq(expected.jitter_buffer_minimum_delay)), |
| Field("jitter_buffer_target_delay", &Frame::jitter_buffer_target_delay, |
| Eq(expected.jitter_buffer_target_delay)), |
| Field("jitter_buffer_delay", &Frame::jitter_buffer_delay, |
| Eq(expected.jitter_buffer_delay))); |
| } |
| |
| TEST(RenderingSimulatorTest, VideoRecvVp8) { |
| std::unique_ptr<ParsedRtcEventLog> parsed_log = |
| ParsedRtcEventLogFromResources("video_recv_vp8_pt96"); |
| |
| RenderingSimulator::Config config{.name = "vp8"}; |
| RenderingSimulator simulator(config); |
| RenderingSimulator::Results results = simulator.Simulate(*parsed_log); |
| |
| EXPECT_THAT(results.config_name, Eq("vp8")); |
| ASSERT_THAT(results.streams, SizeIs(1)); |
| const auto& stream = results.streams.front(); |
| EXPECT_THAT(stream.creation_timestamp, Eq(Timestamp::Millis(100942625))); |
| EXPECT_THAT(stream.ssrc, Eq(3965119250)); |
| EXPECT_THAT(stream.frames, SizeIs(650)); |
| |
| // Spot check the second to last frame. |
| // (The last frame is actually non-decodable due to a VideoReceiveStream2 |
| // recreation in the log.) |
| const auto& last_frame = stream.frames[stream.frames.size() - 2]; |
| EXPECT_THAT( |
| last_frame, |
| EqualsFrame( |
| {// Frame information. |
| .num_packets = 7, |
| .size = DataSize::Bytes(7669), |
| // RTP header information. |
| .payload_type = 96, |
| .rtp_timestamp = 2498233591, |
| .unwrapped_rtp_timestamp = 2498233591, |
| // Dependency descriptor information. |
| .frame_id = 648, |
| .spatial_id = 0, |
| .temporal_id = 0, |
| .num_references = 1, |
| // Packet timestamps. |
| .first_packet_arrival_timestamp = Timestamp::Millis(100964151), |
| .last_packet_arrival_timestamp = Timestamp::Millis(100964166), |
| // Frame timestamps. |
| .assembled_timestamp = Timestamp::Millis(100964166), |
| .render_timestamp = Timestamp::Millis(100964193), |
| .decoded_timestamp = Timestamp::Micros(100964182726), |
| .rendered_timestamp = Timestamp::Micros(100964182726), |
| // Jitter buffer information. |
| .frames_dropped = 0, |
| .jitter_buffer_minimum_delay = TimeDelta::Micros(18861), |
| .jitter_buffer_target_delay = TimeDelta::Micros(18861), |
| .jitter_buffer_delay = TimeDelta::Micros(31726)})); |
| } |
| |
| TEST(RenderingSimulatorTest, VideoRecvVp9) { |
| std::unique_ptr<ParsedRtcEventLog> parsed_log = |
| ParsedRtcEventLogFromResources("video_recv_vp9_pt98"); |
| |
| RenderingSimulator::Config config{.name = "vp9"}; |
| RenderingSimulator simulator(config); |
| RenderingSimulator::Results results = simulator.Simulate(*parsed_log); |
| |
| EXPECT_THAT(results.config_name, Eq("vp9")); |
| ASSERT_THAT(results.streams, SizeIs(1)); |
| const auto& stream = results.streams.front(); |
| EXPECT_THAT(stream.ssrc, Eq(2849747025)); |
| EXPECT_THAT(stream.frames, SizeIs(1493)); |
| |
| // Spot check the last frame. |
| const auto& last_frame = stream.frames.back(); |
| EXPECT_THAT( |
| last_frame, |
| EqualsFrame( |
| {// Frame information. |
| .num_packets = 6, |
| .size = DataSize::Bytes(6265), |
| // RTP header information. |
| .payload_type = 98, |
| .rtp_timestamp = 2236817278, |
| .unwrapped_rtp_timestamp = 2236817278, |
| // Dependency descriptor information. |
| .frame_id = 1493, |
| .spatial_id = 0, |
| .temporal_id = 1, |
| .num_references = 1, |
| // Packet timestamps. |
| .first_packet_arrival_timestamp = Timestamp::Millis(98768274), |
| .last_packet_arrival_timestamp = Timestamp::Millis(98768284), |
| // Frame timestamps. |
| .assembled_timestamp = Timestamp::Millis(98768284), |
| .render_timestamp = Timestamp::Millis(98768325), |
| .decoded_timestamp = Timestamp::Micros(98768315253), |
| .rendered_timestamp = Timestamp::Micros(98768315253), |
| // Jitter buffer state. |
| .frames_dropped = 0, |
| .jitter_buffer_minimum_delay = TimeDelta::Micros(26604), |
| .jitter_buffer_target_delay = TimeDelta::Micros(26604), |
| .jitter_buffer_delay = TimeDelta::Micros(41253)})); |
| } |
| |
| TEST(RenderingSimulatorTest, VideoRecvAv1) { |
| std::unique_ptr<ParsedRtcEventLog> parsed_log = |
| ParsedRtcEventLogFromResources("video_recv_av1_pt45"); |
| |
| RenderingSimulator::Config config{.name = "av1"}; |
| RenderingSimulator simulator(config); |
| RenderingSimulator::Results results = simulator.Simulate(*parsed_log); |
| |
| EXPECT_THAT(results.config_name, Eq("av1")); |
| ASSERT_THAT(results.streams, SizeIs(1)); |
| const auto& stream = results.streams.front(); |
| EXPECT_THAT(stream.ssrc, Eq(2805827407)); |
| EXPECT_THAT(stream.frames, SizeIs(1412)); |
| |
| // Spot check the second to last frame. |
| // (The last frame is actually non-decodable due to a VideoReceiveStream2 |
| // recreation in the log.) |
| const auto& last_frame = stream.frames[stream.frames.size() - 2]; |
| EXPECT_THAT( |
| last_frame, |
| EqualsFrame( |
| {// Frame information. |
| .num_packets = 11, |
| .size = DataSize::Bytes(12705), |
| // RTP header information. |
| .payload_type = 45, |
| .rtp_timestamp = 2213213027, |
| .unwrapped_rtp_timestamp = 2213213027, |
| // Dependency descriptor information. |
| .frame_id = 1410, |
| .spatial_id = 0, |
| .temporal_id = 0, |
| .num_references = 1, |
| // Packet timestamps. |
| .first_packet_arrival_timestamp = Timestamp::Millis(98868775), |
| .last_packet_arrival_timestamp = Timestamp::Millis(98868790), |
| // Frame timestamps. |
| .assembled_timestamp = Timestamp::Millis(98868790), |
| .render_timestamp = Timestamp::Millis(98868822), |
| .decoded_timestamp = Timestamp::Micros(98868811530), |
| .rendered_timestamp = Timestamp::Micros(98868811530), |
| // Jitter buffer state. |
| .frames_dropped = 0, |
| .jitter_buffer_minimum_delay = TimeDelta::Micros(23864), |
| .jitter_buffer_target_delay = TimeDelta::Micros(23864), |
| .jitter_buffer_delay = TimeDelta::Micros(36530)})); |
| } |
| |
| TEST(RenderingSimulatorTest, VideoRecvSequentialJoinVp8Vp9Av1) { |
| std::unique_ptr<ParsedRtcEventLog> parsed_log = |
| ParsedRtcEventLogFromResources("video_recv_sequential_join_vp8_vp9_av1"); |
| |
| RenderingSimulator::Config config; |
| RenderingSimulator simulator(config); |
| RenderingSimulator::Results results = simulator.Simulate(*parsed_log); |
| |
| EXPECT_THAT(results.streams, |
| ElementsAre(AllOf(Field(&Stream::ssrc, Eq(2827012235)), |
| Field(&Stream::frames, SizeIs(1746))), |
| AllOf(Field(&Stream::ssrc, Eq(1651489786)), |
| Field(&Stream::frames, SizeIs(1157))), |
| AllOf(Field(&Stream::ssrc, Eq(1934275846)), |
| Field(&Stream::frames, SizeIs(361))))); |
| } |
| |
| // This log starts experiencing packet losses after half the duration. |
| TEST(RenderingSimulatorTest, VideoRecvVp8Lossy) { |
| std::unique_ptr<ParsedRtcEventLog> parsed_log = |
| ParsedRtcEventLogFromResources("video_recv_vp8_pt96_lossy"); |
| |
| RenderingSimulator::Config config{.name = "vp8"}; |
| RenderingSimulator simulator(config); |
| RenderingSimulator::Results results = simulator.Simulate(*parsed_log); |
| |
| EXPECT_THAT(results.config_name, Eq("vp8")); |
| ASSERT_THAT(results.streams, SizeIs(1)); |
| const auto& stream = results.streams.front(); |
| EXPECT_THAT(stream.creation_timestamp, Eq(Timestamp::Millis(821417933))); |
| EXPECT_THAT(stream.ssrc, Eq(4096673911)); |
| EXPECT_THAT(stream.frames, SizeIs(1145)); |
| // Number of rendered frames. |
| EXPECT_THAT(absl::c_count_if(stream.frames, |
| [](const auto& e) { |
| return e.ArrivalTimestamp().IsFinite(); |
| }), |
| Eq(960)); |
| |
| // Find the last rendered frame. |
| EXPECT_TRUE(absl::c_is_sorted(stream.frames, |
| ArrivalOrder<RenderingSimulator::Frame>)); |
| auto it = stream.frames.rbegin(); |
| while (it != stream.frames.rend() && !it->ArrivalTimestamp().IsFinite()) { |
| ++it; |
| } |
| ASSERT_THAT(it, Ne(stream.frames.rend())); |
| |
| // Spot check the last rendered frame. |
| EXPECT_THAT( |
| *it, |
| EqualsFrame( |
| {// Frame information. |
| .num_packets = 4, |
| .size = DataSize::Bytes(3902), |
| // RTP header information. |
| .payload_type = 96, |
| .rtp_timestamp = 2607363343, |
| .unwrapped_rtp_timestamp = 2607363343, |
| // Dependency descriptor information. |
| .frame_id = 1165, |
| .spatial_id = 0, |
| .temporal_id = 1, |
| .num_references = 1, |
| // Packet timestamps. |
| .first_packet_arrival_timestamp = Timestamp::Millis(821457147), |
| .last_packet_arrival_timestamp = Timestamp::Millis(821457158), |
| // Frame timestamps. |
| .assembled_timestamp = Timestamp::Millis(821457158), |
| .render_timestamp = Timestamp::Millis(821457178), |
| .decoded_timestamp = Timestamp::Micros(821457168065), |
| .rendered_timestamp = Timestamp::Micros(821457168065), |
| // Jitter buffer information. |
| .frames_dropped = 0, |
| // The value below is unreasonably low, we should fix this. |
| .jitter_buffer_minimum_delay = TimeDelta::Micros(13085), |
| .jitter_buffer_target_delay = TimeDelta::Micros(13085), |
| .jitter_buffer_delay = TimeDelta::Micros(21065)})); |
| } |
| |
| } // namespace |
| } // namespace webrtc::video_timing_simulator |
