flowly-mpegts 0.2.2

Mpeg2Ts format streaming parser
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
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

use crate::mpegts::{
    legal_time_window::LegalTimeWindow,
    piecewise_rate::PiecewiseRate,
    seamless_splice::SeamlessSplice,
    timestamp::{Clock, PCR, Timestamp},
};

/// Adaptation field.
#[allow(missing_docs)]
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct AdaptationField {
    /// Set `true` if current TS packet is in a discontinuity state with respect to
    /// either the continuity counter or the program clock reference.
    pub discontinuity_indicator: bool,

    /// Set `true` when the stream may be decoded without errors from this point.
    pub random_access_indicator: bool,

    /// Set `true` when this stream should be considered "high priority".
    pub es_priority_indicator: bool,

    pub pcr: Option<Timestamp<Clock<PCR>>>,
    pub opcr: Option<Timestamp<Clock<PCR>>>,

    /// Indicates how many TS packets from this one a splicing point occurs.
    pub splice_countdown: Option<i8>,

    pub transport_private_data: Vec<u8>,
    pub extension: Option<AdaptationExtensionField>,
}

impl AdaptationField {
    pub fn external_size(&self) -> usize {
        let mut n = 1 /* adaptation_field_len */ + 1 /* flags */;
        if self.pcr.is_some() {
            n += 6;
        }

        if self.opcr.is_some() {
            n += 6;
        }

        if self.splice_countdown.is_some() {
            n += 1;
        }

        n += self.transport_private_data.len();
        if let Some(ref x) = self.extension {
            n += x.external_size();
        }

        n
    }
}

/// Adaptation extension field.
#[allow(missing_docs)]
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct AdaptationExtensionField {
    pub legal_time_window: Option<LegalTimeWindow>,
    pub piecewise_rate: Option<PiecewiseRate>,
    pub seamless_splice: Option<SeamlessSplice>,
}

impl AdaptationExtensionField {
    fn external_size(&self) -> usize {
        let mut n = 1 /* length */ + 1 /* flags */;
        if self.legal_time_window.is_some() {
            n += 2;
        }

        if self.piecewise_rate.is_some() {
            n += 3;
        }

        if self.seamless_splice.is_some() {
            n += 5;
        }

        n
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
#[repr(u8)]
pub enum AdaptationFieldControl {
    Reserved = 0b00,
    PayloadOnly = 0b01,
    AdaptationFieldOnly = 0b10,
    AdaptationFieldAndPayload = 0b11,
    Unknown(u8),
}
impl AdaptationFieldControl {
    pub fn has_adaptation_field(&self) -> bool {
        *self != AdaptationFieldControl::PayloadOnly
    }

    pub fn has_payload(&self) -> bool {
        *self != AdaptationFieldControl::AdaptationFieldOnly
    }

    pub fn from_u8(n: u8) -> Self {
        match n {
            0b00 => AdaptationFieldControl::Reserved,
            0b01 => AdaptationFieldControl::PayloadOnly,
            0b10 => AdaptationFieldControl::AdaptationFieldOnly,
            0b11 => AdaptationFieldControl::AdaptationFieldAndPayload,
            v => AdaptationFieldControl::Unknown(v),
        }
    }
}