rtcp.hh

#pragma once
 
#include "uvgrtp/export.hh"
#include "uvgrtp/definitions.hh"
 
#include "clock.hh"
#include "util.hh"
#include "frame.hh"
 
#ifdef _WIN32
#include <ws2ipdef.h>
#else
#include <sys/socket.h>
#include <netinet/in.h>
#endif
 
#include <bitset>
#include <map>
#include <thread>
#include <vector>
#include <functional>
#include <memory>
#include <mutex>
#include <deque>
#include <atomic>
 
namespace uvgrtp {
 
    class socketfactory;
    class rtp;
    class srtcp;
    class rtcp_internal;
 
    class UVGRTP_EXPORT rtcp {
        friend class media_stream_internal;
        public:
            ~rtcp();
 
            // the Core api suitable for shared and static library use
 
            void set_ts_info(uint64_t clock_start, uint32_t clock_rate, uint32_t rtp_ts_start);
 
            rtp_error_t add_sdes_item(const uvgrtp::frame::rtcp_sdes_item& item);
 
            rtp_error_t clear_sdes_items();
 
            rtp_error_t send_app_packet(const char* name, uint8_t subtype, uint32_t payload_len, const uint8_t* payload);
 
            rtp_error_t install_send_app_hook(
                const char* app_name,
                uint8_t* (*send_hook)(uint8_t* subtype, uint32_t* payload_len, void* user_arg),
                void* user_arg
            );
 
            rtp_error_t remove_send_app_hook(const char* app_name);
 
            rtp_error_t send_bye_packet(const uint32_t* ssrcs, size_t count);
 
            rtp_error_t install_sender_hook(void (*handler)(uvgrtp::frame::rtcp_sr*));
 
            rtp_error_t install_receiver_hook(void (*handler)(uvgrtp::frame::rtcp_rr*));
 
            rtp_error_t install_sdes_hook(void (*handler)(uvgrtp::frame::rtcp_sdes*));
 
            rtp_error_t install_app_hook(void (*handler)(uvgrtp::frame::rtcp_app_packet*));
 
            rtp_error_t remove_all_hooks();
 
            uvgrtp::frame::rtcp_sr* get_sr(uint32_t ssrc);
 
            uvgrtp::frame::rtcp_rr* get_rr(uint32_t ssrc);
 
            uvgrtp::frame::rtcp_sdes* get_sdes(uint32_t ssrc);
 
            uvgrtp::frame::rtcp_app_packet* get_app_packet(uint32_t ssrc);
 
 
  // End of CORE_API group
 
#if UVGRTP_EXTENDED_API
 
            rtp_error_t send_sdes_packet(const std::vector<uvgrtp::frame::rtcp_sdes_item>& items);
 
            rtp_error_t send_bye_packet(const std::vector<uint32_t>& ssrcs);
 
            rtp_error_t install_sender_hook(std::function<void(std::unique_ptr<uvgrtp::frame::rtcp_sender_report>)> sr_handler);
 
            rtp_error_t install_receiver_hook(std::function<void(std::unique_ptr<uvgrtp::frame::rtcp_receiver_report>)> rr_handler);
 
            rtp_error_t install_sdes_hook(std::function<void(std::unique_ptr<uvgrtp::frame::rtcp_sdes_packet>)> sdes_handler);
 
            rtp_error_t install_app_hook(std::function<void(std::unique_ptr<uvgrtp::frame::rtcp_app_packet>)> app_handler);
 
            rtp_error_t install_roundtrip_time_hook(std::function<void(uint32_t, uint32_t, double)> rtt_handler);
 
            rtp_error_t install_send_app_hook(const std::string& app_name,
                std::function<std::unique_ptr<uint8_t[]>(uint8_t& subtype, uint32_t& payload_len)> app_sending_func);
 
            rtp_error_t remove_send_app_hook(const std::string& app_name);
 
 
            // deprecated functions
 
            // replaced by unique_ptr
            [[deprecated("Replaced with unique_ptr or C-style hook functions")]]
            rtp_error_t install_sender_hook(std::function<void(std::shared_ptr<uvgrtp::frame::rtcp_sender_report>)> sr_handler);
 
            [[deprecated("Replaced with unique_ptr or C-style hook functions")]]
            rtp_error_t install_receiver_hook(std::function<void(std::shared_ptr<uvgrtp::frame::rtcp_receiver_report>)> rr_handler);
 
            [[deprecated("Replaced with unique_ptr or C-style hook functions")]]
            rtp_error_t install_sdes_hook(std::function<void(std::shared_ptr<uvgrtp::frame::rtcp_sdes_packet>)> sdes_handler);
 
            [[deprecated("Replaced with unique_ptr or C-style hook functions")]]
            rtp_error_t install_app_hook(std::function<void(std::shared_ptr<uvgrtp::frame::rtcp_app_packet>)> app_handler);
 
            // replaced by ABI-safe versions
            [[deprecated("Use install_sender_hook(rtcp_sr*) from Core API instead")]]
            rtp_error_t install_sender_hook(void (*hook)(uvgrtp::frame::rtcp_sender_report*));
 
            [[deprecated("Use install_receiver_hook(rtcp_rr*) from Core API instead")]]
            rtp_error_t install_receiver_hook(void (*hook)(uvgrtp::frame::rtcp_receiver_report*));
 
            [[deprecated("Use install_sdes_hook(rtcp_sdes*) from Core API instead")]]
            rtp_error_t install_sdes_hook(void (*hook)(uvgrtp::frame::rtcp_sdes_packet*));
 
            [[deprecated("Use get_sr from Core API")]]
            uvgrtp::frame::rtcp_sender_report* get_sender_packet(uint32_t ssrc);
 
            [[deprecated("Use get_rr from Core API")]]
            uvgrtp::frame::rtcp_receiver_report* get_receiver_packet(uint32_t ssrc);
 
            [[deprecated("Use get_sdes from Core API")]]
            uvgrtp::frame::rtcp_sdes_packet* get_sdes_packet(uint32_t ssrc);
 
  // End of EXTENDED_API group
#endif
 
        private:
 
            rtcp(std::shared_ptr<uvgrtp::rtp> rtp, std::shared_ptr<std::atomic<std::uint32_t>> ssrc, std::shared_ptr<std::atomic<uint32_t>> remote_ssrc,
                std::string cname, std::shared_ptr<uvgrtp::socketfactory> sfp, int rce_flags);
            rtcp(std::shared_ptr<uvgrtp::rtp> rtp, std::shared_ptr<std::atomic<std::uint32_t>> ssrc, std::shared_ptr<std::atomic<uint32_t>> remote_ssrc,
                std::string cname, std::shared_ptr<uvgrtp::socketfactory> sfp, std::shared_ptr<uvgrtp::srtcp> srtcp, int rce_flags);
 
 
            rtcp_internal* pimpl_;
    };
}
 
namespace uvg_rtp = uvgrtp;