pub(super) const ORDER_HINT_BITS: u32 = 8;
pub(super) const PRIMARY_REF_NONE: u8 = 7;
pub(super) const BASE_Q_IDX: u8 = 128;
pub(super) const MAX_WIDTH: u32 = 4096;
pub(super) const MAX_AREA: u32 = 4096 * 2304;
const OBU_SEQUENCE_HEADER: u8 = 1;
const OBU_TEMPORAL_DELIMITER: u8 = 2;
const OBU_FRAME_HEADER: u8 = 3;
pub(super) const TEMPORAL_DELIMITER: [u8; 2] = [(OBU_TEMPORAL_DELIMITER << 3) | 0b10, 0];
#[derive(Default)]
struct BitWriter {
bytes: Vec<u8>,
bits: usize,
}
impl BitWriter {
fn put(&mut self, value: u32, bits: u32) {
for i in (0..bits).rev() {
if self.bits.is_multiple_of(8) {
self.bytes.push(0);
}
if (value >> i) & 1 == 1 {
let last = self.bytes.len() - 1;
self.bytes[last] |= 0x80 >> (self.bits % 8);
}
self.bits += 1;
}
}
fn flag(&mut self, value: bool) {
self.put(u32::from(value), 1);
}
fn position(&self) -> u32 {
self.bits as u32
}
fn trailing_bits(&mut self) {
self.put(1, 1);
while !self.bits.is_multiple_of(8) {
self.put(0, 1);
}
}
}
fn leb128_fixed(value: usize, len: usize) -> Vec<u8> {
(0..len)
.map(|i| {
let byte = ((value >> (7 * i)) & 0x7f) as u8;
if i + 1 < len { byte | 0x80 } else { byte }
})
.collect()
}
fn obu_header(obu_type: u8) -> u8 {
(obu_type << 3) | 0b10
}
pub(super) fn level_idx(width: u32, height: u32, fps: u32, bitrate_kbps: u32) -> u8 {
const LEVELS: [(u8, u64, u32, u32, u64, u32); 10] = [
(0, 147_456, 2048, 1152, 4_423_680, 1_500),
(1, 278_784, 2816, 1584, 8_363_520, 3_000),
(4, 665_856, 4352, 2448, 19_975_680, 6_000),
(5, 1_065_024, 5504, 3096, 31_950_720, 10_000),
(8, 2_359_296, 6144, 3456, 70_778_880, 12_000),
(9, 2_359_296, 6144, 3456, 141_557_760, 20_000),
(12, 8_912_896, 8192, 4352, 267_386_880, 30_000),
(13, 8_912_896, 8192, 4352, 534_773_760, 40_000),
(14, 8_912_896, 8192, 4352, 1_069_547_520, 60_000),
(16, 35_651_584, 16384, 8704, 1_069_547_520, 60_000),
];
let pic = u64::from(width) * u64::from(height);
LEVELS
.iter()
.find(|(_, max_pic, max_w, max_h, max_rate, max_kbps)| {
pic <= *max_pic
&& width <= *max_w
&& height <= *max_h
&& pic * u64::from(fps) <= *max_rate
&& bitrate_kbps <= *max_kbps
})
.map_or(31, |level| level.0)
}
fn bits_for(value: u32) -> u32 {
(u32::BITS - value.leading_zeros()).max(1)
}
pub(super) fn sequence_header(width: u32, height: u32, level_idx: u8) -> Vec<u8> {
let mut w = BitWriter::default();
w.put(0, 3); w.flag(false); w.flag(false); w.flag(false); w.flag(false); w.put(0, 5); w.put(0, 12); w.put(u32::from(level_idx), 5); if level_idx > 7 {
w.flag(false); }
let width_bits = bits_for(width - 1);
let height_bits = bits_for(height - 1);
w.put(width_bits - 1, 4); w.put(height_bits - 1, 4); w.put(width - 1, width_bits); w.put(height - 1, height_bits); w.flag(false); w.flag(false); w.flag(false); w.flag(false); w.flag(false); w.flag(false); w.flag(false); w.flag(false); w.flag(true); w.flag(false); w.flag(false); w.flag(false);
w.put(0, 1);
w.put(ORDER_HINT_BITS - 1, 3); w.flag(false); w.flag(true); w.flag(false); w.flag(false); w.flag(false); w.flag(false); w.flag(false); w.put(0, 2); w.flag(false); w.flag(false); w.trailing_bits();
let mut obu = vec![obu_header(OBU_SEQUENCE_HEADER)];
obu.extend(leb128_fixed(w.bytes.len(), 1));
obu.extend(w.bytes);
obu
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(super) enum FrameRefs {
Key,
Inter { reference: u8, refresh: u8 },
}
#[derive(Debug, PartialEq, Eq)]
pub(super) struct FrameHeader {
pub data: Vec<u8>,
pub bit_offset_qindex: u32,
pub bit_offset_segmentation: u32,
pub bit_offset_loopfilter_params: u32,
pub bit_offset_cdef_params: u32,
pub size_in_bits_cdef_params: u32,
pub byte_offset_obu_size: u32,
}
pub(super) fn superblocks(width: u32, height: u32) -> (u32, u32) {
let mi_cols = 2 * width.div_ceil(8);
let mi_rows = 2 * height.div_ceil(8);
(mi_cols.div_ceil(16), mi_rows.div_ceil(16))
}
fn tile_log2(block: u32, target: u32) -> u32 {
let mut k = 0;
while (block << k) < target {
k += 1;
}
k
}
pub(super) fn frame_header(
refs: FrameRefs,
order_hint: u8,
width: u32,
height: u32,
obu_size_bytes: usize,
) -> FrameHeader {
let mut w = BitWriter::default();
let key = refs == FrameRefs::Key;
w.flag(false); w.put(if key { 0 } else { 1 }, 2); w.flag(true); if !key {
w.flag(false); }
w.flag(false); w.flag(false); w.put(u32::from(order_hint), ORDER_HINT_BITS);
if let FrameRefs::Inter { reference, refresh } = refs {
w.put(0, 3); w.put(u32::from(refresh), 8); w.flag(false); for _ in 0..7 {
w.put(u32::from(reference), 3); }
w.flag(false); w.flag(false); w.flag(false); w.put(0, 2); w.flag(false); } else {
w.flag(false); }
w.flag(false);
let (sb_cols, sb_rows) = superblocks(width, height);
let max_log2_tile_cols = tile_log2(1, sb_cols.min(64));
let max_log2_tile_rows = tile_log2(1, sb_rows.min(64));
let min_log2_tile_cols = tile_log2(MAX_WIDTH / 64, sb_cols);
debug_assert_eq!(min_log2_tile_cols, 0, "frame too wide for one tile");
w.flag(true); if min_log2_tile_cols < max_log2_tile_cols {
w.flag(false); }
if max_log2_tile_rows > 0 {
w.flag(false); }
let bit_offset_qindex = w.position();
w.put(u32::from(BASE_Q_IDX), 8); w.flag(false); w.flag(false); w.flag(false); w.flag(false);
let bit_offset_segmentation = w.position();
w.flag(false);
w.flag(false);
let bit_offset_loopfilter_params = w.position();
w.put(0, 6); w.put(0, 6); w.put(0, 3); w.flag(false);
let bit_offset_cdef_params = w.position();
w.put(0, 2); w.put(0, 2); w.put(0, 4); w.put(0, 2); w.put(0, 4); w.put(0, 2); let size_in_bits_cdef_params = w.position() - bit_offset_cdef_params;
w.flag(true); if !key {
w.flag(false); }
w.flag(false); if !key {
for _ in 0..7 {
w.flag(false); }
}
w.trailing_bits();
let mut data = vec![obu_header(OBU_FRAME_HEADER)];
data.extend(leb128_fixed(w.bytes.len(), obu_size_bytes));
let prefix_bits = 8 * data.len() as u32;
data.extend(w.bytes);
FrameHeader {
data,
bit_offset_qindex: prefix_bits + bit_offset_qindex,
bit_offset_segmentation: prefix_bits + bit_offset_segmentation,
bit_offset_loopfilter_params: prefix_bits + bit_offset_loopfilter_params,
bit_offset_cdef_params: prefix_bits + bit_offset_cdef_params,
size_in_bits_cdef_params,
byte_offset_obu_size: 1,
}
}
pub(super) fn starts_with_temporal_delimiter(data: &[u8]) -> bool {
data.first()
.is_some_and(|byte| (byte >> 3) & 0xf == OBU_TEMPORAL_DELIMITER)
}
#[cfg(test)]
mod tests {
use super::*;
fn hex(data: &[u8]) -> String {
data.iter().map(|b| format!("{b:02x}")).collect()
}
#[test]
fn sequence_header_for_720p() {
assert_eq!(level_idx(1280, 720, 30, 2000), 5);
assert_eq!(
hex(&sequence_header(1280, 720, 5)),
"0a0b0000002d4cffb3c021d004"
);
}
#[test]
fn key_frame_header_for_720p() {
let header = frame_header(FrameRefs::Key, 0, 1280, 720, 2);
assert_eq!(hex(&header.data), "1a8900100090000000000050");
assert_eq!(header.bit_offset_qindex, 43);
assert_eq!(header.bit_offset_loopfilter_params, 57);
assert_eq!(header.bit_offset_cdef_params, 73);
assert_eq!(header.size_in_bits_cdef_params, 16);
assert_eq!(header.byte_offset_obu_size, 1);
}
#[test]
fn inter_frame_header_for_720p() {
let refs = FrameRefs::Inter {
reference: 0,
refresh: 0b10,
};
let header = frame_header(refs, 1, 1280, 720, 2);
assert_eq!(hex(&header.data), "1a8f00300200800000012000000000008020");
assert_eq!(header.bit_offset_qindex, 82);
assert_eq!(header.bit_offset_loopfilter_params, 96);
assert_eq!(header.bit_offset_cdef_params, 112);
}
#[test]
fn reference_slot_and_size_field_are_coded() {
let refs = FrameRefs::Inter {
reference: 5,
refresh: 0,
};
let header = frame_header(refs, 3, 1920, 1080, 4);
assert_eq!(&header.data[1..5], &[0x8f, 0x80, 0x80, 0x00]);
assert_eq!(header.bit_offset_qindex, 82 + 16);
let payload = &header.data[5..];
let bits: String = payload.iter().map(|b| format!("{b:08b}")).collect();
assert_eq!(&bits[27..48], "101".repeat(7));
assert_eq!(&bits[7..15], "00000011", "order_hint");
assert_eq!(&bits[18..26], "00000000", "refresh_frame_flags");
}
#[test]
fn levels_follow_size_rate_and_bitrate() {
assert_eq!(level_idx(1920, 1080, 30, 6000), 8);
assert_eq!(level_idx(1920, 1080, 60, 6000), 9);
assert_eq!(level_idx(2560, 1440, 60, 12000), 12);
assert_eq!(
level_idx(1280, 720, 30, 15000),
9,
"bitrate raises the level"
);
assert_eq!(level_idx(8192, 8192, 60, 1000), 31);
}
#[test]
fn padded_leb128() {
assert_eq!(leb128_fixed(9, 2), [0x89, 0x00]);
assert_eq!(leb128_fixed(300, 4), [0xac, 0x82, 0x80, 0x00]);
assert_eq!(leb128_fixed(11, 1), [0x0b]);
}
#[test]
fn temporal_delimiter_detection() {
assert!(starts_with_temporal_delimiter(&TEMPORAL_DELIMITER));
assert!(!starts_with_temporal_delimiter(&[0x0a, 0x0b]));
assert!(!starts_with_temporal_delimiter(&[]));
}
}