remux.h

Go to the documentation of this file.

/*
 * remux.h: Tools for detecting frames and handling PAT/PMT
 *
 * See the main source file 'vdr.c' for copyright information and
 * how to reach the author.
 *
 * $Id: remux.h 5.11 2025/12/30 12:38:52 kls Exp $
 */
 
#ifndef __REMUX_H
#define __REMUX_H
 
#include "channels.h"
#include "tools.h"
 
enum ePesHeader {
  phNeedMoreData = -1,
  phInvalid = 0,
  phMPEG1 = 1,
  phMPEG2 = 2
  };
 
ePesHeader AnalyzePesHeader(const uchar *Data, int Count, int &PesPayloadOffset, bool *ContinuationHeader = NULL);
 
class cRemux {
public:
  static void SetBrokenLink(uchar *Data, int Length);
  };
 
// Some TS handling tools.
// The following functions all take a pointer to one complete TS packet.
 
#define TS_SYNC_BYTE          0x47
#define TS_SIZE               188
#define TS_ERROR              0x80
#define TS_PAYLOAD_START      0x40
#define TS_TRANSPORT_PRIORITY 0x20
#define TS_PID_MASK_HI        0x1F
#define TS_SCRAMBLING_CONTROL 0xC0
#define TS_ADAPT_FIELD_EXISTS 0x20
#define TS_PAYLOAD_EXISTS     0x10
#define TS_CONT_CNT_MASK      0x0F
#define TS_ADAPT_DISCONT      0x80
#define TS_ADAPT_RANDOM_ACC   0x40 // would be perfect for detecting independent frames, but unfortunately not used by all broadcasters
#define TS_ADAPT_ELEM_PRIO    0x20
#define TS_ADAPT_PCR          0x10
#define TS_ADAPT_OPCR         0x08
#define TS_ADAPT_SPLICING     0x04
#define TS_ADAPT_TP_PRIVATE   0x02
#define TS_ADAPT_EXTENSION    0x01
 
#define PATPID 0x0000 // PAT PID (constant 0)
#define CATPID 0x0001 // CAT PID (constant 1)
#define EITPID 0x0012 // EIT PID (constant 18)
#define MAXPID 0x2000 // for arrays that use a PID as the index
 
#define PTSTICKS  90000 // number of PTS ticks per second
#define PCRFACTOR 300 // conversion from 27MHz PCR extension to 90kHz PCR base
#define MAX33BIT  0x00000001FFFFFFFFLL // max. possible value with 33 bit
#define MAX27MHZ  ((MAX33BIT + 1) * PCRFACTOR - 1) // max. possible PCR value
 
inline bool TsHasPayload(const uchar *p)
{
  return p[3] & TS_PAYLOAD_EXISTS;
}
 
inline bool TsSetPayload(const uchar *p)
{
  return p[3] & TS_PAYLOAD_EXISTS;
}
 
inline bool TsHasAdaptationField(const uchar *p)
{
  return p[3] & TS_ADAPT_FIELD_EXISTS;
}
 
inline bool TsPayloadStart(const uchar *p)
{
  return p[1] & TS_PAYLOAD_START;
}
 
inline bool TsError(const uchar *p)
{
  return p[1] & TS_ERROR;
}
 
inline int TsPid(const uchar *p)
{
  return (p[1] & TS_PID_MASK_HI) * 256 + p[2];
}
 
inline void TsSetPid(uchar *p, int Pid)
{
  p[1] = (p[1] & ~TS_PID_MASK_HI) | ((Pid >> 8) & TS_PID_MASK_HI);
  p[2] = Pid & 0x00FF;
}
 
inline bool TsIsScrambled(const uchar *p)
{
  return p[3] & TS_SCRAMBLING_CONTROL;
}
 
inline uchar TsContinuityCounter(const uchar *p)
{
  return p[3] & TS_CONT_CNT_MASK;
}
 
inline void TsSetContinuityCounter(uchar *p, uchar Counter)
{
  p[3] = (p[3] & ~TS_CONT_CNT_MASK) | (Counter & TS_CONT_CNT_MASK);
}
 
inline int TsPayloadOffset(const uchar *p)
{
  int o = TsHasAdaptationField(p) ? p[4] + 5 : 4;
  return o <= TS_SIZE ? o : TS_SIZE;
}
 
