use crate::internal::bpg_bitstream::BitWriter;
use crate::{ChromaFormat, StillHevcConfig};
pub fn aq_diff_cu_qp_delta_depth(config: &StillHevcConfig) -> u32 {
(6 - crate::resolve_aq_qg_log2(config)) as u32
}
fn write_rbsp_trailing_bits(w: &mut BitWriter) {
w.write_bit(1);
w.byte_align();
}
fn write_profile_tier_level(
w: &mut BitWriter,
max_sub_layers_minus1: u8,
config: &StillHevcConfig,
) {
assert_eq!(
max_sub_layers_minus1, 0,
"write_profile_tier_level: only max_sub_layers_minus1 == 0 is implemented"
);
w.write_bits(2, 0); w.write_bit(0); let main_still_picture = config.chroma == ChromaFormat::Yuv420 && config.bit_depth == 8;
let profile_idc = if main_still_picture { 3 } else { 4 };
w.write_bits(5, profile_idc);
for i in 0..32 {
let compatible = if main_still_picture {
matches!(i, 1 | 2 | 3)
} else {
i == 4
};
w.write_bit(compatible as u32);
}
w.write_bit(1); w.write_bit(0); w.write_bit(0); w.write_bit(1);
if profile_idc == 4 {
let max_422 = matches!(
config.chroma,
ChromaFormat::Gray | ChromaFormat::Yuv420 | ChromaFormat::Yuv422
);
let max_420 = matches!(config.chroma, ChromaFormat::Gray | ChromaFormat::Yuv420);
w.write_bit((config.bit_depth <= 12) as u32);
w.write_bit((config.bit_depth <= 10) as u32);
w.write_bit((config.bit_depth <= 8 && config.chroma != ChromaFormat::Yuv422) as u32);
w.write_bit(max_422 as u32);
w.write_bit(max_420 as u32);
w.write_bit((config.chroma == ChromaFormat::Gray) as u32);
w.write_bit(1); w.write_bit(1); w.write_bit(1); w.write_bits(32, 0);
w.write_bits(3, 0);
} else {
w.write_bits(32, 0);
w.write_bits(12, 0);
}
w.write_bits(8, level_idc(config));
}
pub fn write_vps(config: &StillHevcConfig) -> Vec<u8> {
let mut w = BitWriter::new();
w.write_bits(4, 0); w.write_bit(1); w.write_bit(1); w.write_bits(6, 0); w.write_bits(3, 0); w.write_bit(1); w.write_bits(16, 0xFFFF);
write_profile_tier_level(&mut w, 0, config);
w.write_bit(1); w.write_ue_golomb(0); w.write_ue_golomb(0); w.write_ue_golomb(0);
w.write_bits(6, 0); w.write_ue_golomb(0);
w.write_bit(0); w.write_bit(0);
write_rbsp_trailing_bits(&mut w);
w.into_bytes()
}
#[cfg(test)]
mod tests {
use super::*;
use crate::internal::bpg_bitstream::BitReader;
fn test_config(deblock: crate::DeblockMode) -> StillHevcConfig {
StillHevcConfig {
width: 64,
height: 64,
bit_depth: 8,
chroma: ChromaFormat::Yuv420,
qp: 28,
effort: crate::Effort::Slow,
sao: crate::SaoMode::Off,
deblock,
adaptive_qp: false,
aq_mode: crate::AqMode::Off,
aq_strength: 0.35,
aq_clamp: 2,
two_pass_gate: true,
psy_rd: 0.0,
psy_rdoq: 0.0,
aq_qg: 32,
}
}
fn check_pps_rbsp_terminates(deblock: crate::DeblockMode) {
check_pps_rbsp_terminates_config(&test_config(deblock));
}
fn check_pps_rbsp_terminates_config(config: &StillHevcConfig) {
let wpp = effective_wpp_enabled(config);
let pps = write_pps(config, effective_tile_dims(config), wpp);
let mut r = BitReader::new(&pps);
let ue = |r: &mut BitReader| r.read_ue_golomb().unwrap();
ue(&mut r); ue(&mut r); r.read_bits(1); r.read_bits(1); r.read_bits(3); r.read_bits(1); r.read_bits(1); ue(&mut r); ue(&mut r); r.read_se_golomb().unwrap(); r.read_bits(1); r.read_bits(1); let cu_qp_delta_enabled = r.read_bits(1); assert_eq!(cu_qp_delta_enabled, crate::aq_active(config) as u32);
if cu_qp_delta_enabled == 1 {
assert_eq!(ue(&mut r), aq_diff_cu_qp_delta_depth(config));
}
r.read_se_golomb().unwrap(); r.read_se_golomb().unwrap(); r.read_bits(1); r.read_bits(1); r.read_bits(1); r.read_bits(1); assert_eq!(r.read_bits(1), 0, "tiles_enabled_flag"); assert_eq!(
r.read_bits(1),
wpp as u32,
"entropy_coding_sync_enabled_flag"
);
r.read_bits(1); let deblock_ctrl = r.read_bits(1); if deblock_ctrl == 1 {
let override_enabled = r.read_bits(1); assert_eq!(override_enabled, 0, "override loop not written");
let disabled = r.read_bits(1); if disabled == 0 {
r.read_se_golomb().unwrap(); r.read_se_golomb().unwrap(); }
}
assert_eq!(r.read_bits(1), 0, "pps_scaling_list_data_present_flag");
r.read_bits(1); ue(&mut r); r.read_bits(1); assert_eq!(r.read_bits(1), 0, "pps_extension_present_flag");
assert_eq!(r.read_bits(1), 1, "rbsp_stop_one_bit");
let left = pps.len() * 8 - r.bit_pos();
assert!(left < 8, "more than a byte of padding left: {left} bits");
for _ in 0..left {
assert_eq!(r.read_bits(1), 0, "rbsp_alignment_zero_bit");
}
}
#[test]
fn pps_rbsp_terminates_for_conformant_decoder_deblock_off() {
check_pps_rbsp_terminates(crate::DeblockMode::Off);
}
#[test]
fn pps_rbsp_terminates_for_conformant_decoder_deblock_on() {
check_pps_rbsp_terminates(crate::DeblockMode::On);
}
#[test]
fn pps_aq_active_emits_cu_qp_delta_depth_and_terminates() {
for chroma in [
ChromaFormat::Yuv420,
ChromaFormat::Yuv422,
ChromaFormat::Yuv444,
] {
for deblock in [crate::DeblockMode::Off, crate::DeblockMode::On] {
let mut config = test_config(deblock); config.chroma = chroma;
config.adaptive_qp = true; assert!(
crate::aq_active(&config),
"AQ should be active for {chroma:?}"
);
check_pps_rbsp_terminates_config(&config);
}
}
}
#[test]
fn pps_aq_qg16_emits_depth_two() {
let mut config = test_config(crate::DeblockMode::On);
config.aq_mode = crate::AqMode::Perceptual;
config.aq_qg = 16;
assert_eq!(crate::resolve_aq_qg_log2(&config), 4);
assert_eq!(aq_diff_cu_qp_delta_depth(&config), 2);
check_pps_rbsp_terminates_config(&config);
config.aq_mode = crate::AqMode::TwoPassMeasured;
assert_eq!(crate::resolve_aq_qg_log2(&config), 5);
assert_eq!(aq_diff_cu_qp_delta_depth(&config), 1);
check_pps_rbsp_terminates_config(&config);
config.aq_mode = crate::AqMode::Perceptual;
for bad in [0u8, 8, 24, 64] {
config.aq_qg = bad;
assert_eq!(crate::resolve_aq_qg_log2(&config), 5, "aq_qg = {bad}");
}
}
#[test]
fn pps_aq_off_for_monochrome() {
let mut config = test_config(crate::DeblockMode::On); config.chroma = ChromaFormat::Gray;
config.adaptive_qp = true; assert!(!crate::aq_active(&config));
check_pps_rbsp_terminates_config(&config);
}
#[test]
fn pps_aq_off_for_high_quality_tiers() {
for effort in [crate::Effort::Slow, crate::Effort::Placebo] {
let mut config = test_config(crate::DeblockMode::On);
config.effort = effort;
assert!(!crate::aq_active(&config));
check_pps_rbsp_terminates_config(&config);
}
}
#[test]
fn auto_grid_small_image_stays_single() {
assert_eq!(super::auto_tile_dims(16, 12, 1, 6), None);
assert_eq!(super::auto_tile_dims(6, 6, 20, 6), None);
assert_eq!(super::auto_tile_dims(11, 11, 20, 6), None);
}
#[test]
fn auto_grid_targets_cores_without_overshoot() {
assert_eq!(super::auto_tile_dims(38, 29, 20, 6), Some((5, 4)));
assert_eq!(super::auto_tile_dims(38, 29, 20, 8), Some((4, 3)));
let (c, r) = super::auto_tile_dims(63, 47, 20, 6).unwrap();
assert!(c * r <= 20, "tile count {} overshot cores", c * r);
assert!(c * r >= 16, "tile count {} undershot badly", c * r);
}
#[test]
fn auto_grid_prefers_square_tiles() {
assert_eq!(super::auto_tile_dims(24, 24, 4, 6), Some((2, 2)));
}
fn read_signalled_colour(rbsp: &[u8]) -> (bool, u32, u32, u32) {
let mut r = BitReader::new(rbsp);
let ue = |r: &mut BitReader| r.read_ue_golomb().unwrap();
r.read_bits(4 + 3 + 1); let profile_idc = {
r.read_bits(2 + 1);
r.read_bits(5)
};
assert_eq!(profile_idc, 3, "walker is for 8-bit 4:2:0 only");
r.skip_bits(32 + 4 + 44 + 8); ue(&mut r); let chroma = ue(&mut r);
assert_eq!(chroma, 1);
ue(&mut r); ue(&mut r); assert_eq!(r.read_bits(1), 0); ue(&mut r); ue(&mut r); ue(&mut r); assert_eq!(r.read_bits(1), 0); ue(&mut r);
ue(&mut r);
ue(&mut r);
ue(&mut r); ue(&mut r); ue(&mut r); ue(&mut r); ue(&mut r); ue(&mut r); r.read_bits(1); r.read_bits(1); r.read_bits(1); assert_eq!(r.read_bits(1), 0); ue(&mut r); r.read_bits(1); r.read_bits(1); r.read_bits(1); assert_eq!(r.read_bits(1), 1); assert_eq!(r.read_bits(1), 0); assert_eq!(r.read_bits(1), 0); assert_eq!(r.read_bits(1), 1); assert_eq!(r.read_bits(3), 5); let full_range = r.read_bits(1) != 0;
assert_eq!(r.read_bits(1), 1); let primaries = r.read_bits(8);
let transfer = r.read_bits(8);
let matrix = r.read_bits(8);
(full_range, primaries, transfer, matrix)
}
fn msps_of(config: &StillHevcConfig, colour: Option<VuiColour>) -> Vec<u8> {
let mut annexb = Vec::new();
crate::nal::write_annexb_nal(&mut annexb, crate::nal::NalType::Vps, &write_vps(config));
crate::nal::write_annexb_nal(
&mut annexb,
crate::nal::NalType::Sps,
&write_sps_with_colour(config, colour),
);
crate::internal::bpg_hevc::ModifiedSps::from_hevc_stream(&annexb)
.expect("rewrite_sps accepts this SPS")
.0
.bytes
}
#[test]
fn vui_colour_round_trips_and_bpg_rewrite_skips_it() {
let config = test_config(crate::DeblockMode::Off);
let plain = write_sps(&config);
let parsed = crate::internal::bpg_hevc_decode::hevc::params::parse_sps(&plain).unwrap();
assert!(!parsed.video_full_range_flag);
assert_eq!(parsed.matrix_coeffs, 2);
let srgb = VuiColour::from_color_space(crate::ColorSpace::Srgb, 8, false);
assert_eq!(
(
srgb.colour_primaries,
srgb.transfer_characteristics,
srgb.matrix_coeffs
),
(1, 13, 1)
);
assert!(srgb.full_range);
let coloured = write_sps_with_colour(&config, Some(srgb));
let parsed = crate::internal::bpg_hevc_decode::hevc::params::parse_sps(&coloured).unwrap();
assert!(parsed.video_full_range_flag);
assert_eq!(parsed.matrix_coeffs, 1);
assert_eq!(read_signalled_colour(&coloured), (true, 1, 13, 1));
assert_eq!(msps_of(&config, None), msps_of(&config, Some(srgb)));
let limited = VuiColour::from_color_space(crate::ColorSpace::YCbCr, 8, true);
let limited_sps = write_sps_with_colour(&config, Some(limited));
let parsed =
crate::internal::bpg_hevc_decode::hevc::params::parse_sps(&limited_sps).unwrap();
assert!(!parsed.video_full_range_flag);
assert_eq!(parsed.matrix_coeffs, 6);
assert_eq!(read_signalled_colour(&limited_sps), (false, 6, 6, 6));
let mut rext = config.clone();
rext.chroma = ChromaFormat::Yuv444;
assert_eq!(msps_of(&rext, None), msps_of(&rext, Some(srgb)));
}
}
fn chroma_format_idc(chroma: ChromaFormat) -> u32 {
match chroma {
ChromaFormat::Gray => 0,
ChromaFormat::Yuv420 => 1,
ChromaFormat::Yuv422 => 2,
ChromaFormat::Yuv444 => 3,
}
}
fn level_idc(config: &StillHevcConfig) -> u32 {
const LEVELS: &[(u32, u64)] = &[
(30, 36_864),
(60, 122_880),
(63, 245_760),
(90, 552_960),
(93, 983_040),
(120, 2_228_224),
(150, 8_912_896),
(180, 35_651_584),
];
let samples = config.width as u64 * config.height as u64;
for &(idc, max_samples) in LEVELS {
let max_dimension = ((max_samples * 8) as f64).sqrt().floor() as u64;
if samples <= max_samples
&& config.width as u64 <= max_dimension
&& config.height as u64 <= max_dimension
{
return idc;
}
}
186 }
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct VuiColour {
pub full_range: bool,
pub colour_primaries: u8,
pub transfer_characteristics: u8,
pub matrix_coeffs: u8,
}
impl VuiColour {
pub fn from_color_space(color: crate::ColorSpace, bit_depth: u8, limited_range: bool) -> Self {
let (primaries, transfer, matrix) = color.nclx_codes(bit_depth);
Self {
full_range: !limited_range,
colour_primaries: primaries as u8,
transfer_characteristics: transfer as u8,
matrix_coeffs: matrix as u8,
}
}
}
pub fn write_sps(config: &StillHevcConfig) -> Vec<u8> {
write_sps_with_colour(config, None)
}
pub fn write_sps_with_colour(config: &StillHevcConfig, colour: Option<VuiColour>) -> Vec<u8> {
let mut w = BitWriter::new();
w.write_bits(4, 0); w.write_bits(3, 0); w.write_bit(1);
write_profile_tier_level(&mut w, 0, config);
w.write_ue_golomb(0);
let chroma_idc = chroma_format_idc(config.chroma);
w.write_ue_golomb(chroma_idc);
if chroma_idc == 3 {
w.write_bit(0); }
w.write_ue_golomb(config.width); w.write_ue_golomb(config.height);
w.write_bit(0);
let bit_depth_minus8 = (config.bit_depth - 8) as u32;
w.write_ue_golomb(bit_depth_minus8); w.write_ue_golomb(bit_depth_minus8);
w.write_ue_golomb(4);
w.write_bit(0); w.write_ue_golomb(0); w.write_ue_golomb(0); w.write_ue_golomb(0);
w.write_ue_golomb(0); w.write_ue_golomb(3); w.write_ue_golomb(0); w.write_ue_golomb(3); w.write_ue_golomb(2); w.write_ue_golomb(2);
w.write_bit(0);
w.write_bit(1); w.write_bit((config.sao != crate::SaoMode::Off) as u32);
w.write_bit(0);
w.write_ue_golomb(0);
w.write_bit(0);
w.write_bit(1); w.write_bit(1);
w.write_bit(1); w.write_bit(0); w.write_bit(0); match colour {
None => w.write_bit(0), Some(colour) => {
w.write_bit(1); w.write_bits(3, 5); w.write_bit(colour.full_range as u32);
w.write_bit(1); w.write_bits(8, colour.colour_primaries as u32);
w.write_bits(8, colour.transfer_characteristics as u32);
w.write_bits(8, colour.matrix_coeffs as u32);
}
}
w.write_bit(0); w.write_bit(0); w.write_bit(0); w.write_bit(0); w.write_bit(0); w.write_bit(0); w.write_bit(0);
w.write_bit(0);
write_rbsp_trailing_bits(&mut w);
w.into_bytes()
}
fn tile_core_count() -> u32 {
if let Ok(v) = std::env::var("BPG_ENC_THREADS") {
if let Ok(n) = v.trim().parse::<u32>() {
return n.max(1);
}
}
std::thread::available_parallelism()
.map(|n| n.get() as u32)
.unwrap_or(1)
}
fn explicit_tile_request() -> bool {
std::env::var("BPG_TILES")
.ok()
.map(|v| {
let s = v.trim();
!(s.is_empty()
|| s.eq_ignore_ascii_case("auto")
|| s == "0"
|| s.eq_ignore_ascii_case("off")
|| s.eq_ignore_ascii_case("none"))
})
.unwrap_or(false)
}
fn wpp_env_allows_auto() -> bool {
std::env::var("BPG_WPP")
.ok()
.map(|v| {
let s = v.trim();
!(s == "0" || s.eq_ignore_ascii_case("off") || s.eq_ignore_ascii_case("none"))
})
.unwrap_or(true)
}
fn aq_wpp_build_env_allows_auto() -> bool {
std::env::var("BPG_AQ_WPP")
.ok()
.map(|v| {
let s = v.trim();
!(s == "0" || s.eq_ignore_ascii_case("off") || s.eq_ignore_ascii_case("none"))
})
.unwrap_or(true)
}
fn wpp_shape_enabled(config: &StillHevcConfig) -> bool {
if !wpp_env_allows_auto() || explicit_tile_request() {
return false;
}
if !crate::effort::template(config.effort).parallel_analysis {
return false;
}
if tile_core_count() <= 1 {
return false;
}
let ctb = 1u32 << 6;
config.width.div_ceil(ctb) > 1 && config.height.div_ceil(ctb) > 1
}
pub fn effective_wpp_enabled(config: &StillHevcConfig) -> bool {
if crate::aq_active(config) {
return false;
}
wpp_shape_enabled(config)
}
pub fn effective_wpp_build_enabled(config: &StillHevcConfig) -> bool {
if crate::aq_active(config) && !aq_wpp_build_env_allows_auto() {
return false;
}
wpp_shape_enabled(config)
}
fn auto_tile_dims(ctbs_x: u32, ctbs_y: u32, cores: u32, min_ctbs: u32) -> Option<(u32, u32)> {
if cores <= 1 {
return None;
}
let max_cols = (ctbs_x / min_ctbs).max(1);
let max_rows = (ctbs_y / min_ctbs).max(1);
if max_cols * max_rows <= 1 {
return None;
}
let mut best: Option<(u32, u32)> = None;
let mut best_score = f64::INFINITY;
for c in 1..=max_cols {
for r in 1..=max_rows {
let t = c * r;
if t <= 1 || t > cores {
continue;
}
let tile_aspect = (ctbs_x as f64 / c as f64) / (ctbs_y as f64 / r as f64);
let aspect_dev = tile_aspect.ln().abs();
let score = (cores - t) as f64 * 2.0 + aspect_dev;
if score < best_score {
best_score = score;
best = Some((c, r));
}
}
}
best.filter(|&(c, r)| c * r > 1)
}
fn tile_capable(config: &StillHevcConfig) -> bool {
config.sao == crate::SaoMode::On || crate::effort::template(config.effort).parallel_analysis
}
fn auto_tile_effort(effort: crate::Effort) -> bool {
matches!(effort, crate::Effort::Slow)
}
pub fn effective_tile_dims(config: &StillHevcConfig) -> Option<(u32, u32)> {
if effective_wpp_enabled(config) || effective_wpp_build_enabled(config) {
return None;
}
if !tile_capable(config) {
return None;
}
let ctb = 1u32 << 6; let ctbs_x = config.width.div_ceil(ctb);
let ctbs_y = config.height.div_ceil(ctb);
let spec = std::env::var("BPG_TILES").ok();
let spec = spec.as_deref().map(str::trim);
match spec {
None | Some("") | Some("auto") | Some("AUTO") => {
if !auto_tile_effort(config.effort) {
return None;
}
let min_ctbs = std::env::var("BPG_TILE_MIN_CTBS")
.ok()
.and_then(|v| v.trim().parse::<u32>().ok())
.filter(|&v| v >= 1)
.unwrap_or(6);
let oversub = std::env::var("BPG_TILE_OVERSUB")
.ok()
.and_then(|v| v.trim().parse::<f64>().ok())
.filter(|&v| v >= 1.0)
.unwrap_or(1.0);
let budget = ((tile_core_count() as f64 * oversub).round() as u32).max(1);
auto_tile_dims(ctbs_x, ctbs_y, budget, min_ctbs)
}
Some("0") | Some("off") | Some("OFF") | Some("none") | Some("NONE") => None,
Some(s) => {
let (c, r) = s.split_once(|ch| ch == 'x' || ch == 'X' || ch == ',')?;
let cols: u32 = c.trim().parse().ok()?;
let rows: u32 = r.trim().parse().ok()?;
if cols < 1 || rows < 1 || cols > ctbs_x || rows > ctbs_y || (cols == 1 && rows == 1) {
return None;
}
Some((cols, rows))
}
}
}
pub fn write_pps(config: &StillHevcConfig, tiles: Option<(u32, u32)>, wpp: bool) -> Vec<u8> {
let mut w = BitWriter::new();
w.write_ue_golomb(0); w.write_ue_golomb(0); w.write_bit(0); w.write_bit(0); w.write_bits(3, 0); w.write_bit(crate::sdh_active(config) as u32); w.write_bit(0); w.write_ue_golomb(0); w.write_ue_golomb(0); w.write_se_golomb(0); w.write_bit(0); w.write_bit(0); let aq_active = crate::aq_active(config);
w.write_bit(aq_active as u32); if aq_active {
w.write_ue_golomb(aq_diff_cu_qp_delta_depth(config)); }
let chroma_qp_offset = crate::chroma_qp_offset() as i32;
w.write_se_golomb(chroma_qp_offset); w.write_se_golomb(chroma_qp_offset); w.write_bit(0); w.write_bit(0); w.write_bit(0); w.write_bit(0); w.write_bit(tiles.is_some() as u32); w.write_bit(wpp as u32); if let Some((cols, rows)) = tiles {
w.write_ue_golomb(cols - 1); w.write_ue_golomb(rows - 1); w.write_bit(1); w.write_bit(1); }
w.write_bit(1); let deblock_enabled = config.deblock == crate::DeblockMode::On;
w.write_bit(1); w.write_bit(0); w.write_bit((!deblock_enabled) as u32); if deblock_enabled {
w.write_se_golomb(0); w.write_se_golomb(0); }
w.write_bit(0); w.write_bit(0); w.write_ue_golomb(0); w.write_bit(0);
w.write_bit(0);
write_rbsp_trailing_bits(&mut w);
w.into_bytes()
}