mpegtsframer.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/audiodesc.h>
#include <promeki/buffer.h>
#include <promeki/bufferview.h>
#include <promeki/error.h>
#include <promeki/frame.h>
#include <promeki/framerate.h>
#include <promeki/function.h>
#include <promeki/imagedesc.h>
#include <promeki/list.h>
#include <promeki/map.h>
#include <promeki/mpegts.h>
#include <promeki/mpegtsmuxer.h>
#include <promeki/mpegtsdemuxer.h>
#include <promeki/uniqueptr.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class MpegTsFramer {
        public:
                enum class AacFraming {
                        Adts,
                        Latm
                };
 
                using EmitCallback = MpegTsMuxer::EmitCallback;
 
                using FrameCallback = Function<Error(Frame &&)>;
 
                MpegTsFramer();
                ~MpegTsFramer();
 
                MpegTsFramer(const MpegTsFramer &) = delete;
                MpegTsFramer &operator=(const MpegTsFramer &) = delete;
 
                // ---- Common configuration --------------------------
 
                void setVideoPid(uint16_t v) { _videoPid = v; }
 
                uint16_t videoPid() const { return _videoPid; }
 
                void setAudioPid(uint16_t v) { _audioPid = v; }
 
                uint16_t audioPid() const { return _audioPid; }
 
                void setProgramNumber(uint16_t v) { _programNumber = v; }
 
                uint16_t programNumber() const { return _programNumber; }
 
                void setPmtPid(uint16_t v) { _pmtPid = v; }
 
                uint16_t pmtPid() const { return _pmtPid; }
 
                void setPatPmtIntervalMs(int v) { _patPmtIntervalMs = v; }
 
                int patPmtIntervalMs() const { return _patPmtIntervalMs; }
 
                void setPcrIntervalMs(int v) { _pcrIntervalMs = v; }
 
                int pcrIntervalMs() const { return _pcrIntervalMs; }
 
                void setMuxRateBps(int64_t v) { _muxRateBps = v; }
 
                int64_t muxRateBps() const { return _muxRateBps; }
 
                void setAacFraming(AacFraming v) { _aacFraming = v; }
 
                AacFraming aacFraming() const { return _aacFraming; }
 
                void setWriterFrameRate(const FrameRate &fps) { _writerFrameRate = fps; }
 
                const FrameRate &writerFrameRate() const { return _writerFrameRate; }
 
                Error configureStreams(const MediaDesc &desc);
 
                bool haveVideoStream() const { return _haveVideoStream; }
 
                bool haveAudioStream() const { return _haveAudioStream; }
 
                // ---- Writer side -----------------------------------
 
                void forcePatPmt();
 
                Error markNextAccessUnitDiscontinuous(uint16_t pid);
 
                Error writeFrame(const Frame &frame, const EmitCallback &emit);
 
                int64_t writerAccessUnitsEmitted() const { return _writerAccessUnitsEmitted; }
 
                // ---- Reader side -----------------------------------
 
                void setFrameCallback(FrameCallback cb) { _frameCallback = std::move(cb); }
 
                Error pushBytes(const BufferView &data);
 
                Error flushReader();
 
                size_t drainFrames(Frame::List &out);
 
                MpegTsMuxer *muxer();
 
                MpegTsDemuxer *demuxer();
 
        private:
                MpegTsMuxer   *ensureMuxer();
                MpegTsDemuxer *ensureDemuxer();
                Error          registerVideoStream(MpegTs::StreamType st, uint32_t registrationFormat,
                                                   const ImageDesc &imageDesc);
                Error          registerAudioStream(MpegTs::StreamType st, uint32_t registrationFormat,
                                                   const AudioDesc &audioDesc);
                Error          handleAccessUnit(const MpegTsDemuxer::AccessUnit &au);
                void           probeVideoDimensions(uint16_t pid, MpegTs::StreamType st, const BufferView &au);
 
                // Configuration.
                uint16_t   _videoPid = MpegTs::DefaultVideoPid;
                uint16_t   _audioPid = MpegTs::DefaultAudioPid;
                uint16_t   _pmtPid = MpegTs::DefaultPmtPid;
                uint16_t   _programNumber = MpegTs::DefaultProgramNumber;
                int        _patPmtIntervalMs = 100;
                int        _pcrIntervalMs = 20;
                int64_t    _muxRateBps = 0;
                AacFraming _aacFraming = AacFraming::Adts;
                FrameRate  _writerFrameRate;
 
                // Lazy components.
                UniquePtr<MpegTsMuxer>   _muxer;
                UniquePtr<MpegTsDemuxer> _demuxer;
 
                // Writer state.
                bool     _haveVideoStream = false;
                bool     _haveAudioStream = false;
                uint64_t _writerFrameIndex = 0;
                uint64_t _writerAudioPts90k = 0;
                int64_t  _writerAccessUnitsEmitted = 0;
                // SMPTE 302M block phase counter — wraps 0..191
                // (one AES3 block = 192 frames).  Carries the F-bit
                // phase across @ref writeFrame calls so we stamp the
                // first AES3 subframe of every block correctly.
                uint32_t _writer302MBlockPhase = 0;
 
                // Reader state.
                FrameCallback        _frameCallback;
                Frame::List          _readQueue;
                Map<uint16_t, ImageDesc> _readerImageDesc; // per video PID, learned from SPS.
                Map<uint16_t, bool>      _readerDimsProbed;
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_PROAV