mpegtsdemuxer.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 MpegTsDemuxer {
        public:
                struct AccessUnit {
                                uint16_t pid = 0;                                          
                                MpegTs::StreamType streamType = MpegTs::StreamTypeReserved; 
                                uint32_t           registrationFormat = 0;
                                BufferView         payload;                                 
                                bool               hasPts = false;
                                bool               hasDts = false;
                                uint64_t           pts90k = 0;
                                uint64_t           dts90k = 0;
                                bool               randomAccess = false; 
                                bool               dataAlignment = false; 
                                bool               discontinuity = false; 
                };
 
                using StreamCallback = Function<Error(const AccessUnit &)>;
 
                using ProgramCallback = Function<void()>;
 
                using PcrCallback = Function<void(uint16_t pid, uint64_t pcr27mhz)>;
 
                MpegTsDemuxer();
                ~MpegTsDemuxer();
 
                void setStreamCallback(StreamCallback cb) { _streamCallback = std::move(cb); }
 
                void setProgramCallback(ProgramCallback cb) { _programCallback = std::move(cb); }
 
                void setPcrCallback(PcrCallback cb) { _pcrCallback = std::move(cb); }
 
                Error push(const BufferView &data);
 
                Error flush();
 
                uint16_t pmtPid() const { return _pmtPid; }
 
                uint16_t programNumber() const { return _programNumber; }
 
                uint16_t pcrPid() const { return _pcrPid; }
 
                struct StreamInfo {
                                uint16_t           pid = 0;
                                MpegTs::StreamType streamType = MpegTs::StreamTypeReserved;
                                uint32_t           registrationFormat = 0;
                };
 
                List<StreamInfo> streams() const;
 
                uint64_t continuityErrors() const { return _continuityErrors; }
 
                uint64_t bytesDiscarded() const { return _bytesDiscarded; }
 
        private:
                struct PsiReasm {
                                Buffer  buffer;
                                size_t  writePos = 0;
                                size_t  expectedTotal = 0; // 0 = not yet known.
                };
 
                struct PesReasm {
                                MpegTs::StreamType streamType = MpegTs::StreamTypeReserved;
                                Buffer             buffer;              
                                size_t             writePos = 0;
                                size_t             expectedTotal = 0;   
                                bool               inProgress = false;
                                bool               unbounded = false;
                                bool               hasPts = false;
                                bool               hasDts = false;
                                uint64_t           pts90k = 0;
                                uint64_t           dts90k = 0;
                                bool               randomAccess = false;
                                bool               dataAlignment = false;
                                bool               discontinuity = false;
                                uint8_t            continuityCounter = 0;
                                bool               haveCc = false;
                };
 
                Error processPacket(const uint8_t *p);
                Error processPsiPacket(const uint8_t *payload, size_t payloadLen, uint16_t pid, bool pusi);
                Error dispatchPsiSection(uint16_t pid, const uint8_t *section, size_t len);
                Error parsePat(const uint8_t *section, size_t len);
                Error parsePmt(const uint8_t *section, size_t len);
                Error finalizePes(uint16_t pid, PesReasm &pr);
                Error startNewPes(uint16_t pid, PesReasm &pr, const uint8_t *pesStart, size_t pesAvail,
                                  bool randomAccess, bool discontinuity);
 
                StreamCallback  _streamCallback;
                ProgramCallback _programCallback;
                PcrCallback     _pcrCallback;
 
                // Sync-alignment ring buffer.  Holds up to (188 - 1)
                // bytes carried over from one push() to the next.
                uint8_t _carry[MpegTs::PacketSize];
                size_t  _carrySize = 0;
 
                uint16_t _programNumber = 0;
                uint16_t _pmtPid = MpegTs::PidNull;
                uint16_t _pcrPid = MpegTs::PidNull;
                bool     _havePat = false;
                bool     _havePmt = false;
 
                Map<uint16_t, MpegTs::StreamType> _streamTypeByPid;
                Map<uint16_t, uint32_t>           _registrationByPid;
                Map<uint16_t, PesReasm>           _pes;
                Map<uint16_t, PsiReasm>           _psi;
 
                uint64_t _continuityErrors = 0;
                uint64_t _bytesDiscarded = 0;
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_PROAV