pub fn end_units(&mut self, ctx: &mut Context<Ctx>) {
        if let Some(backtrack) = self.state.end_backtrack_bytes() {
            // if we were in the middle of parsing a sequence of 0x00 bytes that might have become
            // a start-code, but actually reached the end of input, then we will now need to emit
            // those 0x00 bytes that we had been holding back,
            if backtrack > 0 {
                let tmp = [0u8; 3];
                self.nal_reader.push(ctx, &tmp[0..backtrack]);
            }
        }
        self.to(ParseState::End);
        self.nal_reader.end(ctx);
    }
/// To be invoked when calling code knows that the end of a sequence of NAL Unit data has been
/// reached.
///
/// For example, if the containing data structure demarcates the end of a sequence of NAL
/// Units explicitly, the parser for that structure should call `end_units()` once all data
/// has been passed to the `push()` function.
To be invoked when calling code knows that the end of a sequence of NAL Unit data has been
reached.

For example, if the containing data structure demarcates the end of a sequence of NAL
Units explicitly, the parser for that structure should call `end_units()` once all data
has been passed to the `push()` function.
To be invoked when calling code knows that the end of a sequence of NAL Unit data has been reached . For example if the containing data structure demarcates the end of a sequence of NAL Units explicitly the parser for that structure should call ` end_units () ` once all data has been passed to the ` push () ` function .
pub fn end_units(&mut self, ctx: &mut Context<Ctx>) {
        if let Some(backtrack) = self.state.end_backtrack_bytes() {
            // if we were in the middle of parsing a sequence of 0x00 bytes that might have become
            // a start-code, but actually reached the end of input, then we will now need to emit
            // those 0x00 bytes that we had been holding back,
            if backtrack > 0 {
                let tmp = [0u8; 3];
                self.nal_reader.push(ctx, &tmp[0..backtrack]);
            }
        }
        self.to(ParseState::End);
        self.nal_reader.end(ctx);
    }
pub fn end_units ( & mut self , ctx : & mut Context < Ctx > ) { if let Some ( backtrack ) = self . state . end_backtrack_bytes ( ) { // if we were in the middle of parsing a sequence of 0x00 bytes that might have become // a start-code, but actually reached the end of input, then we will now need to emit // those 0x00 bytes that we had been holding back, if backtrack > 0 { let tmp = [ 0u8 ; 3 ] ; self . nal_reader . push ( ctx , & tmp [ 0 .. backtrack ] ) ; } } self . to ( ParseState :: End ) ; self . nal_reader . end ( ctx ) ; }
To be invoked when calling code knows that the end of a sequence of NAL Unit data has been
reached.
To be invoked when calling code knows that the end of a sequence of NAL Unit data has been reached .
&mut self
ctx
&mut Context<Ctx>
&mut self
ctx
&mut Context<Ctx>