inline int TsGetPayload(const uchar **p)
{
  if (TsHasPayload(*p)) {
     int o = TsPayloadOffset(*p);
     *p += o;
     return TS_SIZE - o;
     }
  return 0;
}
 
inline int64_t TsGetPcr(const uchar *p)
{
  if (TsHasAdaptationField(p)) {
     if (p[4] >= 7 && (p[5] & TS_ADAPT_PCR)) {
        return ((((int64_t)p[ 6]) << 25) |
                (((int64_t)p[ 7]) << 17) |
                (((int64_t)p[ 8]) <<  9) |
                (((int64_t)p[ 9]) <<  1) |
                (((int64_t)p[10]) >>  7)) * PCRFACTOR +
               (((((int)p[10]) & 0x01) << 8) |
                ( ((int)p[11])));
        }
     }
  return -1;
}
 
void TsHidePayload(uchar *p);
void TsSetPcr(uchar *p, int64_t Pcr);
 
// Helper macro and function to quickly check whether Data points to the beginning
// of a TS packet. The return value is the number of bytes that need to be skipped
// to synchronize on the next TS packet (zero if already sync'd). TsSync() can be
// called directly, the macro just performs the initial check inline and adds some
// debug information for logging.
 
#define TS_SYNC(Data, Length) (*Data == TS_SYNC_BYTE ? 0 : TsSync(Data, Length, __FILE__, __FUNCTION__, __LINE__))
int TsSync(const uchar *Data, int Length, const char *File = NULL, const char *Function = NULL, int Line = 0);
 
// The following functions all take a pointer to a sequence of complete TS packets.
 
int64_t TsGetPts(const uchar *p, int l);
int64_t TsGetDts(const uchar *p, int l);
void TsSetPts(uchar *p, int l, int64_t Pts);
void TsSetDts(uchar *p, int l, int64_t Dts);
void TsExtendAdaptionField(unsigned char *Packet, int ToLength);
 
// Some PES handling tools:
// The following functions that take a pointer to PES data all assume that
// there is enough data so that PesLongEnough() returns true.
 
inline bool PesLongEnough(int Length)
{
  return Length >= 6;
}
 
inline bool PesHasLength(const uchar *p)
{
  return p[4] | p[5];
}
 
inline int PesLength(const uchar *p)
{
  return 6 + p[4] * 256 + p[5];
}
 
inline int PesPayloadOffset(const uchar *p)
{
  return 9 + p[8];
}
 
inline bool PesHasPts(const uchar *p)
{
  return (p[7] & 0x80) && p[8] >= 5;
}
 
inline bool PesHasDts(const uchar *p)
{
  return (p[7] & 0x40) && p[8] >= 10;
}
 
inline int64_t PesGetPts(const uchar *p)
{
  return ((((int64_t)p[ 9]) & 0x0E) << 29) |
         (( (int64_t)p[10])         << 22) |
         ((((int64_t)p[11]) & 0xFE) << 14) |
         (( (int64_t)p[12])         <<  7) |
         ((((int64_t)p[13]) & 0xFE) >>  1);
}
 
inline int64_t PesGetDts(const uchar *p)
{
  return ((((int64_t)p[14]) & 0x0E) << 29) |
         (( (int64_t)p[15])         << 22) |
         ((((int64_t)p[16]) & 0xFE) << 14) |
         (( (int64_t)p[17])         <<  7) |
         ((((int64_t)p[18]) & 0xFE) >>  1);
}
 
void PesSetPts(uchar *p, int64_t Pts);
void PesSetDts(uchar *p, int64_t Dts);
 
// PTS handling:
 
inline int64_t PtsAdd(int64_t Pts1, int64_t Pts2) { return (Pts1 + Pts2) & MAX33BIT; }
int64_t PtsDiff(int64_t Pts1, int64_t Pts2);
 
// A transparent TS payload handler:
 
