refactor: Clear code errors & clippy warnings

Author: IshanGrover2004

src/rust/src/decoder/mod.rs

@@ -36,44 +36,45 @@ pub struct Dtvcc<'a> {
     pub packet_length: u8,
     pub is_header_parsed: bool,
     pub last_sequence: i32,
-    pub encoder: &'a mut encoder_ctx,
+    pub encoder: *mut encoder_ctx,
     pub no_rollup: bool,
     pub timing: &'a mut ccx_common_timing_ctx,
 }
 
 impl<'a> Dtvcc<'a> {
     /// Create a new dtvcc context
-    pub fn new(opts: &'a mut ccx_decoder_dtvcc_settings) -> Self {
+    pub fn new(opts: &ccx_decoder_dtvcc_settings) -> Self {
         let report = unsafe { &mut *opts.report };
         let timing = unsafe { &mut *opts.timing };
-        let encoder = unsafe { &mut *std::ptr::null_mut() };
+        let encoder = std::ptr::null_mut();
 
         let decoders = {
-            let mut decoders: [dtvcc_service_decoder; CCX_DTVCC_MAX_SERVICES];
+            let mut decoders: [dtvcc_service_decoder; CCX_DTVCC_MAX_SERVICES] =
+                [dtvcc_service_decoder::default(); CCX_DTVCC_MAX_SERVICES];
 
-            decoders.iter_mut().enumerate().for_each(|(i, mut dec)| {
+            for i in 0..CCX_DTVCC_MAX_SERVICES {
                 if is_false(opts.services_enabled[i]) {
-                    return;
+                    continue;
                 }
 
-                let mut decoder = Box::new(dtvcc_service_decoder {
-                    tv: Box::into_raw(Box::new(dtvcc_tv_screen {
+                decoders[i] = unsafe {
+                    *Box::into_raw(Box::new(dtvcc_service_decoder {
+                        tv: Box::into_raw(Box::new(dtvcc_tv_screen {
+                            cc_count: 0,
+                            service_number: i as i32 + 1,
+                            ..dtvcc_tv_screen::default()
+                        })),
                         cc_count: 0,
-                        service_number: i as i32 + 1,
-                        ..dtvcc_tv_screen::default()
-                    })),
-                    cc_count: 0,
-                    ..dtvcc_service_decoder::default()
-                });
+                        ..dtvcc_service_decoder::default()
+                    }))
+                };
 
-                decoder.windows.iter_mut().for_each(|window| {
+                decoders[i].windows.iter_mut().for_each(|window| {
                     window.memory_reserved = 0;
                 });
 
-                unsafe { dtvcc_windows_reset(decoder.as_mut()) };
-
-                dec = &mut *decoder;
-            });
+                unsafe { dtvcc_windows_reset(&mut decoders[i]) };
+            }
 
             decoders
         };
@@ -208,7 +209,7 @@ impl<'a> Dtvcc<'a> {
                 let decoder = &mut self.decoders[(service_number - 1) as usize];
                 decoder.process_service_block(
                     &self.packet[pos as usize..(pos + block_length) as usize],
-                    self.encoder,
+                    unsafe { &mut *self.encoder },
                     self.timing,
                     self.no_rollup,
                 );

src/rust/src/lib.rs

@@ -52,10 +52,8 @@ pub extern "C" fn ccxr_init_logger() {
 ///     - opts.report
 ///     - opts.timing
 #[no_mangle]
-extern "C" fn ccxr_dtvcc_init<'a>(
-    dtvcc_settings_ptr: *mut ccx_decoder_dtvcc_settings,
-) -> *mut Dtvcc<'a> {
-    let mut opts = unsafe { dtvcc_settings_ptr.as_mut() }.expect("Didn't get dtvcc pointer");
+extern "C" fn ccxr_dtvcc_init<'a>(opts_ptr: *const ccx_decoder_dtvcc_settings) -> *mut Dtvcc<'a> {
+    let opts = unsafe { opts_ptr.as_ref() }.expect("Unable to get dtvcc settings pointer");
     Box::into_raw(Box::new(Dtvcc::new(opts)))
 }
 
@@ -89,13 +87,11 @@ extern "C" fn ccxr_process_cc_data(
         .map(|x| unsafe { *data.add(x as usize) })
         .collect();
     let dec_ctx = unsafe { &mut *dec_ctx };
-    let dtvcc_ctx = unsafe { &mut *dec_ctx.dtvcc };
-    let mut dtvcc = Dtvcc::new(dtvcc_ctx);
     for cc_block in cc_data.chunks_exact_mut(3) {
         if !validate_cc_pair(cc_block) {
             continue;
         }
-        let success = do_cb(dec_ctx, &mut dtvcc, cc_block);
+        let success = do_cb(dec_ctx, cc_block);
         if success {
             ret = 0;
         }
@@ -139,7 +135,8 @@ pub fn verify_parity(data: u8) -> bool {
 }
 
 /// Process CC data according to its type
-pub fn do_cb(ctx: &mut lib_cc_decode, dtvcc: &mut Dtvcc, cc_block: &[u8]) -> bool {
+pub fn do_cb(ctx: &mut lib_cc_decode, cc_block: &[u8]) -> bool {
+    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;