mjpegstreammediaio.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_HTTP
#include <promeki/atomic.h>
#include <promeki/buffer.h>
#include <promeki/dedicatedthreadmediaio.h>
#include <promeki/duration.h>
#include <promeki/error.h>
#include <promeki/framerate.h>
#include <promeki/httphandler.h>
#include <promeki/list.h>
#include <promeki/map.h>
#include <promeki/mediadesc.h>
#include <promeki/mediaiofactory.h>
#include <promeki/mutex.h>
#include <promeki/namespace.h>
#include <promeki/string.h>
#include <promeki/timestamp.h>
#include <promeki/uniqueptr.h>
#include <promeki/videoencoder.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class HttpServer;
 
class MjpegStreamSubscriber {
        public:
                virtual ~MjpegStreamSubscriber() = default;
 
                virtual void onFrame(const Buffer &jpeg, const TimeStamp &ts) = 0;
 
                virtual void onClosed() = 0;
};
 
struct MjpegStreamSnapshot {
                int64_t framesEncoded = 0;
                int64_t framesRateLimited = 0;
                int64_t framesEncodeError = 0;
                int64_t totalEncodeUs = 0;
                int64_t peakEncodeUs = 0;
                int64_t encodeSamples = 0;
                int64_t totalEncodedBytes = 0;
};
 
class MjpegStreamMediaIO : public DedicatedThreadMediaIO {
                PROMEKI_OBJECT(MjpegStreamMediaIO, DedicatedThreadMediaIO)
        public:
                static const String HttpBoundary;
 
                static const String LatestJpegContentType;
 
                MjpegStreamMediaIO(ObjectBase *parent = nullptr);
 
                ~MjpegStreamMediaIO() override;
 
                int attachSubscriber(MjpegStreamSubscriber *s);
 
                void detachSubscriber(int id);
 
                bool isStreaming() const;
 
                Buffer latestJpeg() const;
 
                TimeStamp latestJpegTimestamp() const;
 
                MjpegStreamSnapshot snapshot() const;
 
                void registerHttpRoute(HttpServer &server, const String &path);
 
                static HttpHandlerFunc buildMultipartHandler(MjpegStreamMediaIO *sink);
 
                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(MediaIOCommandStats &cmd) override;
 
        private:
 
                Error encodeFrame(const Frame &frame, Buffer *out, TimeStamp *ts);
 
                bool latestRingEntry(Buffer *out, TimeStamp *outTs) const;
 
                void publishEncoded(const Buffer &jpeg, const TimeStamp &ts);
 
                // ---- Resolved configuration (latched at open time) ----
                FrameRate _maxRate;
                Duration  _period;
                int       _quality = 80;
                int       _ringDepth = 1;
                bool      _isOpen = false;
 
                // ---- Encoder strand state ----
                UniquePtr<VideoEncoder> _encoder;
                TimeStamp _lastEncoded;
                bool      _hasLastEncoded = false;
                int64_t   _frameSerial = 0;
 
                // ---- Ring + subscribers (mutex-guarded) ----
                struct RingEntry {
                                Buffer jpeg; 
                                TimeStamp   timestamp;
                };
 
                mutable Mutex                     _stateMutex;
                List<RingEntry>                   _ring;
                Map<int, MjpegStreamSubscriber *> _subscribers;
                int                               _nextSubscriberId = 1;
                MjpegStreamSnapshot               _stats;
                bool _isStreaming = false;
};
 
class MjpegStreamFactory : public MediaIOFactory {
        public:
                MjpegStreamFactory() = default;
 
                String name() const override { return String("MjpegStream"); }
                String displayName() const override { return String("MJPEG Preview Stream"); }
                String description() const override {
                        return String("Frame-rate-limited motion-JPEG preview sink "
                                      "(HTTP multipart-friendly).");
                }
 
                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_HTTP