`RtpPacketInfo`: new ctor + deprecated ctors clean-up
New ctor added without optional and media specific fields.
Bug: webrtc:10739, b/246753278
Change-Id: I7e15849aced6ed0a7ada725ea171a15ea1e9bc5a
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/275941
Reviewed-by: Ivo Creusen <ivoc@webrtc.org>
Reviewed-by: Tomas Gunnarsson <tommi@webrtc.org>
Commit-Queue: Alessio Bazzica <alessiob@webrtc.org>
Reviewed-by: Danil Chapovalov <danilchap@webrtc.org>
Reviewed-by: Erik Språng <sprang@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#38124}
diff --git a/api/rtp_packet_info.cc b/api/rtp_packet_info.cc
index db818f7..312dc33 100644
--- a/api/rtp_packet_info.cc
+++ b/api/rtp_packet_info.cc
@@ -18,6 +18,15 @@
RtpPacketInfo::RtpPacketInfo()
: ssrc_(0), rtp_timestamp_(0), receive_time_(Timestamp::MinusInfinity()) {}
+RtpPacketInfo::RtpPacketInfo(uint32_t ssrc,
+ std::vector<uint32_t> csrcs,
+ uint32_t rtp_timestamp,
+ Timestamp receive_time)
+ : ssrc_(ssrc),
+ csrcs_(std::move(csrcs)),
+ rtp_timestamp_(rtp_timestamp),
+ receive_time_(receive_time) {}
+
RtpPacketInfo::RtpPacketInfo(
uint32_t ssrc,
std::vector<uint32_t> csrcs,
@@ -28,9 +37,9 @@
: ssrc_(ssrc),
csrcs_(std::move(csrcs)),
rtp_timestamp_(rtp_timestamp),
+ receive_time_(receive_time),
audio_level_(audio_level),
- absolute_capture_time_(absolute_capture_time),
- receive_time_(receive_time) {}
+ absolute_capture_time_(absolute_capture_time) {}
RtpPacketInfo::RtpPacketInfo(const RTPHeader& rtp_header,
Timestamp receive_time)
@@ -69,11 +78,10 @@
bool operator==(const RtpPacketInfo& lhs, const RtpPacketInfo& rhs) {
return (lhs.ssrc() == rhs.ssrc()) && (lhs.csrcs() == rhs.csrcs()) &&
(lhs.rtp_timestamp() == rhs.rtp_timestamp()) &&
+ (lhs.receive_time() == rhs.receive_time()) &&
(lhs.audio_level() == rhs.audio_level()) &&
(lhs.absolute_capture_time() == rhs.absolute_capture_time()) &&
- (lhs.receive_time() == rhs.receive_time() &&
- (lhs.local_capture_clock_offset() ==
- rhs.local_capture_clock_offset()));
+ (lhs.local_capture_clock_offset() == rhs.local_capture_clock_offset());
}
} // namespace webrtc
diff --git a/api/rtp_packet_info.h b/api/rtp_packet_info.h
index bc9839f..f9980a1c 100644
--- a/api/rtp_packet_info.h
+++ b/api/rtp_packet_info.h
@@ -34,6 +34,13 @@
RtpPacketInfo(uint32_t ssrc,
std::vector<uint32_t> csrcs,
uint32_t rtp_timestamp,
+ Timestamp receive_time);
+
+ // TODO(bugs.webrtc.org/12722): Deprecated, remove once downstream projects
+ // are updated.
+ RtpPacketInfo(uint32_t ssrc,
+ std::vector<uint32_t> csrcs,
+ uint32_t rtp_timestamp,
absl::optional<uint8_t> audio_level,
absl::optional<AbsoluteCaptureTime> absolute_capture_time,
Timestamp receive_time);
@@ -64,31 +71,36 @@
uint32_t rtp_timestamp() const { return rtp_timestamp_; }
void set_rtp_timestamp(uint32_t value) { rtp_timestamp_ = value; }
- absl::optional<uint8_t> audio_level() const { return audio_level_; }
- void set_audio_level(absl::optional<uint8_t> value) { audio_level_ = value; }
-
- const absl::optional<AbsoluteCaptureTime>& absolute_capture_time() const {
- return absolute_capture_time_;
- }
- void set_absolute_capture_time(
- const absl::optional<AbsoluteCaptureTime>& value) {
- absolute_capture_time_ = value;
- }
-
- const absl::optional<int64_t>& local_capture_clock_offset() const {
- return local_capture_clock_offset_;
- }
-
- void set_local_capture_clock_offset(const absl::optional<int64_t>& value) {
- local_capture_clock_offset_ = value;
- }
-
Timestamp receive_time() const { return receive_time_; }
void set_receive_time(Timestamp value) { receive_time_ = value; }
// TODO(bugs.webrtc.org/12722): Deprecated, remove once downstream projects
// are updated.
int64_t receive_time_ms() const { return receive_time_.ms(); }
+ absl::optional<uint8_t> audio_level() const { return audio_level_; }
+ RtpPacketInfo& set_audio_level(absl::optional<uint8_t> value) {
+ audio_level_ = value;
+ return *this;
+ }
+
+ const absl::optional<AbsoluteCaptureTime>& absolute_capture_time() const {
+ return absolute_capture_time_;
+ }
+ RtpPacketInfo& set_absolute_capture_time(
+ const absl::optional<AbsoluteCaptureTime>& value) {
+ absolute_capture_time_ = value;
+ return *this;
+ }
+
+ const absl::optional<int64_t>& local_capture_clock_offset() const {
+ return local_capture_clock_offset_;
+ }
+ RtpPacketInfo& set_local_capture_clock_offset(
+ const absl::optional<int64_t>& value) {
+ local_capture_clock_offset_ = value;
+ return *this;
+ }
+
private:
// Fields from the RTP header:
// https://tools.ietf.org/html/rfc3550#section-5.1
@@ -96,6 +108,9 @@
std::vector<uint32_t> csrcs_;
uint32_t rtp_timestamp_;
+ // Local `webrtc::Clock`-based timestamp of when the packet was received.
+ Timestamp receive_time_;
+
// Fields from the Audio Level header extension:
// https://tools.ietf.org/html/rfc6464#section-3
absl::optional<uint8_t> audio_level_;
@@ -112,9 +127,6 @@
// Clock offset against capturer's clock. Should be derived from the estimated
// capture clock offset defined in the Absolute Capture Time header extension.
absl::optional<int64_t> local_capture_clock_offset_;
-
- // Local `webrtc::Clock`-based timestamp of when the packet was received.
- Timestamp receive_time_;
};
bool operator==(const RtpPacketInfo& lhs, const RtpPacketInfo& rhs);
diff --git a/api/rtp_packet_info_unittest.cc b/api/rtp_packet_info_unittest.cc
index 0e82aef..80abccc 100644
--- a/api/rtp_packet_info_unittest.cc
+++ b/api/rtp_packet_info_unittest.cc
@@ -15,7 +15,7 @@
namespace webrtc {
TEST(RtpPacketInfoTest, Ssrc) {
- const uint32_t value = 4038189233;
+ constexpr uint32_t kValue = 4038189233;
RtpPacketInfo lhs;
RtpPacketInfo rhs;
@@ -23,8 +23,8 @@
EXPECT_TRUE(lhs == rhs);
EXPECT_FALSE(lhs != rhs);
- rhs.set_ssrc(value);
- EXPECT_EQ(rhs.ssrc(), value);
+ rhs.set_ssrc(kValue);
+ EXPECT_EQ(rhs.ssrc(), kValue);
EXPECT_FALSE(lhs == rhs);
EXPECT_TRUE(lhs != rhs);
@@ -35,10 +35,11 @@
EXPECT_FALSE(lhs != rhs);
rhs = RtpPacketInfo();
- EXPECT_NE(rhs.ssrc(), value);
+ EXPECT_NE(rhs.ssrc(), kValue);
- rhs = RtpPacketInfo(value, {}, {}, {}, {}, Timestamp::Zero());
- EXPECT_EQ(rhs.ssrc(), value);
+ rhs = RtpPacketInfo(/*ssrc=*/kValue, /*csrcs=*/{}, /*rtp_timestamp=*/{},
+ /*receive_time=*/Timestamp::Zero());
+ EXPECT_EQ(rhs.ssrc(), kValue);
}
TEST(RtpPacketInfoTest, Csrcs) {
@@ -64,12 +65,13 @@
rhs = RtpPacketInfo();
EXPECT_NE(rhs.csrcs(), value);
- rhs = RtpPacketInfo({}, value, {}, {}, {}, Timestamp::Zero());
+ rhs = RtpPacketInfo(/*ssrc=*/{}, /*csrcs=*/value, /*rtp_timestamp=*/{},
+ /*receive_time=*/Timestamp::Zero());
EXPECT_EQ(rhs.csrcs(), value);
}
TEST(RtpPacketInfoTest, RtpTimestamp) {
- const uint32_t value = 4038189233;
+ constexpr uint32_t kValue = 4038189233;
RtpPacketInfo lhs;
RtpPacketInfo rhs;
@@ -77,8 +79,8 @@
EXPECT_TRUE(lhs == rhs);
EXPECT_FALSE(lhs != rhs);
- rhs.set_rtp_timestamp(value);
- EXPECT_EQ(rhs.rtp_timestamp(), value);
+ rhs.set_rtp_timestamp(kValue);
+ EXPECT_EQ(rhs.rtp_timestamp(), kValue);
EXPECT_FALSE(lhs == rhs);
EXPECT_TRUE(lhs != rhs);
@@ -89,97 +91,15 @@
EXPECT_FALSE(lhs != rhs);
rhs = RtpPacketInfo();
- EXPECT_NE(rhs.rtp_timestamp(), value);
+ EXPECT_NE(rhs.rtp_timestamp(), kValue);
- rhs = RtpPacketInfo({}, {}, value, {}, {}, Timestamp::Zero());
- EXPECT_EQ(rhs.rtp_timestamp(), value);
-}
-
-TEST(RtpPacketInfoTest, AudioLevel) {
- const absl::optional<uint8_t> value = 31;
-
- RtpPacketInfo lhs;
- RtpPacketInfo rhs;
-
- EXPECT_TRUE(lhs == rhs);
- EXPECT_FALSE(lhs != rhs);
-
- rhs.set_audio_level(value);
- EXPECT_EQ(rhs.audio_level(), value);
-
- EXPECT_FALSE(lhs == rhs);
- EXPECT_TRUE(lhs != rhs);
-
- lhs = rhs;
-
- EXPECT_TRUE(lhs == rhs);
- EXPECT_FALSE(lhs != rhs);
-
- rhs = RtpPacketInfo();
- EXPECT_NE(rhs.audio_level(), value);
-
- rhs = RtpPacketInfo({}, {}, {}, value, {}, Timestamp::Zero());
- EXPECT_EQ(rhs.audio_level(), value);
-}
-
-TEST(RtpPacketInfoTest, AbsoluteCaptureTime) {
- const absl::optional<AbsoluteCaptureTime> value = AbsoluteCaptureTime{12, 34};
-
- RtpPacketInfo lhs;
- RtpPacketInfo rhs;
-
- EXPECT_TRUE(lhs == rhs);
- EXPECT_FALSE(lhs != rhs);
-
- rhs.set_absolute_capture_time(value);
- EXPECT_EQ(rhs.absolute_capture_time(), value);
-
- EXPECT_FALSE(lhs == rhs);
- EXPECT_TRUE(lhs != rhs);
-
- lhs = rhs;
-
- EXPECT_TRUE(lhs == rhs);
- EXPECT_FALSE(lhs != rhs);
-
- rhs = RtpPacketInfo();
- EXPECT_NE(rhs.absolute_capture_time(), value);
-
- rhs = RtpPacketInfo({}, {}, {}, {}, value, Timestamp::Zero());
- EXPECT_EQ(rhs.absolute_capture_time(), value);
-}
-
-TEST(RtpPacketInfoTest, LocalCaptureClockOffset) {
- RtpPacketInfo lhs;
- RtpPacketInfo rhs;
-
- EXPECT_TRUE(lhs == rhs);
- EXPECT_FALSE(lhs != rhs);
-
- const absl::optional<int64_t> value = 10;
- rhs.set_local_capture_clock_offset(value);
- EXPECT_EQ(rhs.local_capture_clock_offset(), value);
-
- EXPECT_FALSE(lhs == rhs);
- EXPECT_TRUE(lhs != rhs);
-
- lhs = rhs;
-
- EXPECT_TRUE(lhs == rhs);
- EXPECT_FALSE(lhs != rhs);
-
- // Default local capture clock offset is null.
- rhs = RtpPacketInfo();
- EXPECT_EQ(rhs.local_capture_clock_offset(), absl::nullopt);
-
- // Default local capture clock offset is null.
- rhs = RtpPacketInfo({}, {}, {}, {}, AbsoluteCaptureTime{12, 34},
- Timestamp::Zero());
- EXPECT_EQ(rhs.local_capture_clock_offset(), absl::nullopt);
+ rhs = RtpPacketInfo(/*ssrc=*/{}, /*csrcs=*/{}, /*rtp_timestamp=*/kValue,
+ /*receive_time=*/Timestamp::Zero());
+ EXPECT_EQ(rhs.rtp_timestamp(), kValue);
}
TEST(RtpPacketInfoTest, ReceiveTimeMs) {
- const Timestamp timestamp = Timestamp::Micros(8868963877546349045LL);
+ constexpr Timestamp kValue = Timestamp::Micros(8868963877546349045LL);
RtpPacketInfo lhs;
RtpPacketInfo rhs;
@@ -187,8 +107,8 @@
EXPECT_TRUE(lhs == rhs);
EXPECT_FALSE(lhs != rhs);
- rhs.set_receive_time(timestamp);
- EXPECT_EQ(rhs.receive_time(), timestamp);
+ rhs.set_receive_time(kValue);
+ EXPECT_EQ(rhs.receive_time(), kValue);
EXPECT_FALSE(lhs == rhs);
EXPECT_TRUE(lhs != rhs);
@@ -199,10 +119,99 @@
EXPECT_FALSE(lhs != rhs);
rhs = RtpPacketInfo();
- EXPECT_NE(rhs.receive_time(), timestamp);
+ EXPECT_NE(rhs.receive_time(), kValue);
- rhs = RtpPacketInfo({}, {}, {}, {}, {}, timestamp);
- EXPECT_EQ(rhs.receive_time(), timestamp);
+ rhs = RtpPacketInfo(/*ssrc=*/{}, /*csrcs=*/{}, /*rtp_timestamp=*/{},
+ /*receive_time=*/kValue);
+ EXPECT_EQ(rhs.receive_time(), kValue);
+}
+
+TEST(RtpPacketInfoTest, AudioLevel) {
+ constexpr absl::optional<uint8_t> kValue = 31;
+
+ RtpPacketInfo lhs;
+ RtpPacketInfo rhs;
+
+ EXPECT_TRUE(lhs == rhs);
+ EXPECT_FALSE(lhs != rhs);
+
+ rhs.set_audio_level(kValue);
+ EXPECT_EQ(rhs.audio_level(), kValue);
+
+ EXPECT_FALSE(lhs == rhs);
+ EXPECT_TRUE(lhs != rhs);
+
+ lhs = rhs;
+
+ EXPECT_TRUE(lhs == rhs);
+ EXPECT_FALSE(lhs != rhs);
+
+ rhs = RtpPacketInfo();
+ EXPECT_NE(rhs.audio_level(), kValue);
+
+ rhs = RtpPacketInfo(/*ssrc=*/{}, /*csrcs=*/{}, /*rtp_timestamp=*/{},
+ /*receive_time=*/Timestamp::Zero());
+ rhs.set_audio_level(kValue);
+ EXPECT_EQ(rhs.audio_level(), kValue);
+}
+
+TEST(RtpPacketInfoTest, AbsoluteCaptureTime) {
+ constexpr absl::optional<AbsoluteCaptureTime> kValue = AbsoluteCaptureTime{
+ .absolute_capture_timestamp = 12, .estimated_capture_clock_offset = 34};
+
+ RtpPacketInfo lhs;
+ RtpPacketInfo rhs;
+
+ EXPECT_TRUE(lhs == rhs);
+ EXPECT_FALSE(lhs != rhs);
+
+ rhs.set_absolute_capture_time(kValue);
+ EXPECT_EQ(rhs.absolute_capture_time(), kValue);
+
+ EXPECT_FALSE(lhs == rhs);
+ EXPECT_TRUE(lhs != rhs);
+
+ lhs = rhs;
+
+ EXPECT_TRUE(lhs == rhs);
+ EXPECT_FALSE(lhs != rhs);
+
+ rhs = RtpPacketInfo();
+ EXPECT_NE(rhs.absolute_capture_time(), kValue);
+
+ rhs = RtpPacketInfo(/*ssrc=*/{}, /*csrcs=*/{}, /*rtp_timestamp=*/{},
+ /*receive_time=*/Timestamp::Zero());
+ rhs.set_absolute_capture_time(kValue);
+ EXPECT_EQ(rhs.absolute_capture_time(), kValue);
+}
+
+TEST(RtpPacketInfoTest, LocalCaptureClockOffset) {
+ constexpr absl::optional<int64_t> kValue = 10;
+
+ RtpPacketInfo lhs;
+ RtpPacketInfo rhs;
+
+ EXPECT_TRUE(lhs == rhs);
+ EXPECT_FALSE(lhs != rhs);
+
+ rhs.set_local_capture_clock_offset(kValue);
+ EXPECT_EQ(rhs.local_capture_clock_offset(), kValue);
+
+ EXPECT_FALSE(lhs == rhs);
+ EXPECT_TRUE(lhs != rhs);
+
+ lhs = rhs;
+
+ EXPECT_TRUE(lhs == rhs);
+ EXPECT_FALSE(lhs != rhs);
+
+ rhs = RtpPacketInfo();
+ EXPECT_EQ(rhs.local_capture_clock_offset(), absl::nullopt);
+
+ rhs = RtpPacketInfo(/*ssrc=*/{}, /*csrcs=*/{}, /*rtp_timestamp=*/{},
+ /*receive_time=*/Timestamp::Zero());
+ rhs.set_local_capture_clock_offset(kValue);
+ EXPECT_EQ(rhs.local_capture_clock_offset(), kValue);
}
} // namespace webrtc
diff --git a/api/rtp_packet_infos_unittest.cc b/api/rtp_packet_infos_unittest.cc
index e83358f..a90cfa0 100644
--- a/api/rtp_packet_infos_unittest.cc
+++ b/api/rtp_packet_infos_unittest.cc
@@ -27,12 +27,23 @@
} // namespace
TEST(RtpPacketInfosTest, BasicFunctionality) {
- RtpPacketInfo p0(123, {1, 2}, 89, 5, AbsoluteCaptureTime{45, 78},
- Timestamp::Millis(7));
- RtpPacketInfo p1(456, {3, 4}, 89, 4, AbsoluteCaptureTime{13, 21},
- Timestamp::Millis(1));
- RtpPacketInfo p2(789, {5, 6}, 88, 1, AbsoluteCaptureTime{99, 78},
- Timestamp::Millis(7));
+ RtpPacketInfo p0(/*ssrc=*/123, /*csrcs=*/{1, 2}, /*rtp_timestamp=*/89,
+ /*receive_time=*/Timestamp::Millis(7));
+ p0.set_audio_level(5);
+ p0.set_absolute_capture_time(AbsoluteCaptureTime{
+ .absolute_capture_timestamp = 45, .estimated_capture_clock_offset = 78});
+
+ RtpPacketInfo p1(/*ssrc=*/456, /*csrcs=*/{3, 4}, /*rtp_timestamp=*/89,
+ /*receive_time=*/Timestamp::Millis(1));
+ p1.set_audio_level(4);
+ p1.set_absolute_capture_time(AbsoluteCaptureTime{
+ .absolute_capture_timestamp = 13, .estimated_capture_clock_offset = 21});
+
+ RtpPacketInfo p2(/*ssrc=*/789, /*csrcs=*/{5, 6}, /*rtp_timestamp=*/88,
+ /*receive_time=*/Timestamp::Millis(7));
+ p2.set_audio_level(1);
+ p2.set_absolute_capture_time(AbsoluteCaptureTime{
+ .absolute_capture_timestamp = 99, .estimated_capture_clock_offset = 78});
RtpPacketInfos x({p0, p1, p2});
@@ -55,12 +66,23 @@
}
TEST(RtpPacketInfosTest, CopyShareData) {
- RtpPacketInfo p0(123, {1, 2}, 89, 5, AbsoluteCaptureTime{45, 78},
- Timestamp::Millis(7));
- RtpPacketInfo p1(456, {3, 4}, 89, 4, AbsoluteCaptureTime{13, 21},
- Timestamp::Millis(1));
- RtpPacketInfo p2(789, {5, 6}, 88, 1, AbsoluteCaptureTime{99, 78},
- Timestamp::Millis(7));
+ RtpPacketInfo p0(/*ssrc=*/123, /*csrcs=*/{1, 2}, /*rtp_timestamp=*/89,
+ /*receive_time=*/Timestamp::Millis(7));
+ p0.set_audio_level(5);
+ p0.set_absolute_capture_time(AbsoluteCaptureTime{
+ .absolute_capture_timestamp = 45, .estimated_capture_clock_offset = 78});
+
+ RtpPacketInfo p1(/*ssrc=*/456, /*csrcs=*/{3, 4}, /*rtp_timestamp=*/89,
+ /*receive_time=*/Timestamp::Millis(1));
+ p1.set_audio_level(4);
+ p1.set_absolute_capture_time(AbsoluteCaptureTime{
+ .absolute_capture_timestamp = 13, .estimated_capture_clock_offset = 21});
+
+ RtpPacketInfo p2(/*ssrc=*/789, /*csrcs=*/{5, 6}, /*rtp_timestamp=*/88,
+ /*receive_time=*/Timestamp::Millis(7));
+ p2.set_audio_level(1);
+ p2.set_absolute_capture_time(AbsoluteCaptureTime{
+ .absolute_capture_timestamp = 99, .estimated_capture_clock_offset = 78});
RtpPacketInfos lhs({p0, p1, p2});
RtpPacketInfos rhs = lhs;
diff --git a/modules/audio_coding/neteq/red_payload_splitter.cc b/modules/audio_coding/neteq/red_payload_splitter.cc
index 7438f25..cec9f2f 100644
--- a/modules/audio_coding/neteq/red_payload_splitter.cc
+++ b/modules/audio_coding/neteq/red_payload_splitter.cc
@@ -136,9 +136,9 @@
/*ssrc=*/red_packet.packet_info.ssrc(),
/*csrcs=*/std::vector<uint32_t>(),
/*rtp_timestamp=*/new_packet.timestamp,
- red_packet.packet_info.audio_level(),
- /*absolute_capture_time=*/absl::nullopt,
/*receive_time=*/red_packet.packet_info.receive_time());
+ new_packet.packet_info.set_audio_level(
+ red_packet.packet_info.audio_level());
new_packets.push_front(std::move(new_packet));
payload_ptr += payload_length;
}
diff --git a/modules/audio_mixer/audio_mixer_impl_unittest.cc b/modules/audio_mixer/audio_mixer_impl_unittest.cc
index 20b7d29..e4b12a7 100644
--- a/modules/audio_mixer/audio_mixer_impl_unittest.cc
+++ b/modules/audio_mixer/audio_mixer_impl_unittest.cc
@@ -665,30 +665,29 @@
const Timestamp kReceiveTime0 = Timestamp::Millis(10);
const Timestamp kReceiveTime1 = Timestamp::Millis(20);
- const RtpPacketInfo kPacketInfo0(kSsrc0, {kCsrc0, kCsrc1}, kRtpTimestamp0,
- kAudioLevel0, absl::nullopt, kReceiveTime0);
- const RtpPacketInfo kPacketInfo1(kSsrc1, {kCsrc2}, kRtpTimestamp1,
- kAudioLevel1, absl::nullopt, kReceiveTime1);
- const RtpPacketInfo kPacketInfo2(kSsrc2, {kCsrc3}, kRtpTimestamp1,
- kAudioLevel2, absl::nullopt, kReceiveTime1);
+ RtpPacketInfo p0(kSsrc0, {kCsrc0, kCsrc1}, kRtpTimestamp0, kReceiveTime0);
+ p0.set_audio_level(kAudioLevel0);
+ RtpPacketInfo p1(kSsrc1, {kCsrc2}, kRtpTimestamp1, kReceiveTime1);
+ p1.set_audio_level(kAudioLevel1);
+ RtpPacketInfo p2(kSsrc2, {kCsrc3}, kRtpTimestamp1, kReceiveTime1);
+ p2.set_audio_level(kAudioLevel2);
const auto mixer = AudioMixerImpl::Create();
MockMixerAudioSource source;
- source.set_packet_infos(RtpPacketInfos({kPacketInfo0}));
+ source.set_packet_infos(RtpPacketInfos({p0}));
mixer->AddSource(&source);
ResetFrame(source.fake_frame());
mixer->Mix(1, &frame_for_mixing);
MockMixerAudioSource other_source;
- other_source.set_packet_infos(RtpPacketInfos({kPacketInfo1, kPacketInfo2}));
+ other_source.set_packet_infos(RtpPacketInfos({p1, p2}));
ResetFrame(other_source.fake_frame());
mixer->AddSource(&other_source);
mixer->Mix(/*number_of_channels=*/1, &frame_for_mixing);
- EXPECT_THAT(frame_for_mixing.packet_infos_,
- UnorderedElementsAre(kPacketInfo0, kPacketInfo1, kPacketInfo2));
+ EXPECT_THAT(frame_for_mixing.packet_infos_, UnorderedElementsAre(p0, p1, p2));
}
TEST(AudioMixer, MixerShouldIncludeRtpPacketInfoFromMixedSourcesOnly) {
@@ -706,25 +705,23 @@
const Timestamp kReceiveTime0 = Timestamp::Millis(10);
const Timestamp kReceiveTime1 = Timestamp::Millis(20);
- const RtpPacketInfo kPacketInfo0(kSsrc0, {kCsrc0, kCsrc1}, kRtpTimestamp0,
- kAudioLevel0, absl::nullopt, kReceiveTime0);
- const RtpPacketInfo kPacketInfo1(kSsrc1, {kCsrc2}, kRtpTimestamp1,
- kAudioLevelMissing, absl::nullopt,
- kReceiveTime1);
- const RtpPacketInfo kPacketInfo2(kSsrc2, {kCsrc3}, kRtpTimestamp1,
- kAudioLevelMissing, absl::nullopt,
- kReceiveTime1);
+ RtpPacketInfo p0(kSsrc0, {kCsrc0, kCsrc1}, kRtpTimestamp0, kReceiveTime0);
+ p0.set_audio_level(kAudioLevel0);
+ RtpPacketInfo p1(kSsrc1, {kCsrc2}, kRtpTimestamp1, kReceiveTime1);
+ p1.set_audio_level(kAudioLevelMissing);
+ RtpPacketInfo p2(kSsrc2, {kCsrc3}, kRtpTimestamp1, kReceiveTime1);
+ p2.set_audio_level(kAudioLevelMissing);
const auto mixer = AudioMixerImpl::Create(/*max_sources_to_mix=*/2);
MockMixerAudioSource source1;
- source1.set_packet_infos(RtpPacketInfos({kPacketInfo0}));
+ source1.set_packet_infos(RtpPacketInfos({p0}));
mixer->AddSource(&source1);
ResetFrame(source1.fake_frame());
mixer->Mix(1, &frame_for_mixing);
MockMixerAudioSource source2;
- source2.set_packet_infos(RtpPacketInfos({kPacketInfo1}));
+ source2.set_packet_infos(RtpPacketInfos({p1}));
ResetFrame(source2.fake_frame());
mixer->AddSource(&source2);
@@ -732,15 +729,14 @@
// We limit the number of sources to mix to 2 and set the third source's VAD
// activity to kVadPassive so that it will not be added to the mix.
MockMixerAudioSource source3;
- source3.set_packet_infos(RtpPacketInfos({kPacketInfo2}));
+ source3.set_packet_infos(RtpPacketInfos({p2}));
ResetFrame(source3.fake_frame());
source3.fake_frame()->vad_activity_ = AudioFrame::kVadPassive;
mixer->AddSource(&source3);
mixer->Mix(/*number_of_channels=*/1, &frame_for_mixing);
- EXPECT_THAT(frame_for_mixing.packet_infos_,
- UnorderedElementsAre(kPacketInfo0, kPacketInfo1));
+ EXPECT_THAT(frame_for_mixing.packet_infos_, UnorderedElementsAre(p0, p1));
}
class HighOutputRateCalculator : public OutputRateCalculator {
diff --git a/modules/audio_mixer/frame_combiner_unittest.cc b/modules/audio_mixer/frame_combiner_unittest.cc
index fa1fef3..36bf3a0 100644
--- a/modules/audio_mixer/frame_combiner_unittest.cc
+++ b/modules/audio_mixer/frame_combiner_unittest.cc
@@ -21,6 +21,7 @@
#include "api/array_view.h"
#include "api/rtp_packet_info.h"
#include "api/rtp_packet_infos.h"
+#include "api/units/timestamp.h"
#include "audio/utility/audio_frame_operations.h"
#include "modules/audio_mixer/gain_change_calculator.h"
#include "modules/audio_mixer/sine_wave_generator.h"
@@ -69,18 +70,15 @@
AudioFrame frame2;
void SetUpFrames(int sample_rate_hz, int number_of_channels) {
- RtpPacketInfo packet_info1(
- /*ssrc=*/1001, /*csrcs=*/{}, /*rtp_timestamp=*/1000,
- /*audio_level=*/absl::nullopt, /*absolute_capture_time=*/absl::nullopt,
- /*receive_time_ms=*/1);
- RtpPacketInfo packet_info2(
- /*ssrc=*/4004, /*csrcs=*/{}, /*rtp_timestamp=*/1234,
- /*audio_level=*/absl::nullopt, /*absolute_capture_time=*/absl::nullopt,
- /*receive_time_ms=*/2);
- RtpPacketInfo packet_info3(
- /*ssrc=*/7007, /*csrcs=*/{}, /*rtp_timestamp=*/1333,
- /*audio_level=*/absl::nullopt, /*absolute_capture_time=*/absl::nullopt,
- /*receive_time_ms=*/2);
+ RtpPacketInfo packet_info1(/*ssrc=*/1001, /*csrcs=*/{},
+ /*rtp_timestamp=*/1000,
+ /*receive_time=*/Timestamp::Millis(1));
+ RtpPacketInfo packet_info2(/*ssrc=*/4004, /*csrcs=*/{},
+ /*rtp_timestamp=*/1234,
+ /*receive_time=*/Timestamp::Millis(2));
+ RtpPacketInfo packet_info3(/*ssrc=*/7007, /*csrcs=*/{},
+ /*rtp_timestamp=*/1333,
+ /*receive_time=*/Timestamp::Millis(2));
frame1.packet_infos_ = RtpPacketInfos({packet_info1});
frame2.packet_infos_ = RtpPacketInfos({packet_info2, packet_info3});
diff --git a/modules/rtp_rtcp/source/source_tracker_unittest.cc b/modules/rtp_rtcp/source/source_tracker_unittest.cc
index 4cd8ab8..e0440a0 100644
--- a/modules/rtp_rtcp/source/source_tracker_unittest.cc
+++ b/modules/rtp_rtcp/source/source_tracker_unittest.cc
@@ -108,10 +108,11 @@
RtpPacketInfos::vector_type packet_infos;
for (size_t i = 0; i < count; ++i) {
- packet_infos.emplace_back(GenerateSsrc(), GenerateCsrcs(),
- GenerateRtpTimestamp(), GenerateAudioLevel(),
- GenerateAbsoluteCaptureTime(),
- GenerateReceiveTime());
+ packet_infos
+ .emplace_back(GenerateSsrc(), GenerateCsrcs(), GenerateRtpTimestamp(),
+ GenerateReceiveTime())
+ .set_audio_level(GenerateAudioLevel())
+ .set_absolute_capture_time(GenerateAbsoluteCaptureTime());
}
return RtpPacketInfos(std::move(packet_infos));
@@ -260,10 +261,12 @@
SourceTracker tracker(&clock);
tracker.OnFrameDelivered(RtpPacketInfos(
- {RtpPacketInfo(kSsrc1, {kCsrcs0, kCsrcs1}, kRtpTimestamp0, kAudioLevel0,
- kAbsoluteCaptureTime, kReceiveTime0),
- RtpPacketInfo(kSsrc2, {kCsrcs2}, kRtpTimestamp1, kAudioLevel1,
- kAbsoluteCaptureTime, kReceiveTime1)}));
+ {RtpPacketInfo(kSsrc1, {kCsrcs0, kCsrcs1}, kRtpTimestamp0, kReceiveTime0)
+ .set_audio_level(kAudioLevel0)
+ .set_absolute_capture_time(kAbsoluteCaptureTime),
+ RtpPacketInfo(kSsrc2, {kCsrcs2}, kRtpTimestamp1, kReceiveTime1)
+ .set_audio_level(kAudioLevel1)
+ .set_absolute_capture_time(kAbsoluteCaptureTime)}));
int64_t timestamp_ms = clock.TimeInMilliseconds();
constexpr RtpSource::Extensions extensions0 = {
@@ -307,13 +310,17 @@
SimulatedClock clock(1000000000000ULL);
SourceTracker tracker(&clock);
- tracker.OnFrameDelivered(RtpPacketInfos(
- {RtpPacketInfo(kSsrc, {kCsrcs0, kCsrcs1}, kRtpTimestamp0, kAudioLevel0,
- kAbsoluteCaptureTime, kReceiveTime0),
- RtpPacketInfo(kSsrc, {kCsrcs2}, kRtpTimestamp1, kAudioLevel1,
- kAbsoluteCaptureTime, kReceiveTime1),
- RtpPacketInfo(kSsrc, {kCsrcs0}, kRtpTimestamp2, kAudioLevel2,
- kAbsoluteCaptureTime, kReceiveTime2)}));
+ tracker.OnFrameDelivered(RtpPacketInfos({
+ RtpPacketInfo(kSsrc, {kCsrcs0, kCsrcs1}, kRtpTimestamp0, kReceiveTime0)
+ .set_audio_level(kAudioLevel0)
+ .set_absolute_capture_time(kAbsoluteCaptureTime),
+ RtpPacketInfo(kSsrc, {kCsrcs2}, kRtpTimestamp1, kReceiveTime1)
+ .set_audio_level(kAudioLevel1)
+ .set_absolute_capture_time(kAbsoluteCaptureTime),
+ RtpPacketInfo(kSsrc, {kCsrcs0}, kRtpTimestamp2, kReceiveTime2)
+ .set_audio_level(kAudioLevel2)
+ .set_absolute_capture_time(kAbsoluteCaptureTime),
+ }));
int64_t timestamp_ms = clock.TimeInMilliseconds();
constexpr RtpSource::Extensions extensions0 = {kAudioLevel0,
@@ -370,8 +377,9 @@
SourceTracker tracker(&clock);
tracker.OnFrameDelivered(RtpPacketInfos(
- {RtpPacketInfo(kSsrc1, {kCsrcs0, kCsrcs1}, kRtpTimestamp0, kAudioLevel0,
- kAbsoluteCaptureTime0, kReceiveTime0)}));
+ {RtpPacketInfo(kSsrc1, {kCsrcs0, kCsrcs1}, kRtpTimestamp0, kReceiveTime0)
+ .set_audio_level(kAudioLevel0)
+ .set_absolute_capture_time(kAbsoluteCaptureTime0)}));
int64_t timestamp_ms_0 = clock.TimeInMilliseconds();
EXPECT_THAT(
@@ -387,8 +395,9 @@
clock.AdvanceTimeMilliseconds(17);
tracker.OnFrameDelivered(RtpPacketInfos(
- {RtpPacketInfo(kSsrc1, {kCsrcs0, kCsrcs2}, kRtpTimestamp1, kAudioLevel1,
- kAbsoluteCaptureTime1, kReceiveTime1)}));
+ {RtpPacketInfo(kSsrc1, {kCsrcs0, kCsrcs2}, kRtpTimestamp1, kReceiveTime1)
+ .set_audio_level(kAudioLevel1)
+ .set_absolute_capture_time(kAbsoluteCaptureTime1)}));
int64_t timestamp_ms_1 = clock.TimeInMilliseconds();
@@ -405,9 +414,11 @@
// Deliver more packets with update csrcs and a new ssrc.
clock.AdvanceTimeMilliseconds(17);
+
tracker.OnFrameDelivered(RtpPacketInfos(
- {RtpPacketInfo(kSsrc2, {kCsrcs0}, kRtpTimestamp2, kAudioLevel2,
- kAbsoluteCaptureTime2, kReceiveTime2)}));
+ {RtpPacketInfo(kSsrc2, {kCsrcs0}, kRtpTimestamp2, kReceiveTime2)
+ .set_audio_level(kAudioLevel2)
+ .set_absolute_capture_time(kAbsoluteCaptureTime2)}));
int64_t timestamp_ms_2 = clock.TimeInMilliseconds();
@@ -445,14 +456,16 @@
SourceTracker tracker(&clock);
tracker.OnFrameDelivered(RtpPacketInfos(
- {RtpPacketInfo(kSsrc, {kCsrcs0, kCsrcs1}, kRtpTimestamp0, kAudioLevel0,
- kAbsoluteCaptureTime0, kReceiveTime0)}));
+ {RtpPacketInfo(kSsrc, {kCsrcs0, kCsrcs1}, kRtpTimestamp0, kReceiveTime0)
+ .set_audio_level(kAudioLevel0)
+ .set_absolute_capture_time(kAbsoluteCaptureTime0)}));
clock.AdvanceTimeMilliseconds(17);
tracker.OnFrameDelivered(RtpPacketInfos(
- {RtpPacketInfo(kSsrc, {kCsrcs0, kCsrcs2}, kRtpTimestamp1, kAudioLevel1,
- kAbsoluteCaptureTime1, kReceiveTime1)}));
+ {RtpPacketInfo(kSsrc, {kCsrcs0, kCsrcs2}, kRtpTimestamp1, kReceiveTime1)
+ .set_audio_level(kAudioLevel1)
+ .set_absolute_capture_time(kAbsoluteCaptureTime1)}));
int64_t timestamp_ms_1 = clock.TimeInMilliseconds();
diff --git a/test/pc/e2e/analyzer/video/default_video_quality_analyzer_test.cc b/test/pc/e2e/analyzer/video/default_video_quality_analyzer_test.cc
index 3220cc0..2396053 100644
--- a/test/pc/e2e/analyzer/video/default_video_quality_analyzer_test.cc
+++ b/test/pc/e2e/analyzer/video/default_video_quality_analyzer_test.cc
@@ -72,8 +72,6 @@
/*ssrc=*/1,
/*csrcs=*/{},
/*rtp_timestamp=*/frame.timestamp(),
- /*audio_level=*/absl::nullopt,
- /*absolute_capture_time=*/absl::nullopt,
/*receive_time=*/Timestamp::Micros(frame.timestamp_us() + 10000)));
image.SetPacketInfos(RtpPacketInfos(packet_infos));
return image;
diff --git a/video/receive_statistics_proxy2_unittest.cc b/video/receive_statistics_proxy2_unittest.cc
index 45adff8..5061552 100644
--- a/video/receive_statistics_proxy2_unittest.cc
+++ b/video/receive_statistics_proxy2_unittest.cc
@@ -190,8 +190,8 @@
// We set receive time fixed and increase the clock by 10ms
// in the loop which will increase the processing delay by
// 10/20/30ms respectively.
- RtpPacketInfos::vector_type packet_infos = {
- RtpPacketInfo({}, {}, {}, {}, {}, Now())};
+ RtpPacketInfos::vector_type packet_infos = {RtpPacketInfo(
+ /*ssrc=*/{}, /*csrcs=*/{}, /*rtp_timestamp=*/{}, /*receive_time=*/Now())};
frame.set_packet_infos(RtpPacketInfos(packet_infos));
for (int i = 1; i <= 3; ++i) {
time_controller_.AdvanceTime(kProcessingDelay);
@@ -228,8 +228,8 @@
// A single-packet frame will not increase total assembly time
// and frames assembled.
- RtpPacketInfos::vector_type single_packet_frame = {
- RtpPacketInfo({}, {}, {}, {}, {}, Now())};
+ RtpPacketInfos::vector_type single_packet_frame = {RtpPacketInfo(
+ /*ssrc=*/{}, /*csrcs=*/{}, /*rtp_timestamp=*/{}, /*receive_time=*/Now())};
frame.set_packet_infos(RtpPacketInfos(single_packet_frame));
statistics_proxy_->OnDecodedFrame(frame, absl::nullopt, TimeDelta::Millis(1),
VideoContentType::UNSPECIFIED);
@@ -243,9 +243,12 @@
// In an ordered frame the first and last packet matter.
RtpPacketInfos::vector_type ordered_frame = {
- RtpPacketInfo({}, {}, {}, {}, {}, Now()),
- RtpPacketInfo({}, {}, {}, {}, {}, Now() + kAssemblyTime),
- RtpPacketInfo({}, {}, {}, {}, {}, Now() + 2 * kAssemblyTime),
+ RtpPacketInfo(/*ssrc=*/{}, /*csrcs=*/{}, /*rtp_timestamp=*/{},
+ /*receive_time=*/Now()),
+ RtpPacketInfo(/*ssrc=*/{}, /*csrcs=*/{}, /*rtp_timestamp=*/{},
+ /*receive_time=*/Now() + kAssemblyTime),
+ RtpPacketInfo(/*ssrc=*/{}, /*csrcs=*/{}, /*rtp_timestamp=*/{},
+ /*receive_time=*/Now() + 2 * kAssemblyTime),
};
frame.set_packet_infos(RtpPacketInfos(ordered_frame));
statistics_proxy_->OnDecodedFrame(frame, 1u, TimeDelta::Millis(3),
@@ -264,9 +267,12 @@
// "First" and "last" are in receive time, not sequence number.
RtpPacketInfos::vector_type unordered_frame = {
- RtpPacketInfo({}, {}, {}, {}, {}, Now() + 2 * kAssemblyTime),
- RtpPacketInfo({}, {}, {}, {}, {}, Now()),
- RtpPacketInfo({}, {}, {}, {}, {}, Now() + kAssemblyTime),
+ RtpPacketInfo(/*ssrc=*/{}, /*csrcs=*/{}, /*rtp_timestamp=*/{},
+ /*receive_time=*/Now() + 2 * kAssemblyTime),
+ RtpPacketInfo(/*ssrc=*/{}, /*csrcs=*/{}, /*rtp_timestamp=*/{},
+ /*receive_time=*/Now()),
+ RtpPacketInfo(/*ssrc=*/{}, /*csrcs=*/{}, /*rtp_timestamp=*/{},
+ /*receive_time=*/Now() + kAssemblyTime),
};
frame.set_packet_infos(RtpPacketInfos(unordered_frame));
statistics_proxy_->OnDecodedFrame(frame, 1u, TimeDelta::Millis(3),
diff --git a/video/rtp_video_stream_receiver2.cc b/video/rtp_video_stream_receiver2.cc
index 4748257..fb85766 100644
--- a/video/rtp_video_stream_receiver2.cc
+++ b/video/rtp_video_stream_receiver2.cc
@@ -507,15 +507,13 @@
int64_t unwrapped_rtp_seq_num =
rtp_seq_num_unwrapper_.Unwrap(rtp_packet.SequenceNumber());
- auto& packet_info =
+
+ RtpPacketInfo& packet_info =
packet_infos_
- .emplace(
- unwrapped_rtp_seq_num,
- RtpPacketInfo(
- rtp_packet.Ssrc(), rtp_packet.Csrcs(), rtp_packet.Timestamp(),
- /*audio_level=*/absl::nullopt,
- rtp_packet.GetExtension<AbsoluteCaptureTimeExtension>(),
- /*receive_time_ms=*/clock_->CurrentTime()))
+ .emplace(unwrapped_rtp_seq_num,
+ RtpPacketInfo(rtp_packet.Ssrc(), rtp_packet.Csrcs(),
+ rtp_packet.Timestamp(),
+ /*receive_time_ms=*/clock_->CurrentTime()))
.first->second;
// Try to extrapolate absolute capture time if it is missing.
@@ -525,7 +523,8 @@
packet_info.csrcs()),
packet_info.rtp_timestamp(),
// Assume frequency is the same one for all video frames.
- kVideoPayloadTypeFrequency, packet_info.absolute_capture_time()));
+ kVideoPayloadTypeFrequency,
+ rtp_packet.GetExtension<AbsoluteCaptureTimeExtension>()));
RTPVideoHeader& video_header = packet->video_header;
video_header.rotation = kVideoRotation_0;
