#![allow(non_camel_case_types)]: Fix and remove in librav1d.

`rust-analyzer` has false positives for this, so it's simpler to just fix it.
memorysafety · Jul 10, 2024 · f034359 · f034359
1 parent b80ead5
commit f034359
Show file tree

Hide file tree

Showing 14 changed files with 274 additions and 273 deletions.
diff --git a/lib.rs b/lib.rs
@@ -1,4 +1,3 @@
-#![allow(non_camel_case_types)]
 #![allow(non_snake_case)]
 #![allow(non_upper_case_globals)]
 #![cfg_attr(target_arch = "arm", feature(stdarch_arm_feature_detection))]

diff --git a/src/cdf.rs b/src/cdf.rs
@@ -169,7 +169,7 @@ impl Default for CdfModeInterContext {
 #[derive(Clone)]
 pub enum CdfThreadContext {
     QCat(c_uint),
-    Cdf(Arc<CdfThreadContext_data>),
+    Cdf(Arc<CdfThreadContextData>),
 }
 
 impl CdfThreadContext {
@@ -195,7 +195,7 @@ impl Default for CdfThreadContext {
 }
 
 #[repr(C)]
-pub struct CdfThreadContext_data {
+pub struct CdfThreadContextData {
     /// This context should not be contended but needs interior mutability. It
     /// should always be accessible with `.try_*` methods.
     cdf: RwLock<CdfContext>,
@@ -5106,7 +5106,7 @@ pub fn rav1d_cdf_thread_copy(src: &CdfThreadContext) -> CdfContext {
 pub fn rav1d_cdf_thread_alloc(have_frame_mt: bool) -> Rav1dResult<CdfThreadContext> {
     // TODO fallible allocation
     // Previously pooled.
-    Ok(CdfThreadContext::Cdf(Arc::new(CdfThreadContext_data {
+    Ok(CdfThreadContext::Cdf(Arc::new(CdfThreadContextData {
         cdf: Default::default(),
         progress: have_frame_mt.then_some(AtomicU32::new(0)),
     })))

diff --git a/src/decode.rs b/src/decode.rs
@@ -65,8 +65,8 @@ use crate::src::internal::Rav1dBitDepthDSPContext;
 use crate::src::internal::Rav1dContext;
 use crate::src::internal::Rav1dContextTaskType;
 use crate::src::internal::Rav1dFrameContext;
-use crate::src::internal::Rav1dFrameContext_frame_thread;
-use crate::src::internal::Rav1dFrameContext_lf;
+use crate::src::internal::Rav1dFrameContextFrameThread;
+use crate::src::internal::Rav1dFrameContextLf;
 use crate::src::internal::Rav1dFrameData;
 use crate::src::internal::Rav1dState;
 use crate::src::internal::Rav1dTaskContext;
@@ -78,7 +78,6 @@ use crate::src::internal::TileStateRef;
 use crate::src::intra_edge::EdgeFlags;
 use crate::src::intra_edge::EdgeIndex;
 use crate::src::intra_edge::IntraEdges;
-use crate::src::levels::mv;
 use crate::src::levels::Av1Block;
 use crate::src::levels::Av1BlockInter;
 use crate::src::levels::Av1BlockInter1d;
@@ -96,6 +95,7 @@ use crate::src::levels::InterIntraPredMode;
 use crate::src::levels::InterIntraType;
 use crate::src::levels::MVJoint;
 use crate::src::levels::MotionMode;
+use crate::src::levels::Mv;
 use crate::src::levels::SegmentId;
 use crate::src::levels::TxfmSize;
 use crate::src::levels::CFL_PRED;
@@ -139,10 +139,10 @@ use crate::src::recon::debug_block_info;
 use crate::src::refmvs::rav1d_refmvs_find;
 use crate::src::refmvs::rav1d_refmvs_init_frame;
 use crate::src::refmvs::rav1d_refmvs_tile_sbrow_init;
-use crate::src::refmvs::refmvs_block;
-use crate::src::refmvs::refmvs_mvpair;
-use crate::src::refmvs::refmvs_refpair;
+use crate::src::refmvs::RefMvsBlock;
 use crate::src::refmvs::RefMvsFrame;
+use crate::src::refmvs::RefMvsMvPair;
+use crate::src::refmvs::RefMvsRefPair;
 use crate::src::relaxed_atomic::RelaxedAtomic;
 use crate::src::tables::cfl_allowed_mask;
 use crate::src::tables::dav1d_al_part_ctx;
@@ -260,7 +260,7 @@ fn read_mv_component_diff(
     }
 }
 
-fn read_mv_residual(ts_c: &mut Rav1dTileStateContext, ref_mv: &mut mv, mv_prec: i32) {
+fn read_mv_residual(ts_c: &mut Rav1dTileStateContext, ref_mv: &mut Mv, mv_prec: i32) {
     let mv_joint = MVJoint::from_bits_truncate(rav1d_msac_decode_symbol_adapt4(
         &mut ts_c.msac,
         &mut ts_c.cdf.mv.joint.0,
@@ -438,8 +438,8 @@ fn find_matching_ref(
         && t.b.x + bw4 < ts.tiling.col_end
         && intra_edge_flags.contains(EdgeFlags::I444_TOP_HAS_RIGHT);
 
-    let bs = |rp: refmvs_block| rp.bs.dimensions();
-    let matches = |rp: refmvs_block| rp.r#ref.r#ref[0] == r#ref + 1 && rp.r#ref.r#ref[1] == -1;
+    let bs = |rp: RefMvsBlock| rp.bs.dimensions();
+    let matches = |rp: RefMvsBlock| rp.r#ref.r#ref[0] == r#ref + 1 && rp.r#ref.r#ref[1] == -1;
 
     if have_top {
         let mut i = r[0] + t.b.x as usize;
@@ -525,12 +525,12 @@ fn find_matching_ref(
 }
 
 fn derive_warpmv(
-    r: &DisjointMut<AlignedVec64<refmvs_block>>,
+    r: &DisjointMut<AlignedVec64<RefMvsBlock>>,
     t: &Rav1dTaskContext,
     bw4: c_int,
     bh4: c_int,
     masks: &[u64; 2],
-    mv: mv,
+    mv: Mv,
     mut wmp: Rav1dWarpedMotionParams,
 ) -> Rav1dWarpedMotionParams {
     let mut pts = [[[0; 2 /* x, y */]; 2 /* in, out */]; 8];
@@ -543,9 +543,9 @@ fn derive_warpmv(
         *r.index(t.rt.r[(offset as isize + i as isize) as usize] + j as usize)
     };
 
-    let bs = |rp: refmvs_block| rp.bs.dimensions();
+    let bs = |rp: RefMvsBlock| rp.bs.dimensions();
 
-    let mut add_sample = |np: usize, dx: i32, dy: i32, sx: i32, sy: i32, rp: refmvs_block| {
+    let mut add_sample = |np: usize, dx: i32, dy: i32, sx: i32, sy: i32, rp: RefMvsBlock| {
         pts[np][0][0] = 16 * (2 * dx + sx * bs(rp)[0] as i32) - 8;
         pts[np][0][1] = 16 * (2 * dy + sy * bs(rp)[1] as i32) - 8;
         pts[np][1][0] = pts[np][0][0] + rp.mv.mv[0].x as i32;
@@ -905,11 +905,11 @@ fn splat_oneref_mv(
     bh4: usize,
 ) {
     let mode = inter.inter_mode;
-    let tmpl = Align16(refmvs_block {
-        mv: refmvs_mvpair {
-            mv: [inter.nd.one_d.mv[0], mv::ZERO],
+    let tmpl = Align16(RefMvsBlock {
+        mv: RefMvsMvPair {
+            mv: [inter.nd.one_d.mv[0], Mv::ZERO],
         },
-        r#ref: refmvs_refpair {
+        r#ref: RefMvsRefPair {
             r#ref: [
                 inter.r#ref[0] + 1,
                 inter.interintra_type.map(|_| 0).unwrap_or(-1),
@@ -928,15 +928,15 @@ fn splat_intrabc_mv(
     t: &Rav1dTaskContext,
     rf: &RefMvsFrame,
     bs: BlockSize,
-    r#ref: mv,
+    r#ref: Mv,
     bw4: usize,
     bh4: usize,
 ) {
-    let tmpl = Align16(refmvs_block {
-        mv: refmvs_mvpair {
-            mv: [r#ref, mv::ZERO],
+    let tmpl = Align16(RefMvsBlock {
+        mv: RefMvsMvPair {
+            mv: [r#ref, Mv::ZERO],
         },
-        r#ref: refmvs_refpair { r#ref: [0, -1] },
+        r#ref: RefMvsRefPair { r#ref: [0, -1] },
         bs,
         mf: 0,
     });
@@ -955,11 +955,11 @@ fn splat_tworef_mv(
 ) {
     assert!(bw4 >= 2 && bh4 >= 2);
     let mode = inter.inter_mode;
-    let tmpl = Align16(refmvs_block {
-        mv: refmvs_mvpair {
+    let tmpl = Align16(RefMvsBlock {
+        mv: RefMvsMvPair {
             mv: inter.nd.one_d.mv,
         },
-        r#ref: refmvs_refpair {
+        r#ref: RefMvsRefPair {
             r#ref: [inter.r#ref[0] + 1, inter.r#ref[1] + 1],
         },
         bs,
@@ -977,11 +977,11 @@ fn splat_intraref(
     bw4: usize,
     bh4: usize,
 ) {
-    let tmpl = Align16(refmvs_block {
-        mv: refmvs_mvpair {
-            mv: [mv::INVALID, mv::ZERO],
+    let tmpl = Align16(RefMvsBlock {
+        mv: RefMvsMvPair {
+            mv: [Mv::INVALID, Mv::ZERO],
         },
-        r#ref: refmvs_refpair { r#ref: [0, -1] },
+        r#ref: RefMvsRefPair { r#ref: [0, -1] },
         bs,
         mf: 0,
     });
@@ -1072,7 +1072,7 @@ fn affine_lowest_px_chroma(
 }
 
 fn obmc_lowest_px(
-    r: &DisjointMut<AlignedVec64<refmvs_block>>,
+    r: &DisjointMut<AlignedVec64<RefMvsBlock>>,
     t: &mut Rav1dTaskContext,
     ts: &Rav1dTileState,
     layout: Rav1dPixelLayout,
@@ -2044,17 +2044,17 @@ fn decode_b(
             frame_hdr,
         );
 
-        let mut r#ref = if mvstack[0].mv.mv[0] != mv::ZERO {
+        let mut r#ref = if mvstack[0].mv.mv[0] != Mv::ZERO {
             mvstack[0].mv.mv[0]
-        } else if mvstack[1].mv.mv[0] != mv::ZERO {
+        } else if mvstack[1].mv.mv[0] != Mv::ZERO {
             mvstack[1].mv.mv[0]
         } else if t.b.y - (16 << seq_hdr.sb128) < ts.tiling.row_start {
-            mv {
+            Mv {
                 y: 0,
                 x: (-(512 << seq_hdr.sb128) - 2048) as i16,
             }
         } else {
-            mv {
+            Mv {
                 y: -(512 << seq_hdr.sb128) as i16,
                 x: 0,
             }
@@ -2119,7 +2119,7 @@ fn decode_b(
         }
 
         let prev_ref = r#ref;
-        let r#ref = mv {
+        let r#ref = Mv {
             x: ((src_left - t.b.x * 4) * 8) as i16,
             y: ((src_top - t.b.y * 4) * 8) as i16,
         };
@@ -2680,7 +2680,7 @@ fn decode_b(
                 &mut mvstack,
                 &mut n_mvs,
                 &mut ctx,
-                refmvs_refpair {
+                RefMvsRefPair {
                     r#ref: [r#ref[0] + 1, -1],
                 },
                 bs,
@@ -3869,10 +3869,10 @@ fn setup_tile(
     cur: &Rav1dPicture,
     bw: i32,
     bh: i32,
-    frame_thread: &Rav1dFrameContext_frame_thread,
+    frame_thread: &Rav1dFrameContextFrameThread,
     sr_sb128w: i32,
     sb128w: i32,
-    lf: &mut Rav1dFrameContext_lf,
+    lf: &mut Rav1dFrameContextLf,
     in_cdf: &CdfThreadContext,
     data: CArc<[u8]>,
     tile_row: usize,

diff --git a/src/env.rs b/src/env.rs
@@ -7,10 +7,10 @@ use crate::src::align::Align8;
 use crate::src::disjoint_mut::DisjointMut;
 use crate::src::disjoint_mut::DisjointMutSlice;
 use crate::src::internal::Bxy;
-use crate::src::levels::mv;
 use crate::src::levels::BlockLevel;
 use crate::src::levels::BlockPartition;
 use crate::src::levels::CompInterType;
+use crate::src::levels::Mv;
 use crate::src::levels::SegmentId;
 use crate::src::levels::TxfmSize;
 use crate::src::levels::TxfmType;
@@ -20,7 +20,7 @@ use crate::src::levels::H_FLIPADST;
 use crate::src::levels::IDTX;
 use crate::src::levels::V_ADST;
 use crate::src::levels::V_FLIPADST;
-use crate::src::refmvs::refmvs_candidate;
+use crate::src::refmvs::RefMvsCandidate;
 use crate::src::tables::TxfmInfo;
 use std::cmp;
 use std::cmp::Ordering;
@@ -607,7 +607,7 @@ pub fn av1_get_uni_p1_ctx(
 }
 
 #[inline]
-pub fn get_drl_context(ref_mv_stack: &[refmvs_candidate; 8], ref_idx: usize) -> c_int {
+pub fn get_drl_context(ref_mv_stack: &[RefMvsCandidate; 8], ref_idx: usize) -> c_int {
     if ref_mv_stack[ref_idx].weight >= 640 {
         (ref_mv_stack[ref_idx + 1].weight < 640) as c_int
     } else if ref_mv_stack[ref_idx + 1].weight < 640 {
@@ -648,13 +648,13 @@ pub fn get_cur_frame_segid(
 }
 
 #[inline]
-fn fix_int_mv_precision(mv: &mut mv) {
+fn fix_int_mv_precision(mv: &mut Mv) {
     mv.x = (mv.x - (mv.x >> 15) + 3) & !7;
     mv.y = (mv.y - (mv.y >> 15) + 3) & !7;
 }
 
 #[inline]
-pub(crate) fn fix_mv_precision(hdr: &Rav1dFrameHeader, mv: &mut mv) {
+pub(crate) fn fix_mv_precision(hdr: &Rav1dFrameHeader, mv: &mut Mv) {
     if hdr.force_integer_mv {
         fix_int_mv_precision(mv);
     } else if !(*hdr).hp {
@@ -671,14 +671,14 @@ pub(crate) fn get_gmv_2d(
     bw4: c_int,
     bh4: c_int,
     hdr: &Rav1dFrameHeader,
-) -> mv {
+) -> Mv {
     match gmv.r#type {
         Rav1dWarpedMotionType::RotZoom => {
             assert!(gmv.matrix[5] == gmv.matrix[2]);
             assert!(gmv.matrix[4] == -gmv.matrix[3]);
         }
         Rav1dWarpedMotionType::Translation => {
-            let mut res = mv {
+            let mut res = Mv {
                 y: (gmv.matrix[0] >> 13) as i16,
                 x: (gmv.matrix[1] >> 13) as i16,
             };
@@ -688,7 +688,7 @@ pub(crate) fn get_gmv_2d(
             return res;
         }
         Rav1dWarpedMotionType::Identity => {
-            return mv::ZERO;
+            return Mv::ZERO;
         }
         Rav1dWarpedMotionType::Affine => {}
     }
@@ -698,7 +698,7 @@ pub(crate) fn get_gmv_2d(
     let yc = (gmv.matrix[5] - (1 << 16)) * y + gmv.matrix[4] * x + gmv.matrix[1];
     let shift = 16 - (3 - !hdr.hp as c_int);
     let round = 1 << shift >> 1;
-    let mut res = mv {
+    let mut res = Mv {
         y: apply_sign(yc.abs() + round >> shift << !hdr.hp as c_int, yc) as i16,
         x: apply_sign(xc.abs() + round >> shift << !hdr.hp as c_int, xc) as i16,
     };