enum Rav1dFilterMode: Use instead of u8s or Dav1dFilterMode in more places.

Author: kkysen

include/dav1d/headers.rs

@@ -1,3 +1,4 @@
+use crate::src::align::ArrayDefault;
 use crate::src::enum_map::EnumKey;
 use crate::src::levels::SegmentId;
 use crate::src::relaxed_atomic::RelaxedAtomic;
@@ -139,7 +140,7 @@ pub const DAV1D_FILTER_8TAP_SMOOTH: Dav1dFilterMode =
 pub const DAV1D_FILTER_8TAP_REGULAR: Dav1dFilterMode =
     Rav1dFilterMode::Regular8Tap as Dav1dFilterMode;
 
-#[derive(Clone, Copy, PartialEq, Eq, FromRepr, Default)]
+#[derive(Clone, Copy, PartialEq, Eq, FromRepr, Default, Debug)]
 pub enum Rav1dFilterMode {
     #[default] // Not really a real default.
     Regular8Tap = 0,
@@ -149,9 +150,15 @@ pub enum Rav1dFilterMode {
     Switchable = 4,
 }
 
+impl ArrayDefault for Rav1dFilterMode {
+    fn default() -> Self {
+        Default::default()
+    }
+}
+
 impl Rav1dFilterMode {
     pub const N_FILTERS: usize = 4;
-    pub const N_SWITCHABLE_FILTERS: u8 = 3;
+    pub const N_SWITCHABLE_FILTERS: Self = Self::Bilinear;
 }
 
 impl From<Rav1dFilterMode> for Dav1dFilterMode {

src/decode.rs

@@ -5,7 +5,6 @@ use crate::include::common::intops::clip;
 use crate::include::common::intops::clip_u8;
 use crate::include::common::intops::iclip;
 use crate::include::dav1d::common::Rav1dDataProps;
-use crate::include::dav1d::headers::Dav1dFilterMode;
 use crate::include::dav1d::headers::Rav1dFilterMode;
 use crate::include::dav1d::headers::Rav1dFrameHeader;
 use crate::include::dav1d::headers::Rav1dFrameHeader_tiling;
@@ -2983,45 +2982,47 @@ fn decode_b(
             if has_subpel_filter {
                 let comp = comp_type.is_some();
                 let ctx1 = get_filter_ctx(&f.a[t.a], &t.l, comp, false, r#ref[0], by4, bx4);
-                let filter0 = rav1d_msac_decode_symbol_adapt4(
+                let filter0 = Rav1dFilterMode::from_repr(rav1d_msac_decode_symbol_adapt4(
                     &mut ts_c.msac,
                     &mut ts_c.cdf.m.filter.0[0][ctx1 as usize],
                     Rav1dFilterMode::N_SWITCHABLE_FILTERS as u8 - 1,
-                ) as Dav1dFilterMode;
+                ) as usize)
+                .unwrap();
                 if seq_hdr.dual_filter != 0 {
                     let ctx2 = get_filter_ctx(&f.a[t.a], &t.l, comp, true, r#ref[0], by4, bx4);
                     if debug_block_info!(f, t.b) {
                         println!(
-                            "Post-subpel_filter1[{},ctx={}]: r={}",
+                            "Post-subpel_filter1[{:?},ctx={}]: r={}",
                             filter0, ctx1, ts_c.msac.rng,
                         );
                     }
-                    let filter1 = rav1d_msac_decode_symbol_adapt4(
+                    let filter1 = Rav1dFilterMode::from_repr(rav1d_msac_decode_symbol_adapt4(
                         &mut ts_c.msac,
                         &mut ts_c.cdf.m.filter.0[1][ctx2 as usize],
                         Rav1dFilterMode::N_SWITCHABLE_FILTERS as u8 - 1,
-                    ) as Dav1dFilterMode;
+                    ) as usize)
+                    .unwrap();
                     if debug_block_info!(f, t.b) {
                         println!(
-                            "Post-subpel_filter2[{},ctx={}]: r={}",
+                            "Post-subpel_filter2[{:?},ctx={}]: r={}",
                             filter1, ctx2, ts_c.msac.rng,
                         );
                     }
                     [filter0, filter1]
                 } else {
                     if debug_block_info!(f, t.b) {
                         println!(
-                            "Post-subpel_filter[{},ctx={}]: r={}",
+                            "Post-subpel_filter[{:?},ctx={}]: r={}",
                             filter0, ctx1, ts_c.msac.rng
                         );
                     }
                     [filter0; 2]
                 }
             } else {
-                [Rav1dFilterMode::Regular8Tap as u8; 2]
+                [Rav1dFilterMode::Regular8Tap; 2]
             }
         } else {
-            [frame_hdr.subpel_filter_mode as u8; 2]
+            [frame_hdr.subpel_filter_mode; 2]
         };
         let filter2d = dav1d_filter_2d[filter[1] as usize][filter[0] as usize];
 
@@ -3805,7 +3806,7 @@ fn reset_context(ctx: &mut BlockContext, keyframe: bool, pass: c_int) {
         filter
             .get_mut()
             .0
-            .fill(Rav1dFilterMode::N_SWITCHABLE_FILTERS as u8);
+            .fill(Rav1dFilterMode::N_SWITCHABLE_FILTERS);
     }
     ctx.seg_pred.get_mut().0.fill(0);
     ctx.pal_sz.get_mut().0.fill(0);

src/env.rs

@@ -40,7 +40,11 @@ pub struct BlockContext {
     pub intra: DisjointMut<Align8<[u8; 32]>>,
     pub comp_type: DisjointMut<Align8<[Option<CompInterType>; 32]>>,
     pub r#ref: [DisjointMut<Align8<[i8; 32]>>; 2],
-    pub filter: [DisjointMut<Align8<[u8; 32]>>; 2],
+
+    /// No [`Rav1dFilterMode::Switchable`]s here.
+    /// TODO(kkysen) split [`Rav1dFilterMode`] into a version without [`Rav1dFilterMode::Switchable`].
+    pub filter: [DisjointMut<Align8<[Rav1dFilterMode; 32]>>; 2],
+
     pub tx_intra: DisjointMut<Align8<[i8; 32]>>,
     pub tx: DisjointMut<Align8<[u8; 32]>>,
     pub tx_lpf_y: DisjointMut<Align8<[u8; 32]>>,
@@ -169,15 +173,15 @@ pub fn get_filter_ctx(
     });
 
     (comp as u8) * 4
-        + if a_filter == l_filter {
+        + (if a_filter == l_filter {
             a_filter
         } else if a_filter == Rav1dFilterMode::N_SWITCHABLE_FILTERS {
             l_filter
         } else if l_filter == Rav1dFilterMode::N_SWITCHABLE_FILTERS {
             a_filter
         } else {
             Rav1dFilterMode::N_SWITCHABLE_FILTERS
-        }
+        } as u8)
 }
 
 #[inline]