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.

4.0 API model

dvb-si 4.0 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.
• TableId variants use Rust CamelCase names (TableId::Pat, TableId::NetworkInformationActual, TableId::MpeFec), while section parser types carry the Section suffix.

There are no 3.x compatibility aliases in 4.0. See MIGRATION-4.0.md for before/after examples.

Section coverage

Every section parser: typed header fields, symmetric parse/serialize, round-trip tested. 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.

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):

Validated byte-exact against a live French-TNT (M6 HbbTV) capture in the test suite. BIOP object-carousel payloads above this layer are out of scope.

Descriptors

Every allocated descriptor_tag in EN 300 468 V1.19.1 Table 12 (0x40–0x7F) is implemented — plus the MPEG-2 descriptors that matter in SI context and the de-facto private logical_channel_descriptor. Each parses into a typed struct with a symmetric serializer and round-trip tests; any unallocated/unknown tag passes through as raw bytes (tag + payload preserved). Per the crate's zero-copy convention, free-form byte fields (names, selector tails) stay borrowed &[u8]; notes below only where a sub-structure is deliberately kept raw.

Extension descriptor registry (tag 0x7F)

The first payload byte (descriptor_tag_extension) selects a sub-descriptor (EN 300 468 §6.4). A body is typed only when its syntax table is vendored under docs/; everything else is preserved byte-exact as Raw and round-trips losslessly.

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.

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.

Demux in 10 lines

Feed 188-byte TS packets to [SiDemux]; it filters by PID, reassembles sections, validates CRCs, follows the PAT to PMT PIDs, and version-gates so a steady carousel emits each changed section only once. You get a SectionEvent per changed section:

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

let mut demux = SiDemux::builder().build();
for packet in ts_packets {                      // each aligned 188-byte packet
    for event in demux.feed(&packet) {          // changed sections only
        if let Ok(AnyTableSection::PatSection(pat)) = event.table_section() {
            println!("PAT v{} on {}", event.version().unwrap_or(0), event.pid());
            let _ = pat;
        }
    }
}

See examples/si_dump.rs for a complete file-reading CLI (cargo run -p dvb-si --example si_dump -- file.ts [--json]).

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); and DescriptorRegistry lets you plug in private descriptors at runtime. 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}"),
        _ => {}
    }
}

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.

Usage

use dvb_common::Parse;
use dvb_si::tables::sdt::SdtSection;

// `section_bytes`: one complete SDT section, e.g. from `SectionReassembler`.
let sdt = SdtSection::parse(section_bytes)?;
for service in &sdt.services {
    println!("service_id = {}", service.service_id);
}

Collect all sections for a logical table before using table-wide fields. In a live stream, collector errors are section-scoped: log/drop that input section and keep feeding later sections unless your application chooses strict failure.

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 => {
            let collected = match nit_sections.push_section_with_pid(
                Some(event.pid().value()),
                event.bytes(),
            ) {
                Ok(collected) => collected,
                Err(error) => {
                    eprintln!("dropping bad SI section: {error}");
                    continue;
                }
            };
            if let Some(complete) = collected {
                let nit = complete.nit()?;        // flattened logical NIT
                let raw_sections = complete.table::<NitSection>()?; // generic section view
                let _ = (nit, raw_sections);
            }
        }
        eit::TABLE_ID_PF_ACTUAL..=eit::TABLE_ID_SCHEDULE_OTHER_LAST => {
            let collected = match eit_sections.push_section_with_pid(
                Some(event.pid().value()),
                event.bytes(),
            ) {
                Ok(collected) => collected,
                Err(error) => {
                    eprintln!("dropping bad EIT section: {error}");
                    continue;
                }
            };
            if let Some(done) = collected {
                match done {
                    CompletedEit::PresentFollowing(set) => {
                        let eit = set.eit()?;     // one p/f EIT section set
                        let _ = eit;
                    }
                    CompletedEit::Schedule(schedule) => {
                        for (table_id, version) in schedule.table_versions() {
                            println!("completed EIT schedule 0x{table_id:02X} v{version}");
                        }
                        for table in schedule.tables()? {
                            let _ = table.events;
                        }
                    }
                }
            }
        }
        _ => {}
    }
}

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

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.

Features

Default: chrono (MJD+BCD → DateTime<Utc>), ts (TS packet + SectionReassembler), serde.

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

Optional (off by default):

yoke — yoke::Yokeable on every zero-copy view type plus an Owned<T> wrapper, so you can own a parsed view past the input buffer's borrow (store it in a struct field, a cache, a watch/broadcast channel, or send it across a thread) without re-parsing or a hand-written mirror type:

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

dvb-si = { version = "4.0", default-features = false }  # tight build

Family

dvb-common — traits + CRC-32
dvb-t2mi — T2-MI, all 12 packet types
dvb-bbframe — S2/S2X/T2 BBFRAME
For GSE see the existing dvb-gse crate.

License

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