Silencing clippy

Author: ArchitBhonsle

src/rust/src/decoder/mod.rs

@@ -23,7 +23,7 @@ const CCX_DTVCC_SCREENGRID_COLUMNS: u8 = 210;
 const CCX_DTVCC_MAX_ROWS: u8 = 15;
 const CCX_DTVCC_MAX_COLUMNS: u8 = 32 * 2;
 const CCX_DTVCC_MAX_SERVICES: usize = 63;
-const CCX_DTVCC_MAX_WINDOWS: usize = 8;
+// const CCX_DTVCC_MAX_WINDOWS: usize = 8;
 
 /// Context required for processing 708 data
 pub struct Dtvcc<'a> {
@@ -44,18 +44,16 @@ pub struct Dtvcc<'a> {
 
 impl<'a> Dtvcc<'a> {
     /// Create a new dtvcc context
-    pub fn new<'b>(opts: &'b mut ccx_decoder_dtvcc_settings) -> Self {
+    pub fn new(opts: &'_ mut ccx_decoder_dtvcc_settings) -> Self {
         // closely follows `dtvcc_init` at `src/lib_ccx/ccx_dtvcc.c:76`
 
         let report = unsafe { opts.report.as_mut().unwrap() };
         report.reset_count = 0;
 
         let is_active = false;
-        let no_rollup = opts.no_rollup;
-        let active_services_count = opts.active_services_count;
-        let no_rollup = is_true(opts.no_rollup);
-        let active_services_count = opts.active_services_count as u8;
-        let services_active = opts.services_enabled.clone();
+        let _no_rollup = is_true(opts.no_rollup);
+        let _active_services_count = opts.active_services_count as u8;
+        let services_active = opts.services_enabled;
 
         // `dtvcc_clear_packet` does the following
         let packet_length = 0;
@@ -70,43 +68,47 @@ impl<'a> Dtvcc<'a> {
         // unlike C, here the decoders are allocated on the stack as an array.
         let decoders = {
             const INIT: Option<dtvcc_service_decoder> = None;
-            let mut val = [INIT; CCX_DTVCC_MAX_SERVICES];
-
-            for i in 0..CCX_DTVCC_MAX_SERVICES {
-                if is_false(opts.services_enabled[i]) {
-                    continue;
-                }
+            let mut decoders = [INIT; CCX_DTVCC_MAX_SERVICES];
+
+            decoders
+                .iter_mut()
+                .zip(opts.services_enabled)
+                .enumerate()
+                .for_each(|(i, (d, se))| {
+                    if is_false(se) {
+                        return;
+                    }
 
-                let mut decoder = dtvcc_service_decoder {
-                    // we cannot allocate this on the stack as `dtvcc_service_decoder` is a C
-                    // struct cannot be changed trivially
-                    tv: Box::into_raw(Box::new(dtvcc_tv_screen {
-                        cc_count: 0,
-                        service_number: i as i32 + 1,
-                        ..dtvcc_tv_screen::default()
-                    })),
-                    ..dtvcc_service_decoder::default()
-                };
-
-                decoder.windows.iter_mut().for_each(|w| {
-                    w.memory_reserved = 0;
-                });
+                    let mut decoder = dtvcc_service_decoder {
+                        // we cannot allocate this on the stack as `dtvcc_service_decoder` is a C
+                        // struct cannot be changed trivially
+                        tv: Box::into_raw(Box::new(dtvcc_tv_screen {
+                            cc_count: 0,
+                            service_number: i as i32 + 1,
+                            ..dtvcc_tv_screen::default()
+                        })),
+                        ..dtvcc_service_decoder::default()
+                    };
+
+                    decoder.windows.iter_mut().for_each(|w| {
+                        w.memory_reserved = 0;
+                    });
 
-                unsafe { dtvcc_windows_reset(&mut decoder) };
+                    unsafe { dtvcc_windows_reset(&mut decoder) };
 
-                val[i] = Some(decoder);
-            }
+                    *d = Some(decoder);
+                });
 
-            val
+            decoders
         };
 
         let encoder = None; // Unlike C, does not mention `encoder` and is initialised to `null` by default
 
         Self {
             report,
             is_active,
-            no_rollup,
-            active_services_count,
+            no_rollup: _no_rollup,
+            active_services_count: _active_services_count,
             services_active,
             packet_length,
             is_header_parsed,

src/rust/src/lib.rs

@@ -135,7 +135,7 @@ pub fn verify_parity(data: u8) -> bool {
 
 /// Process CC data according to its type
 pub fn do_cb(ctx: &mut lib_cc_decode, cc_block: &[u8]) -> bool {
-    let dtvcc: &mut Dtvcc = unsafe { std::mem::transmute(ctx.dtvcc_rust) };
+    let dtvcc = unsafe { &mut *(ctx.dtvcc_rust as *mut decoder::Dtvcc<'_>) };
     let cc_valid = (cc_block[0] & 4) >> 2;
     let cc_type = cc_block[0] & 3;
     let mut timeok = true;