| /* |
| * 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 "absl/strings/string_view.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/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::Matcher; |
| using ::testing::SizeIs; |
| |
| using Frame = RenderingSimulator::Frame; |
| using Stream = RenderingSimulator::Stream; |
| |
| 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))); |
| } |
| |
| // TODO: b/423646186 - Add tests for logs with losses. |
| |
| 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(98768315261), |
| .rendered_timestamp = Timestamp::Micros(98768315261), |
| // Jitter buffer state. |
| .frames_dropped = 0, |
| .jitter_buffer_minimum_delay = TimeDelta::Micros(26611), |
| .jitter_buffer_target_delay = TimeDelta::Micros(26611), |
| .jitter_buffer_delay = TimeDelta::Micros(41261)})); |
| } |
| |
| 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(98868811531), |
| .rendered_timestamp = Timestamp::Micros(98868811531), |
| // 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(36531)})); |
| } |
| |
| 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))))); |
| } |
| |
| } // namespace |
| } // namespace webrtc::video_timing_simulator |
