go-astits

To use the library in your Go projects, install it using go get. To install the provided command-line executables (astits-probe and astits-es-split), install the cmd package.

Note: The library is not yet production ready. Use at your own risk.

# Install the library
go get -u github.com/asticode/go-astits/...

# Install the CLI executables
go install github.com/asticode/go-astits/cmd

The PSIData struct represents the parsed Program-Specific Information. It consists of a PointerField (used for packet alignment) and a slice of PSISection pointers.

Each PSISection contains:

• CRC32: A checksum of the table (excluding the pointer field, filler, and the CRC itself).
• Header: A PSISectionHeader containing metadata like TableID and SectionLength.
• Syntax: A PSISectionSyntax containing the actual table data (e.g., PAT, PMT, NIT, etc.) and its syntax header.

type PSIData struct {
	PointerField int // Present at the start of the TS packet payload
	Sections     []*PSISection
}

type PSISection struct {
	CRC32  uint32
	Header *PSISectionHeader
	Syntax *PSISectionSyntax
}

A PacketSkipper is a function type used to filter out unwanted packets from the pipeline before they are processed. The function receives the parsed header and adaptation field of the packet.

Signature: type PacketSkipper func(p *Packet) (skip bool)

If the function returns true, the packet is skipped, and NextPacket() will automatically attempt to return the next unskipped packet.

skipper := func(p *astits.Packet) bool {
	// Example: skip packets with a specific PID if needed
	return p.Pid == 0x123
}

dmx, _ := astits.NewDemuxer(ctx, r, astits.DemuxerOptPacketSkipper(skipper))

The Packet type represents a single MPEG transport stream packet. It consists of a header, an optional adaptation field, and the payload content.

Key components:

• Header: Contains metadata like PID, continuity counter, and scrambling control.
• AdaptationField: An optional field containing clock references (PCR/OPCR), splicing information, or stuffing bytes.
• Payload: The actual data content of the packet (excluding the header and adaptation field).

type Packet struct {
	AdaptationField *PacketAdaptationField
	Header          PacketHeader
	Payload         []byte // This is only the payload content
}

A PacketsParser allows you to define how a sequence of packets is converted into DemuxerData. This is useful if you need to handle specific payload types or custom parsing logic.

Signature: type PacketsParser func(ps []*Packet) (ds []*DemuxerData, skip bool, err error)

• ps: A slice of packets containing a unique payload.
• ds: The resulting slice of DemuxerData objects.
• skip: If true, indicates the default processing should be skipped.
• err: Any error encountered during parsing.

parser := func(ps []*astits.Packet) ([]*astits.DemuxerData, bool, error) {
	// custom parsing logic here
	return ds, false, nil
}

dmx, _ := astits.NewDemuxer(ctx, r, astits.DemuxerOptPacketsParser(parser))

The astits-probe tool executes different logic based on the first positional argument provided:

• data: Iterates through the stream using dmx.NextData() and logs specific MPEG data structures. You can filter which types are logged using the -d flag.
• packets: Iterates through the stream using dmx.NextPacket() and logs detailed header information for every packet (PID, Continuity Counter, etc.).
• default (or any other string): Scans the stream to build a list of Program objects, including their Map IDs, descriptors, and elementary streams. Output can be formatted as json using the -f flag.

The Descriptor struct is the primary container for parsed MPEG descriptor data. It contains a Tag field indicating the descriptor type and several optional pointers to specific descriptor types (e.g., AC3, AVCVideo, Service). When a descriptor is parsed, the pointer corresponding to its Tag will be non-nil.

// Example conceptual usage
if desc.Tag == astits.DescriptorTagService {
    // Access service-specific data
    if desc.Service != nil {
        fmt.Printf("Service Name: %s\n", string(desc.Service.Name))
    }
}

To demultiplex (demux) a transport stream, use astits.NewDemuxer. It requires a context.Context for cancellation and an io.Reader (using bufio.Reader is recommended for performance). You can iterate through the stream using dmx.NextData() to retrieve parsed data segments, such as PMT (Program Map Table) data.

// Create a cancellable context
ctx, cancel := context.WithCancel(context.Background())

// Open your file or initialize any kind of io.Reader
f, _ := os.Open("/path/to/file.ts")
defer f.Close()

// Create the demuxer
dmx := astits.NewDemuxer(ctx, f)
for {
    // Get the next data
    d, _ := dmx.NextData()
    
    // Example: Handle PMT data
    if d.PMT != nil {
        for _, es := range d.PMT.ElementaryStreams {
            fmt.Printf("Stream detected: %d\n", es.ElementaryPID)
        }
        return
    }
}

You can customize the behavior of the demuxer or muxer by passing functional options to NewDemuxer or NewMuxer. Look for methods prefixed with DemuxerOpt or MuxerOpt.

Example: Providing a custom packet parser using DemuxerOptPacketsParser.

// This is your custom packets parser
p := func(ps []*astits.Packet) (ds []*astits.Data, skip bool, err error) {
    // Your logic here
    skip = true
    return
}

// Create a demuxer with custom options
dmx := astits.NewDemuxer(ctx, f, astits.DemuxerOptPacketSize(192), astits.DemuxerOptPacketsParser(p))

The Demuxer can be customized using several functional options passed to NewDemuxer:

• DemuxerOptLogger(l astikit.StdLogger): Sets a custom logger.
• DemuxerOptPacketSize(packetSize int): Sets the expected size of a single packet (e.g., 188).
• DemuxerOptPacketsParser(p PacketsParser): Provides a custom function to parse sets of packets into DemuxerData.
• DemuxerOptPacketSkipper(s PacketSkipper): Provides a function to filter out specific packets before they are parsed.

opts := []func(*astits.Demuxer){
	astits.DemuxerOptPacketSize(188),
	astits.DemuxerOptPacketSkipper(func(p *astits.Packet) bool {
		// return true to skip the packet
		return false
	}),
}
dmx, err := astits.NewDemuxer(ctx, reader, opts...)