| use std::collections::{HashMap, HashSet}; | |
| use itertools::Itertools; | |
| use ordered_float::OrderedFloat; | |
| use serde::{Deserialize, Serialize}; | |
| use crate::{CodingUnitKind, Frame, Plane, PlaneType, ProtoEnumMapping, Spatial}; | |
| #[derive(Copy, Clone, PartialEq, Eq, Debug, Deserialize, Serialize)] | |
| pub enum FrameStatistic { | |
| LumaModes, | |
| ChromaModes, | |
| BlockSizes, | |
| Symbols, | |
| PartitionSplit, | |
| } | |
| #[derive(Default, Debug, Deserialize, Serialize, PartialEq)] | |
| pub struct StatsFilter { | |
| pub include: Vec<String>, | |
| pub exclude: Vec<String>, | |
| } | |
| impl StatsFilter { | |
| fn from_comma_separated(include: &str, exclude: &str) -> Self { | |
| Self { | |
| include: include | |
| .split(',') | |
| .map(|s| s.trim().to_string()) | |
| .filter(|s| !s.is_empty()) | |
| .collect(), | |
| exclude: exclude | |
| .split(',') | |
| .map(|s| s.trim().to_string()) | |
| .filter(|s| !s.is_empty()) | |
| .collect(), | |
| } | |
| } | |
| } | |
| #[derive(Copy, Clone, PartialEq, Eq, Debug, Deserialize, Serialize)] | |
| pub enum StatSortMode { | |
| Unsorted, | |
| ByName, | |
| ByValue, | |
| } | |
| impl StatSortMode { | |
| pub fn name(&self) -> &'static str { | |
| match self { | |
| Self::Unsorted => "Unsorted", | |
| Self::ByName => "By name", | |
| Self::ByValue => "By value", | |
| } | |
| } | |
| } | |
| #[derive(Debug, Clone, PartialEq, Deserialize, Serialize)] | |
| pub struct StatsSettings { | |
| pub sort_by: StatSortMode, | |
| // Using separate bool + value fields rather than an Option to make the UI design a bit more intuitive (e.g. checkbox + disabled number input). | |
| pub apply_limit_count: bool, | |
| pub limit_count: usize, | |
| pub apply_limit_frac: bool, | |
| pub limit_frac: f32, | |
| pub include_filter: String, | |
| pub exclude_filter: String, | |
| pub include_filter_exact_match: bool, | |
| pub exclude_filter_exact_match: bool, | |
| pub show_relative_total: bool, | |
| // Comma separated list of block sizes to include for partition split stats. | |
| pub partition_split_block_sizes: String, | |
| } | |
| impl Default for StatsSettings { | |
| fn default() -> Self { | |
| Self { | |
| sort_by: StatSortMode::ByValue, | |
| apply_limit_count: false, | |
| limit_count: 20, | |
| apply_limit_frac: false, | |
| limit_frac: 0.01, | |
| include_filter: "".into(), | |
| exclude_filter: "".into(), | |
| include_filter_exact_match: false, | |
| exclude_filter_exact_match: false, | |
| show_relative_total: false, | |
| partition_split_block_sizes: "".into(), | |
| } | |
| } | |
| } | |
| #[derive(Debug)] | |
| pub struct Sample { | |
| pub name: String, | |
| pub value: f64, | |
| } | |
| impl Sample { | |
| pub fn new(name: String, value: f64) -> Self { | |
| Self { name, value } | |
| } | |
| } | |
| impl FrameStatistic { | |
| fn luma_modes(&self, frame: &Frame) -> HashMap<String, f64> { | |
| let modes = frame.iter_coding_units(CodingUnitKind::Shared).map(|ctx| { | |
| let cu = ctx.coding_unit; | |
| let prediction_mode = cu.prediction_mode.as_ref().unwrap(); | |
| frame | |
| .enum_lookup(ProtoEnumMapping::PredictionMode, prediction_mode.mode) | |
| .unwrap_or("UNKNOWN".into()) | |
| }); | |
| let mut modes_map: HashMap<String, f64> = HashMap::new(); | |
| for mode in modes { | |
| *modes_map.entry(mode).or_default() += 1.0; | |
| } | |
| modes_map | |
| } | |
| fn chroma_modes(&self, frame: &Frame) -> HashMap<String, f64> { | |
| let kind = frame.coding_unit_kind(PlaneType::Planar(Plane::U)); | |
| let modes = frame.iter_coding_units(kind).map(|ctx| { | |
| let cu = ctx.coding_unit; | |
| let prediction_mode = cu.prediction_mode.as_ref().unwrap(); | |
| frame | |
| .enum_lookup(ProtoEnumMapping::UvPredictionMode, prediction_mode.uv_mode) | |
| .unwrap_or("UNKNOWN".into()) | |
| }); | |
| let mut modes_map: HashMap<String, f64> = HashMap::new(); | |
| for mode in modes { | |
| *modes_map.entry(mode).or_default() += 1.0; | |
| } | |
| modes_map | |
| } | |
| fn block_sizes(&self, frame: &Frame) -> HashMap<String, f64> { | |
| let sizes = frame.iter_coding_units(CodingUnitKind::Shared).map(|ctx| { | |
| let cu = ctx.coding_unit; | |
| let w = cu.width(); | |
| let h = cu.height(); | |
| format!("{w}x{h}") | |
| }); | |
| let mut sizes_map: HashMap<String, f64> = HashMap::new(); | |
| for size in sizes { | |
| *sizes_map.entry(size).or_default() += 1.0; | |
| } | |
| sizes_map | |
| } | |
| fn partition_split(&self, frame: &Frame, settings: &StatsSettings) -> HashMap<String, f64> { | |
| // TODO(comc): Add settings option for partition kind. | |
| let filter = StatsFilter::from_comma_separated(&settings.partition_split_block_sizes, ""); | |
| let splits = frame.iter_partitions(CodingUnitKind::Shared).filter_map(|ctx| { | |
| let partition = ctx.partition; | |
| let size = partition.size_name(); | |
| if !filter.include.is_empty() && !filter.include.iter().any(|incl| &size == incl) { | |
| return None; | |
| } | |
| let partition_type = frame | |
| .enum_lookup(ProtoEnumMapping::PartitionType, partition.partition_type) | |
| .unwrap_or("UNKNOWN".into()); | |
| Some(partition_type) | |
| }); | |
| let mut splits_map: HashMap<String, f64> = HashMap::new(); | |
| for split in splits { | |
| *splits_map.entry(split).or_default() += 1.0; | |
| } | |
| splits_map | |
| } | |
| fn symbols(&self, frame: &Frame) -> HashMap<String, f64> { | |
| let mut symbols: HashMap<String, f64> = HashMap::new(); | |
| // TODO(comc): Use iter_symbols. Add iter_symbols method for partition blocks as well. | |
| let sbs = frame.iter_superblocks().map(|sb_ctx| { | |
| let sb = sb_ctx.superblock; | |
| let mut symbols_sb: HashMap<String, f64> = HashMap::new(); | |
| for symbol in sb.symbols.iter() { | |
| let info = symbol.info_id; | |
| let info = &frame.symbol_info[&info]; | |
| let name = info.source_function.clone(); | |
| let bits = symbol.bits; | |
| *symbols_sb.entry(name.clone()).or_default() += bits as f64; | |
| } | |
| symbols_sb | |
| }); | |
| for symbols_sb in sbs { | |
| for (name, bits) in symbols_sb { | |
| *symbols.entry(name.clone()).or_default() += bits; | |
| } | |
| } | |
| symbols | |
| } | |
| fn apply_settings(&self, mapping: HashMap<String, f64>, settings: &StatsSettings) -> Vec<Sample> { | |
| let mut samples: Vec<_> = mapping | |
| .into_iter() | |
| .map(|(name, value)| Sample::new(name, value)) | |
| .collect(); | |
| let filter: StatsFilter = StatsFilter::from_comma_separated(&settings.include_filter, &settings.exclude_filter); | |
| let total: f64 = samples.iter().map(|sample| sample.value).sum(); | |
| let mut other = 0.0; | |
| samples.retain(|Sample { name, value }| { | |
| let mut keep = true; | |
| // TODO(comc): Make this a method of StatsFilter. | |
| if !filter.include.is_empty() { | |
| if settings.include_filter_exact_match { | |
| if !filter.include.contains(name) { | |
| keep = false; | |
| } | |
| } else if !filter.include.iter().any(|incl| name.contains(incl)) { | |
| keep = false; | |
| } | |
| } | |
| if settings.exclude_filter_exact_match { | |
| if filter.exclude.contains(name) { | |
| keep = false | |
| } | |
| } else if filter.exclude.iter().any(|excl| name.contains(excl)) { | |
| keep = false; | |
| } | |
| if !keep { | |
| other += value; | |
| } | |
| keep | |
| }); | |
| let filtered_total: f64 = samples.iter().map(|sample| sample.value).sum(); | |
| let top_n = if settings.apply_limit_count { | |
| let top_n: HashSet<_> = samples | |
| .iter() | |
| .sorted_by_key(|sample| (OrderedFloat(sample.value), &sample.name)) // name used as a tie-breaker. | |
| .rev() | |
| .map(|sample| sample.name.clone()) | |
| .take(settings.limit_count) | |
| .collect(); | |
| Some(top_n) | |
| } else { | |
| None | |
| }; | |
| samples.retain(|Sample { name, value }| { | |
| let mut keep = true; | |
| if settings.apply_limit_frac { | |
| let frac = if settings.show_relative_total { | |
| *value / filtered_total | |
| } else { | |
| *value / total | |
| }; | |
| if frac < settings.limit_frac as f64 { | |
| keep = false; | |
| } | |
| } | |
| if let Some(top_n) = &top_n { | |
| if !top_n.contains(name) { | |
| keep = false; | |
| } | |
| } | |
| if !keep { | |
| other += value; | |
| } | |
| keep | |
| }); | |
| if !settings.show_relative_total && other > 0.0 { | |
| samples.push(Sample::new("Other".into(), other)); | |
| } | |
| match settings.sort_by { | |
| StatSortMode::ByName => samples | |
| .into_iter() | |
| .sorted_by_key(|sample| sample.name.clone()) | |
| .collect(), | |
| StatSortMode::ByValue => samples | |
| .into_iter() | |
| .sorted_by_key(|sample| (OrderedFloat(sample.value), sample.name.clone())) // name used as a tie-breaker. | |
| .collect(), | |
| StatSortMode::Unsorted => samples, | |
| } | |
| } | |
| pub fn calculate(&self, frame: &Frame, settings: &StatsSettings) -> Vec<Sample> { | |
| let mapping = match self { | |
| FrameStatistic::LumaModes => self.luma_modes(frame), | |
| FrameStatistic::ChromaModes => self.chroma_modes(frame), | |
| FrameStatistic::BlockSizes => self.block_sizes(frame), | |
| FrameStatistic::Symbols => self.symbols(frame), | |
| FrameStatistic::PartitionSplit => self.partition_split(frame, settings), | |
| }; | |
| self.apply_settings(mapping, settings) | |
| } | |
| pub fn name(&self) -> &'static str { | |
| match self { | |
| FrameStatistic::LumaModes => "Luma modes", | |
| FrameStatistic::ChromaModes => "Chroma modes", | |
| FrameStatistic::BlockSizes => "Block sizes", | |
| FrameStatistic::Symbols => "Symbols", | |
| FrameStatistic::PartitionSplit => "Partition split", | |
| } | |
| } | |
| } | |
| #[cfg(test)] | |
| mod tests { | |
| use super::*; | |
| #[test] | |
| fn test_exclude_filter() { | |
| let mapping: HashMap<String, f64> = [("ABC", 1.0), ("AAA", 2.0)] | |
| .iter() | |
| .map(|(k, v)| (k.to_string(), *v)) | |
| .collect(); | |
| let settings = StatsSettings { | |
| exclude_filter: "A".into(), | |
| exclude_filter_exact_match: true, | |
| show_relative_total: true, | |
| ..Default::default() | |
| }; | |
| let samples = FrameStatistic::Symbols.apply_settings(mapping, &settings); | |
| assert_eq!(samples.len(), 2); | |
| } | |
| } |