From e20a1d2f3962522722522395d934947b44bcd254 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=BF=98=E7=AF=B1?= Date: Fri, 15 May 2020 12:03:43 +0800 Subject: [PATCH] RTC: Rename RTCP_XXX to RtcpXXX --- trunk/src/kernel/srs_kernel_rtc_rtcp.cpp | 258 +++++++++++------------ trunk/src/kernel/srs_kernel_rtc_rtcp.hpp | 102 ++++----- 2 files changed, 179 insertions(+), 181 deletions(-) diff --git a/trunk/src/kernel/srs_kernel_rtc_rtcp.cpp b/trunk/src/kernel/srs_kernel_rtc_rtcp.cpp index 10e08ad79..697b74f15 100644 --- a/trunk/src/kernel/srs_kernel_rtc_rtcp.cpp +++ b/trunk/src/kernel/srs_kernel_rtc_rtcp.cpp @@ -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 SrsRTCP_TWCC::get_packet_chucks() const +const vector SrsRtcpTWCC::get_packet_chucks() const { return encoded_chucks_; } -const vector SrsRTCP_TWCC::get_recv_deltas() const +const vector 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::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::iterator it_sn = recv_sns_.begin(); + set::iterator it_sn = recv_sns_.begin(); base_sn_ = *it_sn; map::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 SrsRTCP_Nack::get_lost_sns() const +const vector SrsRtcpNack::get_lost_sns() const { vector sn; - for(set::iterator it = lost_sns_.begin(); it != lost_sns_.end(); ++it) { + for(set::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::iterator it = lost_sns_.begin(); it != lost_sns_.end(); ++it) { + for(set::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::iterator it; + vector::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::iterator it; + vector::iterator it; for(it = rtcps_.begin(); it != rtcps_.end(); ++it) { - SrsRTCPCommon *rtcp = *it; + SrsRtcpCommon *rtcp = *it; delete rtcp; rtcp = NULL; } diff --git a/trunk/src/kernel/srs_kernel_rtc_rtcp.hpp b/trunk/src/kernel/srs_kernel_rtc_rtcp.hpp index 297d4ee00..8192d1894 100644 --- a/trunk/src/kernel/srs_kernel_rtc_rtcp.hpp +++ b/trunk/src/kernel/srs_kernel_rtc_rtcp.hpp @@ -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 pkt_deltas_; std::map recv_packes_; - std::set recv_sns_; + std::set 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 lost_sns_; + std::set 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 get_lost_sns() const; @@ -334,17 +334,17 @@ public: }; -class SrsRTCPCompound : public ISrsCodec +class SrsRtcpCompound : public ISrsCodec { private: - std::vector rtcps_; + std::vector 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: