use crate::utils::bits::GolombBitReader;
use bytes::Bytes;
use std::time::Duration;
pub const NALU_SEI: u8 = 6;
pub const NALU_SPS: u8 = 7;
pub const NALU_PPS: u8 = 8;
pub const NALU_AUD: u8 = 9;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum NaluType {
Raw = 0,
Avcc = 1,
AnnexB = 2,
}
pub fn remove_h264_or_h265_emulation_bytes(b: &[u8]) -> Vec<u8> {
let mut r = Vec::with_capacity(b.len());
let mut i = 0;
while i < b.len() {
if i + 2 < b.len() && b[i] == 0 && b[i+1] == 0 && b[i+2] == 3 {
r.push(0);
r.push(0);
i += 3;
} else {
r.push(b[i]);
i += 1;
}
}
r
}
pub fn split_nalus(b: &[u8]) -> (Vec<Vec<u8>>, NaluType) {
if b.len() < 4 {
return (vec![b.to_vec()], NaluType::Raw);
}
let val3 = ((b[0] as u32) << 16) | ((b[1] as u32) << 8) | (b[2] as u32);
let val4 = ((b[0] as u32) << 24) | ((b[1] as u32) << 16) | ((b[2] as u32) << 8) | (b[3] as u32);
if val4 <= b.len() as u32 {
let mut nalus = Vec::new();
let mut _val4 = val4 as usize;
let mut _b = &b[4..];
loop {
if _val4 > _b.len() {
break;
}
nalus.push(_b[.._val4].to_vec());
_b = &_b[_val4..];
if _b.len() < 4 {
break;
}
_val4 = ((_b[0] as usize) << 24) | ((_b[1] as usize) << 16) | ((_b[2] as usize) << 8) | (_b[3] as usize);
_b = &_b[4..];
}
if _b.is_empty() {
return (nalus, NaluType::Avcc);
}
}
if val3 == 1 || val4 == 1 {
let mut nalus = Vec::new();
let mut start = 0;
let mut pos = 0;
let mut _val3 = val3;
let mut _val4 = val4;
loop {
if start != pos {
nalus.push(b[start..pos].to_vec());
}
if _val3 == 1 {
pos += 3;
} else if _val4 == 1 {
pos += 4;
}
start = pos;
if start == b.len() {
break;
}
_val3 = 0;
_val4 = 0;
while pos < b.len() {
if pos + 2 < b.len() && b[pos] == 0 {
let v3 = ((b[pos] as u32) << 16) | ((b[pos+1] as u32) << 8) | (b[pos+2] as u32);
if v3 == 0 {
if pos + 3 < b.len() {
let v4 = b[pos+3] as u32;
if v4 == 1 {
_val4 = 1;
_val3 = 0;
break;
}
}
} else if v3 == 1 {
_val3 = 1;
_val4 = 0;
break;
}
pos += 1;
} else {
pos += 1;
}
}
}
return (nalus, NaluType::AnnexB);
}
(vec![b.to_vec()], NaluType::Raw)
}
#[derive(Debug, Default, Clone)]
pub struct SPSInfo {
pub id: u32,
pub profile_idc: u32,
pub level_idc: u32,
pub constraint_set_flag: u32,
pub mb_width: u32,
pub mb_height: u32,
pub crop_left: u32,
pub crop_right: u32,
pub crop_top: u32,
pub crop_bottom: u32,
pub width: u32,
pub height: u32,
pub fps: u32,
}
pub fn parse_sps(data: &[u8]) -> Result<SPSInfo, &'static str> {
let raw_data = remove_h264_or_h265_emulation_bytes(data);
let mut r = GolombBitReader::new(&raw_data);
r.read_bits(8)?;
let mut s = SPSInfo::default();
s.profile_idc = r.read_bits(8)?;
s.constraint_set_flag = r.read_bits(8)? >> 2;
s.level_idc = r.read_bits(8)?;
s.id = r.read_exponential_golomb()?;
if s.profile_idc == 100 || s.profile_idc == 110 ||
s.profile_idc == 122 || s.profile_idc == 244 ||
s.profile_idc == 44 || s.profile_idc == 83 ||
s.profile_idc == 86 || s.profile_idc == 118 {
let chroma_format_idc = r.read_exponential_golomb()?;
if chroma_format_idc == 3 {
r.read_bit()?; }
r.read_exponential_golomb()?; r.read_exponential_golomb()?; r.read_bit()?;
let seq_scaling_matrix_present_flag = r.read_bit()?;
if seq_scaling_matrix_present_flag != 0 {
for i in 0..8 {
let seq_scaling_list_present_flag = r.read_bit()?;
if seq_scaling_list_present_flag != 0 {
let size_of_scaling_list = if i < 6 { 16 } else { 64 };
let mut last_scale = 8i32;
let mut next_scale = 8i32;
for _ in 0..size_of_scaling_list {
if next_scale != 0 {
let delta_scale = r.read_se()?;
next_scale = (last_scale + delta_scale + 256) % 256;
}
if next_scale != 0 {
last_scale = next_scale;
}
}
}
}
}
}
r.read_exponential_golomb()?; let pic_order_cnt_type = r.read_exponential_golomb()?;
if pic_order_cnt_type == 0 {
r.read_exponential_golomb()?; } else if pic_order_cnt_type == 1 {
r.read_bit()?; r.read_se()?; r.read_se()?; let num_ref_frames_in_pic_order_cnt_cycle = r.read_exponential_golomb()?;
for _ in 0..num_ref_frames_in_pic_order_cnt_cycle {
r.read_se()?;
}
}
r.read_exponential_golomb()?; r.read_bit()?;
s.mb_width = r.read_exponential_golomb()? + 1;
s.mb_height = r.read_exponential_golomb()? + 1;
let frame_mbs_only_flag = r.read_bit()?;
if frame_mbs_only_flag == 0 {
r.read_bit()?; }
r.read_bit()?;
let frame_cropping_flag = r.read_bit()?;
if frame_cropping_flag != 0 {
s.crop_left = r.read_exponential_golomb()?;
s.crop_right = r.read_exponential_golomb()?;
s.crop_top = r.read_exponential_golomb()?;
s.crop_bottom = r.read_exponential_golomb()?;
}
s.width = (s.mb_width * 16) - s.crop_left * 2 - s.crop_right * 2;
s.height = ((2 - frame_mbs_only_flag) * s.mb_height * 16) - s.crop_top * 2 - s.crop_bottom * 2;
let vui_parameter_present_flag = r.read_bit()?;
if vui_parameter_present_flag != 0 {
let aspect_ratio_info_present_flag = r.read_bit()?;
if aspect_ratio_info_present_flag != 0 {
let aspect_ratio_idc = r.read_bits(8)?;
if aspect_ratio_idc == 255 {
r.read_bits(16)?; r.read_bits(16)?; }
}
let overscan_info_present_flag = r.read_bit()?;
if overscan_info_present_flag != 0 {
r.read_bit()?; }
let video_signal_type_present_flag = r.read_bit()?;
if video_signal_type_present_flag != 0 {
r.read_bits(3)?; r.read_bit()?; let colour_description_present_flag = r.read_bit()?;
if colour_description_present_flag != 0 {
r.read_bits(8)?; r.read_bits(8)?; r.read_bits(8)?; }
}
let chroma_loc_info_present_flag = r.read_bit()?;
if chroma_loc_info_present_flag != 0 {
r.read_exponential_golomb()?; r.read_exponential_golomb()?; }
let timing_info_present_flag = r.read_bit()?;
if timing_info_present_flag != 0 {
let num_units_in_tick = r.read_bits(16)? << 16 | r.read_bits(16)?;
let time_scale = r.read_bits(16)? << 16 | r.read_bits(16)?;
if num_units_in_tick != 0 {
s.fps = (time_scale as f64 / num_units_in_tick as f64 / 2.0).floor() as u32;
}
}
}
Ok(s)
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum SliceType {
P = 1,
B = 2,
I = 3,
}
pub fn parse_slice_header_from_nalu(packet: &[u8]) -> Result<SliceType, &'static str> {
if packet.len() <= 1 {
return Err("packet too short to parse slice header");
}
let nal_unit_type = packet[0] & 0x1f;
match nal_unit_type {
1 | 2 | 5 | 19 => {} _ => return Err("nal_unit_type has no slice header"),
}
let mut r = GolombBitReader::new(&packet[1..]);
r.read_exponential_golomb()?; let slice_type = r.read_exponential_golomb()?;
match slice_type {
0 | 3 | 5 | 8 => Ok(SliceType::P),
1 | 6 => Ok(SliceType::B),
2 | 4 | 7 | 9 => Ok(SliceType::I),
_ => Err("slice_type invalid"),
}
}