mpegtsmuxer.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_PROAV
#include <cstdint>
#include <promeki/namespace.h>
#include <promeki/buffer.h>
#include <promeki/bufferview.h>
#include <promeki/error.h>
#include <promeki/function.h>
#include <promeki/list.h>
#include <promeki/map.h>
#include <promeki/mpegts.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class MpegTsMuxer {
        public:
                using EmitCallback = Function<Error(const BufferView &)>;
 
                MpegTsMuxer();
 
                ~MpegTsMuxer();
 
                void setTransportStreamId(uint16_t v);
 
                uint16_t transportStreamId() const { return _transportStreamId; }
 
                void setProgramNumber(uint16_t v);
 
                uint16_t programNumber() const { return _programNumber; }
 
                void setPmtPid(uint16_t v);
 
                uint16_t pmtPid() const { return _pmtPid; }
 
                void setPcrPid(uint16_t v);
 
                uint16_t pcrPid() const { return _pcrPid; }
 
                void setPatPmtIntervalMs(int v);
 
                int patPmtIntervalMs() const { return _patPmtIntervalMs; }
 
                void setPcrIntervalMs(int v);
 
                int pcrIntervalMs() const { return _pcrIntervalMs; }
 
                Error addStream(uint16_t pid, MpegTs::StreamType streamType,
                                const BufferView &descriptors = BufferView(),
                                MpegTs::StreamKind kind = MpegTs::StreamKind::Auto);
 
                List<uint16_t> registeredPids() const;
 
                bool hasStream(uint16_t pid) const;
 
                Error writeAccessUnit(uint16_t pid, const BufferView &payload, uint64_t pts90k, uint64_t dts90k,
                                      bool isKeyframe, const EmitCallback &emit);
 
                void forcePatPmt();
 
                Error markNextAccessUnitDiscontinuous(uint16_t pid);
 
                Error emitNullPacket(const EmitCallback &emit);
 
                void setMuxRateBps(int64_t bps);
 
                int64_t muxRateBps() const { return _muxRateBps; }
 
        private:
                struct StreamRec {
                                uint16_t           pid = 0;
                                MpegTs::StreamType streamType = MpegTs::StreamTypeReserved;
                                MpegTs::StreamKind kind = MpegTs::StreamKind::Auto;
                                uint8_t            pesStreamId = 0;
                                Buffer             descriptors;
                                uint8_t            continuityCounter = 0;
                                bool               pendingDiscontinuity = false;
                };
 
                StreamRec       *findStream(uint16_t pid);
                const StreamRec *findStream(uint16_t pid) const;
                uint8_t          pickPesStreamId(MpegTs::StreamType streamType, MpegTs::StreamKind kind,
                                                 size_t indexOfKind) const;
 
                Error emitPatPmtIfDue(uint64_t now27mhz, bool force, const EmitCallback &emit);
                Error writePsiSectionPacket(uint16_t pid, const Buffer &section, uint8_t &cc, const EmitCallback &emit);
 
                uint16_t _transportStreamId = 1;
                uint16_t _programNumber = MpegTs::DefaultProgramNumber;
                uint16_t _pmtPid = MpegTs::DefaultPmtPid;
                uint16_t _pcrPid = MpegTs::DefaultVideoPid;
                int      _patPmtIntervalMs = 100;
                int      _pcrIntervalMs = 20;
                uint8_t  _patVersion = 0;
                uint8_t  _pmtVersion = 0;
                uint8_t  _patCc = 0;
                uint8_t  _pmtCc = 0;
 
                List<StreamRec> _streams;
                size_t          _audioStreamCount = 0; // counts ADTS/LATM/AC3/MP2 streams for stream_id allocation.
                size_t          _videoStreamCount = 0;
 
                bool     _forcePatPmt = true; // emit on the first writeAccessUnit call.
                bool     _havePsiTime = false;
                bool     _havePcrTime = false;
                uint64_t _lastPsiTime27mhz = 0;
                uint64_t _lastPcrTime27mhz = 0;
 
                // CBR padding state.
                int64_t  _muxRateBps = 0;
                bool     _haveCbrAnchor = false;
                uint64_t _cbrAnchor27mhz = 0;
                int64_t  _bytesSinceAnchor = 0;
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_PROAV