dvb-si

ETSI EN 300 468 DVB Service Information parser and builder, plus the MPEG-2 PSI tables it builds on, the DVB-allocated companion tables, and the DSM-CC data carousel.

Complete coverage: every allocated table_id in EN 300 468 V1.19.1 Table 2 (29 section types; 28 dispatched by AnyTableSection + the type-keyed MPE datagram view) and every allocated descriptor_tag in Table 12 (0x40–0x7F, 64 descriptors) is implemented, each with a symmetric Parse / Serialize pair and round-trip tests. Layouts are derived from the ETSI specs (vendored in the repo and transcribed into reviewable markdown) and validated against live broadcast captures.

MSRV: 1.81. no_std + alloc supported — disable the default std feature for embedded targets (non-Latin text charsets and wall-clock time require std).

API model

dvb-si makes the PSI/SI layering explicit:

• Section parsers are named *Section: PatSection, NitSection, SdtSection, SitSection, EitSection, and so on. Each value is exactly one wire section and still borrows from the input bytes where possible.
• AnyTableSection dispatches one complete section by table_id. Demux events expose this through SectionEvent::table_section().
• collect::SectionSetCollector assembles every long-form multi-section table using the common section_number / last_section_number fields. A completed set owns the original section bytes and can be parsed generically: complete.table::<PatSection>().
• collect::CompleteNit, CompleteBat, CompleteSdt, and CompleteEit add flattened logical-table views where that is more useful than a vector of sections. Their descriptor loops are parsed through AnyDescriptor while the raw descriptor-loop bytes remain available.
• collect::EitCollector handles the EIT schedule rule that spans table IDs through last_table_id; ordinary section-number collection is not enough for schedule EIT. EIT schedule sub-tables version independently, and the collector exposes clear() / retain_logical() for long-running EPG pruning.
• epg::EpgStore (feature chrono) builds an electronic programme guide over EitCollector: deduplicated, time-ordered events with decoded short and extended (§6.2.15 fragment-concatenated) text, content/ratings/CRIDs, now_and_next(key, at), SDT service-name join, and services() to enumerate.
• resync::TsResync recovers 188-byte (and 204-byte Reed-Solomon) packet alignment from an arbitrary byte stream — junk prefixes, mid-stream loss.
• TsPacket::adaptation_field() decodes the adaptation field: discontinuity / random-access flags, PCR & OPCR (Pcr::as_27mhz()), and splice countdown.
• mux::SectionPacketizer / mux::SiMux are the byte-exact inverse: pack serialized section bytes back into 188-byte TS packets (ISO/IEC 13818-1 §2.4.4).
• TableId variants use Rust CamelCase names (TableId::Pat, TableId::NetworkInformationActual, TableId::MpeFec), while section parser types carry the Section suffix.

Quickstart

use dvb_si::demux::SiDemux;
use dvb_si::descriptors::AnyDescriptor;
use dvb_si::tables::AnyTableSection;

let mut demux = SiDemux::builder().build();

// In real code, `packet` is each aligned 188-byte packet from your TS source
// (file, UDP, tuner). See `dvb-tools dump` for a complete file-reading CLI.
for event in demux.feed(&packet) {
    match event.table_section() {
        Ok(AnyTableSection::SdtSection(sdt)) => {
            for service in &sdt.services {
                for item in service.descriptors.iter().flatten() {
                    if let AnyDescriptor::Service(svc) = item {
                        // DvbText decodes EN 300 468 Annex A -> UTF-8.
                        println!("service: {}", svc.service_name.decode());
                    }
                }
            }
        }
        Ok(AnyTableSection::PatSection(pat)) => {
            println!("PAT v{} on {}", event.version().unwrap_or(0), event.pid());
        }
        _ => {}
    }
}

See dvb-tools dump for a complete file-reading CLI (cargo run -p dvb-tools -- dump file.ts [--json]).

Layer map

TS packets ──► demux::SiDemux ──► SectionEvent
                                    │ .table_section()
                                    ▼
                              tables::AnyTableSection  (PatSection, SdtSection, …)
                                    │ section.<loop field> : DescriptorLoop
                                    ▼
                          descriptors::parse_loop ──► AnyDescriptor
                                    │ field : DvbText / LangCode
                                    ▼
                              text::DvbText::decode() ──► UTF-8 String

