mpegts.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/list.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class MpegTs {
        public:
                static constexpr int PacketSize = 188;
 
                static constexpr uint8_t SyncByte = 0x47;
 
                static constexpr uint16_t MaxPid = 0x1FFF;
 
                static constexpr uint16_t PidPat = 0x0000;
 
                static constexpr uint16_t PidCat = 0x0001;
 
                static constexpr uint16_t PidTsdt = 0x0002;
 
                static constexpr uint16_t PidIpmp = 0x0003;
 
                static constexpr uint16_t PidNull = 0x1FFF;
 
                static constexpr uint16_t DefaultPmtPid = 0x1000;
 
                static constexpr uint16_t DefaultVideoPid = 0x0100;
 
                static constexpr uint16_t DefaultAudioPid = 0x0101;
 
                static constexpr uint16_t DefaultProgramNumber = 1;
 
                static constexpr uint32_t PesStartCode = 0x000001;
 
                enum StreamType : uint8_t {
                        StreamTypeReserved = 0x00, 
                        StreamTypeMpeg1Video = 0x01, 
                        StreamTypeMpeg2Video = 0x02, 
                        StreamTypeMpeg1Audio = 0x03, 
                        StreamTypeMpeg2Audio = 0x04, 
                        StreamTypePrivatePes = 0x06,
                        StreamTypeAacAdts = 0x0F, 
                        StreamTypeAacLatm = 0x11, 
                        StreamTypeMetadata = 0x15, 
                        StreamTypeH264 = 0x1B, 
                        StreamTypeHevc = 0x24, 
                        StreamTypeJpegXs = 0x32,
                        StreamTypeAc3 = 0x81, 
                        StreamTypeScte35 = 0x86, 
                };
 
                enum class StreamKind : uint8_t {
                        Auto = 0,    
                        Video = 1,   
                        Audio = 2,   
                        Data = 3,    
                        Metadata = 4 
                };
 
                static constexpr uint32_t RegFormatSmpte302M = 0x42535344; 
                static constexpr uint32_t RegFormatOpus      = 0x4F707573; 
                static constexpr uint32_t RegFormatAv1       = 0x41563031; 
                static constexpr uint32_t RegFormatJpegXs    = 0x4A585356; 
 
                static constexpr uint8_t DescriptorTagRegistration = 0x05;
 
                enum PesStreamId : uint8_t {
                        PesStreamIdVideoFirst = 0xE0, 
                        PesStreamIdAudioFirst = 0xC0, 
                        PesStreamIdPrivate1 = 0xBD, 
                        PesStreamIdPadding = 0xBE, 
                        PesStreamIdPrivate2 = 0xBF, 
                        PesStreamIdMetadata = 0xFC, 
                };
 
                static uint32_t psiCrc32(const void *data, size_t len);
 
                static uint32_t psiCrc32(const BufferView &v);
 
                static void encodePesPts(uint64_t value90k, uint8_t prefix, uint8_t out[5]);
 
                static uint64_t decodePesPts(const uint8_t in[5]);
 
                static void encodePcr(uint64_t value27mhz, uint8_t out[6]);
 
                static uint64_t decodePcr(const uint8_t in[6]);
 
                static Error buildPat(uint16_t transportStreamId, uint16_t programNumber, uint16_t pmtPid,
                                      uint8_t versionNumber, Buffer &outBuf);
 
                struct PmtStream {
                                uint8_t  streamType = 0;  
                                uint16_t pid = 0;         
                                Buffer   descriptors;     
                };
 
                static Error buildPmt(uint16_t programNumber, uint16_t pcrPid, uint8_t versionNumber,
                                      const BufferView &programDescriptors, const List<PmtStream> &streams,
                                      Buffer &outBuf);
 
                struct PesHeader {
                                uint8_t  streamId = 0;
                                uint16_t pesPacketLength = 0;        
                                bool     dataAlignmentIndicator = false;
                                bool     hasPts = false;
                                bool     hasDts = false;
                                uint64_t pts90k = 0;
                                uint64_t dts90k = 0;
                };
 
                static size_t pesHeaderSize(const PesHeader &h);
 
                static void writePesHeader(const PesHeader &h, uint8_t *out);
 
                static Error readPesHeader(const uint8_t *in, size_t len, PesHeader *out, size_t *headerSize);
 
                static bool isPsiSectionValid(const uint8_t *section, size_t len);
 
                struct PatEntry {
                                uint16_t programNumber = 0;
                                uint16_t pid = 0;
                };
 
                struct ParsedPat {
                                uint16_t        transportStreamId = 0;
                                uint8_t         versionNumber = 0;
                                bool            currentNextIndicator = false;
                                List<PatEntry>  entries;
                };
 
                static Error parsePat(const uint8_t *section, size_t len, ParsedPat *out);
 
                struct ParsedPmt {
                                uint16_t                programNumber = 0;
                                uint8_t                 versionNumber = 0;
                                bool                    currentNextIndicator = false;
                                uint16_t                pcrPid = 0;
                                Buffer                  programDescriptors;
                                List<PmtStream>         streams;
                };
 
                static Error parsePmt(const uint8_t *section, size_t len, ParsedPmt *out);
 
                static Error buildRegistrationDescriptor(uint32_t formatIdentifier, Buffer &outBuf);
 
                static Error findRegistrationDescriptor(const BufferView &descriptors,
                                                        uint32_t         *outFormatIdentifier);
 
                static constexpr uint8_t DescriptorTagExtension = 0x7F;
 
                static constexpr uint8_t DescriptorTagAv1Video = 0x80;
 
                static constexpr uint8_t DescriptorTagJxsVideo = 0x32;
 
                static constexpr uint8_t ExtensionDescTagOpus = 0x80;
 
                static Error buildOpusExtensionDescriptor(unsigned channels, Buffer &outBuf);
 
                static Error buildAv1VideoDescriptor(Buffer &outBuf);
 
                static Error buildJpegXsVideoDescriptor(uint16_t width, uint16_t height,
                                                        uint32_t frameRateNum, uint32_t frameRateDen,
                                                        Buffer &outBuf);
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_PROAV