class cTsPayload {
private:
  uchar *data;
  int length;
  int pid;
  int index; // points to the next byte to process
  int numPacketsPid; // the number of TS packets with the given PID (for statistical purposes)
  int numPacketsOther; // the number of TS packets with other PIDs (for statistical purposes)
  uchar SetEof(void);
protected:
  void Reset(void);
public:
  cTsPayload(void);
  cTsPayload(uchar *Data, int Length, int Pid = -1);
  void Setup(uchar *Data, int Length, int Pid = -1);
  bool AtTsStart(void) { return index < length && (index % TS_SIZE) == 0; }
  bool AtPayloadStart(void) { return AtTsStart() && TsPayloadStart(data + index) && TsPid(data + index) == pid; }
  int Available(void) { return length - index; }
  int Used(void) { return (index + TS_SIZE - 1) / TS_SIZE * TS_SIZE; }
  bool Eof(void) const { return index >= length; }
  void Statistics(void) const;
  uchar GetByte(void);
  bool SkipBytes(int Bytes);
  bool SkipPesHeader(void);
  int GetLastIndex(void);
  void SetByte(uchar Byte, int Index);
  bool Find(uint32_t Code);
  };
 
// PAT/PMT Generator:
 
#define MAX_SECTION_SIZE 4096 // maximum size of an SI section
#define MAX_PMT_TS  (MAX_SECTION_SIZE / TS_SIZE + 1)
 
class cPatPmtGenerator {
private:
  uchar pat[TS_SIZE]; // the PAT always fits into a single TS packet
  uchar pmt[MAX_PMT_TS][TS_SIZE]; // the PMT may well extend over several TS packets
  int numPmtPackets;
  int patCounter;
  int pmtCounter;
  int patVersion;
  int pmtVersion;
  int pmtPid;
  uchar *esInfoLength;
  void IncCounter(int &Counter, uchar *TsPacket);
  void IncVersion(int &Version);
  void IncEsInfoLength(int Length);
protected:
  int MakeStream(uchar *Target, uchar Type, int Pid);
  int MakeAC3Descriptor(uchar *Target, uchar Type);
  int MakeSubtitlingDescriptor(uchar *Target, const char *Language, uchar SubtitlingType, uint16_t CompositionPageId, uint16_t AncillaryPageId);
  int MakeLanguageDescriptor(uchar *Target, const char *Language);
  int MakeCRC(uchar *Target, const uchar *Data, int Length);
  void GeneratePmtPid(const cChannel *Channel);
  void GeneratePat(void);
  void GeneratePmt(const cChannel *Channel);
public:
  cPatPmtGenerator(const cChannel *Channel = NULL);
  void SetVersions(int PatVersion, int PmtVersion);
  void SetChannel(const cChannel *Channel);
  uchar *GetPat(void);
  uchar *GetPmt(int &Index);
  };
 
// PAT/PMT Parser:
 
#define MAX_PMT_PIDS 32
 
