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

RTC: Rename RTCP_XXX to RtcpXXX

Browse source
This commit is contained in:
忘篱 2020-05-15 12:03:43 +08:00
parent cef8be4a46
commit e20a1d2f39
2 changed files with 179 additions and 181 deletions
Download patch file Download diff file Expand all files Collapse all files

258
trunk/src/kernel/srs_kernel_rtc_rtcp.cpp
View file

@ -28,81 +28,81 @@
using namespace std; using namespace std;
SrsRTCPCommon::SrsRTCPCommon() SrsRtcpCommon::SrsRtcpCommon()
{ {
} }
SrsRTCPCommon::~SrsRTCPCommon() SrsRtcpCommon::~SrsRtcpCommon()
{ {
} }
srs_error_t SrsRTCPCommon::decode_header(SrsBuffer *buffer) srs_error_t SrsRtcpCommon::decode_header(SrsBuffer *buffer)
{ {
buffer->read_bytes((char*)(&header_), sizeof(srs_rtcp_header_t)); buffer->read_bytes((char*)(&header_), sizeof(SrsRtcpHeader));
header_.length = ntohs(header_.length); header_.length = ntohs(header_.length);
return srs_success; return srs_success;
} }
srs_error_t SrsRTCPCommon::encode_header(SrsBuffer *buffer) srs_error_t SrsRtcpCommon::encode_header(SrsBuffer *buffer)
{ {
header_.length = htons(header_.length); header_.length = htons(header_.length);
buffer->write_bytes((char*)(&header_), sizeof(srs_rtcp_header_t)); buffer->write_bytes((char*)(&header_), sizeof(SrsRtcpHeader));
return srs_success; return srs_success;
} }
srs_error_t SrsRTCPCommon::decode(SrsBuffer *buffer) srs_error_t SrsRtcpCommon::decode(SrsBuffer *buffer)
{ {
srs_error_t err = srs_success; srs_error_t err = srs_success;
err = decode_header(buffer); err = decode_header(buffer);
if(srs_success != err) { if(srs_success != err) {
return srs_error_wrap(err, "fail to parse rtcp header"); return srs_error_wrap(err, "fail to parse rtcp header");
} }
payload_len_ = (header_.length + 1) * 4 - sizeof(srs_rtcp_header_t); payload_len_ = (header_.length + 1) * 4 - sizeof(SrsRtcpHeader);
buffer->read_bytes((char *)payload_, payload_len_); buffer->read_bytes((char *)payload_, payload_len_);
return srs_success; return srs_success;
} }
int SrsRTCPCommon::nb_bytes() int SrsRtcpCommon::nb_bytes()
{ {
return sizeof(srs_rtcp_header_t) + payload_len_; return sizeof(SrsRtcpHeader) + payload_len_;
} }
srs_error_t SrsRTCPCommon::encode(SrsBuffer *buffer) srs_error_t SrsRtcpCommon::encode(SrsBuffer *buffer)
{ {
return srs_error_new(ERROR_RTC_RTCP, "not implement"); return srs_error_new(ERROR_RTC_RTCP, "not implement");
} }
SrsRTCP_App::SrsRTCP_App():ssrc_(0) SrsRtcpApp::SrsRtcpApp():ssrc_(0)
{ {
} }
SrsRTCP_App::~SrsRTCP_App() SrsRtcpApp::~SrsRtcpApp()
{ {
} }
const uint32_t SrsRTCP_App::get_ssrc() const const uint32_t SrsRtcpApp::get_ssrc() const
{ {
return ssrc_; return ssrc_;
} }
const uint8_t SrsRTCP_App::get_subtype() const const uint8_t SrsRtcpApp::get_subtype() const
{ {
return header_.rc; return header_.rc;
} }
const string SrsRTCP_App::get_name() const const string SrsRtcpApp::get_name() const
{ {
return string((char*)name_); return string((char*)name_);
} }
const srs_error_t SrsRTCP_App::get_payload(uint8_t*& payload, int& len) const srs_error_t SrsRtcpApp::get_payload(uint8_t*& payload, int& len)
{ {
len = payload_len_; len = payload_len_;
payload = payload_; payload = payload_;
return srs_success; return srs_success;
} }
srs_error_t SrsRTCP_App::set_subtype(uint8_t type) srs_error_t SrsRtcpApp::set_subtype(uint8_t type)
{ {
if(31 < type) { if(31 < type) {
return srs_error_new(ERROR_RTC_RTCP, "subtype is out of range. type:%d", type); return srs_error_new(ERROR_RTC_RTCP, "subtype is out of range. type:%d", type);
@ -111,7 +111,7 @@ srs_error_t SrsRTCP_App::set_subtype(uint8_t type)
return srs_success; return srs_success;
} }
srs_error_t SrsRTCP_App::set_name(std::string name) srs_error_t SrsRtcpApp::set_name(std::string name)
{ {
if(name.length() > 4) { if(name.length() > 4) {
return srs_error_new(ERROR_RTC_RTCP, "length of name is more than 4. len:%d", name.length()); return srs_error_new(ERROR_RTC_RTCP, "length of name is more than 4. len:%d", name.length());
@ -121,7 +121,7 @@ srs_error_t SrsRTCP_App::set_name(std::string name)
return srs_success; return srs_success;
} }
srs_error_t SrsRTCP_App::set_payload(uint8_t* payload, int len) srs_error_t SrsRtcpApp::set_payload(uint8_t* payload, int len)
{ {
if(len > (kRtcpPacketSize - 12)) { if(len > (kRtcpPacketSize - 12)) {
return srs_error_new(ERROR_RTC_RTCP, "length of payload is more than 1488. len:%d", len); return srs_error_new(ERROR_RTC_RTCP, "length of payload is more than 1488. len:%d", len);
@ -131,12 +131,12 @@ srs_error_t SrsRTCP_App::set_payload(uint8_t* payload, int len)
return srs_success; return srs_success;
} }
void SrsRTCP_App::set_ssrc(uint32_t ssrc) void SrsRtcpApp::set_ssrc(uint32_t ssrc)
{ {
ssrc_ = ssrc; ssrc_ = ssrc;
} }
srs_error_t SrsRTCP_App::decode(SrsBuffer *buffer) srs_error_t SrsRtcpApp::decode(SrsBuffer *buffer)
{ {
srs_error_t err = srs_success; srs_error_t err = srs_success;
err = decode_header(buffer); err = decode_header(buffer);
@ -145,17 +145,17 @@ srs_error_t SrsRTCP_App::decode(SrsBuffer *buffer)
} }
ssrc_ = buffer->read_4bytes(); ssrc_ = buffer->read_4bytes();
buffer->read_bytes((char *)name_, sizeof(name_)); buffer->read_bytes((char *)name_, sizeof(name_));
payload_len_ = (header_.length + 1) * 4 - sizeof(srs_rtcp_header_t) - sizeof(name_) - sizeof(ssrc_); payload_len_ = (header_.length + 1) * 4 - sizeof(SrsRtcpHeader) - sizeof(name_) - sizeof(ssrc_);
buffer->read_bytes((char *)payload_, payload_len_); buffer->read_bytes((char *)payload_, payload_len_);
return srs_success; return srs_success;
} }
int SrsRTCP_App::nb_bytes() int SrsRtcpApp::nb_bytes()
{ {
return sizeof(srs_rtcp_header_t) + sizeof(ssrc_) + sizeof(name_) + payload_len_; return sizeof(SrsRtcpHeader) + sizeof(ssrc_) + sizeof(name_) + payload_len_;
} }
srs_error_t SrsRTCP_App::encode(SrsBuffer *buffer) srs_error_t SrsRtcpApp::encode(SrsBuffer *buffer)
{ {
srs_error_t err = srs_success; srs_error_t err = srs_success;
if(! buffer->require(nb_bytes())) { if(! buffer->require(nb_bytes())) {
@ -173,71 +173,71 @@ srs_error_t SrsRTCP_App::encode(SrsBuffer *buffer)
return srs_success; return srs_success;
} }
SrsRTCP_SR::SrsRTCP_SR() SrsRtcpSR::SrsRtcpSR()
{ {
header_.padding = 0; header_.padding = 0;
header_.type = srs_rtcp_type_sr; header_.type = SrsRtcpType_sr;
header_.rc = 0; header_.rc = 0;
header_.version = kRtcpVersion; header_.version = kRtcpVersion;
header_.length = 6; header_.length = 6;
} }
SrsRTCP_SR::~SrsRTCP_SR() SrsRtcpSR::~SrsRtcpSR()
{ {
} }
const uint32_t SrsRTCP_SR::get_sender_ssrc() const const uint32_t SrsRtcpSR::get_sender_ssrc() const
{ {
return sender_ssrc_; return sender_ssrc_;
} }
const uint64_t SrsRTCP_SR::get_ntp() const const uint64_t SrsRtcpSR::get_ntp() const
{ {
return ntp_; return ntp_;
} }
const uint32_t SrsRTCP_SR::get_rtp_ts() const const uint32_t SrsRtcpSR::get_rtp_ts() const
{ {
return rtp_ts_; return rtp_ts_;
} }
const uint32_t SrsRTCP_SR::get_rtp_send_packets() const const uint32_t SrsRtcpSR::get_rtp_send_packets() const
{ {
return send_rtp_packets_; return send_rtp_packets_;
} }
const uint32_t SrsRTCP_SR::get_rtp_send_bytes() const const uint32_t SrsRtcpSR::get_rtp_send_bytes() const
{ {
return send_rtp_bytes_; return send_rtp_bytes_;
} }
void SrsRTCP_SR::set_sender_ssrc(uint32_t ssrc) void SrsRtcpSR::set_sender_ssrc(uint32_t ssrc)
{ {
sender_ssrc_ = ssrc; sender_ssrc_ = ssrc;
} }
void SrsRTCP_SR::set_ntp(uint64_t ntp) void SrsRtcpSR::set_ntp(uint64_t ntp)
{ {
ntp_ = ntp; ntp_ = ntp;
} }
void SrsRTCP_SR::set_rtp_ts(uint32_t ts) void SrsRtcpSR::set_rtp_ts(uint32_t ts)
{ {
rtp_ts_ = ts; rtp_ts_ = ts;
} }
void SrsRTCP_SR::set_rtp_send_packets(uint32_t packets) void SrsRtcpSR::set_rtp_send_packets(uint32_t packets)
{ {
send_rtp_packets_ = packets; send_rtp_packets_ = packets;
} }
void SrsRTCP_SR::set_rtp_send_bytes(uint32_t bytes) void SrsRtcpSR::set_rtp_send_bytes(uint32_t bytes)
{ {
send_rtp_bytes_ = bytes; send_rtp_bytes_ = bytes;
} }
srs_error_t SrsRTCP_SR::decode(SrsBuffer *buffer) srs_error_t SrsRtcpSR::decode(SrsBuffer *buffer)
{ {
srs_error_t err = srs_success; srs_error_t err = srs_success;
err = decode_header(buffer); err = decode_header(buffer);
@ -256,12 +256,12 @@ srs_error_t SrsRTCP_SR::decode(SrsBuffer *buffer)
return err; return err;
} }
int SrsRTCP_SR::nb_bytes() int SrsRtcpSR::nb_bytes()
{ {
return (header_.length + 1) * 4; return (header_.length + 1) * 4;
} }
srs_error_t SrsRTCP_SR::encode(SrsBuffer *buffer) srs_error_t SrsRtcpSR::encode(SrsBuffer *buffer)
{ {
srs_error_t err = srs_success; srs_error_t err = srs_success;
if(! buffer->require(nb_bytes())) { if(! buffer->require(nb_bytes())) {
@ -280,96 +280,96 @@ srs_error_t SrsRTCP_SR::encode(SrsBuffer *buffer)
return err; return err;
} }
SrsRTCP_RR::SrsRTCP_RR(uint32_t sender_ssrc/*=0*/): sender_ssrc_(sender_ssrc) SrsRtcpRR::SrsRtcpRR(uint32_t sender_ssrc/*=0*/): sender_ssrc_(sender_ssrc)
{ {
header_.padding = 0; header_.padding = 0;
header_.type = srs_rtcp_type_rr; header_.type = SrsRtcpType_rr;
header_.rc = 0; header_.rc = 0;
header_.version = kRtcpVersion; header_.version = kRtcpVersion;
header_.length = 7; header_.length = 7;
} }
SrsRTCP_RR::~SrsRTCP_RR() SrsRtcpRR::~SrsRtcpRR()
{ {
} }
const uint32_t SrsRTCP_RR::get_rb_ssrc() const const uint32_t SrsRtcpRR::get_rb_ssrc() const
{ {
return rb_.ssrc; return rb_.ssrc;
} }
const float SrsRTCP_RR::get_lost_rate() const const float SrsRtcpRR::get_lost_rate() const
{ {
return rb_.fraction_lost / 256; return rb_.fraction_lost / 256;
} }
const uint32_t SrsRTCP_RR::get_lost_packets() const const uint32_t SrsRtcpRR::get_lost_packets() const
{ {
return rb_.lost_packets; return rb_.lost_packets;
} }
const uint32_t SrsRTCP_RR::get_highest_sn() const const uint32_t SrsRtcpRR::get_highest_sn() const
{ {
return rb_.highest_sn; return rb_.highest_sn;
} }
const uint32_t SrsRTCP_RR::get_jitter() const const uint32_t SrsRtcpRR::get_jitter() const
{ {
return rb_.jitter; return rb_.jitter;
} }
const uint32_t SrsRTCP_RR::get_lsr() const const uint32_t SrsRtcpRR::get_lsr() const
{ {
return rb_.lsr; return rb_.lsr;
} }
const uint32_t SrsRTCP_RR::get_dlsr() const const uint32_t SrsRtcpRR::get_dlsr() const
{ {
return rb_.dlsr; return rb_.dlsr;
} }
void SrsRTCP_RR::set_rb_ssrc(uint32_t ssrc) void SrsRtcpRR::set_rb_ssrc(uint32_t ssrc)
{ {
rb_.ssrc = ssrc; rb_.ssrc = ssrc;
} }
void SrsRTCP_RR::set_lost_rate(float rate) void SrsRtcpRR::set_lost_rate(float rate)
{ {
rb_.fraction_lost = rate * 256; rb_.fraction_lost = rate * 256;
} }
void SrsRTCP_RR::set_lost_packets(uint32_t count) void SrsRtcpRR::set_lost_packets(uint32_t count)
{ {
rb_.lost_packets = count; rb_.lost_packets = count;
} }
void SrsRTCP_RR::set_highest_sn(uint32_t sn) void SrsRtcpRR::set_highest_sn(uint32_t sn)
{ {
rb_.highest_sn = sn; rb_.highest_sn = sn;
} }
void SrsRTCP_RR::set_jitter(uint32_t jitter) void SrsRtcpRR::set_jitter(uint32_t jitter)
{ {
rb_.jitter = jitter; rb_.jitter = jitter;
} }
void SrsRTCP_RR::set_lsr(uint32_t lsr) void SrsRtcpRR::set_lsr(uint32_t lsr)
{ {
rb_.lsr = lsr; rb_.lsr = lsr;
} }
void SrsRTCP_RR::set_dlsr(uint32_t dlsr) void SrsRtcpRR::set_dlsr(uint32_t dlsr)
{ {
rb_.dlsr = dlsr; rb_.dlsr = dlsr;
} }
void SrsRTCP_RR::set_sender_ntp(uint64_t ntp) void SrsRtcpRR::set_sender_ntp(uint64_t ntp)
{ {
uint32_t lsr = (uint32_t)((ntp >> 16) & 0x00000000FFFFFFFF); uint32_t lsr = (uint32_t)((ntp >> 16) & 0x00000000FFFFFFFF);
rb_.lsr = lsr; rb_.lsr = lsr;
} }
srs_error_t SrsRTCP_RR::decode(SrsBuffer *buffer) srs_error_t SrsRtcpRR::decode(SrsBuffer *buffer)
{ {
srs_error_t err = srs_success; srs_error_t err = srs_success;
err = decode_header(buffer); err = decode_header(buffer);
@ -396,12 +396,12 @@ srs_error_t SrsRTCP_RR::decode(SrsBuffer *buffer)
return err; return err;
} }
int SrsRTCP_RR::nb_bytes() int SrsRtcpRR::nb_bytes()
{ {
return (header_.length + 1) * 4; return (header_.length + 1) * 4;
} }
srs_error_t SrsRTCP_RR::encode(SrsBuffer *buffer) srs_error_t SrsRtcpRR::encode(SrsBuffer *buffer)
{ {
srs_error_t err = srs_success; srs_error_t err = srs_success;
if(! buffer->require(nb_bytes())) { if(! buffer->require(nb_bytes())) {
@ -426,19 +426,19 @@ srs_error_t SrsRTCP_RR::encode(SrsBuffer *buffer)
return err; return err;
} }
SrsRTCP_TWCC::SrsRTCP_TWCC(uint32_t sender_ssrc/*=0*/) : sender_ssrc_(sender_ssrc), pkt_len(0) SrsRtcpTWCC::SrsRtcpTWCC(uint32_t sender_ssrc/*=0*/) : sender_ssrc_(sender_ssrc), pkt_len(0)
{ {
header_.padding = 0; header_.padding = 0;
header_.type = srs_rtcp_type_rtpfb; header_.type = SrsRtcpType_rtpfb;
header_.rc = 15; header_.rc = 15;
header_.version = kRtcpVersion; header_.version = kRtcpVersion;
} }
SrsRTCP_TWCC::~SrsRTCP_TWCC() SrsRtcpTWCC::~SrsRtcpTWCC()
{ {
} }
void SrsRTCP_TWCC::clear() void SrsRtcpTWCC::clear()
{ {
encoded_chucks_.clear(); encoded_chucks_.clear();
pkt_deltas_.clear(); pkt_deltas_.clear();
@ -446,75 +446,75 @@ void SrsRTCP_TWCC::clear()
recv_sns_.clear(); recv_sns_.clear();
} }
const uint32_t SrsRTCP_TWCC::get_media_ssrc() const const uint32_t SrsRtcpTWCC::get_media_ssrc() const
{ {
return media_ssrc_; return media_ssrc_;
} }
const uint16_t SrsRTCP_TWCC::get_base_sn() const const uint16_t SrsRtcpTWCC::get_base_sn() const
{ {
return base_sn_; return base_sn_;
} }
const uint32_t SrsRTCP_TWCC::get_reference_time() const const uint32_t SrsRtcpTWCC::get_reference_time() const
{ {
return reference_time_; return reference_time_;
} }
const uint8_t SrsRTCP_TWCC::get_feedback_count() const const uint8_t SrsRtcpTWCC::get_feedback_count() const
{ {
return fb_pkt_count_; return fb_pkt_count_;
} }
const uint16_t SrsRTCP_TWCC::get_packet_status_count() const const uint16_t SrsRtcpTWCC::get_packet_status_count() const
{ {
return packet_count_; return packet_count_;
} }
const vector<uint16_t> SrsRTCP_TWCC::get_packet_chucks() const const vector<uint16_t> SrsRtcpTWCC::get_packet_chucks() const
{ {
return encoded_chucks_; return encoded_chucks_;
} }
const vector<uint16_t> SrsRTCP_TWCC::get_recv_deltas() const const vector<uint16_t> SrsRtcpTWCC::get_recv_deltas() const
{ {
return pkt_deltas_; return pkt_deltas_;
} }
void SrsRTCP_TWCC::set_media_ssrc(uint32_t ssrc) void SrsRtcpTWCC::set_media_ssrc(uint32_t ssrc)
{ {
media_ssrc_ = ssrc; media_ssrc_ = ssrc;
} }
void SrsRTCP_TWCC::set_base_sn(uint16_t sn) void SrsRtcpTWCC::set_base_sn(uint16_t sn)
{ {
base_sn_ = sn; base_sn_ = sn;
} }
void SrsRTCP_TWCC::set_packet_status_count(uint16_t count) void SrsRtcpTWCC::set_packet_status_count(uint16_t count)
{ {
packet_count_ = count; packet_count_ = count;
} }
void SrsRTCP_TWCC::set_reference_time(uint32_t time) void SrsRtcpTWCC::set_reference_time(uint32_t time)
{ {
reference_time_ = time; reference_time_ = time;
} }
void SrsRTCP_TWCC::set_feedback_count(uint8_t count) void SrsRtcpTWCC::set_feedback_count(uint8_t count)
{ {
fb_pkt_count_ = count; fb_pkt_count_ = count;
} }
void SrsRTCP_TWCC::add_packet_chuck(uint16_t chunk) void SrsRtcpTWCC::add_packet_chuck(uint16_t chunk)
{ {
encoded_chucks_.push_back(chunk); encoded_chucks_.push_back(chunk);
} }
void SrsRTCP_TWCC::add_recv_delta(uint16_t delta) void SrsRtcpTWCC::add_recv_delta(uint16_t delta)
{ {
pkt_deltas_.push_back(delta); pkt_deltas_.push_back(delta);
} }
srs_error_t SrsRTCP_TWCC::recv_packet(uint16_t sn, srs_utime_t ts) srs_error_t SrsRtcpTWCC::recv_packet(uint16_t sn, srs_utime_t ts)
{ {
map<uint16_t, srs_utime_t>::iterator it = recv_packes_.find(sn); map<uint16_t, srs_utime_t>::iterator it = recv_packes_.find(sn);
if(it != recv_packes_.end()) { if(it != recv_packes_.end()) {
@ -525,19 +525,19 @@ srs_error_t SrsRTCP_TWCC::recv_packet(uint16_t sn, srs_utime_t ts)
return srs_success; return srs_success;
} }
srs_error_t SrsRTCP_TWCC::decode(SrsBuffer *buffer) srs_error_t SrsRtcpTWCC::decode(SrsBuffer *buffer)
{ {
srs_error_t err = srs_success; srs_error_t err = srs_success;
return err; return err;
} }
int SrsRTCP_TWCC::nb_bytes() int SrsRtcpTWCC::nb_bytes()
{ {
return kRtcpPacketSize; return kRtcpPacketSize;
} }
srs_utime_t SrsRTCP_TWCC::calculate_delta_us(srs_utime_t ts, srs_utime_t last) srs_utime_t SrsRtcpTWCC::calculate_delta_us(srs_utime_t ts, srs_utime_t last)
{ {
int64_t divisor = kTwccFbReferenceTimeDivisor; int64_t divisor = kTwccFbReferenceTimeDivisor;
int64_t delta_us = (ts - last) % divisor; int64_t delta_us = (ts - last) % divisor;
@ -551,7 +551,7 @@ srs_utime_t SrsRTCP_TWCC::calculate_delta_us(srs_utime_t ts, srs_utime_t last)
return delta_us; return delta_us;
} }
bool SrsRTCP_TWCC::can_add_to_chunk(SrsRTCP_TWCC::srs_rtcp_twcc_chunk_t& chunk, int delta_size) bool SrsRtcpTWCC::can_add_to_chunk(SrsRtcpTWCC::srs_rtcp_twcc_chunk_t& chunk, int delta_size)
{ {
srs_verbose("can_add %d chunk->size %u delta_sizes %d %d %d %d %d %d %d %d %d %d %d %d %d %d" srs_verbose("can_add %d chunk->size %u delta_sizes %d %d %d %d %d %d %d %d %d %d %d %d %d %d"
" all_same %d has_large_delta %d", " all_same %d has_large_delta %d",
@ -583,7 +583,7 @@ bool SrsRTCP_TWCC::can_add_to_chunk(SrsRTCP_TWCC::srs_rtcp_twcc_chunk_t& chunk,
return false; return false;
} }
void SrsRTCP_TWCC::add_to_chunk(SrsRTCP_TWCC::srs_rtcp_twcc_chunk_t& chunk, int delta_size) void SrsRtcpTWCC::add_to_chunk(SrsRtcpTWCC::srs_rtcp_twcc_chunk_t& chunk, int delta_size)
{ {
if (chunk.size < kTwccFbMaxBitElements) if (chunk.size < kTwccFbMaxBitElements)
chunk.delta_sizes[chunk.size] = delta_size; chunk.delta_sizes[chunk.size] = delta_size;
@ -592,7 +592,7 @@ void SrsRTCP_TWCC::add_to_chunk(SrsRTCP_TWCC::srs_rtcp_twcc_chunk_t& chunk, int
chunk.has_large_delta = chunk.has_large_delta || delta_size >= kTwccFbLargeRecvDeltaBytes; chunk.has_large_delta = chunk.has_large_delta || delta_size >= kTwccFbLargeRecvDeltaBytes;
} }
srs_error_t SrsRTCP_TWCC::encode_chunk_run_length(SrsRTCP_TWCC::srs_rtcp_twcc_chunk_t& chunk) srs_error_t SrsRtcpTWCC::encode_chunk_run_length(SrsRtcpTWCC::srs_rtcp_twcc_chunk_t& chunk)
{ {
if (!chunk.all_same || chunk.size > kTwccFbMaxRunLength) if (!chunk.all_same || chunk.size > kTwccFbMaxRunLength)
return srs_error_new(ERROR_RTC_RTCP, "cannot encode by run length. all_same:%d, size:%d", chunk.all_same, chunk.size); return srs_error_new(ERROR_RTC_RTCP, "cannot encode by run length. all_same:%d, size:%d", chunk.all_same, chunk.size);
@ -605,7 +605,7 @@ srs_error_t SrsRTCP_TWCC::encode_chunk_run_length(SrsRTCP_TWCC::srs_rtcp_twcc_ch
return 0; return 0;
} }
srs_error_t SrsRTCP_TWCC::encode_chunk_one_bit(SrsRTCP_TWCC::srs_rtcp_twcc_chunk_t& chunk) srs_error_t SrsRtcpTWCC::encode_chunk_one_bit(SrsRtcpTWCC::srs_rtcp_twcc_chunk_t& chunk)
{ {
int i = 0; int i = 0;
if (chunk.has_large_delta) if (chunk.has_large_delta)
@ -622,7 +622,7 @@ srs_error_t SrsRTCP_TWCC::encode_chunk_one_bit(SrsRTCP_TWCC::srs_rtcp_twcc_chunk
return srs_success; return srs_success;
} }
srs_error_t SrsRTCP_TWCC::encode_chunk_two_bit(SrsRTCP_TWCC::srs_rtcp_twcc_chunk_t& chunk, size_t size, bool shift) srs_error_t SrsRtcpTWCC::encode_chunk_two_bit(SrsRtcpTWCC::srs_rtcp_twcc_chunk_t& chunk, size_t size, bool shift)
{ {
unsigned int i = 0; unsigned int i = 0;
uint8_t delta_size = 0; uint8_t delta_size = 0;
@ -644,15 +644,13 @@ srs_error_t SrsRTCP_TWCC::encode_chunk_two_bit(SrsRTCP_TWCC::srs_rtcp_twcc_chunk
chunk.all_same = (chunk.all_same && delta_size == chunk.delta_sizes[0]); chunk.all_same = (chunk.all_same && delta_size == chunk.delta_sizes[0]);
chunk.has_large_delta = chunk.has_large_delta || delta_size == kTwccFbLargeRecvDeltaBytes; chunk.has_large_delta = chunk.has_large_delta || delta_size == kTwccFbLargeRecvDeltaBytes;
} }
// JANUS_LOG(LOG_INFO, "ccc->size %u size %u B\n", ccc->size, size);
chunk.size -= size; chunk.size -= size;
// JANUS_LOG(LOG_INFO, "ccc->size %u shift %d A\n", ccc->size, shift);
} }
return srs_success; return srs_success;
} }
void SrsRTCP_TWCC::reset_chunk(SrsRTCP_TWCC::srs_rtcp_twcc_chunk_t& chunk) void SrsRtcpTWCC::reset_chunk(SrsRtcpTWCC::srs_rtcp_twcc_chunk_t& chunk)
{ {
chunk.size = 0; chunk.size = 0;
@ -660,7 +658,7 @@ void SrsRTCP_TWCC::reset_chunk(SrsRTCP_TWCC::srs_rtcp_twcc_chunk_t& chunk)
chunk.has_large_delta = false; chunk.has_large_delta = false;
} }
srs_error_t SrsRTCP_TWCC::encode_chunk(SrsRTCP_TWCC::srs_rtcp_twcc_chunk_t& chunk) srs_error_t SrsRtcpTWCC::encode_chunk(SrsRtcpTWCC::srs_rtcp_twcc_chunk_t& chunk)
{ {
srs_error_t err = srs_success; srs_error_t err = srs_success;
@ -688,7 +686,7 @@ srs_error_t SrsRTCP_TWCC::encode_chunk(SrsRTCP_TWCC::srs_rtcp_twcc_chunk_t& chun
return err; return err;
} }
srs_error_t SrsRTCP_TWCC::encode_remaining_chunk(SrsRTCP_TWCC::srs_rtcp_twcc_chunk_t& chunk) srs_error_t SrsRtcpTWCC::encode_remaining_chunk(SrsRtcpTWCC::srs_rtcp_twcc_chunk_t& chunk)
{ {
if (chunk.all_same) { if (chunk.all_same) {
return encode_chunk_run_length(chunk); return encode_chunk_run_length(chunk);
@ -699,7 +697,7 @@ srs_error_t SrsRTCP_TWCC::encode_remaining_chunk(SrsRTCP_TWCC::srs_rtcp_twcc_chu
return encode_chunk_one_bit(chunk); return encode_chunk_one_bit(chunk);
} }
srs_error_t SrsRTCP_TWCC::process_pkt_chunk(SrsRTCP_TWCC::srs_rtcp_twcc_chunk_t& chunk, int delta_size) srs_error_t SrsRtcpTWCC::process_pkt_chunk(SrsRtcpTWCC::srs_rtcp_twcc_chunk_t& chunk, int delta_size)
{ {
srs_error_t err = srs_success; srs_error_t err = srs_success;
@ -732,7 +730,7 @@ srs_error_t SrsRTCP_TWCC::process_pkt_chunk(SrsRTCP_TWCC::srs_rtcp_twcc_chunk_t&
return err; return err;
} }
srs_error_t SrsRTCP_TWCC::encode(SrsBuffer *buffer) srs_error_t SrsRtcpTWCC::encode(SrsBuffer *buffer)
{ {
srs_error_t err = srs_success; srs_error_t err = srs_success;
if(! buffer->require(nb_bytes())) { if(! buffer->require(nb_bytes())) {
@ -740,7 +738,7 @@ srs_error_t SrsRTCP_TWCC::encode(SrsBuffer *buffer)
"the size of buffer is not enough. buffer:%d, required:%d", buffer->left(), nb_bytes()); "the size of buffer is not enough. buffer:%d, required:%d", buffer->left(), nb_bytes());
} }
pkt_len = kTwccFbPktHeaderSize; pkt_len = kTwccFbPktHeaderSize;
set<uint16_t, less_compare>::iterator it_sn = recv_sns_.begin(); set<uint16_t, SrsSeqCompareLess>::iterator it_sn = recv_sns_.begin();
base_sn_ = *it_sn; base_sn_ = *it_sn;
map<uint16_t, srs_utime_t>::iterator it_ts = recv_packes_.find(base_sn_); map<uint16_t, srs_utime_t>::iterator it_ts = recv_packes_.find(base_sn_);
srs_utime_t ts = it_ts->second; srs_utime_t ts = it_ts->second;
@ -750,7 +748,7 @@ srs_error_t SrsRTCP_TWCC::encode(SrsBuffer *buffer)
packet_count_ = recv_packes_.size(); packet_count_ = recv_packes_.size();
do { do {
// encode chunk // encode chunk
SrsRTCP_TWCC::srs_rtcp_twcc_chunk_t chunk; SrsRtcpTWCC::srs_rtcp_twcc_chunk_t chunk;
for(; it_sn != recv_sns_.end(); ++it_sn) { for(; it_sn != recv_sns_.end(); ++it_sn) {
uint16_t current_sn = *it_sn; uint16_t current_sn = *it_sn;
// calculate delta // calculate delta
@ -836,43 +834,43 @@ srs_error_t SrsRTCP_TWCC::encode(SrsBuffer *buffer)
return err; return err;
} }
SrsRTCP_Nack::SrsRTCP_Nack(uint32_t sender_ssrc /*= 0*/): sender_ssrc_(sender_ssrc) SrsRtcpNack::SrsRtcpNack(uint32_t sender_ssrc /*= 0*/): sender_ssrc_(sender_ssrc)
{ {
header_.padding = 0; header_.padding = 0;
header_.type = srs_rtcp_type_rtpfb; header_.type = SrsRtcpType_rtpfb;
header_.rc = 1; header_.rc = 1;
header_.version = kRtcpVersion; header_.version = kRtcpVersion;
} }
SrsRTCP_Nack::~SrsRTCP_Nack() SrsRtcpNack::~SrsRtcpNack()
{ {
} }
const uint32_t SrsRTCP_Nack::get_media_ssrc() const const uint32_t SrsRtcpNack::get_media_ssrc() const
{ {
return media_ssrc_; return media_ssrc_;
} }
const vector<uint16_t> SrsRTCP_Nack::get_lost_sns() const const vector<uint16_t> SrsRtcpNack::get_lost_sns() const
{ {
vector<uint16_t> sn; vector<uint16_t> sn;
for(set<uint16_t, less_compare>::iterator it = lost_sns_.begin(); it != lost_sns_.end(); ++it) { for(set<uint16_t, SrsSeqCompareLess>::iterator it = lost_sns_.begin(); it != lost_sns_.end(); ++it) {
sn.push_back(*it); sn.push_back(*it);
} }
return sn; return sn;
} }
void SrsRTCP_Nack::set_media_ssrc(uint32_t ssrc) void SrsRtcpNack::set_media_ssrc(uint32_t ssrc)
{ {
media_ssrc_ = ssrc; media_ssrc_ = ssrc;
} }
void SrsRTCP_Nack::add_lost_sn(uint16_t sn) void SrsRtcpNack::add_lost_sn(uint16_t sn)
{ {
lost_sns_.insert(sn); lost_sns_.insert(sn);
} }
srs_error_t SrsRTCP_Nack::decode(SrsBuffer *buffer) srs_error_t SrsRtcpNack::decode(SrsBuffer *buffer)
{ {
srs_error_t err = srs_success; srs_error_t err = srs_success;
err = decode_header(buffer); err = decode_header(buffer);
@ -898,12 +896,12 @@ srs_error_t SrsRTCP_Nack::decode(SrsBuffer *buffer)
return err; return err;
} }
int SrsRTCP_Nack::nb_bytes() int SrsRtcpNack::nb_bytes()
{ {
return kRtcpPacketSize; return kRtcpPacketSize;
} }
srs_error_t SrsRTCP_Nack::encode(SrsBuffer *buffer) srs_error_t SrsRtcpNack::encode(SrsBuffer *buffer)
{ {
srs_error_t err = srs_success; srs_error_t err = srs_success;
if(! buffer->require(nb_bytes())) { if(! buffer->require(nb_bytes())) {
@ -916,7 +914,7 @@ srs_error_t SrsRTCP_Nack::encode(SrsBuffer *buffer)
pid_blp_t chunk; pid_blp_t chunk;
chunk.in_use = false; chunk.in_use = false;
uint16_t pid = 0; uint16_t pid = 0;
for(set<uint16_t, less_compare>::iterator it = lost_sns_.begin(); it != lost_sns_.end(); ++it) { for(set<uint16_t, SrsSeqCompareLess>::iterator it = lost_sns_.begin(); it != lost_sns_.end(); ++it) {
uint16_t sn = *it; uint16_t sn = *it;
if(!chunk.in_use) { if(!chunk.in_use) {
chunk.pid = sn; chunk.pid = sn;
@ -957,27 +955,27 @@ srs_error_t SrsRTCP_Nack::encode(SrsBuffer *buffer)
return err; return err;
} }
SrsRTCPCompound::SrsRTCPCompound(): nb_bytes_(0) SrsRtcpCompound::SrsRtcpCompound(): nb_bytes_(0)
{ {
} }
SrsRTCPCompound::~SrsRTCPCompound() SrsRtcpCompound::~SrsRtcpCompound()
{ {
clear(); clear();
} }
SrsRTCPCommon* SrsRTCPCompound::get_next_rtcp() SrsRtcpCommon* SrsRtcpCompound::get_next_rtcp()
{ {
if(rtcps_.empty()) { if(rtcps_.empty()) {
return NULL; return NULL;
} }
SrsRTCPCommon *rtcp = rtcps_.back(); SrsRtcpCommon *rtcp = rtcps_.back();
nb_bytes_ -= rtcp->nb_bytes(); nb_bytes_ -= rtcp->nb_bytes();
rtcps_.pop_back(); rtcps_.pop_back();
return rtcp; return rtcp;
} }
srs_error_t SrsRTCPCompound::add_rtcp(SrsRTCPCommon *rtcp) srs_error_t SrsRtcpCompound::add_rtcp(SrsRtcpCommon *rtcp)
{ {
int new_len = rtcp->nb_bytes(); int new_len = rtcp->nb_bytes();
if((new_len + nb_bytes_) > kRtcpPacketSize) { if((new_len + nb_bytes_) > kRtcpPacketSize) {
@ -989,17 +987,17 @@ srs_error_t SrsRTCPCompound::add_rtcp(SrsRTCPCommon *rtcp)
return srs_success; return srs_success;
} }
srs_error_t SrsRTCPCompound::decode(SrsBuffer *buffer) srs_error_t SrsRtcpCompound::decode(SrsBuffer *buffer)
{ {
srs_error_t err = srs_success; srs_error_t err = srs_success;
while(0 != buffer->left()) { while(0 != buffer->left()) {
srs_rtcp_header_t* header = (srs_rtcp_header_t *)(buffer->head()); SrsRtcpHeader* header = (SrsRtcpHeader *)(buffer->head());
switch (header->type) switch (header->type)
{ {
case srs_rtcp_type_sr: case SrsRtcpType_sr:
{ {
SrsRTCP_SR *rtcp = new SrsRTCP_SR; SrsRtcpSR *rtcp = new SrsRtcpSR;
err = rtcp->decode(buffer); err = rtcp->decode(buffer);
if(srs_success != err) { if(srs_success != err) {
return srs_error_wrap(err, "fail to decode rtcp sr"); return srs_error_wrap(err, "fail to decode rtcp sr");
@ -1008,9 +1006,9 @@ srs_error_t SrsRTCPCompound::decode(SrsBuffer *buffer)
rtcps_.push_back(rtcp); rtcps_.push_back(rtcp);
break; break;
} }
case srs_rtcp_type_rr: case SrsRtcpType_rr:
{ {
SrsRTCP_RR *rtcp = new SrsRTCP_RR; SrsRtcpRR *rtcp = new SrsRtcpRR;
err = rtcp->decode(buffer); err = rtcp->decode(buffer);
if(srs_success != err) { if(srs_success != err) {
return srs_error_wrap(err, "fail to decode rtcp rr"); return srs_error_wrap(err, "fail to decode rtcp rr");
@ -1021,7 +1019,7 @@ srs_error_t SrsRTCPCompound::decode(SrsBuffer *buffer)
} }
default: default:
{ {
SrsRTCPCommon *rtcp = new SrsRTCPCommon; SrsRtcpCommon *rtcp = new SrsRtcpCommon;
err = rtcp->decode(buffer); err = rtcp->decode(buffer);
if(srs_success != err) { if(srs_success != err) {
return srs_error_wrap(err, "fail to decode rtcp type:%d", header->type); return srs_error_wrap(err, "fail to decode rtcp type:%d", header->type);
@ -1036,12 +1034,12 @@ srs_error_t SrsRTCPCompound::decode(SrsBuffer *buffer)
return err; return err;
} }
int SrsRTCPCompound::nb_bytes() int SrsRtcpCompound::nb_bytes()
{ {
return nb_bytes_; return nb_bytes_;
} }
srs_error_t SrsRTCPCompound::encode(SrsBuffer *buffer) srs_error_t SrsRtcpCompound::encode(SrsBuffer *buffer)
{ {
srs_error_t err = srs_success; srs_error_t err = srs_success;
if(false == buffer->require(nb_bytes_)) { if(false == buffer->require(nb_bytes_)) {
@ -1049,9 +1047,9 @@ srs_error_t SrsRTCPCompound::encode(SrsBuffer *buffer)
"the left size of buffer is not enough. buffer:%d, required:%d", buffer->left(), nb_bytes_); "the left size of buffer is not enough. buffer:%d, required:%d", buffer->left(), nb_bytes_);
} }
vector<SrsRTCPCommon*>::iterator it; vector<SrsRtcpCommon*>::iterator it;
for(it = rtcps_.begin(); it != rtcps_.end(); ++it) { for(it = rtcps_.begin(); it != rtcps_.end(); ++it) {
SrsRTCPCommon *rtcp = *it; SrsRtcpCommon *rtcp = *it;
err = rtcp->encode(buffer); err = rtcp->encode(buffer);
if(err != srs_success) { if(err != srs_success) {
return srs_error_wrap(err, "fail to encode rtcp compound. type:%d", rtcp->type()); return srs_error_wrap(err, "fail to encode rtcp compound. type:%d", rtcp->type());
@ -1062,11 +1060,11 @@ srs_error_t SrsRTCPCompound::encode(SrsBuffer *buffer)
return err; return err;
} }
void SrsRTCPCompound::clear() void SrsRtcpCompound::clear()
{ {
vector<SrsRTCPCommon*>::iterator it; vector<SrsRtcpCommon*>::iterator it;
for(it = rtcps_.begin(); it != rtcps_.end(); ++it) { for(it = rtcps_.begin(); it != rtcps_.end(); ++it) {
SrsRTCPCommon *rtcp = *it; SrsRtcpCommon *rtcp = *it;
delete rtcp; delete rtcp;
rtcp = NULL; rtcp = NULL;
} }

102
trunk/src/kernel/srs_kernel_rtc_rtcp.hpp
View file

@ -35,22 +35,22 @@
const int kRtcpPacketSize = 1500; const int kRtcpPacketSize = 1500;
const uint8_t kRtcpVersion = 0x2; const uint8_t kRtcpVersion = 0x2;
/*! \brief RTCP Packet Types (http://www.networksorcery.com/enp/protocol/rtcp.htm) */ // RTCP Packet Types, @see http://www.networksorcery.com/enp/protocol/rtcp.htm
typedef enum { enum SrsRtcpType {
srs_rtcp_type_fir = 192, SrsRtcpType_fir = 192,
srs_rtcp_type_sr = 200, SrsRtcpType_sr = 200,
srs_rtcp_type_rr = 201, SrsRtcpType_rr = 201,
srs_rtcp_type_sdes = 202, SrsRtcpType_sdes = 202,
srs_rtcp_type_bye = 203, SrsRtcpType_bye = 203,
srs_rtcp_type_app = 204, SrsRtcpType_app = 204,
srs_rtcp_type_rtpfb = 205, SrsRtcpType_rtpfb = 205,
srs_rtcp_type_psfb = 206, SrsRtcpType_psfb = 206,
srs_rtcp_type_xr = 207, SrsRtcpType_xr = 207,
} srs_rtcp_type; };
/*! \brief RTCP Header (http://tools.ietf.org/html/rfc3550#section-6.1) */ // RTCP Header, @see http://tools.ietf.org/html/rfc3550#section-6.1
typedef struct srs_rtcp_header_s struct SrsRtcpHeader
{ {
uint16_t rc:5; uint16_t rc:5;
uint16_t padding:1; uint16_t padding:1;
@ -58,18 +58,18 @@ typedef struct srs_rtcp_header_s
uint16_t type:8; uint16_t type:8;
uint16_t length:16; uint16_t length:16;
} srs_rtcp_header_t; };
struct less_compare { struct SrsSeqCompareLess {
bool operator()(const uint16_t &lhs, const uint16_t &rhs) const { bool operator()(const uint16_t &lhs, const uint16_t &rhs) const {
return SnCompare(rhs, lhs); return SnCompare(rhs, lhs);
} }
}; };
class SrsRTCPCommon: public ISrsCodec class SrsRtcpCommon: public ISrsCodec
{ {
protected: protected:
srs_rtcp_header_t header_; SrsRtcpHeader header_;
uint8_t payload_[kRtcpPacketSize]; uint8_t payload_[kRtcpPacketSize];
int payload_len_; int payload_len_;
@ -77,8 +77,8 @@ protected:
srs_error_t decode_header(SrsBuffer *buffer); srs_error_t decode_header(SrsBuffer *buffer);
srs_error_t encode_header(SrsBuffer *buffer); srs_error_t encode_header(SrsBuffer *buffer);
public: public:
SrsRTCPCommon(); SrsRtcpCommon();
virtual ~SrsRTCPCommon(); virtual ~SrsRtcpCommon();
virtual const uint8_t type() const { return header_.type; } virtual const uint8_t type() const { return header_.type; }
public: public:
@ -88,18 +88,18 @@ public:
virtual srs_error_t encode(SrsBuffer *buffer); virtual srs_error_t encode(SrsBuffer *buffer);
}; };
class SrsRTCP_App : public SrsRTCPCommon class SrsRtcpApp : public SrsRtcpCommon
{ {
srs_rtcp_header_t header_; SrsRtcpHeader header_;
uint32_t ssrc_; uint32_t ssrc_;
uint8_t name_[4]; uint8_t name_[4];
uint8_t payload_[kRtcpPacketSize]; uint8_t payload_[kRtcpPacketSize];
int payload_len_; int payload_len_;
public: public:
SrsRTCP_App(); SrsRtcpApp();
virtual ~SrsRTCP_App(); virtual ~SrsRtcpApp();
virtual const uint8_t type() const { return srs_rtcp_type_app; } virtual const uint8_t type() const { return SrsRtcpType_app; }
const uint32_t get_ssrc() const; const uint32_t get_ssrc() const;
const uint8_t get_subtype() const; const uint8_t get_subtype() const;
@ -117,7 +117,7 @@ public:
virtual srs_error_t encode(SrsBuffer *buffer); virtual srs_error_t encode(SrsBuffer *buffer);
}; };
typedef struct srs_rtcp_report_block_s { struct srs_rtcp_rb_t {
uint32_t ssrc; uint32_t ssrc;
uint8_t fraction_lost; uint8_t fraction_lost;
uint32_t lost_packets; uint32_t lost_packets;
@ -125,9 +125,9 @@ typedef struct srs_rtcp_report_block_s {
uint32_t jitter; uint32_t jitter;
uint32_t lsr; uint32_t lsr;
uint32_t dlsr; uint32_t dlsr;
}srs_rtcp_rb_t; };
class SrsRTCP_SR : public SrsRTCPCommon class SrsRtcpSR : public SrsRtcpCommon
{ {
private: private:
uint32_t sender_ssrc_; uint32_t sender_ssrc_;
@ -136,12 +136,12 @@ private:
uint32_t send_rtp_packets_; uint32_t send_rtp_packets_;
uint32_t send_rtp_bytes_; uint32_t send_rtp_bytes_;
public: public:
SrsRTCP_SR(); SrsRtcpSR();
virtual ~SrsRTCP_SR(); virtual ~SrsRtcpSR();
const uint8_t get_rc() const { return header_.rc; } const uint8_t get_rc() const { return header_.rc; }
// overload SrsRTCPCommon // overload SrsRtcpCommon
virtual const uint8_t type() const { return srs_rtcp_type_sr; } virtual const uint8_t type() const { return SrsRtcpType_sr; }
const uint32_t get_sender_ssrc() const; const uint32_t get_sender_ssrc() const;
const uint64_t get_ntp() const; const uint64_t get_ntp() const;
const uint32_t get_rtp_ts() const; const uint32_t get_rtp_ts() const;
@ -161,17 +161,17 @@ public:
virtual srs_error_t encode(SrsBuffer *buffer); virtual srs_error_t encode(SrsBuffer *buffer);
}; };
class SrsRTCP_RR : public SrsRTCPCommon class SrsRtcpRR : public SrsRtcpCommon
{ {
private: private:
uint32_t sender_ssrc_; uint32_t sender_ssrc_;
srs_rtcp_rb_t rb_; srs_rtcp_rb_t rb_;
public: public:
SrsRTCP_RR(uint32_t sender_ssrc = 0); SrsRtcpRR(uint32_t sender_ssrc = 0);
virtual ~SrsRTCP_RR(); virtual ~SrsRtcpRR();
// overload SrsRTCPCommon // overload SrsRtcpCommon
virtual const uint8_t type() const { return srs_rtcp_type_rr; } virtual const uint8_t type() const { return SrsRtcpType_rr; }
const uint32_t get_rb_ssrc() const; const uint32_t get_rb_ssrc() const;
const float get_lost_rate() const; const float get_lost_rate() const;
@ -237,7 +237,7 @@ public:
#define kTwccFbLargeRecvDeltaBytes 2 #define kTwccFbLargeRecvDeltaBytes 2
#define kTwccFbMaxBitElements kTwccFbOneBitElements #define kTwccFbMaxBitElements kTwccFbOneBitElements
class SrsRTCP_TWCC : public SrsRTCPCommon class SrsRtcpTWCC : public SrsRtcpCommon
{ {
private: private:
uint32_t sender_ssrc_; uint32_t sender_ssrc_;
@ -250,7 +250,7 @@ private:
std::vector<uint16_t> pkt_deltas_; std::vector<uint16_t> pkt_deltas_;
std::map<uint16_t, srs_utime_t> recv_packes_; std::map<uint16_t, srs_utime_t> recv_packes_;
std::set<uint16_t, less_compare> recv_sns_; std::set<uint16_t, SrsSeqCompareLess> recv_sns_;
typedef struct srs_rtcp_twcc_chunk { typedef struct srs_rtcp_twcc_chunk {
uint8_t delta_sizes[kTwccFbMaxBitElements]; uint8_t delta_sizes[kTwccFbMaxBitElements];
@ -275,8 +275,8 @@ private:
srs_error_t encode_remaining_chunk(srs_rtcp_twcc_chunk_t& chunk); srs_error_t encode_remaining_chunk(srs_rtcp_twcc_chunk_t& chunk);
public: public:
SrsRTCP_TWCC(uint32_t sender_ssrc = 0); SrsRtcpTWCC(uint32_t sender_ssrc = 0);
virtual ~SrsRTCP_TWCC(); virtual ~SrsRtcpTWCC();
const uint32_t get_media_ssrc() const; const uint32_t get_media_ssrc() const;
const uint16_t get_base_sn() const; const uint16_t get_base_sn() const;
@ -304,7 +304,7 @@ public:
}; };
class SrsRTCP_Nack : public SrsRTCPCommon class SrsRtcpNack : public SrsRtcpCommon
{ {
private: private:
typedef struct pid_blp_s { typedef struct pid_blp_s {
@ -315,10 +315,10 @@ private:
uint32_t sender_ssrc_; uint32_t sender_ssrc_;
uint32_t media_ssrc_; uint32_t media_ssrc_;
std::set<uint16_t, less_compare> lost_sns_; std::set<uint16_t, SrsSeqCompareLess> lost_sns_;
public: public:
SrsRTCP_Nack(uint32_t sender_ssrc = 0); SrsRtcpNack(uint32_t sender_ssrc = 0);
virtual ~SrsRTCP_Nack(); virtual ~SrsRtcpNack();
const uint32_t get_media_ssrc() const; const uint32_t get_media_ssrc() const;
const std::vector<uint16_t> get_lost_sns() const; const std::vector<uint16_t> get_lost_sns() const;
@ -334,17 +334,17 @@ public:
}; };
class SrsRTCPCompound : public ISrsCodec class SrsRtcpCompound : public ISrsCodec
{ {
private: private:
std::vector<SrsRTCPCommon* > rtcps_; std::vector<SrsRtcpCommon*> rtcps_;
int nb_bytes_; int nb_bytes_;
public: public:
SrsRTCPCompound(); SrsRtcpCompound();
virtual ~SrsRTCPCompound(); virtual ~SrsRtcpCompound();
SrsRTCPCommon* get_next_rtcp(); SrsRtcpCommon* get_next_rtcp();
srs_error_t add_rtcp(SrsRTCPCommon *rtcp); srs_error_t add_rtcp(SrsRtcpCommon *rtcp);
void clear(); void clear();
public: public: