Windows failing tests

Author: steel-bucket

src/rust/lib_ccxr/src/activity.rs

@@ -1,9 +1,9 @@
+#![allow(static_mut_refs)] // Temporary fix for mutable static variable
 use std::io;
 use std::io::Write;
 
 use crate::common::Options;
 use std::sync::atomic::{AtomicUsize, Ordering};
-
 pub static mut NET_ACTIVITY_GUI: AtomicUsize = AtomicUsize::new(0);
 
 pub trait ActivityExt {

src/rust/lib_ccxr/src/demuxer/demux.rs

@@ -1,6 +1,7 @@
 #![allow(non_camel_case_types)]
 #![allow(unexpected_cfgs)]
 #![allow(unused_mut)]
+#![allow(clippy::needless_lifetimes)]
 
 use crate::activity::ActivityExt;
 use crate::common::{
@@ -851,7 +852,7 @@ impl<'a> CcxDemuxer<'a> {
 }
 
 /// This function returns the file size for a given demuxer.
-/// Translated from the C function `ccx_demuxer_get_file_size`.
+/// C function `ccx_demuxer_get_file_size`.
 /// LLONG is `int64_t`, so we use `i64` in Rust.
 pub fn ccx_demuxer_get_file_size(ctx: &mut CcxDemuxer) -> i64 {
     // Get the file descriptor from ctx.
@@ -873,7 +874,10 @@ pub fn ccx_demuxer_get_file_size(ctx: &mut CcxDemuxer) -> i64 {
         Ok(pos) => pos,
         Err(_) => {
             // Return the fd back and then -1.
+            #[cfg(unix)]
             let _ = file.into_raw_fd();
+            #[cfg(windows)]
+            let _ = file.into_raw_handle();
             return -1;
         }
     };
@@ -882,7 +886,10 @@ pub fn ccx_demuxer_get_file_size(ctx: &mut CcxDemuxer) -> i64 {
     let length = match file.seek(SeekFrom::End(0)) {
         Ok(pos) => pos,
         Err(_) => {
+            #[cfg(unix)]
             let _ = file.into_raw_fd();
+            #[cfg(windows)]
+            let _ = file.into_raw_handle();
             return -1;
         }
     };
@@ -896,24 +903,30 @@ pub fn ccx_demuxer_get_file_size(ctx: &mut CcxDemuxer) -> i64 {
     let ret = match file.seek(SeekFrom::Start(current)) {
         Ok(pos) => pos,
         Err(_) => {
+            #[cfg(unix)]
             let _ = file.into_raw_fd();
+            #[cfg(windows)]
+            let _ = file.into_raw_handle();
             return -1;
         }
     };
 
     // Return the fd back to its original owner.
+    #[cfg(unix)]
     let _ = file.into_raw_fd();
+    #[cfg(windows)]
+    let _ = file.into_raw_handle();
     length as i64
 }
 
-/// Translated from the C function `ccx_demuxer_get_stream_mode`.
+/// C function `ccx_demuxer_get_stream_mode`.
 /// Returns the current stream mode.
 pub fn ccx_demuxer_get_stream_mode(ctx: &CcxDemuxer) -> i32 {
     // return ctx->stream_mode;
     ctx.stream_mode as i32
 }
 
-/// Translated from the C function `ccx_demuxer_print_cfg`.
+/// C function `ccx_demuxer_print_cfg`.
 /// Prints the current `auto_stream` mode for the demuxer.
 // Note: `#ifdef WTV_DEBUG` becomes `#[cfg(feature = "wtv_debug")]` in Rust.
 pub fn ccx_demuxer_print_cfg(ctx: &CcxDemuxer) {
@@ -973,7 +986,7 @@ fn y_n(count: i32) -> &'static str {
     }
 }
 
-/// Translated version of the C `print_file_report` function, preserving structure
+/// C `print_file_report` function, preserving structure
 /// and replacing `#ifdef` with `#[cfg(feature = "wtv_debug")]`.
 /// Uses `printf` from libc.
 pub fn print_file_report(ctx: &mut LibCcxCtx) {
@@ -1089,9 +1102,9 @@ pub fn print_file_report(ctx: &mut LibCcxCtx) {
             // dec_ctx = update_decoder_list_cinfo(ctx, best_info); // TODO
             if (*dec_ctx).in_bufferdatatype == BufferdataType::Pes
                 && (demux_ctx.stream_mode == StreamMode::Transport
-                || demux_ctx.stream_mode == StreamMode::Program
-                || demux_ctx.stream_mode == StreamMode::Asf
-                || demux_ctx.stream_mode == StreamMode::Wtv)
+                    || demux_ctx.stream_mode == StreamMode::Program
+                    || demux_ctx.stream_mode == StreamMode::Asf
+                    || demux_ctx.stream_mode == StreamMode::Wtv)
             {
                 println!("Width: {}", (*dec_ctx).current_hor_size);
                 println!("Height: {}", (*dec_ctx).current_vert_size);
@@ -1120,7 +1133,7 @@ pub fn print_file_report(ctx: &mut LibCcxCtx) {
         ptr::write_bytes(&mut ctx.freport as *mut FileReport, 0, 1);
     }
 }
-
+#[allow(clippy::manual_c_str_literals)]
 pub fn get_desc_placeholder(_index: usize) -> *const i8 {
     b"Unknown\0".as_ptr() as *const i8
 }
@@ -1259,7 +1272,7 @@ mod tests {
                 DebugMessageMask::new(DebugMessageFlag::VERBOSE, DebugMessageFlag::VERBOSE),
                 false,
             ))
-                .ok();
+            .ok();
         });
     }
     #[test]

