extern crate alloc;
#[doc(hidden)]
pub mod internal {
#[doc(hidden)]
pub mod bpg_bitstream;
#[doc(hidden)]
pub mod bpg_decode;
#[doc(hidden)]
pub mod bpg_encode;
#[doc(hidden)]
pub mod bpg_format;
#[doc(hidden)]
pub mod bpg_hevc;
#[doc(hidden)]
pub mod bpg_hevc_decode;
#[doc(hidden)]
pub mod bpg_image;
}
#[doc(hidden)]
pub mod analysis_cache;
pub mod backend;
#[doc(hidden)]
pub mod batch;
#[doc(hidden)]
pub mod cabac;
#[doc(hidden)]
pub mod contexts;
#[doc(hidden)]
pub mod effort;
pub mod encoder;
#[doc(hidden)]
pub mod nal;
#[doc(hidden)]
pub mod params;
#[doc(hidden)]
pub mod plan;
#[doc(hidden)]
pub mod preanalysis;
mod primitives;
mod rdoq;
#[doc(hidden)]
pub mod residual;
#[doc(hidden)]
pub mod sao;
#[doc(hidden)]
pub mod slice;
#[doc(hidden)]
pub mod trace;
#[doc(hidden)]
pub mod transform;
#[doc(hidden)]
pub mod tu_diag;
pub use crate::internal::bpg_decode::heic::{
HeicImageInfo, decode_heic, decode_heic_thumbnail, decode_heic_to_frame, get_heic_image_info,
};
pub use crate::internal::bpg_decode::{
ContainerKind, DecodeError, DecodeOutput, DecoderConfig, ImageInfo, Limits, PixelLayout,
};
pub use crate::internal::bpg_encode::heic::{HeicEncodeOptions, ImageOrientation};
pub use crate::internal::bpg_encode::{
EncodeError, EncoderTuning, HevcBackendCaps, HevcEncodeParams, HevcEncoder,
};
pub use crate::internal::bpg_hevc_decode::DecodedFrame;
pub use crate::internal::bpg_image::{ChromaFormat, ColorSpace, Image};
pub use backend::{LastEncodeStats, RustStillHevcEncoder};
pub fn encode_bpg(
image: Image,
encoder: &RustStillHevcEncoder,
qp: u8,
) -> Result<Vec<u8>, EncodeError> {
crate::internal::bpg_encode::encode_still_image(image, encoder, qp, 1, EncoderTuning::default())
}
pub fn encode_heic(
image: Image,
encoder: &RustStillHevcEncoder,
qp: u8,
options: HeicEncodeOptions,
) -> Result<Vec<u8>, EncodeError> {
crate::internal::bpg_encode::heic::encode_heic_still_image(
image,
encoder,
qp,
1,
EncoderTuning::default(),
options,
)
}
pub fn decode_bpg(data: &[u8], layout: PixelLayout) -> Result<DecodeOutput, DecodeError> {
DecoderConfig::default().decode(data, layout)
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum Effort {
Fast,
#[default]
Slow,
Placebo,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum SaoMode {
#[default]
Off,
On,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum DeblockMode {
#[default]
Off,
On,
}
#[inline]
pub fn is_reference_tier(effort: Effort) -> bool {
matches!(effort, Effort::Placebo)
}
#[inline]
pub fn aq_active(config: &StillHevcConfig) -> bool {
if config.chroma == ChromaFormat::Gray {
return false;
}
resolve_aq_mode(config) != AqMode::Off || preanalysis::external_aq_map_requested()
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum AqMode {
#[default]
Off,
LegacyShrink,
Perceptual,
PerceptualChroma,
AutoVariance,
AutoVarianceBiased,
PsnrProbe,
PositiveProbe,
TwoPassMeasured,
}
impl AqMode {
#[inline]
pub const fn recommended() -> Self {
Self::TwoPassMeasured
}
pub fn is_two_pass(self) -> bool {
matches!(self, AqMode::TwoPassMeasured)
}
}
#[inline]
pub const fn recommended_aq_preset() -> (AqMode, f32, u8) {
(AqMode::recommended(), 1.00, 4)
}
pub fn aq_preset(name: &str) -> Option<(AqMode, f32, u8)> {
Some(match name.trim().to_ascii_lowercase().as_str() {
"off" => (AqMode::Off, 0.0, 2),
"legacy-shrink" | "legacy" => (AqMode::LegacyShrink, 0.0, 8),
"perceptual-mild" => (AqMode::Perceptual, 0.20, 2),
"perceptual" => (AqMode::Perceptual, 0.35, 2),
"perceptual-chroma-mild" => (AqMode::PerceptualChroma, 0.20, 2),
"perceptual-chroma" => (AqMode::PerceptualChroma, 0.35, 2),
"auto-variance" | "autovar" => (AqMode::AutoVariance, 1.0, 6),
"auto-variance-biased" | "autovar-biased" => (AqMode::AutoVarianceBiased, 1.0, 6),
"psnr-probe" | "psnr" => (AqMode::PsnrProbe, 0.35, 2),
"positive-probe" | "positive" => (AqMode::PositiveProbe, 0.35, 2),
"two-pass" | "twopass" => recommended_aq_preset(),
_ => return None,
})
}
pub fn resolve_aq_mode(config: &StillHevcConfig) -> AqMode {
if config.effort == Effort::Placebo {
if let Some((mode, _)) = placebo_aq_env() {
return mode;
}
}
if config.aq_mode != AqMode::Off {
return config.aq_mode;
}
if config.adaptive_qp {
return AqMode::LegacyShrink;
}
AqMode::Off
}
pub fn resolve_aq(config: &StillHevcConfig) -> (AqMode, f32, f32) {
if config.effort == Effort::Placebo {
if let Some((mode, strength)) = placebo_aq_env() {
return (mode, strength, preanalysis::VAR_AQ_CLAMP);
}
}
let mode = resolve_aq_mode(config);
(mode, config.aq_strength, config.aq_clamp.max(1) as f32)
}
fn placebo_aq_env() -> Option<(AqMode, f32)> {
let mode = std::env::var("BPG_PLACEBO_AQ").ok()?;
let mode = mode.trim();
if mode.is_empty() || mode == "0" {
return None;
}
let aq_mode = if mode.eq_ignore_ascii_case("perceptual") {
AqMode::Perceptual
} else if mode.eq_ignore_ascii_case("perceptual-chroma")
|| mode.eq_ignore_ascii_case("perceptual_chroma")
{
AqMode::PerceptualChroma
} else if mode.eq_ignore_ascii_case("positive") {
AqMode::PositiveProbe
} else {
AqMode::PsnrProbe
};
let strength = std::env::var("BPG_PLACEBO_AQ_STRENGTH")
.ok()
.and_then(|s| s.trim().parse::<f32>().ok())
.filter(|s| s.is_finite() && *s >= 0.0)
.unwrap_or(1.0);
Some((aq_mode, strength))
}
#[inline]
pub fn sdh_active(config: &StillHevcConfig) -> bool {
let _ = config;
if let Ok(v) = std::env::var("BPG_SDH") {
return v.trim() != "0";
}
std::env::var("BPG_BEST2_SDH")
.ok()
.map(|v| v.trim() != "0")
.unwrap_or(true)
}
#[inline]
pub fn chroma_qp_offset() -> i8 {
std::env::var("BPG_CHROMA_QP_OFFSET")
.ok()
.and_then(|v| v.trim().parse::<i8>().ok())
.map(|v| v.clamp(-12, 12))
.unwrap_or(0)
}
#[derive(Debug, Clone)]
pub struct StillHevcConfig {
pub width: u32,
pub height: u32,
pub bit_depth: u8,
pub chroma: ChromaFormat,
pub qp: u8,
pub effort: Effort,
pub sao: SaoMode,
pub deblock: DeblockMode,
pub adaptive_qp: bool,
pub aq_mode: AqMode,
pub aq_strength: f32,
pub aq_clamp: u8,
pub two_pass_gate: bool,
pub psy_rd: f32,
pub psy_rdoq: f32,
pub aq_qg: u8,
}
#[inline]
pub fn resolve_aq_qg_log2(config: &StillHevcConfig) -> u8 {
if config.aq_qg == 16 && resolve_aq_mode(config) != AqMode::TwoPassMeasured {
4
} else {
5
}
}
pub struct StillHevcEncoder;
impl StillHevcEncoder {
pub fn syntax_skeleton(config: &StillHevcConfig) -> Vec<u8> {
let mut out = Vec::new();
nal::write_annexb_nal(&mut out, nal::NalType::Vps, ¶ms::write_vps(config));
nal::write_annexb_nal(&mut out, nal::NalType::Sps, ¶ms::write_sps(config));
let wpp = params::effective_wpp_enabled(config);
let tiles = params::effective_tile_dims(config);
nal::write_annexb_nal(
&mut out,
nal::NalType::Pps,
¶ms::write_pps(config, tiles, wpp),
);
nal::write_annexb_nal(
&mut out,
nal::NalType::IdrWRadl,
&slice::write_slice_segment_header(config, tiles, wpp, &[]),
);
out
}
}