libmpegts 0.3.4

MPEG-TS Library
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
112
113
114
115
116
117
118
119
120
121

#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
pub struct Timestamp(u64);

impl Timestamp {
    /// Maximum valid value (33 bits)
    pub const MAX: u64 = (1 << 33) - 1;

    /// 90 kHz clock per millisecond
    pub const CLOCK_MS: u64 = 90;

    pub const fn new(value: u64) -> Self {
        Self(value & Self::MAX)
    }

    pub const fn value(&self) -> u64 {
        self.0
    }

    pub const fn wrapping_add(self, v: Self) -> Self {
        Self(self.0.wrapping_add(v.0) & Self::MAX)
    }

    pub const fn wrapping_sub(self, v: Self) -> Self {
        Self(self.0.wrapping_sub(v.0) & Self::MAX)
    }

    /// Circular comparison.
    /// Returns true if self is before other
    pub fn is_before(self, other: Self) -> bool {
        let diff = self.wrapping_sub(other).value();
        diff > (Self::MAX >> 1)
    }

    /// Writes the timestamp into a 5-byte buffer with the given marker (PTS or DTS)
    /// Returns the number of bytes written (always 5)
    ///
    /// Markers:
    /// - 0b0011 for PTS with following DTS
    /// - 0b0010 for PTS only
    /// - 0b0001 for DTS only
    pub fn write(&self, buf: &mut [u8], marker: u8) -> usize {
        buf[0] = (marker << 4) | ((self.0 >> 29) & 0x0E) as u8 | 0x01;
        buf[1] = (self.0 >> 22) as u8;
        buf[2] = ((self.0 >> 14) & 0xFE) as u8 | 0x01;
        buf[3] = (self.0 >> 7) as u8;
        buf[4] = ((self.0 << 1) & 0xFE) as u8 | 0x01;
        5
    }

    /// Reads a timestamp from a 5-byte PES timestamp field with the expected marker.
    pub fn read(buf: &[u8], marker: u8) -> Option<Self> {
        if buf.len() < 5 {
            return None;
        }

        if (buf[0] >> 4) != marker
            || (buf[0] & 0x01) == 0
            || (buf[2] & 0x01) == 0
            || (buf[4] & 0x01) == 0
        {
            return None;
        }

        let b0 = ((buf[0] & 0x0E) >> 1) as u64;
        let b1 = buf[1] as u64;
        let b2 = ((buf[2] & 0xFE) >> 1) as u64;
        let b3 = buf[3] as u64;
        let b4 = ((buf[4] & 0xFE) >> 1) as u64;

        Some(Self::new(
            (b0 << 30) | (b1 << 22) | (b2 << 15) | (b3 << 7) | b4,
        ))
    }
}

impl From<u64> for Timestamp {
    fn from(value: u64) -> Self {
        Self::new(value)
    }
}

impl From<Timestamp> for u64 {
    fn from(ts: Timestamp) -> Self {
        ts.0
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct PtsDts {
    pub pts: Timestamp,
    pub dts: Option<Timestamp>,
}

impl PtsDts {
    pub fn new(pts: impl Into<Timestamp>) -> Self {
        Self {
            pts: pts.into(),
            dts: None,
        }
    }

    pub fn with_dts(mut self, dts: impl Into<Timestamp>) -> Self {
        self.dts = Some(dts.into());
        self
    }

    /// Returns DTS if present, otherwise PTS.
    /// Used for scheduling (decode order).
    pub fn timestamp(&self) -> Timestamp {
        self.dts.unwrap_or(self.pts)
    }
}

impl From<(u64, Option<u64>)> for PtsDts {
    fn from((pts, dts): (u64, Option<u64>)) -> Self {
        Self {
            pts: pts.into(),
            dts: dts.map(Timestamp::from),
        }
    }
}