diff --git a/Cargo.lock b/Cargo.lock
index 852a5ff..751402f 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -843,6 +843,7 @@ dependencies = [
  "serde_with",
  "sha-1",
  "sha2",
+ "smallvec",
  "strum",
  "strum_macros",
  "thiserror 2.0.17",
diff --git a/backend/Cargo.toml b/backend/Cargo.toml
index 125462d..375d740 100644
--- a/backend/Cargo.toml
+++ b/backend/Cargo.toml
@@ -16,6 +16,9 @@ mrp = { git = "https://github.com/signalapp/ringrtc", tag = "v2.59.1" }
 calling_common = { path = "../common" }
 metrics = { path = "../metrics" }
 
+# For small, inline collections
+smallvec = "1.15.1"
+
 # For error handling
 anyhow = "1.0.100"
 thiserror = "2.0.17"
diff --git a/backend/fuzz/Cargo.toml b/backend/fuzz/Cargo.toml
index 76c31d5..f11c283 100644
--- a/backend/fuzz/Cargo.toml
+++ b/backend/fuzz/Cargo.toml
@@ -60,6 +60,12 @@ path = "fuzz_targets/googcc.rs"
 test = false
 doc = false
 
+[[bin]]
+name = "dependency-descriptor"
+path = "fuzz_targets/dependency_descriptor.rs"
+test = false
+doc = false
+
 # keep in sync with workspace patches
 [patch.crates-io]
 # Use our fork of curve25519-dalek because we're using zkgroup.
diff --git a/backend/fuzz/fuzz_targets/dependency_descriptor.rs b/backend/fuzz/fuzz_targets/dependency_descriptor.rs
new file mode 100644
index 0000000..a84b8a7
--- /dev/null
+++ b/backend/fuzz/fuzz_targets/dependency_descriptor.rs
@@ -0,0 +1,14 @@
+//
+// Copyright 2021 Signal Messenger, LLC
+// SPDX-License-Identifier: AGPL-3.0-only
+//
+
+#![no_main]
+
+use calling_backend::*;
+use libfuzzer_sys::fuzz_target;
+
+fuzz_target!(|data: Vec<u8>| {
+    _ = rtp::DependencyDescriptor::read(&data, None);
+});
+
diff --git a/backend/src/bitstream.rs b/backend/src/bitstream.rs
new file mode 100644
index 0000000..00695b4
--- /dev/null
+++ b/backend/src/bitstream.rs
@@ -0,0 +1,425 @@
+//
+// Copyright 2026 Signal Messenger, LLC
+// SPDX-License-Identifier: AGPL-3.0-only
+//
+
+use anyhow::bail;
+use smallvec::SmallVec;
+
+#[derive(Debug)]
+pub struct BitstreamReader<'a> {
+    bytes: &'a [u8],
+    /// The index into `bytes` of the next byte to read.
+    byte_index: usize,
+    /// The offset into `bytes[byte_index]` of the next bit to read. In the range 0..=7.
+    bit_offset: u8,
+}
+
+impl<'a> BitstreamReader<'a> {
+    pub fn new(bytes: &'a [u8]) -> Self {
+        Self {
+            bytes,
+            byte_index: 0,
+            bit_offset: 0,
+        }
+    }
+
+    pub fn read_u64(&mut self, bits: usize) -> anyhow::Result<u64> {
+        assert!(bits <= 64);
+        let mut result = 0;
+        if bits > 0 {
+            let byte_count = bits / 8;
+            if byte_count > 0 {
+                result |= u64::from(self.read_u8(8)?);
+                for _ in 0..byte_count - 1 {
+                    result <<= 8;
+                    result |= u64::from(self.read_u8(8)?);
+                }
+            }
+            let bits_left = bits - (byte_count * 8);
+            result <<= bits_left;
+            result |= u64::from(self.read_u8(bits_left as u8)?);
+        }
+        Ok(result)
+    }
+
+    pub fn read_u32(&mut self, bits: usize) -> anyhow::Result<u32> {
+        assert!(bits <= 32);
+        self.read_u64(bits).map(|v| v as u32)
+    }
+
+    pub fn read_u16(&mut self, bits: usize) -> anyhow::Result<u16> {
+        assert!(bits <= 16);
+        self.read_u64(bits).map(|v| v as u16)
+    }
+
+    /// An implementation of the `f(n)` function in the spec, where 0 < n <= 8:
+    /// https://aomediacodec.github.io/av1-rtp-spec/#a82-syntax
+    pub fn read_u8(&mut self, bits: u8) -> anyhow::Result<u8> {
+        if bits == 0 {
+            return Ok(0);
+        }
+
+        assert!(bits <= 8);
+
+        let bytes_len = self.bytes.len();
+        if self.byte_index >= bytes_len
+            || (self.bit_offset + bits > 8 && self.byte_index + 1 == bytes_len)
+        {
+            bail!(
+                "out of bounds access: byte_index={}, bit_offset={}, bits={bits}, bytes_len={}",
+                self.byte_index,
+                self.bit_offset,
+                bytes_len,
+            );
+        }
+
+        let mut byte: u8;
+        if self.bit_offset + bits >= 8 {
+            // Need to read the remainder of the current byte, and potentially some of the
+            // following byte.
+            byte = self.bytes[self.byte_index];
+
+            let num_bits_in_current_byte = 8 - self.bit_offset;
+            if num_bits_in_current_byte < 8 {
+                byte &= (1 << num_bits_in_current_byte) - 1;
+            }
+            let num_bits_in_next_byte = bits - num_bits_in_current_byte;
+            byte <<= num_bits_in_next_byte;
+
+            if num_bits_in_next_byte > 0 {
+                let next_byte = self.bytes[self.byte_index + 1];
+                let mask = ((1 << num_bits_in_next_byte) - 1) << (8 - num_bits_in_next_byte);
+                byte |= (next_byte & mask) >> (8 - num_bits_in_next_byte);
+            }
+
+            self.byte_index += 1;
+            self.bit_offset = (self.bit_offset + bits) % 8;
+        } else {
+            // Only need to look at the current byte.
+            byte = self.bytes[self.byte_index];
+            byte &= ((1 << bits) - 1) << (8 - self.bit_offset - bits);
+            byte >>= 8 - self.bit_offset - bits;
+
+            self.bit_offset += bits;
+        }
+
+        Ok(byte)
+    }
+
+    pub fn read_non_symmetric(&mut self, n: u8) -> anyhow::Result<u8> {
+        let mut w = 0;
+        let mut x = n;
+        while x != 0 {
+            x >>= 1;
+            w += 1;
+        }
+
+        let m = (1 << w) - n;
+        let v = self.read_u8(w - 1)?;
+        if v < m {
+            return Ok(v);
+        }
+
+        let extra_bit = self.read_u8(1)?;
+        Ok((v << 1) - m + extra_bit)
+    }
+
+    pub fn has_more(&mut self) -> bool {
+        self.byte_index < self.bytes.len()
+    }
+
+    pub fn zero_pad(&mut self) {
+        if self.bit_offset > 0 {
+            self.bit_offset = 0;
+            self.byte_index += 1;
+        }
+    }
+
+    /// An implementation of https://aomediacodec.github.io/av1-spec/#leb128
+    pub fn read_leb128(&mut self) -> anyhow::Result<u128> {
+        let mut value = 0;
+        for i in 0..8 {
+            let byte = self.read_u8(8)? as u128;
+            value |= (byte & 0x7f) << (i * 7);
+            if byte & 0x80 == 0 {
+                break;
+            }
+        }
+        Ok(value)
+    }
+}
+
+macro_rules! impl_bit_writer_for_type {
+    ($type:ty, $func_name:ident) => {
+        pub fn $func_name(&mut self, value: $type, bits: usize) {
+            if bits > 0 {
+                let len = std::mem::size_of::<$type>();
+                assert!(bits <= len * 8);
+                let bytes = value.to_be_bytes();
+                let index = (len * 8 - bits) / 8;
+                let topmost_bits = bits - (len - index - 1) * 8;
+                self.write_u8(bytes[index], topmost_bits);
+                for i in index + 1..len {
+                    self.write_u8(bytes[i], 8);
+                }
+            }
+        }
+    };
+}
+
+#[derive(Debug, Default)]
+pub struct BitstreamWriter<const N: usize> {
+    storage: SmallVec<[u8; N]>,
+    free_bits: usize,
+}
+
+impl<const N: usize> BitstreamWriter<N> {
+    impl_bit_writer_for_type!(u16, write_u16);
+    impl_bit_writer_for_type!(u32, write_u32);
+    impl_bit_writer_for_type!(u64, write_u64);
+
+    fn push_bits(&mut self, value: u8, bits: usize) {
+        let i = self.storage.len() - 1;
+        self.free_bits -= bits;
+        self.storage[i] |= value << self.free_bits;
+    }
+
+    fn extend(&mut self) {
+        self.storage.push(0);
+        self.free_bits = 8;
+    }
+
+    pub fn write_u8(&mut self, value: u8, bits: usize) {
+        if bits > 0 {
+            if self.free_bits == 0 {
+                self.extend();
+                self.push_bits(value, bits);
+            } else if bits <= self.free_bits {
+                self.push_bits(value, bits);
+            } else {
+                let overflow = bits - self.free_bits;
+                self.push_bits(value >> overflow, self.free_bits);
+                self.extend();
+                self.push_bits(value & ((1 << overflow) - 1), overflow);
+            }
+        }
+    }
+
+    pub fn write(&mut self, bytes: &[u8]) {
+        for byte in bytes {
+            self.write_u8(*byte, 8);
+        }
+    }
+
+    pub fn write_padding(&mut self) {
+        self.write_u8(0, self.free_bits);
+    }
+
+    pub fn write_non_symmetric(&mut self, n: usize, v: u8) {
+        if n == 1 {
+            return;
+        }
+        let mut w = 0;
+        let mut x = n;
+        while x != 0 {
+            x >>= 1;
+            w += 1;
+        }
+        let m = (1 << w) - n as u8;
+        if v < m {
+            self.write_u8(v, w - 1);
+        } else {
+            self.write_u8(v + m, w);
+        }
+    }
+
+    pub fn len(&self) -> usize {
+        8 * self.storage.len() + 8 - self.free_bits
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.storage.is_empty() && self.free_bits == 8
+    }
+
+    pub fn as_slice(&self) -> &[u8] {
+        self.storage.as_slice()
+    }
+}
+
+#[cfg(test)]
+mod bitstream_reader_tests {
+    use super::*;
+
+    #[test]
+    fn read_u8() -> anyhow::Result<()> {
+        let bytes = [0b0000_0010, 0b1010_0000];
+        let mut rdr = BitstreamReader::new(&bytes);
+
+        assert_eq!(rdr.read_u8(1)?, 0);
+
+        rdr.bit_offset = 1;
+        assert_eq!(rdr.read_u8(1)?, 0);
+
+        rdr.bit_offset = 6;
+        assert_eq!(rdr.read_u8(1)?, 1);
+
+        rdr.bit_offset = 3;
+        assert_eq!(rdr.read_u8(5)?, 0b10);
+
+        rdr.byte_index = 0;
+        rdr.bit_offset = 6;
+        assert_eq!(rdr.read_u8(3)?, 0b101);
+
+        Ok(())
+    }
+
+    #[test]
+    fn read_u8_error() -> anyhow::Result<()> {
+        let bytes = [];
+        let mut rdr = BitstreamReader::new(&bytes);
+        assert!(!rdr.has_more());
+        assert!(rdr.read_u8(8).is_err());
+        assert!(rdr.read_u8(1).is_err());
+
+        let bytes = [0b1000_0000];
+        let mut rdr = BitstreamReader::new(&bytes);
+        assert!(rdr.has_more());
+        assert_eq!(rdr.read_u8(1)?, 1);
+
+        assert!(rdr.has_more());
+        assert!(rdr.read_u8(8).is_err());
+
+        assert_eq!(rdr.read_u8(1)?, 0);
+        assert!(rdr.has_more());
+        assert!(rdr.read_u8(8).is_err());
+        assert!(rdr.read_u8(7).is_err());
+
+        assert_eq!(rdr.read_u8(1)?, 0);
+        assert!(rdr.has_more());
+        assert!(rdr.read_u8(8).is_err());
+        assert!(rdr.read_u8(7).is_err());
+        assert!(rdr.read_u8(6).is_err());
+
+        assert_eq!(rdr.read_u8(1)?, 0);
+        assert!(rdr.has_more());
+        assert!(rdr.read_u8(8).is_err());
+        assert!(rdr.read_u8(7).is_err());
+        assert!(rdr.read_u8(6).is_err());
+        assert!(rdr.read_u8(5).is_err());
+
+        assert_eq!(rdr.read_u8(1)?, 0);
+        assert!(rdr.has_more());
+        assert!(rdr.read_u8(8).is_err());
+        assert!(rdr.read_u8(7).is_err());
+        assert!(rdr.read_u8(6).is_err());
+        assert!(rdr.read_u8(5).is_err());
+        assert!(rdr.read_u8(4).is_err());
+
+        assert_eq!(rdr.read_u8(1)?, 0);
+        assert!(rdr.has_more());
+        assert!(rdr.read_u8(8).is_err());
+        assert!(rdr.read_u8(7).is_err());
+        assert!(rdr.read_u8(6).is_err());
+        assert!(rdr.read_u8(5).is_err());
+        assert!(rdr.read_u8(4).is_err());
+        assert!(rdr.read_u8(3).is_err());
+
+        assert_eq!(rdr.read_u8(1)?, 0);
+        assert!(rdr.has_more());
+        assert!(rdr.read_u8(8).is_err());
+        assert!(rdr.read_u8(7).is_err());
+        assert!(rdr.read_u8(6).is_err());
+        assert!(rdr.read_u8(5).is_err());
+        assert!(rdr.read_u8(4).is_err());
+        assert!(rdr.read_u8(3).is_err());
+        assert!(rdr.read_u8(2).is_err());
+
+        assert_eq!(rdr.read_u8(1)?, 0);
+        assert!(!rdr.has_more());
+        assert!(rdr.read_u8(8).is_err());
+        assert!(rdr.read_u8(7).is_err());
+        assert!(rdr.read_u8(6).is_err());
+        assert!(rdr.read_u8(5).is_err());
+        assert!(rdr.read_u8(4).is_err());
+        assert!(rdr.read_u8(3).is_err());
+        assert!(rdr.read_u8(2).is_err());
+        assert!(rdr.read_u8(1).is_err());
+
+        Ok(())
+    }
+
+    #[test]
+    fn read_u8_two_bytes() -> anyhow::Result<()> {
+        let bytes = [0b0000_0010, 0b1010_0011];
+        let mut rdr = BitstreamReader::new(&bytes);
+
+        assert_eq!(rdr.read_u8(1)?, 0);
+        assert_eq!(rdr.read_u8(1)?, 0);
+        assert_eq!(rdr.read_u8(5)?, 0b1);
+        assert_eq!(rdr.read_u8(1)?, 0);
+        assert_eq!(rdr.read_u8(4)?, 0b1010);
+        assert_eq!(rdr.read_u8(2)?, 0b0);
+        assert_eq!(rdr.read_u8(1)?, 0b1);
+        assert_eq!(rdr.read_u8(1)?, 0b1);
+
+        assert!(rdr.read_u8(1).is_err());
+
+        Ok(())
+    }
+
+    #[test]
+    fn read_u8_one_byte() -> anyhow::Result<()> {
+        let bytes = [0b0001_1011];
+        let mut rdr = BitstreamReader::new(&bytes);
+
+        assert_eq!(rdr.read_u8(1)?, 0);
+        assert_eq!(rdr.read_u8(1)?, 0);
+        assert_eq!(rdr.read_u8(1)?, 0);
+        assert_eq!(rdr.read_u8(1)?, 1);
+        assert_eq!(rdr.read_u8(1)?, 1);
+        assert_eq!(rdr.read_u8(1)?, 0);
+        assert_eq!(rdr.read_u8(1)?, 1);
+        assert_eq!(rdr.read_u8(1)?, 1);
+
+        rdr.byte_index = 0;
+        rdr.bit_offset = 0;
+        assert_eq!(rdr.read_u8(2)?, 0b0);
+        assert_eq!(rdr.read_u8(2)?, 0b1);
+        assert_eq!(rdr.read_u8(2)?, 0b10);
+        assert_eq!(rdr.read_u8(2)?, 0b11);
+
+        rdr.byte_index = 0;
+        rdr.bit_offset = 0;
+        assert_eq!(rdr.read_u8(4)?, 0b1);
+        assert_eq!(rdr.read_u8(4)?, 0b1011);
+
+        rdr.byte_index = 0;
+        rdr.bit_offset = 0;
+        assert_eq!(rdr.read_u8(5)?, 0b11);
+        assert_eq!(rdr.read_u8(3)?, 0b11);
+
+        rdr.byte_index = 0;
+        rdr.bit_offset = 0;
+        assert_eq!(rdr.read_u8(8)?, 0b0001_1011);
+
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod bitstream_writer_tests {
+    use crate::bitstream::BitstreamWriter;
+
+    #[test]
+    fn test_bitwriter_u8_write() {
+        let mut writer = BitstreamWriter::<32>::default();
+        writer.write_u8(0b00000011, 2);
+        assert_eq!(writer.as_slice()[0], 0b11000000);
+        writer.write_u8(0b00000101, 3);
+        assert_eq!(writer.as_slice()[0], 0b11101000);
+        writer.write_u8(0b00001111, 4);
+        assert_eq!(writer.as_slice()[0], 0b11101111);
+        assert_eq!(writer.as_slice()[1], 0b10000000);
+    }
+}
diff --git a/backend/src/call.rs b/backend/src/call.rs
index c95c634..0aff35a 100644
--- a/backend/src/call.rs
+++ b/backend/src/call.rs
@@ -1567,21 +1567,12 @@ impl CallInner {
                 sender.is_maybe_in_dtx = false;
             }
         }
-        let dependency_descriptor = if incoming_rtp.is_vp8() {
-            time_scope_us!("calling.call.handle_rtp.vp8_header");
-            if let Some((dependency_descriptor, need_reallocation)) =
-                sender.update_incoming_video_rate_and_resolution(&incoming_rtp, now)?
-            {
-                if need_reallocation {
-                    self.reallocate_target_send_rates(now);
-                }
-                Some(dependency_descriptor)
-            } else {
-                return Ok(vec![]);
-            }
-        } else {
-            None
-        };
+
+        if incoming_rtp.is_vp8()
+            && sender.update_incoming_video_rate_and_resolution(&incoming_rtp, now)?
+        {
+            self.reallocate_target_send_rates(now);
+        }
 
         let mut rtp_to_send = vec![];
 
@@ -1598,12 +1589,17 @@ impl CallInner {
                 LayerId::Audio => receiver.forward_audio_rtp(&incoming_rtp),
                 LayerId::RtpData => receiver.forward_data_rtp(&incoming_rtp),
                 LayerId::Video0 | LayerId::Video1 | LayerId::Video2 => {
-                    receiver.forward_video_rtp(&incoming_rtp, dependency_descriptor.as_ref())
+                    if incoming_rtp.is_vp8() {
+                        receiver.forward_video_rtp_vp8(&incoming_rtp)
+                    } else {
+                        None
+                    }
                 }
             } {
                 rtp_to_send.push((receiver.demux_id, rtp_to_forward));
             }
         }
