rtp.h

#ifndef TINS_RTP_H
#define TINS_RTP_H
 
#include <tins/endianness.h>
#include <tins/pdu.h>
#include <tins/pdu_option.h>
#include <tins/small_uint.h>
 
namespace Tins {

class TINS_API RTP : public PDU {
public:
    static const PDU::PDUType pdu_flag = PDU::RTP;

    typedef std::vector<uint32_t> csrc_ids_type;

    typedef std::vector<uint32_t> extension_header_data_type;

    RTP();

    RTP(const uint8_t* data, uint32_t size);

    small_uint<2> version() const { return header_.version; }

    small_uint<1> padding_bit() const { return header_.padding; }

    small_uint<1> extension_bit() const { return header_.extension; }

    small_uint<4> csrc_count() const { return header_.csrc_count; }

    small_uint<1> marker_bit() const { return header_.marker; }

    small_uint<7> payload_type() const { return header_.payload_type; }

    uint16_t sequence_number() const { return Endian::be_to_host(header_.seq_num); }

    uint32_t timestamp() const { return Endian::be_to_host(header_.timestamp); }

    uint32_t ssrc_id() const { return Endian::be_to_host(header_.ssrc_id); }

    const csrc_ids_type& csrc_ids() const {
        return csrc_ids_;
    }

    uint8_t padding_size() const { return padding_size_; }

    uint16_t extension_profile() const { return Endian::be_to_host(ext_header_.profile); }

    uint16_t extension_length() const { return Endian::be_to_host(ext_header_.length); }

    const extension_header_data_type& extension_data() const {
        return ext_data_;
    }

    void version(small_uint<2> version) { header_.version = version; }

    void extension_bit(small_uint<1> extension) { header_.extension = extension; }

    void marker_bit(small_uint<1> marker) { header_.marker = marker; }

    void payload_type(small_uint<7> payload_type) { header_.payload_type = payload_type; }

    void sequence_number(uint16_t seq_num) { header_.seq_num = Endian::host_to_be(seq_num); }

    void timestamp(uint32_t timestamp) { header_.timestamp = Endian::host_to_be(timestamp); }

    void ssrc_id(uint32_t ssrc_id) { header_.ssrc_id = Endian::host_to_be(ssrc_id); }

    void padding_size(uint8_t size) {
        padding_bit(size > 0);
        padding_size_ = size;
    }

    void extension_profile(uint16_t profile) { ext_header_.profile = Endian::host_to_be(profile); }

    void add_extension_data(const uint32_t value);

    bool remove_extension_data(const uint32_t value);

    bool search_extension_data(const uint32_t value);

    void add_csrc_id(const uint32_t csrc_id);

    bool remove_csrc_id(const uint32_t value);

    bool search_csrc_id(const uint32_t value);

    uint32_t header_size() const;

    uint32_t trailer_size() const { return static_cast<uint32_t>(padding_size_); }

    PDUType pdu_type() const { return pdu_flag; }

    RTP *clone() const { return new RTP(*this); }
 
private:
    TINS_BEGIN_PACK
    struct rtp_header {
    #if TINS_IS_BIG_ENDIAN
        uint16_t version:2,
                 padding:1,
                 extension:1,
                 csrc_count:4,
                 marker:1,
                 payload_type:7;
    #elif TINS_IS_LITTLE_ENDIAN
        uint16_t csrc_count:4,
                 extension:1,
                 padding:1,
                 version:2,
                 payload_type:7,
                 marker:1;
    #endif
        uint16_t seq_num;
        uint32_t timestamp;
        uint32_t ssrc_id;
    } TINS_END_PACK;
 
    TINS_BEGIN_PACK
    struct rtp_extension_header {
        uint16_t profile;
        uint16_t length;
    } TINS_END_PACK;
 
    void write_serialization(uint8_t* buffer, uint32_t size);
    csrc_ids_type::const_iterator search_csrc_id_iterator(const uint32_t csrc_id) const;
    csrc_ids_type::iterator search_csrc_id_iterator(const uint32_t csrc_id);
    extension_header_data_type::const_iterator search_extension_data_iterator(const uint32_t data) const;
    extension_header_data_type::iterator search_extension_data_iterator(const uint32_t data);

    void padding_bit(small_uint<1> padding) { header_.padding = padding; }

    void csrc_count(small_uint<4> csrc_count) { header_.csrc_count = csrc_count; }

    void extension_length(uint16_t length) { ext_header_.length = Endian::host_to_be(length); }
 
    rtp_header header_;
    csrc_ids_type csrc_ids_;
    rtp_extension_header ext_header_;
    extension_header_data_type ext_data_;
    uint8_t padding_size_;
};
 
} // Tins
 
#endif // TINS_RTP_H