| use avm_analyzer_common::AvmStreamInfo; | |
| use avm_stats::{FrameStatistic, HeatmapSettings, PlaneType, Sample, StatsSettings}; | |
| use base64::{engine::general_purpose::URL_SAFE, Engine as _}; | |
| use egui::{pos2, vec2, Color32, Pos2, Rect, Stroke}; | |
| use log::info; | |
| use serde::{Deserialize, Serialize}; | |
| use web_time::Instant; | |
| use crate::{ | |
| stream::{Stream, StreamSource}, | |
| views::{SelectedObject, SelectedObjectKind, ViewMode}, | |
| }; | |
| const GITLAB_ROOT: &str = "https://gitlab.com/AOMediaCodec/avm/-/blob/research-v6.0.0"; | |
| const DEFAULT_STREAMS_URL: &str = "/streams"; | |
| const DEFAULT_WORLD_BOUNDS_WIDTH: f32 = 1280.0; | |
| const DEFAULT_WORLD_BOUNDS_HEIGHT: f32 = 720.0; | |
| #[derive(Debug, Serialize, Deserialize, Clone)] | |
| pub struct OverlayStyle { | |
| pub transform_unit_stroke: Stroke, | |
| pub coding_unit_stroke: Stroke, | |
| pub superblock_stroke: Stroke, | |
| pub highlighted_object_stroke: Stroke, | |
| pub selected_object_stroke: Stroke, | |
| pub mode_name_color: Color32, | |
| pub pixel_viewer_text_color: Color32, | |
| pub enable_text_shadows: bool, | |
| } | |
| impl Default for OverlayStyle { | |
| fn default() -> Self { | |
| Self { | |
| transform_unit_stroke: Stroke::new(1.0, Color32::DARK_RED), | |
| coding_unit_stroke: Stroke::new(1.0, Color32::RED), | |
| superblock_stroke: Stroke::new(1.0, Color32::BLUE), | |
| highlighted_object_stroke: Stroke::new(4.0, Color32::LIGHT_YELLOW), | |
| selected_object_stroke: Stroke::new(3.0, Color32::YELLOW), | |
| mode_name_color: Color32::LIGHT_GREEN, | |
| pixel_viewer_text_color: Color32::LIGHT_GREEN, | |
| enable_text_shadows: true, | |
| } | |
| } | |
| } | |
| #[derive(Debug, Serialize, Deserialize, Clone)] | |
| pub struct StyleSettings { | |
| pub overlay: OverlayStyle, | |
| } | |
| #[allow(clippy::derivable_impls)] | |
| impl Default for StyleSettings { | |
| fn default() -> Self { | |
| Self { | |
| overlay: OverlayStyle::default(), | |
| } | |
| } | |
| } | |
| #[derive(Debug, Serialize, Deserialize, Clone, Copy, PartialEq)] | |
| pub enum FrameSortOrder { | |
| Decode, | |
| Display, | |
| } | |
| #[derive(Debug, Serialize, Deserialize, Clone)] | |
| pub struct PersistentSettings { | |
| pub avm_source_url: String, | |
| pub style: StyleSettings, | |
| pub apply_cache_strategy: bool, | |
| pub cache_strategy_limit: usize, | |
| pub update_sharable_url: bool, | |
| pub frame_sort_order: FrameSortOrder, | |
| } | |
| impl Default for PersistentSettings { | |
| fn default() -> Self { | |
| Self { | |
| avm_source_url: GITLAB_ROOT.into(), | |
| style: StyleSettings::default(), | |
| apply_cache_strategy: false, | |
| cache_strategy_limit: 10, | |
| update_sharable_url: false, | |
| frame_sort_order: FrameSortOrder::Decode, | |
| } | |
| } | |
| } | |
| #[derive(Debug, Serialize, Deserialize, Clone, Copy, PartialEq)] | |
| pub enum CoeffViewSelect { | |
| Quantized, | |
| Dequantized, | |
| DequantValue, | |
| } | |
| impl CoeffViewSelect { | |
| pub fn name(&self) -> &str { | |
| match self { | |
| Self::Quantized => "Quantized Coefficients", | |
| Self::Dequantized => "Dequantized Coefficients", | |
| Self::DequantValue => "Inverse Quantization Matrix", | |
| } | |
| } | |
| } | |
| #[derive(Debug, Serialize, Deserialize, Clone, Copy, PartialEq)] | |
| pub enum MotionFieldColoring { | |
| RefFrames, | |
| PastFuture, | |
| Monochrome, | |
| } | |
| impl MotionFieldColoring { | |
| pub fn name(&self) -> &str { | |
| match self { | |
| Self::RefFrames => "Reference frames", | |
| Self::PastFuture => "Past vs Future", | |
| Self::Monochrome => "Monochrome", | |
| } | |
| } | |
| } | |
| #[derive(Debug, Serialize, Deserialize, Clone, PartialEq)] | |
| pub struct MotionFieldSettings { | |
| pub show: bool, | |
| pub show_origin: bool, | |
| pub normalize: bool, | |
| /// In 4x4 units. | |
| pub granularity: usize, | |
| pub auto_granularity: bool, | |
| pub coloring: MotionFieldColoring, | |
| pub scale: f32, | |
| } | |
| impl Default for MotionFieldSettings { | |
| fn default() -> Self { | |
| Self { | |
| show: false, | |
| show_origin: true, | |
| normalize: true, | |
| granularity: 1, | |
| auto_granularity: true, | |
| coloring: MotionFieldColoring::RefFrames, | |
| scale: 1.0, | |
| } | |
| } | |
| } | |
| #[derive(Debug, Serialize, Deserialize, Clone, Copy, PartialEq, Eq)] | |
| pub enum DistortionView { | |
| Original, | |
| Reconstruction, | |
| Distortion, | |
| } | |
| impl DistortionView { | |
| pub fn name(&self) -> &str { | |
| match self { | |
| Self::Original => "Source (pre-encode)", | |
| Self::Reconstruction => "Reconstruction", | |
| Self::Distortion => "Distortion", | |
| } | |
| } | |
| } | |
| #[derive(Debug, Serialize, Deserialize, Clone, PartialEq)] | |
| pub struct SharableSettings { | |
| pub view_mode: ViewMode, | |
| pub current_plane: PlaneType, | |
| pub show_relative_delta: bool, | |
| pub show_overlay: bool, | |
| pub show_yuv: bool, | |
| pub motion_field: MotionFieldSettings, | |
| pub selected_stat: FrameStatistic, | |
| pub stats_settings: StatsSettings, | |
| pub symbol_info_filter: String, | |
| pub symbol_info_show_tags: bool, | |
| pub world_bounds: Rect, | |
| pub show_pixel_viewer: bool, | |
| pub show_coeffs_viewer: bool, | |
| pub pixel_viewer_bounds: Rect, | |
| pub coeffs_viewer_bounds: Rect, | |
| pub coeff_view_select: CoeffViewSelect, | |
| pub show_heatmap_legend: bool, | |
| pub heatmap_settings: HeatmapSettings, | |
| pub heatmap_histogram_log_scale: bool, | |
| pub show_remote_streams: bool, | |
| pub streams_url: String, | |
| // The following fields are used only during serialization. Otherwise their settings or state equivalent is used. | |
| pub selected_object_kind: Option<SelectedObjectKind>, | |
| pub selected_stream: Option<AvmStreamInfo>, | |
| pub selected_frame: usize, | |
| } | |
| impl Default for SharableSettings { | |
| fn default() -> Self { | |
| Self { | |
| current_plane: PlaneType::Rgb, | |
| show_relative_delta: false, | |
| show_overlay: true, | |
| show_yuv: true, | |
| motion_field: MotionFieldSettings::default(), | |
| view_mode: ViewMode::CodingFlow, | |
| stats_settings: StatsSettings::default(), | |
| selected_stat: FrameStatistic::BlockSizes, | |
| symbol_info_filter: "".into(), | |
| symbol_info_show_tags: true, | |
| world_bounds: Rect::from_min_size( | |
| Pos2::ZERO, | |
| vec2(DEFAULT_WORLD_BOUNDS_WIDTH, DEFAULT_WORLD_BOUNDS_HEIGHT), | |
| ), | |
| show_pixel_viewer: false, | |
| show_coeffs_viewer: false, | |
| pixel_viewer_bounds: Rect::from_min_max(pos2(0.0, 0.0), pos2(4.0, 4.0)), | |
| coeffs_viewer_bounds: Rect::from_min_max(pos2(0.0, 0.0), pos2(4.0, 4.0)), | |
| coeff_view_select: CoeffViewSelect::Dequantized, | |
| show_heatmap_legend: true, | |
| heatmap_settings: HeatmapSettings::default(), | |
| heatmap_histogram_log_scale: false, | |
| show_remote_streams: true, | |
| streams_url: DEFAULT_STREAMS_URL.into(), | |
| selected_object_kind: None, | |
| selected_stream: None, | |
| selected_frame: 0, | |
| } | |
| } | |
| } | |
| impl SharableSettings { | |
| pub fn encode(&self) -> String { | |
| let bytes = bincode::serialize(self).unwrap(); | |
| let compressed = weezl::encode::Encoder::new(weezl::BitOrder::Lsb, 8) | |
| .encode(&bytes) | |
| .unwrap(); | |
| URL_SAFE.encode(compressed) | |
| } | |
| pub fn decode(settings_str: Option<&str>) -> Option<Self> { | |
| if let Some(settings_str) = settings_str { | |
| if let Ok(bytes) = URL_SAFE.decode(settings_str) { | |
| if let Ok(uncompressed) = weezl::decode::Decoder::new(weezl::BitOrder::Lsb, 8).decode(&bytes) { | |
| if let Ok(sharable) = bincode::deserialize::<SharableSettings>(&uncompressed) { | |
| return Some(sharable); | |
| } | |
| } | |
| } | |
| } | |
| None | |
| } | |
| } | |
| pub struct PlaybackSettings { | |
| pub playback_fps: f32, | |
| pub show_loaded_frames_only: bool, | |
| pub playback_loop: bool, | |
| pub playback_running: bool, | |
| pub current_frame_display_instant: Instant, | |
| } | |
| impl Default for PlaybackSettings { | |
| fn default() -> Self { | |
| Self { | |
| playback_fps: 30.0, | |
| show_loaded_frames_only: true, | |
| playback_loop: true, | |
| playback_running: false, | |
| current_frame_display_instant: Instant::now(), | |
| } | |
| } | |
| } | |
| pub struct Settings { | |
| pub show_stream_select: bool, | |
| pub show_decode_progress: bool, | |
| pub scroll_to_index: Option<usize>, | |
| pub cached_stat_data: Option<Vec<Sample>>, | |
| pub show_performance_window: bool, | |
| pub show_settings_window: bool, | |
| pub persistent: PersistentSettings, | |
| pub sharable: SharableSettings, | |
| pub selected_object: Option<SelectedObject>, | |
| /// The first object that was selected when double clicked to navigate up the hierarchy. | |
| pub selected_object_leaf: Option<SelectedObjectKind>, | |
| pub have_world_bounds_from_shared_settings: bool, | |
| pub playback: PlaybackSettings, | |
| } | |
| #[allow(clippy::derivable_impls)] | |
| impl Default for Settings { | |
| fn default() -> Self { | |
| Self { | |
| show_stream_select: false, | |
| show_decode_progress: false, | |
| scroll_to_index: None, | |
| cached_stat_data: None, | |
| show_performance_window: false, | |
| show_settings_window: false, | |
| persistent: PersistentSettings::default(), | |
| sharable: SharableSettings::default(), | |
| selected_object: None, | |
| selected_object_leaf: None, | |
| have_world_bounds_from_shared_settings: false, | |
| playback: PlaybackSettings::default(), | |
| } | |
| } | |
| } | |
| impl Settings { | |
| pub fn apply_saved_settings_string(&mut self, settings: Option<String>) { | |
| if let Some(settings) = settings { | |
| if let Ok(persistent) = serde_json::from_str::<PersistentSettings>(&settings) { | |
| info!("Restoring saved settings: {persistent:?}"); | |
| self.persistent = persistent; | |
| } | |
| } | |
| } | |
| pub fn from_shared_settings_string(settings_str: Option<&str>) -> Self { | |
| if let Some(sharable) = SharableSettings::decode(settings_str) { | |
| info!("Loaded shared settings: {sharable:?}"); | |
| return Self { | |
| sharable, | |
| have_world_bounds_from_shared_settings: true, | |
| ..Default::default() | |
| }; | |
| } | |
| Self::default() | |
| } | |
| pub fn create_shared_settings(&self, stream: &Option<Stream>) -> SharableSettings { | |
| let mut shared = self.sharable.clone(); | |
| shared.selected_frame = 0; | |
| shared.selected_stream = None; | |
| shared.selected_object_kind = None; | |
| if let Some(stream) = stream { | |
| // Only save state for HTTP streams. | |
| if matches!(stream.source, StreamSource::Http(_)) { | |
| shared.selected_frame = stream.current_frame_index; | |
| // TODO(comc): Can be simplified with serde skip. | |
| shared.selected_stream = Some(AvmStreamInfo { | |
| thumbnail_png: None, | |
| ..stream.stream_info.clone() | |
| }); | |
| if let Some(selected_object) = &self.selected_object { | |
| shared.selected_object_kind = Some(selected_object.kind.clone()); | |
| } | |
| } | |
| } | |
| shared | |
| } | |
| } |