src/rust/lib_ccxr/src/demuxer/lib_ccx.rs

@@ -1,3 +1,4 @@
+#![allow(clippy::needless_lifetimes)]
 use crate::common::{Decoder608Report, DecoderDtvccReport, OutputFormat};
 use crate::demuxer::demux::{CcxDemuxer, DecodersCommonSettings, EITProgram, HList, PSI_buffer};
 

src/rust/lib_ccxr/src/demuxer/stream_functions.rs

@@ -351,7 +351,7 @@ pub fn detect_myth(ctx: &mut CcxDemuxer) -> i32 {
     0
 }
 
-/// Translated version of the C `isValidMP4Box` function with comments preserved.
+/// C `isValidMP4Box` function
 pub fn is_valid_mp4_box(
     buffer: &[u8],
     position: usize,

src/rust/lib_ccxr/src/file_functions/file.rs

@@ -1,5 +1,6 @@
-#![allow(unexpected_cfgs)]
-#![allow(unused_mut)]
+#![allow(unexpected_cfgs)] // Temporary
+#![allow(unused_mut)] // Temporary
+#![allow(static_mut_refs)] // Temporary fix for mutable static variable
 
 use crate::activity::{update_net_activity_gui, ActivityExt, NET_ACTIVITY_GUI};
 use crate::common::{DataSource, Options};
@@ -45,18 +46,31 @@ pub fn position_sanity_check(ctx: &mut CcxDemuxer) {
 
             let fd = ctx.infd;
             // Convert raw fd to a File without taking ownership
+            #[cfg(unix)]
             let mut file = unsafe { File::from_raw_fd(fd) };
+            #[cfg(windows)]
+            let mut file = unsafe { File::from_raw_handle(fd as *mut _) };
             let realpos_result = file.seek(SeekFrom::Current(0));
             let realpos = match realpos_result {
                 Ok(pos) => pos as i64, // Convert to i64 to match C's LLONG
                 Err(_) => {
                     // Return the fd to avoid closing it
-                    let _ = file.into_raw_fd();
+                    #[cfg(unix)]
+                    {
+                        let _ = file.into_raw_fd();
+                    }
+                    #[cfg(windows)]
+                    {
+                        let _ = file.into_raw_handle();
+                    }
                     return;
                 }
             };
             // Return the fd to avoid closing it
+            #[cfg(unix)]
             let _ = file.into_raw_fd();
+            #[cfg(windows)]
+            let _ = file.into_raw_handle();
 
             let expected_pos = ctx.past - ctx.filebuffer_pos as i64 + ctx.bytesinbuffer as i64;
 
@@ -707,7 +721,10 @@ mod tests {
         // Create temp file
         let mut file = tempfile().unwrap();
         file.write_all(b"test data").unwrap();
+        #[cfg(unix)]
         let fd = file.into_raw_fd(); // Now owns the fd
+        #[cfg(windows)]
+        let fd = file.into_raw_handle(); // Now owns the handle
 
         // SAFETY: Initialize directly on heap without stack intermediate
         let mut ctx = Box::new(CcxDemuxer::default());
@@ -722,11 +739,17 @@ mod tests {
         // Example for one array - repeat for others:
         ctx.startbytes = vec![0u8; STARTBYTESLENGTH];
         // Set file position
+        #[cfg(unix)]
         let mut file = unsafe { File::from_raw_fd(fd) };
+        #[cfg(windows)]
+        let mut file = unsafe { File::from_raw_handle(fd as *mut _) };
         file.seek(SeekFrom::Start(130)).unwrap();
 
         // Prevent double-closing when 'file' drops
+        #[cfg(unix)]
         let _ = file.into_raw_fd();
+        #[cfg(windows)]
+        let _ = file.into_raw_handle();
 
         // Run test
         position_sanity_check(&mut ctx);
@@ -900,7 +923,14 @@ mod tests {
             .expect("Unable to seek to start");
         // Get the file descriptor. Ensure the file stays open.
         let file = tmp.reopen().expect("Unable to reopen temp file");
-        file.into_raw_fd()
+        #[cfg(unix)]
+        {
+            file.into_raw_fd()
+        }
+        #[cfg(windows)]
+        {
+            file.into_raw_handle() as i32
+        }
     }
 
     // Dummy allocation for filebuffer.

src/rust/lib_ccxr/src/gxf_demuxer/gxf.rs

@@ -1315,8 +1315,7 @@ pub unsafe fn parse_ad_field(demux: &mut CcxDemuxer, mut len: i32, data: &mut De
     ret
 }
 
-/**
- *  @param vid_format following format are supported to set valid timebase
+/* *  @param vid_format following format are supported to set valid timebase
  *  in demuxer data
  *  value   |  Meaning
  *=====================================
@@ -1346,7 +1345,6 @@ pub unsafe fn parse_ad_field(demux: &mut CcxDemuxer, mut len: i32, data: &mut De
  *        data len may be zero, while setting timebase we don not care about
  *        actual data
  */
-
 pub fn set_data_timebase(vid_format: i32, data: &mut DemuxerData) {
     dbg!("LOG: Format Video {}", vid_format);
 
@@ -1554,11 +1552,8 @@ pub unsafe fn parse_ad_packet(demux: &mut CcxDemuxer, len: i32, data: &mut Demux
  *    |          4:7                |      Not Used MUST be 0     |
  *    +-----------------------------+-----------------------------+
  */
-/// Translated version of the C `set_mpeg_frame_desc` function.
-
+/// C `set_mpeg_frame_desc` function.
 pub fn set_mpeg_frame_desc(vid_track: &mut CcxGxfVideoTrack, mpeg_frame_desc_flag: u8) {
-    // vid_track.p_code = MpegPictureCoding::from(mpeg_frame_desc_flag & 0x03);
-    // vid_track.p_struct = MpegPictureStruct::from((mpeg_frame_desc_flag >> 2) & 0x03);
     vid_track.p_code = MpegPictureCoding::try_from(mpeg_frame_desc_flag & 0x03).unwrap();
     vid_track.p_struct = MpegPictureStruct::try_from((mpeg_frame_desc_flag >> 2) & 0x03).unwrap();
 }
@@ -2008,7 +2003,14 @@ mod tests {
             .expect("Unable to seek to start");
         // Get the file descriptor. Ensure the file stays open.
         let file = tmp.reopen().expect("Unable to reopen temp file");
-        file.into_raw_fd()
+        #[cfg(unix)]
+        {
+            file.into_raw_fd()
+        }
+        #[cfg(windows)]
+        {
+            file.into_raw_handle() as i32
+        }
     }
     /// Create a dummy CcxDemuxer with a filebuffer containing `header_data`.
     fn create_ccx_demuxer_with_header(header_data: &[u8]) -> CcxDemuxer<'static> {