srtmediaio.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_PROAV && PROMEKI_ENABLE_SRT
#include <cstdint>
#include <promeki/namespace.h>
#include <promeki/buffer.h>
#include <promeki/frame.h>
#include <promeki/framerate.h>
#include <promeki/list.h>
#include <promeki/mediaiofactory.h>
#include <promeki/enums_mediaio.h>
#include <promeki/framerate.h>
#include <promeki/pacinggate.h>
#include <promeki/sharedthreadmediaio.h>
#include <promeki/socketaddress.h>
#include <promeki/srtsockettransport.h>
#include <promeki/string.h>
#include <promeki/uniqueptr.h>
#include <promeki/url.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class MpegTsFramer;
 
class SrtMediaIO : public SharedThreadMediaIO {
                PROMEKI_OBJECT(SrtMediaIO, SharedThreadMediaIO)
        public:
                static inline const MediaIOStats::ID StatsPacketsWritten{"PacketsWritten"};
 
                static inline const MediaIOStats::ID StatsBytesWritten{"BytesWritten"};
 
                static inline const MediaIOStats::ID StatsMessagesWritten{"MessagesWritten"};
 
                static inline const MediaIOStats::ID StatsFramesWritten{"FramesWritten"};
 
                static inline const MediaIOStats::ID StatsPacketsRead{"PacketsRead"};
 
                static inline const MediaIOStats::ID StatsBytesRead{"BytesRead"};
 
                static inline const MediaIOStats::ID StatsMessagesRead{"MessagesRead"};
 
                static inline const MediaIOStats::ID StatsFramesRead{"FramesRead"};
 
                static inline const MediaIOStats::ID StatsContinuityErrors{"ContinuityErrors"};
 
                static inline const MediaIOStats::ID StatsBytesDiscarded{"BytesDiscarded"};
 
                static inline const MediaIOStats::ID StatsRttUs{"SrtRttUs"};
 
                static inline const MediaIOStats::ID StatsLinkBandwidthBps{"SrtLinkBandwidthBps"};
 
                static inline const MediaIOStats::ID StatsRcvDrops{"SrtRcvDrops"};
 
                static inline const MediaIOStats::ID StatsRetransmitted{"SrtRetransmitted"};
 
                SrtMediaIO(ObjectBase *parent = nullptr);
                ~SrtMediaIO() override;
 
                Error describe(MediaIODescription *out) const override;
                Error proposeInput(const MediaDesc &offered, MediaDesc *preferred) const override;
 
        protected:
                Error executeCmd(MediaIOCommandOpen &cmd) override;
                Error executeCmd(MediaIOCommandClose &cmd) override;
                Error executeCmd(MediaIOCommandWrite &cmd) override;
                Error executeCmd(MediaIOCommandRead &cmd) override;
                Error executeCmd(MediaIOCommandStats &cmd) override;
                Error executeCmd(MediaIOCommandSetClock &cmd) override;
 
        private:
                Error openSink(const MediaIOCommandOpen &cmd);
                Error openSource(const MediaIOCommandOpen &cmd);
                Error openTransport(const MediaIO::Config &cfg);
                Error flushWriteBuffer();
                Error pumpReader();
                void  applyFramerConfig(const MediaIO::Config &cfg);
 
                void armVideoPaceGate();
 
                bool paceVideoFrame();
 
                bool _isWrite = false;
                bool _eof = false;
 
                UniquePtr<SrtSocketTransport> _transport;
                UniquePtr<MpegTsFramer>       _framer;
                Frame::List                   _readQueue;
 
                // Writer-side accumulation buffer.  We collect TS bytes
                // from the muxer and only flush whole SRT messages
                // (configurable, default 1316 bytes = 7 × 188).
                Buffer _writeBuf;
                size_t _writeBufFill = 0;
                size_t _writePayloadSize = 1316;
 
                // Reader-side scratch buffer for one SRT message.
                Buffer _readBuf;
 
                int64_t _packetsWritten = 0;
                int64_t _bytesWritten = 0;
                int64_t _messagesWritten = 0;
                int64_t _framesWritten = 0;
                int64_t _packetsRead = 0;
                int64_t _bytesRead = 0;
                int64_t _messagesRead = 0;
                int64_t _framesRead = 0;
 
                // Sink-side wall-clock pacing.  Mirrors RtmpMediaIO /
                // RtpMediaIO's pattern so live-mode transport sinks
                // gate upstream-produced frames at frame-rate cadence
                // even when no upstream stage is paced.
                FrameRate      _frameRate;
                PacingGate     _videoPaceGate;
                SrtVideoPacing _videoPacingMode{SrtVideoPacing::Internal};
                int            _paceSkipThresholdMs = 0;
                int            _paceReanchorThresholdMs = 0;
                bool           _paceClockIsExternal = false;
};
 
class SrtFactory : public MediaIOFactory {
        public:
                SrtFactory() = default;
 
                String name() const override { return String("Srt"); }
                String displayName() const override { return String("SRT (MPEG-TS over SRT)"); }
                String description() const override {
                        return String("MPEG-2 Transport Stream over Secure Reliable Transport "
                                      "(H.264 / HEVC + AAC).");
                }
                bool canBeSink() const override { return true; }
                bool canBeSource() const override { return true; }
 
                StringList      schemes() const override { return {String("srt")}; }
                Config::SpecMap configSpecs() const override;
                Error           urlToConfig(const Url &url, Config *outConfig) const override;
                MediaIO        *create(const Config &config, ObjectBase *parent = nullptr) const override;
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_PROAV && PROMEKI_ENABLE_SRT