+
         Ok(rtp_to_send)
     }
 
@@ -2921,13 +2917,10 @@ impl Client {
         &mut self,
         incoming_rtp: &rtp::Packet<&[u8]>,
         now: Instant,
-    ) -> Result<Option<(rtp::DependencyDescriptor, bool)>, Error> {
-        let dependency_descriptor =
-            if let Some((descriptor, _)) = incoming_rtp.dependency_descriptor {
-                descriptor
-            } else {
-                return Err(Error::MissingDependencyDescriptor);
-            };
+    ) -> Result<bool, Error> {
+        let Some((dependency_descriptor, _)) = incoming_rtp.dependency_descriptor.as_ref() else {
+            return Err(Error::MissingDependencyDescriptor);
+        };
         let incoming_layer_index =
             LayerId::layer_index_from_ssrc(incoming_rtp.ssrc()).ok_or(Error::InvalidRtpLayerId)?;
         let incoming_video = &mut self.incoming_video[incoming_layer_index];
@@ -2949,7 +2942,7 @@ impl Client {
         }
 
         let old_resolution = incoming_video.original_resolution;
-        if let Some(resolution) = dependency_descriptor.resolution {
+        if let Some(resolution) = dependency_descriptor.resolution() {
             incoming_video.apply_resolution(resolution, self.video_rotation);
         } else if old_resolution.is_none() && !incoming_video.needs_resolution {
             // Record that we have data on the stream, when the resolution has been cleared.
@@ -2963,7 +2956,7 @@ impl Client {
 
         // If this is a key frame, and it was not allocatable before, update the bitrate and run
         // allocation; this allows for switching to a new stream on the first key frame.
-        if dependency_descriptor.is_key_frame
+        if dependency_descriptor.is_key_frame()
             && (old_resolution.is_none() || incoming_video.rate().unwrap_or_default().as_bps() == 0)
         {
             incoming_video.rate_tracker.update(now);
@@ -3040,7 +3033,7 @@ impl Client {
             }
         }
 
-        Ok(Some((dependency_descriptor, need_reallocation)))
+        Ok(need_reallocation)
     }
 
     fn forward_audio_rtp(
@@ -3060,28 +3053,21 @@ impl Client {
         Some(outgoing_rtp)
     }
 
-    fn forward_video_rtp(
+    fn forward_video_rtp_vp8(
         &mut self,
         incoming_rtp: &rtp::Packet<&[u8]>,
-        dependency_descriptor: Option<&rtp::DependencyDescriptor>,
     ) -> Option<rtp::Packet<Vec<u8>>> {
-        let dependency_descriptor = dependency_descriptor?;
-
         let sender_demux_id = DemuxId::from_ssrc(incoming_rtp.ssrc());
         let forwarder = self
             .video_forwarder_by_sender_demux_id
             .get_mut(&sender_demux_id)?;
 
-        let (outgoing_ssrc, outgoing) =
-            forwarder.forward_vp8_rtp(incoming_rtp, dependency_descriptor)?;
+        let (outgoing_ssrc, outgoing) = forwarder.forward_vp8_rtp(incoming_rtp)?;
         let mut outgoing_rtp = incoming_rtp.rewrite(
             outgoing_ssrc,
             outgoing.seqnum,
             outgoing.timestamp as rtp::TruncatedTimestamp,
         );
-        if let Some((descriptor, _)) = &mut outgoing_rtp.dependency_descriptor {
-            descriptor.truncated_frame_number = outgoing.frame_number as rtp::TruncatedFrameNumber;
-        }
         outgoing_rtp.set_frame_number_in_header(outgoing.frame_number);
         Some(outgoing_rtp)
     }
@@ -3679,10 +3665,10 @@ impl Vp8SimulcastRtpForwarder {
     fn forward_vp8_rtp(
         &mut self,
         incoming_rtp: &rtp::Packet<&[u8]>,
-        dependency_descriptor: &rtp::DependencyDescriptor,
     ) -> Option<(rtp::Ssrc, VideoRewrittenIds)> {
+        let (dependency_descriptor, _) = incoming_rtp.dependency_descriptor.as_ref()?;
         if self.switching_ssrc() == Some(incoming_rtp.ssrc())
-            && dependency_descriptor.is_key_frame
+            && dependency_descriptor.is_key_frame()
             && (incoming_rtp.is_max_seqnum || self.forwarding_ssrc().is_none())
         {
             // When switching from forwarding one SSRC to another, we only
@@ -3718,7 +3704,7 @@ impl Vp8SimulcastRtpForwarder {
                 // In other words, we are only tracking the ROC since the switching point,
                 // and that is now, so the ROC is 0.
                 incoming_rtp.timestamp as rtp::FullTimestamp,
-                dependency_descriptor.truncated_frame_number as rtp::FullFrameNumber,
+                dependency_descriptor.truncated_frame_number() as rtp::FullFrameNumber,
             );
             // We make two simplifying assumptions here:
             // 1. The first packet we received is the first packet of the key frame.
@@ -3745,7 +3731,7 @@ impl Vp8SimulcastRtpForwarder {
             self.switching = Vp8SimulcastRtpSwitchingState::DoNotSwitch;
             self.max_outgoing = first_outgoing;
         } else if self.switching_ssrc() == Some(incoming_rtp.ssrc())
-            && dependency_descriptor.is_key_frame
+            && dependency_descriptor.is_key_frame()
         {
             event!("calling.forwarding.layer_switch.wait_for_in_order_key_frame");
             trace!(
@@ -3767,7 +3753,7 @@ impl Vp8SimulcastRtpForwarder {
         {
             if *incoming_ssrc == incoming_rtp.ssrc() {
                 let expanded_frame_number = rtp::expand_frame_number(
-                    dependency_descriptor.truncated_frame_number,
+                    dependency_descriptor.truncated_frame_number(),
                     &mut max_incoming.frame_number,
                 );
 
@@ -3781,7 +3767,7 @@ impl Vp8SimulcastRtpForwarder {
                     first_outgoing.checked_add(&incoming.checked_sub(first_incoming)?)?;
                 self.max_outgoing = self.max_outgoing.max(&outgoing);
 
-                if dependency_descriptor.is_key_frame {
+                if dependency_descriptor.is_key_frame() {
                     *needs_key_frame = false;
                 }
                 trace!(
@@ -3898,7 +3884,13 @@ mod call_tests {
     use mrp::MrpHeader;
 
     use super::*;
-    use crate::protos::sfu_to_device::{peek_info::PeekDeviceInfo, PeekInfo};
+    use crate::{
+        protos::sfu_to_device::{peek_info::PeekDeviceInfo, PeekInfo},
+        rtp::{
+            DependencyDescriptor, ExtendedDescriptorFields, MandatoryDescriptorFields,
+            TemplateDependencyStructure, TemplateDependencyStructureFields,
+        },
+    };
 
     static CALL_ID: &[u8; 7] = b"call_id";
 
@@ -3943,7 +3935,30 @@ mod call_tests {
             ssrc: u32,
             index: u32,
             rtp: rtp::Packet<Vec<u8>>,
-            dependency_descriptor: rtp::DependencyDescriptor,
+            resolution: Option<PixelSize>,
+        }
+
+        fn dummy_dependency_descriptor(
+            is_key_frame: bool,
+            frame_number: u16,
+            resolution: Option<PixelSize>,
+        ) -> DependencyDescriptor {
+            DependencyDescriptor {
+                mandatory_fields: MandatoryDescriptorFields {
+                    start_of_frame: true,
+                    frame_number,
+                    ..Default::default()
+                },
+                extended_fields: Some(ExtendedDescriptorFields {
+                    template_dependency_structure: is_key_frame.then_some(
+                        TemplateDependencyStructure::new(TemplateDependencyStructureFields {
+                            resolutions: resolution.map(|resolution| [resolution.into()].into()),
+                            ..Default::default()
+                        }),
+                    ),
+                    ..Default::default()
+                }),
+            }
         }
 
         impl Incoming {
@@ -3965,7 +3980,7 @@ mod call_tests {
                     self.rtp.ssrc(),
                     self.index + 1,
                     is_key_frame,
-                    self.dependency_descriptor.resolution,
+                    self.resolution,
                 )
             }
 
@@ -3981,15 +3996,19 @@ mod call_tests {
                 let mut rtp =
                     rtp::Packet::with_empty_tag(pt, seqnum, timestamp, ssrc, None, None, &[]);
                 rtp.is_max_seqnum = true;
+                rtp.dependency_descriptor = Some((
+                    dummy_dependency_descriptor(
+                        is_key_frame,
+                        ((1000 * ssrc) + index) as u16,
+                        resolution,
+                    ),
+                    0..0,
+                ));
                 Self {
                     ssrc,
                     index,
                     rtp,
-                    dependency_descriptor: rtp::DependencyDescriptor {
-                        truncated_frame_number: ((1000 * ssrc) + index) as u16,
-                        is_key_frame,
-                        resolution,
-                    },
+                    resolution,
                 }
             }
 
@@ -4002,12 +4021,10 @@ mod call_tests {
                 let mut rtp = self.rtp.clone();
                 rtp.set_seqnum_in_header(seqnum);
                 rtp.set_timestamp_in_header(timestamp);
+                let (dependency_descriptor, _) = rtp.dependency_descriptor.as_mut().unwrap();
+                dependency_descriptor.mandatory_fields.frame_number = truncated_frame_number;
                 Self {
                     rtp,
-                    dependency_descriptor: rtp::DependencyDescriptor {
-                        truncated_frame_number,
-                        ..self.dependency_descriptor
-                    },
                     ..self.clone()
                 }
             }
@@ -4016,7 +4033,7 @@ mod call_tests {
                 &self,
                 forwarder: &mut Vp8SimulcastRtpForwarder,
             ) -> Option<(rtp::Ssrc, VideoRewrittenIds)> {
-                forwarder.forward_vp8_rtp(&self.rtp.borrow(), &self.dependency_descriptor)
+                forwarder.forward_vp8_rtp(&self.rtp.borrow())
             }
         }
 
@@ -5058,6 +5075,46 @@ mod call_tests {
         create_rtp(sender_demux_id, layer_id, seqnum, &payload[..])
     }
 
+    fn create_dependency_descriptor(
+        frame_number: u16,
+        size: Option<PixelSize>,
+    ) -> DependencyDescriptor {
+        let mut descriptor = if let Some(size) = size {
+            let width_minus_1 = size.width - 1;
+            let height_minus_1 = size.height - 1;
+            let encoded = [
+                0b10000000u8,
+                0b00000000,
+                0b00000001,
+                0b10000000, // The first bit in this byte indicates that this is for a key frame.
+                0b00000010,
+                0b00000100,
+                0b01001110,
+                0b10101010,
+                0b10101111,
+                0b00101000,
+                0b01100000,
+                0b01000001,
+                0b01001101,
+                0b00110100,
+                0b01010011,
+                0b10001010,
+                0b00001001,
+                0b01000000,
+                0b0100_0000 | ((width_minus_1 >> 10) as u8), // width - 1 from 3rd bit
+                ((width_minus_1 >> 2) & 0xFF) as u8,
+                (((width_minus_1 & 0b0000_0011) << 6) as u8) | ((height_minus_1 >> 10) as u8), // height - 1 from 3rd bit
+                ((height_minus_1 >> 2) & 0xFF) as u8,
+                ((height_minus_1 & 0b0000_0011) << 6) as u8,
+            ];
+            DependencyDescriptor::read(&encoded, None).expect("parse the dependency descriptor")
+        } else {
+            DependencyDescriptor::default()
+        };
+        descriptor.mandatory_fields.frame_number = frame_number;
+        descriptor
+    }
+
     fn create_video_rtp(
         sender_demux_id: DemuxId,
         layer_id: LayerId,
@@ -5071,16 +5128,14 @@ mod call_tests {
         let ssrc = layer_id.to_ssrc(sender_demux_id);
         let pt = 108;
         let timestamp = seqnum as rtp::TruncatedTimestamp;
+        let dependency_descriptor =
+            create_dependency_descriptor(truncated_frame_number, key_frame_size);
         rtp::Packet::with_dependency_descriptor(
             pt,
             seqnum,
             timestamp,
             ssrc,
-            rtp::DependencyDescriptor {
-                is_key_frame: key_frame_size.is_some(),
-                resolution: key_frame_size,
-                truncated_frame_number,
-            },
+            dependency_descriptor,
             &payload,
         )
     }
diff --git a/backend/src/connection.rs b/backend/src/connection.rs
index 58a8050..e03d382 100644
--- a/backend/src/connection.rs
+++ b/backend/src/connection.rs
@@ -22,7 +22,7 @@ use crate::{
     pacer::{self, Pacer},
     packet_server::{AddressType, SocketLocator},
     region::RegionRelation,
-    rtp::{self, TruncatedSequenceNumber},
+    rtp::{self, TemplateDependencyStructure, TruncatedSequenceNumber},
     sfu::ConnectionId,
 };
 
@@ -282,9 +282,12 @@ impl Connection {
     pub fn handle_rtp_packet<'packet>(
         &self,
         incoming_packet: &'packet mut [u8],
+        template_dependency_structure: Option<&TemplateDependencyStructure>,
         now: Instant,
     ) -> Result<Option<rtp::Packet<&'packet mut [u8]>>, Error> {
-        self.inner.write().handle_rtp_packet(incoming_packet, now)
+        self.inner
+            .write()
+            .handle_rtp_packet(incoming_packet, template_dependency_structure, now)
     }
 
     /// Decrypts an incoming RTCP packet and processes it.
@@ -725,6 +728,7 @@ impl ConnectionInner {
     fn handle_rtp_packet<'packet>(
         &mut self,
         incoming_packet: &'packet mut [u8],
+        template_dependency_structure: Option<&TemplateDependencyStructure>,
         now: Instant,
     ) -> Result<Option<rtp::Packet<&'packet mut [u8]>>, Error> {
         if self.closed {
@@ -733,7 +737,7 @@ impl ConnectionInner {
 
         let rtp_endpoint = &mut self.rtp.endpoint;
         let size = incoming_packet.len();
-        match rtp_endpoint.receive_rtp(incoming_packet, now) {
+        match rtp_endpoint.receive_rtp(incoming_packet, template_dependency_structure, now) {
             Some(packet) => {
                 if packet.is_rtx() {
                     event!("calling.bandwidth.incoming.rtx_bytes", size);
@@ -1553,7 +1557,7 @@ mod connection_tests {
         assert_eq!(
             expected_decrypted_rtp.to_owned(),
             connection
-                .handle_rtp_packet(&mut encrypted_rtp.into_serialized(), now)
+                .handle_rtp_packet(&mut encrypted_rtp.into_serialized(), None, now)
                 .unwrap()
                 .unwrap()
                 .to_owned()
@@ -1562,7 +1566,7 @@ mod connection_tests {
         let encrypted_rtp = new_encrypted_rtp(2, None, &encrypt, now);
         assert_eq!(
             Err(Error::ReceivedInvalidRtp),
-            connection.handle_rtp_packet(&mut encrypted_rtp.into_serialized(), now)
+            connection.handle_rtp_packet(&mut encrypted_rtp.into_serialized(), None, now)
         );
 
         let encrypted_rtp = new_encrypted_rtx_rtp(5, 2, None, &decrypt, now);
@@ -1570,7 +1574,7 @@ mod connection_tests {
         assert_eq!(
             expected_decrypted_rtp.borrow().to_owned(),
             connection
-                .handle_rtp_packet(&mut encrypted_rtp.into_serialized(), now)
+                .handle_rtp_packet(&mut encrypted_rtp.into_serialized(), None, now)
                 .unwrap()
                 .unwrap()
                 .to_owned()
@@ -1665,7 +1669,7 @@ mod connection_tests {
         let (buf, _addr) = &packets_to_send[0];
 
         assert_eq!(1172, buf.len());
-        let actual_padding_header = rtp::Header::parse(buf).unwrap();
+        let actual_padding_header = rtp::Header::parse(buf, None).unwrap();
         assert_eq!(padding_ssrc, actual_padding_header.ssrc);
         assert_eq!(99, actual_padding_header.payload_type);
         assert_eq!(1136, actual_padding_header.payload_range.len());
@@ -1710,7 +1714,7 @@ mod connection_tests {
         let (buf, _addr) = &packets_to_send[0];
 
         assert_eq!(1172, buf.len());
-        let actual_padding_header = rtp::Header::parse(buf).unwrap();
+        let actual_padding_header = rtp::Header::parse(buf, None).unwrap();
         assert_eq!(padding_ssrc, actual_padding_header.ssrc);
         assert_eq!(99, actual_padding_header.payload_type);
         assert_eq!(1136, actual_padding_header.payload_range.len());
@@ -1815,6 +1819,7 @@ mod connection_tests {
         connection
             .handle_rtp_packet(
                 &mut new_encrypted_rtp(1, Some(101), &decrypt, at(1)).into_serialized(),
+                None,
                 at(1),
             )
             .unwrap()
@@ -1823,6 +1828,7 @@ mod connection_tests {
         connection
             .handle_rtp_packet(
                 &mut new_encrypted_rtp(3, Some(103), &decrypt, at(3)).into_serialized(),
+                None,
                 at(3),
             )
             .unwrap()
@@ -1875,6 +1881,7 @@ mod connection_tests {
         connection
             .handle_rtp_packet(
                 &mut new_encrypted_rtp(2, Some(102), &decrypt, at(10002)).into_serialized(),
+                None,
                 at(10002),
             )
             .unwrap()
diff --git a/backend/src/lib.rs b/backend/src/lib.rs
index ce4af91..5a46e69 100644
--- a/backend/src/lib.rs
+++ b/backend/src/lib.rs
@@ -4,6 +4,7 @@
 //
 
 pub mod audio;
+pub mod bitstream;
 pub mod call;
 pub mod call_lifecycle;
 pub mod candidate_selector;
diff --git a/backend/src/rtp.rs b/backend/src/rtp.rs
index 8bc5d1a..f93cd18 100644
--- a/backend/src/rtp.rs
+++ b/backend/src/rtp.rs
@@ -6,6 +6,7 @@
 //! Implementation of RTP/SRTP. See https://tools.ietf.org/html/rfc3550 and
 //! https://tools.ietf.org/html/rfc7714. Assumes AES-GCM 128.
 
+mod dependency_descriptor;
 mod nack;
 mod packet;
 mod rtcp;
@@ -16,13 +17,15 @@ mod types;
 use std::{collections::HashMap, convert::TryInto};
 
 use calling_common::{expand_truncated_counter, read_u16, Bits, Duration, Instant, Writer};
+pub use dependency_descriptor::*;
 use log::*;
 use metrics::*;
 use nack::*;
 pub use nack::{write_nack, Nack};
 use packet::*;
-pub use packet::{DependencyDescriptor, Header, Packet};
-pub use rtcp::{ControlPacket, KeyFrameRequest, *};
+pub use packet::{Header, Packet};
+use rtcp::*;
+pub use rtcp::{ControlPacket, KeyFrameRequest};
 pub use rtx::to_rtx_ssrc;
 use rtx::*;
 use srtp::*;
@@ -38,6 +41,7 @@ const PADDING_PAYLOAD_TYPE: PayloadType = 99;
 const CLIENT_SERVER_DATA_PAYLOAD_TYPE: PayloadType = 101;
 pub const OPUS_PAYLOAD_TYPE: PayloadType = 102;
 pub const VP8_PAYLOAD_TYPE: PayloadType = 108;
+pub const VP9_PAYLOAD_TYPE: PayloadType = 109;
 
 // Discard outgoing packets after this time.
 // 3 second lifetime matches WebRTC's RTX history
@@ -114,7 +118,7 @@ fn is_audio_payload_type(pt: PayloadType) -> bool {
 }
 
 fn is_video_payload_type(pt: PayloadType) -> bool {
-    pt == VP8_PAYLOAD_TYPE
+    pt == VP8_PAYLOAD_TYPE || pt == VP9_PAYLOAD_TYPE
 }
 
 fn is_padding_payload_type(pt: PayloadType) -> bool {
@@ -228,10 +232,11 @@ impl Endpoint {
     pub fn receive_rtp<'packet>(
         &mut self,
         encrypted: &'packet mut [u8],
+        template_dependency_structure: Option<&TemplateDependencyStructure>,
         now: Instant,
     ) -> Option<Packet<&'packet mut [u8]>> {
         // Header::parse will log a warning for every place where it fails to parse.
-        let header = Header::parse(encrypted)?;
+        let header = Header::parse(encrypted, template_dependency_structure)?;
 
         let tcc_seqnum = header
             .tcc_seqnum
@@ -859,7 +864,7 @@ pub mod fuzz {
     }
 
     pub fn parse_and_forward_rtp_for_fuzzing(data: Vec<u8>) -> Option<Vec<u8>> {
-        let header = Header::parse(&data)?;
+        let header = Header::parse(&data, None)?;
 
         let mut incoming = Packet::new(
             &header,
@@ -946,7 +951,7 @@ mod test {
             )
             .unwrap();
         let received1 = receiver
-            .receive_rtp(sent1.serialized.borrow_mut(), at(10))
+            .receive_rtp(sent1.serialized.borrow_mut(), None, at(10))
             .unwrap();
         sent1.encrypted = false; // Got decrypted by the above
         let received1 = received1.to_owned();
@@ -994,7 +999,7 @@ mod test {
             )
             .unwrap();
         let received3 = receiver
-            .receive_rtp(sent3.serialized.borrow_mut(), at(20))
+            .receive_rtp(sent3.serialized.borrow_mut(), None, at(20))
             .unwrap();
         sent3.encrypted = false; // Got decrypted by the above
         let received3 = received3.to_owned();
@@ -1018,7 +1023,7 @@ mod test {
 
         let mut resent2 = sender.resend_rtp(3, 2, at(50)).unwrap();
         let received2 = receiver
-            .receive_rtp(resent2.serialized.borrow_mut(), at(60))
+            .receive_rtp(resent2.serialized.borrow_mut(), None, at(60))
             .unwrap();
         resent2.encrypted = false; // Got decrypted by the above
         let mut received2 = received2.to_owned();
@@ -1047,7 +1052,7 @@ mod test {
             .send_rtp(sent2.rewrite(33, 22, 44), at(70))
             .unwrap();
         let forwarded2 = sender
-            .receive_rtp(forwarded2.serialized.borrow_mut(), at(80))
+            .receive_rtp(forwarded2.serialized.borrow_mut(), None, at(80))
             .unwrap();
         let forwarded2 = forwarded2.to_owned();
         assert_eq!(sent2.payload_type(), forwarded2.payload_type());
@@ -1063,13 +1068,13 @@ mod test {
             .unwrap();
         assert_eq!(1, reforwarded2.seqnum_in_header);
         assert_eq!(Some(22), reforwarded2.seqnum_in_payload);
-        let reforwarded2 = sender.receive_rtp(reforwarded2.serialized.borrow_mut(), at(90));
+        let reforwarded2 = sender.receive_rtp(reforwarded2.serialized.borrow_mut(), None, at(90));
         assert_eq!(reforwarded2, None);
 
         // Padding
         let mut padding = sender.send_padding(4, at(100)).unwrap();
         let received_padding = receiver
-            .receive_rtp(padding.serialized.borrow_mut(), at(110))
+            .receive_rtp(padding.serialized.borrow_mut(), None, at(110))
             .unwrap();
         assert_eq!(99, received_padding.payload_type());
         assert_eq!(99, received_padding.payload_type_in_header);
@@ -1179,14 +1184,14 @@ mod test {
             .unwrap();
         let mut sent200b = sent200a.clone();
 
-        let received1a = receiver.receive_rtp(sent1a.serialized.borrow_mut(), at(10));
-        let received1b = receiver.receive_rtp(sent1b.serialized.borrow_mut(), at(10));
-        let received2a = receiver.receive_rtp(sent2a.serialized.borrow_mut(), at(10));
-        let received2b = receiver.receive_rtp(sent2b.serialized.borrow_mut(), at(10));
-        let received200a = receiver.receive_rtp(sent200a.serialized.borrow_mut(), at(10));
-        let received200b = receiver.receive_rtp(sent200b.serialized.borrow_mut(), at(10));
-        let received1c = receiver.receive_rtp(sent1c.serialized.borrow_mut(), at(10));
-        let received2c = receiver.receive_rtp(sent2c.serialized.borrow_mut(), at(10));
+        let received1a = receiver.receive_rtp(sent1a.serialized.borrow_mut(), None, at(10));
+        let received1b = receiver.receive_rtp(sent1b.serialized.borrow_mut(), None, at(10));
+        let received2a = receiver.receive_rtp(sent2a.serialized.borrow_mut(), None, at(10));
+        let received2b = receiver.receive_rtp(sent2b.serialized.borrow_mut(), None, at(10));
+        let received200a = receiver.receive_rtp(sent200a.serialized.borrow_mut(), None, at(10));
+        let received200b = receiver.receive_rtp(sent200b.serialized.borrow_mut(), None, at(10));
+        let received1c = receiver.receive_rtp(sent1c.serialized.borrow_mut(), None, at(10));
+        let received2c = receiver.receive_rtp(sent2c.serialized.borrow_mut(), None, at(10));
 
         assert!(received1a.is_some());
         assert!(received1b.is_none());
diff --git a/backend/src/rtp/dependency_descriptor.rs b/backend/src/rtp/dependency_descriptor.rs
new file mode 100644
index 0000000..70120b0
--- /dev/null
+++ b/backend/src/rtp/dependency_descriptor.rs
@@ -0,0 +1,1109 @@
+//
+// Copyright 2026 Signal Messenger, LLC
+// SPDX-License-Identifier: AGPL-3.0-only
+//
+
+// Implements parsing and serialization of the Dependency Descriptor as defined in Appendix A
+// of the AV1 RTP specification (https://aomediacodec.github.io/av1-rtp-spec/).
+
+use std::{
+    fmt::Debug,
+    ops::{Deref, DerefMut},
+    sync::Arc,
+};
+
+use anyhow::{anyhow, bail, Result};
+use calling_common::PixelSize;
+use smallvec::SmallVec;
+
+use crate::bitstream::{BitstreamReader, BitstreamWriter};
+
+pub type DefaultBitstreamWriter = BitstreamWriter<128>;
+
+/// RTP header extension containing frame dependency metadata for scalable video streams.
+///
+/// # Structure
+///
+/// - **Mandatory fields** (3 bytes minimum): Present in every descriptor, containing
+///   frame boundaries, template ID, and frame number.
+/// - **Extended fields** (optional): Present when descriptor size > 3 bytes, containing
+///   template dependency structure, active decode targets, and custom overrides.
+///
+/// # Key Frame vs Delta Frame
+///
+/// - **Key frames** include a `template_dependency_structure` that defines the entire
+///   scalability structure (templates, layers, decode targets, chains).
+/// - **Delta frames** reference templates from the most recent key frame, optionally
+///   overriding DTIs, Fdiffs, or Chains with custom values.
+#[derive(Debug, Default, PartialEq, Eq, Clone)]
+pub struct DependencyDescriptor {
+    pub mandatory_fields: MandatoryDescriptorFields,
+    pub extended_fields: Option<ExtendedDescriptorFields>,
+}
+
+#[derive(Debug, Default, PartialEq, Eq, Clone)]
+pub struct MandatoryDescriptorFields {
+    /// MUST be set to `true` if the first payload byte of the RTP packet is the beginning of a new
+    /// frame, and MUST be set to `false` otherwise. Note that this frame might not be the first
+    /// frame of a temporal unit.
+    pub start_of_frame: bool,
+    /// MUST be set to `true` for the final RTP packet of a frame, and MUST be set to 0 otherwise.
+    /// Note  that, if spatial scalability is in use, more frames from the same temporal unit may
+    /// follow.
+    pub end_of_frame: bool,
+    /// ID of the Frame dependency template to use. MUST be in the range of template_id_offset to
+    /// (template_id_offset + TemplateCnt - 1), inclusive. frame_dependency_template_id MUST be
+    /// the same for all packets of the same frame.
+    pub frame_dependency_template_id: u8,
+    /// The frame number is represented using 16 bits and increases strictly monotonically in decode
+    /// order. frame_number MAY start on a random number, and MUST wrap after reaching the maximum
+    /// value. All packets of the same frame MUST have the same frame_number value.
+    pub frame_number: u16,
+}
+
+#[derive(Debug, Default, PartialEq, Eq, Clone)]
+pub struct ExtendedDescriptorFields {
+    /// This field defines a set of frame templates that describe how frames relate to each other
+    /// in a scalable video stream. This field is transmitted in key frames to establish
+    /// the decoding framework.
+    pub template_dependency_structure: Option<TemplateDependencyStructure>,
+    /// active_decode_targets_bitmask contains a bitmask that indicates which Decode targets are
+    /// available for decoding. Bit i is equal to 1 if Decode target i is available for decoding,
+    /// 0 otherwise. The least significant bit corresponds to Decode target 0.
+    pub active_decode_targets_bitmask: ActiveDecodeTargetsBitmask,
+    /// Frame DTIs, if present
+    pub custom_dtis: Option<Dtis>,
+    /// Frame Fdiffs, if present
+    pub custom_fdiffs: Option<CustomFdiffs>,
+    /// Frame chains, if present
+    pub custom_chains: Option<CustomChains>,
+}
+
+/// Represents the state and availability of decode targets in the dependency descriptor.
+/// - **Uninitialized**: Default state before any decode targets are configured.
+/// - **AllImplicitlyActive**: All decode targets are implicitly active based on template
+///   dependency structure. Contains the bitmask derived from decode target count where all
+///   targets are enabled.
+/// - **Available**: Explicitly specifies which decode targets are active via a custom bitmask.
+///   Present when the active decode targets present bit is set in extended descriptor fields.
+#[derive(Debug, Default, PartialEq, Eq, Clone)]
+pub enum ActiveDecodeTargetsBitmask {
+    #[default]
+    Uninitialized,
+    AllImplicitlyActive {
+        bitmask: u32,
+        size: usize,
+    },
+    Available {
+        bitmask: u32,
+        size: usize,
+    },
+}
+
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub struct Template {
+    pub layer: Layer,
+    pub dtis: Dtis,
+    pub fdiffs: Fdiffs,
+    pub chains: Chains,
+}
+
+// This is a simple macro that implements Deref and DerefMut for simple containers that wrap
+// SmallVec. Specifically, this is used for Dtis, Fdiffs, Chains, Resolutions, and Layers.
+// Improves legibility.
+macro_rules! impl_smallvec_container {
+    ($name:ident, $inner_type:ty, $initial_size:tt) => {
+        #[derive(Debug, Default, Clone, PartialEq, Eq)]
+        pub struct $name(SmallVec<[$inner_type; $initial_size]>);
+
+        impl $name {
+            fn push(&mut self, item: $inner_type) {
+                self.0.push(item);
+            }
+        }
+
+        impl Deref for $name {
+            type Target = [$inner_type];
+            fn deref(&self) -> &Self::Target {
+                &self.0
+            }
+        }
+
+        impl DerefMut for $name {
+            fn deref_mut(&mut self) -> &mut Self::Target {
+                &mut self.0
+            }
+        }
+
+        #[cfg(any(test, feature = "load_test"))]
+        impl<const N: usize> From<[$inner_type; N]> for $name {
+            fn from(v: [$inner_type; N]) -> Self {
+                Self(SmallVec::from_iter(v.into_iter()))
+            }
+        }
+    };
+}
+
+impl_smallvec_container!(Layers, Layer, 16);
+impl_smallvec_container!(DecodeTargetChainIndices, u8, 16);
+impl_smallvec_container!(Resolutions, Resolution, 8);
+impl_smallvec_container!(Chains, u8, 16);
+impl_smallvec_container!(CustomChains, u8, 16);
+impl_smallvec_container!(Fdiffs, u8, 16);
+impl_smallvec_container!(CustomFdiffs, u16, 16);
+impl_smallvec_container!(Dtis, Dti, 16);
+
+#[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
+pub struct Layer {
+    pub spatial_id: u8,
+    pub temporal_id: u8,
+}
+
+impl Layer {
+    pub const fn zero() -> Self {
+        Self {
+            spatial_id: 0,
+            temporal_id: 0,
+        }
+    }
+}
+
+#[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
+pub struct Resolution {
+    pub width: u16,
+    pub height: u16,
+}
+
+impl Resolution {
+    pub const fn zero() -> Self {
+        Self {
+            width: 0,
+            height: 0,
+        }
+    }
+}
+
+impl From<Resolution> for PixelSize {
+    fn from(resolution: Resolution) -> Self {
+        let Resolution { width, height } = resolution;
+        Self { width, height }
+    }
+}
+
+impl From<PixelSize> for Resolution {
+    fn from(pixel_size: PixelSize) -> Self {
+        let PixelSize { width, height } = pixel_size;
+        Self { width, height }
+    }
+}
+
+#[derive(Debug, Default, PartialEq, Eq)]
+pub struct TemplateDependencyStructureFields {
+    pub template_id_offset: usize,    // Starting template ID (6 bits, 0-63)
+    pub decode_target_count: usize,   // Number of decode targets
+    pub chain_count: usize,           // Number of chains for loss detection
+    pub max_layer: Layer,             // Highest spatial/temporal layer
+    pub layers: Layers,               // All layer combinations
+    pub templates: Vec<Template>,     // Frame templates
+    pub decode_target_layers: Layers, // Max layer per decode target
+    pub decode_target_chain_indices: Option<DecodeTargetChainIndices>,
+    pub resolutions: Option<Resolutions>, // Resolution per spatial layer
+}
+
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub struct TemplateDependencyStructure(Arc<TemplateDependencyStructureFields>);
+
+#[cfg(any(test, feature = "load_test"))]
+impl TemplateDependencyStructure {
+    pub fn new(template_dependency_structure: TemplateDependencyStructureFields) -> Self {
+        Self(Arc::new(template_dependency_structure))
+    }
+}
+
+impl Deref for TemplateDependencyStructure {
+    type Target = TemplateDependencyStructureFields;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+#[repr(u8)]
+pub enum Dti {
+    /// No payload for this decode target is present.
+    NotPresent = 0,
+    /// Payload for this decode target is present and discardable.
+    Discardable = 1,
+    /// Payload for this decode target is present and switch is possible.
+    Switch = 2,
+    /// Payload for this decode target is present but it is neither discardable nor is it
+    /// a switch indication.
+    Required = 3,
+}
+
+impl TryFrom<u8> for Dti {
+    type Error = anyhow::Error;
+
+    fn try_from(value: u8) -> Result<Self, Self::Error> {
+        match value {
+            0 => Ok(Dti::NotPresent),
+            1 => Ok(Dti::Discardable),
+            2 => Ok(Dti::Switch),
+            3 => Ok(Dti::Required),
+            _ => Err(anyhow!("Invalid DTI value: {}", value)),
+        }
+    }
+}
+
+impl DependencyDescriptor {
+    pub fn read(
+        bytes: &[u8],
+        dependency_structure: Option<&TemplateDependencyStructure>,
+    ) -> Result<Self> {
+        let mut buffer = BitstreamReader::new(bytes);
+        let mandatory_fields = MandatoryDescriptorFields::read(&mut buffer)?;
+        let extended_fields = if bytes.len() > 3 {
+            Some(ExtendedDescriptorFields::read(
+                dependency_structure,
+                &mut buffer,
+            )?)
+        } else {
+            None
+        };
+        Ok(Self {
+            mandatory_fields,
+            extended_fields,
+        })
+    }
+
+    pub fn write(&self, writer: &mut DefaultBitstreamWriter) {
+        self.mandatory_fields.write(writer);
+        if let Some(extended_fields) = &self.extended_fields {
+            extended_fields.write(writer);
+        }
+        writer.write_padding();
+    }
+
+    pub fn serialize(&self) -> Vec<u8> {
+        let mut writer = DefaultBitstreamWriter::default();
+        self.write(&mut writer);
+        writer.as_slice().to_owned()
+    }
+
+    /// Returns `true` if the frame that this descriptor is accompanying is a key frame.
+    pub fn is_key_frame(&self) -> bool {
+        self.extended_fields
+            .as_ref()
+            .is_some_and(|v| v.template_dependency_structure.is_some())
+    }
+
+    /// Returns the frame number.
+    pub fn truncated_frame_number(&self) -> u16 {
+        self.mandatory_fields.frame_number
+    }
+
+    /// Returns the frame resolution, if one is available. This method will should only be used
+    /// if the caller is certain that there will only one resolution be available in
+    /// the template dependency structure. This should be the case for simulcast.
+    pub fn resolution(&self) -> Option<PixelSize> {
+        self.extended_fields
+            .as_ref()
+            .and_then(|extended_fields| extended_fields.template_dependency_structure.as_ref())
+            .and_then(|dependency_structure| dependency_structure.resolutions.as_ref())
+            .and_then(|resolutions| resolutions.first().map(|v| (*v).into()))
+    }
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct FrameDependencyDefinition {
+    template_dependency_structure: TemplateDependencyStructure,
+    template_index: usize,
+    pub custom_dtis: Option<Dtis>,
+    pub custom_fdiffs: Option<CustomFdiffs>,
+    pub custom_chains: Option<CustomChains>,
+}
+
+impl FrameDependencyDefinition {
+    /// Builds a new `FrameDependencyDefinition` from the information in the given dependency
+    /// descriptor and the given extended descriptor fields. This method will fail if
+    /// the frame dependency template ID is not in the valid range for the given template
+    /// dependency structure.
+    pub fn new(
+        dependency_structure: &TemplateDependencyStructure,
+        extended_descriptor_fields: Option<&ExtendedDescriptorFields>,
+        frame_dependency_template_id: u8,
+    ) -> Result<Self> {
+        let template_id = frame_dependency_template_id as usize;
+        let template_index = (template_id + 64 - dependency_structure.template_id_offset) % 64;
+        if template_index >= dependency_structure.templates.len() {
+            bail!("Template ID out of bounds: {}", template_id);
+        }
+        let template_dependency_structure = dependency_structure.clone();
+        let (custom_dtis, custom_fdiffs, custom_chains) = match extended_descriptor_fields {
+            Some(v) => (
+                v.custom_dtis.clone(),
+                v.custom_fdiffs.clone(),
+                v.custom_chains.clone(),
+            ),
+            None => (None, None, None),
+        };
+        Ok(Self {
+            template_index,
+            template_dependency_structure,
+            custom_dtis,
+            custom_fdiffs,
+            custom_chains,
+        })
+    }
+
+    pub fn template_dependency_structure(&self) -> &TemplateDependencyStructure {
+        &self.template_dependency_structure
+    }
+
+    /// Retrieves the frame's template.
+    pub fn template(&self) -> &Template {
+        &self.template_dependency_structure.templates[self.template_index]
+    }
+
+    /// Retrieves the frame's resolution, if available.
+    pub fn resolution(&self) -> Option<Resolution> {
+        let index = self.template().layer.spatial_id as usize;
+        self.template_dependency_structure
+            .resolutions
+            .as_ref()
+            .map(|resolutions| resolutions[index])
+    }
+
+    /// Retrieves the DTI for the given active decode target.
+    pub fn dti(&self, active_decode_target: usize) -> Result<Dti> {
+        let dti = {
+            if let Some(dtis) = self.custom_dtis.as_ref() {
+                dtis.get(active_decode_target)
+                    .ok_or_else(|| anyhow!("Dependency target out of range"))?
+            } else {
+                self.template()
+                    .dtis
+                    .get(active_decode_target)
+                    .ok_or_else(|| anyhow!("Dependency target out of range"))?
+            }
+        };
+        Ok(*dti)
+    }
+
+    /// Retrieves the frame's layer.
+    pub fn layer(&self) -> Layer {
+        self.template().layer
+    }
+}
+
+impl ExtendedDescriptorFields {
+    const TEMPLATE_DEPENDENCY_STRUCTURE_PRESENT_BIT: u8 = 1 << 4;
+    const ACTIVE_DECODE_TARGETS_PRESENT_BIT: u8 = 1 << 3;
+    const CUSTOM_DTIS_PRESENT_BIT: u8 = 1 << 2;
+    const CUSTOM_FDIFFS_PRESENT_BIT: u8 = 1 << 1;
+    const CUSTOM_CHAINS_PRESENT_BIT: u8 = 1;
+
+    fn read(
+        dependency_structure: Option<&TemplateDependencyStructure>,
+        buffer: &mut BitstreamReader,
+    ) -> Result<Self> {
+        let (mut decode_target_count, mut chain_count) = match dependency_structure {
+            Some(v) => (Some(v.decode_target_count), Some(v.chain_count)),
+            None => (None, None),
+        };
+
+        let mut extended_descriptor_fields = Self::default();
+
+        let flags = buffer.read_u8(5)?;
+
+        if flags & Self::TEMPLATE_DEPENDENCY_STRUCTURE_PRESENT_BIT != 0 {
+            let dependency_structure = TemplateDependencyStructure::read(buffer)?;
+            decode_target_count = Some(dependency_structure.decode_target_count);
+            chain_count = Some(dependency_structure.chain_count);
+            extended_descriptor_fields.active_decode_targets_bitmask =
+                ActiveDecodeTargetsBitmask::AllImplicitlyActive {
+                    bitmask: ((1u64 << dependency_structure.decode_target_count) - 1) as u32,
+                    size: dependency_structure.decode_target_count,
+                };
+            extended_descriptor_fields.template_dependency_structure = Some(dependency_structure);
+        }
+        if flags & Self::ACTIVE_DECODE_TARGETS_PRESENT_BIT != 0 {
+            let decode_target_count =
+                decode_target_count.ok_or_else(|| anyhow!("Missing dependency structure"))?;
+            let active_decode_target_bitmask = buffer.read_u32(decode_target_count)?;
+            extended_descriptor_fields.active_decode_targets_bitmask =
+                ActiveDecodeTargetsBitmask::Available {
+                    bitmask: active_decode_target_bitmask,
+                    size: decode_target_count,
+                };
+        }
+        if flags & Self::CUSTOM_DTIS_PRESENT_BIT != 0 {
+            let decode_target_count =
+                decode_target_count.ok_or_else(|| anyhow!("Missing dependency structure"))?;
+            extended_descriptor_fields.custom_dtis = Some(Dtis::read(decode_target_count, buffer)?);
+        }
+        if flags & Self::CUSTOM_FDIFFS_PRESENT_BIT != 0 {
+            extended_descriptor_fields.custom_fdiffs = Some(CustomFdiffs::read(buffer)?);
+        }
+        if flags & Self::CUSTOM_CHAINS_PRESENT_BIT != 0 {
+            let chain_count = chain_count.ok_or_else(|| anyhow!("Missing dependency structure"))?;
+            extended_descriptor_fields.custom_chains =
+                Some(CustomChains::read(chain_count, buffer)?);
+        }
+
+        Ok(extended_descriptor_fields)
+    }
+
+    fn write(&self, writer: &mut DefaultBitstreamWriter) {
+        let mut flags = 0;
+        if self.custom_chains.is_some() {
+            flags |= Self::CUSTOM_CHAINS_PRESENT_BIT;
+        }
+        if self.custom_dtis.is_some() {
+            flags |= Self::CUSTOM_DTIS_PRESENT_BIT;
+        }
+        if self.custom_fdiffs.is_some() {
+            flags |= Self::CUSTOM_FDIFFS_PRESENT_BIT;
+        }
+        if let ActiveDecodeTargetsBitmask::Available { .. } = self.active_decode_targets_bitmask {
+            flags |= Self::ACTIVE_DECODE_TARGETS_PRESENT_BIT;
+        }
+        if self.template_dependency_structure.is_some() {
+            flags |= Self::TEMPLATE_DEPENDENCY_STRUCTURE_PRESENT_BIT;
+        }
+        writer.write_u8(flags, 5);
+        if let Some(template_dependency_structure) = self.template_dependency_structure.as_ref() {
+            template_dependency_structure.write(writer);
+        }
+        if let ActiveDecodeTargetsBitmask::Available { bitmask, size } =
+            self.active_decode_targets_bitmask
+        {
+            writer.write_u32(bitmask, size);
+        }
+        if let Some(custom_dtis) = self.custom_dtis.as_ref() {
+            custom_dtis.write(writer);
+        }
+        if let Some(custom_fdiffs) = self.custom_fdiffs.as_ref() {
+            custom_fdiffs.write(writer);
+        }
+        if let Some(custom_chains) = self.custom_chains.as_ref() {
+            custom_chains.write(writer);
+        }
+    }
+}
+
+impl TemplateDependencyStructure {
+    /// Returns `true` if the frame packet is a part of an active chain. This method will fail if
+    /// the decode target chain indices are not (yet) available, for whatever reason.
+    pub fn is_part_of_active_chain(
+        &self,
+        active_decode_targets_bitmask: u32,
+        chain_index: usize,
+        frame_dependency: &FrameDependencyDefinition,
+    ) -> Result<bool> {
+        if !self.chain_has_active_decode_targets(active_decode_targets_bitmask, chain_index)? {
+            Ok(false)
+        } else {
+            let decode_target_chain_indices = self
+                .decode_target_chain_indices
+                .as_ref()
+                .ok_or_else(|| anyhow!("Missing decode target chain indices"))?;
+            for i in 0..self.decode_target_count {
+                let dti = frame_dependency.dti(i)?;
+                if decode_target_chain_indices[i] as usize == chain_index
+                    && matches!(dti, Dti::NotPresent | Dti::Discardable)
+                {
+                    return Ok(false);
+                }
+            }
+            Ok(true)
+        }
+    }
+
+    /// Returns `true` if the given chain has active decode targets. This method will fail if
+    /// the decode target chain indices are not (yet) available, for whatever reason.
+    pub fn chain_has_active_decode_targets(
+        &self,
+        active_decode_target_bitmask: u32,
+        chain_index: usize,
+    ) -> Result<bool> {
+        let decode_target_chain_indices = self
+            .decode_target_chain_indices
+            .as_ref()
+            .ok_or_else(|| anyhow!("Missing decode target chain indices"))?;
+        for i in 0..self.decode_target_count {
+            if decode_target_chain_indices[i] as usize == chain_index
+                && ((active_decode_target_bitmask >> i) & 1) == 1
+            {
+                return Ok(true);
+            }
+        }
+        Ok(false)
+    }
+
+    fn read(buffer: &mut BitstreamReader) -> Result<Self> {
+        let template_id_offset = buffer.read_u8(6)? as usize;
+        let decode_target_count = 1 + buffer.read_u8(5)? as usize;
+        let (max_layer, layers) = Layers::read(buffer)?;
+
+        let mut templates: Vec<_> = layers
+            .iter()
+            .map(|layer| Template {
+                layer: *layer,
+                ..Default::default()
+            })
+            .collect();
+
+        for template in &mut templates {
+            template
+                .dtis
+                .extend_from_buffer(decode_target_count, buffer)?;
+        }
+        for template in &mut templates {
+            template.fdiffs.extend_from_buffer(buffer)?;
+        }
+
+        let chain_count = buffer.read_non_symmetric(decode_target_count as u8 + 1)? as usize;
+        let decode_target_chain_indices = if chain_count > 0 {
+            let decode_target_chain_indices =
+                DecodeTargetChainIndices::read(decode_target_count, chain_count, buffer)?;
+            for template in &mut templates {
+                template.chains.extend_from_buffer(chain_count, buffer)?;
+            }
+            Some(decode_target_chain_indices)
+        } else {
+            None
+        };
+
+        // Associate each decode target with a layer. Specifically, we select
+        // the largest layer from the set of templates that are associated with
+        // the given decode target.
+        let mut decode_target_layers = Layers::default();
+        for i in 0..decode_target_count {
+            let mut layer = Layer::zero();
+            for template in &templates {
+                if template.dtis[i] != Dti::NotPresent {
+                    layer.spatial_id = layer.spatial_id.max(template.layer.spatial_id);
+                    layer.temporal_id = layer.temporal_id.max(template.layer.temporal_id);
+                }
+            }
+            decode_target_layers.push(layer);
+        }
+
+        let resolutions = if buffer.read_u8(1)? == 1 {
+            Some(Resolutions::read(max_layer.spatial_id as usize, buffer)?)
+        } else {
+            None
+        };
+
+        Ok(Self(Arc::new(TemplateDependencyStructureFields {
+            template_id_offset,
+            chain_count,
+            max_layer,
+            layers,
+            templates,
+            decode_target_count,
+            decode_target_layers,
+            decode_target_chain_indices,
+            resolutions,
+        })))
+    }
+
+    fn write(&self, writer: &mut DefaultBitstreamWriter) {
+        writer.write_u8(self.template_id_offset as u8, 6);
+        writer.write_u8((self.decode_target_count as u8).saturating_sub(1), 5);
+
+        self.layers.write(writer);
+
+        for template in &self.templates {
+            template.dtis.write(writer);
+        }
+        for template in &self.templates {
+            template.fdiffs.write(writer);
+        }
+
+        writer.write_non_symmetric(
+            self.decode_target_count.saturating_add(1),
+            self.chain_count as u8,
+        );
+        if let Some(decode_target_chain_indices) = self.decode_target_chain_indices.as_ref() {
+            decode_target_chain_indices.write(self.chain_count, writer);
+            for template in &self.templates {
+                template.chains.write(writer);
+            }
+        }
+
+        if let Some(resolutions) = self.resolutions.as_ref() {
+            writer.write_u8(1, 1);
+            resolutions.write(writer);
+        } else {
+            writer.write_u8(0, 1);
+        }
+    }
+}
+
+impl MandatoryDescriptorFields {
+    fn read(buffer: &mut BitstreamReader) -> Result<Self> {
+        let start_of_frame = buffer.read_u8(1)? == 1;
+        let end_of_frame = buffer.read_u8(1)? == 1;
+        let frame_dependency_template_id = buffer.read_u8(6)?;
+        let frame_number = buffer.read_u16(16)?;
+        Ok(Self {
+            start_of_frame,
+            end_of_frame,
+            frame_dependency_template_id,
+            frame_number,
+        })
+    }
+
+    fn write(&self, writer: &mut DefaultBitstreamWriter) {
+        writer.write_u8(self.start_of_frame.into(), 1);
+        writer.write_u8(self.end_of_frame.into(), 1);
+        writer.write_u8(self.frame_dependency_template_id, 6);
+        writer.write_u16(self.frame_number, 16);
+    }
+}
+
+impl Dtis {
+    fn read(count: usize, buffer: &mut BitstreamReader) -> Result<Self> {
+        let mut result = Self::default();
+        result.extend_from_buffer(count, buffer)?;
+        Ok(result)
+    }
+
+    fn extend_from_buffer(&mut self, count: usize, buffer: &mut BitstreamReader) -> Result<()> {
+        for _ in 0..count {
+            let dti = buffer.read_u8(2)?;
+            self.push(dti.try_into()?);
+        }
+        Ok(())
+    }
+
+    fn write(&self, writer: &mut DefaultBitstreamWriter) {
+        for dti in &self.0 {
+            writer.write_u8(*dti as u8, 2);
+        }
+    }
+}
+
+impl Fdiffs {
+    fn extend_from_buffer(&mut self, buffer: &mut BitstreamReader) -> Result<()> {
+        while buffer.read_u8(1)? != 0 {
+            self.push(buffer.read_u8(4)? + 1);
+        }
+        Ok(())
+    }
+
+    fn write(&self, writer: &mut DefaultBitstreamWriter) {
+        for fdiff in &self.0 {
+            writer.write_u8(1, 1);
+            writer.write_u8(*fdiff - 1, 4);
+        }
+        writer.write_u8(0, 1);
+    }
+}
+
+impl CustomFdiffs {
+    const VAL_MASK: u16 = 0x1fff;
+    const LEN_MASK: u16 = 0xe000;
+    const LEN_SHIFT: u16 = 13;
+
+    fn read(buffer: &mut BitstreamReader) -> Result<Self> {
+        let mut result = Self::default();
+        result.extend_from_buffer(buffer)?;
+        Ok(result)
+    }
+
+    fn extend_from_buffer(&mut self, buffer: &mut BitstreamReader) -> Result<()> {
+        loop {
+            let n = buffer.read_u8(2)? as usize;
+            if n == 0 {
+                break;
+            }
+            let fdiff = buffer.read_u16(n * 4)? + 1;
+            self.push((n as u16) << Self::LEN_SHIFT | fdiff);
+        }
+        Ok(())
+    }
+
+    fn write(&self, writer: &mut DefaultBitstreamWriter) {
+        for fdiff in &self.0 {
+            let n = ((fdiff & Self::LEN_MASK) >> Self::LEN_SHIFT) as usize;
+            writer.write_u8(n as u8, 2);
+            writer.write_u16((fdiff & Self::VAL_MASK) - 1, n * 4);
+        }
+        writer.write_u8(0, 2);
+    }
+
+    pub fn get(&self, index: usize) -> Option<u16> {
+        self.0.get(index).map(|v| v & Self::VAL_MASK)
+    }
+}
+
+impl Chains {
+    fn extend_from_buffer(&mut self, count: usize, buffer: &mut BitstreamReader) -> Result<()> {
+        for _ in 0..count {
+            self.push(buffer.read_u8(4)?);
+        }
+        Ok(())
+    }
+
+    fn write(&self, writer: &mut DefaultBitstreamWriter) {
+        for chain in &self.0 {
+            writer.write_u8(*chain, 4);
+        }
+    }
+}
+
+impl CustomChains {
+    fn read(count: usize, buffer: &mut BitstreamReader) -> Result<Self> {
+        let mut result = Self::default();
+        result.extend_from_buffer(count, buffer)?;
+        Ok(result)
+    }
+
+    fn extend_from_buffer(&mut self, count: usize, buffer: &mut BitstreamReader) -> Result<()> {
+        for _ in 0..count {
+            self.push(buffer.read_u8(8)?);
+        }
+        Ok(())
+    }
+
+    fn write(&self, writer: &mut DefaultBitstreamWriter) {
+        for chain in &self.0 {
+            writer.write_u8(*chain, 8);
+        }
+    }
+}
+
+impl Resolutions {
+    fn read(count: usize, buffer: &mut BitstreamReader) -> Result<Self> {
+        let mut result = Self::default();
+        result.extend_from_buffer(count, buffer)?;
+        Ok(result)
+    }
+
+    fn extend_from_buffer(&mut self, count: usize, buffer: &mut BitstreamReader) -> Result<()> {
+        for _ in 0..=count {
+            let width = buffer
+                .read_u16(16)?
+                .checked_add(1)
+                .ok_or(anyhow!("Invalid resolution"))?;
+            let height = buffer
+                .read_u16(16)?
+                .checked_add(1)
+                .ok_or(anyhow!("Invalid resolution"))?;
+            self.push(Resolution { width, height });
+        }
+        Ok(())
+    }
+
+    fn write(&self, writer: &mut DefaultBitstreamWriter) {
+        for resolution in &self.0 {
+            writer.write_u16(resolution.width - 1, 16);
+            writer.write_u16(resolution.height - 1, 16);
+        }
+    }
+}
+
+impl DecodeTargetChainIndices {
+    fn read(
+        decode_target_count: usize,
+        chain_count: usize,
+        buffer: &mut BitstreamReader,
+    ) -> Result<Self> {
+        let mut result = Self::default();
+        result.extend_from_buffer(decode_target_count, chain_count, buffer)?;
+        Ok(result)
+    }
+
+    fn extend_from_buffer(
+        &mut self,
+        decode_target_count: usize,
+        chain_count: usize,
+        buffer: &mut BitstreamReader,
+    ) -> Result<()> {
+        for _ in 0..decode_target_count {
+            let index = buffer.read_non_symmetric(chain_count as u8)?;
+            self.push(index);
+        }
+        Ok(())
+    }
+
+    fn write(&self, chain_count: usize, writer: &mut DefaultBitstreamWriter) {
+        for index in &self.0 {
+            writer.write_non_symmetric(chain_count, *index);
+        }
+    }
+}
+
+impl Layers {
+    fn read(buffer: &mut BitstreamReader) -> Result<(Layer, Layers)> {
+        let mut decode_target_layers = Layers::default();
+        let (mut spatial_id, mut temporal_id, mut max_temporal_id) = (0, 0, 0);
+        loop {
+            decode_target_layers.push(Layer {
+                spatial_id,
+                temporal_id,
+            });
+            match buffer.read_u8(2)? {
+                0 => {}
+                1 => {
+                    temporal_id = temporal_id
+                        .checked_add(1)
+                        .ok_or(anyhow!("Temporal ID overflow"))?;
+                    max_temporal_id = max_temporal_id.max(temporal_id);
+                }
+                2 => {
+                    temporal_id = 0;
+                    spatial_id = spatial_id
+                        .checked_add(1)
+                        .ok_or(anyhow!("Spatial ID overflow"))?;
+                }
+                3 => break,
+                _ => unreachable!(),
+            }
+        }
+        let max_layer = Layer {
+            spatial_id,
+            temporal_id: max_temporal_id,
+        };
+        Ok((max_layer, decode_target_layers))
+    }
+
+    fn write(&self, writer: &mut DefaultBitstreamWriter) {
+        let (mut spatial_id, mut temporal_id) = (0, 0);
+
+        for i in 1..self.0.len() {
+            let layer = self.0[i];
+            if layer.spatial_id == spatial_id {
+                if layer.temporal_id == temporal_id {
+                    writer.write_u8(0, 2);
+                } else {
+                    writer.write_u8(1, 2);
+                    temporal_id = layer.temporal_id;
+                }
+            } else {
+                writer.write_u8(2, 2);
+                spatial_id = layer.spatial_id;
+                temporal_id = 0;
+            }
+        }
+
+        writer.write_u8(3, 2);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use calling_common::PixelSize;
+
+    use crate::rtp::{
+        dependency_descriptor::DependencyDescriptor, ActiveDecodeTargetsBitmask, Dti,
+        ExtendedDescriptorFields, FrameDependencyDefinition, Layer, MandatoryDescriptorFields,
+        Template, TemplateDependencyStructure, TemplateDependencyStructureFields,
+    };
+
+    #[test]
+    fn test_decode_encode() {
+        let bytes = [
+            // stert of frame: true, end of frame: false
+            // template dependency structure present
+            // decode targets present
+            0b10101001, 0b00000100, 0b00110011, 0b11000101, 0b00000101, 0b00010100, 0b10000101,
+            0b00111010, 0b10111111, 0b10101010, 0b10100001, 0b10001111, 0b00000100, 0b00110000,
+            0b01000011, 0b00000010, 0b10100000, 0b00101010, 0b00000000, 0b01100000, 0b00000001,
+            0b00000000, 0b00011011, 0b10010011, 0b01000101, 0b00010101, 0b11100000, 0b10000010,
+            0b01110000, 0b01000110, 0b00001000, 0b11000000, 0b11000111, 0b10000111, 0b00000000,
+            0b01000011, 0b00100001, 0b01100101, 0b00010001, 0b00010001, 0b01010100, 0b00110010,
+            0b01110110, 0b10000000, 0b10011111, 0b10000000, 0b01110111, 0b10000001, 0b00111111,
+            0b10000000, 0b11101111, 0b10000000,
+        ];
+
+        let deserialized = DependencyDescriptor::read(&bytes, None).expect("decode succeeds");
+        assert_eq!(bytes, deserialized.serialize().as_slice());
+    }
+
+    #[test]
+    fn test_encode_decode_with_custom_fields() {
+        let template = Template {
+            dtis: [Dti::Required, Dti::NotPresent, Dti::NotPresent].into(),
+            chains: [5, 6, 7].into(),
+            ..Default::default()
+        };
+        let template_dependency_structure =
+            TemplateDependencyStructure::new(TemplateDependencyStructureFields {
+                decode_target_count: 3,
+                chain_count: 3,
+                decode_target_chain_indices: Some([0, 1, 2].into()),
+                decode_target_layers: [Layer::zero(), Layer::zero(), Layer::zero()].into(),
+                layers: [Layer::zero()].into(),
+                templates: [template].into(),
+                ..Default::default()
+            });
+        let descriptor = DependencyDescriptor {
+            mandatory_fields: MandatoryDescriptorFields {
+                start_of_frame: true,
+                end_of_frame: false,
+                frame_dependency_template_id: 0,
+                frame_number: 0xc350,
+            },
+            extended_fields: Some(ExtendedDescriptorFields {
+                template_dependency_structure: Some(template_dependency_structure),
+                active_decode_targets_bitmask: ActiveDecodeTargetsBitmask::Available {
+                    bitmask: 3,
+                    size: 3,
+                },
+                custom_dtis: Some([Dti::Required, Dti::NotPresent, Dti::NotPresent].into()),
+                custom_fdiffs: Some([0x6001, 0x6002, 0x6003].into()),
+                custom_chains: Some([10, 11, 12].into()),
+            }),
+        };
+
+        let serialized = descriptor.serialize();
+        let deserialized = DependencyDescriptor::read(&serialized, None).expect("decode succeeds");
+        assert_eq!(deserialized, descriptor);
+    }
+
+    #[test]
+    fn read_camera_layer_0() -> anyhow::Result<()> {
+        let bytes = [
+            0b11000000,
+            0b00000000,
+            0b00000001,
+            0b10000000, // The first bit in this byte indicates that this is for a key frame.
+            0b00000010,
+            0b00000100,
+            0b01001110,
+            0b10101010,
+            0b10101111,
+            0b00101000,
+            0b01100000,
+            0b01000001,
+            0b01001101,
+            0b00110100,
+            0b01010011,
+            0b10001010,
+            0b00001001,
+            0b01000000,
+            // The resolution is 160x120, but the value on the wire is one pixel smaller than the
+            // real resolution. 159x119 in binary is 0b1001_1111 x 0b0111_0111 and each value is
+            // stored as 2 bytes.
+            //
+            // The second bit in the following byte indicates that a resolution is included.
+            // The third bit is where the width starts.
+            0b01_000000,
+            0b00_100111,
+            // The third bit in the following byte is where the height starts.
+            0b11_000000,
+            0b00_011101,
+            0b11_000000,
+        ];
+
+        let descriptor = DependencyDescriptor::read(&bytes, None)?;
+
+        assert!(descriptor.is_key_frame());
+        assert_eq!(
+            descriptor.resolution(),
+            Some(PixelSize {
+                width: 160,
+                height: 120
+            })
+        );
+
+        Ok(())
+    }
+
+    #[test]
+    fn read_screenshare() -> anyhow::Result<()> {
+        let bytes = [
+            0b10000000,
+            0b00001011,
+            0b00001011,
+            0b10000000, // The first bit in this byte indicates that this is for a key frame.
+            0b00000001,
+            0b00000100,
+            0b11101010,
+            0b10101100,
+            0b10000101,
+            0b00010100,
+            0b01010000,
+            0b01000110,
+            0b0000_0100, // width - 1 is 2879 / 0b0000_1011_0011_1111 (starting on the 7th bit)
+            0b0010_1100,
+            0b1111_1100, // height - 1 is 1619 / 0b0000_0110_0101_0011 (from the 7th bit)
+            0b0001_1001,
+            0b0100_1100,
+        ];
+
+        let descriptor = DependencyDescriptor::read(&bytes, None)?;
+
+        assert!(descriptor.is_key_frame());
+        assert_eq!(
+            descriptor.resolution(),
+            Some(PixelSize {
+                width: 2880,
+                height: 1620
+            })
+        );
+
+        Ok(())
+    }
+
+    #[test]
+    fn read_no_dependency_structure() -> anyhow::Result<()> {
+        let bytes = [0b10000011, 0b00000001, 0b01100101];
+        let descriptor = DependencyDescriptor::read(&bytes, None)?;
+
+        assert!(!descriptor.is_key_frame());
+        assert_eq!(descriptor.resolution(), None);
+
+        Ok(())
+    }
+
+    #[test]
+    fn read_ignore_custom_fdiffs() -> anyhow::Result<()> {
+        let bytes = [
+            0b10000010,
+            0b00001011,
+            0b00101100,
+            // The first bit in the following byte indicates that this isn't a keyframe. The fourth
+            // bit indicates that there are custom fdiffs.
+            0b0001_0010,
+            0b01000000,
+        ];
+
+        let descriptor = DependencyDescriptor::read(&bytes, None)?;
+
+        assert!(!descriptor.is_key_frame());
+        assert_eq!(descriptor.resolution(), None);
+
+        Ok(())
+    }
+
+    #[test]
+    fn valid_template_id() -> anyhow::Result<()> {
+        let template = TemplateDependencyStructure::new(TemplateDependencyStructureFields {
+            template_id_offset: 4,
+            templates: [Template::default(), Template::default()].into(),
+            ..Default::default()
+        });
+        assert!(FrameDependencyDefinition::new(&template, None, 0).is_err());
+        FrameDependencyDefinition::new(&template, None, 4)?;
+        FrameDependencyDefinition::new(&template, None, 5)?;
+        assert!(FrameDependencyDefinition::new(&template, None, 6).is_err());
+
+        let template = TemplateDependencyStructure::new(TemplateDependencyStructureFields {
+            template_id_offset: 0,
+            templates: [Template::default(), Template::default()].into(),
+            ..Default::default()
+        });
+        assert!(FrameDependencyDefinition::new(&template, None, 15).is_err());
+        FrameDependencyDefinition::new(&template, None, 1)?;
+        FrameDependencyDefinition::new(&template, None, 0)?;
+        assert!(FrameDependencyDefinition::new(&template, None, 2).is_err());
+
+        Ok(())
+    }
+}
diff --git a/backend/src/rtp/packet.rs b/backend/src/rtp/packet.rs
index 1022cdb..de2ab85 100644
--- a/backend/src/rtp/packet.rs
+++ b/backend/src/rtp/packet.rs
@@ -11,7 +11,7 @@ use std::{
 
 use aes::cipher::{generic_array::GenericArray, KeyInit};
 use aes_gcm::{AeadInPlace, Aes128Gcm};
-use anyhow::{anyhow, bail, Result};
+use anyhow::{anyhow, Result};
 use calling_common::{
     parse_u16, parse_u32, round_up_to_multiple_of, CheckedSplitAt, DataRate, DataSize, Instant,
     PixelSize, Writer,
@@ -21,10 +21,15 @@ use metrics::event;
 
 use super::{
     from_rtx_payload_type, from_rtx_ssrc, is_audio_payload_type, is_padding_payload_type,
-    is_video_payload_type, srtp::*, to_rtx_payload_type, to_rtx_ssrc, types::*, VideoRotation,
-    CLIENT_SERVER_DATA_PAYLOAD_TYPE, PACKET_LIFETIME, VERSION, VP8_PAYLOAD_TYPE,
+    is_video_payload_type, srtp::*, to_rtx_payload_type, to_rtx_ssrc, types::*,
+    TemplateDependencyStructure, VideoRotation, CLIENT_SERVER_DATA_PAYLOAD_TYPE, PACKET_LIFETIME,
+    VERSION, VP8_PAYLOAD_TYPE,
+};
+use crate::{
+    audio,
+    bitstream::BitstreamReader,
+    rtp::{dependency_descriptor::DependencyDescriptor, tcc, VP9_PAYLOAD_TYPE},
 };
-use crate::{audio, rtp::tcc};
 
 const RTP_MIN_HEADER_LEN: usize = 12;
 pub const RTP_PAYLOAD_TYPE_OFFSET: usize = 1;
@@ -104,7 +109,10 @@ pub struct Header {
 
 impl Header {
     // pub for tests
-    pub fn parse(packet: &[u8]) -> Option<Self> {
+    pub fn parse(
+        packet: &[u8],
+        template_dependency_structure: Option<&TemplateDependencyStructure>,
+    ) -> Option<Self> {
         let (main_header, csrcs_extensions_payload_tag) =
             packet.checked_split_at(RTP_MIN_HEADER_LEN)?;
 
@@ -223,10 +231,10 @@ impl Header {
                             );
                             return None;
                         }
-
-                        dependency_descriptor = read_dependency_descriptor(val)
-                            .ok()
-                            .map(|descriptor| (descriptor, extension_val_range));
+                        dependency_descriptor =
+                            DependencyDescriptor::read(val, template_dependency_structure)
+                                .ok()
+                                .map(|descriptor| (descriptor, extension_val_range));
                     }
                     (RTP_EXT_ID_VIDEO_LAYERS_ALLOCATION, val) => {
                         video_layers_allocation = read_video_layers_allocation(val).ok();
@@ -283,211 +291,6 @@ impl Header {
     }
 }
 
-#[derive(Debug)]
-struct BitBuffer<'a> {
-    bytes: &'a [u8],
-    /// The index into `bytes` of the next byte to read.
-    byte_index: usize,
-    /// The offset into `bytes[byte_index]` of the next bit to read. In the range 0..=7.
-    bit_offset: u8,
-}
-
-impl<'a> BitBuffer<'a> {
-    pub fn new(bytes: &'a [u8]) -> Self {
-        Self {
-            bytes,
-            byte_index: 0,
-            bit_offset: 0,
-        }
-    }
-
-    /// An implementation of the `f(n)` function in the spec, where 0 < n <= 8:
-    /// https://aomediacodec.github.io/av1-rtp-spec/#a82-syntax
-    fn read_u8(&mut self, bits: u8) -> Result<u8> {
-        assert!(bits > 0 && bits <= 8);
-
-        let bytes_len = self.bytes.len();
-        if self.byte_index >= bytes_len
-            || (self.bit_offset + bits > 8 && self.byte_index + 1 == bytes_len)
-        {
-            bail!(
-                "out of bounds access: byte_index={}, bit_offset={}, bits={bits}, bytes_len={}",
-                self.byte_index,
-                self.bit_offset,
-                bytes_len,
-            );
-        }
-
-        let mut byte: u8;
-        if self.bit_offset + bits >= 8 {
-            // Need to read the remainder of the current byte, and potentially some of the
-            // following byte.
-            byte = self.bytes[self.byte_index];
-
-            let num_bits_in_current_byte = 8 - self.bit_offset;
-            if num_bits_in_current_byte < 8 {
-                byte &= (1 << num_bits_in_current_byte) - 1;
-            }
-            let num_bits_in_next_byte = bits - num_bits_in_current_byte;
-            byte <<= num_bits_in_next_byte;
-
-            if num_bits_in_next_byte > 0 {
-                let next_byte = self.bytes[self.byte_index + 1];
-                let mask = ((1 << num_bits_in_next_byte) - 1) << (8 - num_bits_in_next_byte);
-                byte |= (next_byte & mask) >> (8 - num_bits_in_next_byte);
-            }
-
-            self.byte_index += 1;
-            self.bit_offset = (self.bit_offset + bits) % 8;
-        } else {
-            // Only need to look at the current byte.
-            byte = self.bytes[self.byte_index];
-            byte &= ((1 << bits) - 1) << (8 - self.bit_offset - bits);
-            byte >>= 8 - self.bit_offset - bits;
-
-            self.bit_offset += bits;
-        }
-
-        Ok(byte)
-    }
-
-    /// A special case of the `f(n)` function where n = 16:
-    /// https://aomediacodec.github.io/av1-rtp-spec/#a82-syntax
-    fn read_u16(&mut self) -> Result<u16> {
-        match (self.read_u8(8), self.read_u8(8)) {
-            (Ok(upper), Ok(lower)) => Ok(u16::from_be_bytes([upper, lower])),
-            (Err(err), _) => Err(err),
-            (_, Err(err)) => Err(err),
-        }
-    }
-
-    /// A variant of the `ns(n)` function in the spec which doesn't return the result:
-    /// https://aomediacodec.github.io/av1-rtp-spec/#a82-syntax
-    fn skip_non_symmetric(&mut self, n: u8) -> Result<()> {
-        let mut w = 0;
-        let mut x = n;
-        while x != 0 {
-            x >>= 1;
-            w += 1;
-        }
-
-        let m = (1 << w) - n;
-        let v = self.read_u8(w - 1)?;
-        if v < m {
-            return Ok(());
-        }
-
-        let _extra_bit = self.read_u8(1)?;
-        Ok(())
-    }
-
-    fn has_more(&mut self) -> bool {
-        self.byte_index < self.bytes.len()
-    }
-
-    fn zero_pad(&mut self) {
-        if self.bit_offset > 0 {
-            self.bit_offset = 0;
-            self.byte_index += 1;
-        }
-    }
-    /// An implementation of https://aomediacodec.github.io/av1-spec/#leb128
-    fn read_leb128(&mut self) -> Result<u128> {
-        let mut value = 0;
-        for i in 0..8 {
-            let byte = self.read_u8(8)? as u128;
-            value |= (byte & 0x7f) << (i * 7);
-            if byte & 0x80 == 0 {
-                break;
-            }
-        }
-        Ok(value)
-    }
-}
-
-/// https://aomediacodec.github.io/av1-rtp-spec/#dependency-descriptor-rtp-header-extension
-#[derive(Copy, Clone, Debug, PartialEq, Eq)]
-pub struct DependencyDescriptor {
-    pub is_key_frame: bool,
-    pub resolution: Option<PixelSize>,
-    pub truncated_frame_number: u16,
-}
-
-/// An implementation of the pseudocode from the following section of the spec:
-/// https://aomediacodec.github.io/av1-rtp-spec/#a82-syntax
-///
-/// The meaning of each parsed field is here:
-/// https://aomediacodec.github.io/av1-rtp-spec/#a83-semantics
-fn read_dependency_descriptor(bytes: &[u8]) -> Result<DependencyDescriptor> {
-    let mut data = BitBuffer::new(bytes);
-
-    // Ignore start_of_frame, end_of_frame, and frame_dependency_template_id.
-    data.byte_index = 1;
-
-    let truncated_frame_number = data.read_u16()?;
-    if data.bytes.len() == 3 {
-        return Ok(DependencyDescriptor {
-            is_key_frame: false,
-            resolution: None,
-            truncated_frame_number,
-        });
-    }
-
-    let template_dependency_structure_present_flag = data.read_u8(1)? == 1;
-    let _active_decode_targets_present_flag = data.read_u8(1)?;
-    let _custom_dtis_flag = data.read_u8(1)?;
-    let _custom_fdiffs_flag = data.read_u8(1)?;
-    let _custom_chains_flag = data.read_u8(1)?;
-
-    if !template_dependency_structure_present_flag {
-        return Ok(DependencyDescriptor {
-            is_key_frame: false,
-            resolution: None,
-            truncated_frame_number,
-        });
-    }
-
-    let _template_id_offset = data.read_u8(6)?;
-    let dt_cnt = data.read_u8(5)? + 1;
-
-    // template_layers
-    let mut template_cnt = 1;
-    while data.read_u8(2)? != 3 {
-        template_cnt += 1;
-    }
-
-    // template_dtis
-    for _ in 0..template_cnt {
-        for _ in 0..dt_cnt {
-            let _template_dti = data.read_u8(2)?;
-        }
-    }
-
-    // template_fdiffs
-    for _ in 0..template_cnt {
-        while data.read_u8(1)? == 1 {
-            let _fdiff_minus_one = data.read_u8(4)?;
-        }
-    }
-
-    // Skip over template_chains since we don't use SVC, so num_chains is 0.
-    data.skip_non_symmetric(dt_cnt + 1)?;
-
-    let mut resolution = None;
-    let resolutions_present_flag = data.read_u8(1)?;
-    if resolutions_present_flag == 1 {
-        let width = data.read_u16()?.saturating_add(1);
-        let height = data.read_u16()?.saturating_add(1);
-        resolution = Some(PixelSize { width, height });
-    }
-
-    Ok(DependencyDescriptor {
-        is_key_frame: true,
-        resolution,
-        truncated_frame_number,
-    })
-}
-
 type RtpStreamAllocation = Vec<SpatialLayer>;
 
 /// http://www.webrtc.org/experiments/rtp-hdrext/video-layers-allocation00
@@ -519,7 +322,7 @@ fn read_video_layers_allocation(bytes: &[u8]) -> Result<Vec<RtpStreamAllocation>
         return Ok(vec![]);
     }
 
-    let mut data = BitBuffer::new(bytes);
+    let mut data = BitstreamReader::new(bytes);
 
     let _rid = data.read_u8(2)?;
     let ns = data.read_u8(2)? + 1;
@@ -566,8 +369,8 @@ fn read_video_layers_allocation(bytes: &[u8]) -> Result<Vec<RtpStreamAllocation>
         for allocation in allocations.iter_mut() {
             for spatial_layer in allocation.iter_mut() {
                 spatial_layer.size = Some(PixelSize {
-                    width: data.read_u16()? + 1,
-                    height: data.read_u16()? + 1,
+                    width: data.read_u16(16)? + 1,
+                    height: data.read_u16(16)? + 1,
                 });
                 // Our server has no use for the framerate
                 let _framerate = Some(data.read_u8(8)?);
@@ -752,6 +555,10 @@ impl<T> Packet<T> {
         self.payload_type() == VP8_PAYLOAD_TYPE
     }
 
+    pub fn is_vp9(&self) -> bool {
+        self.payload_type() == VP9_PAYLOAD_TYPE
+    }
+
     pub fn is_data(&self) -> bool {
         self.payload_type() == CLIENT_SERVER_DATA_PAYLOAD_TYPE
     }
@@ -769,7 +576,7 @@ impl<T> Packet<T> {
 }
 
 impl<T: Borrow<[u8]>> Packet<T> {
-    pub(super) fn serialized(&self) -> &[u8] {
+    pub fn serialized(&self) -> &[u8] {
         self.serialized.borrow()
     }
 
@@ -973,12 +780,13 @@ impl<T: BorrowMut<[u8]>> Packet<T> {
     }
 
     pub fn set_frame_number_in_header(&mut self, frame_number: FullFrameNumber) {
-        let Some((_, range)) = &self.dependency_descriptor else {
+        let Some((dependency_descriptor, range)) = &mut self.dependency_descriptor else {
             return;
         };
 
         // Refer to https://aomediacodec.github.io/av1-rtp-spec/#a82-syntax for dependency
         // descriptor format.
+        dependency_descriptor.mandatory_fields.frame_number = frame_number as u16;
         let frame_number_start = range.start + 1;
         self.write_in_header(
             frame_number_start..(frame_number_start + std::mem::size_of::<TruncatedFrameNumber>()),
@@ -1051,47 +859,23 @@ fn write_two_byte_extension(id: u8, value: impl Writer) -> impl Writer {
 
 // Supports the subset of dependency descriptor features that the tests (and load_test) need.
 #[cfg(any(test, feature = "load_test"))]
-pub fn write_dependency_descriptor(dependency_descriptor: DependencyDescriptor) -> Box<dyn Writer> {
-    let frame_number = dependency_descriptor.truncated_frame_number.to_be_bytes();
+pub fn write_dependency_descriptor(
+    dependency_descriptor: &DependencyDescriptor,
+) -> Box<dyn Writer> {
+    use crate::rtp::dependency_descriptor::DefaultBitstreamWriter;
 
-    if let Some(PixelSize { width, height }) = dependency_descriptor.resolution {
-        // key frame
-        let width_minus_1 = width - 1;
-        let height_minus_1 = height - 1;
+    let mut writer = DefaultBitstreamWriter::default();
+    dependency_descriptor.write(&mut writer);
+    let serialized = writer.as_slice().to_owned();
+    if dependency_descriptor.is_key_frame() {
         Box::new(write_two_byte_extension(
             RTP_EXT_ID_DEPENDENCY_DESCRIPTOR,
-            (
-                [0b10000000u8],
-                frame_number,
-                [
-                    0b10000000u8, // The first bit in this byte indicates that this is for a key frame.
-                    0b00000010,
-                    0b00000100,
-                    0b01001110,
-                    0b10101010,
-                    0b10101111,
-                    0b00101000,
-                    0b01100000,
-                    0b01000001,
-                    0b01001101,
-                    0b00110100,
-                    0b01010011,
-                    0b10001010,
-                    0b00001001,
-                    0b01000000,
-                    0b0100_0000 | ((width_minus_1 >> 10) as u8), // width - 1 from 3rd bit
-                    ((width_minus_1 >> 2) & 0xFF) as u8,
-                    (((width_minus_1 & 0b0000_0011) << 6) as u8) | ((height_minus_1 >> 10) as u8), // height - 1 from 3rd bit
-                    ((height_minus_1 >> 2) & 0xFF) as u8,
-                    ((height_minus_1 & 0b0000_0011) << 6) as u8,
-                ],
-            ),
+            serialized,
         ))
     } else {
-        // delta frame
         Box::new(write_extension(
             RTP_EXT_ID_DEPENDENCY_DESCRIPTOR,
-            ([0b10000011u8], frame_number),
+            serialized,
         ))
     }
 }
@@ -1219,7 +1003,7 @@ impl Packet<Vec<u8>> {
         payload: &[u8],
     ) -> Self {
         let marker = false;
-        let extensions = write_dependency_descriptor(dependency_descriptor);
+        let extensions = write_dependency_descriptor(&dependency_descriptor);
         let extensions_len = extensions.written_len();
         let profile = if extensions_len > 16 || extensions_len == 0 {
             HeaderExtensionsProfile::TwoByte
@@ -1267,20 +1051,39 @@ impl Packet<Vec<u8>> {
         timestamp: TruncatedTimestamp,
         payload: &[u8],
     ) -> Packet<Vec<u8>> {
+        use crate::rtp::dependency_descriptor::*;
+
         let marker = false;
         let pt = VP8_PAYLOAD_TYPE;
 
+        let mandatory_fields = MandatoryDescriptorFields {
+            frame_number: truncated_frame_number,
+            ..Default::default()
+        };
+        let extended_fields = if is_key_frame {
+            let template_dependency_structure = Some(TemplateDependencyStructure::new(
+                TemplateDependencyStructureFields {
+                    resolutions: resolution.map(|r| [r.into()].into()),
+                    ..Default::default()
+                },
+            ));
+            Some(ExtendedDescriptorFields {
+                template_dependency_structure,
+                ..Default::default()
+            })
+        } else {
+            None
+        };
         let dependency_descriptor = DependencyDescriptor {
-            is_key_frame,
-            resolution: if is_key_frame { resolution } else { None },
-            truncated_frame_number,
+            extended_fields,
+            mandatory_fields,
         };
 
         let ((serialized, payload_range), tcc_seqnum_range) =
-            if dependency_descriptor.resolution.is_some() {
+            if dependency_descriptor.resolution().is_some() {
                 let extensions = (
                     write_two_byte_extension(RTP_EXT_ID_TCC_SEQNUM, 0u16),
-                    write_dependency_descriptor(dependency_descriptor),
+                    write_dependency_descriptor(&dependency_descriptor),
                 );
 
                 (
@@ -1299,7 +1102,7 @@ impl Packet<Vec<u8>> {
             } else {
                 let extensions = (
                     write_extension(RTP_EXT_ID_TCC_SEQNUM, 0u16),
-                    write_dependency_descriptor(dependency_descriptor),
+                    write_dependency_descriptor(&dependency_descriptor),
                 );
                 (
                     Self::write_serialized(
@@ -1378,283 +1181,6 @@ impl Packet<Vec<u8>> {
     }
 }
 
-#[cfg(test)]
-mod bit_buffer_tests {
-    use super::*;
-
-    #[test]
-    fn read_u8() -> Result<()> {
-        let bytes = [0b0000_0010, 0b1010_0000];
-        let mut rdr = BitBuffer::new(&bytes);
-
-        assert_eq!(rdr.read_u8(1)?, 0);
-
-        rdr.bit_offset = 1;
-        assert_eq!(rdr.read_u8(1)?, 0);
-
-        rdr.bit_offset = 6;
-        assert_eq!(rdr.read_u8(1)?, 1);
-
-        rdr.bit_offset = 3;
-        assert_eq!(rdr.read_u8(5)?, 0b10);
-
-        rdr.byte_index = 0;
-        rdr.bit_offset = 6;
-        assert_eq!(rdr.read_u8(3)?, 0b101);
-
-        Ok(())
-    }
-
-    #[test]
-    fn read_u8_error() -> Result<()> {
-        let bytes = [];
-        let mut rdr = BitBuffer::new(&bytes);
-        assert!(!rdr.has_more());
-        assert!(rdr.read_u8(8).is_err());
-        assert!(rdr.read_u8(1).is_err());
-
-        let bytes = [0b1000_0000];
-        let mut rdr = BitBuffer::new(&bytes);
-        assert!(rdr.has_more());
-        assert_eq!(rdr.read_u8(1)?, 1);
-
-        assert!(rdr.has_more());
-        assert!(rdr.read_u8(8).is_err());
-
-        assert_eq!(rdr.read_u8(1)?, 0);
-        assert!(rdr.has_more());
-        assert!(rdr.read_u8(8).is_err());
-        assert!(rdr.read_u8(7).is_err());
-
-        assert_eq!(rdr.read_u8(1)?, 0);
-        assert!(rdr.has_more());
-        assert!(rdr.read_u8(8).is_err());
-        assert!(rdr.read_u8(7).is_err());
-        assert!(rdr.read_u8(6).is_err());
-
-        assert_eq!(rdr.read_u8(1)?, 0);
-        assert!(rdr.has_more());
-        assert!(rdr.read_u8(8).is_err());
-        assert!(rdr.read_u8(7).is_err());
-        assert!(rdr.read_u8(6).is_err());
-        assert!(rdr.read_u8(5).is_err());
-
-        assert_eq!(rdr.read_u8(1)?, 0);
-        assert!(rdr.has_more());
-        assert!(rdr.read_u8(8).is_err());
-        assert!(rdr.read_u8(7).is_err());
-        assert!(rdr.read_u8(6).is_err());
-        assert!(rdr.read_u8(5).is_err());
-        assert!(rdr.read_u8(4).is_err());
-
-        assert_eq!(rdr.read_u8(1)?, 0);
-        assert!(rdr.has_more());
-        assert!(rdr.read_u8(8).is_err());
-        assert!(rdr.read_u8(7).is_err());
-        assert!(rdr.read_u8(6).is_err());
-        assert!(rdr.read_u8(5).is_err());
-        assert!(rdr.read_u8(4).is_err());
-        assert!(rdr.read_u8(3).is_err());
-
-        assert_eq!(rdr.read_u8(1)?, 0);
-        assert!(rdr.has_more());
-        assert!(rdr.read_u8(8).is_err());
-        assert!(rdr.read_u8(7).is_err());
-        assert!(rdr.read_u8(6).is_err());
-        assert!(rdr.read_u8(5).is_err());
-        assert!(rdr.read_u8(4).is_err());
-        assert!(rdr.read_u8(3).is_err());
-        assert!(rdr.read_u8(2).is_err());
-
-        assert_eq!(rdr.read_u8(1)?, 0);
-        assert!(!rdr.has_more());
-        assert!(rdr.read_u8(8).is_err());
-        assert!(rdr.read_u8(7).is_err());
-        assert!(rdr.read_u8(6).is_err());
-        assert!(rdr.read_u8(5).is_err());
-        assert!(rdr.read_u8(4).is_err());
-        assert!(rdr.read_u8(3).is_err());
-        assert!(rdr.read_u8(2).is_err());
-        assert!(rdr.read_u8(1).is_err());
-
-        Ok(())
-    }
-
-    #[test]
-    fn read_u8_two_bytes() -> Result<()> {
-        let bytes = [0b0000_0010, 0b1010_0011];
-        let mut rdr = BitBuffer::new(&bytes);
-
-        assert_eq!(rdr.read_u8(1)?, 0);
-        assert_eq!(rdr.read_u8(1)?, 0);
-        assert_eq!(rdr.read_u8(5)?, 0b1);
-        assert_eq!(rdr.read_u8(1)?, 0);
-        assert_eq!(rdr.read_u8(4)?, 0b1010);
-        assert_eq!(rdr.read_u8(2)?, 0b0);
-        assert_eq!(rdr.read_u8(1)?, 0b1);
-        assert_eq!(rdr.read_u8(1)?, 0b1);
-
-        assert!(rdr.read_u8(1).is_err());
-
-        Ok(())
-    }
-
-    #[test]
-    fn read_u8_one_byte() -> Result<()> {
-        let bytes = [0b0001_1011];
-        let mut rdr = BitBuffer::new(&bytes);
-
-        assert_eq!(rdr.read_u8(1)?, 0);
-        assert_eq!(rdr.read_u8(1)?, 0);
-        assert_eq!(rdr.read_u8(1)?, 0);
-        assert_eq!(rdr.read_u8(1)?, 1);
-        assert_eq!(rdr.read_u8(1)?, 1);
-        assert_eq!(rdr.read_u8(1)?, 0);
-        assert_eq!(rdr.read_u8(1)?, 1);
-        assert_eq!(rdr.read_u8(1)?, 1);
-
-        rdr.byte_index = 0;
-        rdr.bit_offset = 0;
-        assert_eq!(rdr.read_u8(2)?, 0b0);
-        assert_eq!(rdr.read_u8(2)?, 0b1);
-        assert_eq!(rdr.read_u8(2)?, 0b10);
-        assert_eq!(rdr.read_u8(2)?, 0b11);
-
-        rdr.byte_index = 0;
-        rdr.bit_offset = 0;
-        assert_eq!(rdr.read_u8(4)?, 0b1);
-        assert_eq!(rdr.read_u8(4)?, 0b1011);
-
-        rdr.byte_index = 0;
-        rdr.bit_offset = 0;
-        assert_eq!(rdr.read_u8(5)?, 0b11);
-        assert_eq!(rdr.read_u8(3)?, 0b11);
-
-        rdr.byte_index = 0;
-        rdr.bit_offset = 0;
-        assert_eq!(rdr.read_u8(8)?, 0b0001_1011);
-
-        Ok(())
-    }
-}
-
-#[cfg(test)]
-mod dependency_descriptor_tests {
-    use super::*;
-    #[test]
-    fn read_camera_layer_0() -> Result<()> {
-        let bytes = [
-            0b11000000,
-            0b00000000,
-            0b00000001,
-            0b10000000, // The first bit in this byte indicates that this is for a key frame.
-            0b00000010,
-            0b00000100,
-            0b01001110,
-            0b10101010,
-            0b10101111,
-            0b00101000,
-            0b01100000,
-            0b01000001,
-            0b01001101,
-            0b00110100,
-            0b01010011,
-            0b10001010,
-            0b00001001,
-            0b01000000,
-            // The resolution is 160x120, but the value on the wire is one pixel smaller than the
-            // real resolution. 159x119 in binary is 0b1001_1111 x 0b0111_0111 and each value is
-            // stored as 2 bytes.
-            //
-            // The second bit in the following byte indicates that a resolution is included.
-            // The third bit is where the width starts.
-            0b01_000000,
-            0b00_100111,
-            // The third bit in the following byte is where the height starts.
-            0b11_000000,
-            0b00_011101,
-            0b11_000000,
-        ];
-        let descriptor = read_dependency_descriptor(&bytes)?;
-
-        assert!(descriptor.is_key_frame);
-        assert_eq!(
-            descriptor.resolution,
-            Some(PixelSize {
-                width: 160,
-                height: 120
-            })
-        );
-
-        Ok(())
-    }
-
-    #[test]
-    fn read_screenshare() -> Result<()> {
-        let bytes = [
-            0b10000000,
-            0b00001011,
-            0b00001011,
-            0b10000000, // The first bit in this byte indicates that this is for a key frame.
-            0b00000001,
-            0b00000100,
-            0b11101010,
-            0b10101100,
-            0b10000101,
-            0b00010100,
-            0b01010000,
-            0b01000110,
-            0b0000_0100, // width - 1 is 2879 / 0b0000_1011_0011_1111 (starting on the 7th bit)
-            0b0010_1100,
-            0b1111_1100, // height - 1 is 1619 / 0b0000_0110_0101_0011 (from the 7th bit)
-            0b0001_1001,
-            0b0100_1100,
-        ];
-        let descriptor = read_dependency_descriptor(&bytes)?;
-
-        assert!(descriptor.is_key_frame);
-        assert_eq!(
-            descriptor.resolution,
-            Some(PixelSize {
-                width: 2880,
-                height: 1620
-            })
-        );
-
-        Ok(())
-    }
-
-    #[test]
-    fn read_no_dependency_structure() -> Result<()> {
-        let bytes = [0b10000011, 0b00000001, 0b01100101];
-        let descriptor = read_dependency_descriptor(&bytes)?;
-
-        assert!(!descriptor.is_key_frame);
-        assert_eq!(descriptor.resolution, None);
-
-        Ok(())
-    }
-
-    #[test]
-    fn read_ignore_custom_fdiffs() -> Result<()> {
-        let bytes = [
-            0b10000010,
-            0b00001011,
-            0b00101100,
-            // The first bit in the following byte indicates that this isn't a keyframe. The fourth
-            // bit indicates that there are custom fdiffs.
-            0b0001_0010,
-            0b01000000,
-        ];
-        let descriptor = read_dependency_descriptor(&bytes)?;
-
-        assert!(!descriptor.is_key_frame);
-        assert_eq!(descriptor.resolution, None);
-
-        Ok(())
-    }
-}
-
 #[cfg(test)]
 mod video_layers_allocation_tests {
     use super::*;
@@ -1913,7 +1439,11 @@ mod video_layers_allocation_tests {
 #[cfg(test)]
 mod test {
     use super::*;
-    use crate::rtp::{looks_like_rtcp, looks_like_rtp, RTCP_PAYLOAD_TYPE_OFFSET, RTCP_TYPE_BYE};
+    use crate::rtp::{
+        looks_like_rtcp, looks_like_rtp, ActiveDecodeTargetsBitmask, Dti, ExtendedDescriptorFields,
+        Layer, MandatoryDescriptorFields, Resolution, Template, TemplateDependencyStructure,
+        TemplateDependencyStructureFields, RTCP_PAYLOAD_TYPE_OFFSET, RTCP_TYPE_BYE,
+    };
 
     #[test]
     fn test_packet_classification_rtp() {
@@ -1970,7 +1500,7 @@ mod test {
 
     #[test]
     fn test_parse_rtp_header() {
-        assert_eq!(None, Header::parse(&[]));
+        assert_eq!(None, Header::parse(&[], None));
         let mut packet = Packet::with_empty_tag(1, 2, 3, 4, None, None, &[]).into_serialized();
         assert_eq!(
             Some(Header {
@@ -1988,20 +1518,20 @@ mod test {
                 payload_range: RTP_MIN_HEADER_LEN..RTP_MIN_HEADER_LEN,
                 video_layers_allocation: None,
             }),
-            Header::parse(&packet)
+            Header::parse(&packet, None)
         );
-        assert_eq!(None, Header::parse(&packet[..RTP_MIN_HEADER_LEN]));
-        assert_eq!(None, Header::parse(&packet[..SRTP_AUTH_TAG_LEN]));
-        assert_eq!(None, Header::parse(&packet[..SRTP_AUTH_TAG_LEN + 5]));
+        assert_eq!(None, Header::parse(&packet[..RTP_MIN_HEADER_LEN], None));
+        assert_eq!(None, Header::parse(&packet[..SRTP_AUTH_TAG_LEN], None));
+        assert_eq!(None, Header::parse(&packet[..SRTP_AUTH_TAG_LEN + 5], None));
         assert_eq!(
             None,
-            Header::parse(&packet[..packet.len() - SRTP_AUTH_TAG_LEN])
+            Header::parse(&packet[..packet.len() - SRTP_AUTH_TAG_LEN], None)
         );
 
         // Make it look like there are many CSRCS
         // (an evil packet)
         packet[0] |= 0b1111;
-        assert_eq!(None, Header::parse(&packet));
+        assert_eq!(None, Header::parse(&packet, None));
     }
 
     #[test]
@@ -2025,20 +1555,20 @@ mod test {
                 payload_range: expected_payload_start..expected_payload_start,
                 video_layers_allocation: None,
             }),
-            Header::parse(&packet)
+            Header::parse(&packet, None)
         );
-        assert_eq!(None, Header::parse(&packet[..RTP_MIN_HEADER_LEN]));
-        assert_eq!(None, Header::parse(&packet[..SRTP_AUTH_TAG_LEN]));
-        assert_eq!(None, Header::parse(&packet[..SRTP_AUTH_TAG_LEN + 5]));
+        assert_eq!(None, Header::parse(&packet[..RTP_MIN_HEADER_LEN], None));
+        assert_eq!(None, Header::parse(&packet[..SRTP_AUTH_TAG_LEN], None));
+        assert_eq!(None, Header::parse(&packet[..SRTP_AUTH_TAG_LEN + 5], None));
         assert_eq!(
             None,
-            Header::parse(&packet[..packet.len() - SRTP_AUTH_TAG_LEN])
+            Header::parse(&packet[..packet.len() - SRTP_AUTH_TAG_LEN], None)
         );
 
         // Make it look like there are many CSRCS
         // (an evil packet)
         packet[0] |= 0b1111;
-        assert_eq!(None, Header::parse(&packet));
+        assert_eq!(None, Header::parse(&packet, None));
     }
 
     #[test]
@@ -2055,7 +1585,7 @@ mod test {
                 HeaderExtensionsProfile::OneByte,
                 &[],
             );
-            let parsed = Header::parse(&packet).unwrap();
+            let parsed = Header::parse(&packet, None).unwrap();
             parsed.audio_level.unwrap()
         }
 
@@ -2106,7 +1636,7 @@ mod test {
                 payload_range,
                 video_layers_allocation: None,
             }),
-            Header::parse(&packet)
+            Header::parse(&packet, None)
         );
 
         let extensions = (
@@ -2139,7 +1669,7 @@ mod test {
                 payload_range,
                 video_layers_allocation: None,
             }),
-            Header::parse(&packet)
+            Header::parse(&packet, None)
         );
 
         // Try once more with extra tail padding.
@@ -2174,7 +1704,7 @@ mod test {
                 payload_range,
                 video_layers_allocation: None,
             }),
-            Header::parse(&packet)
+            Header::parse(&packet, None)
         );
     }
 
@@ -2207,7 +1737,7 @@ mod test {
                 payload_range,
                 video_layers_allocation: None,
             }),
-            Header::parse(&packet)
+            Header::parse(&packet, None)
         );
 
         let extensions = write_extension(RTP_EXT_ID_VIDEO_ORIENTATION, [0x2u8]);
@@ -2237,7 +1767,7 @@ mod test {
                 payload_range,
                 video_layers_allocation: None,
             }),
-            Header::parse(&packet)
+            Header::parse(&packet, None)
         );
 
         // Try once more with extra tail padding.
@@ -2271,18 +1801,21 @@ mod test {
                 payload_range,
                 video_layers_allocation: None,
             }),
-            Header::parse(&packet)
+            Header::parse(&packet, None)
         );
     }
 
     #[test]
     fn test_parse_rtp_header_with_dependency_descriptor() {
         let dependency_descriptor = DependencyDescriptor {
-            is_key_frame: false,
-            resolution: None,
-            truncated_frame_number: 357,
+            mandatory_fields: MandatoryDescriptorFields {
+                start_of_frame: true,
+                frame_number: 357,
+                ..Default::default()
+            },
+            ..Default::default()
         };
-        let extensions = write_dependency_descriptor(dependency_descriptor);
+        let extensions = write_dependency_descriptor(&dependency_descriptor);
         let (packet, payload_range) = Packet::write_serialized(
             false,
             1,
@@ -2309,23 +1842,51 @@ mod test {
                 payload_range,
                 video_layers_allocation: None,
             }),
-            Header::parse(&packet)
+            Header::parse(&packet, None)
         );
     }
 
     #[test]
     fn test_parse_rtp_header_two_byte_extensions() {
+        let template_dependency_structure = Some(TemplateDependencyStructure::new(
+            TemplateDependencyStructureFields {
+                decode_target_count: 1,
+                layers: [Layer::zero()].into(),
+                templates: [Template {
+                    layer: Layer::zero(),
+                    dtis: [Dti::Switch].into(),
+                    ..Default::default()
+                }]
+                .into(),
+                decode_target_layers: [Layer::zero()].into(),
+                resolutions: Some(
+                    [Resolution {
+                        width: 640,
+                        height: 400,
+                    }]
+                    .into(),
+                ),
+                ..Default::default()
+            },
+        ));
         let dependency_descriptor = DependencyDescriptor {
-            is_key_frame: true,
-            resolution: Some(PixelSize {
-                width: 640,
-                height: 480,
+            mandatory_fields: MandatoryDescriptorFields {
+                start_of_frame: true,
+                frame_number: 2135,
+                ..Default::default()
+            },
+            extended_fields: Some(ExtendedDescriptorFields {
+                template_dependency_structure,
+                active_decode_targets_bitmask: ActiveDecodeTargetsBitmask::Available {
+                    bitmask: 0,
+                    size: 1,
+                },
+                ..Default::default()
             }),
-            truncated_frame_number: 2135,
         };
         let extensions = (
             write_two_byte_extension(RTP_EXT_ID_VIDEO_ORIENTATION, [0x3u8]),
-            write_dependency_descriptor(dependency_descriptor),
+            write_dependency_descriptor(&dependency_descriptor),
         );
 
         let (packet, payload_range) = Packet::write_serialized(
@@ -2348,13 +1909,13 @@ mod test {
                 ssrc: 4,
                 video_rotation: Some(VideoRotation::Clockwise270),
                 audio_level: None,
-                dependency_descriptor: Some((dependency_descriptor, 21..44)),
+                dependency_descriptor: Some((dependency_descriptor, 21..31)),
                 tcc_seqnum: None,
                 tcc_seqnum_range: None,
                 payload_range,
                 video_layers_allocation: None,
             }),
-            Header::parse(&packet)
+            Header::parse(&packet, None)
         );
     }
 
@@ -2409,12 +1970,95 @@ mod test {
                 audio_level: None,
                 dependency_descriptor: Some((
                     DependencyDescriptor {
-                        is_key_frame: true,
-                        resolution: Some(PixelSize {
-                            width: 2880,
-                            height: 1620,
-                        }),
-                        truncated_frame_number: 2,
+                        mandatory_fields: MandatoryDescriptorFields {
+                            start_of_frame: true,
+                            frame_number: 2,
+                            ..Default::default()
+                        },
+                        extended_fields: Some(ExtendedDescriptorFields {
+                            active_decode_targets_bitmask:
+                                ActiveDecodeTargetsBitmask::AllImplicitlyActive {
+                                    bitmask: (1u32 << 2) - 1,
+                                    size: 2,
+                                },
+                            template_dependency_structure: Some(TemplateDependencyStructure::new(
+                                TemplateDependencyStructureFields {
+                                    decode_target_count: 2,
+                                    max_layer: Layer {
+                                        spatial_id: 0,
+                                        temporal_id: 1
+                                    },
+                                    layers: [
+                                        Layer::zero(),
+                                        Layer::zero(),
+                                        Layer::zero(),
+                                        Layer {
+                                            spatial_id: 0,
+                                            temporal_id: 1
+                                        },
+                                        Layer {
+                                            spatial_id: 0,
+                                            temporal_id: 1
+                                        }
+                                    ]
+                                    .into(),
+                                    templates: vec![
+                                        Template {
+                                            layer: Layer::zero(),
+                                            dtis: [Dti::Switch, Dti::Switch].into(),
+                                            ..Default::default()
+                                        },
+                                        Template {
+                                            layer: Layer::zero(),
+                                            dtis: [Dti::Switch, Dti::Switch].into(),
+                                            fdiffs: [2].into(),
+                                            ..Default::default()
+                                        },
+                                        Template {
+                                            layer: Layer::zero(),
+                                            dtis: [Dti::Switch, Dti::Required].into(),
+                                            fdiffs: [2].into(),
+                                            ..Default::default()
+                                        },
+                                        Template {
+                                            layer: Layer {
+                                                spatial_id: 0,
+                                                temporal_id: 1
+                                            },
+                                            dtis: [Dti::NotPresent, Dti::Switch].into(),
+                                            fdiffs: [1].into(),
+                                            ..Default::default()
+                                        },
+                                        Template {
+                                            layer: Layer {
+                                                spatial_id: 0,
+                                                temporal_id: 1
+                                            },
+                                            dtis: [Dti::NotPresent, Dti::Discardable].into(),
+                                            fdiffs: [2, 1].into(),
+                                            ..Default::default()
+                                        }
+                                    ],
+                                    decode_target_layers: [
+                                        Layer::zero(),
+                                        Layer {
+                                            spatial_id: 0,
+                                            temporal_id: 1
+                                        }
+                                    ]
+                                    .into(),
+                                    resolutions: Some(
+                                        [Resolution {
+                                            width: 2880,
+                                            height: 1620
+                                        }]
+                                        .into()
+                                    ),
+                                    ..Default::default()
+                                }
+                            )),
+                            ..Default::default()
+                        })
                     },
                     22..39
                 )),
@@ -2423,7 +2067,7 @@ mod test {
                 payload_range,
                 video_layers_allocation: None,
             }),
-            Header::parse(&packet)
+            Header::parse(&packet, None)
         );
     }
 }
diff --git a/backend/src/rtp/rtcp.rs b/backend/src/rtp/rtcp.rs
index 50e1dfe..f67f191 100644
--- a/backend/src/rtp/rtcp.rs
+++ b/backend/src/rtp/rtcp.rs
@@ -23,7 +23,7 @@ use super::{
     types::*,
     Packet, OPUS_PAYLOAD_TYPE, VERSION, VP8_PAYLOAD_TYPE,
 };
-use crate::transportcc as tcc;
+use crate::{rtp::VP9_PAYLOAD_TYPE, transportcc as tcc};
 
 const RTCP_HEADER_LEN: usize = 8;
 const RTCP_RECEIVER_REPORT_BLOCK_LEN: usize = 28;
@@ -563,7 +563,7 @@ impl RtcpReportSender {
     fn estimate_sample_freq(payload_type: PayloadType) -> u32 {
         if payload_type == OPUS_PAYLOAD_TYPE {
             48000
-        } else if payload_type == VP8_PAYLOAD_TYPE {
+        } else if payload_type == VP8_PAYLOAD_TYPE || payload_type == VP9_PAYLOAD_TYPE {
             90000
         } else {
             warn!(
diff --git a/backend/src/sfu.rs b/backend/src/sfu.rs
index cad3bbb..c26cdaa 100644
--- a/backend/src/sfu.rs
+++ b/backend/src/sfu.rs
@@ -841,7 +841,7 @@ impl Sfu {
             let incoming_rtp = {
                 time_scope_us!("calling.sfu.handle_packet.rtp.in_incoming_connection_lock");
                 incoming_connection
-                    .handle_rtp_packet(incoming_packet, Instant::now())
+                    .handle_rtp_packet(incoming_packet, None, Instant::now())
                     .map_err(SfuError::ConnectionError)?
             };
 
diff --git a/load_test/src/main.rs b/load_test/src/main.rs
index 64f0009..66b177d 100644
--- a/load_test/src/main.rs
+++ b/load_test/src/main.rs
@@ -515,7 +515,7 @@ fn main() -> Result<()> {
             let incoming_packet = &mut buf[0..len];
             stats.bytes_total += len;
             if rtp::looks_like_rtp(incoming_packet) {
-                match endpoint.receive_rtp(incoming_packet, now) {
+                match endpoint.receive_rtp(incoming_packet, None, now) {
                     Some(packet) => {
                         let truncated_ntp_now = (ntp_now() >> 16) as u32;
                         let timestamp = BigEndian::read_u32(packet.payload());