class cPatPmtParser {
private:
  uchar pmt[MAX_SECTION_SIZE];
  int pmtSize;
  int patVersion;
  int pmtVersion;
  int pmtPids[MAX_PMT_PIDS + 1]; // list is zero-terminated
  int vpid;
  int ppid;
  int vtype;
  int apids[MAXAPIDS + 1]; // list is zero-terminated
  int atypes[MAXAPIDS + 1]; // list is zero-terminated
  char alangs[MAXAPIDS][MAXLANGCODE2];
  int dpids[MAXDPIDS + 1]; // list is zero-terminated
  int dtypes[MAXDPIDS + 1]; // list is zero-terminated
  char dlangs[MAXDPIDS][MAXLANGCODE2];
  int spids[MAXSPIDS + 1]; // list is zero-terminated
  char slangs[MAXSPIDS][MAXLANGCODE2];
  uchar subtitlingTypes[MAXSPIDS];
  uint16_t compositionPageIds[MAXSPIDS];
  uint16_t ancillaryPageIds[MAXSPIDS];
  bool updatePrimaryDevice;
  bool completed;
protected:
  int SectionLength(const uchar *Data, int Length) { return (Length >= 3) ? ((int(Data[1]) & 0x0F) << 8)| Data[2] : 0; }
public:
  cPatPmtParser(bool UpdatePrimaryDevice = false);
  void Reset(void);
  void ParsePat(const uchar *Data, int Length);
  void ParsePmt(const uchar *Data, int Length);
  bool ParsePatPmt(const uchar *Data, int Length);
  bool GetVersions(int &PatVersion, int &PmtVersion) const;
  bool IsPmtPid(int Pid) const { for (int i = 0; pmtPids[i]; i++) if (pmtPids[i] == Pid) return true; return false; }
  int Vpid(void) const { return vpid; }
  int Ppid(void) const { return ppid; }
  int Vtype(void) const { return vtype; }
  bool Completed(void) { return completed; }
  const int *Apids(void) const { return apids; }
  const int *Dpids(void) const { return dpids; }
  const int *Spids(void) const { return spids; }
  int Apid(int i) const { return (0 <= i && i < MAXAPIDS) ? apids[i] : 0; }
  int Dpid(int i) const { return (0 <= i && i < MAXDPIDS) ? dpids[i] : 0; }
  int Spid(int i) const { return (0 <= i && i < MAXSPIDS) ? spids[i] : 0; }
  int Atype(int i) const { return (0 <= i && i < MAXAPIDS) ? atypes[i] : 0; }
  int Dtype(int i) const { return (0 <= i && i < MAXDPIDS) ? dtypes[i] : 0; }
  const char *Alang(int i) const { return (0 <= i && i < MAXAPIDS) ? alangs[i] : ""; }
  const char *Dlang(int i) const { return (0 <= i && i < MAXDPIDS) ? dlangs[i] : ""; }
  const char *Slang(int i) const { return (0 <= i && i < MAXSPIDS) ? slangs[i] : ""; }
  uchar SubtitlingType(int i) const { return (0 <= i && i < MAXSPIDS) ? subtitlingTypes[i] : uchar(0); }
  uint16_t CompositionPageId(int i) const { return (0 <= i && i < MAXSPIDS) ? compositionPageIds[i] : uint16_t(0); }
  uint16_t AncillaryPageId(int i) const { return (0 <= i && i < MAXSPIDS) ? ancillaryPageIds[i] : uint16_t(0); }
  };
 
// EIT Generator:
 
class cEitGenerator {
private:
  uchar eit[TS_SIZE];
  int counter;
  int version;
  uint16_t YMDtoMJD(int Y, int M, int D);
  uchar *AddParentalRatingDescriptor(uchar *p, uchar ParentalRating = 0);
public:
  cEitGenerator(int Sid = 0);
  uchar *Generate(int Sid);
  uchar *Data(void) { return eit; }
  int Length(void) { return sizeof(eit); }
  };
 
// TS to PES converter:
// Puts together the payload of several TS packets that form one PES
// packet.
 
class cTsToPes {
private:
  uchar *data;
  int size;
  int length;
  int offset;
  uchar *lastData;
  int lastLength;
  bool repeatLast;
public:
  cTsToPes(void);
  ~cTsToPes();
  void PutTs(const uchar *Data, int Length);
  const uchar *GetPes(int &Length);
  void SetRepeatLast(void);
  void Reset(void);
  };
 
// Some helper functions for debugging:
 
void BlockDump(const char *Name, const u_char *Data, int Length);
void TsDump(const char *Name, const u_char *Data, int Length);
void PesDump(const char *Name, const u_char *Data, int Length);
 
// Frame detector:
 
#define MIN_TS_PACKETS_FOR_FRAME_DETECTOR 100
 
class cFrameParser;
 
enum eScanType {
  stUnknown     = 0,
  stProgressive = 1,
  stInterlaced  = 2,
  stMax
  };
 
enum eAspectRatio {
  arUnknown = 0,
  ar_1_1    = 1,
  ar_4_3    = 2,
  ar_16_9   = 3,
  ar_2_21_1 = 4,
  arMax
  };
 
extern const char *ScanTypeChars;
extern const char *AspectRatioTexts[];
 
class cTsChecker;
class cPtsChecker;
 
class cFrameChecker {
private:
  cTsChecker *tsChecker;
  cPtsChecker *ptsChecker;
public:
  cFrameChecker(void);
  ~cFrameChecker();
  void Reset(void);
  bool Check(const uchar *Data, int Length, bool Independent, bool &Errors, bool &Missing, bool Final);
  int TotalErrors(void);
  };
 
class cFrameDetector {
private:
  enum { MaxPtsValues = 150 };
  int pid;
  int type;
  bool synced;
  bool newFrame;
  bool independentFrame;
  uint32_t ptsValues[MaxPtsValues]; // 32 bit is enough - we only need the delta
  int numPtsValues;
  int numIFrames;
  bool isVideo;
  double framesPerSecond;
  uint16_t frameWidth;
  uint16_t frameHeight;
  eScanType scanType;
  eAspectRatio aspectRatio;
  int framesInPayloadUnit;
  int framesPerPayloadUnit; // Some broadcasters send one frame per payload unit (== 1),
                            // while others put an entire GOP into one payload unit (> 1).
  bool scanning;
  bool firstIframeSeen;
  int previousErrors;
  int missingFrames;
  cFrameParser *parser;
  cTsChecker *tsChecker;
  cPtsChecker *ptsChecker;
public:
  cFrameDetector(int Pid = 0, int Type = 0);
  ~cFrameDetector();
  void SetPid(int Pid, int Type);
  [[deprecated("use SetLastPts() instead")]] void SetMissing(void) {}
  void SetLastPts(int64_t LastPts);
  int Errors(bool *PreviousErrors = NULL, bool *MissingFrames = NULL);
  int Analyze(const uchar *Data, int Length, bool ErrorCheck = true);
  bool Synced(void) { return synced; }
  [[deprecated("use NewFrame(bool&, bool&) instead")]] bool NewFrame(int *PreviousErrors = NULL, int *MissingFrames = NULL);
  bool NewFrame(bool &PreviousErrors, bool &MissingFrames);
  bool IndependentFrame(void) { return independentFrame; }
  double FramesPerSecond(void) { return framesPerSecond; }
  uint16_t FrameWidth(void) { return frameWidth; }
  uint16_t FrameHeight(void) { return frameHeight; }
  eScanType ScanType(void) { return scanType; }
  eAspectRatio AspectRatio(void) { return aspectRatio; }
  };
 
#define PATCH_NALUDUMP 100
 
class cNaluDumper {
    unsigned int History;
 
    int LastContinuityInput;
    int LastContinuityOutput;
    int ContinuityOffset;
 
    bool DropAllPayload;
 
    int PesId;
    int PesOffset;
 
    int NaluOffset;
 
    enum eNaluFillState {
        NALU_NONE=0,    // currently not NALU fill stream
        NALU_FILL,      // Within NALU fill stream, 0xff bytes and NALU start code in byte 0
        NALU_TERM,      // Within NALU fill stream, read 0x80 terminating byte
        NALU_END        // Beyond end of NALU fill stream, expecting 0x00 0x00 0x01 now
        };
 
    eNaluFillState NaluFillState;
 
    struct sPayloadInfo {
        int DropPayloadStartBytes;
        int DropPayloadEndBytes;
        bool DropAllPayloadBytes;
    };
 
public:
    cNaluDumper();
 
    void reset();
 
    // Single packet interface:
    bool ProcessTSPacket(unsigned char *Packet);
 
private:
    void ProcessPayload(unsigned char *Payload, int size, bool PayloadStart, sPayloadInfo &Info);
};
 
class cNaluStreamProcessor {
    //Buffer stream interface:
    int vpid;
    uchar *data;
    int length;
    uchar tempBuffer[TS_SIZE];
    int tempLength;
    bool tempLengthAtEnd;
    cPatPmtParser *pPatPmtParser;
    cNaluDumper NaluDumper;
 
    long long int TotalPackets;
    long long int DroppedPackets;
public:
    cNaluStreamProcessor();
 
    void SetPid(int VPid) { vpid = VPid; }
    void SetPatPmtParser(cPatPmtParser *_pPatPmtParser) { pPatPmtParser = _pPatPmtParser; }
    // Set either a PID or set a pointer to an PatPmtParser that will detect _one_ PID
 
    void PutBuffer(uchar *Data, int Length);
    // Add new data to be processed. Data must be valid until Get() returns NULL.
    uchar* GetBuffer(int &OutLength);
    // Returns filtered data, or NULL/0 to indicate that all data from Put() was processed
    // or buffered.
 
    long long int GetTotalPackets() { return TotalPackets; }
    long long int GetDroppedPackets() { return DroppedPackets; }
};
 
#endif //__REMUX_H