Add support for parsing access_unit_delimiter_rbsp()

Author: dholroyd

CHANGELOG.md

@@ -13,6 +13,7 @@
 *   Add `Profile::CavlcIntra444` (profile_idc 44) and `Profile::MFCHigh` (profile_idc 134) enum variants.
 *   Parse AvcC extension fields (`chroma_format`, `bit_depth_luma_minus8`, `bit_depth_chroma_minus8`, SPS extension NAL units) for High profile and above.
 *   Add `slice_group_change_cycle`, `slice_alpha_c0_offset_div2` and `slice_beta_offset_div2 to `SliceHeader`
+*   Parse `access_unit_delimiter_rbsp()` (NAL type 9) via new `aud::AccessUnitDelimiter`.
 *   Parse `seq_parameter_set_extension_rbsp()` (NAL type 13) via new `sps_extension::SeqParameterSetExtension`.
 *   Parse `subset_seq_parameter_set_rbsp()` (NAL type 15) via new `subset_sps::SubsetSps`, including SVC extension (profiles 83/86) and MVC extension (profiles 118/128/134).
 *   Add `Context::put_subset_seq_param_set()`, `Context::subset_sps_by_id()`, and `Context::subset_sps()` for managing subset SPS state.

examples/dump.rs

@@ -1,4 +1,5 @@
 use h264_reader::annexb::AnnexBReader;
+use h264_reader::nal::aud::AccessUnitDelimiter;
 use h264_reader::nal::pps::PicParameterSet;
 use h264_reader::nal::sei::buffering_period::BufferingPeriod;
 use h264_reader::nal::sei::pic_timing::PicTiming;
@@ -128,6 +129,12 @@ fn main() {
                     }
                 }
             }
+            UnitType::AccessUnitDelimiter => {
+                match AccessUnitDelimiter::from_bits(nal.rbsp_bits()) {
+                    Ok(aud) => println!("{:#?}", aud),
+                    Err(e) => println!("AUD error: {:?}", e),
+                }
+            }
             UnitType::SeqParameterSetExtension => {
                 hex_dump(&nal);
                 match SeqParameterSetExtension::from_bits(nal.rbsp_bits()) {

fuzz/fuzz_targets/fuzz_target_1.rs

@@ -2,7 +2,7 @@
 use libfuzzer_sys::fuzz_target;
 use h264_reader::annexb::AnnexBReader;
 use h264_reader::Context;
-use h264_reader::nal::{Nal, RefNal, UnitType, pps, slice, sei, sps, sps_extension, subset_sps};
+use h264_reader::nal::{Nal, RefNal, UnitType, aud, pps, slice, sei, sps, sps_extension, subset_sps};
 use h264_reader::push::NalInterest;
 
 fuzz_target!(|data: &[u8]| {
@@ -45,6 +45,9 @@ fuzz_target!(|data: &[u8]| {
             UnitType::SliceLayerWithoutPartitioningIdr | UnitType::SliceLayerWithoutPartitioningNonIdr => {
                 let _ = slice::SliceHeader::from_bits(&ctx, &mut nal.rbsp_bits(), hdr);
             },
+            UnitType::AccessUnitDelimiter => {
+                let _ = aud::AccessUnitDelimiter::from_bits(nal.rbsp_bits());
+            },
             UnitType::SeqParameterSetExtension => {
                 let _ = sps_extension::SeqParameterSetExtension::from_bits(nal.rbsp_bits());
             },

src/nal/aud.rs

@@ -0,0 +1,119 @@
+//! Parser for `access_unit_delimiter_rbsp()` (NAL type 9, spec 7.3.2.4).
+
+use crate::rbsp::BitRead;
+use std::fmt;
+
+/// Indicates which slice types may be present in the primary coded picture
+/// of the access unit (Table 7-5).
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum PrimaryPicType {
+    /// I slices only
+    I = 0,
+    /// I, P slices
+    IP = 1,
+    /// I, P, B slices
+    IPB = 2,
+    /// SI slices only
+    SI = 3,
+    /// SI, SP slices
+    SISP = 4,
+    /// I, SI slices
+    ISI = 5,
+    /// I, SI, P, SP slices
+    ISIPSP = 6,
+    /// I, SI, P, SP, B slices
+    ISIPSPB = 7,
+}
+
+/// Error returned when a `primary_pic_type` value is out of range.
+#[derive(Debug)]
+pub struct PrimaryPicTypeError(pub u8);
+
+impl fmt::Display for PrimaryPicTypeError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "invalid primary_pic_type value: {}", self.0)
+    }
+}
+
+impl PrimaryPicType {
+    pub fn from_id(id: u8) -> Result<PrimaryPicType, PrimaryPicTypeError> {
+        match id {
+            0 => Ok(PrimaryPicType::I),
+            1 => Ok(PrimaryPicType::IP),
+            2 => Ok(PrimaryPicType::IPB),
+            3 => Ok(PrimaryPicType::SI),
+            4 => Ok(PrimaryPicType::SISP),
+            5 => Ok(PrimaryPicType::ISI),
+            6 => Ok(PrimaryPicType::ISIPSP),
+            7 => Ok(PrimaryPicType::ISIPSPB),
+            _ => Err(PrimaryPicTypeError(id)),
+        }
+    }
+
+    pub fn id(self) -> u8 {
+        self as u8
+    }
+}
+
+/// Parsed `access_unit_delimiter_rbsp()` (NAL unit type 9).
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct AccessUnitDelimiter {
+    pub primary_pic_type: PrimaryPicType,
+}
+
+impl AccessUnitDelimiter {
+    pub fn from_bits<R: BitRead>(mut r: R) -> Result<AccessUnitDelimiter, AudError> {
+        let val: u8 = r.read(3, "primary_pic_type")?;
+        let primary_pic_type =
+            PrimaryPicType::from_id(val).map_err(AudError::InvalidPrimaryPicType)?;
+        r.finish_rbsp()?;
+        Ok(AccessUnitDelimiter { primary_pic_type })
+    }
+}
+
+/// Error type for AUD parsing.
+#[derive(Debug)]
+pub enum AudError {
+    InvalidPrimaryPicType(PrimaryPicTypeError),
+    RbspError(crate::rbsp::BitReaderError),
+}
+
+impl From<crate::rbsp::BitReaderError> for AudError {
+    fn from(e: crate::rbsp::BitReaderError) -> Self {
+        AudError::RbspError(e)
+    }
+}
+
+impl fmt::Display for AudError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            AudError::InvalidPrimaryPicType(e) => write!(f, "{}", e),
+            AudError::RbspError(e) => write!(f, "{:?}", e),
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use crate::rbsp::BitReader;
+
+    #[test]
+    fn parse_all_pic_types() {
+        for id in 0u8..=7 {
+            // primary_pic_type(3 bits) + rbsp_stop_one_bit(1) + padding(4 zeros)
+            let byte = (id << 5) | 0x10;
+            let data = [byte];
+            let aud = AccessUnitDelimiter::from_bits(BitReader::new(&data[..])).unwrap();
+            assert_eq!(aud.primary_pic_type.id(), id);
+        }
+    }
+
+    #[test]
+    fn parse_ipb() {
+        // primary_pic_type=2 (IPB): 010 1 0000 = 0x50
+        let data = [0x50u8];
+        let aud = AccessUnitDelimiter::from_bits(BitReader::new(&data[..])).unwrap();
+        assert_eq!(aud.primary_pic_type, PrimaryPicType::IPB);
+    }
+}

src/nal/mod.rs

@@ -4,6 +4,7 @@
 //! [`RbspDecoder`](../rbsp/struct.RbspDecoder.html)), where it has been encoded with
 //! 'emulation prevention bytes'.
 
+pub mod aud;
 pub mod pps;
 pub mod sei;
 pub mod slice;