sdpsession.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_CORE
#include <cstdint>
#include <promeki/error.h>
#include <promeki/namespace.h>
#include <promeki/string.h>
#include <promeki/list.h>
#include <promeki/map.h>
#include <promeki/pair.h>
#include <promeki/result.h>
#include <promeki/sharedptr.h>
#include <promeki/datatype.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class DataStream;
 
class SdpMediaDescription {
        public:
                SdpMediaDescription() = default;
 
                const String &mediaType() const { return _mediaType; }
 
                void setMediaType(const String &type) { _mediaType = type; }
 
                uint16_t port() const { return _port; }
 
                void setPort(uint16_t port) { _port = port; }
 
                const String &protocol() const { return _protocol; }
 
                void setProtocol(const String &proto) { _protocol = proto; }
 
                const List<uint8_t> &payloadTypes() const { return _payloadTypes; }
 
                void addPayloadType(uint8_t pt) { _payloadTypes.pushToBack(pt); }
 
                using Attribute = Pair<String, String>;
 
                using AttributeList = ::promeki::List<Attribute>;
 
                String attribute(const String &name) const {
                        for (size_t i = 0; i < _attributes.size(); i++) {
                                if (_attributes[i].first() == name) return _attributes[i].second();
                        }
                        return String();
                }
 
                void setAttribute(const String &name, const String &value) {
                        for (size_t i = 0; i < _attributes.size(); i++) {
                                if (_attributes[i].first() == name) {
                                        _attributes[i].setSecond(value);
                                        return;
                                }
                        }
                        _attributes.pushToBack(Attribute(name, value));
                }
 
                const AttributeList &attributes() const { return _attributes; }
 
                const String &connectionAddress() const { return _connectionAddress; }
 
                void setConnectionAddress(const String &addr) { _connectionAddress = addr; }
 
                struct RtpMap {
                                uint8_t      payloadType = 0; 
                                String       encoding; 
                                uint32_t     clockRate = 0; 
                                unsigned int channels = 1;  
                                bool         valid = false; 
                };
 
                RtpMap rtpMap() const;
 
                using FmtpParameters = ::promeki::Map<String, String>;
 
                FmtpParameters fmtpParameters() const;
 
                bool operator==(const SdpMediaDescription &other) const {
                        return _mediaType == other._mediaType && _port == other._port && _protocol == other._protocol &&
                               _payloadTypes == other._payloadTypes && _attributes == other._attributes &&
                               _connectionAddress == other._connectionAddress;
                }
 
                bool operator!=(const SdpMediaDescription &other) const { return !(*this == other); }
 
        private:
                String        _mediaType;
                uint16_t      _port = 0;
                String        _protocol;
                List<uint8_t> _payloadTypes;
                AttributeList _attributes;
                String        _connectionAddress;
};
 
class SdpSession {
                PROMEKI_SHARED_FINAL(SdpSession)
        public:
                PROMEKI_DATATYPE(SdpSession, DataTypeSdpSession, 1)
 
                
                Error writeToStream(DataStream &s) const;
                template <uint32_t V> static Result<SdpSession> readFromStream(DataStream &s);
 
                using Ptr = SharedPtr<SdpSession>;
 
                using List = ::promeki::List<SdpSession>;
 
                using PtrList = ::promeki::List<SdpSession::Ptr>;
 
                using MediaDescriptionList = ::promeki::List<SdpMediaDescription>;
 
                static Result<SdpSession> fromString(const String &sdp);
 
                static Result<SdpSession> fromFile(const String &path);
 
                SdpSession() = default;
 
                const String &sessionName() const { return _sessionName; }
 
                void setSessionName(const String &name) { _sessionName = name; }
 
                const String &originUsername() const { return _originUsername; }
 
                uint64_t sessionId() const { return _sessionId; }
 
                uint64_t sessionVersion() const { return _sessionVersion; }
 
                void setOrigin(const String &username, uint64_t sessionId, uint64_t sessionVersion,
                               const String &netType = "IN", const String &addrType = "IP4",
                               const String &address = "0.0.0.0");
 
                const String &originNetType() const { return _originNetType; }
 
                const String &originAddrType() const { return _originAddrType; }
 
                const String &originAddress() const { return _originAddress; }
 
                const String &connectionAddress() const { return _connectionAddress; }
 
                void setConnectionAddress(const String &address) { _connectionAddress = address; }
 
                const MediaDescriptionList &mediaDescriptions() const { return _mediaDescriptions; }
 
                void addMediaDescription(const SdpMediaDescription &md) { _mediaDescriptions.pushToBack(md); }
 
                String toString() const;
 
                Error toFile(const String &path) const;
 
                bool operator==(const SdpSession &other) const {
                        return _sessionName == other._sessionName && _originUsername == other._originUsername &&
                               _sessionId == other._sessionId && _sessionVersion == other._sessionVersion &&
                               _originNetType == other._originNetType && _originAddrType == other._originAddrType &&
                               _originAddress == other._originAddress &&
                               _connectionAddress == other._connectionAddress &&
                               _mediaDescriptions == other._mediaDescriptions;
                }
 
                bool operator!=(const SdpSession &other) const { return !(*this == other); }
 
        private:
                String                             _sessionName;
                String                             _originUsername = "-";
                uint64_t                           _sessionId = 0;
                uint64_t                           _sessionVersion = 0;
                String                             _originNetType = "IN";
                String                             _originAddrType = "IP4";
                String                             _originAddress = "0.0.0.0";
                String                             _connectionAddress;
                MediaDescriptionList               _mediaDescriptions;
};
 
PROMEKI_NAMESPACE_END
 
PROMEKI_FORMAT_VIA_TOSTRING(promeki::SdpSession);
 
#endif // PROMEKI_ENABLE_CORE