SectionEvent.bytes() ──► collect::SectionSetCollector ──► CompleteSectionSet
                                                         │ .table::<T>()
                                                         ├ .nit() / .bat() / .sdt() / .eit()
                                                         ▼
                                                   complete logical tables

serialized sections ──► mux::SectionPacketizer ──► 188-byte TS packets

Section coverage

28 table_ids are dispatched by AnyTableSection::parse; MpeDatagramSection (0x3E) is reachable via AnyTableSection::parse_as as noted below. Every section parser has typed header fields, symmetric parse/serialize, and round-trip tests. Per the crate's zero-copy convention, descriptor loops and repeated sub-structures borrow from the input bytes. Flat descriptor loops are DescriptorLoop values that walk into typed descriptors; notes below call out only tables that go further or deliberately keep a nested structure raw.

Remaining table_id values are reserved or user-defined in EN 300 468 V1.19.1 Table 2 — there is nothing standardized left to implement.

Descriptors

71 descriptor tags are dispatched by AnyDescriptor (via DescriptorLoop::iter / parse_loop): 6 MPEG-2/DSM-CC tags, 64 DVB-allocated tags (0x40–0x7F), and the de-facto private logical_channel_descriptor (0x83) — which exists as a variant but is not auto-dispatched (register it via DescriptorRegistry with PDS context). Unknown or unregistered tags pass through as AnyDescriptor::Unknown { tag, body } — the raw payload is preserved and round-trips losslessly.

MPEG-2 / DSM-CC descriptors (ISO/IEC 13818-1 / -6)

DVB descriptors (EN 300 468, and companion specs)

All 64 allocated tags 0x40–0x7F from EN 300 468 V1.19.1 Table 12 are implemented. Each parses into a typed struct with a symmetric serializer and round-trip tests; any free-form byte fields (names, selector tails) stay borrowed &[u8] per the crate's zero-copy convention.

Private descriptors

Extension descriptor registry (tag 0x7F)

The first payload byte (descriptor_tag_extension) selects a sub-descriptor (EN 300 468 §6.4). 21 tag_extensions are fully typed; everything else is preserved byte-exact as ExtensionBody::Raw and round-trips losslessly. Private descriptor_tag_extension values are surfaced via DescriptorLoop::iter_with_extensions(&desc_reg, &ext_reg) as ExtIterItem::CustomExtension.

Tags whose governing spec is not vendored (0x01–0x03 CPCM, 0x0C XAIT_PID, 0x0E/0x0F/0x21 DTS family, 0x14 CI_ancillary, 0x18 protection_message) are preserved as ExtensionBody::Raw and round-trip byte-exact.

DSM-CC data carousel

The carousel module types the download-protocol payloads carried inside DSM-CC sections (ISO/IEC 13818-6 §7.2/§7.3 as profiled by DVB — TR 101 202, TS 102 006 SSU, TS 102 809 object carousels):

The BIOP object-carousel layer (carousel::biop) is also implemented: ServiceGatewayInfo, BiopMessage (Directory / File / ServiceGateway / Stream / StreamEvent), IOR + tagged profiles, and the CarouselFs virtual-file-tree walker (resolve / file_bytes); ISO/IEC 13818-6 §11 as profiled by TR 101 202.

Validated byte-exact against a live French-TNT (M6 HbbTV) capture in the test suite.

Text decoding

Full EN 300 468 Annex A Table A.3 selector coverage:

Annex A.1 control codes are honored for both the single-byte (0x80–0x9F) and two-byte (U+E080–U+E09F PUA, Table A.2) tables: emphasis markers dropped, CR/LF → space, reserved controls stripped.

The non-Latin charsets (encoding_rs) require the std feature.

Typed dispatch

You rarely match table_ids or descriptor_tags by hand. AnyTableSection::parse dispatches a complete section to the right typed section parser; a section's descriptor-loop field is a DescriptorLoop whose .iter() yields AnyDescriptor values (typed where known, Unknown otherwise, never panicking — parse_loop does the same for a free byte slice). DescriptorRegistry lets you plug in private descriptors at runtime, TableRegistry does the same for private table_ids, and ExtensionRegistry handles private tag-extension sub-descriptors (tag 0x7F). All are generated from a single declarative list so the dispatcher can never drift from the implemented set.

