From 37958cf76557186e28b2bdb839331fa978af5e8b Mon Sep 17 00:00:00 2001 From: Daniel Almeida Date: Fri, 4 Aug 2023 14:10:30 -0300 Subject: [PATCH] codec: av1: add an AV1 parser --- src/codec.rs | 1 + src/codec/av1.rs | 7 + src/codec/av1/helpers.rs | 119 + src/codec/av1/parser.rs | 3211 ++++++++++++++++++++ src/codec/av1/reader.rs | 295 ++ src/codec/av1/test_data/av1-annexb.ivf | Bin 0 -> 579 bytes src/codec/av1/test_data/test-25fps.av1.ivf | Bin 0 -> 223686 bytes 7 files changed, 3633 insertions(+) create mode 100644 src/codec/av1.rs create mode 100644 src/codec/av1/helpers.rs create mode 100644 src/codec/av1/parser.rs create mode 100644 src/codec/av1/reader.rs create mode 100644 src/codec/av1/test_data/av1-annexb.ivf create mode 100644 src/codec/av1/test_data/test-25fps.av1.ivf diff --git a/src/codec.rs b/src/codec.rs index d84b31dd..582ef5fc 100644 --- a/src/codec.rs +++ b/src/codec.rs @@ -11,6 +11,7 @@ //! There shall be no dependencies from other modules of this crate to this module, so that it //! can be turned into a crate of its own if needed in the future. +pub mod av1; pub mod h264; pub mod h265; pub mod vp8; diff --git a/src/codec/av1.rs b/src/codec/av1.rs new file mode 100644 index 00000000..5612c58e --- /dev/null +++ b/src/codec/av1.rs @@ -0,0 +1,7 @@ +// Copyright 2023 The ChromiumOS Authors +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +mod helpers; +pub mod parser; +pub mod reader; diff --git a/src/codec/av1/helpers.rs b/src/codec/av1/helpers.rs new file mode 100644 index 00000000..31eb9595 --- /dev/null +++ b/src/codec/av1/helpers.rs @@ -0,0 +1,119 @@ +// Copyright 2023 The ChromiumOS Authors +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +use crate::codec::av1::parser::NUM_REF_FRAMES; + +/// Implements FloorLog2(x), which is defined to be the floor of the base 2 +/// logarithm of the input x. +/// +/// The input x will always be an integer, and will always be greater than or equal to 1. +/// This function extracts the location of the most significant bit in x. +pub fn floor_log2(mut x: u8) -> u8 { + assert!(x > 0); + let mut s = 0; + + while x != 0 { + x >>= 1; + s += 1; + } + + s - 1 +} + +pub fn get_relative_dist(enable_order_hint: bool, order_hint_bits: i32, a: i32, b: i32) -> i32 { + if !enable_order_hint { + 0 + } else { + let diff = a - b; + let m = 1 << (order_hint_bits - 1); + (diff & (m - 1)) - (diff & m) + } +} + +pub fn find_latest_backward( + shifted_order_hints: &[i32; NUM_REF_FRAMES], + used_frame: &[bool; NUM_REF_FRAMES], + cur_frame_hint: i32, + latest_order_hint: &mut i32, +) -> i32 { + let mut _ref = -1; + + for i in 0..NUM_REF_FRAMES { + let hint = shifted_order_hints[i]; + if !used_frame[i] && hint >= cur_frame_hint && (_ref < 0 || hint >= *latest_order_hint) { + _ref = i as i32; + *latest_order_hint = hint; + } + } + + _ref +} + +pub fn find_earliest_backward( + shifted_order_hints: &[i32; NUM_REF_FRAMES], + used_frame: &[bool; NUM_REF_FRAMES], + cur_frame_hint: i32, + earliest_order_hint: &mut i32, +) -> i32 { + let mut _ref = -1; + + for i in 0..NUM_REF_FRAMES { + let hint = shifted_order_hints[i]; + if !used_frame[i] && hint >= cur_frame_hint && (_ref < 0 || hint < *earliest_order_hint) { + _ref = i as i32; + *earliest_order_hint = hint; + } + } + + _ref +} + +pub fn find_latest_forward( + shifted_order_hints: &[i32; NUM_REF_FRAMES], + used_frame: &[bool; NUM_REF_FRAMES], + cur_frame_hint: i32, + latest_order_hint: &mut i32, +) -> i32 { + let mut _ref = -1; + for i in 0..NUM_REF_FRAMES { + let hint = shifted_order_hints[i]; + if !used_frame[i] && hint < cur_frame_hint && (_ref < 0 || hint >= *latest_order_hint) { + _ref = i as i32; + *latest_order_hint = hint; + } + } + + _ref +} + +pub fn tile_log2(blk_size: u32, target: u32) -> u32 { + let mut k = 0; + + while (blk_size << k) < target { + k += 1; + } + + k +} + +pub fn clip3(x: i32, y: i32, z: i32) -> i32 { + if z < x { + x + } else if z > y { + y + } else { + z + } +} + +/// 5.9.29 +pub fn inverse_recenter(r: i32, v: i32) -> i32 { + if v > 2 * r { + v + } else if v & 1 != 0 { + r - ((v + 1) >> 1) + } else { + r + (v >> 1) + } +} diff --git a/src/codec/av1/parser.rs b/src/codec/av1/parser.rs new file mode 100644 index 00000000..fe6e956a --- /dev/null +++ b/src/codec/av1/parser.rs @@ -0,0 +1,3211 @@ +// Copyright 2023 The ChromiumOS Authors +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +use std::borrow::Cow; +use std::rc::Rc; + +use anyhow::anyhow; +use enumn::N; + +use crate::codec::av1::helpers; +use crate::codec::av1::reader::Reader; + +pub const TOTAL_REFS_PER_FRAME: usize = 8; +pub const NUM_REF_FRAMES: usize = 8; +pub const REFS_PER_FRAME: usize = 7; +pub const MAX_SEGMENTS: usize = 8; +pub const SEG_LVL_ALT_Q: usize = 0; +pub const SEG_LVL_ALT_LF_Y_V: usize = 1; +pub const SEG_LVL_REF_FRAME: usize = 5; +pub const SEG_LVL_SKIP: usize = 6; +pub const SEG_LVL_GLOBAL_MV: usize = 7; +pub const SEG_LVL_MAX: usize = 8; +pub const MAX_TILE_COLS: usize = 64; +pub const MAX_TILE_ROWS: usize = 64; +pub const CDEF_MAX: usize = 1 << 3; +pub const MAX_NUM_PLANES: usize = 3; +pub const MAX_NUM_Y_POINTS: usize = 16; +pub const MAX_NUM_CB_POINTS: usize = 16; +pub const MAX_NUM_CR_POINTS: usize = 16; +pub const MAX_NUM_POS_LUMA: usize = 25; +pub const MAX_NUM_SPATIAL_LAYERS: usize = 4; +pub const MAX_NUM_TEMPORAL_LAYERS: usize = 8; +pub const MAX_NUM_OPERATING_POINTS: usize = MAX_NUM_SPATIAL_LAYERS * MAX_NUM_TEMPORAL_LAYERS; +pub const SELECT_SCREEN_CONTENT_TOOLS: usize = 2; +pub const SELECT_INTEGER_MV: usize = 2; +pub const PRIMARY_REF_NONE: u32 = 7; +pub const SUPERRES_DENOM_BITS: usize = 3; +pub const SUPERRES_DENOM_MIN: usize = 9; +pub const SUPERRES_NUM: usize = 8; +pub const MAX_TILE_WIDTH: u32 = 4096; +pub const MAX_TILE_HEIGHT: u32 = 2304; +pub const MAX_TILE_AREA: u32 = MAX_TILE_WIDTH * MAX_TILE_HEIGHT; +pub const RESTORATION_TILESIZE_MAX: u32 = 256; +pub const WARPEDMODEL_PREC_BITS: u32 = 16; +pub const GM_ABS_ALPHA_BITS: u32 = 12; +pub const GM_ALPHA_PREC_BITS: u32 = 15; +pub const GM_ABS_TRANS_ONLY_BITS: u32 = 9; +pub const GM_TRANS_ONLY_PREC_BITS: u32 = 3; +pub const GM_ABS_TRANS_BITS: u32 = 12; +pub const GM_TRANS_PREC_BITS: u32 = 6; + +#[derive(N, Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord)] +pub enum ObuType { + #[default] + Reserved = 0, + SequenceHeader = 1, + TemporalDelimiter = 2, + FrameHeader = 3, + TileGroup = 4, + Metadata = 5, + Frame = 6, + RedundantFrameHeader = 7, + TileList = 8, + Reserved2 = 9, + Reserved3 = 10, + Reserved4 = 11, + Reserved5 = 12, + Reserved6 = 13, + Reserved7 = 14, + Padding = 15, +} + +#[derive(N, Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord)] +pub enum Profile { + #[default] + Profile0 = 0, + Profile1 = 1, + Profile2 = 2, +} + +#[derive(Clone, Debug, Default, PartialEq, Eq)] +pub struct ObuHeader { + pub obu_type: ObuType, + pub extension_flag: bool, + pub has_size_field: bool, + pub temporal_id: u32, + pub spatial_id: u32, +} + +impl ObuHeader { + /// Length in bytes + pub fn len(&self) -> usize { + if self.extension_flag { + 2 + } else { + 1 + } + } +} + +#[derive(Clone, Debug, Default, PartialEq, Eq)] +pub struct Obu<'a> { + /// The OBU header. + pub header: ObuHeader, + /// The data backing the OBU. + pub data: Cow<'a, [u8]>, + /// Where the OBU data starts, after the size has been read. + pub start_offset: usize, + /// The OBU size as per the specification after `start_offset`. + pub size: usize, +} + +impl<'a> AsRef<[u8]> for Obu<'a> { + fn as_ref(&self) -> &[u8] { + &self.data[self.start_offset..self.start_offset + self.size] + } +} + +#[derive(Clone, Debug, Default, PartialEq, Eq)] +pub struct Tile { + pub tile_offset: u32, + pub tile_size: u32, + pub tile_row: u32, + pub tile_col: u32, + pub mi_row_start: u32, + pub mi_row_end: u32, + pub mi_col_start: u32, + pub mi_col_end: u32, +} + +#[derive(Clone, Debug, Default, PartialEq, Eq)] +pub struct TileGroupObu<'a> { + pub obu: Obu<'a>, + pub tile_start_and_end_present_flag: bool, + pub tg_start: u32, + pub tg_end: u32, + pub tiles: Vec, +} + +#[derive(Clone, Debug, Default, PartialEq, Eq)] +pub struct OperatingPoint { + pub seq_level_idx: u32, + pub seq_tier: u32, + pub idc: u32, + pub decoder_model_present_for_this_op: bool, + pub decoder_buffer_delay: u32, + pub encoder_buffer_delay: u32, + pub low_delay_mode_flag: bool, + pub initial_display_delay_present_for_this_op: bool, + pub initial_display_delay_minus_1: u32, +} + +#[derive(Clone, Debug, Default, PartialEq, Eq)] +pub struct TimingInfo { + pub num_units_in_display_tick: u32, + pub time_scale: u32, + pub equal_picture_interval: bool, + pub num_ticks_per_picture_minus_1: u32, +} + +#[derive(Clone, Debug, Default, PartialEq, Eq)] +pub struct DecoderModelInfo { + pub buffer_delay_length_minus_1: u32, + pub num_units_in_decoding_tick: u32, + pub buffer_removal_time_length_minus_1: u32, + pub frame_presentation_time_length_minus_1: u32, +} + +/// Defined by the “Color primaries” section of ISO/IEC 23091-4/ITU-T H.273 +/// See 6.4.2 +#[derive(N, Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord)] +pub enum ColorPrimaries { + Bt709 = 1, + #[default] + Unspecified = 2, + Bt470M = 4, + Bt470bg = 5, + Bt601 = 6, + Smpte240 = 7, + GenericFilm = 8, + Bt2020 = 9, + Xyz = 10, + Smpte431 = 11, + Smpte432 = 12, + Ebu3213 = 22, +} + +#[derive(N, Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord)] +pub enum TransferCharacteristics { + Reserved0 = 0, + Bt709 = 1, + #[default] + Unspecified = 2, + Reserved3 = 3, + Bt470m = 4, + Bt470bg = 5, + Bt601 = 6, + Smpte240 = 7, + Linear = 8, + Log100 = 9, + Log100Sqrt10 = 10, + Iec61966 = 11, + Bt1361 = 12, + Srgb = 13, + Bt202010Bit = 14, + Bt202012Bit = 15, + Smpte2084 = 16, + Smpte428 = 17, + Hlg = 18, +} + +#[derive(N, Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord)] +pub enum BitDepth { + #[default] + Depth8, + Depth10, + Depth12, +} + +#[derive(N, Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord)] +pub enum MatrixCoefficients { + Identity = 0, + Bt709 = 1, + #[default] + Unspecified = 2, + Reserved3 = 3, + Fcc = 4, + Bt470bg = 5, + Bt601 = 6, + Smpte240 = 7, + Ycgco = 8, + Bt2020Ncl = 9, + Bt2020Cl = 10, + Smpte2085 = 11, + ChromaDerivedNcl = 12, + ChromaDerivedCl = 13, + Ictcp = 14, +} + +#[derive(N, Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord)] +pub enum ChromaSamplePosition { + #[default] + Unknown = 0, + Vertical = 1, + Colocated = 2, + Reserved = 3, +} + +#[derive(Clone, Debug, Default, PartialEq, Eq)] +pub struct ColorConfig { + pub high_bitdepth: bool, + pub twelve_bit: bool, + pub mono_chrome: bool, + pub color_description_present_flag: bool, + pub color_primaries: ColorPrimaries, + pub transfer_characteristics: TransferCharacteristics, + pub matrix_coefficients: MatrixCoefficients, + pub color_range: bool, + pub subsampling_x: bool, + pub subsampling_y: bool, + pub chroma_sample_position: ChromaSamplePosition, + pub separate_uv_delta_q: bool, +} + +#[derive(Clone, Debug, Default, PartialEq, Eq)] +pub struct SequenceHeaderObu { + pub obu_header: ObuHeader, + pub seq_profile: Profile, + pub still_picture: bool, + pub reduced_still_picture_header: bool, + pub frame_width_bits_minus_1: u32, + pub frame_height_bits_minus_1: u32, + pub max_frame_width_minus_1: u32, + pub max_frame_height_minus_1: u32, + pub frame_id_numbers_present_flag: bool, + pub delta_frame_id_length_minus_2: u32, + pub additional_frame_id_length_minus_1: u32, + pub use_128x128_superblock: bool, + pub enable_filter_intra: bool, + pub enable_intra_edge_filter: bool, + pub enable_interintra_compound: bool, + pub enable_masked_compound: bool, + pub enable_warped_motion: bool, + pub enable_order_hint: bool, + pub enable_dual_filter: bool, + pub enable_jnt_comp: bool, + pub enable_ref_frame_mvs: bool, + pub seq_choose_screen_content_tools: bool, + pub seq_force_screen_content_tools: u32, + pub seq_choose_integer_mv: bool, + pub seq_force_integer_mv: u32, + pub order_hint_bits_minus_1: i32, + pub order_hint_bits: i32, + pub enable_superres: bool, + pub enable_cdef: bool, + pub enable_restoration: bool, + pub film_grain_params_present: bool, + pub operating_points_cnt_minus_1: u32, + pub operating_points: [OperatingPoint; MAX_NUM_OPERATING_POINTS], + pub decoder_model_info_present_flag: bool, + pub decoder_model_info: DecoderModelInfo, + pub initial_display_delay_present_flag: bool, + pub timing_info_present_flag: bool, + pub timing_info: TimingInfo, + pub color_config: ColorConfig, + + /* CamelCase */ + pub bit_depth: BitDepth, + pub num_planes: u32, +} + +#[derive(Clone, Debug, Default, PartialEq, Eq)] +pub struct TemporalDelimiterObu { + pub obu_header: ObuHeader, +} + +#[derive(N, Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord)] +pub enum InterpolationFilter { + #[default] + EightTap = 0, + EightTapSmooth = 1, + EightTapSharp = 2, + Bilinear = 3, + Switchable = 4, +} + +#[derive(N, Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord)] +pub enum TxModes { + #[default] + Only4x4 = 0, + Largest = 1, + Select = 2, +} + +#[derive(N, Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord)] +pub enum FrameRestorationType { + #[default] + None = 0, + Wiener = 1, + Sgrproj = 2, + Switchable = 3, +} + +#[derive(N, Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord)] +pub enum ReferenceFrameType { + #[default] + Intra = 0, + Last = 1, + Last2 = 2, + Last3 = 3, + Golden = 4, + BwdRef = 5, + AltRef2 = 6, + AltRef = 7, +} + +#[derive(N, Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord)] +pub enum WarpModelType { + #[default] + Identity = 0, + Translation = 1, + RotZoom = 2, + Affine = 3, +} + +#[derive(N, Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord)] +pub enum FrameType { + #[default] + KeyFrame = 0, + InterFrame = 1, + IntraOnlyFrame = 2, + SwitchFrame = 3, +} + +#[derive(N, Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord)] +pub enum TxMode { + #[default] + Only4x4 = 0, + Largest = 1, + Select = 2, +} + +#[derive(Clone, Debug, Default, PartialEq, Eq)] +pub struct FrameObu<'a> { + header: FrameHeaderObu, + tile: TileGroupObu<'a>, +} + +#[derive(Clone, Debug, Default, PartialEq, Eq)] +pub struct FrameHeaderObu { + /// The original OBU header. This may be from a FrameOBU or a FrameHeaderOBU + /// directly. + pub obu_header: ObuHeader, + pub show_existing_frame: bool, + pub frame_to_show_map_idx: u32, + pub frame_presentation_time: u32, + pub tu_presentation_delay: u32, + pub display_frame_id: u32, + pub frame_type: FrameType, + pub show_frame: bool, + pub showable_frame: bool, + pub error_resilient_mode: bool, + pub disable_cdf_update: bool, + pub allow_screen_content_tools: u32, + pub force_integer_mv: u32, + pub current_frame_id: u32, + pub frame_size_override_flag: bool, + pub order_hint: u32, + pub primary_ref_frame: u32, + pub buffer_removal_time_present_flag: bool, + pub buffer_removal_time: Vec, + pub refresh_frame_flags: u32, + pub ref_order_hint: [u32; NUM_REF_FRAMES], + pub allow_intrabc: bool, + pub frame_refs_short_signaling: bool, + pub last_frame_idx: u32, + pub gold_frame_idx: u32, + pub ref_frame_idx: [i32; REFS_PER_FRAME], + pub allow_high_precision_mv: bool, + pub is_motion_mode_switchable: bool, + pub use_ref_frame_mvs: bool, + pub disable_frame_end_update_cdf: bool, + pub allow_warped_motion: bool, + pub reduced_tx_set: bool, + pub render_and_frame_size_different: bool, + pub use_superres: bool, + pub is_filter_switchable: bool, + pub interpolation_filter: InterpolationFilter, + pub loop_filter_params: LoopFilterParams, + pub quantization_params: QuantizationParams, + pub segmentation_params: SegmentationParams, + pub tile_info: TileInfo, + pub cdef_params: CdefParams, + pub loop_restoration_params: LoopRestorationParams, + pub tx_mode_select: u32, + pub skip_mode_present: bool, + pub reference_select: bool, + pub global_motion_params: GlobalMotionParams, + pub film_grain_params: FilmGrainParams, + + /* CamelCase variables */ + pub superres_denom: u32, + pub frame_is_intra: bool, + pub order_hints: [u32; NUM_REF_FRAMES], + pub ref_frame_sign_bias: [bool; NUM_REF_FRAMES], + pub coded_lossless: bool, + pub all_lossless: bool, + pub lossless_array: [bool; MAX_SEGMENTS], + pub seg_qm_level: [[u32; MAX_SEGMENTS]; 3], + pub upscaled_width: u32, + pub frame_width: u32, + pub frame_height: u32, + pub render_width: u32, + pub render_height: u32, + pub tx_mode: TxMode, + pub skip_mode_frame: [u32; 2], + pub mi_cols: u32, + pub mi_rows: u32, + pub header_bytes: usize, +} + +#[derive(Clone, Debug, Default, PartialEq, Eq)] +pub struct LoopFilterParams { + pub loop_filter_level: [u32; 4], + pub loop_filter_sharpness: u32, + pub loop_filter_delta_enabled: bool, + pub loop_filter_delta_update: bool, + pub loop_filter_ref_deltas: [i32; TOTAL_REFS_PER_FRAME], + pub loop_filter_mode_deltas: [i32; 2], + pub delta_lf_present: bool, + pub delta_lf_res: u32, + pub delta_lf_multi: u32, +} + +#[derive(Clone, Debug, Default, PartialEq, Eq)] +pub struct QuantizationParams { + pub base_q_idx: u32, + pub diff_uv_delta: bool, + pub using_qmatrix: bool, + pub qm_y: u32, + pub qm_u: u32, + pub qm_v: u32, + pub delta_q_present: bool, + pub delta_q_res: u32, + pub delta_q_y_dc: i32, + pub delta_q_u_dc: i32, + pub delta_q_u_ac: i32, + pub delta_q_v_dc: i32, + pub delta_q_v_ac: i32, +} + +#[derive(Clone, Debug, Default, PartialEq, Eq)] +pub struct SegmentationParams { + pub segmentation_enabled: bool, + pub segmentation_update_map: bool, + pub segmentation_temporal_update: bool, + pub segmentation_update_data: bool, + pub feature_enabled: [[bool; SEG_LVL_MAX]; MAX_SEGMENTS], + pub feature_data: [[i16; SEG_LVL_MAX]; MAX_SEGMENTS], + pub seg_id_pre_skip: u32, + pub last_active_seg_id: u32, +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct TileInfo { + pub uniform_tile_spacing_flag: bool, + pub increment_tile_rows_log2: u32, + pub width_in_sbs_minus_1: [u32; MAX_TILE_COLS], + pub height_in_sbs_minus_1: [u32; MAX_TILE_ROWS], + pub tile_size_bytes_minus_1: u32, + pub context_update_tile_id: u32, + pub mi_col_starts: [u32; MAX_TILE_COLS + 1], + pub mi_row_starts: [u32; MAX_TILE_ROWS + 1], + pub tile_cols_log2: u32, + pub tile_cols: u32, + pub tile_rows_log2: u32, + pub tile_rows: u32, + pub tile_size_bytes: u32, +} + +impl Default for TileInfo { + fn default() -> Self { + Self { + uniform_tile_spacing_flag: Default::default(), + increment_tile_rows_log2: Default::default(), + width_in_sbs_minus_1: [0; MAX_TILE_COLS], + height_in_sbs_minus_1: [0; MAX_TILE_ROWS], + tile_size_bytes_minus_1: Default::default(), + context_update_tile_id: Default::default(), + mi_col_starts: [0; MAX_TILE_COLS + 1], + mi_row_starts: [0; MAX_TILE_ROWS + 1], + tile_cols_log2: Default::default(), + tile_cols: Default::default(), + tile_rows_log2: Default::default(), + tile_rows: Default::default(), + tile_size_bytes: Default::default(), + } + } +} + +#[derive(Clone, Debug, Default, PartialEq, Eq)] +pub struct CdefParams { + pub cdef_damping: u32, + pub cdef_bits: u32, + pub cdef_y_pri_strength: [u32; CDEF_MAX], + pub cdef_y_sec_strength: [u32; CDEF_MAX], + pub cdef_uv_pri_strength: [u32; CDEF_MAX], + pub cdef_uv_sec_strength: [u32; CDEF_MAX], +} + +#[derive(Clone, Debug, Default, PartialEq, Eq)] +pub struct LoopRestorationParams { + pub lr_unit_shift: u32, + pub lr_uv_shift: u32, + pub frame_restoration_type: [FrameRestorationType; MAX_NUM_PLANES], + pub loop_restoration_size: [u32; MAX_NUM_PLANES], + pub uses_lr: bool, + pub uses_chroma_lr: bool, +} + +#[derive(Clone, Debug, Default, PartialEq, Eq)] +pub struct GlobalMotionParams { + pub is_global: [bool; NUM_REF_FRAMES], + pub is_rot_zoom: [bool; NUM_REF_FRAMES], + pub is_translation: [bool; NUM_REF_FRAMES], + pub gm_params: [[i32; 6]; NUM_REF_FRAMES], + pub invalid: [bool; NUM_REF_FRAMES], + /// Same as GmType. + pub gm_type: [WarpModelType; NUM_REF_FRAMES], +} + +#[derive(Clone, Debug, Default, PartialEq, Eq)] +pub struct FilmGrainParams { + pub apply_grain: bool, + pub grain_seed: u32, + pub update_grain: bool, + pub film_grain_params_ref_idx: u32, + pub num_y_points: u32, + pub point_y_value: [u32; MAX_NUM_Y_POINTS], + pub point_y_scaling: [u32; MAX_NUM_Y_POINTS], + pub chroma_scaling_from_luma: bool, + pub num_cb_points: u32, + pub point_cb_value: [u32; MAX_NUM_CB_POINTS], + pub point_cb_scaling: [u32; MAX_NUM_CB_POINTS], + pub num_cr_points: u32, + pub point_cr_value: [u32; MAX_NUM_CR_POINTS], + pub point_cr_scaling: [u32; MAX_NUM_CR_POINTS], + pub grain_scaling_minus_8: u32, + pub ar_coeff_lag: u32, + pub ar_coeffs_y_plus_128: [u32; MAX_NUM_POS_LUMA], + pub ar_coeffs_cb_plus_128: [u32; MAX_NUM_POS_LUMA], + pub ar_coeffs_cr_plus_128: [u32; MAX_NUM_POS_LUMA], + pub ar_coeff_shift_minus_6: u32, + pub grain_scale_shift: u32, + pub cb_mult: u32, + pub cb_luma_mult: u32, + pub cb_offset: u32, + pub cr_mult: u32, + pub cr_luma_mult: u32, + pub cr_offset: u32, + pub overlap_flag: bool, + pub clip_to_restricted_range: bool, +} + +/// Keeps track of the state of the reference frames in the parser. All +/// variables are CamelCase. +#[derive(Clone, Debug, Default, PartialEq, Eq)] +struct ReferenceFrameInfo { + ref_valid: bool, + ref_frame_id: u32, + ref_upscaled_width: u32, + ref_frame_width: u32, + ref_frame_height: u32, + ref_render_width: u32, + ref_render_height: u32, + ref_mi_cols: u32, + ref_mi_rows: u32, + ref_frame_type: FrameType, + ref_subsampling_x: u32, + ref_subsampling_y: u32, + ref_bit_depth: u32, + ref_order_hint: u32, + segmentation_params: SegmentationParams, + global_motion_params: GlobalMotionParams, + loop_filter_params: LoopFilterParams, + film_grain_params: FilmGrainParams, + tile_info: TileInfo, +} + +#[derive(Debug, Default)] +pub struct AnnexBState { + pub temporal_unit_size: u32, + pub frame_unit_size: u32, + pub temporal_unit_consumed: u32, + pub frame_unit_consumed: u32, +} + +#[derive(Debug)] +enum StreamFormat { + LowOverhead, + AnnexB(AnnexBState), +} + +#[derive(Debug)] +pub struct Parser { + stream_format: StreamFormat, + operating_point: u32, + /// The last seen frame header, if any. Replaces "seen_frame_header" in the + /// specification. + last_frame_header: Option, + operating_point_idc: u32, + sequence_changed: bool, + should_probe_for_annexb: bool, + is_first_frame: bool, + ref_info: [ReferenceFrameInfo; NUM_REF_FRAMES], + + /* CamelCase variables */ + found_first_frame: bool, + upscaled_width: u32, + frame_width: u32, + frame_height: u32, + mi_cols: u32, + mi_rows: u32, + render_width: u32, + render_height: u32, + prev_frame_id: u32, + current_frame_id: u32, + mi_col_starts: [u32; MAX_TILE_COLS + 1], + mi_row_starts: [u32; MAX_TILE_ROWS + 1], + tile_cols_log2: u32, + tile_cols: u32, + tile_rows_log2: u32, + tile_rows: u32, + tile_size_bytes: u32, + + // We first read into these, then copy into the frame. Not sure whether it + // is strictly necessary, but it lets us implement setup_past_independence() + // in a similar fashion as the vp9 parser. + lf: LoopFilterParams, + seg: SegmentationParams, + + /// The last SequenceHeaderObu parsed. + pub sequence_header: Option>, +} + +impl Parser { + /// Probes the input data for the Annex B format. Anything other than + /// Ok(true) refers to data in "low-overhead" format instead, as we are trying to parse + fn annexb_probe(data: &[u8]) -> anyhow::Result { + let mut r = Reader::new(data); + let mut seen_sequence = false; + let mut seen_frame = false; + + // Try reading the first TU and frame unit size + let temporal_unit_size = r.read_leb128()?; + if temporal_unit_size == 0 { + return Ok(false); + } + + let frame_unit_size = r.read_leb128()?; + if frame_unit_size == 0 || frame_unit_size > temporal_unit_size { + return Ok(false); + } + + let obu_length = r.read_leb128()?; + if obu_length == 0 || obu_length > frame_unit_size { + return Ok(false); + } + + // The first OBU in the first frame_unit of each temporal_unit must + // be a temporal delimiter OBU (and this is the only place temporal + // delimiter OBUs can appear) + let header = Self::parse_obu_header(&mut r.clone())?; + if !matches!(header.obu_type, ObuType::TemporalDelimiter) { + return Ok(false); + } + + // Try identifying a sequence and a frame. + r.skip(u64::from(obu_length) * 8)?; + let mut num_bytes_read = 0; + + loop { + let obu_length = r.read_leb128()?; + let mut obu_reader = r.clone(); + + r.skip(u64::from(obu_length) * 8)?; + num_bytes_read += obu_length; + + if !seen_sequence { + let header = Self::parse_obu_header(&mut obu_reader)?; + seen_sequence = matches!(header.obu_type, ObuType::SequenceHeader); + } + + if !seen_frame { + let header = Self::parse_obu_header(&mut obu_reader)?; + seen_frame = matches!(header.obu_type, ObuType::Frame | ObuType::FrameHeader); + } + + if seen_sequence && seen_frame { + // OK, enough evidence of Annex B format. + return Ok(true); + } + + if num_bytes_read >= frame_unit_size { + // We read what we've identified as the first frame and yet no + // sequence and no actual frames were found. + return Ok(false); + } + } + } + + fn compute_image_size(&mut self, fh: &mut FrameHeaderObu) -> anyhow::Result<()> { + fh.mi_cols = 2 * ((fh.frame_width + 7) >> 3); + fh.mi_rows = 2 * ((fh.frame_height + 7) >> 3); + self.mi_cols = fh.mi_cols; + self.mi_rows = fh.mi_rows; + Ok(()) + } + + // 5.9.8 + fn parse_superres_params( + fh: &mut FrameHeaderObu, + r: &mut Reader, + seq: &SequenceHeaderObu, + ) -> anyhow::Result<()> { + if seq.enable_superres { + fh.use_superres = r.read_bit()?; + } else { + fh.use_superres = false; + } + + if fh.use_superres { + fh.superres_denom = r.read_bits(SUPERRES_DENOM_BITS as u8)? + SUPERRES_DENOM_MIN as u32; + } else { + fh.superres_denom = SUPERRES_NUM as u32; + } + + fh.upscaled_width = fh.frame_width; + fh.frame_width = + (fh.upscaled_width * SUPERRES_NUM as u32 + (fh.superres_denom / 2)) / fh.superres_denom; + + Ok(()) + } + + // 7.8 verbatim. + fn set_frame_refs( + &self, + fh: &mut FrameHeaderObu, + ref_order_hint: &[u32; NUM_REF_FRAMES], + ) -> anyhow::Result<()> { + let seq = self.sequence()?; + let mut ref_frame_idx = [-1; REFS_PER_FRAME]; + + ref_frame_idx[0] = fh.last_frame_idx.try_into().unwrap(); + ref_frame_idx[ReferenceFrameType::Golden as usize - ReferenceFrameType::Last as usize] = + fh.gold_frame_idx.try_into().unwrap(); + + let mut used_frame = [false; NUM_REF_FRAMES]; + used_frame[fh.last_frame_idx as usize] = true; + used_frame[fh.gold_frame_idx as usize] = true; + + let cur_frame_hint = 1 << (seq.order_hint_bits - 1); + let mut shifted_order_hints = [0; NUM_REF_FRAMES]; + for i in 0..NUM_REF_FRAMES { + shifted_order_hints[i] = cur_frame_hint + + helpers::get_relative_dist( + seq.enable_order_hint, + seq.order_hint_bits, + ref_order_hint[i].try_into().unwrap(), + fh.order_hint.try_into().unwrap(), + ); + } + + let mut latest_order_hint = shifted_order_hints[fh.last_frame_idx as usize]; + if latest_order_hint >= cur_frame_hint { + return Err(anyhow!("It is a requirement of bitstream conformance that last_order_hint < cur_frame_hint")); + } + + let mut earliest_order_hint = shifted_order_hints[fh.gold_frame_idx as usize]; + if earliest_order_hint >= cur_frame_hint { + return Err(anyhow!("It is a requirement of bitstream conformance that gold_order_hint < cur_frame_hint")); + } + + let ref_ = helpers::find_latest_backward( + &shifted_order_hints, + &used_frame, + cur_frame_hint, + &mut latest_order_hint, + ); + + if ref_ >= 0 { + ref_frame_idx + [ReferenceFrameType::AltRef as usize - ReferenceFrameType::Last as usize] = ref_; + used_frame[ref_ as usize] = true; + } + + let ref_ = helpers::find_earliest_backward( + &shifted_order_hints, + &used_frame, + cur_frame_hint, + &mut earliest_order_hint, + ); + + if ref_ >= 0 { + ref_frame_idx + [ReferenceFrameType::BwdRef as usize - ReferenceFrameType::Last as usize] = ref_; + used_frame[ref_ as usize] = true; + } + + let ref_ = helpers::find_earliest_backward( + &shifted_order_hints, + &used_frame, + cur_frame_hint, + &mut earliest_order_hint, + ); + + if ref_ >= 0 { + ref_frame_idx + [ReferenceFrameType::AltRef2 as usize - ReferenceFrameType::Last as usize] = ref_; + used_frame[ref_ as usize] = true; + } + + let ref_frame_list = [ + ReferenceFrameType::Last2 as usize, + ReferenceFrameType::Last3 as usize, + ReferenceFrameType::BwdRef as usize, + ReferenceFrameType::AltRef2 as usize, + ReferenceFrameType::AltRef as usize, + ]; + + #[allow(clippy::needless_range_loop)] + for i in 0..REFS_PER_FRAME - 2 { + let ref_frame = ref_frame_list[i]; + + if ref_frame_idx[ref_frame - ReferenceFrameType::Last as usize] < 0 { + let ref_ = helpers::find_latest_forward( + &shifted_order_hints, + &used_frame, + cur_frame_hint, + &mut latest_order_hint, + ); + + if ref_ >= 0 { + ref_frame_idx[ref_frame - ReferenceFrameType::Last as usize] = ref_; + used_frame[ref_ as usize] = true; + } + } + } + + let mut ref_ = -1; + #[allow(clippy::needless_range_loop)] + for i in 0..NUM_REF_FRAMES { + let hint = shifted_order_hints[i]; + if ref_ < 0 || hint < earliest_order_hint { + ref_ = i as i32; + earliest_order_hint = hint; + } + } + + #[allow(clippy::needless_range_loop)] + for i in 0..REFS_PER_FRAME { + if ref_frame_idx[i] < 0 { + ref_frame_idx[i] = ref_; + } + } + + Ok(()) + } + + // 5.9.5. + fn parse_frame_size(&mut self, fh: &mut FrameHeaderObu, r: &mut Reader) -> anyhow::Result<()> { + let seq = self.sequence()?; + if fh.frame_size_override_flag { + let n = seq.frame_width_bits_minus_1 + 1; + fh.frame_width = r.read_bits(n.try_into().unwrap())? + 1; + + let n = seq.frame_height_bits_minus_1 + 1; + fh.frame_height = r.read_bits(n.try_into().unwrap())? + 1; + } else { + fh.frame_width = seq.max_frame_width_minus_1 + 1; + fh.frame_height = seq.max_frame_height_minus_1 + 1; + } + + Self::parse_superres_params(fh, r, seq)?; + self.compute_image_size(fh)?; + + Ok(()) + } + + fn parse_render_size(fh: &mut FrameHeaderObu, r: &mut Reader) -> anyhow::Result<()> { + fh.render_and_frame_size_different = r.read_bit()?; + if fh.render_and_frame_size_different { + fh.render_width = r.read_bits(16)? + 1; + fh.render_height = r.read_bits(16)? + 1; + } else { + fh.render_width = fh.upscaled_width; + fh.render_height = fh.frame_height; + } + Ok(()) + } + + fn frame_size_with_refs( + &mut self, + fh: &mut FrameHeaderObu, + r: &mut Reader, + ) -> anyhow::Result<()> { + let mut found_ref = false; + let seq = self.sequence()?; + + for i in 0..REFS_PER_FRAME { + found_ref = r.read_bit()?; + + if found_ref { + let rf = &self.ref_info[i]; + fh.upscaled_width = rf.ref_upscaled_width; + fh.frame_width = fh.upscaled_width; + fh.frame_height = rf.ref_frame_height; + fh.render_width = rf.ref_render_width; + fh.render_height = rf.ref_render_height; + break; + } + } + + if !found_ref { + self.parse_frame_size(fh, r)?; + Self::parse_render_size(fh, r)?; + } else { + Self::parse_superres_params(fh, r, seq)?; + self.compute_image_size(fh)?; + } + + Ok(()) + } + + /// Skip the padding bits, ensuring that they actually make sense. + fn skip_and_check_trailing_bits(r: &mut Reader, obu: &Obu) -> anyhow::Result<()> { + // We can't have that in parse_obu as per the spec, because the reader + // is not initialized on our design at that point, so move the check to + // inside this function. + if obu.size == 0 + || matches!( + obu.header.obu_type, + ObuType::TileList | ObuType::TileGroup | ObuType::Frame + ) + { + return Ok(()); + } + let num_trailing = obu.as_ref().len() as u64 * 8 - r.position(); + r.read_trailing_bits(num_trailing)?; + Ok(()) + } + + fn parse_obu_header(r: &mut Reader) -> anyhow::Result { + let _obu_forbidden_bit = r.read_bit()?; + + let mut header = ObuHeader { + obu_type: ObuType::n(r.read_bits(4)?).ok_or(anyhow!("Invalid OBU type"))?, + extension_flag: r.read_bit()?, + has_size_field: r.read_bit()?, + temporal_id: Default::default(), + spatial_id: Default::default(), + }; + + let obu_reserved_1bit = r.read_bit()?; + assert!(!obu_reserved_1bit); // Must be set to zero as per spec. + + if header.extension_flag { + header.temporal_id = r.read_bits(3)?; + header.spatial_id = r.read_bits(2)?; + let _ = r.read_bits(3)?; + } + + Ok(header) + } + + /// Parses one OBU from `data`, which can be in Annex B or low-overhead + /// format. + pub fn parse_obu<'a>(&mut self, data: &'a [u8]) -> anyhow::Result>> { + if data.is_empty() { + return Ok(None); + } + + let mut reader = Reader::new(data); + + if self.should_probe_for_annexb { + // Try probing for Annex B data. + self.stream_format = if matches!(Self::annexb_probe(data), Ok(true)) { + log::debug!("Parsing an Annex B stream"); + StreamFormat::AnnexB(AnnexBState::default()) + } else { + log::debug!("Parsing a low-overhead stream"); + StreamFormat::LowOverhead + }; + + self.should_probe_for_annexb = false; + } + + let obu_length = if let StreamFormat::AnnexB(annexb_state) = &mut self.stream_format { + // Read the length to skip to the start of the open_bitstream_unit() + // syntax element. + let obu_length = reader.current_annexb_obu_length(annexb_state)?; + match obu_length { + Some(length) => length, + None => return Ok(None), + } + } else { + 0 + }; + + let start_pos = reader.consumed(0); + + // Both "low-overhead" and Annex B are now at the same point, i.e.: a + // open_bitstream_unit() follows. + let header = Self::parse_obu_header(&mut reader)?; + if matches!(self.stream_format, StreamFormat::LowOverhead) { + assert!(header.has_size_field); + } + + let obu_size = if header.has_size_field { + reader.read_leb128()? as usize + } else { + /* trap any bugs when computing the final length */ + obu_length + .checked_sub(1) + .unwrap() + .checked_sub(header.extension_flag as usize) + .unwrap() + }; + + let consumed = reader.consumed(start_pos); + + if let StreamFormat::AnnexB(annexb_state) = &mut self.stream_format { + annexb_state.temporal_unit_consumed += consumed; + annexb_state.frame_unit_consumed += consumed; + + annexb_state.temporal_unit_consumed += u32::try_from(obu_size).unwrap(); + annexb_state.frame_unit_consumed += u32::try_from(obu_size).unwrap(); + } + + assert!(reader.position() % 8 == 0); + let start_offset: usize = (reader.position() / 8).try_into().unwrap(); + + log::debug!( + "Identified OBU type {:?}, data size: {}, obu_size: {}", + header.obu_type, + start_offset + obu_size, + obu_size + ); + + Ok(Some(Obu { + header, + data: Cow::from(&data[..start_offset + obu_size]), + start_offset, + size: obu_size, + })) + } + + fn parse_color_config(s: &mut SequenceHeaderObu, r: &mut Reader) -> anyhow::Result<()> { + let cc = &mut s.color_config; + + cc.high_bitdepth = r.read_bit()?; + if s.seq_profile as u32 == 2 && cc.high_bitdepth { + cc.twelve_bit = r.read_bit()?; + if cc.twelve_bit { + s.bit_depth = BitDepth::Depth12; + } else { + s.bit_depth = BitDepth::Depth10; + } + } else if s.seq_profile as u32 <= 2 { + s.bit_depth = if cc.high_bitdepth { + BitDepth::Depth10 + } else { + BitDepth::Depth8 + }; + } + + if s.seq_profile as u32 == 1 { + cc.mono_chrome = false; + } else { + cc.mono_chrome = r.read_bit()?; + } + + if cc.mono_chrome { + s.num_planes = 1; + } else { + s.num_planes = 3; + } + + cc.color_description_present_flag = r.read_bit()?; + if cc.color_description_present_flag { + cc.color_primaries = + ColorPrimaries::n(r.read_bits(8)?).ok_or(anyhow!("Invalid color_primaries"))?; + cc.transfer_characteristics = TransferCharacteristics::n(r.read_bits(8)?) + .ok_or(anyhow!("Invalid transfer_characteristics"))?; + cc.matrix_coefficients = MatrixCoefficients::n(r.read_bits(8)?) + .ok_or(anyhow!("Invalid matrix_coefficients"))?; + } else { + cc.color_primaries = ColorPrimaries::Unspecified; + cc.transfer_characteristics = TransferCharacteristics::Unspecified; + cc.matrix_coefficients = MatrixCoefficients::Unspecified; + } + + if cc.mono_chrome { + cc.color_range = r.read_bit()?; + cc.subsampling_x = true; + cc.subsampling_y = true; + cc.chroma_sample_position = ChromaSamplePosition::Unknown; + cc.separate_uv_delta_q = false; + return Ok(()); + } else if matches!(cc.color_primaries, ColorPrimaries::Bt709) + && matches!(cc.transfer_characteristics, TransferCharacteristics::Srgb) + && matches!(cc.matrix_coefficients, MatrixCoefficients::Identity) + { + cc.color_range = true; + cc.subsampling_x = false; + cc.subsampling_y = false; + } else { + cc.color_range = r.read_bit()?; + if s.seq_profile as u32 == 0 { + cc.subsampling_x = true; + cc.subsampling_y = true; + } else if s.seq_profile as u32 == 1 { + cc.subsampling_x = false; + cc.subsampling_y = false; + } else if matches!(s.bit_depth, BitDepth::Depth12) { + cc.subsampling_x = r.read_bit()?; + if cc.subsampling_x { + cc.subsampling_y = r.read_bit()?; + } else { + cc.subsampling_y = false; + } + } else { + cc.subsampling_x = true; + cc.subsampling_y = false; + } + + if cc.subsampling_x && cc.subsampling_y { + cc.chroma_sample_position = ChromaSamplePosition::n(r.read_bits(2)?) + .ok_or(anyhow!("Invalid chroma_sample_position"))?; + } + } + + cc.separate_uv_delta_q = r.read_bit()?; + + Ok(()) + } + + fn parse_operating_parameters_info( + opi: &mut OperatingPoint, + r: &mut Reader, + buffer_delay_length_minus_1: u32, + ) -> anyhow::Result<()> { + let n = u8::try_from(buffer_delay_length_minus_1 + 1).unwrap(); + opi.decoder_buffer_delay = r.read_bits(n)?; + opi.encoder_buffer_delay = r.read_bits(n)?; + opi.low_delay_mode_flag = r.read_bit()?; + Ok(()) + } + + fn parse_decoder_model_info(dmi: &mut DecoderModelInfo, r: &mut Reader) -> anyhow::Result<()> { + dmi.buffer_delay_length_minus_1 = r.read_bits(5)?; + dmi.num_units_in_decoding_tick = r.read_bits(32)?; + dmi.buffer_removal_time_length_minus_1 = r.read_bits(5)?; + dmi.frame_presentation_time_length_minus_1 = r.read_bits(5)?; + Ok(()) + } + + fn parse_timing_info(ti: &mut TimingInfo, r: &mut Reader) -> anyhow::Result<()> { + ti.num_units_in_display_tick = r.read_bits(32)?; + ti.time_scale = r.read_bits(32)?; + ti.equal_picture_interval = r.read_bit()?; + if ti.equal_picture_interval { + ti.num_ticks_per_picture_minus_1 = r.read_ulvc()?; + } + Ok(()) + } + + /// Selects an operating point. Only call this after the Sequence OBU for + /// which the operating point should apply has been parsed. + pub fn choose_operating_point(&mut self, operating_point: u32) -> anyhow::Result<()> { + if operating_point > self.sequence()?.operating_points_cnt_minus_1 { + return Err(anyhow!( + "Invalid operating point {} (max {})", + operating_point, + self.sequence()?.operating_points_cnt_minus_1 + )); + } + self.operating_point = operating_point; + self.operating_point_idc = self.sequence()?.operating_points[operating_point as usize].idc; + Ok(()) + } + + pub fn parse_sequence_header_obu( + &mut self, + obu: &Obu, + ) -> anyhow::Result> { + if !matches!(obu.header.obu_type, ObuType::SequenceHeader) { + return Err(anyhow!( + "Expected a SequenceHeaderOBU, got {:?}", + obu.header.obu_type + )); + } + + let mut s = SequenceHeaderObu { + obu_header: obu.header.clone(), + ..Default::default() + }; + + let mut r = Reader::new(obu.as_ref()); + let profile = r.read_bits(3)?; + + s.seq_profile = Profile::n(profile).ok_or(anyhow!("Invalid profile {}", profile))?; + s.still_picture = r.read_bit()?; + s.reduced_still_picture_header = r.read_bit()?; + + if s.reduced_still_picture_header { + /* Default::default() already ensures a lot of this, but lets go verbatim */ + s.timing_info_present_flag = false; + s.decoder_model_info_present_flag = false; + s.initial_display_delay_present_flag = false; + s.operating_points_cnt_minus_1 = 0; + s.operating_points[0].idc = 0; + s.operating_points[0].seq_level_idx = r.read_bits(5)?; + s.operating_points[0].seq_tier = 0; + s.operating_points[0].decoder_model_present_for_this_op = false; + s.operating_points[0].initial_display_delay_present_for_this_op = false; + } else { + s.timing_info_present_flag = r.read_bit()?; + if s.timing_info_present_flag { + Self::parse_timing_info(&mut s.timing_info, &mut r)?; + s.decoder_model_info_present_flag = r.read_bit()?; + if s.decoder_model_info_present_flag { + Self::parse_decoder_model_info(&mut s.decoder_model_info, &mut r)?; + } + } else { + s.decoder_model_info_present_flag = false; + } + + s.initial_display_delay_present_flag = r.read_bit()?; + s.operating_points_cnt_minus_1 = r.read_bits(5)?; + if s.operating_points_cnt_minus_1 > MAX_NUM_OPERATING_POINTS as u32 { + return Err(anyhow!( + "Invalid operating_points_cnt_minus_1 {}", + s.operating_points_cnt_minus_1 + )); + } + + for i in 0..=s.operating_points_cnt_minus_1 as usize { + s.operating_points[i].idc = r.read_bits(12)?; + s.operating_points[i].seq_level_idx = r.read_bits(5)?; + if s.operating_points[i].seq_level_idx > 7 { + s.operating_points[i].seq_tier = u32::from(r.read_bit()?); + } else { + s.operating_points[i].seq_tier = 0; + } + if s.decoder_model_info_present_flag { + s.operating_points[i].decoder_model_present_for_this_op = r.read_bit()?; + if s.operating_points[i].decoder_model_present_for_this_op { + let buffer_delay_length_minus_1 = + s.decoder_model_info.buffer_delay_length_minus_1; + Self::parse_operating_parameters_info( + &mut s.operating_points[i], + &mut r, + buffer_delay_length_minus_1, + )?; + } + } else { + s.operating_points[i].decoder_model_present_for_this_op = false; + } + + if s.initial_display_delay_present_flag { + s.operating_points[i].initial_display_delay_present_for_this_op = + r.read_bit()?; + if s.operating_points[i].initial_display_delay_present_for_this_op { + s.operating_points[i].initial_display_delay_minus_1 = r.read_bits(4)?; + } + } + } + } + + /* Client is supposed to set the operating point */ + + s.frame_width_bits_minus_1 = r.read_bits(4)?; + s.frame_height_bits_minus_1 = r.read_bits(4)?; + s.max_frame_width_minus_1 = r.read_bits(s.frame_width_bits_minus_1 as u8 + 1)?; + s.max_frame_height_minus_1 = r.read_bits(s.frame_height_bits_minus_1 as u8 + 1)?; + if s.reduced_still_picture_header { + s.frame_id_numbers_present_flag = false; + } else { + s.frame_id_numbers_present_flag = r.read_bit()?; + } + if s.frame_id_numbers_present_flag { + s.delta_frame_id_length_minus_2 = r.read_bits(4)?; + s.additional_frame_id_length_minus_1 = r.read_bits(3)?; + let frame_id_length = + s.additional_frame_id_length_minus_1 + s.delta_frame_id_length_minus_2 + 3; + if frame_id_length > 16 { + return Err(anyhow!("Invalid frame_id_length {}", frame_id_length)); + } + } + + s.use_128x128_superblock = r.read_bit()?; + s.enable_filter_intra = r.read_bit()?; + s.enable_intra_edge_filter = r.read_bit()?; + if s.reduced_still_picture_header { + s.enable_interintra_compound = false; + s.enable_masked_compound = false; + s.enable_warped_motion = false; + s.enable_dual_filter = false; + s.enable_order_hint = false; + s.enable_jnt_comp = false; + s.enable_ref_frame_mvs = false; + s.seq_force_screen_content_tools = SELECT_SCREEN_CONTENT_TOOLS as _; + s.seq_force_integer_mv = SELECT_INTEGER_MV as _; + s.order_hint_bits = 0; + s.order_hint_bits_minus_1 = -1; + } else { + s.enable_interintra_compound = r.read_bit()?; + s.enable_masked_compound = r.read_bit()?; + s.enable_warped_motion = r.read_bit()?; + s.enable_dual_filter = r.read_bit()?; + s.enable_order_hint = r.read_bit()?; + if s.enable_order_hint { + s.enable_jnt_comp = r.read_bit()?; + s.enable_ref_frame_mvs = r.read_bit()?; + } else { + s.enable_jnt_comp = false; + s.enable_ref_frame_mvs = false; + } + s.seq_choose_screen_content_tools = r.read_bit()?; + if s.seq_choose_screen_content_tools { + s.seq_force_screen_content_tools = SELECT_SCREEN_CONTENT_TOOLS as _; + } else { + s.seq_force_screen_content_tools = r.read_bit()? as _; + } + if s.seq_force_screen_content_tools > 0 { + s.seq_choose_integer_mv = r.read_bit()?; + if s.seq_choose_integer_mv { + s.seq_force_integer_mv = SELECT_INTEGER_MV as _; + } else { + s.seq_force_integer_mv = r.read_bit()? as _; + } + } else { + s.seq_force_integer_mv = SELECT_INTEGER_MV as _; + } + + if s.enable_order_hint { + s.order_hint_bits_minus_1 = r.read_bits(3)?.try_into().unwrap(); + s.order_hint_bits = s.order_hint_bits_minus_1 + 1; + } else { + s.order_hint_bits_minus_1 = -1; + s.order_hint_bits = 0; + } + } + + s.enable_superres = r.read_bit()?; + s.enable_cdef = r.read_bit()?; + s.enable_restoration = r.read_bit()?; + + Self::parse_color_config(&mut s, &mut r)?; + + s.film_grain_params_present = r.read_bit()?; + + Self::skip_and_check_trailing_bits(&mut r, obu)?; + let rc = Rc::new(s); + self.sequence_header = Some(rc.clone()); + + Ok(rc) + } + + /// Implements 7.21. Note that 7.20 will use the information from the + /// header, so we must save them now, as they will not be parsed from the + /// bitstream. We also save some internal parser state which will be useful + /// later. + fn load_reference_frame(&mut self, fh: &mut FrameHeaderObu) -> anyhow::Result<()> { + let rf = &self.ref_info[fh.ref_frame_idx[0] as usize]; + + // Section 6.8.1: It is a requirement of bitstream conformance that a + // sequence header OBU has been received before a frame header OBU. + let Some(seq) = self.sequence_header.as_ref() else { + return Err(anyhow!("No sequence header parsed yet")) + }; + + /* at least save the sizes and for both kf and non-kf */ + fh.frame_type = rf.ref_frame_type; + fh.upscaled_width = rf.ref_upscaled_width; + fh.frame_width = rf.ref_frame_width; + fh.frame_height = rf.ref_frame_height; + fh.render_width = rf.ref_render_width; + fh.render_height = rf.ref_render_height; + + /* Save into the frame header */ + if fh.frame_type == FrameType::KeyFrame { + fh.current_frame_id = rf.ref_frame_id; + /* We don't keep track of sequence information at the frame level */ + fh.mi_cols = rf.ref_mi_cols; + fh.mi_rows = rf.ref_mi_rows; + /* The accelerator is keeping track of CDF values, so that is skipped too */ + fh.global_motion_params = rf.global_motion_params.clone(); + + if seq.film_grain_params_present { + fh.film_grain_params = rf.film_grain_params.clone(); + } + fh.loop_filter_params = rf.loop_filter_params.clone(); + fh.segmentation_params = rf.segmentation_params.clone(); + } + + Ok(()) + } + + fn setup_past_independence(fh: &mut FrameHeaderObu) { + fh.segmentation_params.feature_enabled = Default::default(); + fh.segmentation_params.feature_data = Default::default(); + + for i in ReferenceFrameType::Last as usize..ReferenceFrameType::AltRef as usize { + fh.global_motion_params.gm_type[i] = WarpModelType::Identity; + } + + fh.loop_filter_params.loop_filter_delta_enabled = true; + fh.loop_filter_params.loop_filter_ref_deltas[ReferenceFrameType::Intra as usize] = 1; + fh.loop_filter_params.loop_filter_ref_deltas[ReferenceFrameType::Last as usize] = 0; + fh.loop_filter_params.loop_filter_ref_deltas[ReferenceFrameType::Last2 as usize] = 0; + fh.loop_filter_params.loop_filter_ref_deltas[ReferenceFrameType::Last3 as usize] = 0; + fh.loop_filter_params.loop_filter_ref_deltas[ReferenceFrameType::BwdRef as usize] = 0; + fh.loop_filter_params.loop_filter_ref_deltas[ReferenceFrameType::Golden as usize] = -1; + fh.loop_filter_params.loop_filter_ref_deltas[ReferenceFrameType::AltRef as usize] = -1; + fh.loop_filter_params.loop_filter_ref_deltas[ReferenceFrameType::AltRef2 as usize] = -1; + + fh.loop_filter_params.loop_filter_mode_deltas = Default::default(); + } + + fn parse_tile_info(&mut self, r: &mut Reader, ti: &mut TileInfo) -> anyhow::Result<()> { + let seq = self.sequence()?; + + let sb_cols = if seq.use_128x128_superblock { + (self.mi_cols + 31) >> 5 + } else { + (self.mi_cols + 15) >> 4 + }; + + let sb_rows = if seq.use_128x128_superblock { + (self.mi_rows + 31) >> 5 + } else { + (self.mi_rows + 15) >> 4 + }; + + let sb_shift = if seq.use_128x128_superblock { 5 } else { 4 }; + let sb_size = sb_shift + 2; + + let max_tile_width_sb = MAX_TILE_WIDTH >> sb_size; + let mut max_tile_area_sb = MAX_TILE_AREA >> (2 * sb_size); + + let min_log2_tile_cols = helpers::tile_log2(max_tile_width_sb, sb_cols); + + let max_log2_tile_cols = + helpers::tile_log2(1, std::cmp::min(sb_cols, MAX_TILE_COLS as u32)); + + let max_log2_tile_rows = + helpers::tile_log2(1, std::cmp::min(sb_rows, MAX_TILE_ROWS as u32)); + + let min_log2_tiles = std::cmp::max( + min_log2_tile_cols, + helpers::tile_log2(max_tile_area_sb, sb_rows * sb_cols), + ); + + ti.uniform_tile_spacing_flag = r.read_bit()?; + + if ti.uniform_tile_spacing_flag { + self.tile_cols_log2 = min_log2_tile_cols; + while self.tile_cols_log2 < max_log2_tile_cols { + let increment_tile_cols_log_2 = r.read_bit()?; + if increment_tile_cols_log_2 { + self.tile_cols_log2 += 1; + } else { + break; + } + } + + let tile_width_sb = (sb_cols + (1 << self.tile_cols_log2) - 1) >> self.tile_cols_log2; + + let mut i = 0; + let mut start_sb = 0; + + while start_sb < sb_cols { + self.mi_col_starts[i] = start_sb << sb_shift; + i += 1; + start_sb += tile_width_sb; + } + + self.mi_col_starts[i] = self.mi_cols; + self.tile_cols = i as _; + + let min_log2_tile_rows = std::cmp::max(min_log2_tiles - self.tile_cols_log2, 0); + self.tile_rows_log2 = min_log2_tile_rows; + + while self.tile_rows_log2 < max_log2_tile_rows { + let increment_tile_rows_log_2 = r.read_bit()?; + + if increment_tile_rows_log_2 { + self.tile_rows_log2 += 1; + } else { + break; + } + } + + let tile_height_sb = (sb_rows + (1 << self.tile_rows_log2) - 1) >> self.tile_rows_log2; + + let mut i = 0; + let mut start_sb = 0; + + while start_sb < sb_rows { + self.mi_row_starts[i] = start_sb << sb_shift; + i += 1; + start_sb += tile_height_sb; + } + + self.mi_row_starts[i] = self.mi_rows; + self.tile_rows = i as _; + } else { + let mut widest_tile_sb = 0; + let mut start_sb = 0; + let mut i = 0; + + while start_sb < sb_cols { + self.mi_col_starts[i] = start_sb << sb_shift; + + let max_width = std::cmp::min(sb_cols - start_sb, max_tile_width_sb); + ti.width_in_sbs_minus_1[i] = r.read_ns(max_width.try_into().unwrap())?; + + let size_sb = ti.width_in_sbs_minus_1[i] + 1; + widest_tile_sb = std::cmp::max(size_sb, widest_tile_sb); + + start_sb += size_sb; + i += 1; + } + + self.mi_col_starts[i] = self.mi_cols; + self.tile_cols = i as _; + self.tile_cols_log2 = helpers::tile_log2(1, self.tile_cols); + + if min_log2_tiles > 0 { + max_tile_area_sb = (sb_rows * sb_cols) >> (min_log2_tiles + 1); + } else { + max_tile_area_sb = sb_rows * sb_cols; + } + + let max_tile_height_sb = std::cmp::max(max_tile_area_sb / widest_tile_sb, 1); + let mut start_sb = 0; + let mut i = 0; + while start_sb < sb_rows { + self.mi_row_starts[i] = start_sb << sb_shift; + let max_height = std::cmp::min(sb_rows - start_sb, max_tile_height_sb); + ti.height_in_sbs_minus_1[i] = r.read_ns(max_height.try_into().unwrap())?; + + let size_sb = ti.height_in_sbs_minus_1[i] + 1; + start_sb += size_sb; + i += 1; + } + + self.mi_row_starts[i] = self.mi_rows; + self.tile_rows = i as _; + self.tile_rows_log2 = helpers::tile_log2(1, self.tile_rows); + } + + if self.tile_cols_log2 > 0 || self.tile_rows_log2 > 0 { + let num_bits = (self.tile_rows_log2 + self.tile_cols_log2) + .try_into() + .unwrap(); + ti.context_update_tile_id = r.read_bits(num_bits)?; + ti.tile_size_bytes_minus_1 = r.read_bits(2)?; + self.tile_size_bytes = ti.tile_size_bytes_minus_1 + 1; + } else { + ti.context_update_tile_id = 0; + } + + Ok(()) + } + + fn parse_quantization_params( + r: &mut Reader, + q: &mut QuantizationParams, + num_planes: u32, + separate_uv_delta_q: bool, + ) -> anyhow::Result<()> { + q.base_q_idx = r.read_bits(8)?; + q.delta_q_y_dc = r.read_delta_q()?; + if num_planes > 1 { + if separate_uv_delta_q { + q.diff_uv_delta = r.read_bit()?; + } else { + q.diff_uv_delta = false; + } + + q.delta_q_u_dc = r.read_delta_q()?; + q.delta_q_u_ac = r.read_delta_q()?; + if q.diff_uv_delta { + q.delta_q_v_dc = r.read_delta_q()?; + q.delta_q_v_ac = r.read_delta_q()?; + } else { + q.delta_q_v_dc = q.delta_q_u_dc; + q.delta_q_v_ac = q.delta_q_u_ac; + } + } else { + q.delta_q_u_dc = 0; + q.delta_q_u_ac = 0; + q.delta_q_v_dc = 0; + q.delta_q_v_ac = 0; + } + + q.using_qmatrix = r.read_bit()?; + if q.using_qmatrix { + q.qm_y = r.read_bits(4)?; + q.qm_u = r.read_bits(4)?; + if !separate_uv_delta_q { + q.qm_v = q.qm_u; + } else { + q.qm_v = r.read_bits(4)?; + } + } + Ok(()) + } + + fn parse_delta_q_params(r: &mut Reader, q: &mut QuantizationParams) -> anyhow::Result<()> { + q.delta_q_res = 0; + q.delta_q_present = false; + if q.base_q_idx > 0 { + q.delta_q_present = r.read_bit()?; + } + if q.delta_q_present { + q.delta_q_res = r.read_bits(2)?; + } + + Ok(()) + } + + fn parse_delta_lf_params( + r: &mut Reader, + lf: &mut LoopFilterParams, + delta_q_present: bool, + allow_intrabc: bool, + ) -> anyhow::Result<()> { + lf.delta_lf_present = false; + lf.delta_lf_res = 0; + lf.delta_lf_multi = 0; + if delta_q_present { + if !allow_intrabc { + lf.delta_lf_present = r.read_bit()?; + } + if lf.delta_lf_present { + lf.delta_lf_res = r.read_bits(2)?; + lf.delta_lf_multi = r.read_bits(1)?; + } + } + Ok(()) + } + + fn parse_segmentation_params( + &mut self, + r: &mut Reader, + s: &mut SegmentationParams, + primary_ref_frame: u32, + ) -> anyhow::Result<()> { + const FEATURE_BITS: [u8; SEG_LVL_MAX] = [8, 6, 6, 6, 6, 3, 0, 0]; + const FEATURE_SIGNED: [bool; SEG_LVL_MAX] = + [true, true, true, true, true, false, false, false]; + const FEATURE_MAX: [i32; SEG_LVL_MAX] = [255, 63, 63, 63, 63, 7, 0, 0]; + s.segmentation_enabled = r.read_bit()?; + if s.segmentation_enabled { + if primary_ref_frame == PRIMARY_REF_NONE { + s.segmentation_update_map = true; + s.segmentation_temporal_update = false; + s.segmentation_update_data = true; + } else { + s.segmentation_update_map = r.read_bit()?; + if s.segmentation_update_map { + s.segmentation_temporal_update = r.read_bit()?; + } + s.segmentation_update_data = r.read_bit()?; + } + if s.segmentation_update_data { + for i in 0..MAX_SEGMENTS { + for j in 0..SEG_LVL_MAX { + let feature_enabled = r.read_bit()?; + s.feature_enabled[i][j] = feature_enabled; + if feature_enabled { + let bits_to_read = FEATURE_BITS[j]; + let limit = FEATURE_MAX[j]; + let signed = FEATURE_SIGNED[j]; + + if signed { + let feature_value = r.read_su(1 + bits_to_read)?; + let clipped_value = helpers::clip3(-limit, limit, feature_value); + s.feature_data[i][j] = clipped_value as _; + } else { + let feature_value = r.read_su(bits_to_read)?; + let clipped_value = helpers::clip3(0, limit, feature_value); + s.feature_data[i][j] = clipped_value as _; + } + } + } + } + } else { + for i in 0..MAX_SEGMENTS { + for j in 0..SEG_LVL_MAX { + s.feature_enabled[i][j] = false; + s.feature_data[i][j] = 0; + } + } + } + } + s.seg_id_pre_skip = 0; + s.last_active_seg_id = 0; + for i in 0..MAX_SEGMENTS { + for j in 0..SEG_LVL_MAX { + if s.feature_enabled[i][j] { + s.last_active_seg_id = i as _; + if j >= SEG_LVL_REF_FRAME { + s.seg_id_pre_skip = 1; + } + } + } + } + + Ok(()) + } + + fn parse_loop_filter_parameters( + r: &mut Reader, + fh: &mut FrameHeaderObu, + num_planes: u32, + ) -> anyhow::Result<()> { + let lf = &mut fh.loop_filter_params; + if fh.coded_lossless || fh.allow_intrabc { + lf.loop_filter_level[0] = 0; + lf.loop_filter_level[1] = 0; + + lf.loop_filter_ref_deltas[ReferenceFrameType::Intra as usize] = 1; + lf.loop_filter_ref_deltas[ReferenceFrameType::Last as usize] = 0; + lf.loop_filter_ref_deltas[ReferenceFrameType::Last2 as usize] = 0; + lf.loop_filter_ref_deltas[ReferenceFrameType::Last3 as usize] = 0; + lf.loop_filter_ref_deltas[ReferenceFrameType::BwdRef as usize] = 0; + lf.loop_filter_ref_deltas[ReferenceFrameType::Golden as usize] = -1; + lf.loop_filter_ref_deltas[ReferenceFrameType::AltRef as usize] = -1; + lf.loop_filter_ref_deltas[ReferenceFrameType::AltRef2 as usize] = -1; + + for delta in &mut lf.loop_filter_mode_deltas { + *delta = 0; + } + + return Ok(()); + } + + lf.loop_filter_level[0] = r.read_bits(6)?; + lf.loop_filter_level[1] = r.read_bits(6)?; + if num_planes > 1 && (lf.loop_filter_level[0] > 0 || lf.loop_filter_level[1] > 0) { + lf.loop_filter_level[2] = r.read_bits(6)?; + lf.loop_filter_level[3] = r.read_bits(6)?; + } + + lf.loop_filter_sharpness = r.read_bits(3)?; + lf.loop_filter_delta_enabled = r.read_bit()?; + if lf.loop_filter_delta_enabled { + lf.loop_filter_delta_update = r.read_bit()?; + if lf.loop_filter_delta_update { + for i in 0..TOTAL_REFS_PER_FRAME { + let update_ref_delta = r.read_bit()?; + if update_ref_delta { + lf.loop_filter_ref_deltas[i] = r.read_su(7)?; + } + } + + for i in 0..2 { + let update_mode_delta = r.read_bit()?; + if update_mode_delta { + lf.loop_filter_mode_deltas[i] = r.read_su(7)?; + } + } + } + } + + Ok(()) + } + + fn parse_cdef_params( + r: &mut Reader, + fh: &mut FrameHeaderObu, + enable_cdef: bool, + num_planes: u32, + ) -> anyhow::Result<()> { + let cdef = &mut fh.cdef_params; + + if fh.coded_lossless || fh.allow_intrabc || !enable_cdef { + cdef.cdef_bits = 0; + cdef.cdef_y_pri_strength[0] = 0; + cdef.cdef_y_sec_strength[0] = 0; + cdef.cdef_uv_pri_strength[0] = 0; + cdef.cdef_uv_sec_strength[0] = 0; + cdef.cdef_damping = 3; + return Ok(()); + } + + cdef.cdef_damping = r.read_bits(2)? + 3; + cdef.cdef_bits = r.read_bits(2)?; + for i in 0..(1 << cdef.cdef_bits) as usize { + cdef.cdef_y_pri_strength[i] = r.read_bits(4)?; + cdef.cdef_y_sec_strength[i] = r.read_bits(2)?; + if cdef.cdef_y_sec_strength[i] == 3 { + cdef.cdef_y_sec_strength[i] += 1; + if num_planes > 1 { + cdef.cdef_uv_pri_strength[i] = r.read_bits(4)?; + cdef.cdef_uv_sec_strength[i] = r.read_bits(2)?; + if cdef.cdef_uv_sec_strength[i] == 3 { + cdef.cdef_uv_sec_strength[i] += 1; + } + } + } + } + + Ok(()) + } + + fn parse_loop_restoration_params( + r: &mut Reader, + fh: &mut FrameHeaderObu, + enable_restoration: bool, + num_planes: u32, + use_128x128_superblock: bool, + subsampling_x: bool, + subsampling_y: bool, + ) -> anyhow::Result<()> { + let lr = &mut fh.loop_restoration_params; + + if fh.all_lossless || fh.allow_intrabc || !enable_restoration { + lr.frame_restoration_type[0] = FrameRestorationType::None; + lr.frame_restoration_type[1] = FrameRestorationType::None; + lr.frame_restoration_type[2] = FrameRestorationType::None; + lr.uses_lr = false; + return Ok(()); + } + + lr.uses_lr = false; + lr.uses_chroma_lr = false; + + const REMAP_LR_TYPE: [FrameRestorationType; 4] = [ + FrameRestorationType::None, + FrameRestorationType::Switchable, + FrameRestorationType::Wiener, + FrameRestorationType::Sgrproj, + ]; + + for i in 0..num_planes as usize { + let lr_type = r.read_bits(2)?; + lr.frame_restoration_type[i] = REMAP_LR_TYPE[lr_type as usize]; + if lr.frame_restoration_type[i] != FrameRestorationType::None { + lr.uses_lr = true; + if i > 0 { + lr.uses_chroma_lr = true; + } + } + } + + if lr.uses_chroma_lr { + if use_128x128_superblock { + lr.lr_unit_shift = r.read_bits(1)? + 1; + } else { + lr.lr_unit_shift = r.read_bits(1)?; + if lr.lr_unit_shift > 0 { + lr.lr_unit_shift += r.read_bits(1)? + } + } + + lr.loop_restoration_size[0] = RESTORATION_TILESIZE_MAX >> (2 - lr.lr_unit_shift); + if subsampling_x && subsampling_y && lr.uses_chroma_lr { + lr.lr_uv_shift = r.read_bits(1)?; + } else { + lr.lr_uv_shift = 0; + } + + lr.loop_restoration_size[1] = lr.loop_restoration_size[0] >> lr.lr_uv_shift; + lr.loop_restoration_size[2] = lr.loop_restoration_size[0] >> lr.lr_uv_shift; + } + + Ok(()) + } + + fn read_tx_mode(r: &mut Reader, fh: &mut FrameHeaderObu) -> anyhow::Result<()> { + if fh.coded_lossless { + fh.tx_mode = TxMode::Only4x4; + } else { + let tx_mode_select = r.read_bit()?; + + if tx_mode_select { + fh.tx_mode = TxMode::Select; + } else { + fh.tx_mode = TxMode::Largest; + } + } + + Ok(()) + } + + fn parse_skip_mode_params( + r: &mut Reader, + fh: &mut FrameHeaderObu, + enable_order_hint: bool, + order_hint_bits: i32, + ) -> anyhow::Result<()> { + let skip_mode_allowed; + + if fh.frame_is_intra || !fh.reference_select || !enable_order_hint { + skip_mode_allowed = false; + } else { + let mut forward_idx = -1; + let mut backward_idx = -1; + let mut forward_hint = 0; + let mut backward_hint = 0; + for i in 0..REFS_PER_FRAME { + let ref_hint = fh.ref_order_hint[fh.ref_frame_idx[i] as usize]; + if helpers::get_relative_dist( + enable_order_hint, + order_hint_bits, + ref_hint.try_into().unwrap(), + fh.order_hint.try_into().unwrap(), + ) < 0 + && (forward_idx < 0 + || helpers::get_relative_dist( + enable_order_hint, + order_hint_bits, + ref_hint.try_into().unwrap(), + forward_hint, + ) > 0) + { + forward_idx = i as i32; + forward_hint = ref_hint.try_into().unwrap(); + } else if helpers::get_relative_dist( + enable_order_hint, + order_hint_bits, + ref_hint.try_into().unwrap(), + fh.order_hint.try_into().unwrap(), + ) > 0 + && (backward_idx < 0 || { + helpers::get_relative_dist( + enable_order_hint, + order_hint_bits, + ref_hint.try_into().unwrap(), + backward_hint, + ) < 0 + }) + { + backward_idx = i as i32; + backward_hint = ref_hint.try_into().unwrap(); + } + } + + if forward_idx < 0 { + skip_mode_allowed = false; + } else if backward_idx >= 0 { + skip_mode_allowed = true; + fh.skip_mode_frame[0] = ReferenceFrameType::Last as u32 + + std::cmp::min(forward_idx, backward_idx) as u32; + fh.skip_mode_frame[1] = ReferenceFrameType::Last as u32 + + std::cmp::max(forward_idx, backward_idx) as u32; + } else { + let mut second_forward_idx = -1; + let mut second_forward_hint = 0; + for i in 0..REFS_PER_FRAME { + let ref_hint = fh.ref_order_hint[fh.ref_frame_idx[i] as usize]; + if helpers::get_relative_dist( + enable_order_hint, + order_hint_bits, + ref_hint.try_into().unwrap(), + forward_hint, + ) < 0 + && (second_forward_idx < 0 + || helpers::get_relative_dist( + enable_order_hint, + order_hint_bits, + ref_hint.try_into().unwrap(), + second_forward_hint, + ) > 0) + { + second_forward_idx = i as i32; + second_forward_hint = ref_hint.try_into().unwrap(); + } + } + + if second_forward_idx < 0 { + skip_mode_allowed = false; + } else { + skip_mode_allowed = true; + fh.skip_mode_frame[0] = ReferenceFrameType::Last as u32 + + std::cmp::min(forward_idx, second_forward_idx) as u32; + fh.skip_mode_frame[1] = ReferenceFrameType::Last as u32 + + std::cmp::max(forward_idx, second_forward_idx) as u32; + } + } + } + + if skip_mode_allowed { + fh.skip_mode_present = r.read_bit()?; + } else { + fh.skip_mode_present = false; + } + + Ok(()) + } + + fn parse_frame_reference_mode(r: &mut Reader, fh: &mut FrameHeaderObu) -> anyhow::Result<()> { + if fh.frame_is_intra { + fh.reference_select = false; + } else { + fh.reference_select = r.read_bit()?; + } + Ok(()) + } + + fn seg_feature_active_idx(seg: &SegmentationParams, idx: u32, feature: u32) -> bool { + seg.segmentation_enabled && seg.feature_enabled[idx as usize][feature as usize] + } + + fn get_qindex(fh: &FrameHeaderObu, ignore_deltaq: bool, segment_id: u32) -> i32 { + let base_q_idx = fh.quantization_params.base_q_idx as i32; + if Self::seg_feature_active_idx(&fh.segmentation_params, segment_id, SEG_LVL_ALT_Q as u32) { + let data = fh.segmentation_params.feature_data[segment_id as usize][SEG_LVL_ALT_Q]; + let mut qindex = base_q_idx + i32::from(data); + if !ignore_deltaq && fh.quantization_params.delta_q_present { + qindex += i32::try_from(fh.quantization_params.delta_q_res).unwrap(); + } + helpers::clip3(0, 255, qindex) + } else { + base_q_idx + } + } + + fn read_global_param( + reader: &mut Reader, + type_: WarpModelType, + ref_frame: usize, + idx: usize, + allow_high_precision_mv: bool, + prev_gm_params: &[[i32; 6]; NUM_REF_FRAMES], + gm_params: &mut [[i32; 6]; NUM_REF_FRAMES], + ) -> anyhow::Result<()> { + let mut abs_bits = GM_ABS_ALPHA_BITS; + let mut prec_bits = GM_ALPHA_PREC_BITS; + if idx < 2 { + if type_ == WarpModelType::Translation { + abs_bits = GM_ABS_TRANS_ONLY_BITS - !allow_high_precision_mv as u32; + prec_bits = GM_ABS_TRANS_ONLY_BITS - !allow_high_precision_mv as u32; + } else { + abs_bits = GM_ABS_TRANS_BITS; + prec_bits = GM_TRANS_PREC_BITS; + } + } + + let prec_diff = WARPEDMODEL_PREC_BITS - prec_bits; + + let (round, sub) = if (idx % 3) == 2 { + (1 << WARPEDMODEL_PREC_BITS, 1 << prec_bits) + } else { + (0, 0) + }; + + let mx = 1 << abs_bits; + let r = (prev_gm_params[ref_frame][idx] >> prec_diff) - sub; + gm_params[ref_frame][idx] = + (reader.decode_signed_subexp_with_ref(-mx, mx + 1, r)? << prec_diff) + round; + + Ok(()) + } + + fn parse_global_motion_params( + &mut self, + r: &mut Reader, + fh: &mut FrameHeaderObu, + ) -> anyhow::Result<()> { + let gm = &mut fh.global_motion_params; + let mut type_; + let mut prev_gm_params: [[i32; 6]; NUM_REF_FRAMES] = Default::default(); + + for ref_frame in ReferenceFrameType::Last as usize..=ReferenceFrameType::AltRef as usize { + gm.gm_type[ref_frame] = WarpModelType::Identity; + for i in 0..6 { + gm.gm_params[ref_frame][i] = if i % 3 == 2 { + 1 << WARPEDMODEL_PREC_BITS + } else { + 0 + } + } + } + + if fh.frame_is_intra { + return Ok(()); + } + + // Following libgav1: implement part of setup_past_independence() and + // load_previous(), i.e.: the parts that refer to the global motion + // parameters. + if fh.primary_ref_frame == PRIMARY_REF_NONE { + // setup_past_independence() + #[allow(clippy::needless_range_loop)] + for ref_frame in ReferenceFrameType::Last as usize..ReferenceFrameType::AltRef as usize + { + for i in 0..5 { + prev_gm_params[ref_frame][i] = if i % 3 == 2 { + 1 << WARPEDMODEL_PREC_BITS + } else { + 0 + } + } + } + } else { + // load_previous(): + // 1. The variable prevFrame is set equal to ref_frame_idx[ primary_ref_frame ]. + // 2. PrevGmParams is set equal to SavedGmParams[ prevFrame ]. + let prev_frame = fh.ref_frame_idx[fh.primary_ref_frame as usize] as usize; + prev_gm_params = self.ref_info[prev_frame].global_motion_params.gm_params + } + + for ref_frame in ReferenceFrameType::Last as usize..=ReferenceFrameType::AltRef as usize { + gm.is_global[ref_frame] = r.read_bit()?; + if gm.is_global[ref_frame] { + gm.is_rot_zoom[ref_frame] = r.read_bit()?; + if gm.is_rot_zoom[ref_frame] { + type_ = WarpModelType::RotZoom; + } else { + gm.is_translation[ref_frame] = r.read_bit()?; + if gm.is_translation[ref_frame] { + type_ = WarpModelType::Translation; + } else { + type_ = WarpModelType::Affine; + } + } + } else { + type_ = WarpModelType::Identity; + } + + gm.gm_type[ref_frame] = type_; + if gm.gm_type[ref_frame] as u32 >= WarpModelType::RotZoom as u32 { + Self::read_global_param( + r, + type_, + ref_frame, + 2, + fh.allow_high_precision_mv, + &prev_gm_params, + &mut gm.gm_params, + )?; + + Self::read_global_param( + r, + type_, + ref_frame, + 3, + fh.allow_high_precision_mv, + &prev_gm_params, + &mut gm.gm_params, + )?; + + if type_ == WarpModelType::Affine { + Self::read_global_param( + r, + type_, + ref_frame, + 4, + fh.allow_high_precision_mv, + &prev_gm_params, + &mut gm.gm_params, + )?; + + Self::read_global_param( + r, + type_, + ref_frame, + 5, + fh.allow_high_precision_mv, + &prev_gm_params, + &mut gm.gm_params, + )?; + } else { + gm.gm_params[ref_frame][4] = -gm.gm_params[ref_frame][3]; + gm.gm_params[ref_frame][5] = gm.gm_params[ref_frame][2]; + } + } + + if gm.gm_type[ref_frame] as u32 >= WarpModelType::Translation as u32 { + Self::read_global_param( + r, + type_, + ref_frame, + 0, + fh.allow_high_precision_mv, + &prev_gm_params, + &mut gm.gm_params, + )?; + + Self::read_global_param( + r, + type_, + ref_frame, + 1, + fh.allow_high_precision_mv, + &prev_gm_params, + &mut gm.gm_params, + )?; + } + } + + Ok(()) + } + + fn parse_film_grain_parameters( + &self, + r: &mut Reader, + fh: &mut FrameHeaderObu, + film_grain_params_present: bool, + mono_chrome: bool, + subsampling_x: bool, + subsampling_y: bool, + ) -> anyhow::Result<()> { + let fg = &mut fh.film_grain_params; + + if !film_grain_params_present || (!fh.show_frame && !fh.showable_frame) { + *fg = Default::default(); + return Ok(()); + } + + fg.apply_grain = r.read_bit()?; + if !fg.apply_grain { + *fg = Default::default(); + return Ok(()); + } + + fg.grain_seed = r.read_bits(16)?; + if fh.frame_type == FrameType::InterFrame { + fg.update_grain = r.read_bit()?; + } else { + fg.update_grain = true; + } + + if !fg.update_grain { + fg.film_grain_params_ref_idx = r.read_bits(3)?; + let temp_grain_seed = fg.grain_seed; + + if !fh + .ref_frame_idx + .iter() + .any(|&ref_frame_idx| ref_frame_idx == fg.film_grain_params_ref_idx as i32) + { + return Err(anyhow!("Invalid film_grain_params_ref_idx")); + } + + // load_grain_params() + *fg = self.ref_info[fg.film_grain_params_ref_idx as usize] + .film_grain_params + .clone(); + + fg.grain_seed = temp_grain_seed; + + return Ok(()); + } + + fg.num_y_points = r.read_bits(4)?; + for i in 0..fg.num_y_points as usize { + fg.point_y_value[i] = r.read_bits(8)?; + fg.point_y_scaling[i] = r.read_bits(8)?; + } + + if mono_chrome { + fg.chroma_scaling_from_luma = false; + } else { + fg.chroma_scaling_from_luma = r.read_bit()?; + } + + if mono_chrome + || fg.chroma_scaling_from_luma + || (subsampling_x && subsampling_y && fg.num_y_points == 0) + { + fg.num_cb_points = 0; + fg.num_cr_points = 0; + } else { + fg.num_cb_points = r.read_bits(4)?; + for i in 0..fg.num_cb_points as usize { + fg.point_cb_value[i] = r.read_bits(8)?; + fg.point_cb_scaling[i] = r.read_bits(8)?; + } + + fg.num_cr_points = r.read_bits(4)?; + for i in 0..fg.num_cr_points as usize { + fg.point_cr_value[i] = r.read_bits(8)?; + fg.point_cr_scaling[i] = r.read_bits(8)?; + } + } + + fg.grain_scaling_minus_8 = r.read_bits(2)?; + fg.ar_coeff_lag = r.read_bits(2)?; + + let num_pos_luma = 2 * fg.ar_coeff_lag * (fg.ar_coeff_lag + 1); + let num_pos_chroma = if fg.num_y_points > 0 { + for i in 0..num_pos_luma as usize { + fg.ar_coeffs_y_plus_128[i] = r.read_bits(8)?; + } + num_pos_luma + 1 + } else { + num_pos_luma + }; + + if fg.chroma_scaling_from_luma || fg.num_cb_points > 0 { + for i in 0..num_pos_chroma as usize { + fg.ar_coeffs_cb_plus_128[i] = r.read_bits(8)?; + } + } + + if fg.chroma_scaling_from_luma || fg.num_cr_points > 0 { + for i in 0..num_pos_chroma as usize { + fg.ar_coeffs_cr_plus_128[i] = r.read_bits(8)?; + } + } + + fg.ar_coeff_shift_minus_6 = r.read_bits(2)?; + fg.grain_scale_shift = r.read_bits(2)?; + + if fg.num_cb_points > 0 { + fg.cb_mult = r.read_bits(8)?; + fg.cb_luma_mult = r.read_bits(8)?; + fg.cb_offset = r.read_bits(9)?; + } + + if fg.num_cr_points > 0 { + fg.cr_mult = r.read_bits(8)?; + fg.cr_luma_mult = r.read_bits(8)?; + fg.cr_offset = r.read_bits(9)?; + } + + fg.overlap_flag = r.read_bit()?; + fg.clip_to_restricted_range = r.read_bit()?; + + Ok(()) + } + + fn sequence(&self) -> anyhow::Result<&SequenceHeaderObu> { + let Some(seq) = self.sequence_header.as_ref() else { + return Err(anyhow!("No sequence header parsed yet")) + }; + + Ok(seq) + } + + fn parse_uncompressed_frame_header(&mut self, obu: &Obu) -> anyhow::Result { + let mut r = Reader::new(obu.as_ref()); + + let mut fh = FrameHeaderObu { + obu_header: obu.header.clone(), + ..Default::default() + }; + + // Section 6.8.1: It is a requirement of bitstream conformance that a + // sequence header OBU has been received before a frame header OBU. + let &SequenceHeaderObu { + operating_points_cnt_minus_1, + seq_force_integer_mv, + additional_frame_id_length_minus_1, + delta_frame_id_length_minus_2, + decoder_model_info_present_flag, + reduced_still_picture_header, + frame_id_numbers_present_flag, + use_128x128_superblock, + enable_order_hint, + seq_force_screen_content_tools, + order_hint_bits, + enable_cdef, + enable_restoration, + enable_warped_motion, + color_config: + ColorConfig { + subsampling_x, + subsampling_y, + separate_uv_delta_q, + mono_chrome, + .. + }, + timing_info: + TimingInfo { + equal_picture_interval, + .. + }, + decoder_model_info: + DecoderModelInfo { + frame_presentation_time_length_minus_1, + buffer_removal_time_length_minus_1, + .. + }, + num_planes, + film_grain_params_present, + .. + } = self.sequence()?; + + let mut id_len = 0; + + if frame_id_numbers_present_flag { + id_len = additional_frame_id_length_minus_1 + delta_frame_id_length_minus_2 + 3; + } + + const ALL_FRAMES: u32 = (1 << NUM_REF_FRAMES) - 1; + + if reduced_still_picture_header { + fh.show_existing_frame = false; + fh.frame_type = FrameType::KeyFrame; + fh.frame_is_intra = true; + fh.show_frame = true; + fh.showable_frame = false; + } else { + fh.show_existing_frame = r.read_bit()?; + if fh.show_existing_frame { + fh.frame_to_show_map_idx = r.read_bits(3)?; + if decoder_model_info_present_flag && !equal_picture_interval { + fh.frame_presentation_time = r.read_bits( + u8::try_from(frame_presentation_time_length_minus_1).unwrap() + 1, + )?; + } + fh.refresh_frame_flags = 0; + if frame_id_numbers_present_flag { + assert!(id_len > 0); + fh.display_frame_id = r.read_bits(id_len.try_into().unwrap())?; + } + + // In decode_frame_wrapup(): + // + // Otherwise (show_existing_frame is equal to 1), if frame_type + // is equal to KEY_FRAME, the reference frame loading process as + // specified in section 7.21 is invoked (this process loads + // frame state from the reference frames into the current frame + // state variables) + // + // The following ordered steps now apply: + // + // 1. The reference frame update process as specified in section + // 7.20 is invoked (this process saves the current frame state + // into the reference frames). + // + // 2. If show_frame is equal to 1 or show_existing_frame is + // equal to 1, the output process as specified in section 7.18 + // is invoked (this will output the current frame or a saved + // frame). + // + // We implement 1. here while 2. is left to the actual decoder + self.load_reference_frame(&mut fh)?; + if fh.frame_type == FrameType::KeyFrame { + fh.refresh_frame_flags = ALL_FRAMES; + } + + if film_grain_params_present { + // load_grain_params() + fh.film_grain_params = self.ref_info[fh.frame_to_show_map_idx as usize] + .film_grain_params + .clone(); + } + + // See 5.10. + if matches!(obu.header.obu_type, ObuType::Frame) { + r.byte_alignment()?; + } + + fh.header_bytes = usize::try_from(r.position() / 8).unwrap(); + return Ok(fh); + } + + fh.frame_type = FrameType::n(r.read_bits(2)?).ok_or(anyhow!("Invalid frame type"))?; + fh.frame_is_intra = matches!( + fh.frame_type, + FrameType::IntraOnlyFrame | FrameType::KeyFrame + ); + + fh.show_frame = r.read_bit()?; + + if fh.show_frame && decoder_model_info_present_flag && equal_picture_interval { + fh.frame_presentation_time = + r.read_bits(u8::try_from(frame_presentation_time_length_minus_1).unwrap() + 1)?; + } + + if fh.show_frame { + fh.showable_frame = !matches!(fh.frame_type, FrameType::KeyFrame); + } else { + fh.showable_frame = r.read_bit()?; + } + + if fh.frame_type == FrameType::SwitchFrame + || (fh.frame_type == FrameType::KeyFrame && fh.show_frame) + { + fh.error_resilient_mode = true; + } else { + fh.error_resilient_mode = r.read_bit()?; + } + } + + if fh.frame_type == FrameType::KeyFrame && fh.show_frame { + for i in 0..NUM_REF_FRAMES { + self.ref_info[i].ref_valid = false; + self.ref_info[i].ref_order_hint = 0; + } + for i in 0..REFS_PER_FRAME { + fh.order_hints[ReferenceFrameType::Last as usize + i] = 0; + } + } + + fh.disable_cdf_update = r.read_bit()?; + if seq_force_screen_content_tools == SELECT_SCREEN_CONTENT_TOOLS as u32 { + fh.allow_screen_content_tools = r.read_bit()? as u32; + } else { + fh.allow_screen_content_tools = seq_force_screen_content_tools; + } + + if fh.allow_screen_content_tools > 0 { + if seq_force_integer_mv == SELECT_INTEGER_MV as u32 { + fh.force_integer_mv = r.read_bit()? as u32; + } else { + fh.force_integer_mv = seq_force_integer_mv; + } + } else { + fh.force_integer_mv = 0; + } + + if fh.frame_is_intra { + fh.force_integer_mv = 1; + } + + if frame_id_numbers_present_flag { + self.prev_frame_id = self.current_frame_id; + self.current_frame_id = r.read_bits(id_len.try_into().unwrap())?; + fh.current_frame_id = self.current_frame_id; + + /* conformance checking, as per aom */ + let have_prev_frame_id = + !(self.is_first_frame || fh.frame_type == FrameType::KeyFrame && fh.show_frame); + + if have_prev_frame_id { + let frame_id_length = + additional_frame_id_length_minus_1 + delta_frame_id_length_minus_2 + 3; + + let diff_frame_id = if self.current_frame_id > self.prev_frame_id { + self.current_frame_id - self.prev_frame_id + } else { + assert!(frame_id_length <= 16); + (1 << frame_id_length) + self.current_frame_id - self.prev_frame_id + }; + + if self.prev_frame_id == self.current_frame_id + || diff_frame_id >= (1 << (frame_id_length - 1)) + { + return Err(anyhow!( + "Invalid frame_id: prev_frame_id = {}, current_frame_id = {}", + self.prev_frame_id, + self.current_frame_id + )); + } + } + + /* mark_ref_frames (idLen) */ + let diff_len = delta_frame_id_length_minus_2 + 2; + let shifted_diff_len = 1 << diff_len; + let shifted_id_len = 1 << id_len; + + for i in 0..NUM_REF_FRAMES { + if self.current_frame_id > shifted_diff_len { + if self.ref_info[i].ref_frame_id > self.current_frame_id + || self.ref_info[i].ref_frame_id + < (self.current_frame_id - shifted_diff_len) + { + self.ref_info[i].ref_valid = false; + } + } else if self.ref_info[i].ref_frame_id > self.current_frame_id + && self.ref_info[i].ref_frame_id + < shifted_id_len + self.current_frame_id - shifted_diff_len + { + self.ref_info[i].ref_valid = false; + } + } + } else { + self.current_frame_id = 0; + self.prev_frame_id = self.current_frame_id; + fh.current_frame_id = self.current_frame_id; + } + + if fh.frame_type == FrameType::SwitchFrame { + fh.frame_size_override_flag = true; + } else if reduced_still_picture_header { + fh.frame_size_override_flag = false; + } else { + fh.frame_size_override_flag = r.read_bit()?; + } + + fh.order_hint = r.read_bits(order_hint_bits.try_into().unwrap())?; + + if fh.frame_is_intra || fh.error_resilient_mode { + fh.primary_ref_frame = PRIMARY_REF_NONE; + } else { + fh.primary_ref_frame = r.read_bits(3)?; + } + + let operating_points = &self.sequence()?.operating_points; + if decoder_model_info_present_flag { + fh.buffer_removal_time_present_flag = r.read_bit()?; + if fh.buffer_removal_time_present_flag { + #[allow(clippy::needless_range_loop)] + for op_num in 0..=operating_points_cnt_minus_1 as usize { + if operating_points[op_num].decoder_model_present_for_this_op { + let op_pt_idc = operating_points[op_num].idc; + let in_temporal_layer = (op_pt_idc >> fh.obu_header.temporal_id) & 1 != 0; + let in_spatial_layer = + (op_pt_idc >> (fh.obu_header.spatial_id + 8)) & 1 != 0; + + if op_pt_idc == 0 || (in_temporal_layer && in_spatial_layer) { + let n = buffer_removal_time_length_minus_1 + 1; + fh.buffer_removal_time[op_num] = r.read_bits(n.try_into().unwrap())?; + } + } + } + } + } + + fh.allow_high_precision_mv = false; + fh.use_ref_frame_mvs = false; + fh.allow_intrabc = false; + if fh.frame_type == FrameType::SwitchFrame + || (fh.frame_type == FrameType::KeyFrame && fh.show_frame) + { + fh.refresh_frame_flags = ALL_FRAMES; + } else { + fh.refresh_frame_flags = r.read_bits(8)?; + } + + /* equivalent boolean expression */ + if (!fh.frame_is_intra || fh.refresh_frame_flags != ALL_FRAMES) + && fh.error_resilient_mode + && enable_order_hint + { + for i in 0..NUM_REF_FRAMES { + fh.ref_order_hint[i] = r.read_bits(order_hint_bits.try_into().unwrap())?; + if fh.ref_order_hint[i] != self.ref_info[i].ref_order_hint { + self.ref_info[i].ref_valid = false; + } + } + } + + if fh.frame_is_intra { + self.parse_frame_size(&mut fh, &mut r)?; + Self::parse_render_size(&mut fh, &mut r)?; + if fh.allow_screen_content_tools > 0 && fh.upscaled_width == fh.frame_width { + fh.allow_intrabc = r.read_bit()?; + } + } else { + if !enable_order_hint { + fh.frame_refs_short_signaling = false; + } else { + fh.frame_refs_short_signaling = r.read_bit()?; + if fh.frame_refs_short_signaling { + fh.last_frame_idx = r.read_bits(3)?; + fh.gold_frame_idx = r.read_bits(3)?; + let ref_order_hints = self + .ref_info + .iter() + .map(|i| i.ref_order_hint) + .collect::>() + .try_into() + .unwrap(); + self.set_frame_refs(&mut fh, &ref_order_hints)?; + } + } + + let mut expected_frame_id = [0; REFS_PER_FRAME]; + #[allow(clippy::needless_range_loop)] + for i in 0..REFS_PER_FRAME { + if fh.frame_refs_short_signaling { + fh.ref_frame_idx[i] = r.read_bits(3)?.try_into().unwrap(); + } + + if frame_id_numbers_present_flag { + /* DeltaFrameId */ + let delta_frame_id = + r.read_bits(u8::try_from(delta_frame_id_length_minus_2).unwrap() + 2)? + 1; + + assert!(id_len > 0); + let shifted_id_len = 1 << id_len; + + expected_frame_id[i] = + (self.current_frame_id + shifted_id_len - delta_frame_id) % shifted_id_len; + + let actual_frame_id = self.ref_info[fh.ref_frame_idx[i] as usize].ref_frame_id; + + if expected_frame_id[i] != actual_frame_id { + return Err(anyhow!( + "Invalid frame id, expected {} got {}", + expected_frame_id[i], + actual_frame_id + )); + } + } + } + + if fh.frame_size_override_flag && !fh.error_resilient_mode { + self.frame_size_with_refs(&mut fh, &mut r)?; + } else { + self.parse_frame_size(&mut fh, &mut r)?; + Self::parse_render_size(&mut fh, &mut r)?; + } + + if fh.force_integer_mv > 0 { + fh.allow_high_precision_mv = false; + } else { + fh.allow_high_precision_mv = r.read_bit()?; + } + + /* read_interpolation_filter */ + fh.is_filter_switchable = r.read_bit()?; + if fh.is_filter_switchable { + fh.interpolation_filter = InterpolationFilter::Switchable; + } else { + fh.interpolation_filter = InterpolationFilter::n(r.read_bits(2)?) + .ok_or(anyhow!("Invalid interpolation filter"))?; + } + + fh.is_motion_mode_switchable = r.read_bit()?; + + if fh.error_resilient_mode || !self.sequence()?.enable_ref_frame_mvs { + fh.use_ref_frame_mvs = false; + } else { + fh.use_ref_frame_mvs = r.read_bit()?; + } + + for i in 0..REFS_PER_FRAME { + let ref_frame = ReferenceFrameType::Last as usize + i; + let hint = self.ref_info[fh.ref_frame_idx[i] as usize].ref_order_hint; + fh.order_hints[ref_frame] = hint; + + if !enable_order_hint { + fh.ref_frame_sign_bias[i] = false; + } else { + fh.ref_frame_sign_bias[i] = helpers::get_relative_dist( + enable_order_hint, + order_hint_bits, + hint.try_into().unwrap(), + fh.order_hint.try_into().unwrap(), + ) > 0; + } + } + } + + if reduced_still_picture_header || fh.disable_cdf_update { + fh.disable_frame_end_update_cdf = true; + } else { + fh.disable_frame_end_update_cdf = r.read_bit()?; + } + + if fh.primary_ref_frame == PRIMARY_REF_NONE { + Self::setup_past_independence(&mut fh); + } else { + /* load from the past reference */ + let prev_frame = &self.ref_info[fh.primary_ref_frame as usize]; + + if !prev_frame.ref_valid { + return Err(anyhow!("Reference is invalid")); + } + + /* load_loop_filter_params: load ref_deltas and mode_deltas */ + self.lf.loop_filter_ref_deltas = prev_frame.loop_filter_params.loop_filter_ref_deltas; + self.lf.loop_filter_mode_deltas = prev_frame.loop_filter_params.loop_filter_mode_deltas; + + /* load_segmentation_params: load feature_enabled and feature_data */ + self.seg.feature_enabled = prev_frame.segmentation_params.feature_enabled; + self.seg.feature_data = prev_frame.segmentation_params.feature_data; + } + + // TODO: we can live without this for now. + // if fh.use_ref_frame_mvs { + // // motion_field_estimators() + // } + + self.parse_tile_info(&mut r, &mut fh.tile_info)?; + Self::parse_quantization_params( + &mut r, + &mut fh.quantization_params, + num_planes, + separate_uv_delta_q, + )?; + self.parse_segmentation_params(&mut r, &mut fh.segmentation_params, fh.primary_ref_frame)?; + Self::parse_delta_q_params(&mut r, &mut fh.quantization_params)?; + Self::parse_delta_lf_params( + &mut r, + &mut fh.loop_filter_params, + fh.quantization_params.delta_q_present, + fh.allow_intrabc, + )?; + + fh.coded_lossless = true; + for segment_id in 0..MAX_SEGMENTS { + let q_index = Self::get_qindex(&fh, true, segment_id as _); + let q = &fh.quantization_params; + fh.lossless_array[segment_id] = q_index == 0 + && q.delta_q_y_dc == 0 + && q.delta_q_u_ac == 0 + && q.delta_q_u_dc == 0 + && q.delta_q_v_ac == 0 + && q.delta_q_v_dc == 0; + if !fh.lossless_array[segment_id] { + fh.coded_lossless = false; + } + if q.using_qmatrix { + if fh.lossless_array[segment_id] { + fh.seg_qm_level[0][segment_id] = 15; + fh.seg_qm_level[1][segment_id] = 15; + fh.seg_qm_level[2][segment_id] = 15; + } else { + fh.seg_qm_level[0][segment_id] = q.qm_y; + fh.seg_qm_level[1][segment_id] = q.qm_u; + fh.seg_qm_level[2][segment_id] = q.qm_v; + } + } + } + + fh.all_lossless = fh.coded_lossless && fh.frame_width == fh.upscaled_width; + Self::parse_loop_filter_parameters(&mut r, &mut fh, num_planes)?; + Self::parse_cdef_params(&mut r, &mut fh, enable_cdef, num_planes)?; + Self::parse_loop_restoration_params( + &mut r, + &mut fh, + enable_restoration, + num_planes, + use_128x128_superblock, + subsampling_x, + subsampling_y, + )?; + Self::read_tx_mode(&mut r, &mut fh)?; + Self::parse_frame_reference_mode(&mut r, &mut fh)?; + Self::parse_skip_mode_params(&mut r, &mut fh, enable_order_hint, order_hint_bits)?; + Self::read_tx_mode(&mut r, &mut fh)?; + Self::parse_frame_reference_mode(&mut r, &mut fh)?; + Self::parse_skip_mode_params(&mut r, &mut fh, enable_order_hint, order_hint_bits)?; + + if fh.frame_is_intra || fh.error_resilient_mode || !enable_warped_motion { + fh.allow_warped_motion = false; + } else { + fh.allow_warped_motion = r.read_bit()?; + } + + fh.reduced_tx_set = r.read_bit()?; + self.parse_global_motion_params(&mut r, &mut fh)?; + self.parse_film_grain_parameters( + &mut r, + &mut fh, + film_grain_params_present, + mono_chrome, + subsampling_x, + subsampling_y, + )?; + + Self::skip_and_check_trailing_bits(&mut r, obu)?; + + // See 5.10 + if matches!(obu.header.obu_type, ObuType::Frame) { + r.byte_alignment()?; + } + + fh.header_bytes = usize::try_from(r.position() / 8).unwrap(); + Ok(fh) + } + + pub fn parse_tile_group_obu<'a>(&mut self, obu: Obu<'a>) -> anyhow::Result> { + let mut tg = TileGroupObu { + obu, + ..Default::default() + }; + + let mut r = Reader::new(tg.obu.as_ref()); + + assert!(r.remaining_bits() % 8 == 0); + let mut sz = r.remaining_bits() / 8; + + let num_tiles = self.tile_rows * self.tile_cols; + let start_bit_pos = r.position(); + + if num_tiles > 1 { + tg.tile_start_and_end_present_flag = r.read_bit()?; + } + + if num_tiles == 1 || !tg.tile_start_and_end_present_flag { + tg.tg_start = 0; + tg.tg_end = num_tiles - 1; + } else { + let tile_bits = u8::try_from(self.tile_cols_log2 + self.tile_rows_log2).unwrap(); + tg.tg_start = r.read_bits(tile_bits)?; + tg.tg_end = r.read_bits(tile_bits)?; + } + + r.byte_alignment()?; + + let end_bit_pos = r.position(); + let header_bytes = (end_bit_pos - start_bit_pos) / 8; + sz -= header_bytes; + + let mut tile_num = tg.tg_start; + while tile_num <= tg.tg_end { + let tile_row = tile_num / self.tile_cols; + let tile_col = tile_num % self.tile_cols; + let last_tile = tile_num == tg.tg_end; + let tile_size; + + if last_tile { + tile_size = tg.tg_end; + } else { + tile_size = r.read_le(self.tile_size_bytes.try_into().unwrap())? + 1; + sz -= u64::from(tile_size + self.tile_size_bytes); + } + + let tile = Tile { + tile_offset: u32::try_from(r.position()).unwrap() / 8, + tile_size, + tile_row, + tile_col, + mi_row_start: self.mi_row_starts[tile_row as usize], + mi_row_end: self.mi_row_starts[tile_row as usize + 1], + mi_col_start: self.mi_row_starts[tile_col as usize], + mi_col_end: self.mi_row_starts[tile_col as usize + 1], + }; + + tg.tiles.push(tile); + + // init_symbol, decode_tile() and exit_symbol() left to the accelerator. + + // Skip the actual tile data + if tile_num < tg.tg_end { + r.skip(u64::from(tile_size))?; + } + + tile_num += 1; + } + + assert_eq!(tg.tiles.len(), num_tiles as usize); + + if tg.tg_end == num_tiles - 1 { + // left to the accelerator: + // if ( !disable_frame_end_update_cdf ) { + // frame_end_update_cdf( ) + // } + // decode_frame_wrapup( ) + self.last_frame_header = None; + } + + Ok(tg) + } + + pub fn parse_frame_obu<'a>(&mut self, obu: Obu<'a>) -> anyhow::Result> { + if !matches!(obu.header.obu_type, ObuType::Frame) { + return Err(anyhow!( + "Expected a FrameOBU, got {:?}", + obu.header.obu_type + )); + } + + let frame_header_obu = self.parse_frame_header_obu(&obu)?; + let obu = Obu { + header: obu.header, + data: obu.data, + start_offset: obu.start_offset + frame_header_obu.header_bytes, + size: obu.size - frame_header_obu.header_bytes, + }; + let tile_group_obu = self.parse_tile_group_obu(obu)?; + + Ok(FrameObu { + header: frame_header_obu, + tile: tile_group_obu, + }) + } + + pub fn parse_frame_header_obu(&mut self, obu: &Obu) -> anyhow::Result { + if !matches!(obu.header.obu_type, ObuType::FrameHeader | ObuType::Frame) { + return Err(anyhow!( + "Expected a FrameHeaderOBU, got {:?}", + obu.header.obu_type + )); + } + + if let Some(last_frame_header) = self.last_frame_header.as_ref() { + log::debug!("Using last frame header"); + Ok(last_frame_header.clone()) + } else { + let header = self.parse_uncompressed_frame_header(obu)?; + if header.show_existing_frame { + self.last_frame_header = None; + } else { + /* TileNum = 0 */ + self.last_frame_header = Some(header.clone()); + } + + Ok(header) + } + } +} + +impl Default for Parser { + fn default() -> Self { + Self { + stream_format: StreamFormat::LowOverhead, + operating_point: Default::default(), + last_frame_header: Default::default(), + operating_point_idc: Default::default(), + sequence_changed: true, + should_probe_for_annexb: true, + is_first_frame: Default::default(), + found_first_frame: Default::default(), + upscaled_width: Default::default(), + frame_width: Default::default(), + frame_height: Default::default(), + mi_cols: Default::default(), + mi_rows: Default::default(), + render_width: Default::default(), + render_height: Default::default(), + prev_frame_id: Default::default(), + current_frame_id: Default::default(), + ref_info: Default::default(), + mi_col_starts: [0; MAX_TILE_COLS + 1], + mi_row_starts: [0; MAX_TILE_ROWS + 1], + tile_cols_log2: Default::default(), + tile_cols: Default::default(), + tile_rows_log2: Default::default(), + tile_rows: Default::default(), + tile_size_bytes: Default::default(), + lf: Default::default(), + seg: Default::default(), + sequence_header: Default::default(), + } + } +} + +#[cfg(test)] +mod tests { + use crate::codec::av1::parser::{Parser, StreamFormat}; + use crate::utils::IvfIterator; + + use super::ObuType; + + const STREAM_TEST_25_FPS: &[u8] = include_bytes!("test_data/test-25fps.av1.ivf"); + + /// Encoded with + /// + /// gst-launch-1.0 videotestsrc num-buffers=1 ! + /// video/x-raw,format=I420,width=64,height=64 ! filesink + /// location=aom_input.yuv + /// + /// And: + /// + /// aomenc -p 1 --ivf -w 64 -h 64 -o av1-annexb.ivf aom_input.yuv --annexb=1 + const STREAM_ANNEXB: &[u8] = include_bytes!("test_data/av1-annexb.ivf"); + + #[test] + fn parse_test25fps() { + let mut parser = Parser::default(); + let ivf_iter = IvfIterator::new(STREAM_TEST_25_FPS); + let mut num_obus = 0; + + for packet in ivf_iter { + let mut consumed = 0; + + while let Some(obu) = parser.parse_obu(&packet[consumed..]).unwrap() { + consumed += obu.data.len(); + num_obus += 1; + } + } + + // Manually checked with GStreamer under GDB by using a hitcount on + // "gst_av1_parse_identify_one_obu" *after* the stream format has been + // detected. + assert_eq!(num_obus, 525) + } + + #[test] + /// Test that we can correctly identify streams in both "low-overhead" and + /// Annex B formats. + fn parse_annexb() { + let mut parser = Parser::default(); + let mut ivf_iter = IvfIterator::new(STREAM_TEST_25_FPS); + let packet = ivf_iter.next().unwrap(); + + parser.parse_obu(packet).unwrap(); + assert!(matches!(parser.stream_format, StreamFormat::LowOverhead)); + + let mut parser = Parser::default(); + let mut ivf_iter = IvfIterator::new(STREAM_ANNEXB); + let packet = ivf_iter.next().unwrap(); + + parser.parse_obu(packet).unwrap(); + assert!(matches!(parser.stream_format, StreamFormat::AnnexB { .. })); + } + + #[test] + /// Test that we can correctly identify streams in both "low-overhead" and + /// Annex B formats and identify all the OBUs in the stream until the end. + fn parse_annexb_full() { + let mut parser = Parser::default(); + let ivf_iter = IvfIterator::new(STREAM_TEST_25_FPS); + + for packet in ivf_iter { + let mut consumed = 0; + + while let Some(obu) = parser.parse_obu(&packet[consumed..]).unwrap() { + assert!(matches!(parser.stream_format, StreamFormat::LowOverhead)); + consumed += obu.data.len(); + } + } + + let mut parser = Parser::default(); + let ivf_iter = IvfIterator::new(STREAM_ANNEXB); + let mut num_obus = 0; + + for packet in ivf_iter { + let mut consumed = 0; + + while let Some(obu) = parser.parse_obu(&packet[consumed..]).unwrap() { + assert!(matches!(parser.stream_format, StreamFormat::AnnexB { .. })); + consumed += obu.data.len(); + num_obus += 1; + } + } + + assert_eq!(num_obus, 3); + let annexb_state = match parser.stream_format { + StreamFormat::AnnexB(annexb_state) => annexb_state, + _ => panic!("Wrong StreamFormat, expected AnnexB"), + }; + assert_eq!( + annexb_state.temporal_unit_consumed, + annexb_state.temporal_unit_size + ); + assert_eq!( + annexb_state.frame_unit_consumed, + annexb_state.frame_unit_size + ); + } + + #[test] + fn parse_test25fps_obus() { + let mut parser = Parser::default(); + let ivf_iter = IvfIterator::new(STREAM_TEST_25_FPS); + + for packet in ivf_iter { + let mut consumed = 0; + + while let Some(obu) = parser.parse_obu(&packet[consumed..]).unwrap() { + let data_len = obu.data.len(); + + match obu.header.obu_type { + ObuType::SequenceHeader => { + parser.parse_sequence_header_obu(&obu).unwrap(); + } + ObuType::FrameHeader | ObuType::RedundantFrameHeader => { + parser.parse_frame_header_obu(&obu).unwrap(); + } + ObuType::TileGroup => { + parser.parse_tile_group_obu(obu).unwrap(); + } + ObuType::Frame => { + parser.parse_frame_obu(obu).unwrap(); + } + _ => {} + }; + + consumed += data_len; + } + } + } +} diff --git a/src/codec/av1/reader.rs b/src/codec/av1/reader.rs new file mode 100644 index 00000000..ee5a66c0 --- /dev/null +++ b/src/codec/av1/reader.rs @@ -0,0 +1,295 @@ +// Copyright 2023 The ChromiumOS Authors +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +use anyhow::anyhow; +use bitreader::BitReader; + +use crate::codec::av1::helpers; + +use super::parser::AnnexBState; + +pub struct Reader<'a>(BitReader<'a>); + +impl<'a> Reader<'a> { + pub fn new(data: &'a [u8]) -> Self { + Self(BitReader::new(data)) + } + + /// Read a single bit from the spec. Implements f(1) to return a bool for + /// convenience. + pub fn read_bit(&mut self) -> anyhow::Result { + self.0.read_bool().map_err(|e| anyhow!(e)) + } + + /// Implements f(n): Unsigned n-bit number appearing directly in the + /// bitstream. The bits are read from high to low order. See 4.10.2 + pub fn read_bits(&mut self, num_bits: u8) -> anyhow::Result { + self.0.read_u32(num_bits).map_err(|e| anyhow!(e)) + } + + /// Implements uvlc(): Variable length unsigned n-bit number appearing + /// directly in the bitstream. See 4.10.3 + pub fn read_ulvc(&mut self) -> anyhow::Result { + let mut leading_zeroes = 0; + loop { + let done = self.read_bit()?; + + if done { + break; + } + + leading_zeroes += 1; + } + + if leading_zeroes >= 32 { + return Ok(u32::MAX); + } + + let value = self.read_bits(leading_zeroes)?; + Ok(value + (1 << leading_zeroes) - 1) + } + + /// Implements le(n): Unsigned little-endian n-byte number appearing + /// directly in the bitstream. See 4.10.4 + pub fn read_le(&mut self, num_bits: u8) -> anyhow::Result { + assert!(self.0.is_aligned(1)); + let mut t = 0; + + for i in 0..num_bits { + let byte = self.read_bits(8)?; + t += byte << (i * 8) + } + + Ok(t) + } + + /// Implements leb128(): Unsigned integer represented by a variable number + /// of little-endian bytes. See 4.10.5 + pub fn read_leb128(&mut self) -> anyhow::Result { + assert!(self.0.is_aligned(1)); + + let mut value = 0u64; + let mut leb128bytes = 0; + + for i in 0..8 { + let byte = u64::from(self.read_bits(8)?); + value |= (byte & 0x7f) << (i * 7); + + leb128bytes += 1; + + if byte & 0x80 == 0 { + break; + } + } + + assert!(leb128bytes < 8); + assert!(value < u32::MAX.into()); + Ok(value as u32) + } + + /// Implements su(n): Signed integer converted from an n bits unsigned + /// integer in the bitstream. (The unsigned integer corresponds to the + /// bottom n bits of the signed integer.). See 4.10.6 + pub fn read_su(&mut self, num_bits: u8) -> anyhow::Result { + let mut value = self.read_bits(num_bits)? as i32; + let sign_mask = 1 << (num_bits - 1); + + if (value & sign_mask) != 0 { + value -= 2 * sign_mask; + } + + Ok(value) + } + + /// Implements ns(n): Unsigned encoded integer with maximum number of values + /// n (i.e. output in range 0..n-1). See 4.10.7 + pub fn read_ns(&mut self, num_bits: u8) -> anyhow::Result { + let w = helpers::floor_log2(num_bits) + 1; + let m = (1 << w) - num_bits; + let v = self.read_bits(w - 1)?; + + if v < m.into() { + return Ok(v); + } + + let extra_bit = self.read_bit()?; + Ok((v << 1) - u32::from(m) + u32::from(extra_bit)) + } + + /// Implements 5.9.13: Delta quantizer syntax. + pub fn read_delta_q(&mut self) -> anyhow::Result { + let delta_coded = self.read_bit()?; + + if delta_coded { + self.read_su(7) + } else { + Ok(0) + } + } + + pub fn more_data_in_bitstream(&self) -> bool { + self.0.remaining() != 0 + } + + pub(crate) fn consumed(&self, start_pos: u32) -> u32 { + assert!(self.position() % 8 == 0); + (self.position() / 8) as u32 - start_pos + } + + /// Get the length of the current OBU in AnnexB format. + pub fn current_annexb_obu_length( + &mut self, + annexb_state: &mut AnnexBState, + ) -> anyhow::Result> { + if !self.more_data_in_bitstream() { + return Ok(None); + } + + #[allow(clippy::comparison_chain)] + if annexb_state.temporal_unit_consumed == annexb_state.temporal_unit_size { + annexb_state.temporal_unit_size = 0; + } else if annexb_state.temporal_unit_consumed > annexb_state.temporal_unit_size { + return Err(anyhow!( + "temporal_unit_size is {} but we consumed {} bytes", + annexb_state.temporal_unit_size, + annexb_state.temporal_unit_consumed, + )); + } + + if annexb_state.temporal_unit_size == 0 { + annexb_state.temporal_unit_size = self.read_leb128()?; + if annexb_state.temporal_unit_size == 0 { + return Ok(None); + } + } + + let start_pos = self.consumed(0); + + #[allow(clippy::comparison_chain)] + if annexb_state.frame_unit_consumed == annexb_state.frame_unit_size { + annexb_state.frame_unit_size = 0; + } else if annexb_state.frame_unit_consumed > annexb_state.frame_unit_size { + return Err(anyhow!( + "frame_unit_size is {} but we consumed {} bytes", + annexb_state.frame_unit_size, + annexb_state.frame_unit_consumed, + )); + } + + if annexb_state.frame_unit_size == 0 { + annexb_state.frame_unit_size = self.read_leb128()?; + if annexb_state.frame_unit_size == 0 { + return Ok(None); + } + annexb_state.temporal_unit_consumed += self.consumed(start_pos); + } + + let start_pos = self.consumed(0); + let obu_length = self.read_leb128()?; + let consumed = self.consumed(start_pos); + + annexb_state.temporal_unit_consumed += consumed; + annexb_state.frame_unit_consumed += consumed; + + Ok(Some(obu_length.try_into().unwrap())) + } + + /// Skips `num_bits` bits. + pub fn skip(&mut self, num_bits: u64) -> anyhow::Result<()> { + self.0.skip(num_bits).map_err(|e| anyhow!(e)) + } + + pub fn position(&self) -> u64 { + self.0.position() + } + + /// Implements 5.3.4. + pub fn read_trailing_bits(&mut self, mut num_bits: u64) -> anyhow::Result<()> { + let trailing_one_bit = self.read_bit()?; + num_bits -= 1; + + if !trailing_one_bit { + return Err(anyhow!("bad padding: trailing_one_bit is not set")); + } + + while num_bits > 0 { + let trailing_zero_bit = self.read_bit()?; + if trailing_zero_bit { + return Err(anyhow!("bad padding: trailing_zero_bit is set")); + } + num_bits -= 1; + } + + Ok(()) + } + + fn decode_subexp(&mut self, num_syms: i32) -> anyhow::Result { + let mut i = 0; + let mut mk = 0; + let k = 3; + + loop { + let b2 = if i != 0 { k + i - 1 } else { k }; + let a = 1 << b2; + if num_syms <= mk + 3 * a { + let num_bits = u8::try_from(num_syms - mk).unwrap(); + let subexp_final_bits = self.read_ns(num_bits)?; + return Ok(subexp_final_bits); + } else { + let subexp_more_bits = self.read_bit()?; + if subexp_more_bits { + i += 1; + mk += a; + } else { + let num_bits = u8::try_from(b2).unwrap(); + let subexp_bits = self.read_bits(num_bits)?; + return Ok(subexp_bits + mk as u32); + } + } + } + } + + /// Implements 5.9.27. + pub fn decode_unsigned_subexp_with_ref(&mut self, mx: i32, r: i32) -> anyhow::Result { + let v = self.decode_subexp(mx)?; + if (r << 1) <= mx { + Ok(helpers::inverse_recenter(r, v.try_into().unwrap()) + .try_into() + .unwrap()) + } else { + let res = mx - 1 - helpers::inverse_recenter(mx - 1 - r, v.try_into().unwrap()); + Ok(res.try_into().unwrap()) + } + } + + /// Implements 5.9.26. + pub fn decode_signed_subexp_with_ref( + &mut self, + low: i32, + high: i32, + r: i32, + ) -> anyhow::Result { + let x = self.decode_unsigned_subexp_with_ref(high - low, r - low)?; + Ok(i32::try_from(x).unwrap() + low) + } + + /// Implements 5.3.5 Byte alignment syntax + pub fn byte_alignment(&mut self) -> anyhow::Result<()> { + while (self.position() & 7) != 0 { + self.read_bit()?; + } + + Ok(()) + } + + pub fn remaining_bits(&self) -> u64 { + self.0.remaining() + } +} + +impl<'a> Clone for Reader<'a> { + fn clone(&self) -> Self { + Self(self.0.relative_reader()) + } +} diff --git a/src/codec/av1/test_data/av1-annexb.ivf b/src/codec/av1/test_data/av1-annexb.ivf new file mode 100644 index 0000000000000000000000000000000000000000..1bdc6b4c675d03aabb4197c14f9d64f534831315 GIT binary patch literal 579 zcmV-J0=)f1OG!om03ZNCRxmL@06+j90000100001000000000N0ssI2000000001$ z1d{{-5DN$Z00087|G)n*2!jML6aXOr004jjz<}FvNjdpAZ%GAtK|?t;|5+}LhN>Hm z*&=8vwruHfh~s9$j4wMYBt0g2X0nWoL8+k(zs+_noGMFo?IFe!V2 zx&XC|Djk9)sX>jn0ImpGQ#2(g6iiy4k?M2c?}jMxj={0wrg4{3Wp!t|$oRkYyg7S@wS9Jc#lw4ZnanZZ6|HYk^ zar+yxEQO!^(rE%5T*0(0m6lnuAwVZ32g$Y{u07fbi===w^oI*)2Ke{WZrZg)fsau6 zMK%pX(Z?xFmIhC$?$>Evgdd0IoH+fSv8O#VPOr6RJGyIkf~R+PT?k(^0gwIpIb3mH RVcwIqMmH}rK|g?430Mco01yBG literal 0 HcmV?d00001 diff --git a/src/codec/av1/test_data/test-25fps.av1.ivf b/src/codec/av1/test_data/test-25fps.av1.ivf new file mode 100644 index 0000000000000000000000000000000000000000..83b53b2710bcac516081e7bbfe0f2e7a755475ed GIT binary patch literal 223686 zcmV)GK)%03OG!om03ZNCRxmL@0q_7B000010002`000000001YDF6Tf000000000I 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

