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

Remove usused RTP shared packet.

Browse source
This commit is contained in:
winlin 2020-05-02 10:24:31 +08:00
parent 42ee52fa29
commit 5c43037190
9 changed files with 16 additions and 534 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -853,224 +853,3 @@ srs_error_t SrsRtpFUAPayload2::decode(SrsBuffer* buf)
return srs_success;
}
SrsRtpPayloadHeader::SrsRtpPayloadHeader()
{
is_first_packet_of_frame = false;
is_last_packet_of_frame = false;
is_key_frame = false;
}
SrsRtpPayloadHeader::~SrsRtpPayloadHeader()
{
}
SrsRtpPayloadHeader::SrsRtpPayloadHeader(const SrsRtpPayloadHeader& rhs)
{
operator=(rhs);
}
SrsRtpPayloadHeader& SrsRtpPayloadHeader::operator=(const SrsRtpPayloadHeader& rhs)
{
is_first_packet_of_frame = rhs.is_first_packet_of_frame;
is_last_packet_of_frame = rhs.is_last_packet_of_frame;
return *this;
}
SrsRtpH264Header::SrsRtpH264Header() : SrsRtpPayloadHeader()
{
}
SrsRtpH264Header::~SrsRtpH264Header()
{
}
SrsRtpH264Header::SrsRtpH264Header(const SrsRtpH264Header& rhs)
{
operator=(rhs);
}
SrsRtpH264Header& SrsRtpH264Header::operator=(const SrsRtpH264Header& rhs)
{
SrsRtpPayloadHeader::operator=(rhs);
nalu_type = rhs.nalu_type;
nalu_header = rhs.nalu_header;
nalu_offset = rhs.nalu_offset;
return *this;
}
SrsRtpOpusHeader::SrsRtpOpusHeader() : SrsRtpPayloadHeader()
{
}
SrsRtpOpusHeader::~SrsRtpOpusHeader()
{
}
SrsRtpOpusHeader::SrsRtpOpusHeader(const SrsRtpOpusHeader& rhs)
{
operator=(rhs);
}
SrsRtpOpusHeader& SrsRtpOpusHeader::operator=(const SrsRtpOpusHeader& rhs)
{
SrsRtpPayloadHeader::operator=(rhs);
return *this;
}
SrsRtpSharedPacket::SrsRtpSharedPacketPayload::SrsRtpSharedPacketPayload()
{
payload = NULL;
size = 0;
shared_count = 0;
}
SrsRtpSharedPacket::SrsRtpSharedPacketPayload::~SrsRtpSharedPacketPayload()
{
srs_freepa(payload);
}
SrsRtpSharedPacket::SrsRtpSharedPacket()
{
payload_ptr = NULL;
payload = NULL;
size = 0;
rtp_payload_header = NULL;
}
SrsRtpSharedPacket::~SrsRtpSharedPacket()
{
if (payload_ptr) {
if (payload_ptr->shared_count == 0) {
srs_freep(payload_ptr);
} else {
--payload_ptr->shared_count;
}
}
srs_freep(rtp_payload_header);
}
srs_error_t SrsRtpSharedPacket::create(SrsRtpHeader* rtp_h, SrsRtpPayloadHeader* rtp_ph, char* p, int s)
{
srs_error_t err = srs_success;
if (s < 0) {
return srs_error_new(ERROR_RTP_PACKET_CREATE, "create packet size=%d", s);
}
srs_assert(!payload_ptr);
this->rtp_header = *rtp_h;
this->rtp_payload_header = rtp_ph;
// TODO: rtp header padding.
int buffer_size = rtp_header.nb_bytes() + 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 = buffer;
payload_ptr->size = buffer_size;
this->payload = payload_ptr->payload;
this->size = payload_ptr->size;
return err;
}
srs_error_t SrsRtpSharedPacket::decode(char* buf, int nb_buf)
{
srs_error_t err = srs_success;
SrsBuffer stream(buf, nb_buf);
if ((err = rtp_header.decode(&stream)) != srs_success) {
return srs_error_wrap(err, "rtp header decode failed");
}
payload_ptr = new SrsRtpSharedPacketPayload();
payload_ptr->payload = buf;
payload_ptr->size = nb_buf;
this->payload = payload_ptr->payload;
this->size = payload_ptr->size;
return err;
}
SrsRtpSharedPacket* SrsRtpSharedPacket::copy()
{
SrsRtpSharedPacket* copy = new SrsRtpSharedPacket();
copy->payload_ptr = payload_ptr;
payload_ptr->shared_count++;
copy->rtp_header = rtp_header;
if (dynamic_cast<SrsRtpH264Header*>(rtp_payload_header)) {
copy->rtp_payload_header = new SrsRtpH264Header(*(dynamic_cast<SrsRtpH264Header*>(rtp_payload_header)));
} else if (dynamic_cast<SrsRtpOpusHeader*>(rtp_payload_header)) {
copy->rtp_payload_header = new SrsRtpOpusHeader(*(dynamic_cast<SrsRtpOpusHeader*>(rtp_payload_header)));
}
copy->payload = payload;
copy->size = size;
return copy;
}
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 < kRtpHeaderFixedSize) {
return srs_error_new(ERROR_RTC_RTP_MUXER, "rtp payload incorrect");
}
rtp_header.set_marker(marker);
if (marker) {
payload_ptr->payload[1] |= kRtpMarker;
} else {
payload_ptr->payload[1] &= (~kRtpMarker);
}
return err;
}
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 < 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::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 < kRtpHeaderFixedSize) {
return srs_error_new(ERROR_RTC_RTP_MUXER, "rtp payload incorrect");
}
rtp_header.set_payload_type(payload_type);
payload_ptr->payload[1] = (payload_ptr->payload[1] & 0x80) | payload_type;
return err;
}