libmpegts 0.3.2

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

use super::PsiSectionError;

/// Reference to a single MPEG-TS descriptor (tag + length + data).
#[derive(Debug, Clone, Copy)]
pub struct DescriptorRef<'a>(&'a [u8]);

impl<'a> DescriptorRef<'a> {
    pub fn tag(&self) -> u8 {
        self.0[0]
    }

    pub fn data(&self) -> &'a [u8] {
        &self.0[2 ..]
    }

    pub fn bytes(&self) -> &'a [u8] {
        self.0
    }
}

/// Reference to a list of MPEG-TS descriptors.
pub struct DescriptorsRef<'a>(&'a [u8]);

impl<'a> From<&'a [u8]> for DescriptorsRef<'a> {
    fn from(value: &'a [u8]) -> Self {
        DescriptorsRef(value)
    }
}

impl<'a> IntoIterator for DescriptorsRef<'a> {
    type Item = Result<DescriptorRef<'a>, PsiSectionError>;
    type IntoIter = DescriptorIter<'a>;

    fn into_iter(self) -> Self::IntoIter {
        DescriptorIter {
            data: self.0,
            offset: 0,
        }
    }
}

/// Iterator over MPEG-TS descriptors.
pub struct DescriptorIter<'a> {
    data: &'a [u8],
    offset: usize,
}

impl<'a> Iterator for DescriptorIter<'a> {
    type Item = Result<DescriptorRef<'a>, PsiSectionError>;

    fn next(&mut self) -> Option<Self::Item> {
        if self.offset >= self.data.len() {
            return None;
        }
        if self.offset + 2 > self.data.len() {
            return Some(Err(PsiSectionError::InvalidDescriptorLength));
        }
        let end = self.offset + 2 + self.data[self.offset + 1] as usize;
        if end > self.data.len() {
            return Some(Err(PsiSectionError::InvalidDescriptorLength));
        }
        let desc = DescriptorRef(&self.data[self.offset .. end]);
        self.offset = end;
        Some(Ok(desc))
    }
}