srtsocket.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/uniqueptr.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class SrtSocket : public IODevice {
                PROMEKI_OBJECT(SrtSocket, IODevice)
        public:
                using UPtr = UniquePtr<SrtSocket>;
 
                static constexpr int InvalidHandle = -1;
 
                struct Stats {
                                int64_t  msSinceStart = 0;
                                int64_t  pktSent = 0;
                                int64_t  pktRecv = 0;
                                uint64_t byteSent = 0;
                                uint64_t byteRecv = 0;
                                int      pktSndLost = 0;
                                int      pktRcvLost = 0;
                                int      pktRetransmitted = 0;
                                int      pktSndDrop = 0;
                                int      pktRcvDrop = 0;
                                int      pktRcvUndecrypt = 0;
                                double   rttMs = 0.0;
                                double   linkBandwidthMbps = 0.0;
                                double   maxBandwidthMbps = 0.0;
                                int      sendBufferBytes = 0;
                                int      sendBufferMs = 0;
                                int      recvBufferBytes = 0;
                                int      recvBufferMs = 0;
                };
 
                enum TransportType {
                        Live, 
                        File  
                };
 
                enum SocketState {
                        Init,       
                        Opened,     
                        Listening,  
                        Connecting, 
                        Connected,  
                        Broken,     
                        Closing,    
                        Closed,     
                        NonExist    
                };
 
                SrtSocket(ObjectBase *parent = nullptr);
 
                SrtSocket(int handle, ObjectBase *parent = nullptr);
 
                ~SrtSocket() override;
 
                Error open(OpenMode mode) override;
 
                Error close() override;
 
                bool isOpen() const override;
 
                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; }
 
                Error bind(const SocketAddress &address);
 
                Error connectToHost(const SocketAddress &address);
 
                Error waitForConnected(unsigned int timeoutMs = 0);
 
                SocketAddress localAddress() const { return _localAddress; }
 
                SocketAddress peerAddress() const { return _peerAddress; }
 
                SocketState state() const;
 
                PROMEKI_SIGNAL(connected);
 
                PROMEKI_SIGNAL(disconnected);
 
                int handle() const { return _sock; }
 
                int groupHandle() const;
 
                // ---- SRT-specific configuration knobs ----------------
 
                Error setLatency(int ms);
 
                int latency() const { return _latencyMs; }
 
                Error setPayloadSize(int bytes);
 
                int payloadSize() const { return _payloadSize; }
 
                Error setTransportType(TransportType type);
 
                TransportType transportType() const { return _transportType; }
 
                Error setPassphrase(const String &passphrase);
 
                bool hasPassphrase() const { return !_passphrase.isEmpty(); }
 
                Error setEncryptionKeyLength(int bytes);
 
                int encryptionKeyLength() const { return _pbKeyLen; }
 
                Error setStreamId(const String &id);
 
                String streamId() const;
 
                Error setMaxBandwidth(int64_t bytesPerSec);
 
                Error setReceiveBufferSize(int bytes);
 
                Error setSendBufferSize(int bytes);
 
                Error setReceiveTimeout(int timeoutMs);
 
                Error setSendTimeout(int timeoutMs);
 
                Error setConnectTimeout(int timeoutMs);
 
                Error setRendezvous(bool enable);
 
                bool isRendezvous() const { return _rendezvous; }
 
                Error setNonBlocking(bool enable);
 
                String lastSrtError() const { return _lastError; }
 
                Stats stats(bool resetWindowed = false) const;
 
        protected:
                void updateLocalAddress();
 
                void updatePeerAddress();
 
                void captureLastError();
 
        private:
                friend class SrtServer;
 
                int           _sock = InvalidHandle; 
                SocketAddress _localAddress;
                SocketAddress _peerAddress;
                String        _passphrase;
                String        _streamId;
                String        _lastError;
                int           _latencyMs = 120;
                int           _payloadSize = 0;
                int           _pbKeyLen = 0;
                bool          _rendezvous = false;
                TransportType _transportType = Live;
 
                Error applyPreConnectOptions();
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_SRT