1SA13Uv$S0}t4Y(!=*&KXY}Ht?<|(h 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%0D0jgEYIqk87i^VBT**g}3+hw$2*E(f zK>9;fjjy8+wHLcb>pY2rViU%s<9%q)i$qCKk21EcNEKT>BpU3SH?_w_=6j+@m7mj>w>$~JF%L>Apv8?4aOX(LM4do04_LAQLB zlmv|A*b|%x@6JiQaHZ3ga+k64$%&1=4tx}TXA$zzU%p;rk94Xy(S0=`Be{+^{>XIj zpG?<4^oIX5E(r#BfzSXzdH~>o0nq+oSDcCAH!}Fe;-idIpwR6%^EBDS9CRg+p`VKs zZ?b%NsJ_SMXQ<431!u z>=|CCD7AT@_%r%z_lY;hvje(h)t-(fFMwGg!gC1rh0GpNMn+CMqFsWuNBD zU~9-Wxp3WnIW54>_!nGo5}vM}=N38c-)ku~p(#mwy(-JBrNOpBaRUR80!4_PB(59P zms%Kmk5SFfLCW?6Wp0rYhlDz7vbInGptrOH!R4nyRV6#}Cvra4C@yx2Ra!f~;>>|d zK{&9B7~Pv6`yc*i|8rn^qkqFOtnZK25q<&k0{xGf`4f@ZnlUch5qH_elCMr?%j}mR zH0MC<2OF*J`Mv-d%se(uf|68K`r~C|<39T9ltzehfNe(RmKZx;PK75!z*4BWE0TI{>4$ z&5s`2(DeSJP_OQ=CiO@cm~9Bgs5ZaY11J}8IbLW=84nk2DP+8(ifiFC7(m|TFsX&} z#JyITXl!$x$1PrJhj$6mzT0n=@ zibgbNz-`tOOdUiNYv@ttTgj*%yI&Vwv@Am^HuLo&qHTQUz+yu zdpD~I& z3=aI@tE@#`eomkt|MyW9E+rR4_)&cmBs@s#uYFrj>e<{hpNOJz+RqLFf zCAR65I}86@CW(HHr4;h^%p$1rSe{(qBGmL6aNG}^WPsrocMlTZ?H%EtW&! zpCkeq8Riy!vcATG#t^!#D*B7`$^i&2t}JLMan#91T*1&;uT-n?hxE_c?pt;B1j1Q9 zX~-xSGD9(2*+xQrwv)e%tN`C9+fff@d0&mz1v8hOG1wRwswEQf9}^R~Rva_0f}LAK z>83A0WwEWBUD4f^=t_LSe#FC;^`h9Gd-_B^*k-vVNpVe{d$TbE9hG4Q^Ucdj6tgA@_5dZHv8sY*9rFDSGd0%;qT2I!@3xz-F@$@ z!p*u-s3I>>~4xa7m7=}#Aq#dFfkE|SHqc)o7h_Tf^dw$8|f zMm#e1hDB$gu2SzUc+qlrdl7BztEAv&M=yK$X~-9drav8WXbN7^TAINjw+<|T-JH0M zcYuI8#u|Nbu*Lj8H(DI3YanR-JpuKaXkf9H6(I2n9ZPY}boVzDqoSGsv_I#gZjaEecF zTPwQ6dmjj!2R$V-wj>`L&XsW^N&99NNNzZ*>0mD?To$O90ec>3Dgyu1r|IUt5FzSOhmp;Kel?~hreX7-Usw7W~Wk6X*XaXlU7=4b@ zKW&c^SCCq(f^w%`$-E=Qb*+EFRnp(y3A#0=-vr2TooO!}yCL*Hl(V#WpR#&dPuBg} z9b_JMjSA4invYXuqMtmm7iV%)>HM>6_1RdFK7q91?BAzU%Dy0oXf?CcIx#eEuVIga z(W`Z-)QaLOFy=kA_(-ACr7aBW1L2-Mx#JF5lk02nOgZitX`RVOYkJD5qsFgwSnAPh zp)VCL1fIv;(H+3uuz0{iTDC1Q7#X;O)5?E^qW2Di=Py6gK^W-v$v z9Yw|egZsmc8=w3zkI@)Q&Bof4v>cuhkUAVV^kMDxzFupjUK52a zd=z|rar+_;Zi7BB&L=J>oMyiQQTbWp79=5R8r;@9>sPzQRJ-5&e2-g0C8G|EEzaoZ z@9H(D)pfb4PTdiz&z-QH45&*~qA*Vrm*j(t;pW3~=%;K%~!GTtm0$hJSx_eq;0EWmH-j~a-3C?DmHdHR-yr@X}is6mS zm4Me!tWa|A6Yfd`+LDf}R1Hz4b%OJ)V+1>)t^Qrbz+h-Iz-yZxX3KqOsFI~REea;+ zVph@85=DvsJUO1KdqvdFWItNC7yY=?NcHdLa{wg0~yDGn5GMOcO^t*;N z+-!;(CNBzK^df~jJy->Xf(zpmDDjF(7)rE)bGMM^{)jjoh--XjC6BLW8rcGJhgR*Nac z$%pz>&1DcOL+q-w?$BX2SzL@hryPCE#Nvo0yrvYmDRY<&Q!}zlNM=4cSFS@YM^<(! zRpm8CzFO^}%8X}nW$sJ6%fg1+Mpf-_%axiFqvW-3$oJ`kSz^Onu{5Qm0PddgolsSS zky_+M!*Iyt8mRz=;5Z>8sV&ZiTv#Y;BctKe)&9yjXH;k4VxVXD@{A5JJVK~+9$7UjHqh$fv?j{FM`n3a~knrg{Y9 z`MDlHC)+1qZ0VOK5!3ApU@RyW3~ZJ+M#0NB9T@jcQ zHCS{!tfMBBLqM|U7Q$I@7Z!Fi9)1`E+jx7IaJtWoy@)c`Vr(VEh&_s7W;P+>{?CrF;{*3Oou>F%0B=k=TGJm4|SK%C|QH`ZR`w1&&s);C81+N72f4Gr>FP`(W z0Riuj(9sc_^3OYloIp+^l>8N_LjC43XCSabP1xMC-sg@q{wN9f+t_Nxg_06)4I!!! zhB2&(<-9hOPdoyc{u=l!4hFdelzo5%>r8*&N{?>9T*)}>th zC5x|$xIQSXO(Z$3jew1;_lb}EyZRy>85T5ziM|1i{Fm_JT;-R8v}+Z+VnkVQonZ?v zXm85PGJC9^)`GjLzFZQi5!4>P6B$i?V`%0_!gM`Ou$imi&Y?Mb-5M!kx5|L& z4GMK$W|eVax3soJK;F5q`HBa~q$M#5DziKDh8vPY8W0=C*O}62c>~jm=CJQg{B5=e{h+3 zQmA$F>RtTG5O>rJ4y=l7cqx1l4{8s~sQ8WDSYhxPkYNEZy&(l|MA|gUu;grv8H=ZEM+sVQ@xG5@(6mb-4 zvl5U@(fV_{t;`O4TE90X(U(7?bpXjOXgVu=fa^&T69g07&~y?!fjk=n0*;m1mghUa zZUEB;)WR74_Ttk45_1axbgMB!T;$PJrG@8tJ8n*(JN&Fb9}+s3>r`yzn>GrY1J69x|{%3$7P8$10x^W@h@YiCIG6l&@S=%b16s%ovzd1IP#JTNJ8u17l%|?;npNWeYJvp^L^?7S_Jn z&p;i@II{DncWkkF;z#)K>-_!h*-1mgVXN*au^%GkfT=3cRnztFLkeXJ86zZTxu)Qy zW~7`@ymuw;J9m!PE@+4c@6R|K`@AwlM1bDzBbp0m>lqUXv<1mm$0Z^IFD$u*n$*YS zjZU3yC19ofdMPBTkTG#>3bLn5UT2pw=8ADWR8?wNi0H; zUKDWIJ<37W-IZzD$R8BygTeP_rKEW%;LkDL;~;QUbl)?-qnQBFJ{97S$QiJTNVIVP zSP6~bGth16uFdXd!J!d%4&R&j#ffqZ=)_1b%7r&~PPNkHCt>k-YNeCxD3f~*gE*o0 z$fW)x+Prk{c8;AGrBX-$XrC&L0>A5T-ou!;+hYPSc3)B~b!#NQZGBre)5swAd~X_0 zkSzP|gwHY{75$wERn3%Y&w-Y3PW7J#9ky*}{Q~v}Q4kEiFzNbD(!?N<3G2#~dsZ=1 z=6Gy>hucK>RMukyu9z>$=uzrx&k?Ro-f~pIJ-4zgGB-m}IVaU5(5&i;4B|W@>Ad69 zNaFNvWQQ{^4(MYMrmrFng5=9;Sc~FDGEDAy9B-9e9{hZmGh}U4P6t((gtw?Gm=Vm%7eDSfPZBk}c+_z939K-)aPq)y}7t&3hL1dSd%94>_TI z=Y?G*-;-J#XT%&1P*SXd`<>nDCSHcKC##Xdhr z-w;%U%puvb8KsrUH~R}-fh<9w%}A*z*@8;2Z=hLE3~zKsjK3$Bm+`$&#asWb zGk23;RDR=>y9`ev*dByD%O}g70So=cstifJW{oP+P@T45By1Mf*^7520p_3+y4|>? z59t(8${bX{7(gzKnTbCJw2ypwC*1Kq|9ydbp@iEbGIiNi9I~!!vL8@)k(*SRfLm?M zzeDapxl_||dr1v1vU>oqRQy5*4`2C~TQ-DPK0F*a>MTkJKy@Wp75hX|ocTFm7QTkc zPpBO<&AjO}ur6lR1pS5C_A;hIE~+k1H{x|4kSc?b9G*8SonJf~QL4tnR>tE8HoJ&$ z-}gi!G`fOc53fV4i2c$hdAD2a6dNQ)iR`2ky^Jl=NY+YupHIDORMvxmh^>>4Xt{$x$$jmWwfB}P~*!b zrXo(^5}@Oeh=2p1IDD2jp@f?N0RWu-XZ<}8db59VJW&6OzTmVLrPfd z6WJ>($*ruU3AAm1-#f_8h$9*y*qa$Evn~dQOlm);=LaVAw_>sqaimihGn0r*NO3Q+aN|DT zuk_q01DmxOfc5g1*D86I(f+PQE6ZnVwrWSd7O9EJ=tS%ZXhLvB+yc857MbsK8yufW zo;ZmYx{#3U2Wm|SmpdJ1rC^BaE+<-0rRkvN_|*_TWuoX*LMRsPlv9cih@!1d8c?6t zg{Lx9T7%&y?}~L4ugtI&KT`zlk{qx1 zy#<3Bu0LIx3;^bMZ3{pFz(Y%U;qTS`HtrNEL`;t;`j=X^-bR##^iyp{P9wH+Kl{;^ zT)8-*wou1iEMZq=dCeinChTP#$Wv4uv8&JP-uno$H>mxb%Kr$R7y3J%2=??nCo2 z$$6=jgL)QIDWo{hs4C>Sg|&xLftJDm0}o?)xmBUOi9TxF-A3~qv3PlHF;CT60di1i zm=ms=+oGN=11h}8p9g>TpUZ^;)0_Vj!t?ule_#mk002KQgflTj81V=27ls4XjH|Z4 z&v%=ai91+_qLsT*^D#aQHnzVzF~kC-L>ENY#u-Dpwapw_zU2)e53OSCCc_;FSO)eP zm!I&Y$J<43Bl65GL zDJ=eMc1dLl#B>H{pY%Mv$`uT)}7U&Q;E<{Ic}k${uFCTTM@cGlQiQz&w@$1n(A@wG!Z$xz<+0( zD1HPhSlx@d5oOBTR?m9(hg{Iq!KM~;Ukc4Hni@9L`$@WDKOO;Wb>**nS+;SnXEP6Q zXq+yCylEYs9t}H3`ZPn?iDEXX4i6Hc% z!5Ap7T}4-fu&yiLkoN=APyJCERXT;GVbFT6&ftT+cYmL|xc^2)H<8LUTxqVR?`hWT z1+>p7uKrbh_u3s#VgcAeVJ-nKO0I3g`a$z^h|aMyMs%K?Nrw6ECoLId(3-r7a6~M| z$S5d8L7TxVg`F0x`_dNb`Eim~{JJe#F{)Hn+xvGf*OtO||p$SR~e8+;HM-@JHxO8+3<04>9 z=)(s6^UmCblAW;jpv{y9N~2wkg}ejzK5pB>qAX5E7^M%keZlVCi{p4#{^gjQnyJI5 zp_W;Y!A7HeYe)~OwjX(3qGv0g>UR~@s8iZ8RI5Qa@rmx#pp*-Ny!K&kQlMv;s^q?R z%%T9+1tE{W^s!{<>8g9W=1;7Qrsx#RmMEv z$PE+MG(YZGniZSdFim$xF$X^3sX-C@18Kq}nd!W9d#b$-OdY=ww%_ov?1uYrGh*^= zjB=5Px5m6Rd0BCg=~!}{RSAPHJrYn+<9E4)N9j6c6|V@;ThPM)0@|1@ z;0h>aT7Trd{7>EnV0x?ng;?F6AO3$%_4AJPiaR)JU);+^*16`F@j-&>6D)u-v*_vF z3@f+;A<7D!+VhX*k@=ksqwby4N%H#Nwq^JXC#E^7a{*=&TwFfM%Nn*G;H#UHfM8i5 zo1m9!4KgVzUA3C&yO!V*wELn-&e!Q_fdU6;Zhc_}oAJz8o)^vXNOwvRVz!w)B8}VT zpvJ-V;g>c;`F>U3}W?X-Ha>BCRLIv z9lix`SgUp^3BJueJWI_;Pe^^-^d93w@`6E#qorDzl4ar4T^Ce8V^}2{96jo4`&&7~ zp)vtlmDlX-vV#JKj(lob39cClUsdI+7vPXQ#IVd&Q_iigmKFd}9h=`BgavcsP&pc- zn~-{?4X@1QVSnC%=mlwBsPVfFj>E3m*YroLtN%pY2cozBCmeS}{*#*V0{pWS|ARg! zp^=n0{V4GUB-_!*LQ}bbkqD4Y*Bt+oLCo17Zam{wr`eY(r~3ZXx&4OW+!D9)@>bGPF^3l za1z`)wm$Eoj-6y^deRKJ0c-A%&(Tap6EfD4$Po~)=JJ%lIA2Wy{@VkH&pdEon z#rwFi9RV24cs8gJ8d#l1qNWFeZ@}YqV+mzmOp>ti`R2b6{RBtAhaiERH}HQ8P?ptx z{guEnywY}LnjeH`Mfx=%e7UOD<*)+wlMY}1XLCOgdYgaK;h*`fpL7`He}@GY|ICg% z2znnxg?mj(6U~J1o|Td?^$M-@UW=H{_7~eby9#Dnzo9~xe^hM zGe0$9lW;NbZC!*!t!19}!}ZAt^#qMh1GaPHPIeV^ir3(C4g{_PPS0Y#RuP$;jI|U# zG+?98$8uBdQc-z&Sip+;AWI7~+a}~&3wJF^fXm$sPo3VUu4v9P*=NzB5Jt|dUL}N2 z&ESEmZykzq+8oK>xi51A)=DLW)Zgt0feE-9)dpj-mI@obEx@Yrog4Ym3K;Yxx|M+? z(#F-gqV;BF&O8pcE>=Mno#$}85!TNzZcm+F1ZVF?)945wz^7PFXS zrDe!ol)BqsCw}%IR)y7yzz(ElnmK+nTFO9&I-T4}UMc|wH_ltnI^p(8mdLmK`pYBd zz!AKGsP=dEMCWl#pfOslNtw?_x!gA6wKVs`h343Jeq@86!7OZKB1X?f=klB_5Iq{& zh>HcYHm=6Fr#Cq;6Y16~b7a=zs_-1KFf#@qbJGE@k5OTkZAjxBUn+{S!dz3e1&HFJ zg%mx|`@H|afnlR%8egK9jF4RZ;|DzeaPyx>Ak*9ai-H{R1ppBJ7X|qRHMjqL z697VQ_wO_oL=S-Ne^Y;I5TkvaU+ixkkJ~sRQGb%Y*S+NQsGtfPc-Xnhu7vi*cHdiD zbR=*xWKmo?<7VW36D8TX?g>MM&0ITbyBa^ss%jO98e5OqR-mC{84z&SDsrBco1v2G zF!hVLg-K&tj_=&bKUige#)0y%V|&Z5%KNX`z%%5!4+`rFz<1Z5nvqDik|#L+>~e}N za?WKG=J#&T*j;uAp}R(?G~pzuChQnNtb5V-E|^+fT&?W#uFhudU86;~O7uuPh3~$K z{FMrSIt|bwgBHVS>ja}IFtW(ZrBTg~@JGNM*3>%(Hc@B#IH^wCE*rY#|AW4xFi7AxseqQ=`eUnpwZ&w&PxM|?j{jf$>5~4R;T_~Mv-Kj?0^UEjG z%HSOhx6brIe-c3%-)m9JFCQU5FJ1=aJ?#aVm2MvUC*j@Nkv4D0pFsWbiM#)NA`XP! z{$FMVgf9R*0DRz2JjnsL4d=Uw7(=xm4?irEO}t zn`(Q5L)J0vhlt#CZ}yErKKqHn47Flly-~orPNz zS`)@Wx}*dtKf2acq#Nmu1(uXpLQ+5^q?YdPR2rm9a#=bTDOp6MJC+t#8a}S~K97IH z{AS*nbKWy&^28sKD!{BF7m;l4fEEDW!- zJE5~n$Q$i9&|>7>>Ow)urCOfc>CFK&yoyiQ7W*eEnL`0}YdfW+!QVIxj>()N5yTUB z9ZM!dU$-hELUB3T=jNwOPrwb`jGyE5iSj4&fy4tN<_`pjj5D?w$Xm# zXvyYm{yks={DEr{LT-JjaBK4=)(4d_q7k|b?=#^F8EJOJJiz>J+Q~RgKYYqcJ2 z6H;h~37BOM^FOv06<;`Ub^ru6QJ-+1ToE~OE>?s-ult@f0jXpoSM}jib2E=!4#~7Y zRcz=^dPzrn=*i#)KLI161HkJw%P8q?-Ijd8Z0Z3Xkjsw&I2>WSCc@hEBytasf7`=h zy31GeGvcu)L{Mzc{~-8f0jAwq0k&x*k;l&ED3RaFk%9>y zuv)C)E&GNQVWYs(2?v)qHma5a?-4oui^wNzKDR&aw0m)f{8Kih|1oj?V-~iG^{p^R zX0IEDiCzYdxojvuC$zo zol-5#NC5PfFw>94ynIztZ0hy)69$}|mp{*N5Z*P*Dyo4qXR>cMwmDQ|EY1XPADnK7 zql_dk>{4DlO=k5`)EM=|1RfIgDJ5=Jjd&!3n8U_E6u5_s?&2x zoU2BJtg-PAmW2K6%sS*dXt$LprH{Siykr9`ZH<9C}+uOY1fDQHG9c_N8c>1-DAlyfoshR0izw;`Rk6Rc4j)+O} zrMmPBD>~kb%sy{=ip8@ZNcYC@S*Y0yyjD=~xBljYDxt+9j+}@h5xt@RDIqbBkDTSU z`7K4j*6Rx8_%8Q9Eim}T+({JT(NY?z8=40%d39GE&>fSX`jLz#aj>& zx5y5rPEbCKGFGu(sAE(l)q|PU#gAhduDpjO>nL;4&RZ z{nYPPG|O~!l`ekleO_?ai{42eqlLT|wZ8Xu*_LDefYi~uW+`D}gaOqXB@_WYQwh-5 zeR^KWh!Wz)tD|5Fm*MN3iph9AnOsI{G%MKD!xgcpah!fdIX64w-o9(Tx?pB!7HGTo zt({dFf7{3*{p(XLOV$R%Apd>NI&+0_hPxz}RUFQbK~n~rTOT%j?kEK0tz>In)V64c zz#Wa>GfQ#O>Fmn({t{3YOtK^30!}B+MqYIz(n zvl{YGR^La5Lq6lBiMFY@6KbWAK;4D~azF*HT&cCHOkCbHxbK8Z)i{V>E$YUzB4LKW z@v@Jn#x~3`51<1KWU>@`6#c}CY}5P;+{zk)ZE=0id}t8pjnSVwNjy?-b~g<{aNSvp z@iAxLjoY?PeeP!p;UtL`Eb941Xcnn`9&GXa4;eeRG}-uRqvl}*A<72WI4u$Ew=0GD zp^1*(C)Zvzoj&i~^6fUH7pk;j0Q2iLmR<6x!ZpFfj-nqMvs$%mVWiJFssuBNbxz73 zkM$;yE9>C6FxdA7>mk;1S&XATCs8B#m1cbAHFZZkV5B22(#syV2&n871{GgH&OALi zZ$YKn=(#eN7R={Uj$B<`PblRWqROPq5`%d7zvk9l+2W>|@=SdulvvMkyV=y| zIT|{4SJ)sa_G{Ei?k=8il_f|P?Nx%PP?Khg%k#sJ10br z)YoV7>a>o>uD+?=BUwi>Yh<55=#~R!_hVZ_)l(5AHSJr}Leo5wbOebue!!hWj(4I? zJas>{BJ*pM&PaB_eXP#q=&L*r=Yn?o^88xVLnnzp6+b-g@8P zHNK_{?24TWcUs*HBhmvy^lX?&?+Q!UzVHe$x-JNb9>2pjf957g$yQMvlmGVRTW;H) zD~Zy`r<>Et+KT7JjC{X5fiN|!`Q4g#@d+NRmnP6Q|Ma7J`+DNZRHc6nZRM zMWb;J3dYnv(?zq-@6_6@klif#)`{DAV`-706uJ9yqXycHS7Br9BWVA##!&9ew0MIA z*PY;Omr!brEfhWio=7w2?GM#96H?DOJmJP8q~@rP5-OCgF4iW+>P ze}FK0VHeHUtD_(HL18x;hxKsKrRtI$rHm%2^nQAvQI<4wuLuhs=jHM`L0Wy!jEKN@ z+l_ehs2wJ@OTW{;il!8JlY@v$KMf|kOT%dPLY`iK zBK;`m{cldAcr2agwpVdln5t5o1ctYa9>O6(AD}|_58zF+S9ld&Z^3T%(5yJ$-T+*> zVU~Ct@P#3Xw}iLaD86}IOt39*j%8u?NGNfM&ToIgqAv8_I59HDc>H+B0oy95bCVbW z%W2T|?LCA0ph2<4pU;TBr6C0hhF_9%_x1E|U86u+A^ZmN4jCsYWreI-uh&Q8$r}9N zxXOWBn+++2ps^0fX=BNin999h~L+B0B zPczeQ`_rGZXu*-(+@d!Q_YZr|oN2Wd!MSGg66go7v|{z`Qt#+ImNz=suZf;$4v^y2 zb$-k0m-&ookk85%%vw@QC3)pLR|czHvPmo=n_#NKzviO0x4c_@^dp6mNA~*3gxkAv zjWaV`8%ZzXvp(*?U0jWT`Jldmua7TTh}G!?3ZFWJ=uoIIHH)9@y?W?^q@b;@9!TvZ z8+J46WQVwjB3)asYQ@|?7W*XqESjJml<6Cz@*etWw0DlxgHLcBm*v(U#!^&|bKyrA z#`@}DQiYI;0b7U~*hwA$xE~MeBHJh$`-zc5i>4Pu>LVAb6bRosvEkCpb+8$OYzxYM(o3<7Y_zNgZ|RqP6H5b*B`(u(G}UZ|C$C$lcs zP+Bbw)8rQ*x5_mV`(aXZ1h86Ji-~X&cblLVN^g=>a>7ke&m$NVJLSPh4J1UuWr4>_ zF{L5az48X;8%IZW?`j2^wZjXM)HOqccSp>l<-EY;feS?pi;2|;`j2lO+R zU_$0<)py`fwZ`B=961QLXF}%NOs+!jBCLaGAF=_zMLWy550|*1uH?awDG{1t(Xb)_`kTd;ys3n#z0-;8$e8CTZS;;^gbt4%~<=pR*jiIuFUk$_Al zicq3(~Q7n-1yVW+QEHd%Vtx6!_t>E5PUx@k{^=c)N?v<0z)M#N!MWK?e9zUecJ$f`LA z2OVb&K6Icx&5Xt#+hIqIHNE^WlR6Vcvvg*$K$T!r;-ajN&q`ly*16*v8!g^uGhP~y z{BV+5^n8UvzOg`v7n$auRxOASYzrWep%kMdUn6a__SVeVKB$NwS1+t%;?3|K~+f4H!{sgex#B z=fJMUyq^U9{(%SV{M*hGV^Hw-@`6ra5S+gpteVVUVr!Kys8Ir?Z73_Qf!&D)m7CAas;0 zE@ZO{Hg6uH@+iUN#@4>cK2m>mFj$k~x;IADK7r^N>hO(g31T+!?zpr;IUOtb>hBy#LL8_? z$|^tXGj_V6Q~_7MGEOaW!4kznz8{&=dK=xfznF4Cmwcy)A7W@<&9u99(rCTxg&zWd zmz|d!!!PAaz-BraoVTJ!x}2g3ltV&fNk|=A1H0da=rM6kGLmD_bo#x#yz)(^bpIfs ZV7v{OkGRwMcVa<1R`TFM>KrjB=>NCj<2nEU literal 0 HcmV?d00001