MVP example parsing NALs about h264-reader HOT 3 CLOSED

// First we have to create a context to keep track of SPS and PPS NALs that we receive. It *needs* to be persistent through all parsing
let mut stream_context = Context::new();

// Then we prepare an AnnexBReader to handle the parsed data
let mut reader = AnnexBReader::accumulate(|nal: RefNal<'_>| {
    // We only ever want to parse complete NALs.
    // You can filter for the specific types of NALs you're
    // interested in and NalInterest::Ignore the rest here.
    //
    // If a NAL is incomplete, trying to read its data will result in a WouldBlock.
    if !nal.is_complete() {
        return NalInterest::Buffer;
    }

    // Parse the NAL header, so we know what the NAL type is
    let nal_header = nal.header().unwrap();
    let nal_unit_type = nal_header.nal_unit_type();

    // Decode the NAL types that we're interested in
    match nal_unit_type {
        UnitType::SeqParameterSet => {
            let data = SeqParameterSet::from_bits(nal.rbsp_bits()).unwrap();
            // Don't forget to tell stream_context that we have a new SPS.
            // If you want to handle it separately, you can clone the struct before passing along,
            // But if you only care about it when a slice calls for it, you don't have to handle it here.
            stream_context.put_seq_param_set(data);
        }
        UnitType::PicParameterSet => {
            // Same as when parsing an SPS, except it borrows the stream context so it can pick out
            // the SPS that this PPS references
            let data = PicParameterSet::from_bits(&stream_context, nal.rbsp_bits()).unwrap();
            // Same as with an SPS, tell the context that we've found a PPS
            stream_context.put_pic_param_set(data);
        }
        // Let's handle a random slice type too to see how that works
        UnitType::SliceLayerWithoutPartitioningIdr => {
            let mut bits = nal.rbsp_bits();
            // We can parse the slice header, and it will give us:
            let (header, // The header of the slice
                seq_params, // A borrow of the SPS...
                pic_params // ...and PPS activated by the header
            ) = SliceHeader::from_bits(&stream_context,
                                       &mut bits, // takes a mutable borrow so the body parser can continue from where this ended
                                       nal_header).unwrap();
            // I don't think any slice data parsers are implemented right now.
        }
        other => {println!("Unhandled {other:?}")}
    }
    NalInterest::Ignore
});

// Push data. Doesn't have to be aligned in any way. You can push multiple times for a single NAL, or send an entire file in at once.
reader.push(data);
// If we're sure that the entire current NAL has been pushed, then we can call this to signal
// that the parser should immediately stop waiting for a new NAL marker.
reader.reset();