qiurui
/
uvgrtp-base
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

common: Add const qualifiers where applicable

This commit is contained in:
Joni Räsänen 2022-05-16 12:02:37 +03:00
parent a6f9afcd28
commit 088fc585ed
14 changed files with 82 additions and 95 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
include/uvgrtp/context.hh
View File

@ -80,7 +80,7 @@ namespace uvgrtp {
private:
/* Generate CNAME for participant using host and login names */
std::string generate_cname();
std::string generate_cname() const;
/* CNAME is the same for all connections */
std::string cname_;

36
include/uvgrtp/crypto.hh
View File

@ -52,10 +52,10 @@ namespace uvgrtp {
namespace hmac {
class sha1 {
public:
sha1(uint8_t *key, size_t key_size);
sha1(const uint8_t *key, size_t key_size);
~sha1();
void update(uint8_t *data, size_t len);
void update(const uint8_t *data, size_t len);
void final(uint8_t *digest);
/* truncate digest to "size" bytes */
@ -69,10 +69,10 @@ namespace uvgrtp {
class sha256 {
public:
sha256(uint8_t *key, size_t key_size);
sha256(const uint8_t *key, size_t key_size);
~sha256();
void update(uint8_t *data, size_t len);
void update(const uint8_t *data, size_t len);
void final(uint8_t *digest);
private:
@ -87,7 +87,7 @@ namespace uvgrtp {
sha256();
~sha256();
void update(uint8_t *data, size_t len);
void update(const uint8_t *data, size_t len);
void final(uint8_t *digest);
private:
@ -100,11 +100,11 @@ namespace uvgrtp {
class ecb {
public:
ecb(uint8_t *key, size_t key_size);
ecb(const uint8_t *key, size_t key_size);
~ecb();
void encrypt(uint8_t *output, uint8_t *input, size_t len);
void decrypt(uint8_t *output, uint8_t *input, size_t len);
void encrypt(uint8_t *output, const uint8_t *input, size_t len);
void decrypt(uint8_t *output, const uint8_t *input, size_t len);
private:
#ifdef __RTP_CRYPTO__
@ -115,11 +115,11 @@ namespace uvgrtp {
class cfb {
public:
cfb(uint8_t *key, size_t key_size, uint8_t *iv);
cfb(const uint8_t *key, size_t key_size, const uint8_t *iv);
~cfb();
void encrypt(uint8_t *output, uint8_t *input, size_t len);
void decrypt(uint8_t *output, uint8_t *input, size_t len);
void encrypt(uint8_t *output, const uint8_t *input, size_t len);
void decrypt(uint8_t *output, const uint8_t *input, size_t len);
private:
#ifdef __RTP_CRYPTO__
@ -130,11 +130,11 @@ namespace uvgrtp {
class ctr {
public:
ctr(uint8_t *key, size_t key_size, uint8_t *iv);
ctr(const uint8_t *key, size_t key_size, const uint8_t *iv);
~ctr();
void encrypt(uint8_t *output, uint8_t *input, size_t len);
void decrypt(uint8_t *output, uint8_t *input, size_t len);
void encrypt(uint8_t *output, const uint8_t *input, size_t len);
void decrypt(uint8_t *output, const uint8_t *input, size_t len);
private:
#ifdef __RTP_CRYPTO__
@ -176,7 +176,7 @@ namespace uvgrtp {
b32();
~b32();
void encode(uint8_t *input, uint8_t *output, size_t len);
void encode(const uint8_t *input, uint8_t *output, size_t len);
private:
#ifdef __RTP_CRYPTO__
@ -189,9 +189,9 @@ namespace uvgrtp {
}
namespace crc32 {
void get_crc32(uint8_t *input, size_t len, uint32_t *output);
bool verify_crc32(uint8_t *input, size_t len, uint32_t old_crc);
uint32_t calculate_crc32(uint8_t *input, size_t len);
void get_crc32(const uint8_t *input, size_t len, uint32_t *output);
bool verify_crc32(const uint8_t *input, size_t len, uint32_t old_crc);
uint32_t calculate_crc32(const uint8_t *input, size_t len);
}
bool enabled();

2
include/uvgrtp/media_stream.hh
View File

@ -279,7 +279,7 @@ namespace uvgrtp {
/* Get unique key of the media stream
* Used by session to index media streams */
uint32_t get_key();
uint32_t get_key() const;
/// \endcond
/**

51
include/uvgrtp/rtcp.hh
View File

@ -119,7 +119,7 @@ namespace uvgrtp {
* \retval RTP_MEMORY_ERROR If allocation fails
* \retval RTP_GENERIC_ERROR If sending fails
*/
rtp_error_t send_sdes_packet(std::vector<uvgrtp::frame::rtcp_sdes_item>& items);
rtp_error_t send_sdes_packet(const std::vector<uvgrtp::frame::rtcp_sdes_item>& items);
/**
* \brief Send an RTCP APP packet
@ -133,7 +133,7 @@ namespace uvgrtp {
* \retval RTP_MEMORY_ERROR If allocation fails
* \retval RTP_GENERIC_ERROR If sending fails
*/
rtp_error_t send_app_packet(char *name, uint8_t subtype, size_t payload_len, uint8_t *payload);
rtp_error_t send_app_packet(const char *name, uint8_t subtype, size_t payload_len, const uint8_t *payload);
/**
* \brief Send an RTCP BYE packet
@ -175,22 +175,7 @@ namespace uvgrtp {
rtp_error_t add_participant(std::string dst_addr, uint16_t dst_port, uint16_t src_port, uint32_t clock_rate);
/* Functions for updating various RTP sender statistics */
void sender_inc_seq_cycle_count();
void sender_inc_sent_pkts(size_t n);
void sender_inc_sent_bytes(size_t n);
void sender_update_stats(uvgrtp::frame::rtp_frame *frame);
void receiver_inc_sent_bytes(uint32_t sender_ssrc, size_t n);
void receiver_inc_overhead_bytes(uint32_t sender_ssrc, size_t n);
void receiver_inc_total_bytes(uint32_t sender_ssrc, size_t n);
void receiver_inc_sent_pkts(uint32_t sender_ssrc, size_t n);
/* Update the RTCP statistics regarding this packet
*
* Return RTP_OK if packet is valid
* Return RTP_INVALID_VALUE if SSRCs of remotes have collided or the packet is invalid in some way
* return RTP_SSRC_COLLISION if our own SSRC has collided and we need to reinitialize it */
rtp_error_t receiver_update_stats(uvgrtp::frame::rtp_frame *frame);
void sender_update_stats(const uvgrtp::frame::rtp_frame *frame);
/* If we've detected that our SSRC has collided with someone else's SSRC, we need to
* generate new random SSRC and reinitialize our own RTCP state.
@ -202,10 +187,10 @@ namespace uvgrtp {
rtp_error_t reset_rtcp_state(uint32_t ssrc);
/* Update various session statistics */
void update_session_statistics(uvgrtp::frame::rtp_frame *frame);
void update_session_statistics(const uvgrtp::frame::rtp_frame *frame);
/* Return SSRCs of all participants */
std::vector<uint32_t> get_participants();
std::vector<uint32_t> get_participants() const;
/// \endcond
/**
@ -318,7 +303,7 @@ namespace uvgrtp {
/* when we start the RTCP instance, we don't know what the SSRC of the remote is
* when an RTP packet is received, we must check if we've already received a packet
* from this sender and if not, create new entry to receiver_stats_ map */
bool is_participant(uint32_t ssrc);
bool is_participant(uint32_t ssrc) const;
/* When we receive an RTP or RTCP packet, we need to check the source address and see if it's
* the same address where we've received packets before.
@ -326,14 +311,14 @@ namespace uvgrtp {
* If the address is new, it means we have detected an SSRC collision and the paket should
* be dropped We also need to check whether this SSRC matches with our own SSRC and if it does
* we need to send RTCP BYE and rejoin to the session */
bool collision_detected(uint32_t ssrc, sockaddr_in& src_addr);
bool collision_detected(uint32_t ssrc, const sockaddr_in& src_addr) const;
/* Move participant from initial_peers_ to participants_ */
rtp_error_t add_participant(uint32_t ssrc);
/* We've got a message from new source (the SSRC of the frame is not known to us)
* Initialize statistics for the peer and move it to participants_ */
rtp_error_t init_new_participant(uvgrtp::frame::rtp_frame *frame);
rtp_error_t init_new_participant(const uvgrtp::frame::rtp_frame *frame);
/* Initialize the RTP Sequence related stuff of peer
* This function assumes that the peer already exists in the participants_ map */
@ -364,8 +349,8 @@ namespace uvgrtp {
uint16_t secondField, uvgrtp::frame::RTCP_FRAME_TYPE frame_type, bool addLocalSSRC);
/* read the header values from rtcp packet */
void read_rtcp_header(uint8_t* packet, uvgrtp::frame::rtcp_header& header);
void read_reports(uint8_t* packet, size_t size, uint8_t count, bool has_sender_block,
void read_rtcp_header(const uint8_t* packet, uvgrtp::frame::rtcp_header& header);
void read_reports(const uint8_t* packet, size_t size, uint8_t count, bool has_sender_block,
std::vector<uvgrtp::frame::rtcp_report_block>& reports);
/* Takes ownership of the frame */
@ -374,20 +359,17 @@ namespace uvgrtp {
void free_participant(rtcp_participant* participant);
/* Pointer to RTP context from which clock rate etc. info is collected and which is
* used to change SSRC if a collision is detected */
std::shared_ptr<uvgrtp::rtp> rtp_;
/* Secure RTCP context */
std::shared_ptr<uvgrtp::srtcp> srtcp_;
/* RTP context flags */
int flags_;
/* are we a sender or a receiver */
/* are we a sender (and possible a receiver) or just a receiver */
int our_role_;
/* TODO: time_t?? */
// TODO: Check these, they don't seem to be used
size_t tp_; /* the last time an RTCP packet was transmitted */
size_t tc_; /* the current time */
size_t tn_; /* the next scheduled transmission time of an RTCP packet */
@ -399,19 +381,23 @@ namespace uvgrtp {
* that will be used for RTCP packets by all members of this session,
* in octets per second. This will be a specified fraction of the
* "session bandwidth" parameter supplied to the application at startup. */
// TODO: Not used anywhere at the moment
size_t rtcp_bandwidth_;
/* Flag that is true if the application has sent data since
* the 2nd previous RTCP report was transmitted. */
// TODO: Only set, never read
bool we_sent_;
/* The average compound RTCP packet size, in octets,
* over all RTCP packets sent and received by this participant. The
* size includes lower-layer transport and network protocol headers
* (e.g., UDP and IP) as explained in Section 6.2 */
// TODO: Only set, never read
size_t avg_rtcp_pkt_pize_;
/* Number of RTCP packets and bytes sent and received by this participant */
// TODO: Only set, never read
size_t rtcp_pkt_count_;
size_t rtcp_byte_count_;
@ -419,10 +405,11 @@ namespace uvgrtp {
uint32_t rtcp_pkt_sent_count_;
/* Flag that is true if the application has not yet sent an RTCP packet. */
// TODO: Only set, never read
bool initial_;
/* Copy of our own current SSRC */
uint32_t ssrc_;
const uint32_t ssrc_;
/* NTP timestamp associated with initial RTP timestamp (aka t = 0) */
uint64_t clock_start_;
@ -434,7 +421,7 @@ namespace uvgrtp {
uint32_t rtp_ts_start_;
std::map<uint32_t, rtcp_participant *> participants_;
uint8_t num_receivers_; // maximum is 32 (5 bits)
uint8_t num_receivers_; // maximum is 32 at the moment (5 bits)
/* statistics for RTCP Sender and Receiver Reports */
struct sender_statistics our_stats;

2
src/context.cc
View File

@ -64,7 +64,7 @@ rtp_error_t uvgrtp::context::destroy_session(uvgrtp::session *session)
return RTP_OK;
}
std::string uvgrtp::context::generate_cname()
std::string uvgrtp::context::generate_cname() const
{
std::string host = uvgrtp::hostname::get_hostname();
std::string user = uvgrtp::hostname::get_username();

36
src/crypto.cc
View File

@ -7,7 +7,7 @@
/* ***************** hmac-sha1 ***************** */
uvgrtp::crypto::hmac::sha1::sha1(uint8_t *key, size_t key_size)
uvgrtp::crypto::hmac::sha1::sha1(const uint8_t *key, size_t key_size)
#ifdef __RTP_CRYPTO__
:hmac_(key, key_size)
#endif
@ -21,7 +21,7 @@ uvgrtp::crypto::hmac::sha1::~sha1()
{
}
void uvgrtp::crypto::hmac::sha1::update(uint8_t *data, size_t len)
void uvgrtp::crypto::hmac::sha1::update(const uint8_t *data, size_t len)
{
#ifdef __RTP_CRYPTO__
hmac_.Update(data, len);
@ -62,7 +62,7 @@ void uvgrtp::crypto::hmac::sha1::final(uint8_t *digest, size_t size)
/* ***************** hmac-sha256 ***************** */
uvgrtp::crypto::hmac::sha256::sha256(uint8_t *key, size_t key_size)
uvgrtp::crypto::hmac::sha256::sha256(const uint8_t *key, size_t key_size)
#ifdef __RTP_CRYPTO__
:hmac_(key, key_size)
#endif
@ -76,7 +76,7 @@ uvgrtp::crypto::hmac::sha256::~sha256()
{
}
void uvgrtp::crypto::hmac::sha256::update(uint8_t *data, size_t len)
void uvgrtp::crypto::hmac::sha256::update(const uint8_t *data, size_t len)
{
#ifdef __RTP_CRYPTO__
hmac_.Update(data, len);
@ -113,7 +113,7 @@ uvgrtp::crypto::sha256::~sha256()
{
}
void uvgrtp::crypto::sha256::update(uint8_t *data, size_t len)
void uvgrtp::crypto::sha256::update(const uint8_t *data, size_t len)
{
#ifdef __RTP_CRYPTO__
sha_.Update(data, len);
@ -139,7 +139,7 @@ void uvgrtp::crypto::sha256::final(uint8_t *digest)
/* ***************** aes-128 ***************** */
uvgrtp::crypto::aes::ctr::ctr(uint8_t *key, size_t key_size, uint8_t *iv)
uvgrtp::crypto::aes::ctr::ctr(const uint8_t *key, size_t key_size, const uint8_t *iv)
#ifdef __RTP_CRYPTO__
:enc_(key, key_size, iv),
dec_(key, key_size, iv)
@ -154,7 +154,7 @@ uvgrtp::crypto::aes::ctr::~ctr()
{
}
void uvgrtp::crypto::aes::ctr::encrypt(uint8_t *output, uint8_t *input, size_t len)
void uvgrtp::crypto::aes::ctr::encrypt(uint8_t *output, const uint8_t *input, size_t len)
{
#ifdef __RTP_CRYPTO__
enc_.ProcessData(output, input, len);
@ -166,7 +166,7 @@ void uvgrtp::crypto::aes::ctr::encrypt(uint8_t *output, uint8_t *input, size_t l
#endif
}
void uvgrtp::crypto::aes::ctr::decrypt(uint8_t *output, uint8_t *input, size_t len)
void uvgrtp::crypto::aes::ctr::decrypt(uint8_t *output, const uint8_t *input, size_t len)
{
#ifdef __RTP_CRYPTO__
dec_.ProcessData(output, input, len);
@ -178,7 +178,7 @@ void uvgrtp::crypto::aes::ctr::decrypt(uint8_t *output, uint8_t *input, size_t l
#endif
}
uvgrtp::crypto::aes::cfb::cfb(uint8_t *key, size_t key_size, uint8_t *iv)
uvgrtp::crypto::aes::cfb::cfb(const uint8_t *key, size_t key_size, const uint8_t *iv)
#ifdef __RTP_CRYPTO__
:enc_(key, key_size, iv),
dec_(key, key_size, iv)
@ -193,7 +193,7 @@ uvgrtp::crypto::aes::cfb::~cfb()
{
}
void uvgrtp::crypto::aes::cfb::encrypt(uint8_t *output, uint8_t *input, size_t len)
void uvgrtp::crypto::aes::cfb::encrypt(uint8_t *output, const uint8_t *input, size_t len)
{
#ifdef __RTP_CRYPTO__
enc_.ProcessData(output, input, len);
@ -205,7 +205,7 @@ void uvgrtp::crypto::aes::cfb::encrypt(uint8_t *output, uint8_t *input, size_t l
#endif
}
void uvgrtp::crypto::aes::cfb::decrypt(uint8_t *output, uint8_t *input, size_t len)
void uvgrtp::crypto::aes::cfb::decrypt(uint8_t *output, const uint8_t *input, size_t len)
{
#ifdef __RTP_CRYPTO__
dec_.ProcessData(output, input, len);
@ -217,7 +217,7 @@ void uvgrtp::crypto::aes::cfb::decrypt(uint8_t *output, uint8_t *input, size_t l
#endif
}
uvgrtp::crypto::aes::ecb::ecb(uint8_t *key, size_t key_size)
uvgrtp::crypto::aes::ecb::ecb(const uint8_t *key, size_t key_size)
#ifdef __RTP_CRYPTO__
:enc_(key, key_size),
dec_(key, key_size)
@ -232,7 +232,7 @@ uvgrtp::crypto::aes::ecb::~ecb()
{
}
void uvgrtp::crypto::aes::ecb::encrypt(uint8_t *output, uint8_t *input, size_t len)
void uvgrtp::crypto::aes::ecb::encrypt(uint8_t *output, const uint8_t *input, size_t len)
{
#ifdef __RTP_CRYPTO__
enc_.ProcessData(output, input, len);
@ -244,7 +244,7 @@ void uvgrtp::crypto::aes::ecb::encrypt(uint8_t *output, uint8_t *input, size_t l
#endif
}
void uvgrtp::crypto::aes::ecb::decrypt(uint8_t *output, uint8_t *input, size_t len)
void uvgrtp::crypto::aes::ecb::decrypt(uint8_t *output, const uint8_t *input, size_t len)
{
#ifdef __RTP_CRYPTO__
dec_.ProcessData(output, input, len);
@ -382,7 +382,7 @@ uvgrtp::crypto::b32::~b32()
{
}
void uvgrtp::crypto::b32::encode(uint8_t *input, uint8_t *output, size_t len)
void uvgrtp::crypto::b32::encode(const uint8_t *input, uint8_t *output, size_t len)
{
#ifdef __RTP_CRYPTO__
enc_.Put(input, len);
@ -418,7 +418,7 @@ void uvgrtp::crypto::random::generate_random(uint8_t *out, size_t len)
/* ***************** crc32 ***************** */
void uvgrtp::crypto::crc32::get_crc32(uint8_t *input, size_t len, uint32_t *output)
void uvgrtp::crypto::crc32::get_crc32(const uint8_t *input, size_t len, uint32_t *output)
{
#ifdef __RTP_CRYPTO__
CryptoPP::CRC32 crc32;
@ -433,7 +433,7 @@ void uvgrtp::crypto::crc32::get_crc32(uint8_t *input, size_t len, uint32_t *outp
#endif
}
uint32_t uvgrtp::crypto::crc32::calculate_crc32(uint8_t *input, size_t len)
uint32_t uvgrtp::crypto::crc32::calculate_crc32(const uint8_t *input, size_t len)
{
#ifdef __RTP_CRYPTO__
CryptoPP::CRC32 crc32;
@ -451,7 +451,7 @@ uint32_t uvgrtp::crypto::crc32::calculate_crc32(uint8_t *input, size_t len)
#endif
}
bool uvgrtp::crypto::crc32::verify_crc32(uint8_t *input, size_t len, uint32_t old_crc)
bool uvgrtp::crypto::crc32::verify_crc32(const uint8_t *input, size_t len, uint32_t old_crc)
{
#ifdef __RTP_CRYPTO__
CryptoPP::CRC32 crc32;

2
src/media_stream.cc
View File

@ -574,7 +574,7 @@ rtp_error_t uvgrtp::media_stream::configure_ctx(int flag, ssize_t value)
return ret;
}
uint32_t uvgrtp::media_stream::get_key()
uint32_t uvgrtp::media_stream::get_key() const
{
return key_;
}

2
src/reception_flow.cc
View File

@ -75,7 +75,7 @@ void uvgrtp::reception_flow::destroy_ring_buffer()
ring_buffer_.clear();
}
void uvgrtp::reception_flow::set_buffer_size(ssize_t& value)
void uvgrtp::reception_flow::set_buffer_size(const ssize_t& value)
{
buffer_size_kbytes_ = value;
create_ring_buffer();

2
src/reception_flow.hh
View File

@ -145,7 +145,7 @@ namespace uvgrtp {
uvgrtp::frame::rtp_frame *pull_frame();
uvgrtp::frame::rtp_frame *pull_frame(size_t timeout_ms);
void set_buffer_size(ssize_t& value);
void set_buffer_size(const ssize_t& value);
private:
/* RTP packet receiver thread */

34
src/rtcp.cc
View File

@ -36,11 +36,12 @@ constexpr int ESTIMATED_MAX_RECEPTION_TIME_MS = 10;
const uint32_t MAX_SUPPORTED_PARTICIPANTS = 31;
uvgrtp::rtcp::rtcp(std::shared_ptr<uvgrtp::rtp> rtp, int flags):
rtp_(rtp), flags_(flags), our_role_(RECEIVER),
flags_(flags), our_role_(RECEIVER),
tp_(0), tc_(0), tn_(0), pmembers_(0),
members_(0), senders_(0), rtcp_bandwidth_(0),
we_sent_(0), avg_rtcp_pkt_pize_(0), rtcp_pkt_count_(0),
rtcp_pkt_sent_count_(0), initial_(true), num_receivers_(0),
we_sent_(false), avg_rtcp_pkt_pize_(0), rtcp_pkt_count_(0),
rtcp_pkt_sent_count_(0), initial_(true), ssrc_(rtp->get_ssrc()),
num_receivers_(0),
sender_hook_(nullptr),
receiver_hook_(nullptr),
sdes_hook_(nullptr),
@ -55,7 +56,6 @@ uvgrtp::rtcp::rtcp(std::shared_ptr<uvgrtp::rtp> rtp, int flags):
app_hook_u_(nullptr),
active_(false)
{
ssrc_ = rtp->get_ssrc();
clock_rate_ = rtp->get_clock_rate();
clock_start_ = 0;
@ -595,7 +595,7 @@ std::vector<uvgrtp::socket>& uvgrtp::rtcp::get_sockets()
return sockets_;
}
std::vector<uint32_t> uvgrtp::rtcp::get_participants()
std::vector<uint32_t> uvgrtp::rtcp::get_participants() const
{
std::vector<uint32_t> ssrcs;
@ -645,7 +645,7 @@ void uvgrtp::rtcp::zero_stats(uvgrtp::receiver_statistics *stats)
stats->cycles = 0;
}
bool uvgrtp::rtcp::is_participant(uint32_t ssrc)
bool uvgrtp::rtcp::is_participant(uint32_t ssrc) const
{
return participants_.find(ssrc) != participants_.end();
}
@ -657,7 +657,7 @@ void uvgrtp::rtcp::set_ts_info(uint64_t clock_start, uint32_t clock_rate, uint32
rtp_ts_start_ = rtp_ts_start;
}
void uvgrtp::rtcp::sender_update_stats(uvgrtp::frame::rtp_frame *frame)
void uvgrtp::rtcp::sender_update_stats(const uvgrtp::frame::rtp_frame *frame)
{
if (!frame)
{
@ -675,7 +675,7 @@ void uvgrtp::rtcp::sender_update_stats(uvgrtp::frame::rtp_frame *frame)
our_stats.sent_rtp_packet = true;
}
rtp_error_t uvgrtp::rtcp::init_new_participant(uvgrtp::frame::rtp_frame *frame)
rtp_error_t uvgrtp::rtcp::init_new_participant(const uvgrtp::frame::rtp_frame *frame)
{
rtp_error_t ret;
@ -809,14 +809,14 @@ rtp_error_t uvgrtp::rtcp::reset_rtcp_state(uint32_t ssrc)
return RTP_OK;
}
bool uvgrtp::rtcp::collision_detected(uint32_t ssrc, sockaddr_in& src_addr)
bool uvgrtp::rtcp::collision_detected(uint32_t ssrc, const sockaddr_in& src_addr) const
{
if (participants_.find(ssrc) == participants_.end())
{
return false;
}
auto sender = participants_[ssrc];
auto sender = participants_.at(ssrc);
if (src_addr.sin_port != sender->address.sin_port &&
src_addr.sin_addr.s_addr != sender->address.sin_addr.s_addr)
@ -827,7 +827,7 @@ bool uvgrtp::rtcp::collision_detected(uint32_t ssrc, sockaddr_in& src_addr)
return false;
}
void uvgrtp::rtcp::update_session_statistics(uvgrtp::frame::rtp_frame *frame)
void uvgrtp::rtcp::update_session_statistics(const uvgrtp::frame::rtp_frame *frame)
{
auto p = participants_[frame->header.ssrc];
@ -1137,7 +1137,7 @@ rtp_error_t uvgrtp::rtcp::handle_app_packet(uint8_t* packet, size_t size,
return RTP_OK;
}
rtp_error_t uvgrtp::rtcp::handle_receiver_report_packet(uint8_t* packet, size_t size,
rtp_error_t uvgrtp::rtcp::handle_receiver_report_packet(uint8_t* packet, size_t size,
uvgrtp::frame::rtcp_header& header)
{
if (!packet || !size)
@ -1286,7 +1286,7 @@ rtp_error_t uvgrtp::rtcp::construct_rtcp_header(size_t packet_size,
return RTP_OK;
}
void uvgrtp::rtcp::read_rtcp_header(uint8_t* packet, uvgrtp::frame::rtcp_header& header)
void uvgrtp::rtcp::read_rtcp_header(const uint8_t* packet, uvgrtp::frame::rtcp_header& header)
{
header.version = (packet[0] >> 6) & 0x3;
header.padding = (packet[0] >> 5) & 0x1;
@ -1303,7 +1303,7 @@ void uvgrtp::rtcp::read_rtcp_header(uint8_t* packet, uvgrtp::frame::rtcp_header&
header.length = ntohs(*(uint16_t*)&packet[2]);
}
void uvgrtp::rtcp::read_reports(uint8_t* packet, size_t size, uint8_t count, bool has_sender_block,
void uvgrtp::rtcp::read_reports(const uint8_t* packet, size_t size, uint8_t count, bool has_sender_block,
std::vector<uvgrtp::frame::rtcp_report_block>& reports)
{
uint32_t report_section = RTCP_HEADER_SIZE + SSRC_CSRC_SIZE;
@ -1463,7 +1463,7 @@ rtp_error_t uvgrtp::rtcp::generate_report()
return send_rtcp_packet_to_participants(frame, frame_size);
}
rtp_error_t uvgrtp::rtcp::send_sdes_packet(std::vector<uvgrtp::frame::rtcp_sdes_item>& items)
rtp_error_t uvgrtp::rtcp::send_sdes_packet(const std::vector<uvgrtp::frame::rtcp_sdes_item>& items)
{
if (items.empty())
{
@ -1540,8 +1540,8 @@ rtp_error_t uvgrtp::rtcp::send_bye_packet(std::vector<uint32_t> ssrcs)
return send_rtcp_packet_to_participants(frame, frame_size);
}
rtp_error_t uvgrtp::rtcp::send_app_packet(char* name, uint8_t subtype,
size_t payload_len, uint8_t* payload)
rtp_error_t uvgrtp::rtcp::send_app_packet(const char* name, uint8_t subtype,
size_t payload_len, const uint8_t* payload)
{
rtp_error_t ret = RTP_OK;
uint8_t* frame = nullptr;

2
src/srtp/base.cc
View File

@ -212,7 +212,7 @@ rtp_error_t uvgrtp::base_srtp::allocate_crypto_ctx(size_t key_size)
return RTP_OK;
}
size_t uvgrtp::base_srtp::get_key_size(int flags)
size_t uvgrtp::base_srtp::get_key_size(int flags) const
{
size_t key_size = AES128_KEY_SIZE;

2
src/srtp/base.hh
View File

@ -148,7 +148,7 @@ namespace uvgrtp {
* Returns false if replay protection has not been enabled */
bool is_replayed_packet(uint8_t *digest);
size_t get_key_size(int flags);
size_t get_key_size(int flags) const;
protected:

2
src/srtp/srtp.cc
View File

@ -151,7 +151,7 @@ authenticate:
return ret;
}
bool uvgrtp::srtp::authenticate_rtp()
bool uvgrtp::srtp::authenticate_rtp() const
{
return authenticate_rtp_;
}

2
src/srtp/srtp.hh
View File

@ -24,7 +24,7 @@ namespace uvgrtp {
rtp_error_t encrypt(uint32_t ssrc, uint16_t seq, uint8_t* buffer, size_t len);
/* Has RTP packet authentication been enabled? */
bool authenticate_rtp();
bool authenticate_rtp() const;
/* By default RTP packet authentication is disabled but by
* giving RCE_SRTP_AUTHENTICATE_RTP to create_stream() user can enable it.