external/srs
1
0
Fork 0
mirror of https://github.com/ossrs/srs.git synced 2025-03-09 15:49:59 +00:00
Code Issues Releases Wiki Activity

Add SrsRtpHeader.

Browse source
This commit is contained in:
xiaozhihong 2020-04-08 14:45:26 +08:00
parent e6e8605304
commit ca7060c005
6 changed files with 234 additions and 125 deletions
Download patch file Download diff file Expand all files Collapse all files

178
trunk/src/kernel/srs_kernel_rtp.cpp
View file

@ -32,6 +32,117 @@ using namespace std;
#include <srs_kernel_buffer.hpp>
#include <srs_kernel_utility.hpp>
SrsRtpHeader::SrsRtpHeader()
{
padding = false;
extension = false;
cc = 0;
marker = false;
payload_type = 0;
sequence = 0;
timestamp = 0;
ssrc = 0;
extension_length = 0;
}
SrsRtpHeader::SrsRtpHeader(const SrsRtpHeader& rhs)
{
operator=(rhs);
}
SrsRtpHeader& SrsRtpHeader::operator=(const SrsRtpHeader& rhs)
{
padding = rhs.padding;
extension = rhs.extension;
cc = rhs.cc;
marker = rhs.marker;
payload_type = rhs.payload_type;
sequence = rhs.sequence;
timestamp = rhs.timestamp;
ssrc = rhs.ssrc;
for (size_t i = 0; i < cc; ++i) {
csrc[i] = rhs.csrc[i];
}
extension_length = rhs.extension_length;
return *this;
}
SrsRtpHeader::~SrsRtpHeader()
{
}
srs_error_t SrsRtpHeader::decode(SrsBuffer* stream)
{
srs_error_t err = srs_success;
// TODO:
return err;
}
srs_error_t SrsRtpHeader::encode(SrsBuffer* stream)
{
srs_error_t err = srs_success;
uint8_t first = 0x80 | cc;
if (padding) {
first |= 0x40;
}
if (extension) {
first |= 0x10;
}
stream->write_1bytes(first);
uint8_t second = payload_type;
if (marker) {
payload_type |= kRtpMarker;
}
stream->write_1bytes(second);
stream->write_2bytes(sequence);
stream->write_4bytes(timestamp);
stream->write_4bytes(ssrc);
for (size_t i = 0; i < cc; ++i) {
stream->write_4bytes(csrc[i]);
}
// TODO: Write exteinsion field.
if (extension) {
}
return err;
}
size_t SrsRtpHeader::header_size()
{
return kRtpHeaderFixedSize + cc * 4 + (extension ? (extension_length + 1) * 4 : 0);
}
void SrsRtpHeader::set_marker(bool marker)
{
this->marker = marker;
}
void SrsRtpHeader::set_payload_type(uint8_t payload_type)
{
this->payload_type = payload_type;
}
void SrsRtpHeader::set_sequence(uint16_t sequence)
{
this->sequence = sequence;
}
void SrsRtpHeader::set_timestamp(int64_t timestamp)
{
this->timestamp = timestamp;
}
void SrsRtpHeader::set_ssrc(uint32_t ssrc)
{
this->ssrc = ssrc;
}
SrsRtpSharedPacket::SrsRtpSharedPacketPayload::SrsRtpSharedPacketPayload()
{
payload = NULL;
@ -50,11 +161,6 @@ SrsRtpSharedPacket::SrsRtpSharedPacket()
payload = NULL;
size = 0;
timestamp = -1;
sequence = 0;
ssrc = 0;
payload_type = 0;
}
SrsRtpSharedPacket::~SrsRtpSharedPacket()
@ -68,27 +174,38 @@ SrsRtpSharedPacket::~SrsRtpSharedPacket()
}
}
srs_error_t SrsRtpSharedPacket::create(int64_t t, uint16_t seq, uint32_t sc, uint16_t pt, char* p, int s)
srs_error_t SrsRtpSharedPacket::create(int64_t timestamp, uint16_t sequence, uint32_t ssrc, uint16_t payload_type, char* p, int s)
{
srs_error_t err = srs_success;
if (size < 0) {
return srs_error_new(ERROR_RTP_PACKET_CREATE, "create packet size=%d", size);
if (s < 0) {
return srs_error_new(ERROR_RTP_PACKET_CREATE, "create packet size=%d", s);
}
srs_assert(!payload_ptr);
timestamp = t;
sequence = seq;
ssrc = sc;
payload_type = pt;
rtp_header.set_timestamp(timestamp);
rtp_header.set_sequence(sequence);
rtp_header.set_ssrc(ssrc);
rtp_header.set_payload_type(payload_type);
// TODO: rtp header padding.
size_t buffer_size = rtp_header.header_size() + s;
char* buffer = new char[buffer_size];
SrsBuffer stream(buffer, buffer_size);
if ((err = rtp_header.encode(&stream)) != srs_success) {
srs_freepa(buffer);
return srs_error_wrap(err, "rtp header encode");
}
stream.write_bytes(p, s);
payload_ptr = new SrsRtpSharedPacketPayload();
payload_ptr->payload = p;
payload_ptr->size = s;
payload_ptr->payload = buffer;
payload_ptr->size = buffer_size;
payload = payload_ptr->payload;
size = payload_ptr->size;
this->payload = payload_ptr->payload;
this->size = payload_ptr->size;
return err;
}
@ -100,56 +217,57 @@ SrsRtpSharedPacket* SrsRtpSharedPacket::copy()
copy->payload_ptr = payload_ptr;
payload_ptr->shared_count++;
copy->rtp_header = rtp_header;
copy->payload = payload;
copy->size = size;
copy->timestamp = timestamp;
copy->sequence = sequence;
copy->ssrc = ssrc;
copy->payload_type = payload_type;
return copy;
}
srs_error_t SrsRtpSharedPacket::set_marker(bool marker)
srs_error_t SrsRtpSharedPacket::modify_rtp_header_marker(bool marker)
{
srs_error_t err = srs_success;
if (payload_ptr == NULL || payload_ptr->payload == NULL || payload_ptr->size < 1) {
if (payload_ptr == NULL || payload_ptr->payload == NULL || payload_ptr->size < kRtpHeaderFixedSize) {
return srs_error_new(ERROR_RTC_RTP_MUXER, "rtp payload incorrect");
}
rtp_header.set_marker(marker);
if (marker) {
payload_ptr->payload[1] |= kMarker;
payload_ptr->payload[1] |= kRtpMarker;
} else {
payload_ptr->payload[1] &= (~kMarker);
payload_ptr->payload[1] &= (~kRtpMarker);
}
return err;
}
srs_error_t SrsRtpSharedPacket::set_ssrc(uint32_t ssrc)
srs_error_t SrsRtpSharedPacket::modify_rtp_header_ssrc(uint32_t ssrc)
{
srs_error_t err = srs_success;
if (payload_ptr == NULL || payload_ptr->payload == NULL || payload_ptr->size < 12) {
if (payload_ptr == NULL || payload_ptr->payload == NULL || payload_ptr->size < kRtpHeaderFixedSize) {
return srs_error_new(ERROR_RTC_RTP_MUXER, "rtp payload incorrect");
}
rtp_header.set_ssrc(ssrc);
SrsBuffer stream(payload_ptr->payload + 8, 4);
stream.write_4bytes(ssrc);
return err;
}
srs_error_t SrsRtpSharedPacket::set_payload_type(uint8_t pt)
srs_error_t SrsRtpSharedPacket::modify_rtp_header_payload_type(uint8_t payload_type)
{
srs_error_t err = srs_success;
if (payload_ptr == NULL || payload_ptr->payload == NULL || payload_ptr->size < 2) {
if (payload_ptr == NULL || payload_ptr->payload == NULL || payload_ptr->size < kRtpHeaderFixedSize) {
return srs_error_new(ERROR_RTC_RTP_MUXER, "rtp payload incorrect");
}
payload_ptr->payload[1] = (payload_ptr->payload[1] & 0x80) | pt;
rtp_header.set_payload_type(payload_type);
payload_ptr->payload[1] = (payload_ptr->payload[1] & 0x80) | payload_type;
return err;
}