use crate::internal::bpg_bitstream::{BitReader, BitWriter, write_ue7};
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum HevcError {
Truncated,
UnexpectedNalType { expected: u8, found: u8 },
UnsupportedFeature { what: &'static str },
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct BpgHevcInfo {
pub width: u32,
pub height: u32,
pub chroma_format_idc: u8,
pub bit_depth: u8,
pub limited_range: bool,
pub matrix_coefficients: u8,
}
#[derive(Debug, Clone, PartialEq, Eq)]
struct ModifiedSpsFields {
log2_min_luma_coding_block_size_minus3: u32,
log2_diff_max_min_luma_coding_block_size: u32,
log2_min_luma_transform_block_size_minus2: u32,
log2_diff_max_min_luma_transform_block_size: u32,
max_transform_hierarchy_depth_intra: u32,
sample_adaptive_offset_enabled_flag: u32,
pcm_enabled_flag: u32,
pcm: Option<(u32, u32, u32, u32, u32)>,
strong_intra_smoothing_enabled_flag: u32,
sps_extension_flag: u32,
sps_range_extension_flag: u32,
sps_range_extension_flags: u32,
}
pub fn find_nal_end(buf: &[u8]) -> Result<usize, HevcError> {
let buf_len = buf.len();
let mut idx;
if buf_len >= 4 && buf[0] == 0 && buf[1] == 0 && buf[2] == 0 && buf[3] == 1 {
idx = 4;
} else if buf_len >= 3 && buf[0] == 0 && buf[1] == 0 && buf[2] == 1 {
idx = 3;
} else {
return Err(HevcError::Truncated);
}
if idx + 2 > buf_len {
return Err(HevcError::Truncated);
}
loop {
if idx + 2 >= buf_len {
idx = buf_len;
break;
}
if buf[idx] == 0 && buf[idx + 1] == 0 && buf[idx + 2] == 1 {
break;
}
if idx + 3 < buf_len
&& buf[idx] == 0
&& buf[idx + 1] == 0
&& buf[idx + 2] == 0
&& buf[idx + 3] == 1
{
break;
}
idx += 1;
}
Ok(idx)
}
pub fn extract_nal(buf: &[u8]) -> Result<(Vec<u8>, usize), HevcError> {
let end = find_nal_end(buf)?;
let start = if buf[2] == 1 { 3 } else { 4 };
let mut nal_buf = Vec::with_capacity(end - start);
let mut idx = start;
while idx < end {
if idx + 2 < end && buf[idx] == 0 && buf[idx + 1] == 0 && buf[idx + 2] == 3 {
nal_buf.push(0);
nal_buf.push(0);
idx += 3;
} else {
nal_buf.push(buf[idx]);
idx += 1;
}
}
Ok((nal_buf, end))
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ModifiedSps {
pub bytes: Vec<u8>,
}
impl ModifiedSps {
pub fn from_hevc_stream(hevc: &[u8]) -> Result<(Self, usize), HevcError> {
let (vps, idx) = extract_nal(hevc)?;
if vps.len() < 2 {
return Err(HevcError::Truncated);
}
let nal_unit_type = (vps[0] >> 1) & 0x3f;
if nal_unit_type != 32 {
return Err(HevcError::UnexpectedNalType {
expected: 32,
found: nal_unit_type,
});
}
let (sps, ret) = extract_nal(&hevc[idx..])?;
let idx = idx + ret;
if sps.len() < 2 {
return Err(HevcError::Truncated);
}
let nal_unit_type = (sps[0] >> 1) & 0x3f;
if nal_unit_type != 33 {
return Err(HevcError::UnexpectedNalType {
expected: 33,
found: nal_unit_type,
});
}
let bytes = Self::rewrite_sps(&sps)?;
Ok((ModifiedSps { bytes }, idx))
}
fn rewrite_sps(sps: &[u8]) -> Result<Vec<u8>, HevcError> {
let mut gb = BitReader::new(sps);
let ue = |gb: &mut BitReader| gb.read_ue_golomb().ok_or(HevcError::Truncated);
gb.skip_bits(16);
let vps_id = gb.read_bits(4);
if vps_id != 0 {
return Err(HevcError::UnsupportedFeature {
what: "vps_id != 0",
});
}
let max_sub_layers = gb.read_bits(3);
if max_sub_layers != 0 {
return Err(HevcError::UnsupportedFeature {
what: "max_sub_layers != 0",
});
}
gb.skip_bits(1);
gb.skip_bits(2);
gb.skip_bits(1);
let _profile_idc = gb.read_bits(5);
for _ in 0..32 {
gb.skip_bits(1);
}
gb.skip_bits(1);
gb.skip_bits(1);
gb.skip_bits(1);
gb.skip_bits(1);
gb.skip_bits(44);
gb.skip_bits(8);
let sps_id = ue(&mut gb)?;
if sps_id != 0 {
return Err(HevcError::UnsupportedFeature {
what: "sps_id != 0",
});
}
let chroma_format_idc = ue(&mut gb)?;
if chroma_format_idc == 3 {
gb.skip_bits(1);
}
let _width = ue(&mut gb)?;
let _height = ue(&mut gb)?;
if gb.read_bits(1) != 0 {
ue(&mut gb)?;
ue(&mut gb)?;
ue(&mut gb)?;
ue(&mut gb)?;
}
let _bit_depth_luma = ue(&mut gb)? + 8;
let _bit_depth_chroma = ue(&mut gb)? + 8;
let log2_max_poc_lsb = ue(&mut gb)? + 4;
if log2_max_poc_lsb != 8 {
return Err(HevcError::UnsupportedFeature {
what: "log2_max_poc_lsb != 8",
});
}
let _sublayer_ordering_info = gb.read_bits(1);
ue(&mut gb)?;
ue(&mut gb)?;
ue(&mut gb)?;
let log2_min_cb_size = ue(&mut gb)? + 3;
let log2_diff_max_min_coding_block_size = ue(&mut gb)?;
let log2_min_tb_size = ue(&mut gb)? + 2;
let log2_diff_max_min_transform_block_size = ue(&mut gb)?;
let max_transform_hierarchy_depth_inter = ue(&mut gb)?;
let max_transform_hierarchy_depth_intra = ue(&mut gb)?;
if max_transform_hierarchy_depth_inter != max_transform_hierarchy_depth_intra {
return Err(HevcError::UnsupportedFeature {
what: "max_transform_hierarchy_depth_inter != intra",
});
}
let scaling_list_enable_flag = gb.read_bits(1);
if scaling_list_enable_flag != 0 {
return Err(HevcError::UnsupportedFeature {
what: "scaling_list_enable_flag != 0",
});
}
let amp_enabled_flag = gb.read_bits(1);
if amp_enabled_flag == 0 {
return Err(HevcError::UnsupportedFeature {
what: "amp_enabled_flag == 0",
});
}
let sao_enabled = gb.read_bits(1);
let pcm_enabled_flag = gb.read_bits(1);
let mut pcm = None;
if pcm_enabled_flag != 0 {
let pcm_sample_bit_depth_luma_minus1 = gb.read_bits(4);
let pcm_sample_bit_depth_chroma_minus1 = gb.read_bits(4);
let log2_min_pcm_luma_coding_block_size_minus3 = ue(&mut gb)?;
let log2_diff_max_min_pcm_luma_coding_block_size = ue(&mut gb)?;
let pcm_loop_filter_disabled_flag = gb.read_bits(1);
pcm = Some((
pcm_sample_bit_depth_luma_minus1,
pcm_sample_bit_depth_chroma_minus1,
log2_min_pcm_luma_coding_block_size_minus3,
log2_diff_max_min_pcm_luma_coding_block_size,
pcm_loop_filter_disabled_flag,
));
}
let nb_st_rps = ue(&mut gb)?;
if nb_st_rps != 0 {
return Err(HevcError::UnsupportedFeature {
what: "nb_st_rps != 0",
});
}
let long_term_ref_pics_present_flag = gb.read_bits(1);
if long_term_ref_pics_present_flag != 0 {
return Err(HevcError::UnsupportedFeature {
what: "long_term_ref_pics_present_flag != 0",
});
}
let sps_temporal_mvp_enabled_flag = gb.read_bits(1);
if sps_temporal_mvp_enabled_flag == 0 {
return Err(HevcError::UnsupportedFeature {
what: "sps_temporal_mvp_enabled_flag == 0",
});
}
let sps_strong_intra_smoothing_enable_flag = gb.read_bits(1);
let vui_present = gb.read_bits(1);
if vui_present != 0 {
let sar_present = gb.read_bits(1);
if sar_present != 0 {
let sar_idx = gb.read_bits(8);
if sar_idx == 255 {
gb.skip_bits(16);
gb.skip_bits(16);
}
}
let overscan_info_present_flag = gb.read_bits(1);
if overscan_info_present_flag != 0 {
gb.skip_bits(1);
}
let video_signal_type_present_flag = gb.read_bits(1);
if video_signal_type_present_flag != 0 {
gb.skip_bits(3); gb.skip_bits(1); let colour_description_present_flag = gb.read_bits(1);
if colour_description_present_flag != 0 {
gb.skip_bits(8); gb.skip_bits(8); gb.skip_bits(8); }
}
let chroma_loc_info_present_flag = gb.read_bits(1);
if chroma_loc_info_present_flag != 0 {
ue(&mut gb)?;
ue(&mut gb)?;
}
gb.skip_bits(1);
gb.skip_bits(1);
gb.skip_bits(1);
let default_display_window_flag = gb.read_bits(1);
if default_display_window_flag != 0 {
return Err(HevcError::UnsupportedFeature {
what: "default_display_window_flag != 0",
});
}
let vui_timing_info_present_flag = gb.read_bits(1);
if vui_timing_info_present_flag != 0 {
gb.skip_bits(32);
gb.skip_bits(32);
let vui_poc_proportional_to_timing_flag = gb.read_bits(1);
if vui_poc_proportional_to_timing_flag != 0 {
ue(&mut gb)?;
}
let vui_hrd_parameters_present_flag = gb.read_bits(1);
if vui_hrd_parameters_present_flag != 0 {
return Err(HevcError::UnsupportedFeature {
what: "vui_hrd_parameters_present_flag != 0",
});
}
}
let bitstream_restriction_flag = gb.read_bits(1);
if bitstream_restriction_flag != 0 {
gb.skip_bits(1);
gb.skip_bits(1);
gb.skip_bits(1);
ue(&mut gb)?;
ue(&mut gb)?;
ue(&mut gb)?;
ue(&mut gb)?;
ue(&mut gb)?;
}
}
let sps_extension_flag = gb.read_bits(1);
let mut sps_range_extension_flag = 0;
let mut sps_range_extension_flags = 0;
if sps_extension_flag != 0 {
sps_range_extension_flag = gb.read_bits(1);
let sps_extension_7bits = gb.read_bits(7);
if sps_extension_7bits != 0 {
return Err(HevcError::UnsupportedFeature {
what: "sps_extension_7bits != 0",
});
}
if sps_range_extension_flag != 0 {
sps_range_extension_flags = gb.read_bits(9);
if sps_range_extension_flags
& ((1 << (8 - 3)) | (1 << (8 - 4)) | (1 << (8 - 6)) | (1 << (8 - 8)))
!= 0
{
return Err(HevcError::UnsupportedFeature {
what: "unsupported sps range extensions",
});
}
}
}
let mut pb = BitWriter::new();
pb.write_ue_golomb(log2_min_cb_size - 3);
pb.write_ue_golomb(log2_diff_max_min_coding_block_size);
pb.write_ue_golomb(log2_min_tb_size - 2);
pb.write_ue_golomb(log2_diff_max_min_transform_block_size);
pb.write_ue_golomb(max_transform_hierarchy_depth_intra);
pb.write_bits(1, sao_enabled);
pb.write_bits(1, pcm_enabled_flag);
if let Some((luma_m1, chroma_m1, log2_min_m3, log2_diff_max, loop_filter)) = pcm {
pb.write_bits(4, luma_m1);
pb.write_bits(4, chroma_m1);
pb.write_ue_golomb(log2_min_m3);
pb.write_ue_golomb(log2_diff_max);
pb.write_bits(1, loop_filter);
}
pb.write_bits(1, sps_strong_intra_smoothing_enable_flag);
pb.write_bits(1, sps_extension_flag);
if sps_extension_flag != 0 {
pb.write_bits(1, sps_range_extension_flag);
pb.write_bits(7, 0);
if sps_range_extension_flag != 0 {
pb.write_bits(9, sps_range_extension_flags);
}
}
let msps = pb.into_bytes();
let msps_len = msps.len();
let mut out = Vec::with_capacity(5 + msps_len);
write_ue7(&mut out, msps_len as u32);
out.extend_from_slice(&msps);
Ok(out)
}
}
pub fn build_modified_hevc(cbuf: &[u8]) -> Result<Vec<u8>, HevcError> {
let mut out = Vec::new();
let (msps, mut cidx) = ModifiedSps::from_hevc_stream(cbuf)?;
out.extend_from_slice(&msps.bytes);
let mut first_nal = true;
while cidx < cbuf.len() {
let nal = &cbuf[cidx..];
let nal_len = find_nal_end(nal)?;
cidx += nal_len;
let start = 3 + (nal[2] == 0) as usize;
let l = if first_nal { start } else { 0 };
out.extend_from_slice(&nal[l..nal_len]);
first_nal = false;
}
Ok(out)
}
pub fn rebuild_annexb_from_bpg_payload(
payload: &[u8],
info: BpgHevcInfo,
) -> Result<Vec<u8>, HevcError> {
let mut pos = 0usize;
let msps_len = crate::internal::bpg_bitstream::read_ue7(payload, &mut pos)
.ok_or(HevcError::Truncated)? as usize;
let msps_end = pos.checked_add(msps_len).ok_or(HevcError::Truncated)?;
if msps_end > payload.len() {
return Err(HevcError::Truncated);
}
if payload.len() == msps_end {
return Err(HevcError::Truncated);
}
let fields = parse_modified_sps_fields(&payload[pos..msps_end])?;
let sps_payload = build_sps_payload(&fields, info);
let sps_nal = make_nal(33, &sps_payload);
let mut out = Vec::with_capacity(payload.len() + sps_nal.len() + 16);
out.extend_from_slice(&[0, 0, 0, 1]);
out.extend_from_slice(&sps_nal);
out.extend_from_slice(&[0, 0, 1]);
out.extend_from_slice(&payload[msps_end..]);
Ok(out)
}
fn parse_modified_sps_fields(msps: &[u8]) -> Result<ModifiedSpsFields, HevcError> {
let mut r = BitReader::new(msps);
let ue = |r: &mut BitReader| r.read_ue_golomb().ok_or(HevcError::Truncated);
let log2_min_luma_coding_block_size_minus3 = ue(&mut r)?;
let log2_diff_max_min_luma_coding_block_size = ue(&mut r)?;
let log2_min_luma_transform_block_size_minus2 = ue(&mut r)?;
let log2_diff_max_min_luma_transform_block_size = ue(&mut r)?;
let max_transform_hierarchy_depth_intra = ue(&mut r)?;
let sample_adaptive_offset_enabled_flag = r.read_bits(1);
let pcm_enabled_flag = r.read_bits(1);
let pcm = if pcm_enabled_flag != 0 {
Some((
r.read_bits(4),
r.read_bits(4),
ue(&mut r)?,
ue(&mut r)?,
r.read_bits(1),
))
} else {
None
};
let strong_intra_smoothing_enabled_flag = r.read_bits(1);
let sps_extension_flag = r.read_bits(1);
let mut sps_range_extension_flag = 0;
let mut sps_range_extension_flags = 0;
if sps_extension_flag != 0 {
sps_range_extension_flag = r.read_bits(1);
let sps_extension_7bits = r.read_bits(7);
if sps_extension_7bits != 0 {
return Err(HevcError::UnsupportedFeature {
what: "sps_extension_7bits != 0",
});
}
if sps_range_extension_flag != 0 {
sps_range_extension_flags = r.read_bits(9);
}
}
Ok(ModifiedSpsFields {
log2_min_luma_coding_block_size_minus3,
log2_diff_max_min_luma_coding_block_size,
log2_min_luma_transform_block_size_minus2,
log2_diff_max_min_luma_transform_block_size,
max_transform_hierarchy_depth_intra,
sample_adaptive_offset_enabled_flag,
pcm_enabled_flag,
pcm,
strong_intra_smoothing_enabled_flag,
sps_extension_flag,
sps_range_extension_flag,
sps_range_extension_flags,
})
}
fn build_sps_payload(fields: &ModifiedSpsFields, info: BpgHevcInfo) -> Vec<u8> {
let mut w = BitWriter::new();
w.write_bits(4, 0); w.write_bits(3, 0); w.write_bits(1, 1); write_profile_tier_level(&mut w);
w.write_ue_golomb(0); w.write_ue_golomb(info.chroma_format_idc as u32);
if info.chroma_format_idc == 3 {
w.write_bits(1, 0); }
w.write_ue_golomb(info.width);
w.write_ue_golomb(info.height);
w.write_bits(1, 0); w.write_ue_golomb((info.bit_depth - 8) as u32);
w.write_ue_golomb((info.bit_depth - 8) as u32);
w.write_ue_golomb(4); w.write_bits(1, 0); w.write_ue_golomb(0); w.write_ue_golomb(0); w.write_ue_golomb(0);
w.write_ue_golomb(fields.log2_min_luma_coding_block_size_minus3);
w.write_ue_golomb(fields.log2_diff_max_min_luma_coding_block_size);
w.write_ue_golomb(fields.log2_min_luma_transform_block_size_minus2);
w.write_ue_golomb(fields.log2_diff_max_min_luma_transform_block_size);
w.write_ue_golomb(fields.max_transform_hierarchy_depth_intra);
w.write_ue_golomb(fields.max_transform_hierarchy_depth_intra);
w.write_bits(1, 0); w.write_bits(1, 1); w.write_bits(1, fields.sample_adaptive_offset_enabled_flag);
w.write_bits(1, fields.pcm_enabled_flag);
if let Some((luma_m1, chroma_m1, log2_min_m3, log2_diff_max, loop_filter)) = fields.pcm {
w.write_bits(4, luma_m1);
w.write_bits(4, chroma_m1);
w.write_ue_golomb(log2_min_m3);
w.write_ue_golomb(log2_diff_max);
w.write_bits(1, loop_filter);
}
w.write_ue_golomb(0); w.write_bits(1, 0); w.write_bits(1, 1); w.write_bits(1, fields.strong_intra_smoothing_enabled_flag);
w.write_bits(1, 1); w.write_bits(1, 0); w.write_bits(1, 0); w.write_bits(1, 1); w.write_bits(3, 5); w.write_bits(1, (!info.limited_range) as u32);
w.write_bits(1, 1); let colour_primaries = match info.matrix_coefficients {
1 => 1,
9 => 9,
_ => 6,
};
w.write_bits(8, colour_primaries);
w.write_bits(8, colour_primaries);
w.write_bits(8, info.matrix_coefficients as u32);
w.write_bits(1, 0); w.write_bits(1, 0); w.write_bits(1, 0); w.write_bits(1, 0); w.write_bits(1, 0); w.write_bits(1, 0); w.write_bits(1, 0);
w.write_bits(1, fields.sps_extension_flag);
if fields.sps_extension_flag != 0 {
w.write_bits(1, fields.sps_range_extension_flag);
w.write_bits(7, 0);
if fields.sps_range_extension_flag != 0 {
w.write_bits(9, fields.sps_range_extension_flags);
}
}
write_rbsp_trailing_bits(&mut w);
w.into_bytes()
}
fn write_profile_tier_level(w: &mut BitWriter) {
w.write_bits(2, 0); w.write_bits(1, 0); w.write_bits(5, 1); w.write_bits(32, 0); w.write_bits(1, 1); w.write_bits(1, 0); w.write_bits(1, 0); w.write_bits(1, 1); w.write_bits(32, 0);
w.write_bits(12, 0);
w.write_bits(8, 120); }
fn write_rbsp_trailing_bits(w: &mut BitWriter) {
w.write_bits(1, 1);
w.byte_align();
}
fn make_nal(nal_unit_type: u8, payload: &[u8]) -> Vec<u8> {
let mut rbsp = Vec::with_capacity(payload.len() + 2);
rbsp.push(nal_unit_type << 1);
rbsp.push(1);
rbsp.extend_from_slice(payload);
let mut out = Vec::with_capacity(rbsp.len() + 8);
let mut zeros = 0usize;
for b in rbsp {
if zeros >= 2 && b <= 0x03 {
out.push(0x03);
zeros = 0;
}
out.push(b);
if b == 0 {
zeros += 1;
} else {
zeros = 0;
}
}
out
}
#[cfg(test)]
mod tests {
use super::*;
fn nal(four_byte_start: bool, nut: u8, payload: &[u8]) -> Vec<u8> {
let mut v = Vec::new();
if four_byte_start {
v.extend_from_slice(&[0, 0, 0, 1]);
} else {
v.extend_from_slice(&[0, 0, 1]);
}
v.push(nut << 1);
v.push(0x01);
v.extend_from_slice(payload);
v
}
#[test]
fn find_nal_end_three_byte_start() {
let buf = nal(false, 33, &[0xaa, 0xbb]);
assert_eq!(find_nal_end(&buf), Ok(buf.len()));
}
#[test]
fn find_nal_end_stops_at_next_start_code() {
let mut buf = nal(true, 32, &[0x11]);
let first_len = buf.len();
buf.extend_from_slice(&nal(false, 33, &[0x22, 0x33]));
assert_eq!(find_nal_end(&buf), Ok(first_len));
}
#[test]
fn find_nal_end_rejects_missing_start_code() {
assert_eq!(find_nal_end(&[0x12, 0x34, 0x56]), Err(HevcError::Truncated));
}
#[test]
fn extract_nal_strips_start_code_and_epb() {
let buf = nal(false, 33, &[0x00, 0x00, 0x03, 0x04]);
let (rbsp, end) = extract_nal(&buf).unwrap();
assert_eq!(end, buf.len());
assert_eq!(rbsp, vec![33 << 1, 0x01, 0x00, 0x00, 0x04]);
}
#[test]
fn extract_nal_trailing_zero_pair_without_third_byte_is_literal() {
let buf = nal(false, 33, &[0x00, 0x00]);
let (rbsp, _) = extract_nal(&buf).unwrap();
assert_eq!(rbsp, vec![33 << 1, 0x01, 0x00, 0x00]);
}
#[test]
fn from_hevc_stream_rejects_non_vps_first_nal() {
let buf = nal(false, 33, &[0x00, 0x00]);
assert_eq!(
ModifiedSps::from_hevc_stream(&buf),
Err(HevcError::UnexpectedNalType {
expected: 32,
found: 33
})
);
}
#[test]
fn build_modified_hevc_copies_nals_after_msps() {
let mut buf = nal(true, 32, &[0x0c, 0x01]);
buf.extend_from_slice(&nal(false, 33, &[0x44]));
buf.extend_from_slice(&nal(false, 19, &[0x55, 0x66]));
let third_start = find_nal_end(&buf).unwrap();
let rest = &buf[third_start..];
let second_len = find_nal_end(rest).unwrap();
assert_eq!(&rest[second_len..], &nal(false, 19, &[0x55, 0x66])[..]);
}
}