mpeg-ts 0.7.0

MPEG-2 Transport Stream framing (ITU-T H.222.0 / ISO/IEC 13818-1): TS packet, adaptation field, PCR, PSI section reassembly + packetisation, resync. no_std.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

//! Error type returned by every parser and builder in this crate.

use thiserror::Error;

/// Crate-wide result alias.
pub type Result<T> = core::result::Result<T, Error>;

/// Error variants that parsers + builders can return.
///
/// Spec references inside `#[error(...)]` strings quote clauses from
/// ITU-T H.222.0 (= ISO/IEC 13818-1) where applicable.
#[derive(Debug, Error, PartialEq, Eq, Clone)]
#[non_exhaustive]
pub enum Error {
    /// Input buffer was shorter than the smallest valid encoding for the type.
    #[error(transparent)]
    BufferTooShort(#[from] broadcast_common::error::BufferTooShort),

    /// CRC-32 validation failed for a table section.
    #[error(transparent)]
    CrcMismatch(#[from] broadcast_common::error::CrcMismatch),

    /// A fixed marker did not match (TS sync byte, expected `0x47`).
    #[error(transparent)]
    InvalidSync(#[from] broadcast_common::error::InvalidSync),

    /// Write buffer passed to `serialize_into` was smaller than `serialized_len()`.
    #[error(transparent)]
    OutputBufferTooSmall(#[from] broadcast_common::error::OutputBufferTooSmall),

    /// A `section_length` declared more bytes than the containing buffer could hold.
    #[error("section_length {declared} exceeds remaining buffer ({available} bytes)")]
    SectionLengthOverflow {
        /// Length bytes declared inside the section header.
        declared: usize,
        /// Bytes actually available after the header.
        available: usize,
    },

    /// A payload was longer than a single TS packet's fixed payload capacity
    /// (see `OwnedTsPacket::serialize_with_payload`, #1129).
    #[error("payload {len} bytes exceeds the {max}-byte TS packet payload capacity")]
    PayloadTooLarge {
        /// The payload length that did not fit.
        len: usize,
        /// The maximum payload capacity.
        max: usize,
    },

    /// A length or count field's value does not fit its wire field
    /// (see `broadcast_common::len`, #1129).
    #[error(transparent)]
    FieldOverflow(#[from] broadcast_common::len::FieldOverflow),

    /// `Section::payload` did not match what `section_length` implies (see
    /// `Section::serialize_into`, #1074 W5). Serializing a hand-built
    /// `Section` whose fields disagree used to index past `serialized_len()`
    /// and panic (or write the CRC over payload bytes) instead of erroring.
    #[error(
        "section payload is {actual} bytes but section_length ({section_length}) implies {expected}"
    )]
    SectionPayloadLengthMismatch {
        /// `section_length` field the caller set.
        section_length: u16,
        /// Payload length `section_length` implies (accounting for the
        /// extension header + CRC on long-form sections).
        expected: usize,
        /// Actual `payload.len()`.
        actual: usize,
    },
}