mirror of
https://github.com/ossrs/srs.git
synced 2025-03-09 15:49:59 +00:00
RTC: Rename RTCP_XXX to RtcpXXX
This commit is contained in:
忘篱
parent
cef8be4a46
commit
e20a1d2f39
2 changed files with 179 additions and 181 deletions
|
|
@ -28,81 +28,81 @@
|
|||
|
||||
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);
|
||||
return srs_success;
|
||||
}
|
||||
|
||||
srs_error_t SrsRTCPCommon::encode_header(SrsBuffer *buffer)
|
||||
srs_error_t SrsRtcpCommon::encode_header(SrsBuffer *buffer)
|
||||
{
|
||||
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;
|
||||
}
|
||||
|
||||
srs_error_t SrsRTCPCommon::decode(SrsBuffer *buffer)
|
||||
srs_error_t SrsRtcpCommon::decode(SrsBuffer *buffer)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
err = decode_header(buffer);
|
||||
if(srs_success != err) {
|
||||
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_);
|
||||
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");
|
||||
}
|
||||
|
||||
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_;
|
||||
}
|
||||
|
||||
const uint8_t SrsRTCP_App::get_subtype() const
|
||||
const uint8_t SrsRtcpApp::get_subtype() const
|
||||
{
|
||||
return header_.rc;
|
||||
}
|
||||
|
||||
const string SrsRTCP_App::get_name() const
|
||||
const string SrsRtcpApp::get_name() const
|
||||
{
|
||||
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_;
|
||||
payload = payload_;
|
||||
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) {
|
||||
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;
|
||||
}
|
||||
|
||||
srs_error_t SrsRTCP_App::set_name(std::string name)
|
||||
srs_error_t SrsRtcpApp::set_name(std::string name)
|
||||
{
|
||||
if(name.length() > 4) {
|
||||
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;
|
||||
}
|
||||
|
||||
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)) {
|
||||
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;
|
||||
}
|
||||
|
||||
void SrsRTCP_App::set_ssrc(uint32_t ssrc)
|
||||
void SrsRtcpApp::set_ssrc(uint32_t ssrc)
|
||||
{
|
||||
ssrc_ = ssrc;
|
||||
}
|
||||
|
||||
srs_error_t SrsRTCP_App::decode(SrsBuffer *buffer)
|
||||
srs_error_t SrsRtcpApp::decode(SrsBuffer *buffer)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
err = decode_header(buffer);
|
||||
|
|
@ -145,17 +145,17 @@ srs_error_t SrsRTCP_App::decode(SrsBuffer *buffer)
|
|||
}
|
||||
ssrc_ = buffer->read_4bytes();
|
||||
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_);
|
||||
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;
|
||||
if(! buffer->require(nb_bytes())) {
|
||||
|
|
@ -173,71 +173,71 @@ srs_error_t SrsRTCP_App::encode(SrsBuffer *buffer)
|
|||
return srs_success;
|
||||
}
|
||||
|
||||
SrsRTCP_SR::SrsRTCP_SR()
|
||||
SrsRtcpSR::SrsRtcpSR()
|
||||
{
|
||||
header_.padding = 0;
|
||||
header_.type = srs_rtcp_type_sr;
|
||||
header_.type = SrsRtcpType_sr;
|
||||
header_.rc = 0;
|
||||
header_.version = kRtcpVersion;
|
||||
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_;
|
||||
}
|
||||
|
||||
const uint64_t SrsRTCP_SR::get_ntp() const
|
||||
const uint64_t SrsRtcpSR::get_ntp() const
|
||||
{
|
||||
return ntp_;
|
||||
}
|
||||
|
||||
const uint32_t SrsRTCP_SR::get_rtp_ts() const
|
||||
const uint32_t SrsRtcpSR::get_rtp_ts() const
|
||||
{
|
||||
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_;
|
||||
}
|
||||
|
||||
const uint32_t SrsRTCP_SR::get_rtp_send_bytes() const
|
||||
const uint32_t SrsRtcpSR::get_rtp_send_bytes() const
|
||||
{
|
||||
return send_rtp_bytes_;
|
||||
}
|
||||
|
||||
void SrsRTCP_SR::set_sender_ssrc(uint32_t ssrc)
|
||||
void SrsRtcpSR::set_sender_ssrc(uint32_t ssrc)
|
||||
{
|
||||
sender_ssrc_ = ssrc;
|
||||
}
|
||||
|
||||
void SrsRTCP_SR::set_ntp(uint64_t ntp)
|
||||
void SrsRtcpSR::set_ntp(uint64_t ntp)
|
||||
{
|
||||
ntp_ = ntp;
|
||||
}
|
||||
|
||||
void SrsRTCP_SR::set_rtp_ts(uint32_t ts)
|
||||
void SrsRtcpSR::set_rtp_ts(uint32_t 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;
|
||||
}
|
||||
|
||||
void SrsRTCP_SR::set_rtp_send_bytes(uint32_t bytes)
|
||||
void SrsRtcpSR::set_rtp_send_bytes(uint32_t 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;
|
||||
err = decode_header(buffer);
|
||||
|
|
@ -256,12 +256,12 @@ srs_error_t SrsRTCP_SR::decode(SrsBuffer *buffer)
|
|||
return err;
|
||||
}
|
||||
|
||||
int SrsRTCP_SR::nb_bytes()
|
||||
int SrsRtcpSR::nb_bytes()
|
||||
{
|
||||
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;
|
||||
if(! buffer->require(nb_bytes())) {
|
||||
|
|
@ -280,96 +280,96 @@ srs_error_t SrsRTCP_SR::encode(SrsBuffer *buffer)
|
|||
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_.type = srs_rtcp_type_rr;
|
||||
header_.type = SrsRtcpType_rr;
|
||||
header_.rc = 0;
|
||||
header_.version = kRtcpVersion;
|
||||
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;
|
||||
}
|
||||
|
||||
const float SrsRTCP_RR::get_lost_rate() const
|
||||
const float SrsRtcpRR::get_lost_rate() const
|
||||
{
|
||||
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;
|
||||
}
|
||||
|
||||
const uint32_t SrsRTCP_RR::get_highest_sn() const
|
||||
const uint32_t SrsRtcpRR::get_highest_sn() const
|
||||
{
|
||||
return rb_.highest_sn;
|
||||
}
|
||||
|
||||
const uint32_t SrsRTCP_RR::get_jitter() const
|
||||
const uint32_t SrsRtcpRR::get_jitter() const
|
||||
{
|
||||
return rb_.jitter;
|
||||
}
|
||||
|
||||
const uint32_t SrsRTCP_RR::get_lsr() const
|
||||
const uint32_t SrsRtcpRR::get_lsr() const
|
||||
{
|
||||
return rb_.lsr;
|
||||
}
|
||||
|
||||
const uint32_t SrsRTCP_RR::get_dlsr() const
|
||||
const uint32_t SrsRtcpRR::get_dlsr() const
|
||||
{
|
||||
return rb_.dlsr;
|
||||
}
|
||||
|
||||
void SrsRTCP_RR::set_rb_ssrc(uint32_t ssrc)
|
||||
void SrsRtcpRR::set_rb_ssrc(uint32_t ssrc)
|
||||
{
|
||||
rb_.ssrc = ssrc;
|
||||
}
|
||||
|
||||
void SrsRTCP_RR::set_lost_rate(float rate)
|
||||
void SrsRtcpRR::set_lost_rate(float rate)
|
||||
{
|
||||
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;
|
||||
}
|
||||
|
||||
void SrsRTCP_RR::set_highest_sn(uint32_t sn)
|
||||
void SrsRtcpRR::set_highest_sn(uint32_t sn)
|
||||
{
|
||||
rb_.highest_sn = sn;
|
||||
}
|
||||
|
||||
void SrsRTCP_RR::set_jitter(uint32_t jitter)
|
||||
void SrsRtcpRR::set_jitter(uint32_t jitter)
|
||||
{
|
||||
rb_.jitter = jitter;
|
||||
}
|
||||
|
||||
void SrsRTCP_RR::set_lsr(uint32_t lsr)
|
||||
void SrsRtcpRR::set_lsr(uint32_t lsr)
|
||||
{
|
||||
rb_.lsr = lsr;
|
||||
}
|
||||
|
||||
void SrsRTCP_RR::set_dlsr(uint32_t dlsr)
|
||||
void SrsRtcpRR::set_dlsr(uint32_t 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);
|
||||
rb_.lsr = lsr;
|
||||
}
|
||||
|
||||
srs_error_t SrsRTCP_RR::decode(SrsBuffer *buffer)
|
||||
srs_error_t SrsRtcpRR::decode(SrsBuffer *buffer)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
err = decode_header(buffer);
|
||||
|
|
@ -396,12 +396,12 @@ srs_error_t SrsRTCP_RR::decode(SrsBuffer *buffer)
|
|||
return err;
|
||||
}
|
||||
|
||||
int SrsRTCP_RR::nb_bytes()
|
||||
int SrsRtcpRR::nb_bytes()
|
||||
{
|
||||
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;
|
||||
if(! buffer->require(nb_bytes())) {
|
||||
|
|
@ -426,19 +426,19 @@ srs_error_t SrsRTCP_RR::encode(SrsBuffer *buffer)
|
|||
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_.type = srs_rtcp_type_rtpfb;
|
||||
header_.type = SrsRtcpType_rtpfb;
|
||||
header_.rc = 15;
|
||||
header_.version = kRtcpVersion;
|
||||
}
|
||||
|
||||
SrsRTCP_TWCC::~SrsRTCP_TWCC()
|
||||
SrsRtcpTWCC::~SrsRtcpTWCC()
|
||||
{
|
||||
}
|
||||
|
||||
void SrsRTCP_TWCC::clear()
|
||||
void SrsRtcpTWCC::clear()
|
||||
{
|
||||
encoded_chucks_.clear();
|
||||
pkt_deltas_.clear();
|
||||
|
|
@ -446,75 +446,75 @@ void SrsRTCP_TWCC::clear()
|
|||
recv_sns_.clear();
|
||||
}
|
||||
|
||||
const uint32_t SrsRTCP_TWCC::get_media_ssrc() const
|
||||
const uint32_t SrsRtcpTWCC::get_media_ssrc() const
|
||||
{
|
||||
return media_ssrc_;
|
||||
}
|
||||
const uint16_t SrsRTCP_TWCC::get_base_sn() const
|
||||
const uint16_t SrsRtcpTWCC::get_base_sn() const
|
||||
{
|
||||
return base_sn_;
|
||||
}
|
||||
|
||||
const uint32_t SrsRTCP_TWCC::get_reference_time() const
|
||||
const uint32_t SrsRtcpTWCC::get_reference_time() const
|
||||
{
|
||||
return reference_time_;
|
||||
}
|
||||
|
||||
const uint8_t SrsRTCP_TWCC::get_feedback_count() const
|
||||
const uint8_t SrsRtcpTWCC::get_feedback_count() const
|
||||
{
|
||||
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_;
|
||||
}
|
||||
|
||||
const vector<uint16_t> SrsRTCP_TWCC::get_packet_chucks() const
|
||||
const vector<uint16_t> SrsRtcpTWCC::get_packet_chucks() const
|
||||
{
|
||||
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_;
|
||||
}
|
||||
|
||||
void SrsRTCP_TWCC::set_media_ssrc(uint32_t ssrc)
|
||||
void SrsRtcpTWCC::set_media_ssrc(uint32_t ssrc)
|
||||
{
|
||||
media_ssrc_ = ssrc;
|
||||
}
|
||||
void SrsRTCP_TWCC::set_base_sn(uint16_t sn)
|
||||
void SrsRtcpTWCC::set_base_sn(uint16_t 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;
|
||||
}
|
||||
|
||||
void SrsRTCP_TWCC::set_reference_time(uint32_t time)
|
||||
void SrsRtcpTWCC::set_reference_time(uint32_t 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;
|
||||
}
|
||||
|
||||
void SrsRTCP_TWCC::add_packet_chuck(uint16_t chunk)
|
||||
void SrsRtcpTWCC::add_packet_chuck(uint16_t 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);
|
||||
}
|
||||
|
||||
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);
|
||||
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;
|
||||
}
|
||||
|
||||
srs_error_t SrsRTCP_TWCC::decode(SrsBuffer *buffer)
|
||||
srs_error_t SrsRtcpTWCC::decode(SrsBuffer *buffer)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
int SrsRTCP_TWCC::nb_bytes()
|
||||
int SrsRtcpTWCC::nb_bytes()
|
||||
{
|
||||
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 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;
|
||||
}
|
||||
|
||||
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"
|
||||
" 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;
|
||||
}
|
||||
|
||||
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)
|
||||
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;
|
||||
}
|
||||
|
||||
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)
|
||||
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;
|
||||
}
|
||||
|
||||
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;
|
||||
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;
|
||||
}
|
||||
|
||||
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;
|
||||
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.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;
|
||||
// JANUS_LOG(LOG_INFO, "ccc->size %u shift %d A\n", ccc->size, shift);
|
||||
}
|
||||
|
||||
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;
|
||||
|
||||
|
|
@ -660,7 +658,7 @@ void SrsRTCP_TWCC::reset_chunk(SrsRTCP_TWCC::srs_rtcp_twcc_chunk_t& chunk)
|
|||
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;
|
||||
|
||||
|
|
@ -688,7 +686,7 @@ srs_error_t SrsRTCP_TWCC::encode_chunk(SrsRTCP_TWCC::srs_rtcp_twcc_chunk_t& chun
|
|||
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) {
|
||||
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);
|
||||
}
|
||||
|
||||
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;
|
||||
|
||||
|
|
@ -732,7 +730,7 @@ srs_error_t SrsRTCP_TWCC::process_pkt_chunk(SrsRTCP_TWCC::srs_rtcp_twcc_chunk_t&
|
|||
return err;
|
||||
}
|
||||
|
||||
srs_error_t SrsRTCP_TWCC::encode(SrsBuffer *buffer)
|
||||
srs_error_t SrsRtcpTWCC::encode(SrsBuffer *buffer)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
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());
|
||||
}
|
||||
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;
|
||||
map<uint16_t, srs_utime_t>::iterator it_ts = recv_packes_.find(base_sn_);
|
||||
srs_utime_t ts = it_ts->second;
|
||||
|
|
@ -750,7 +748,7 @@ srs_error_t SrsRTCP_TWCC::encode(SrsBuffer *buffer)
|
|||
packet_count_ = recv_packes_.size();
|
||||
do {
|
||||
// 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) {
|
||||
uint16_t current_sn = *it_sn;
|
||||
// calculate delta
|
||||
|
|
@ -836,43 +834,43 @@ srs_error_t SrsRTCP_TWCC::encode(SrsBuffer *buffer)
|
|||
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_.type = srs_rtcp_type_rtpfb;
|
||||
header_.type = SrsRtcpType_rtpfb;
|
||||
header_.rc = 1;
|
||||
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_;
|
||||
}
|
||||
|
||||
const vector<uint16_t> SrsRTCP_Nack::get_lost_sns() const
|
||||
const vector<uint16_t> SrsRtcpNack::get_lost_sns() const
|
||||
{
|
||||
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);
|
||||
}
|
||||
return sn;
|
||||
}
|
||||
|
||||
void SrsRTCP_Nack::set_media_ssrc(uint32_t ssrc)
|
||||
void SrsRtcpNack::set_media_ssrc(uint32_t 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);
|
||||
}
|
||||
|
||||
srs_error_t SrsRTCP_Nack::decode(SrsBuffer *buffer)
|
||||
srs_error_t SrsRtcpNack::decode(SrsBuffer *buffer)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
err = decode_header(buffer);
|
||||
|
|
@ -898,12 +896,12 @@ srs_error_t SrsRTCP_Nack::decode(SrsBuffer *buffer)
|
|||
|
||||
return err;
|
||||
}
|
||||
int SrsRTCP_Nack::nb_bytes()
|
||||
int SrsRtcpNack::nb_bytes()
|
||||
{
|
||||
return kRtcpPacketSize;
|
||||
}
|
||||
|
||||
srs_error_t SrsRTCP_Nack::encode(SrsBuffer *buffer)
|
||||
srs_error_t SrsRtcpNack::encode(SrsBuffer *buffer)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
if(! buffer->require(nb_bytes())) {
|
||||
|
|
@ -916,7 +914,7 @@ srs_error_t SrsRTCP_Nack::encode(SrsBuffer *buffer)
|
|||
pid_blp_t chunk;
|
||||
chunk.in_use = false;
|
||||
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;
|
||||
if(!chunk.in_use) {
|
||||
chunk.pid = sn;
|
||||
|
|
@ -957,27 +955,27 @@ srs_error_t SrsRTCP_Nack::encode(SrsBuffer *buffer)
|
|||
return err;
|
||||
}
|
||||
|
||||
SrsRTCPCompound::SrsRTCPCompound(): nb_bytes_(0)
|
||||
SrsRtcpCompound::SrsRtcpCompound(): nb_bytes_(0)
|
||||
{
|
||||
}
|
||||
|
||||
SrsRTCPCompound::~SrsRTCPCompound()
|
||||
SrsRtcpCompound::~SrsRtcpCompound()
|
||||
{
|
||||
clear();
|
||||
}
|
||||
|
||||
SrsRTCPCommon* SrsRTCPCompound::get_next_rtcp()
|
||||
SrsRtcpCommon* SrsRtcpCompound::get_next_rtcp()
|
||||
{
|
||||
if(rtcps_.empty()) {
|
||||
return NULL;
|
||||
}
|
||||
SrsRTCPCommon *rtcp = rtcps_.back();
|
||||
SrsRtcpCommon *rtcp = rtcps_.back();
|
||||
nb_bytes_ -= rtcp->nb_bytes();
|
||||
rtcps_.pop_back();
|
||||
return rtcp;
|
||||
}
|
||||
|
||||
srs_error_t SrsRTCPCompound::add_rtcp(SrsRTCPCommon *rtcp)
|
||||
srs_error_t SrsRtcpCompound::add_rtcp(SrsRtcpCommon *rtcp)
|
||||
{
|
||||
int new_len = rtcp->nb_bytes();
|
||||
if((new_len + nb_bytes_) > kRtcpPacketSize) {
|
||||
|
|
@ -989,17 +987,17 @@ srs_error_t SrsRTCPCompound::add_rtcp(SrsRTCPCommon *rtcp)
|
|||
return srs_success;
|
||||
}
|
||||
|
||||
srs_error_t SrsRTCPCompound::decode(SrsBuffer *buffer)
|
||||
srs_error_t SrsRtcpCompound::decode(SrsBuffer *buffer)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
while(0 != buffer->left()) {
|
||||
srs_rtcp_header_t* header = (srs_rtcp_header_t *)(buffer->head());
|
||||
SrsRtcpHeader* header = (SrsRtcpHeader *)(buffer->head());
|
||||
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);
|
||||
if(srs_success != err) {
|
||||
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);
|
||||
break;
|
||||
}
|
||||
case srs_rtcp_type_rr:
|
||||
case SrsRtcpType_rr:
|
||||
{
|
||||
SrsRTCP_RR *rtcp = new SrsRTCP_RR;
|
||||
SrsRtcpRR *rtcp = new SrsRtcpRR;
|
||||
err = rtcp->decode(buffer);
|
||||
if(srs_success != err) {
|
||||
return srs_error_wrap(err, "fail to decode rtcp rr");
|
||||
|
|
@ -1021,7 +1019,7 @@ srs_error_t SrsRTCPCompound::decode(SrsBuffer *buffer)
|
|||
}
|
||||
default:
|
||||
{
|
||||
SrsRTCPCommon *rtcp = new SrsRTCPCommon;
|
||||
SrsRtcpCommon *rtcp = new SrsRtcpCommon;
|
||||
err = rtcp->decode(buffer);
|
||||
if(srs_success != err) {
|
||||
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;
|
||||
}
|
||||
|
||||
int SrsRTCPCompound::nb_bytes()
|
||||
int SrsRtcpCompound::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;
|
||||
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_);
|
||||
}
|
||||
|
||||
vector<SrsRTCPCommon*>::iterator it;
|
||||
vector<SrsRtcpCommon*>::iterator it;
|
||||
for(it = rtcps_.begin(); it != rtcps_.end(); ++it) {
|
||||
SrsRTCPCommon *rtcp = *it;
|
||||
SrsRtcpCommon *rtcp = *it;
|
||||
err = rtcp->encode(buffer);
|
||||
if(err != srs_success) {
|
||||
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;
|
||||
}
|
||||
|
||||
void SrsRTCPCompound::clear()
|
||||
void SrsRtcpCompound::clear()
|
||||
{
|
||||
vector<SrsRTCPCommon*>::iterator it;
|
||||
vector<SrsRtcpCommon*>::iterator it;
|
||||
for(it = rtcps_.begin(); it != rtcps_.end(); ++it) {
|
||||
SrsRTCPCommon *rtcp = *it;
|
||||
SrsRtcpCommon *rtcp = *it;
|
||||
delete rtcp;
|
||||
rtcp = NULL;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -35,22 +35,22 @@
|
|||
const int kRtcpPacketSize = 1500;
|
||||
const uint8_t kRtcpVersion = 0x2;
|
||||
|
||||
/*! \brief RTCP Packet Types (http://www.networksorcery.com/enp/protocol/rtcp.htm) */
|
||||
typedef enum {
|
||||
srs_rtcp_type_fir = 192,
|
||||
srs_rtcp_type_sr = 200,
|
||||
srs_rtcp_type_rr = 201,
|
||||
srs_rtcp_type_sdes = 202,
|
||||
srs_rtcp_type_bye = 203,
|
||||
srs_rtcp_type_app = 204,
|
||||
srs_rtcp_type_rtpfb = 205,
|
||||
srs_rtcp_type_psfb = 206,
|
||||
srs_rtcp_type_xr = 207,
|
||||
} srs_rtcp_type;
|
||||
// RTCP Packet Types, @see http://www.networksorcery.com/enp/protocol/rtcp.htm
|
||||
enum SrsRtcpType {
|
||||
SrsRtcpType_fir = 192,
|
||||
SrsRtcpType_sr = 200,
|
||||
SrsRtcpType_rr = 201,
|
||||
SrsRtcpType_sdes = 202,
|
||||
SrsRtcpType_bye = 203,
|
||||
SrsRtcpType_app = 204,
|
||||
SrsRtcpType_rtpfb = 205,
|
||||
SrsRtcpType_psfb = 206,
|
||||
SrsRtcpType_xr = 207,
|
||||
};
|
||||
|
||||
|
||||
/*! \brief RTCP Header (http://tools.ietf.org/html/rfc3550#section-6.1) */
|
||||
typedef struct srs_rtcp_header_s
|
||||
// RTCP Header, @see http://tools.ietf.org/html/rfc3550#section-6.1
|
||||
struct SrsRtcpHeader
|
||||
{
|
||||
uint16_t rc:5;
|
||||
uint16_t padding:1;
|
||||
|
|
@ -58,18 +58,18 @@ typedef struct srs_rtcp_header_s
|
|||
uint16_t type:8;
|
||||
|
||||
uint16_t length:16;
|
||||
} srs_rtcp_header_t;
|
||||
};
|
||||
|
||||
struct less_compare {
|
||||
struct SrsSeqCompareLess {
|
||||
bool operator()(const uint16_t &lhs, const uint16_t &rhs) const {
|
||||
return SnCompare(rhs, lhs);
|
||||
}
|
||||
};
|
||||
|
||||
class SrsRTCPCommon: public ISrsCodec
|
||||
class SrsRtcpCommon: public ISrsCodec
|
||||
{
|
||||
protected:
|
||||
srs_rtcp_header_t header_;
|
||||
SrsRtcpHeader header_;
|
||||
uint8_t payload_[kRtcpPacketSize];
|
||||
int payload_len_;
|
||||
|
||||
|
|
@ -77,8 +77,8 @@ protected:
|
|||
srs_error_t decode_header(SrsBuffer *buffer);
|
||||
srs_error_t encode_header(SrsBuffer *buffer);
|
||||
public:
|
||||
SrsRTCPCommon();
|
||||
virtual ~SrsRTCPCommon();
|
||||
SrsRtcpCommon();
|
||||
virtual ~SrsRtcpCommon();
|
||||
virtual const uint8_t type() const { return header_.type; }
|
||||
|
||||
public:
|
||||
|
|
@ -88,18 +88,18 @@ public:
|
|||
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_;
|
||||
uint8_t name_[4];
|
||||
uint8_t payload_[kRtcpPacketSize];
|
||||
int payload_len_;
|
||||
public:
|
||||
SrsRTCP_App();
|
||||
virtual ~SrsRTCP_App();
|
||||
SrsRtcpApp();
|
||||
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 uint8_t get_subtype() const;
|
||||
|
|
@ -117,7 +117,7 @@ public:
|
|||
virtual srs_error_t encode(SrsBuffer *buffer);
|
||||
};
|
||||
|
||||
typedef struct srs_rtcp_report_block_s {
|
||||
struct srs_rtcp_rb_t {
|
||||
uint32_t ssrc;
|
||||
uint8_t fraction_lost;
|
||||
uint32_t lost_packets;
|
||||
|
|
@ -125,9 +125,9 @@ typedef struct srs_rtcp_report_block_s {
|
|||
uint32_t jitter;
|
||||
uint32_t lsr;
|
||||
uint32_t dlsr;
|
||||
}srs_rtcp_rb_t;
|
||||
};
|
||||
|
||||
class SrsRTCP_SR : public SrsRTCPCommon
|
||||
class SrsRtcpSR : public SrsRtcpCommon
|
||||
{
|
||||
private:
|
||||
uint32_t sender_ssrc_;
|
||||
|
|
@ -136,12 +136,12 @@ private:
|
|||
uint32_t send_rtp_packets_;
|
||||
uint32_t send_rtp_bytes_;
|
||||
public:
|
||||
SrsRTCP_SR();
|
||||
virtual ~SrsRTCP_SR();
|
||||
SrsRtcpSR();
|
||||
virtual ~SrsRtcpSR();
|
||||
|
||||
const uint8_t get_rc() const { return header_.rc; }
|
||||
// overload SrsRTCPCommon
|
||||
virtual const uint8_t type() const { return srs_rtcp_type_sr; }
|
||||
// overload SrsRtcpCommon
|
||||
virtual const uint8_t type() const { return SrsRtcpType_sr; }
|
||||
const uint32_t get_sender_ssrc() const;
|
||||
const uint64_t get_ntp() const;
|
||||
const uint32_t get_rtp_ts() const;
|
||||
|
|
@ -161,17 +161,17 @@ public:
|
|||
virtual srs_error_t encode(SrsBuffer *buffer);
|
||||
};
|
||||
|
||||
class SrsRTCP_RR : public SrsRTCPCommon
|
||||
class SrsRtcpRR : public SrsRtcpCommon
|
||||
{
|
||||
private:
|
||||
uint32_t sender_ssrc_;
|
||||
srs_rtcp_rb_t rb_;
|
||||
public:
|
||||
SrsRTCP_RR(uint32_t sender_ssrc = 0);
|
||||
virtual ~SrsRTCP_RR();
|
||||
SrsRtcpRR(uint32_t sender_ssrc = 0);
|
||||
virtual ~SrsRtcpRR();
|
||||
|
||||
// overload SrsRTCPCommon
|
||||
virtual const uint8_t type() const { return srs_rtcp_type_rr; }
|
||||
// overload SrsRtcpCommon
|
||||
virtual const uint8_t type() const { return SrsRtcpType_rr; }
|
||||
|
||||
const uint32_t get_rb_ssrc() const;
|
||||
const float get_lost_rate() const;
|
||||
|
|
@ -237,7 +237,7 @@ public:
|
|||
#define kTwccFbLargeRecvDeltaBytes 2
|
||||
#define kTwccFbMaxBitElements kTwccFbOneBitElements
|
||||
|
||||
class SrsRTCP_TWCC : public SrsRTCPCommon
|
||||
class SrsRtcpTWCC : public SrsRtcpCommon
|
||||
{
|
||||
private:
|
||||
uint32_t sender_ssrc_;
|
||||
|
|
@ -250,7 +250,7 @@ private:
|
|||
std::vector<uint16_t> pkt_deltas_;
|
||||
|
||||
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 {
|
||||
uint8_t delta_sizes[kTwccFbMaxBitElements];
|
||||
|
|
@ -275,8 +275,8 @@ private:
|
|||
srs_error_t encode_remaining_chunk(srs_rtcp_twcc_chunk_t& chunk);
|
||||
|
||||
public:
|
||||
SrsRTCP_TWCC(uint32_t sender_ssrc = 0);
|
||||
virtual ~SrsRTCP_TWCC();
|
||||
SrsRtcpTWCC(uint32_t sender_ssrc = 0);
|
||||
virtual ~SrsRtcpTWCC();
|
||||
|
||||
const uint32_t get_media_ssrc() const;
|
||||
const uint16_t get_base_sn() const;
|
||||
|
|
@ -304,7 +304,7 @@ public:
|
|||
|
||||
};
|
||||
|
||||
class SrsRTCP_Nack : public SrsRTCPCommon
|
||||
class SrsRtcpNack : public SrsRtcpCommon
|
||||
{
|
||||
private:
|
||||
typedef struct pid_blp_s {
|
||||
|
|
@ -315,10 +315,10 @@ private:
|
|||
|
||||
uint32_t sender_ssrc_;
|
||||
uint32_t media_ssrc_;
|
||||
std::set<uint16_t, less_compare> lost_sns_;
|
||||
std::set<uint16_t, SrsSeqCompareLess> lost_sns_;
|
||||
public:
|
||||
SrsRTCP_Nack(uint32_t sender_ssrc = 0);
|
||||
virtual ~SrsRTCP_Nack();
|
||||
SrsRtcpNack(uint32_t sender_ssrc = 0);
|
||||
virtual ~SrsRtcpNack();
|
||||
|
||||
const uint32_t get_media_ssrc() const;
|
||||
const std::vector<uint16_t> get_lost_sns() const;
|
||||
|
|
@ -334,17 +334,17 @@ public:
|
|||
};
|
||||
|
||||
|
||||
class SrsRTCPCompound : public ISrsCodec
|
||||
class SrsRtcpCompound : public ISrsCodec
|
||||
{
|
||||
private:
|
||||
std::vector<SrsRTCPCommon* > rtcps_;
|
||||
std::vector<SrsRtcpCommon*> rtcps_;
|
||||
int nb_bytes_;
|
||||
public:
|
||||
SrsRTCPCompound();
|
||||
virtual ~SrsRTCPCompound();
|
||||
SrsRtcpCompound();
|
||||
virtual ~SrsRtcpCompound();
|
||||
|
||||
SrsRTCPCommon* get_next_rtcp();
|
||||
srs_error_t add_rtcp(SrsRTCPCommon *rtcp);
|
||||
SrsRtcpCommon* get_next_rtcp();
|
||||
srs_error_t add_rtcp(SrsRtcpCommon *rtcp);
|
||||
void clear();
|
||||
|
||||
public:
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue