TSDuck v3.38-3675
MPEG Transport Stream Toolkit
Loading...
Searching...
No Matches
ts::SectionDemux Class Reference

This class rebuilds MPEG tables and sections from TS packets. More...

#include <tsSectionDemux.h>

Inheritance diagram for ts::SectionDemux:
Collaboration diagram for ts::SectionDemux:

Classes

struct  Status
 Demux status information. More...
 

Public Types

using SuperClass = AbstractDemux
 Explicit reference to superclass.
 

Public Member Functions

 SectionDemux (DuckContext &duck, TableHandlerInterface *table_handler=nullptr, SectionHandlerInterface *section_handler=nullptr, const PIDSet &pid_filter=NoPID)
 Constructor.
 
virtual void addPID (PID pid)
 Add one PID to filter.
 
virtual void addPIDs (const PIDSet &pids)
 Add several PID's to filter.
 
int demuxId () const
 Get the "demux id" value, as previously stored by the application.
 
virtual void feedPacket (const TSPacket &pkt) override
 The following method feeds the demux with a TS packet.
 
void fillAndFlushEITs ()
 Add missing sections in all incomplete EIT's and notify these rebuilt tables.
 
void getStatus (Status &status) const
 Get the current status of the demux.
 
bool hasErrors () const
 Check if the demux has errors.
 
virtual bool hasPID (PID pid) const
 Check if a PID is filtered.
 
void packAndFlushSections ()
 Pack sections in all incomplete tables and notify these rebuilt tables.
 
virtual size_t pidCount () const
 Get the current number of PID's being filtered.
 
virtual void removePID (PID pid)
 Remove one PID to filter.
 
virtual void reset ()
 Reset the demux.
 
virtual void resetPID (PID pid)
 Reset the demuxing context for one single PID.
 
void setCurrentNext (bool current, bool next)
 Filter sections based on current/next indicator.
 
void setDemuxId (int id)
 Set some arbitrary "demux id" value.
 
void setInvalidSectionHandler (InvalidSectionHandlerInterface *h)
 Replace the invalid section handler.
 
virtual void setPIDFilter (const PIDSet &pid_filter)
 Replace the list of PID's to filter.
 
void setSectionHandler (SectionHandlerInterface *h)
 Replace the section handler.
 
void setTableHandler (TableHandlerInterface *h)
 Replace the table handler.
 
void setTransportErrorLogLevel (int level)
 Set the log level for messages reporting transport stream errors in demux.
 
void trackInvalidSectionVersions (bool on)
 Track / untrack invalid section version numbers.
 

Protected Member Functions

bool afterCallingHandler (bool executeDelayedOperations=true)
 Helper for subclass, after invoking an application-defined handler.
 
void beforeCallingHandler (PID pid=PID_NULL)
 Helper for subclass, before invoking an application-defined handler.
 
virtual void immediateReset () override
 Reset the demux immediately.
 
virtual void immediateResetPID (PID pid) override
 Reset the demuxing context for one single PID immediately.
 

Protected Attributes

DuckContext_duck
 The TSDuck execution context is accessible to all subclasses.
 
PacketCounter _packet_count = 0
 Number of TS packets in the demultiplexed stream.
 
PIDSet _pid_filter {}
 Current set of filtered PID's.
 

Detailed Description

This class rebuilds MPEG tables and sections from TS packets.

Long sections are validated with CRC. Corrupted sections are not reported.

Sections with the next indicator are ignored. Only sections with the current indicator are reported.

Constructor & Destructor Documentation

◆ SectionDemux()

ts::SectionDemux::SectionDemux ( DuckContext duck,
TableHandlerInterface table_handler = nullptr,
SectionHandlerInterface section_handler = nullptr,
const PIDSet pid_filter = NoPID 
)
explicit

Constructor.

Parameters
[in,out]duckTSDuck execution context. The reference is kept inside the demux. Contextual information (such as standards) are accumulated in the context from demuxed sections.
[in]table_handlerThe object to invoke when a new complete table is extracted.
[in]section_handlerThe object to invoke when any valid section is extracted.
[in]pid_filterThe set of PID's to demux.

Member Function Documentation

◆ feedPacket()

virtual void ts::SectionDemux::feedPacket ( const TSPacket pkt)
overridevirtual

The following method feeds the demux with a TS packet.

Parameters
[in]pktA TS packet.

Reimplemented from ts::AbstractDemux.

◆ packAndFlushSections()

void ts::SectionDemux::packAndFlushSections ( )
inline

Pack sections in all incomplete tables and notify these rebuilt tables.

All incomplete tables which have not yet been notified are packed. This means that missing sections are ignored and the tables are built from existing sections only, as if they were contiguous. Then, the table handler is invoked for each table.

This may create inconsistent tables since sections are missing. But this may me useful at the end of a table collecting sessions to grab incomplete tables.

See also
BinaryTable::packSections()

◆ fillAndFlushEITs()

void ts::SectionDemux::fillAndFlushEITs ( )
inline

Add missing sections in all incomplete EIT's and notify these rebuilt tables.

All DVB Event Information Tables (EIT) which have not yet been notified are completed. Missing sections are added with sections without events. Then, the table handler is invoked for each table.

This is typically useful at the end of processing when segmented EIT's are collected but no empty section was collected at end of segments.

◆ setTableHandler()

void ts::SectionDemux::setTableHandler ( TableHandlerInterface h)
inline

Replace the table handler.

Parameters
[in]hThe new handler.

◆ setSectionHandler()

void ts::SectionDemux::setSectionHandler ( SectionHandlerInterface h)
inline

Replace the section handler.

Parameters
[in]hThe new handler.

◆ setInvalidSectionHandler()

void ts::SectionDemux::setInvalidSectionHandler ( InvalidSectionHandlerInterface h)
inline

Replace the invalid section handler.

This object is invoked each time an invalid section is extracted from the stream, maybe due to invalid section length, invalid CRC32, etc. This type of data block is not a valid section and is never used in the standard table or section handler.

Parameters
[in]hThe new handler.

◆ setCurrentNext()

void ts::SectionDemux::setCurrentNext ( bool  current,
bool  next 
)
inline

Filter sections based on current/next indicator.

Parameters
[in]currentGet "current" tables. This is true by default.
[in]nextGet "next" tables. This is false by default.

◆ trackInvalidSectionVersions()

void ts::SectionDemux::trackInvalidSectionVersions ( bool  on)
inline

Track / untrack invalid section version numbers.

By default, if a section version does not change, the section is ignored. When this tracking is enabled, the content of the sections are tracked and a table is demuxed when a section version does not change but the content changes. This is considered as an error according to MPEG rules.

Parameters
[in]onTrack invalid section versions. This is false by default.

◆ setTransportErrorLogLevel()

void ts::SectionDemux::setTransportErrorLogLevel ( int  level)
inline

Set the log level for messages reporting transport stream errors in demux.

By default, the log level is Severity::Debug.

Parameters
[in]levelThe new log level for messages reporting transport stream errors.

◆ getStatus()

void ts::SectionDemux::getStatus ( Status status) const
inline

Get the current status of the demux.

Parameters
[out]statusThe returned status.

◆ hasErrors()

bool ts::SectionDemux::hasErrors ( ) const
inline

Check if the demux has errors.

Returns
True if any error counter is not zero.

◆ immediateReset()

virtual void ts::SectionDemux::immediateReset ( )
overrideprotectedvirtual

Reset the demux immediately.

Reimplemented from ts::AbstractDemux.

◆ immediateResetPID()

virtual void ts::SectionDemux::immediateResetPID ( PID  pid)
overrideprotectedvirtual

Reset the demuxing context for one single PID immediately.

Parameters
[in]pidThe PID to reset.

Reimplemented from ts::AbstractDemux.

◆ setPIDFilter()

virtual void ts::AbstractDemux::setPIDFilter ( const PIDSet pid_filter)
virtualinherited

Replace the list of PID's to filter.

The method resetPID() is invoked on each removed PID.

