format code and get rid of unused variables

Djuffin · Djuffin · commit af0eaaff4619 · 2025-10-27T03:38:19.000-07:00
diff --git a/src/h264/decoder.rs b/src/h264/decoder.rs
@@ -226,7 +226,10 @@ impl Decoder {
                         }
 
                         for plane_name in [ColorPlane::Cb, ColorPlane::Cr] {
-                            let chroma_qp = get_chroma_qp(qp as i32, slice.pps.chroma_qp_index_offset, 0).try_into().unwrap();
+                            let chroma_qp =
+                                get_chroma_qp(qp as i32, slice.pps.chroma_qp_index_offset, 0)
+                                    .try_into()
+                                    .unwrap();
                             info!("QP: {qp} chroma qp: {chroma_qp}");
                             let chroma_plane = &mut frame.planes[plane_name as usize];
                             let residuals = if let Some(residual) = imb.residual.as_ref() {
@@ -348,7 +351,6 @@ pub fn get_chroma_qp(luma_qp: i32, chroma_qp_offset: i32, qp_bd_offset_c: i32) -
     qp_c + qp_bd_offset_c
 }
 
-
 // Section 8.3.1.1 Derivation process for Intra4x4PredMode
 pub fn render_luma_4x4_intra_prediction(
     slice: &Slice,
@@ -657,6 +659,7 @@ pub fn render_chroma_intra_prediction(
     let loc = Point { x: loc.x >> chroma_shift.width, y: loc.y >> chroma_shift.width };
     let mb_width = MB_WIDTH >> chroma_shift.width;
     let mb_height = MB_HEIGHT >> chroma_shift.height;
+    let offset = point_to_plain_offset(loc);
 
     #[inline]
     fn sum(slice: &[u8]) -> u32 {
@@ -670,14 +673,13 @@ pub fn render_chroma_intra_prediction(
             let y = loc.y as usize;
             let mut src_row = [0; 16];
             src_row[0..mb_width].copy_from_slice(&target.row(y as isize - 1)[x..(x + mb_width)]);
-            let mut target_slice = target.mut_slice(point_to_plain_offset(loc));
+            let mut target_slice = target.mut_slice(offset);
             for row in target_slice.rows_iter_mut().take(mb_height) {
                 row[0..mb_width].copy_from_slice(&src_row[0..mb_width]);
             }
         }
         Intra_Chroma_Pred_Mode::Horizontal => {
             // Section 8.3.4.2 Specification of Intra_Chroma_Horizontal prediction mode
-            let offset = point_to_plain_offset(loc);
             let mut target_slice = target.mut_slice(PlaneOffset { x: offset.x - 1, ..offset });
             for row in target_slice.rows_iter_mut().take(mb_height) {
                 let src = row[0];
@@ -686,7 +688,6 @@ pub fn render_chroma_intra_prediction(
         }
         Intra_Chroma_Pred_Mode::DC => {
             // Section 8.3.4.1 Specification of Intra_Chroma_DC prediction mode
-            let offset = point_to_plain_offset(loc);
 
             // Calculate the sum of all the values at the top of the current block
             let mut top_left = None;
@@ -711,9 +712,10 @@ pub fn render_chroma_intra_prediction(
             }
 
             for blk_idx in 0..4 {
-                const DEFAULT_VALUE : u32 = 1 << 7; // = 1 << ( BitDepthC − 1 )
+                const DEFAULT_VALUE: u32 = 1 << 7; // = 1 << ( BitDepthC − 1 )
                 let result = match blk_idx {
-                    0 => { // If ( xO, yO ) is equal to ( 0, 0 ) or xO and yO are greater than 0
+                    0 => {
+                        // If ( xO, yO ) is equal to ( 0, 0 ) or xO and yO are greater than 0
                         if let (Some(left), Some(top)) = (left_top, top_left) {
                             (left + top + 4) >> 3
                         } else if let Some(s) = top_left {
@@ -724,7 +726,8 @@ pub fn render_chroma_intra_prediction(
                             DEFAULT_VALUE
                         }
                     }
-                    1 => { // If xO is greater than 0 and yO is equal to 0
+                    1 => {
+                        // If xO is greater than 0 and yO is equal to 0
                         if let Some(s) = top_right {
                             (s + 2) >> 2
                         } else if let Some(s) = left_top {
@@ -733,7 +736,8 @@ pub fn render_chroma_intra_prediction(
                             DEFAULT_VALUE
                         }
                     }
-                    2 => { // If xO is equal to 0 and yO is greater than 0
+                    2 => {
+                        // If xO is equal to 0 and yO is greater than 0
                         if let Some(s) = left_bottom {
                             (s + 2) >> 2
                         } else if let Some(s) = top_left {
@@ -742,8 +746,8 @@ pub fn render_chroma_intra_prediction(
                             DEFAULT_VALUE
                         }
                     }
-                    3 => { // If xO is equal to 0 and yO is greater than 0
-                       if let (Some(left), Some(top)) = (left_bottom, top_right) {
+                    3 => {
+                        if let (Some(left), Some(top)) = (left_bottom, top_right) {
                             (left + top + 4) >> 3
                         } else if let Some(s) = top_right {
                             (s + 2) >> 2
@@ -753,7 +757,7 @@ pub fn render_chroma_intra_prediction(
                             DEFAULT_VALUE
                         }
                     }
-                    _ => unreachable!()
+                    _ => unreachable!(),
                 };
 
                 let mut blk_loc = get_4x4chroma_block_location(blk_idx);
@@ -768,10 +772,7 @@ pub fn render_chroma_intra_prediction(
         Intra_Chroma_Pred_Mode::Plane => {
             // Section 8.3.4.4 Specification of Intra_Chroma_Plane prediction mode
             // yCF = 0 and xCF = 0
-            let mut offset = point_to_plain_offset(loc);
-            offset.x -= 1;
-            offset.y -= 1;
-            let target_slice = target.slice(offset);
+            let target_slice = target.slice(PlaneOffset { x: offset.x - 1, y: offset.y - 1 });
             let mut h = 0;
             let mut top_row = [0u8; 9];
             top_row.copy_from_slice(&target_slice[0][0..9]);
@@ -793,7 +794,6 @@ pub fn render_chroma_intra_prediction(
             let b = (34 * h + 32) >> 6;
             let c = (34 * v + 32) >> 6;
 
-            let offset = point_to_plain_offset(loc);
             let mut target_slice = target.mut_slice(offset);
             for (y, row) in target_slice.rows_iter_mut().take(mb_height).enumerate() {
                 for (x, pixel) in row.iter_mut().take(mb_width).enumerate() {
diff --git a/src/h264/macroblock.rs b/src/h264/macroblock.rs
@@ -102,10 +102,13 @@ pub const fn get_4x4luma_block_location(idx: u8) -> Point {
 
 // Section 6.4.7 Inverse 4x4 chroma block scanning process
 pub fn get_4x4chroma_block_location(idx: u8) -> Point {
-    let idx = idx as u32;
-    let x = inverse_raster_scan(idx, 4, 4, 8, false);
-    let y = inverse_raster_scan(idx, 4, 4, 8, true);
-    Point { x, y }
+    match idx {
+        0 => Point { x: 0, y: 0 },
+        1 => Point { x: 4, y: 0 },
+        2 => Point { x: 0, y: 4 },
+        3 => Point { x: 4, y: 4 },
+        _ => unreachable!(),
+    }
 }
 
 // Section 6.4.13.1 Derivation process for 4x4 luma block indices
diff --git a/src/h264/residual.rs b/src/h264/residual.rs
@@ -152,12 +152,7 @@ impl Residual {
                 ColorPlane::Cr => &self.chroma_cr_dc_level,
                 _ => unreachable!(),
             };
-            let mut dcs_block = Block2x2 {
-                samples: [
-                    [dcs[0], dcs[1]],
-                    [dcs[2], dcs[3]],
-                ]
-            };
+            let mut dcs_block = Block2x2 { samples: [[dcs[0], dcs[1]], [dcs[2], dcs[3]]] };
             dcs_block = transform_chroma_dc(&dcs_block);
             dc_scale_2x2_block(&mut dcs_block, qp);
 
@@ -324,15 +319,15 @@ pub fn dc_scale_2x2_block(block: &mut Block2x2, qp: u8) {
     let is_inter = false;
     for row in block.samples.iter_mut() {
         for c in row.iter_mut() {
-            let d = (*c * level_scale_4x4(is_inter, m, 0)  << (qp / 6)) >> 5;
+            let d = (*c * level_scale_4x4(is_inter, m, 0) << (qp / 6)) >> 5;
             *c = d;
         }
     }
 }
 
 // Section 8.5.10 Scaling and transformation process for DC transform coefficients for Intra_16x16
 pub fn transform_dc(block: &Block4x4) -> Block4x4 {
-let b = &block.samples;
+    let b = &block.samples;
     let mut result = Block4x4::default();
     let r = &mut result.samples;
 
@@ -388,12 +383,7 @@ pub fn transform_chroma_dc(block: &Block2x2) -> Block2x2 {
     let hc10 = c[0][0] - c[1][0];
     let hc11 = c[0][1] - c[1][1];
 
-    Block2x2 {
-        samples: [
-            [hc00 + hc01, hc00 - hc01],
-            [hc10 + hc11, hc10 - hc11],
-        ],
-    }
+    Block2x2 { samples: [[hc00 + hc01, hc00 - hc01], [hc10 + hc11, hc10 - hc11]] }
 }
 
 pub fn unzip_block_4x4(block: &[i32]) -> Block4x4 {
@@ -527,14 +517,11 @@ mod tests {
     pub fn test_transform_4x4_zeros() {
         test_transform_4x4(
             Block4x4 { samples: [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]] },
-            Block4x4 {
-                samples: [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]],
-            },
+            Block4x4 { samples: [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]] },
             28,
         );
     }
 
-
     #[test]
     pub fn test_transform_4x4_ex1() {
         test_transform_4x4(
diff --git a/src/y4m_cmp.rs b/src/y4m_cmp.rs
@@ -47,7 +47,9 @@ pub fn compare_frames(
     if let Some((x, y, a, e)) = compare_plane(width / 2, height / 2, actual_v, expected_v) {
         let width_in_mb = width / 2 / chroma_mb_width;
         let mb_idx = x / chroma_mb_width + (y / chroma_mb_width) * width_in_mb;
-        result.push_str(&format!("V-plane mismatch at {x},{y} (MB:{mb_idx}) width_in_mb:{width_in_mb} : {a} != {e}\n"));
+        result.push_str(&format!(
+            "V-plane mismatch at {x},{y} (MB:{mb_idx}) width_in_mb:{width_in_mb} : {a} != {e}\n"
+        ));
     }
 
     result