use dvb_si::descriptors::AnyDescriptor;

for item in eit_event.descriptors.iter() {       // DescriptorLoop::iter()
    match item? {
        AnyDescriptor::ShortEvent(se) => println!("{}", se.event_name.decode()),
        AnyDescriptor::Unknown { tag, .. } => eprintln!("unknown 0x{tag:02X}"),
        _ => {}
    }
}

Multi-section collection and EPG

use dvb_si::collect::{CompletedEit, EitCollector, SectionSetCollector};
use dvb_si::demux::SiDemux;
use dvb_si::tables::eit;
use dvb_si::tables::nit::{self, NitSection};

let mut demux = SiDemux::builder().build();
let mut nit_sections = SectionSetCollector::new();
let mut eit_sections = EitCollector::new();

for event in demux.feed(&packet) {
    match event.table_id() {
        nit::TABLE_ID_ACTUAL | nit::TABLE_ID_OTHER => {
            if let Some(complete) = nit_sections
                .push_section_with_pid(Some(event.pid().value()), event.bytes())
                .ok()
                .flatten()
            {
                let nit = complete.nit()?;            // flattened logical NIT
                let raw = complete.table::<NitSection>()?; // generic section view
                let _ = (nit, raw);
            }
        }
        eit::TABLE_ID_PF_ACTUAL..=eit::TABLE_ID_SCHEDULE_OTHER_LAST => {
            if let Some(done) = eit_sections
                .push_section_with_pid(Some(event.pid().value()), event.bytes())
                .ok()
                .flatten()
            {
                match done {
                    CompletedEit::PresentFollowing(set) => {
                        let eit = set.eit()?;
                        let _ = eit;
                    }
                    CompletedEit::Schedule(schedule) => {
                        for table in schedule.tables()? {
                            let _ = table.events;
                        }
                    }
                }
            }
        }
        _ => {}
    }
}

// Long-running EPG collectors can prune old state.
eit_sections.retain_logical(|key| application_still_needs(key));

Owning parsed views across threads (feature yoke)

Zero-copy parsed types borrow the input slice via <'a>. The optional yoke feature bundles the backing bytes and the borrowing view into one 'static, cheaply-Clone, Send + Sync value via the [yoke] crate:

use std::sync::Arc;
use dvb_si::{owned::Owned, tables::pmt::PmtSection};
use dvb_common::Parse;

let bytes: Arc<[u8]> = Arc::from(section);             // own the section
let pmt: Owned<PmtSection<'static>> = Owned::try_new(bytes, |b| PmtSection::parse(b))?;
let view: &PmtSection = pmt.get();                            // no re-parse, no lifetime

Features

[dependencies]
dvb-si = { version = "7", default-features = false }  # tight build: no_std + alloc

serde is Serialize-only — for display/export (JSON via serde_json); parsing FROM JSON is deliberately unsupported — re-parse from the wire bytes.

Principles

• Spec fidelity. Every field in a section's syntax appears in the parsed struct.
• Parse and construct. Every parser has a symmetric serializer; round-trip is tested.
• Zero-copy where possible. Parsed types borrow from the input via <'a> lifetimes.
• No magic numbers. Every hex literal outside #[cfg(test)] is a named constant or enum.

Spec grounding

Every layout is cited. The repo vendors the ETSI PDFs and transcribes their syntax tables into reviewable markdown (docs/) — each spec below links both the ETSI deliverable and the in-repo transcription:

The crate has been through five adversarial spec-audit rounds; fixture tests run against real transponder captures.

Upgrading

For 3.x → 4.0, see MIGRATION-4.0.md: section parser renames, AnyTableSection, table_section(), CamelCase TableId, and multi-section collection. For older breaks, see MIGRATION-3.1.md and MIGRATION-2.0.md.

Family

dvb-common — traits + CRC-32
dvb-t2mi — T2-MI, all 12 packet types
dvb-bbframe — S2/S2X/T2 BBFRAME
dvb-conformance — TR 101 290 monitor
dvb-tools — CLI: dump / services / epg / pids / t2mi
For GSE see the existing dvb-gse crate.

License

Licensed under either of MIT or Apache-2.0, at your option.