h264_reader/
annexb.rs

1//! A reader for the NAL Unit framing format defined in _ITU-T Recommendation H.264 - Annex B_,
2//! as used when H264 data is embedded in an MPEG2 Transport Stream
3
4use log::*;
5use memchr;
6
7use crate::push::{AccumulatedNalHandler, NalAccumulator, NalFragmentHandler};
8
9/// The current state, named for the most recently examined byte.
10#[derive(Debug)]
11enum ParseState {
12    Start,
13    StartOneZero,
14    StartTwoZero,
15    InUnit,
16    InUnitOneZero,
17    InUnitTwoZero,
18}
19impl ParseState {
20    /// If in a NAL unit (`NalReader`'s `start` has been called but not its `end`),
21    /// returns an object describing the state.
22    fn in_unit(&self) -> Option<InUnitState> {
23        match *self {
24            ParseState::Start => None,
25            ParseState::StartOneZero => None,
26            ParseState::StartTwoZero => None,
27            ParseState::InUnit => Some(InUnitState { backtrack_bytes: 0 }),
28            ParseState::InUnitOneZero => Some(InUnitState { backtrack_bytes: 1 }),
29            ParseState::InUnitTwoZero => Some(InUnitState { backtrack_bytes: 2 }),
30        }
31    }
32}
33
34struct InUnitState {
35    /// The number of bytes to backtrack if the current sequence of `0x00`s
36    /// doesn't end the NAL unit.
37    backtrack_bytes: usize,
38}
39
40/// Push parser for Annex B format which delegates to a [NalFragmentHandler], most commonly a
41/// [NalAccumulator]:
42///
43/// ```
44/// use h264_reader::annexb::AnnexBReader;
45/// use h264_reader::nal::{Nal, RefNal, UnitType};
46/// use h264_reader::push::NalInterest;
47///
48/// let mut calls = Vec::new();
49/// let mut reader = AnnexBReader::accumulate(|nal: RefNal<'_>| {
50///     let nal_unit_type = nal.header().unwrap().nal_unit_type();
51///     calls.push((nal_unit_type, nal.is_complete()));
52///     match nal_unit_type {
53///         UnitType::SeqParameterSet => NalInterest::Buffer,
54///         _ => NalInterest::Ignore,
55///     }
56/// });
57///
58/// // Push a couple NALs. Pushes don't have to match up to Annex B framing.
59/// reader.push(&b"\x00\x00"[..]);
60/// reader.push(&b"\x01\x67\x64\x00\x0A\xAC\x72\x84\x44\x26\x84\x00\x00"[..]);
61/// reader.push(&b"\x03\x00\x04\x00\x00\x03\x00\xCA\x3C\x48\x96\x11\x80\x00\x00\x01"[..]);
62/// reader.push(&b"\x68"[..]);
63/// reader.push(&b"\xE8\x43\x8F\x13\x21\x30"[..]);
64///
65/// assert_eq!(calls, &[
66///     (UnitType::SeqParameterSet, false),
67///     (UnitType::SeqParameterSet, true),
68///     (UnitType::PicParameterSet, false),
69///     // no second call on the PicParameterSet because the handler returned Ignore.
70/// ]);
71/// ```
72///
73/// See [NalAccumulator] for an example with a handler that *owns* state.
74///
75/// When corruption is detected, the `AnnexbReader` logs error and recovers on
76/// the next start code boundary.
77///
78/// Guarantees that the bytes supplied to [`NalFragmentHandler`]—the concatenation of all
79/// `buf`s supplied to `NalFragmentHandler::nal_fragment`—will be exactly the same for a given
80/// Annex B stream, regardless of boundaries of `AnnexBReader::push` calls.
81pub struct AnnexBReader<H: NalFragmentHandler> {
82    state: ParseState,
83    inner: H,
84}
85impl<H: AccumulatedNalHandler> AnnexBReader<NalAccumulator<H>> {
86    /// Constructs an `AnnexBReader` with a `NalAccumulator`.
87    pub fn accumulate(inner: H) -> Self {
88        Self::for_fragment_handler(NalAccumulator::new(inner))
89    }
90
91    /// Gets a reference to the underlying [AccumulatedNalHandler].
92    pub fn nal_handler_ref(&self) -> &H {
93        self.inner.handler()
94    }
95
96    /// Gets a mutable reference to the underlying [AccumulatedNalHandler].
97    pub fn nal_handler_mut(&mut self) -> &mut H {
98        self.inner.handler_mut()
99    }
100
101    /// Unwraps the `AnnexBReader<H>`, returning the inner [AccumulatedNalHandler].
102    pub fn into_nal_handler(self) -> H {
103        self.inner.into_handler()
104    }
105}
106impl<H: NalFragmentHandler> AnnexBReader<H> {
107    /// Constructs an `AnnexBReader` with a custom [`NalFragmentHandler`].
108    pub fn for_fragment_handler(inner: H) -> Self {
109        AnnexBReader {
110            state: ParseState::Start,
111            inner,
112        }
113    }
114
115    /// Gets a reference to the underlying [NalFragmentHandler].
116    pub fn fragment_handler_ref(&self) -> &H {
117        &self.inner
118    }
119
120    /// Gets a mutable reference to the underlying [NalFragmentHandler].
121    pub fn fragment_handler_mut(&mut self) -> &mut H {
122        &mut self.inner
123    }
124
125    /// Unwraps the `AnnexBReader<H>`, returning the inner [NalFragmentHandler].
126    pub fn into_fragment_handler(self) -> H {
127        self.inner
128    }
129
130    pub fn push(&mut self, buf: &[u8]) {
131        // When in a NAL unit, start is the first index in buf with a byte to
132        // be pushed. Note that due to backtracking, sometimes 0x00 bytes
133        // must be pushed that logically precede buf.
134        let mut fake_and_start = self.state.in_unit().map(|s| (s.backtrack_bytes, 0));
135
136        let mut i = 0;
137        while i < buf.len() {
138            debug_assert!(fake_and_start.is_some() == self.state.in_unit().is_some());
139            let b = buf[i];
140            match self.state {
141                ParseState::Start => match b {
142                    0x00 => self.to(ParseState::StartOneZero),
143                    _ => self.err(b),
144                },
145                ParseState::StartOneZero => match b {
146                    0x00 => self.to(ParseState::StartTwoZero),
147                    _ => self.err(b),
148                },
149                ParseState::StartTwoZero => {
150                    match b {
151                        0x00 => (), // keep ignoring further 0x00 bytes
152                        0x01 => {
153                            fake_and_start = Some((0, i + 1));
154                            self.to(ParseState::InUnit);
155                        }
156                        _ => self.err(b),
157                    }
158                }
159                ParseState::InUnit => {
160                    let remaining = &buf[i..];
161                    match memchr::memchr(0x00, remaining) {
162                        Some(pos) => {
163                            self.to(ParseState::InUnitOneZero);
164                            i += pos;
165                        }
166                        None => {
167                            // skip to end
168                            i = buf.len();
169                        }
170                    }
171                }
172                ParseState::InUnitOneZero => match b {
173                    0x00 => self.to(ParseState::InUnitTwoZero),
174                    _ => self.to(ParseState::InUnit),
175                },
176                ParseState::InUnitTwoZero => match b {
177                    0x00 => {
178                        self.maybe_emit(buf, fake_and_start, i, 2, true);
179                        fake_and_start = None;
180                        self.to(ParseState::StartTwoZero);
181                    }
182                    0x01 => {
183                        self.maybe_emit(buf, fake_and_start, i, 2, true);
184                        fake_and_start = Some((0, i + 1));
185                        self.to(ParseState::InUnit);
186                    }
187                    _ => self.to(ParseState::InUnit),
188                },
189            }
190            i += 1;
191        }
192        if let Some(in_unit) = self.state.in_unit() {
193            self.maybe_emit(
194                buf,
195                fake_and_start,
196                buf.len(),
197                in_unit.backtrack_bytes,
198                false,
199            );
200        }
201    }
202
203    /// To be invoked when calling code knows that the end of a sequence of NAL Unit data has been
204    /// reached.
205    ///
206    /// For example, if the containing data structure demarcates the end of a sequence of NAL
207    /// Units explicitly, the parser for that structure should call `end_units()` once all data
208    /// has been passed to the `push()` function.
209    pub fn reset(&mut self) {
210        if let Some(in_unit) = self.state.in_unit() {
211            // if we were in the middle of parsing a sequence of 0x00 bytes that might have become
212            // a start-code, but actually reached the end of input, then we will now need to emit
213            // those 0x00 bytes that we had been holding back,
214            if in_unit.backtrack_bytes > 0 {
215                self.inner
216                    .nal_fragment(&[&[0u8; 2][..in_unit.backtrack_bytes]], true);
217            } else {
218                self.inner.nal_fragment(&[], true);
219            }
220        }
221        self.to(ParseState::Start);
222    }
223
224    fn to(&mut self, new_state: ParseState) {
225        self.state = new_state;
226    }
227
228    fn maybe_emit(
229        &mut self,
230        buf: &[u8],
231        fake_and_start: Option<(usize, usize)>,
232        end: usize,
233        backtrack: usize,
234        is_end: bool,
235    ) {
236        match fake_and_start {
237            Some((fake, start)) if start + backtrack < end => {
238                if fake > 0 {
239                    self.inner.nal_fragment(
240                        &[&[0u8; 2][..fake], &buf[start..end - backtrack]][..],
241                        is_end,
242                    );
243                } else {
244                    self.inner
245                        .nal_fragment(&[&buf[start..end - backtrack]][..], is_end);
246                };
247            }
248            Some(_) if is_end => self.inner.nal_fragment(&[], true),
249            _ => {}
250        }
251    }
252
253    fn err(&mut self, b: u8) {
254        error!(
255            "AnnexBReader: state={:?}, invalid byte {:#x}",
256            self.state, b
257        );
258        self.state = ParseState::Start;
259    }
260}
261
262#[cfg(test)]
263mod tests {
264    use super::*;
265    use hex_literal::*;
266
267    #[derive(Default)]
268    struct MockFragmentHandler {
269        ended: u32,
270        data: Vec<u8>,
271    }
272    impl NalFragmentHandler for MockFragmentHandler {
273        fn nal_fragment(&mut self, bufs: &[&[u8]], end: bool) {
274            assert!(!bufs.is_empty() || end);
275            for buf in bufs {
276                self.data.extend_from_slice(buf);
277            }
278            if end {
279                self.ended += 1;
280            }
281        }
282    }
283
284    #[test]
285    fn simple_nal() {
286        let mock = MockFragmentHandler::default();
287        let mut r = AnnexBReader::for_fragment_handler(mock);
288        let data = vec![
289            0, 0, 0, 1, // start-code
290            3, // NAL data
291            0, 0, 1, // end-code
292        ];
293        r.push(&data[..]);
294        let mock = r.into_fragment_handler();
295        assert_eq!(&mock.data[..], &[3u8][..]);
296        assert_eq!(1, mock.ended);
297    }
298
299    #[test]
300    fn short_start_code() {
301        let mock = MockFragmentHandler::default();
302        let mut r = AnnexBReader::for_fragment_handler(mock);
303        let data = vec![
304            0, 0, 1, // start-code -- only three bytes rather than the usual 4
305            3, // NAL data
306            0, 0, 1, // end-code
307        ];
308        r.push(&data[..]);
309        let mock = r.into_fragment_handler();
310        assert_eq!(&mock.data[..], &[3u8][..]);
311        assert_eq!(1, mock.ended);
312    }
313
314    // Several trailing 0x00 0x00 0x03 bytes
315    #[test]
316    fn rbsp_cabac() {
317        let mock = MockFragmentHandler::default();
318        let mut r = AnnexBReader::for_fragment_handler(mock);
319        let data = vec![
320            0, 0, 0, 1,    // start-code
321            3,    // NAL data
322            0x80, // 1 stop-bit + 7 alignment-zero-bits
323            0, 0, 3, // cabac_zero_word + emulation_prevention_three_byte
324            0, 0, 3, // cabac_zero_word + emulation_prevention_three_byte
325            0, 0, 0, 1, // start-code
326        ];
327        r.push(&data[..]);
328        let mock = r.into_fragment_handler();
329        assert_eq!(&mock.data[..], &[3, 0x80, 0, 0, 3, 0, 0, 3][..]);
330        assert_eq!(1, mock.ended);
331    }
332
333    // Several trailing 0x00 bytes
334    #[test]
335    fn trailing_zero() {
336        let mock = MockFragmentHandler::default();
337        let mut r = AnnexBReader::for_fragment_handler(mock);
338        let data = vec![
339            0, 0, 0, 1,    // start-code
340            3,    // NAL data
341            0x80, // 1 stop-bit + 7 alignment-zero-bits
342            0,    // trailing_zero_8bits
343            0,    // trailing_zero_8bits
344            0, 0, 0, 1, // start-code
345        ];
346        r.push(&data[..]);
347        let mock = r.into_fragment_handler();
348        assert_eq!(&mock.data[..], &[3, 0x80][..]);
349        assert_eq!(1, mock.ended);
350    }
351
352    // If there's bad data after a trailing zero, the parser recovers after the next start code.
353    #[test]
354    fn recovery_on_corrupt_trailing_zero() {
355        let mock = MockFragmentHandler::default();
356        let mut r = AnnexBReader::for_fragment_handler(mock);
357        let data = vec![
358            0, 0, 0, 1,    // start-code
359            3,    // NAL data
360            0x80, // 1 stop-bit + 7 alignment-zero-bits
361            0, 0, 0,  // trailing_zero_8bits
362            42, // unexpected byte
363            0, 0, 1, // start-code
364            2, 3,    // NAL data
365            0x80, // 1 stop-bit + 7 alignment-zero-bits
366            0, 0, 1, // start-code
367        ];
368        r.push(&data[..]);
369        let mock = r.into_fragment_handler();
370        assert_eq!(&mock.data[..], &[3, 0x80, 2, 3, 0x80][..]);
371        assert_eq!(2, mock.ended);
372    }
373
374    #[test]
375    fn implicit_end() {
376        let mock = MockFragmentHandler::default();
377        let mut r = AnnexBReader::for_fragment_handler(mock);
378        let data = vec![
379            0, 0, 0, 1, // start-code
380            3, 0, // NAL data
381        ];
382        r.push(&data[..]);
383        r.reset();
384        let mock = r.into_fragment_handler();
385        assert_eq!(&mock.data[..], &[3u8, 0u8][..]);
386        assert_eq!(1, mock.ended);
387    }
388
389    #[test]
390    fn split_nal() {
391        let mock = MockFragmentHandler::default();
392        let mut r = AnnexBReader::for_fragment_handler(mock);
393        let data = vec![
394            0, 0, 0, 1, // start-code
395            2, 3, // NAL data
396            0, 0, 1, // nd-code
397        ];
398        r.push(&data[..5]); // half-way through the NAL Unit
399        let mock = r.fragment_handler_ref();
400        assert_eq!(&mock.data[..], &[2u8][..]);
401        assert_eq!(0, mock.ended);
402        r.push(&data[5..]); // second half of the NAL Unit
403        let mock = r.fragment_handler_ref();
404        assert_eq!(&mock.data[..], &[2u8, 3u8][..]);
405        assert_eq!(1, mock.ended);
406    }
407
408    #[test]
409    fn split_large() {
410        let data = hex!(
411            "00 00 00 01 67 64 00 0A AC 72 84 44 26 84 00 00
412            03 00 04 00 00 03 00 CA 3C 48 96 11 80 00 00 00
413            01 68 E8 43 8F 13 21 30 00 00 01 65 88 81 00 05
414            4E 7F 87 DF 61 A5 8B 95 EE A4 E9 38 B7 6A 30 6A
415            71 B9 55 60 0B 76 2E B5 0E E4 80 59 27 B8 67 A9
416            63 37 5E 82 20 55 FB E4 6A E9 37 35 72 E2 22 91
417            9E 4D FF 60 86 CE 7E 42 B7 95 CE 2A E1 26 BE 87
418            73 84 26 BA 16 36 F4 E6 9F 17 DA D8 64 75 54 B1
419            F3 45 0C 0B 3C 74 B3 9D BC EB 53 73 87 C3 0E 62
420            47 48 62 CA 59 EB 86 3F 3A FA 86 B5 BF A8 6D 06
421            16 50 82 C4 CE 62 9E 4E E6 4C C7 30 3E DE A1 0B
422            D8 83 0B B6 B8 28 BC A9 EB 77 43 FC 7A 17 94 85
423            21 CA 37 6B 30 95 B5 46 77 30 60 B7 12 D6 8C C5
424            54 85 29 D8 69 A9 6F 12 4E 71 DF E3 E2 B1 6B 6B
425            BF 9F FB 2E 57 30 A9 69 76 C4 46 A2 DF FA 91 D9
426            50 74 55 1D 49 04 5A 1C D6 86 68 7C B6 61 48 6C
427            96 E6 12 4C 27 AD BA C7 51 99 8E D0 F0 ED 8E F6
428            65 79 79 A6 12 A1 95 DB C8 AE E3 B6 35 E6 8D BC
429            48 A3 7F AF 4A 28 8A 53 E2 7E 68 08 9F 67 77 98
430            52 DB 50 84 D6 5E 25 E1 4A 99 58 34 C7 11 D6 43
431            FF C4 FD 9A 44 16 D1 B2 FB 02 DB A1 89 69 34 C2
432            32 55 98 F9 9B B2 31 3F 49 59 0C 06 8C DB A5 B2
433            9D 7E 12 2F D0 87 94 44 E4 0A 76 EF 99 2D 91 18
434            39 50 3B 29 3B F5 2C 97 73 48 91 83 B0 A6 F3 4B
435            70 2F 1C 8F 3B 78 23 C6 AA 86 46 43 1D D7 2A 23
436            5E 2C D9 48 0A F5 F5 2C D1 FB 3F F0 4B 78 37 E9
437            45 DD 72 CF 80 35 C3 95 07 F3 D9 06 E5 4A 58 76
438            03 6C 81 20 62 45 65 44 73 BC FE C1 9F 31 E5 DB
439            89 5C 6B 79 D8 68 90 D7 26 A8 A1 88 86 81 DC 9A
440            4F 40 A5 23 C7 DE BE 6F 76 AB 79 16 51 21 67 83
441            2E F3 D6 27 1A 42 C2 94 D1 5D 6C DB 4A 7A E2 CB
442            0B B0 68 0B BE 19 59 00 50 FC C0 BD 9D F5 F5 F8
443            A8 17 19 D6 B3 E9 74 BA 50 E5 2C 45 7B F9 93 EA
444            5A F9 A9 30 B1 6F 5B 36 24 1E 8D 55 57 F4 CC 67
445            B2 65 6A A9 36 26 D0 06 B8 E2 E3 73 8B D1 C0 1C
446            52 15 CA B5 AC 60 3E 36 42 F1 2C BD 99 77 AB A8
447            A9 A4 8E 9C 8B 84 DE 73 F0 91 29 97 AE DB AF D6
448            F8 5E 9B 86 B3 B3 03 B3 AC 75 6F A6 11 69 2F 3D
449            3A CE FA 53 86 60 95 6C BB C5 4E F3"
450        );
451        let expected = hex!(
452            "67 64 00 0A AC 72 84 44 26 84 00 00
453            03 00 04 00 00 03 00 CA 3C 48 96 11 80
454            68 E8 43 8F 13 21 30 65 88 81 00 05
455            4E 7F 87 DF 61 A5 8B 95 EE A4 E9 38 B7 6A 30 6A
456            71 B9 55 60 0B 76 2E B5 0E E4 80 59 27 B8 67 A9
457            63 37 5E 82 20 55 FB E4 6A E9 37 35 72 E2 22 91
458            9E 4D FF 60 86 CE 7E 42 B7 95 CE 2A E1 26 BE 87
459            73 84 26 BA 16 36 F4 E6 9F 17 DA D8 64 75 54 B1
460            F3 45 0C 0B 3C 74 B3 9D BC EB 53 73 87 C3 0E 62
461            47 48 62 CA 59 EB 86 3F 3A FA 86 B5 BF A8 6D 06
462            16 50 82 C4 CE 62 9E 4E E6 4C C7 30 3E DE A1 0B
463            D8 83 0B B6 B8 28 BC A9 EB 77 43 FC 7A 17 94 85
464            21 CA 37 6B 30 95 B5 46 77 30 60 B7 12 D6 8C C5
465            54 85 29 D8 69 A9 6F 12 4E 71 DF E3 E2 B1 6B 6B
466            BF 9F FB 2E 57 30 A9 69 76 C4 46 A2 DF FA 91 D9
467            50 74 55 1D 49 04 5A 1C D6 86 68 7C B6 61 48 6C
468            96 E6 12 4C 27 AD BA C7 51 99 8E D0 F0 ED 8E F6
469            65 79 79 A6 12 A1 95 DB C8 AE E3 B6 35 E6 8D BC
470            48 A3 7F AF 4A 28 8A 53 E2 7E 68 08 9F 67 77 98
471            52 DB 50 84 D6 5E 25 E1 4A 99 58 34 C7 11 D6 43
472            FF C4 FD 9A 44 16 D1 B2 FB 02 DB A1 89 69 34 C2
473            32 55 98 F9 9B B2 31 3F 49 59 0C 06 8C DB A5 B2
474            9D 7E 12 2F D0 87 94 44 E4 0A 76 EF 99 2D 91 18
475            39 50 3B 29 3B F5 2C 97 73 48 91 83 B0 A6 F3 4B
476            70 2F 1C 8F 3B 78 23 C6 AA 86 46 43 1D D7 2A 23
477            5E 2C D9 48 0A F5 F5 2C D1 FB 3F F0 4B 78 37 E9
478            45 DD 72 CF 80 35 C3 95 07 F3 D9 06 E5 4A 58 76
479            03 6C 81 20 62 45 65 44 73 BC FE C1 9F 31 E5 DB
480            89 5C 6B 79 D8 68 90 D7 26 A8 A1 88 86 81 DC 9A
481            4F 40 A5 23 C7 DE BE 6F 76 AB 79 16 51 21 67 83
482            2E F3 D6 27 1A 42 C2 94 D1 5D 6C DB 4A 7A E2 CB
483            0B B0 68 0B BE 19 59 00 50 FC C0 BD 9D F5 F5 F8
484            A8 17 19 D6 B3 E9 74 BA 50 E5 2C 45 7B F9 93 EA
485            5A F9 A9 30 B1 6F 5B 36 24 1E 8D 55 57 F4 CC 67
486            B2 65 6A A9 36 26 D0 06 B8 E2 E3 73 8B D1 C0 1C
487            52 15 CA B5 AC 60 3E 36 42 F1 2C BD 99 77 AB A8
488            A9 A4 8E 9C 8B 84 DE 73 F0 91 29 97 AE DB AF D6
489            F8 5E 9B 86 B3 B3 03 B3 AC 75 6F A6 11 69 2F 3D
490            3A CE FA 53 86 60 95 6C BB C5 4E F3"
491        );
492        for i in 1..data.len() - 1 {
493            let mock = MockFragmentHandler::default();
494            let mut r = AnnexBReader::for_fragment_handler(mock);
495            let (head, tail) = data.split_at(i);
496            r.push(&head[..]);
497            r.push(&tail[..]);
498            r.reset();
499            let mock = r.into_fragment_handler();
500            assert_eq!(3, mock.ended);
501            assert_eq!(&mock.data[..], &expected[..]);
502        }
503    }
504    #[test]
505    fn onebyte_large() {
506        let data = hex!(
507            "00 00 00 01 67 64 00 0A AC 72 84 44 26 84 00 00
508            03 00 04 00 00 03 00 CA 3C 48 96 11 80 00 00 00
509            01 68 E8 43 8F 13 21 30 00 00 01 65 88 81 00 05
510            4E 7F 87 DF 61 A5 8B 95 EE A4 E9 38 B7 6A 30 6A
511            71 B9 55 60 0B 76 2E B5 0E E4 80 59 27 B8 67 A9
512            63 37 5E 82 20 55 FB E4 6A E9 37 35 72 E2 22 91
513            9E 4D FF 60 86 CE 7E 42 B7 95 CE 2A E1 26 BE 87
514            73 84 26 BA 16 36 F4 E6 9F 17 DA D8 64 75 54 B1
515            F3 45 0C 0B 3C 74 B3 9D BC EB 53 73 87 C3 0E 62
516            47 48 62 CA 59 EB 86 3F 3A FA 86 B5 BF A8 6D 06
517            16 50 82 C4 CE 62 9E 4E E6 4C C7 30 3E DE A1 0B
518            D8 83 0B B6 B8 28 BC A9 EB 77 43 FC 7A 17 94 85
519            21 CA 37 6B 30 95 B5 46 77 30 60 B7 12 D6 8C C5
520            54 85 29 D8 69 A9 6F 12 4E 71 DF E3 E2 B1 6B 6B
521            BF 9F FB 2E 57 30 A9 69 76 C4 46 A2 DF FA 91 D9
522            50 74 55 1D 49 04 5A 1C D6 86 68 7C B6 61 48 6C
523            96 E6 12 4C 27 AD BA C7 51 99 8E D0 F0 ED 8E F6
524            65 79 79 A6 12 A1 95 DB C8 AE E3 B6 35 E6 8D BC
525            48 A3 7F AF 4A 28 8A 53 E2 7E 68 08 9F 67 77 98
526            52 DB 50 84 D6 5E 25 E1 4A 99 58 34 C7 11 D6 43
527            FF C4 FD 9A 44 16 D1 B2 FB 02 DB A1 89 69 34 C2
528            32 55 98 F9 9B B2 31 3F 49 59 0C 06 8C DB A5 B2
529            9D 7E 12 2F D0 87 94 44 E4 0A 76 EF 99 2D 91 18
530            39 50 3B 29 3B F5 2C 97 73 48 91 83 B0 A6 F3 4B
531            70 2F 1C 8F 3B 78 23 C6 AA 86 46 43 1D D7 2A 23
532            5E 2C D9 48 0A F5 F5 2C D1 FB 3F F0 4B 78 37 E9
533            45 DD 72 CF 80 35 C3 95 07 F3 D9 06 E5 4A 58 76
534            03 6C 81 20 62 45 65 44 73 BC FE C1 9F 31 E5 DB
535            89 5C 6B 79 D8 68 90 D7 26 A8 A1 88 86 81 DC 9A
536            4F 40 A5 23 C7 DE BE 6F 76 AB 79 16 51 21 67 83
537            2E F3 D6 27 1A 42 C2 94 D1 5D 6C DB 4A 7A E2 CB
538            0B B0 68 0B BE 19 59 00 50 FC C0 BD 9D F5 F5 F8
539            A8 17 19 D6 B3 E9 74 BA 50 E5 2C 45 7B F9 93 EA
540            5A F9 A9 30 B1 6F 5B 36 24 1E 8D 55 57 F4 CC 67
541            B2 65 6A A9 36 26 D0 06 B8 E2 E3 73 8B D1 C0 1C
542            52 15 CA B5 AC 60 3E 36 42 F1 2C BD 99 77 AB A8
543            A9 A4 8E 9C 8B 84 DE 73 F0 91 29 97 AE DB AF D6
544            F8 5E 9B 86 B3 B3 03 B3 AC 75 6F A6 11 69 2F 3D
545            3A CE FA 53 86 60 95 6C BB C5 4E F3"
546        );
547        let expected = hex!(
548            "67 64 00 0A AC 72 84 44 26 84 00 00
549            03 00 04 00 00 03 00 CA 3C 48 96 11 80
550            68 E8 43 8F 13 21 30 65 88 81 00 05
551            4E 7F 87 DF 61 A5 8B 95 EE A4 E9 38 B7 6A 30 6A
552            71 B9 55 60 0B 76 2E B5 0E E4 80 59 27 B8 67 A9
553            63 37 5E 82 20 55 FB E4 6A E9 37 35 72 E2 22 91
554            9E 4D FF 60 86 CE 7E 42 B7 95 CE 2A E1 26 BE 87
555            73 84 26 BA 16 36 F4 E6 9F 17 DA D8 64 75 54 B1
556            F3 45 0C 0B 3C 74 B3 9D BC EB 53 73 87 C3 0E 62
557            47 48 62 CA 59 EB 86 3F 3A FA 86 B5 BF A8 6D 06
558            16 50 82 C4 CE 62 9E 4E E6 4C C7 30 3E DE A1 0B
559            D8 83 0B B6 B8 28 BC A9 EB 77 43 FC 7A 17 94 85
560            21 CA 37 6B 30 95 B5 46 77 30 60 B7 12 D6 8C C5
561            54 85 29 D8 69 A9 6F 12 4E 71 DF E3 E2 B1 6B 6B
562            BF 9F FB 2E 57 30 A9 69 76 C4 46 A2 DF FA 91 D9
563            50 74 55 1D 49 04 5A 1C D6 86 68 7C B6 61 48 6C
564            96 E6 12 4C 27 AD BA C7 51 99 8E D0 F0 ED 8E F6
565            65 79 79 A6 12 A1 95 DB C8 AE E3 B6 35 E6 8D BC
566            48 A3 7F AF 4A 28 8A 53 E2 7E 68 08 9F 67 77 98
567            52 DB 50 84 D6 5E 25 E1 4A 99 58 34 C7 11 D6 43
568            FF C4 FD 9A 44 16 D1 B2 FB 02 DB A1 89 69 34 C2
569            32 55 98 F9 9B B2 31 3F 49 59 0C 06 8C DB A5 B2
570            9D 7E 12 2F D0 87 94 44 E4 0A 76 EF 99 2D 91 18
571            39 50 3B 29 3B F5 2C 97 73 48 91 83 B0 A6 F3 4B
572            70 2F 1C 8F 3B 78 23 C6 AA 86 46 43 1D D7 2A 23
573            5E 2C D9 48 0A F5 F5 2C D1 FB 3F F0 4B 78 37 E9
574            45 DD 72 CF 80 35 C3 95 07 F3 D9 06 E5 4A 58 76
575            03 6C 81 20 62 45 65 44 73 BC FE C1 9F 31 E5 DB
576            89 5C 6B 79 D8 68 90 D7 26 A8 A1 88 86 81 DC 9A
577            4F 40 A5 23 C7 DE BE 6F 76 AB 79 16 51 21 67 83
578            2E F3 D6 27 1A 42 C2 94 D1 5D 6C DB 4A 7A E2 CB
579            0B B0 68 0B BE 19 59 00 50 FC C0 BD 9D F5 F5 F8
580            A8 17 19 D6 B3 E9 74 BA 50 E5 2C 45 7B F9 93 EA
581            5A F9 A9 30 B1 6F 5B 36 24 1E 8D 55 57 F4 CC 67
582            B2 65 6A A9 36 26 D0 06 B8 E2 E3 73 8B D1 C0 1C
583            52 15 CA B5 AC 60 3E 36 42 F1 2C BD 99 77 AB A8
584            A9 A4 8E 9C 8B 84 DE 73 F0 91 29 97 AE DB AF D6
585            F8 5E 9B 86 B3 B3 03 B3 AC 75 6F A6 11 69 2F 3D
586            3A CE FA 53 86 60 95 6C BB C5 4E F3"
587        );
588        let mock = MockFragmentHandler::default();
589        let mut r = AnnexBReader::for_fragment_handler(mock);
590        for i in 0..data.len() {
591            r.push(&data[i..i + 1]);
592        }
593        r.reset();
594        let mock = r.into_fragment_handler();
595        assert_eq!(3, mock.ended);
596        assert_eq!(&mock.data[..], &expected[..]);
597    }
598}
h264_reader/annexb.rs

h264_reader/
annexb.rs
