media_stream.hh

#pragma once
 
#include <unordered_map>
#include <memory>
 
#include "holepuncher.hh"
#include "pkt_dispatch.hh"
#include "rtcp.hh"
#include "socket.hh"
#include "srtp/srtcp.hh"
#include "srtp/srtp.hh"
#include "util.hh"
 
#include "formats/media.hh"
 
namespace uvgrtp {
 
    class media_stream {
        public:
            media_stream(std::string addr, int src_port, int dst_port, rtp_format_t fmt, int flags);
            media_stream(std::string remote_addr, std::string local_addr, int src_port, int dst_port, rtp_format_t fmt, int flags);
            ~media_stream();
 
            /* Initialize traditional RTP session
             * Allocate Connection/Reader/Writer objects and initialize them
             *
             * Return RTP_OK on success
             * Return RTP_MEMORY_ERROR if allocation failed
             *
             * Other error return codes are defined in {conn,writer,reader}.hh */
            rtp_error_t init();
 
            /* Initialize Secure RTP session
             * Allocate Connection/Reader/Writer objects and initialize them
             *
             * Return RTP_OK on success
             * Return RTP_MEMORY_ERROR if allocation failed
             *
             * TODO document all error codes!
             *
             * Other error return codes are defined in {conn,writer,reader,srtp}.hh */
            rtp_error_t init(uvgrtp::zrtp *zrtp);
 
            rtp_error_t add_srtp_ctx(uint8_t *key, uint8_t *salt);
 
            rtp_error_t push_frame(uint8_t *data, size_t data_len, int flags);
 
            rtp_error_t push_frame(std::unique_ptr<uint8_t[]> data, size_t data_len, int flags);
 
            rtp_error_t push_frame(uint8_t *data, size_t data_len, uint32_t ts, int flags);
 
            rtp_error_t push_frame(std::unique_ptr<uint8_t[]> data, size_t data_len, uint32_t ts, int flags);
 
            uvgrtp::frame::rtp_frame *pull_frame();
 
            uvgrtp::frame::rtp_frame *pull_frame(size_t timeout);
 
            rtp_error_t install_receive_hook(void *arg, void (*hook)(void *, uvgrtp::frame::rtp_frame *));
 
            /* If system call dispatcher is enabled and calling application has special requirements
             * for the deallocation of a frame, it may install a deallocation hook which is called
             * when SCD has processed the frame
             *
             * Return RTP_OK on success
             * Return RTP_INVALID_VALUE if "hook" is nullptr */
            rtp_error_t install_deallocation_hook(void (*hook)(void *));
 
            /* If needed, a notification hook can be installed to uvgRTP that can be used as
             * an information side channel to the internal state of the library.
             *
             * When uvgRTP encouters a situation it doesn't know how to react to,
             * it calls the notify hook with certain notify reason number (src/util.hh).
             * Upon receiving a notification, application may ignore it or act on it somehow
             *
             * Currently only one notification type is supported and only receiver uses notifications
             *
             * "arg" is optional argument that is passed to hook when it is called. It may be nullptr
             *
             * Return RTP_OK on success
             * Return RTP_INVALID_VALUE if "hook" is nullptr */
            rtp_error_t install_notify_hook(void *arg, void (*hook)(void *, int));
 
            rtp_error_t configure_ctx(int flag, ssize_t value);
 
            /* Setter and getter for media-specific config that can be used f.ex with Opus */
            void  set_media_config(void *config);
            void *get_media_config();
 
            /* Get unique key of the media stream
             * Used by session to index media streams */
            uint32_t get_key();
 
            uvgrtp::rtcp *get_rtcp();
 
        private:
            /* Initialize the connection by initializing the socket
             * and binding ourselves to specified interface and creating
             * an outgoing address */
            rtp_error_t init_connection();
 
            /* Create the media object for the stream */
            rtp_error_t create_media(rtp_format_t fmt);
 
            /* free all allocated resources */
            rtp_error_t free_resources(rtp_error_t ret);
 
            uint32_t key_;
 
            uvgrtp::srtp   *srtp_;
            uvgrtp::srtcp  *srtcp_;
            uvgrtp::socket *socket_;
            uvgrtp::rtp    *rtp_;
            uvgrtp::rtcp   *rtcp_;
 
            sockaddr_in addr_out_;
            std::string addr_;
            std::string laddr_;
            int src_port_;
            int dst_port_;
            rtp_format_t fmt_;
            int flags_;
 
            /* Media context config (SCD etc.) */
            rtp_ctx_conf_t ctx_config_;
 
            /* Media config f.ex. for Opus */
            void *media_config_;
 
            /* Has the media stream been initialized */
            bool initialized_;
 
            /* Primary handler keys for the RTP packet dispatcher */
            uint32_t rtp_handler_key_;
            uint32_t zrtp_handler_key_;
 
            /* RTP packet dispatcher for the receiver */
            uvgrtp::pkt_dispatcher *pkt_dispatcher_;
 
            /* Media object associated with this media stream. */
            uvgrtp::formats::media *media_;
 
            /* Thread that keeps the holepunched connection open for unidirectional streams */
            uvgrtp::holepuncher *holepuncher_;
    };
};
 
namespace uvg_rtp = uvgrtp;