nullpacingmediaio.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_PROAV
#include <promeki/atomic.h>
#include <promeki/clock.h>
#include <promeki/duration.h>
#include <promeki/enums.h>
#include <promeki/framerate.h>
#include <promeki/mediadesc.h>
#include <promeki/mediaiofactory.h>
#include <promeki/mutex.h>
#include <promeki/namespace.h>
#include <promeki/pacinggate.h>
#include <promeki/ratetracker.h>
#include <promeki/sharedthreadmediaio.h>
#include <promeki/timestamp.h>
 
PROMEKI_NAMESPACE_BEGIN
 
struct NullPacingSnapshot {
                int64_t framesConsumed = 0;
                int64_t framesDropped = 0;
                int64_t totalLatencyUs = 0;
                int64_t peakLatencyUs = 0;
                int64_t latencySamples = 0;
};
 
class NullPacingMediaIO : public SharedThreadMediaIO {
                PROMEKI_OBJECT(NullPacingMediaIO, SharedThreadMediaIO)
        public:
                NullPacingMediaIO(ObjectBase *parent = nullptr);
 
                ~NullPacingMediaIO() override;
 
                NullPacingSnapshot snapshot() const;
 
        protected:
                Error executeCmd(MediaIOCommandOpen &cmd) override;
                Error executeCmd(MediaIOCommandClose &cmd) override;
                Error executeCmd(MediaIOCommandWrite &cmd) override;
                Error executeCmd(MediaIOCommandStats &cmd) override;
 
        private:
                // ---- Resolved configuration (latched at open time) ----
                NullPacingMode          _mode = NullPacingMode::Wallclock;
                FrameRate               _targetRate;
                Duration                _period;
                bool                    _burnTimings = false;
                bool                    _isOpen = false;
 
                // ---- Pacing state ----
                //
                // Wallclock-mode pacing runs through PacingGate's
                // non-blocking tryAcquire path: if the next tick
                // deadline has arrived we consume, otherwise we drop
                // (the existing rate-limiter semantic).  Free mode
                // leaves the gate without a clock so tryAcquire
                // returns true unconditionally and every frame is
                // consumed.
                PacingGate _gate;
 
                TimeStamp _lastConsumed;
                bool      _hasLastConsumed = false;
 
                // ---- Counters (mutex-guarded; cheap to read via
                // snapshot, cheap to update on every frame) ----
                mutable Mutex      _stateMutex;
                NullPacingSnapshot _stats;
};
 
class NullPacingFactory : public MediaIOFactory {
        public:
                NullPacingFactory() = default;
 
                String name() const override { return String("NullPacing"); }
                String displayName() const override { return String("Null Pacing Sink"); }
                String description() const override {
                        return String("Frame-pacing null sink (consumes and discards frames at a target rate).");
                }
 
                bool canBeSink() const override { return true; }
 
                Config::SpecMap configSpecs() const override;
 
                MediaIO *create(const Config &config, ObjectBase *parent = nullptr) const override;
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_PROAV