YangWX/crossdesk
1
0
Fork 0
mirror of https://github.com/kunkundi/crossdesk.git synced 2025-10-27 04:35:34 +08:00
Code Issues Packages Projects Releases Wiki Activity

[feat] move rtp packet sender out of channel module

Browse Source
This commit is contained in:
dijunkun
2025-03-13 21:11:20 +08:00
parent 23df1f3b60
commit d2b45b91e7
32 changed files with 681 additions and 266 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
src/rtp/rtp_packet/rtp_packet_history.cpp
View File

@@ -17,7 +17,7 @@ void RtpPacketHistory::SetRtt(webrtc::TimeDelta rtt) {
}
void RtpPacketHistory::AddPacket(
std::shared_ptr<webrtc::RtpPacketToSend> rtp_packet,
std::unique_ptr<webrtc::RtpPacketToSend> rtp_packet,
webrtc::Timestamp send_time) {
RemoveDeadPackets();
const uint16_t rtp_seq_no = rtp_packet->SequenceNumber();
@@ -40,7 +40,7 @@ void RtpPacketHistory::AddPacket(
rtp_packet_history_.emplace_back();
}
rtp_packet_history_[packet_index] = {rtp_packet, send_time,
rtp_packet_history_[packet_index] = {std::move(rtp_packet), send_time,
packets_inserted_++};
}
@@ -79,10 +79,10 @@ void RtpPacketHistory::RemoveDeadPackets() {
}
}
std::shared_ptr<webrtc::RtpPacketToSend> RtpPacketHistory::RemovePacket(
std::unique_ptr<webrtc::RtpPacketToSend> RtpPacketHistory::RemovePacket(
int packet_index) {
// Move the packet out from the StoredPacket container.
std::shared_ptr<webrtc::RtpPacketToSend> rtp_packet =
std::unique_ptr<webrtc::RtpPacketToSend> rtp_packet =
std::move(rtp_packet_history_[packet_index].rtp_packet);
if (packet_index == 0) {
while (!rtp_packet_history_.empty() &&

12
src/rtp/rtp_packet/rtp_packet_history.h
View File

@@ -31,25 +31,27 @@ class RtpPacketHistory {
public:
void SetRtt(webrtc::TimeDelta rtt);
void AddPacket(std::shared_ptr<webrtc::RtpPacketToSend> rtp_packet,
void AddPacket(std::unique_ptr<webrtc::RtpPacketToSend> rtp_packet,
webrtc::Timestamp send_time);
void RemoveDeadPackets();
private:
std::shared_ptr<webrtc::RtpPacketToSend> RemovePacket(int packet_index);
std::unique_ptr<webrtc::RtpPacketToSend> RemovePacket(int packet_index);
int GetPacketIndex(uint16_t sequence_number) const;
private:
struct RtpPacketToSendInfo {
RtpPacketToSendInfo() = default;
RtpPacketToSendInfo(std::shared_ptr<webrtc::RtpPacketToSend> rtp_packet,
RtpPacketToSendInfo(std::unique_ptr<webrtc::RtpPacketToSend> rtp_packet,
webrtc::Timestamp send_time, uint64_t index)
: rtp_packet(rtp_packet), send_time(send_time), index(index) {}
: rtp_packet(std::move(rtp_packet)),
send_time(send_time),
index(index) {}
RtpPacketToSendInfo(RtpPacketToSendInfo&&) = default;
RtpPacketToSendInfo& operator=(RtpPacketToSendInfo&&) = default;
~RtpPacketToSendInfo() = default;
std::shared_ptr<webrtc::RtpPacketToSend> rtp_packet;
std::unique_ptr<webrtc::RtpPacketToSend> rtp_packet;
webrtc::Timestamp send_time = webrtc::Timestamp::Zero();
uint64_t index;
};

6
src/rtp/rtp_packetizer/rtp_packetizer.h
View File

@@ -21,9 +21,13 @@ class RtpPacketizer {
virtual ~RtpPacketizer() = default;
virtual std::vector<std::shared_ptr<RtpPacket>> Build(
virtual std::vector<std::unique_ptr<RtpPacket>> Build(
uint8_t* payload, uint32_t payload_size, int64_t capture_timestamp_ms,
bool use_rtp_packet_to_send) = 0;
virtual std::vector<std::unique_ptr<RtpPacket>> BuildPadding(
uint32_t payload_size, int64_t capture_timestamp_ms,
bool use_rtp_packet_to_send) = 0;
};
#endif

4
src/rtp/rtp_packetizer/rtp_packetizer_av1.cpp
View File

@@ -4,10 +4,10 @@ RtpPacketizerAv1::RtpPacketizerAv1(uint32_t ssrc) {}
RtpPacketizerAv1::~RtpPacketizerAv1() {}
std::vector<std::shared_ptr<RtpPacket>> RtpPacketizerAv1::Build(
std::vector<std::unique_ptr<RtpPacket>> RtpPacketizerAv1::Build(
uint8_t* payload, uint32_t payload_size, int64_t capture_timestamp_ms,
bool use_rtp_packet_to_send) {
std::vector<std::shared_ptr<RtpPacket>> rtp_packets;
std::vector<std::unique_ptr<RtpPacket>> rtp_packets;
return rtp_packets;
}

8
src/rtp/rtp_packetizer/rtp_packetizer_av1.h
View File

@@ -15,10 +15,16 @@ class RtpPacketizerAv1 : public RtpPacketizer {
virtual ~RtpPacketizerAv1();
std::vector<std::shared_ptr<RtpPacket>> Build(
std::vector<std::unique_ptr<RtpPacket>> Build(
uint8_t* payload, uint32_t payload_size, int64_t capture_timestamp_ms,
bool use_rtp_packet_to_send) override;
std::vector<std::unique_ptr<RtpPacket>> BuildPadding(
uint32_t payload_size, int64_t capture_timestamp_ms,
bool use_rtp_packet_to_send) override {
return std::vector<std::unique_ptr<RtpPacket>>{};
};
private:
uint8_t version_;
bool has_padding_;

8
src/rtp/rtp_packetizer/rtp_packetizer_generic.cpp
View File

@@ -46,7 +46,7 @@ void RtpPacketizerGeneric::AddAbsSendTimeExtension(
rtp_packet_frame.push_back(abs_send_time & 0xFF);
}
std::vector<std::shared_ptr<RtpPacket>> RtpPacketizerGeneric::Build(
std::vector<std::unique_ptr<RtpPacket>> RtpPacketizerGeneric::Build(
uint8_t* payload, uint32_t payload_size, int64_t capture_timestamp_ms,
bool use_rtp_packet_to_send) {
uint32_t last_packet_size = payload_size % MAX_NALU_LEN;
@@ -58,7 +58,7 @@ std::vector<std::shared_ptr<RtpPacket>> RtpPacketizerGeneric::Build(
std::chrono::system_clock::now().time_since_epoch())
.count();
std::vector<std::shared_ptr<RtpPacket>> rtp_packets;
std::vector<std::unique_ptr<RtpPacket>> rtp_packets;
for (uint32_t index = 0; index < packet_num; index++) {
version_ = kRtpVersion;
@@ -109,12 +109,12 @@ std::vector<std::shared_ptr<RtpPacket>> RtpPacketizerGeneric::Build(
}
if (use_rtp_packet_to_send) {
std::shared_ptr<webrtc::RtpPacketToSend> rtp_packet =
std::unique_ptr<webrtc::RtpPacketToSend> rtp_packet =
std::make_unique<webrtc::RtpPacketToSend>();
rtp_packet->Build(rtp_packet_frame_.data(), rtp_packet_frame_.size());
rtp_packets.emplace_back(std::move(rtp_packet));
} else {
std::shared_ptr<RtpPacket> rtp_packet = std::make_unique<RtpPacket>();
std::unique_ptr<RtpPacket> rtp_packet = std::make_unique<RtpPacket>();
rtp_packet->Build(rtp_packet_frame_.data(), rtp_packet_frame_.size());
rtp_packets.emplace_back(std::move(rtp_packet));
}

8
src/rtp/rtp_packetizer/rtp_packetizer_generic.h
View File

@@ -15,10 +15,16 @@ class RtpPacketizerGeneric : public RtpPacketizer {
virtual ~RtpPacketizerGeneric();
std::vector<std::shared_ptr<RtpPacket>> Build(
std::vector<std::unique_ptr<RtpPacket>> Build(
uint8_t* payload, uint32_t payload_size, int64_t capture_timestamp_ms,
bool use_rtp_packet_to_send) override;
std::vector<std::unique_ptr<RtpPacket>> BuildPadding(
uint32_t payload_size, int64_t capture_timestamp_ms,
bool use_rtp_packet_to_send) override {
return std::vector<std::unique_ptr<RtpPacket>>{};
};
private:
void AddAbsSendTimeExtension(std::vector<uint8_t>& rtp_packet_frame);

81
src/rtp/rtp_packetizer/rtp_packetizer_h264.cpp
View File

@@ -60,7 +60,7 @@ void RtpPacketizerH264::AddAbsSendTimeExtension(
rtp_packet_frame.push_back(abs_send_time & 0xFF);
}
std::vector<std::shared_ptr<RtpPacket>> RtpPacketizerH264::Build(
std::vector<std::unique_ptr<RtpPacket>> RtpPacketizerH264::Build(
uint8_t* payload, uint32_t payload_size, int64_t capture_timestamp_ms,
bool use_rtp_packet_to_send) {
if (payload_size <= MAX_NALU_LEN) {
@@ -72,10 +72,10 @@ std::vector<std::shared_ptr<RtpPacket>> RtpPacketizerH264::Build(
}
}
std::vector<std::shared_ptr<RtpPacket>> RtpPacketizerH264::BuildNalu(
std::vector<std::unique_ptr<RtpPacket>> RtpPacketizerH264::BuildNalu(
uint8_t* payload, uint32_t payload_size, int64_t capture_timestamp_ms,
bool use_rtp_packet_to_send) {
std::vector<std::shared_ptr<RtpPacket>> rtp_packets;
std::vector<std::unique_ptr<RtpPacket>> rtp_packets;
version_ = kRtpVersion;
has_padding_ = false;
@@ -128,12 +128,12 @@ std::vector<std::shared_ptr<RtpPacket>> RtpPacketizerH264::BuildNalu(
payload + payload_size);
if (use_rtp_packet_to_send) {
std::shared_ptr<webrtc::RtpPacketToSend> rtp_packet =
std::make_shared<webrtc::RtpPacketToSend>();
std::unique_ptr<webrtc::RtpPacketToSend> rtp_packet =
std::make_unique<webrtc::RtpPacketToSend>();
rtp_packet->Build(rtp_packet_frame_.data(), rtp_packet_frame_.size());
rtp_packets.emplace_back(std::move(rtp_packet));
} else {
std::shared_ptr<RtpPacket> rtp_packet = std::make_shared<RtpPacket>();
std::unique_ptr<RtpPacket> rtp_packet = std::make_unique<RtpPacket>();
rtp_packet->Build(rtp_packet_frame_.data(), rtp_packet_frame_.size());
rtp_packets.emplace_back(std::move(rtp_packet));
}
@@ -141,10 +141,10 @@ std::vector<std::shared_ptr<RtpPacket>> RtpPacketizerH264::BuildNalu(
return rtp_packets;
}
std::vector<std::shared_ptr<RtpPacket>> RtpPacketizerH264::BuildFua(
std::vector<std::unique_ptr<RtpPacket>> RtpPacketizerH264::BuildFua(
uint8_t* payload, uint32_t payload_size, int64_t capture_timestamp_ms,
bool use_rtp_packet_to_send) {
std::vector<std::shared_ptr<RtpPacket>> rtp_packets;
std::vector<std::unique_ptr<RtpPacket>> rtp_packets;
uint32_t last_packet_size = payload_size % MAX_NALU_LEN;
uint32_t packet_num =
@@ -227,12 +227,12 @@ std::vector<std::shared_ptr<RtpPacket>> RtpPacketizerH264::BuildFua(
}
if (use_rtp_packet_to_send) {
std::shared_ptr<webrtc::RtpPacketToSend> rtp_packet =
std::make_shared<webrtc::RtpPacketToSend>();
std::unique_ptr<webrtc::RtpPacketToSend> rtp_packet =
std::make_unique<webrtc::RtpPacketToSend>();
rtp_packet->Build(rtp_packet_frame_.data(), rtp_packet_frame_.size());
rtp_packets.emplace_back(std::move(rtp_packet));
} else {
std::shared_ptr<RtpPacket> rtp_packet = std::make_shared<RtpPacket>();
std::unique_ptr<RtpPacket> rtp_packet = std::make_unique<RtpPacket>();
rtp_packet->Build(rtp_packet_frame_.data(), rtp_packet_frame_.size());
rtp_packets.emplace_back(std::move(rtp_packet));
}
@@ -241,6 +241,65 @@ std::vector<std::shared_ptr<RtpPacket>> RtpPacketizerH264::BuildFua(
return rtp_packets;
}
std::vector<std::unique_ptr<RtpPacket>> RtpPacketizerH264::BuildPadding(
uint32_t payload_size, int64_t capture_timestamp_ms,
bool use_rtp_packet_to_send) {
std::vector<std::unique_ptr<RtpPacket>> rtp_packets;
version_ = kRtpVersion;
has_padding_ = true;
has_extension_ = true;
csrc_count_ = 0;
marker_ = 0;
uint8_t payload_type = rtp::PAYLOAD_TYPE(payload_type_ - 1);
sequence_number_++;
timestamp_ = kMsToRtpTimestamp * static_cast<uint32_t>(capture_timestamp_ms);
rtp_packet_frame_.clear();
rtp_packet_frame_.push_back((version_ << 6) | (has_padding_ << 5) |
(has_extension_ << 4) | csrc_count_);
rtp_packet_frame_.push_back((marker_ << 7) | payload_type);
rtp_packet_frame_.push_back((sequence_number_ >> 8) & 0xFF);
rtp_packet_frame_.push_back(sequence_number_ & 0xFF);
rtp_packet_frame_.push_back((timestamp_ >> 24) & 0xFF);
rtp_packet_frame_.push_back((timestamp_ >> 16) & 0xFF);
rtp_packet_frame_.push_back((timestamp_ >> 8) & 0xFF);
rtp_packet_frame_.push_back(timestamp_ & 0xFF);
rtp_packet_frame_.push_back((ssrc_ >> 24) & 0xFF);
rtp_packet_frame_.push_back((ssrc_ >> 16) & 0xFF);
rtp_packet_frame_.push_back((ssrc_ >> 8) & 0xFF);
rtp_packet_frame_.push_back(ssrc_ & 0xFF);
for (uint32_t index = 0; index < csrc_count_ && !csrcs_.empty(); index++) {
rtp_packet_frame_.push_back((csrcs_[index] >> 24) & 0xFF);
rtp_packet_frame_.push_back((csrcs_[index] >> 16) & 0xFF);
rtp_packet_frame_.push_back((csrcs_[index] >> 8) & 0xFF);
rtp_packet_frame_.push_back(csrcs_[index] & 0xFF);
}
if (has_extension_) {
AddAbsSendTimeExtension(rtp_packet_frame_);
}
// Add padding bytes
uint32_t padding_size = payload_size;
rtp_packet_frame_.insert(rtp_packet_frame_.end(), padding_size - 1, 0);
rtp_packet_frame_.push_back(padding_size);
if (use_rtp_packet_to_send) {
std::unique_ptr<webrtc::RtpPacketToSend> rtp_packet =
std::make_unique<webrtc::RtpPacketToSend>();
rtp_packet->Build(rtp_packet_frame_.data(), rtp_packet_frame_.size());
rtp_packets.emplace_back(std::move(rtp_packet));
} else {
std::unique_ptr<RtpPacket> rtp_packet = std::make_unique<RtpPacket>();
rtp_packet->Build(rtp_packet_frame_.data(), rtp_packet_frame_.size());
rtp_packets.emplace_back(std::move(rtp_packet));
}
return rtp_packets;
}
// bool BuildFec(uint8_t* payload, uint32_t payload_size) {
// uint8_t** fec_packets =
// fec_encoder_.Encode((const char*)payload, payload_size);

10
src/rtp/rtp_packetizer/rtp_packetizer_h264.h
View File

@@ -15,19 +15,23 @@ class RtpPacketizerH264 : public RtpPacketizer {
virtual ~RtpPacketizerH264();
std::vector<std::shared_ptr<RtpPacket>> Build(
std::vector<std::unique_ptr<RtpPacket>> Build(
uint8_t* payload, uint32_t payload_size, int64_t capture_timestamp_ms,
bool use_rtp_packet_to_send) override;
std::vector<std::shared_ptr<RtpPacket>> BuildNalu(
std::vector<std::unique_ptr<RtpPacket>> BuildNalu(
uint8_t* payload, uint32_t payload_size, int64_t capture_timestamp_ms,
bool use_rtp_packet_to_send);
std::vector<std::shared_ptr<RtpPacket>> BuildFua(uint8_t* payload,
std::vector<std::unique_ptr<RtpPacket>> BuildFua(uint8_t* payload,
uint32_t payload_size,
int64_t capture_timestamp_ms,
bool use_rtp_packet_to_send);
std::vector<std::unique_ptr<RtpPacket>> BuildPadding(
uint32_t payload_size, int64_t capture_timestamp_ms,
bool use_rtp_packet_to_send) override;
private:
bool EncodeH264Fua(RtpPacket& rtp_packet, uint8_t* payload,
size_t payload_size);