srtgroup.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_SRT
#include <promeki/iodevice.h>
#include <promeki/error.h>
#include <promeki/socketaddress.h>
#include <promeki/string.h>
#include <promeki/list.h>
#include <promeki/uniqueptr.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class SrtGroup : public IODevice {
                PROMEKI_OBJECT(SrtGroup, IODevice)
        public:
                using UPtr = UniquePtr<SrtGroup>;
 
                static constexpr int InvalidHandle = -1;
 
                enum Type {
                        Broadcast, 
                        Backup     
                };
 
                struct Member {
                                SocketAddress sourceAddress;
                                SocketAddress peerAddress;
                };
 
                using MemberList = ::promeki::List<Member>;
 
                struct MemberStatus {
                                int           handle = InvalidHandle;
                                SocketAddress peerAddress;
                                int           state = 0;
                                int           membership = 0;
                                int           weight = 0;
                };
 
                using MemberStatusList = ::promeki::List<MemberStatus>;
 
                explicit SrtGroup(Type type = Broadcast, ObjectBase *parent = nullptr);
 
                SrtGroup(int adoptHandle, Type type, ObjectBase *parent = nullptr);
 
                ~SrtGroup() override;
 
                Type type() const { return _type; }
 
                Error open(OpenMode mode) override;
 
                Error close() override;
 
                bool isOpen() const override;
 
                Error connect(const MemberList &members);
 
                int64_t read(void *data, int64_t maxSize) override;
 
                int64_t write(const void *data, int64_t maxSize) override;
 
                bool isSequential() const override { return true; }
 
                int handle() const { return _sock; }
 
                String lastSrtError() const { return _lastError; }
 
                MemberStatusList memberStatus() const;
 
                // ---- Pre-connect group options (applied at @ref connect) ----
 
                Error setLatency(int ms);
 
                Error setPassphrase(const String &passphrase);
 
                Error setEncryptionKeyLength(int bytes);
 
                Error setStreamId(const String &id);
 
                Error setPayloadSize(int bytes);
 
                Error setMaxBandwidth(int64_t bytesPerSec);
 
                Error setReceiveTimeout(int timeoutMs);
 
                Error setSendTimeout(int timeoutMs);
 
                Error setConnectTimeout(int timeoutMs);
 
        protected:
                void captureLastError();
 
                Error applyPreConnectOptions();
 
        private:
                int     _sock = InvalidHandle;
                Type    _type = Broadcast;
                String  _passphrase;
                String  _streamId;
                String  _lastError;
                int     _latencyMs = 120;
                int     _payloadSize = 0;
                int     _pbKeyLen = 0;
                int     _connectTimeoutMs = 0;
                int     _recvTimeoutMs = 0;
                int     _sendTimeoutMs = 0;
                int64_t _maxBw = 0;
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_SRT