rtpvideodepacketizerthread.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_NETWORK
#include <cstdint>
#include <functional>
#include <promeki/function.h>
#include <promeki/atomic.h>
#include <promeki/clockdomain.h>
#include <promeki/eui64.h>
#include <promeki/framenumber.h>
#include <promeki/histogram.h>
#include <promeki/imagedesc.h>
#include <promeki/jpeggeometryprobe.h>
#include <promeki/namespace.h>
#include <promeki/queue.h>
#include <promeki/rtpdepacketizerthread.h>
#include <promeki/rtppacket.h>
#include <promeki/rtppayload.h>
#include <promeki/rtpstreamclock.h>
#include <promeki/rxpayloadbundle.h>
#include <promeki/string.h>
#include <promeki/timestamp.h>
 
PROMEKI_NAMESPACE_BEGIN
 
struct RtpVideoDepacketizerContext {
                Queue<RxVideoFrame> *payloadQueue = nullptr;
 
                const Atomic<uint32_t> *resetEpoch = nullptr;
 
                const bool *active = nullptr;
 
                RtpPayload *payload = nullptr;
 
                ImageDesc *readerImageDesc = nullptr;
 
                String fmtp;
 
                EUI64 ptpGrandmaster;
 
                ClockDomain clockDomain;
 
                const bool *hasSr = nullptr;
 
                const RtpStreamClock *streamClock = nullptr;
 
                Atomic<int64_t> *packetsReceived = nullptr;
                Atomic<int64_t> *bytesReceived = nullptr;
                Atomic<int64_t> *lastPacketArrivalNs = nullptr;
                Atomic<int64_t> *framesReassembled = nullptr;
                Atomic<int64_t> *framesDroppedValidate = nullptr;
                Atomic<int64_t> *framesWaitingParamSets = nullptr;
                Atomic<int64_t> *framesDroppedSsrcReset = nullptr;
 
                Histogram *rxPacketInterval = nullptr;
                Histogram *rxFrameInterval = nullptr;
                Histogram *rxFrameAssembleTime = nullptr;
 
                Function<void()> noteFrameReceived;
 
                Function<void()> refreshStreamClock;
 
                Function<TimeStamp(const NtpTime &)> ntpToSteady;
};
 
class RtpVideoDepacketizerThread : public RtpDepacketizerThread {
        public:
                RtpVideoDepacketizerThread(RtpVideoDepacketizerContext ctx,
                                           const String &name,
                                           uint32_t clockRateHz);
 
                ~RtpVideoDepacketizerThread() override;
 
                RtpVideoDepacketizerThread(const RtpVideoDepacketizerThread &) = delete;
                RtpVideoDepacketizerThread &operator=(const RtpVideoDepacketizerThread &) = delete;
 
                void handlePacketForTest(const RtpPacket &pkt) { handlePacket(pkt); }
 
                void flushForTest() { emitFrame(); }
 
        protected:
                void handlePacket(const RtpPacket &pkt) override;
                void onStop() override;
 
        private:
                void emitFrame();
 
                RtpVideoDepacketizerContext _ctx;
                RtpPacket::List             _reasmPackets;
                uint32_t                    _reasmTimestamp = 0;
                bool                        _reasmHasTimestamp = false;
                TimeStamp                   _frameStartTime;
                bool                        _hasFrameStart = false;
                TimeStamp                   _lastPacketTime;
                bool                        _hasLastPacket = false;
                TimeStamp                   _lastFrameTime;
                bool                        _hasLastFrame = false;
                FrameNumber                 _streamFrameIndex{0};
                JpegGeometryProbe           _jpegProbe;
                uint32_t                    _lastEpoch = 0;
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_NETWORK