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

[feat] add rtp packet history module

Browse Source
This commit is contained in:
dijunkun
2025-02-14 17:30:12 +08:00
parent 7b4bba4166
commit 1ef7c536f1
27 changed files with 365 additions and 1161 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -12,6 +12,7 @@
#include <memory>
#include "rtp_packet.h"
#include "rtp_packet_to_send.h"
class RtpPacketizer {
public:
@@ -20,8 +21,8 @@ class RtpPacketizer {
virtual ~RtpPacketizer() = default;
virtual std::vector<RtpPacket> Build(uint8_t* payload,
uint32_t payload_size) = 0;
virtual std::vector<std::shared_ptr<RtpPacket>> Build(
uint8_t* payload, uint32_t payload_size, bool use_rtp_packet_to_send) = 0;
};
#endif

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

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

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

@@ -15,8 +15,9 @@ class RtpPacketizerAv1 : public RtpPacketizer {
virtual ~RtpPacketizerAv1();
std::vector<RtpPacket> Build(uint8_t* payload,
uint32_t payload_size) override;
std::vector<std::shared_ptr<RtpPacket>> Build(
uint8_t* payload, uint32_t payload_size,
bool use_rtp_packet_to_send) override;
private:
uint8_t version_;

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

@@ -17,8 +17,37 @@ RtpPacketizerGeneric::RtpPacketizerGeneric(uint32_t ssrc)
RtpPacketizerGeneric::~RtpPacketizerGeneric() {}
std::vector<RtpPacket> RtpPacketizerGeneric::Build(uint8_t* payload,
uint32_t payload_size) {
void RtpPacketizerGeneric::AddAbsSendTimeExtension(
std::vector<uint8_t>& rtp_packet_frame) {
uint16_t extension_profile = 0xBEDE; // One-byte header extension
uint8_t sub_extension_id = 3; // ID for Absolute Send Time
uint8_t sub_extension_length =
2; // Length of the extension data in bytes minus 1
uint32_t abs_send_time =
std::chrono::duration_cast<std::chrono::microseconds>(
std::chrono::system_clock::now().time_since_epoch())
.count();
abs_send_time &= 0x00FFFFFF; // Absolute Send Time is 24 bits
// Add extension profile
rtp_packet_frame.push_back((extension_profile >> 8) & 0xFF);
rtp_packet_frame.push_back(extension_profile & 0xFF);
// Add extension length (in 32-bit words, minus one)
rtp_packet_frame.push_back(
0x00); // Placeholder for length, will be updated later
rtp_packet_frame.push_back(0x01); // One 32-bit word
// Add Absolute Send Time extension
rtp_packet_frame.push_back((sub_extension_id << 4) | sub_extension_length);
rtp_packet_frame.push_back((abs_send_time >> 16) & 0xFF);
rtp_packet_frame.push_back((abs_send_time >> 8) & 0xFF);
rtp_packet_frame.push_back(abs_send_time & 0xFF);
}
std::vector<std::shared_ptr<RtpPacket>> RtpPacketizerGeneric::Build(
uint8_t* payload, uint32_t payload_size, bool use_rtp_packet_to_send) {
uint32_t last_packet_size = payload_size % MAX_NALU_LEN;
uint32_t packet_num =
payload_size / MAX_NALU_LEN + (last_packet_size ? 1 : 0);
@@ -28,7 +57,8 @@ std::vector<RtpPacket> RtpPacketizerGeneric::Build(uint8_t* payload,
std::chrono::system_clock::now().time_since_epoch())
.count();
std::vector<RtpPacket> rtp_packets;
std::vector<std::shared_ptr<RtpPacket>> rtp_packets;
for (uint32_t index = 0; index < packet_num; index++) {
version_ = kRtpVersion;
has_padding_ = false;
@@ -77,40 +107,17 @@ std::vector<RtpPacket> RtpPacketizerGeneric::Build(uint8_t* payload,
payload + MAX_NALU_LEN);
}
RtpPacket rtp_packet;
rtp_packet.Build(rtp_packet_frame_.data(), rtp_packet_frame_.size());
rtp_packets.emplace_back(rtp_packet);
if (use_rtp_packet_to_send) {
std::shared_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>();
rtp_packet->Build(rtp_packet_frame_.data(), rtp_packet_frame_.size());
rtp_packets.emplace_back(std::move(rtp_packet));
}
}
return rtp_packets;
}
void RtpPacketizerGeneric::AddAbsSendTimeExtension(
std::vector<uint8_t>& rtp_packet_frame) {
uint16_t extension_profile = 0xBEDE; // One-byte header extension
uint8_t sub_extension_id = 3; // ID for Absolute Send Time
uint8_t sub_extension_length =
2; // Length of the extension data in bytes minus 1
uint32_t abs_send_time =
std::chrono::duration_cast<std::chrono::microseconds>(
std::chrono::system_clock::now().time_since_epoch())
.count();
abs_send_time &= 0x00FFFFFF; // Absolute Send Time is 24 bits
// Add extension profile
rtp_packet_frame.push_back((extension_profile >> 8) & 0xFF);
rtp_packet_frame.push_back(extension_profile & 0xFF);
// Add extension length (in 32-bit words, minus one)
rtp_packet_frame.push_back(
0x00); // Placeholder for length, will be updated later
rtp_packet_frame.push_back(0x01); // One 32-bit word
// Add Absolute Send Time extension
rtp_packet_frame.push_back((sub_extension_id << 4) | sub_extension_length);
rtp_packet_frame.push_back((abs_send_time >> 16) & 0xFF);
rtp_packet_frame.push_back((abs_send_time >> 8) & 0xFF);
rtp_packet_frame.push_back(abs_send_time & 0xFF);
}

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

@@ -15,8 +15,9 @@ class RtpPacketizerGeneric : public RtpPacketizer {
virtual ~RtpPacketizerGeneric();
std::vector<RtpPacket> Build(uint8_t* payload,
uint32_t payload_size) override;
std::vector<std::shared_ptr<RtpPacket>> Build(
uint8_t* payload, uint32_t payload_size,
bool use_rtp_packet_to_send) override;
private:
void AddAbsSendTimeExtension(std::vector<uint8_t>& rtp_packet_frame);

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

@@ -17,15 +17,6 @@ RtpPacketizerH264::RtpPacketizerH264(uint32_t ssrc)
RtpPacketizerH264::~RtpPacketizerH264() {}
std::vector<RtpPacket> RtpPacketizerH264::Build(uint8_t* payload,
uint32_t payload_size) {
if (payload_size <= MAX_NALU_LEN) {
return BuildNalu(payload, payload_size);
} else {
return BuildFua(payload, payload_size);
}
}
// 0 1 2 3
// 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
@@ -67,9 +58,18 @@ void RtpPacketizerH264::AddAbsSendTimeExtension(
rtp_packet_frame.push_back(abs_send_time & 0xFF);
}
std::vector<RtpPacket> RtpPacketizerH264::BuildNalu(uint8_t* payload,
uint32_t payload_size) {
std::vector<RtpPacket> rtp_packets;
std::vector<std::shared_ptr<RtpPacket>> RtpPacketizerH264::Build(
uint8_t* payload, uint32_t payload_size, bool use_rtp_packet_to_send) {
if (payload_size <= MAX_NALU_LEN) {
return BuildNalu(payload, payload_size, use_rtp_packet_to_send);
} else {
return BuildFua(payload, payload_size, use_rtp_packet_to_send);
}
}
std::vector<std::shared_ptr<RtpPacket>> RtpPacketizerH264::BuildNalu(
uint8_t* payload, uint32_t payload_size, bool use_rtp_packet_to_send) {
std::vector<std::shared_ptr<RtpPacket>> rtp_packets;
version_ = kRtpVersion;
has_padding_ = false;
@@ -123,16 +123,23 @@ std::vector<RtpPacket> RtpPacketizerH264::BuildNalu(uint8_t* payload,
rtp_packet_frame_.insert(rtp_packet_frame_.end(), payload,
payload + payload_size);
RtpPacket rtp_packet;
rtp_packet.Build(rtp_packet_frame_.data(), rtp_packet_frame_.size());
rtp_packets.emplace_back(rtp_packet);
if (use_rtp_packet_to_send) {
std::shared_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>();
rtp_packet->Build(rtp_packet_frame_.data(), rtp_packet_frame_.size());
rtp_packets.emplace_back(std::move(rtp_packet));
}
return rtp_packets;
}
std::vector<RtpPacket> RtpPacketizerH264::BuildFua(uint8_t* payload,
uint32_t payload_size) {
std::vector<RtpPacket> rtp_packets;
std::vector<std::shared_ptr<RtpPacket>> RtpPacketizerH264::BuildFua(
uint8_t* payload, uint32_t payload_size, bool use_rtp_packet_to_send) {
std::vector<std::shared_ptr<RtpPacket>> rtp_packets;
uint32_t last_packet_size = payload_size % MAX_NALU_LEN;
uint32_t packet_num =
@@ -214,10 +221,16 @@ std::vector<RtpPacket> RtpPacketizerH264::BuildFua(uint8_t* payload,
payload + index * MAX_NALU_LEN + MAX_NALU_LEN);
}
RtpPacket rtp_packet;
rtp_packet.Build(rtp_packet_frame_.data(), rtp_packet_frame_.size());
rtp_packets.emplace_back(rtp_packet);
if (use_rtp_packet_to_send) {
std::shared_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>();
rtp_packet->Build(rtp_packet_frame_.data(), rtp_packet_frame_.size());
rtp_packets.emplace_back(std::move(rtp_packet));
}
}
return rtp_packets;

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

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