Parameters
[in]pid_filterThe list of PID's to filter.

◆ addPID()

virtual void ts::AbstractDemux::addPID ( PID  pid)
virtualinherited

Add one PID to filter.

Parameters
[in]pidThe new PID to filter.

Reimplemented in ts::MPEDemux.

◆ addPIDs()

virtual void ts::AbstractDemux::addPIDs ( const PIDSet pids)
virtualinherited

Add several PID's to filter.

Parameters
[in]pidsThe list of new PID's to filter.

Reimplemented in ts::MPEDemux.

◆ removePID()

virtual void ts::AbstractDemux::removePID ( PID  pid)
virtualinherited

Remove one PID to filter.

The method resetPID() is invoked on pid.

Parameters
[in]pidThe PID to no longer filter.

Reimplemented in ts::MPEDemux.

◆ pidCount()

virtual size_t ts::AbstractDemux::pidCount ( ) const
virtualinherited

Get the current number of PID's being filtered.

Returns
The current number of PID's being filtered.

◆ hasPID()

virtual bool ts::AbstractDemux::hasPID ( PID  pid) const
virtualinherited

Check if a PID is filtered.

Parameters
[in]pidThe PID to test.
Returns
Tue if pid is filtered.

◆ reset()

virtual void ts::AbstractDemux::reset ( )
virtualinherited

Reset the demux.

Useful when the transport stream changes. The PID filter and the handlers are not modified.

If invoked in an application-handler, the operation is delayed until the handler terminates. For subclass implementers, see beforeCallingHandler() and override immediateReset() instead of reset().

Reimplemented in ts::StandaloneTableDemux.

◆ resetPID()

virtual void ts::AbstractDemux::resetPID ( PID  pid)
virtualinherited

Reset the demuxing context for one single PID.

Forget all previous partially demuxed data on this PID.

If invoked in an application-handler, the operation is delayed until the handler terminates. For subclass implementers, see beforeCallingHandler() and override immediateResetPID() instead of resetPID().

Parameters
[in]pidThe PID to reset.

Reimplemented in ts::StandaloneTableDemux.

◆ setDemuxId()

void ts::AbstractDemux::setDemuxId ( int  id)
inlineinherited

Set some arbitrary "demux id" value.

This value is chosen and set by the application. It can be retrieved later if a table or section handler is used by several demux. The demux id is not interpreted by the demux, it is only stored for the application. The initial value of a demux id is zero.

Parameters
[in]idApplication-defined demux id to assign.

◆ demuxId()

int ts::AbstractDemux::demuxId ( ) const
inlineinherited

Get the "demux id" value, as previously stored by the application.

Returns
The application-defined demux id.

◆ beforeCallingHandler()

void ts::AbstractDemux::beforeCallingHandler ( PID  pid = PID_NULL)
protectedinherited

Helper for subclass, before invoking an application-defined handler.

The idea is to protect the integrity of the demux during the execution of an application-defined handler. The handler is invoked in the middle of an operation but the handler may call reset() or resetPID(). Executing the reset in the middle of an operation may be problematic. By using beforeCallingHandler() and afterCallingHandler(), all reset operations in between are delayed after the execution of the handler.

Example:

try {
_handler->handleEvent(*this, pid, ...);
}
catch (...) {
throw;
}
bool afterCallingHandler(bool executeDelayedOperations=true)
Helper for subclass, after invoking an application-defined handler.
void beforeCallingHandler(PID pid=PID_NULL)
Helper for subclass, before invoking an application-defined handler.
Parameters
[in]pidThe PID for which the handler will be called. All reset operations on this PID will be delayed until afterCallingHandler().

◆ afterCallingHandler()

bool ts::AbstractDemux::afterCallingHandler ( bool  executeDelayedOperations = true)
protectedinherited

Helper for subclass, after invoking an application-defined handler.

Parameters
[in]executeDelayedOperationsWhen true (the default), execute all pending reset operations.
Returns
True if a delayed reset was executed.
See also
beforeCallingHandler()

The documentation for this class was generated from the following file: