demuxer: Rebase and a few tweaks to file_functions

Author: steel-bucket

src/rust/lib_ccxr/src/activity.rs

@@ -30,7 +30,7 @@ impl ActivityExt for Options {
     fn activity_input_file_open(&mut self, filename: &str) {
         if self.gui_mode_reports {
             let mut stderr = io::stderr();
-            writeln!(stderr, "###INPUTFILEOPEN#{}", filename).unwrap();
+            writeln!(stderr, "###INPUTFILEOPEN#{filename}").unwrap();
             stderr.flush().unwrap();
         }
     }

src/rust/src/ctorust.rs

@@ -1,19 +1,5 @@
 #![allow(clippy::unnecessary_cast)] // we have to do this as windows has different types for some C types
-use crate::bindings::{
-    cap_info, ccx_boundary_time, ccx_bufferdata_type, ccx_bufferdata_type_CCX_DVB_SUBTITLE,
-    ccx_bufferdata_type_CCX_DVD_SUBTITLE, ccx_bufferdata_type_CCX_H264,
-    ccx_bufferdata_type_CCX_HAUPPAGE, ccx_bufferdata_type_CCX_ISDB_SUBTITLE,
-    ccx_bufferdata_type_CCX_PES, ccx_bufferdata_type_CCX_PRIVATE_MPEG2_CC,
-    ccx_bufferdata_type_CCX_RAW, ccx_bufferdata_type_CCX_RAW_TYPE,
-    ccx_bufferdata_type_CCX_TELETEXT, ccx_bufferdata_type_CCX_UNKNOWN, ccx_code_type,
-    ccx_common_timing_ctx, ccx_decoder_608_color_code, ccx_decoder_608_color_code_COL_MAX,
-    ccx_decoder_608_report, ccx_decoder_608_settings, ccx_decoder_dtvcc_report,
-    ccx_decoder_dtvcc_settings, ccx_demux_report, ccx_encoders_transcript_format,
-    ccx_encoding_type, ccx_frame_type_CCX_FRAME_TYPE_B_FRAME,
-    ccx_frame_type_CCX_FRAME_TYPE_D_FRAME, ccx_frame_type_CCX_FRAME_TYPE_I_FRAME,
-    ccx_frame_type_CCX_FRAME_TYPE_P_FRAME, ccx_output_date_format, ccx_output_format, ccx_rational,
-    ccx_stream_mode_enum, demuxer_cfg, encoder_cfg, list_head, program_info, PMT_entry, PSI_buffer,
-};
+use crate::bindings::*;
 use crate::demuxer::common_structs::{
     CapInfo, CcxDemuxReport, CcxRational, PMTEntry, PSIBuffer, ProgramInfo,
 };
@@ -493,30 +479,47 @@ impl FromCType<ccx_encoding_type> for Encoding {
 // Implementation for DtvccServiceCharset
 impl FromCType<DtvccServiceCharsetArgs> for DtvccServiceCharset {
     unsafe fn from_ctype(args: DtvccServiceCharsetArgs) -> Option<Self> {
-        if args.services_charsets.is_null() || args.all_services_charset.is_null() {
-            return Some(DtvccServiceCharset::None);
+        // First check if all_services_charset is not null (Same variant)
+        if !args.all_services_charset.is_null() {
+            let charset_str = CStr::from_ptr(args.all_services_charset)
+                .to_string_lossy()
+                .into_owned();
+            return Some(DtvccServiceCharset::Same(charset_str));
         }
 
-        if *args.all_services_charset < ccx_decoder_608_color_code_COL_MAX as i8 {
-            let charset = format!("Charset_{}", *args.all_services_charset);
-            Some(DtvccServiceCharset::Same(charset))
-        } else {
-            let charsets_slice =
-                std::slice::from_raw_parts(args.services_charsets, DTVCC_MAX_SERVICES);
-            let mut charsets = Vec::new();
-            for &code in charsets_slice {
-                if *code < ccx_decoder_608_color_code_COL_MAX as i8 {
-                    charsets.push(format!("Charset_{:?}", code));
+        // Then check if services_charsets is not null (Unique variant)
+        if !args.services_charsets.is_null() {
+            let mut charsets = Vec::with_capacity(DTVCC_MAX_SERVICES);
+
+            // Read each string pointer from the array
+            for i in 0..DTVCC_MAX_SERVICES {
+                let str_ptr = *args.services_charsets.add(i);
+
+                let charset_str = if str_ptr.is_null() {
+                    // If individual string pointer is null, use empty string as fallback
+                    String::new()
                 } else {
-                    charsets.push("Invalid".to_string());
-                }
-            }
-            if let Ok(array) = charsets.try_into() {
-                Some(DtvccServiceCharset::Unique(Box::new(array)))
-            } else {
-                Some(DtvccServiceCharset::None)
+                    CStr::from_ptr(str_ptr).to_string_lossy().into_owned()
+                };
+
+                charsets.push(charset_str);
             }
+
+            // Convert Vec to Box<[String; DTVCC_MAX_SERVICES]>
+            let boxed_array = match charsets.try_into() {
+                Ok(array) => Box::new(array),
+                Err(_) => {
+                    // This should never happen since we allocated exactly DTVCC_MAX_SERVICES items
+                    // But as a fallback, create array filled with empty strings
+                    Box::new([const { String::new() }; DTVCC_MAX_SERVICES])
+                }
+            };
+
+            return Some(DtvccServiceCharset::Unique(boxed_array));
         }
+
+        // Both pointers are null, return None variant
+        Some(DtvccServiceCharset::None)
     }
 }
 

src/rust/src/decoder/output.rs

@@ -70,7 +70,7 @@ impl<'a> Writer<'a> {
     pub fn write_done(&mut self) {
         if self.write_format == ccx_output_format::CCX_OF_SAMI {
             if let Err(err) = self.write_sami_footer() {
-                warn!("{}", err);
+                warn!("{err}");
             }
         } else {
             debug!("dtvcc_write_done: no handling required");
@@ -107,8 +107,7 @@ pub fn color_to_hex(color: u8) -> (u8, u8, u8) {
     let green = (color >> 2) & 0x3;
     let blue = color & 0x3;
     debug!(
-        "Color: {} [{:06x}] {} {} {}",
-        color, color, red, green, blue
+        "Color: {color} [{color:06x}] {red} {green} {blue}"
     );
     (red, green, blue)
 }

src/rust/src/decoder/service_decoder.rs

@@ -115,7 +115,7 @@ impl dtvcc_service_decoder {
         let pd = match dtvcc_window_pd::new(window.attribs.print_direction) {
             Ok(val) => val,
             Err(e) => {
-                warn!("{}", e);
+                warn!("{e}");
                 return;
             }
         };
@@ -218,7 +218,7 @@ impl dtvcc_service_decoder {
         let pd = match dtvcc_window_pd::new(window.attribs.print_direction) {
             Ok(val) => val,
             Err(e) => {
-                warn!("{}", e);
+                warn!("{e}");
                 return;
             }
         };
@@ -283,7 +283,7 @@ impl dtvcc_service_decoder {
             return -1;
         }
 
-        debug!("C1: [{:?}] [{}] ({})", command, name, length);
+        debug!("C1: [{command:?}] [{name}] ({length})");
         match command {
             C1CodeSet::CW0
             | C1CodeSet::CW1
@@ -344,7 +344,7 @@ impl dtvcc_service_decoder {
             for i in 0..CCX_DTVCC_MAX_WINDOWS {
                 if windows_bitmap & 1 == 1 {
                     let window = &mut self.windows[i as usize];
-                    debug!("[W{}]", i);
+                    debug!("[W{i}]");
                     let window_had_content = is_true(window.is_defined)
                         && is_true(window.visible)
                         && is_false(window.is_empty);
@@ -381,7 +381,7 @@ impl dtvcc_service_decoder {
             for i in 0..CCX_DTVCC_MAX_WINDOWS {
                 if windows_bitmap & 1 == 1 {
                     let window = &mut self.windows[i as usize];
-                    debug!("[W{}]", i);
+                    debug!("[W{i}]");
                     if is_true(window.visible) {
                         screen_content_changed = true;
                         window.visible = 0;
@@ -418,11 +418,11 @@ impl dtvcc_service_decoder {
                 let window = &mut self.windows[i as usize];
                 if windows_bitmap & 1 == 1 && is_true(window.is_defined) {
                     if is_false(window.visible) {
-                        debug!("[W-{}: 0->1]", i);
+                        debug!("[W-{i}: 0->1]");
                         window.visible = 1;
                         window.update_time_show(timing);
                     } else {
-                        debug!("[W-{}: 1->0]", i);
+                        debug!("[W-{i}: 1->0]");
                         window.visible = 0;
                         window.update_time_hide(timing);
                         if is_false(window.is_empty) {
@@ -456,7 +456,7 @@ impl dtvcc_service_decoder {
         } else {
             for i in 0..CCX_DTVCC_MAX_WINDOWS {
                 if windows_bitmap & 1 == 1 {
-                    debug!("Deleting [W{}]", i);
+                    debug!("Deleting [W{i}]");
                     let window = &mut self.windows[i as usize];
                     let window_had_content = is_true(window.is_defined)
                         && is_true(window.visible)
@@ -501,9 +501,9 @@ impl dtvcc_service_decoder {
             for i in 0..CCX_DTVCC_MAX_WINDOWS {
                 if windows_bitmap & 1 == 1 {
                     let window = &mut self.windows[i as usize];
-                    debug!("[W{}]", i);
+                    debug!("[W{i}]");
                     if is_false(window.is_defined) {
-                        error!("Window {} was not defined", i);
+                        error!("Window {i} was not defined");
                         continue;
                     }
                     if is_false(window.visible) {
@@ -526,8 +526,7 @@ impl dtvcc_service_decoder {
         timing: &mut ccx_common_timing_ctx,
     ) {
         debug!(
-            "dtvcc_handle_DFx_DefineWindow: W[{}], attributes:",
-            window_id
+            "dtvcc_handle_DFx_DefineWindow: W[{window_id}], attributes:"
         );
         let window = &mut self.windows[window_id as usize];
         let block = &block[..=5];
@@ -562,12 +561,12 @@ impl dtvcc_service_decoder {
         let mut do_clear_window = false;
 
         debug!("Visible: [{}]", if is_true(visible) { "Yes" } else { "No" });
-        debug!("Priority: [{}]", priority);
-        debug!("Row count: [{}]", row_count);
-        debug!("Column count: [{}]", col_count);
-        debug!("Anchor point: [{}]", anchor_point);
-        debug!("Anchor vertical: [{}]", anchor_vertical);
-        debug!("Anchor horizontal: [{}]", anchor_horizontal);
+        debug!("Priority: [{priority}]");
+        debug!("Row count: [{row_count}]");
+        debug!("Column count: [{col_count}]");
+        debug!("Anchor point: [{anchor_point}]");
+        debug!("Anchor vertical: [{anchor_vertical}]");
+        debug!("Anchor horizontal: [{anchor_horizontal}]");
         debug!(
             "Relative pos: [{}]",
             if is_true(relative_pos) { "Yes" } else { "No" }
@@ -580,8 +579,8 @@ impl dtvcc_service_decoder {
             "Column lock: [{}]",
             if is_true(col_lock) { "Yes" } else { "No" }
         );
-        debug!("Pen style: [{}]", pen_style);
-        debug!("Win style: [{}]", win_style);
+        debug!("Pen style: [{pen_style}]");
+        debug!("Win style: [{win_style}]");
 
         // Korean samples have "anchor_vertical" and "anchor_horizontal" mixed up,
         // this seems to be an encoder issue, but we can workaround it
@@ -640,7 +639,7 @@ impl dtvcc_service_decoder {
                 for i in 0..CCX_DTVCC_MAX_ROWS as usize {
                     let layout = Layout::array::<dtvcc_symbol>(CCX_DTVCC_MAX_COLUMNS as usize);
                     if let Err(e) = layout {
-                        error!("dtvcc_handle_DFx_DefineWindow: Incorrect Layout, {}", e);
+                        error!("dtvcc_handle_DFx_DefineWindow: Incorrect Layout, {e}");
                     } else {
                         let ptr = unsafe { alloc(layout.unwrap()) };
                         if ptr.is_null() {
@@ -671,7 +670,7 @@ impl dtvcc_service_decoder {
             for i in 0..CCX_DTVCC_MAX_ROWS as usize {
                 let layout = Layout::array::<dtvcc_symbol>(CCX_DTVCC_MAX_COLUMNS as usize);
                 if let Err(e) = layout {
-                    error!("dtvcc_handle_DFx_DefineWindow: Incorrect Layout, {}", e);
+                    error!("dtvcc_handle_DFx_DefineWindow: Incorrect Layout, {e}");
                 } else {
                     unsafe { dealloc(window.rows[i] as *mut u8, layout.unwrap()) };
                 }
@@ -699,12 +698,10 @@ impl dtvcc_service_decoder {
         let italic = (block[1] >> 7) & 0x1;
         debug!("dtvcc_handle_SPA_SetPenAttributes: attributes: ");
         debug!(
-            "Pen size: [{}]     Offset: [{}]  Text tag: [{}]   Font tag: [{}]",
-            pen_size, offset, text_tag, font_tag
+            "Pen size: [{pen_size}]     Offset: [{offset}]  Text tag: [{text_tag}]   Font tag: [{font_tag}]"
         );
         debug!(
-            "Edge type: [{}]  Underline: [{}]    Italic: [{}]",
-            edge_type, underline, italic
+            "Edge type: [{edge_type}]  Underline: [{underline}]    Italic: [{italic}]"
         );
 
         let window = &mut self.windows[self.current_window as usize];
@@ -739,14 +736,12 @@ impl dtvcc_service_decoder {
         let edge_color = (block[2]) & 0x3f;
         debug!("dtvcc_handle_SPC_SetPenColor: attributes: ");
         debug!(
-            "Foreground color: [{}]     Foreground opacity: [{}]",
-            fg_color, fg_opacity
+            "Foreground color: [{fg_color}]     Foreground opacity: [{fg_opacity}]"
         );
         debug!(
-            "Background color: [{}]     Background opacity: [{}]",
-            bg_color, bg_opacity
+            "Background color: [{bg_color}]     Background opacity: [{bg_opacity}]"
         );
-        debug!("Edge color: [{}]", edge_color);
+        debug!("Edge color: [{edge_color}]");
 
         let window = &mut self.windows[self.current_window as usize];
         if window.pen_row == -1 {
@@ -774,7 +769,7 @@ impl dtvcc_service_decoder {
         debug!("dtvcc_handle_SPL_SetPenLocation: attributes: ");
         let row = block[0] & 0x0f;
         let col = block[1] & 0x3f;
-        debug!("Row: [{}]     Column: [{}]", row, col);
+        debug!("Row: [{row}]     Column: [{col}]");
 
         let window = &mut self.windows[self.current_window as usize];
         window.pen_row = row as i32;
@@ -804,16 +799,13 @@ impl dtvcc_service_decoder {
         let effect_speed = (block[3] >> 4) & 0x0f;
         debug!("dtvcc_handle_SWA_SetWindowAttributes: attributes: ");
         debug!(
-            "Fill color: [{}]     Fill opacity: [{}]    Border color: [{}]  Border type: [{}]",
-            fill_color, fill_opacity, border_color, border_type
+            "Fill color: [{fill_color}]     Fill opacity: [{fill_opacity}]    Border color: [{border_color}]  Border type: [{border_type}]"
         );
         debug!(
-            "Justify: [{}]       Scroll dir: [{}]       Print dir: [{}]    Word wrap: [{}]",
-            justify, scroll_dir, print_dir, word_wrap
+            "Justify: [{justify}]       Scroll dir: [{scroll_dir}]       Print dir: [{print_dir}]    Word wrap: [{word_wrap}]"
         );
         debug!(
-            "Border type: [{}]      Display eff: [{}]      Effect dir: [{}] Effect speed: [{}]",
-            border_type, display_eff, effect_dir, effect_speed
+            "Border type: [{border_type}]      Display eff: [{display_eff}]      Effect dir: [{effect_dir}] Effect speed: [{effect_speed}]"
         );
 
         let window_attribts = &mut self.windows[self.current_window as usize].attribs;
@@ -834,22 +826,20 @@ impl dtvcc_service_decoder {
     ///
     /// Change current window to the window id provided
     pub fn handle_set_current_window(&mut self, window_id: u8) {
-        debug!("dtvcc_handle_CWx_SetCurrentWindow: [{}]", window_id);
+        debug!("dtvcc_handle_CWx_SetCurrentWindow: [{window_id}]");
         if is_true(self.windows[window_id as usize].is_defined) {
             self.current_window = window_id as i32;
         } else {
             debug!(
-                "dtvcc_handle_CWx_SetCurrentWindow: window [{}] is not defined",
-                window_id
+                "dtvcc_handle_CWx_SetCurrentWindow: window [{window_id}] is not defined"
             );
         }
     }
 
     /// DLY Delay
     pub fn handle_delay(&mut self, tenths_of_sec: u8) {
         debug!(
-            "dtvcc_handle_DLY_Delay: dely for {} tenths of second",
-            tenths_of_sec
+            "dtvcc_handle_DLY_Delay: dely for {tenths_of_sec} tenths of second"
         );
     }
 
@@ -910,7 +900,7 @@ impl dtvcc_service_decoder {
         let anchor = match dtvcc_pen_anchor_point::new(window.anchor_point) {
             Ok(val) => val,
             Err(e) => {
-                warn!("{}", e);
+                warn!("{e}");
                 return;
             }
         };
@@ -955,7 +945,7 @@ impl dtvcc_service_decoder {
             "For window {}: Anchor point -> {}, size {}:{}, real position {}:{}",
             window.number, window.anchor_point, window.row_count, window.col_count, top, left
         );
-        debug!("we have top [{}] and left [{}]", top, left);
+        debug!("we have top [{top}] and left [{left}]");
         if top < 0 {
             top = 0
         }
@@ -972,7 +962,7 @@ impl dtvcc_service_decoder {
         } else {
             window.col_count
         };
-        debug!("{}*{} will be copied to the TV.", copy_rows, copy_cols);
+        debug!("{copy_rows}*{copy_cols} will be copied to the TV.");
 
         unsafe {
             let tv = &mut *self.tv;
@@ -997,7 +987,7 @@ impl dtvcc_service_decoder {
         let (a_x1, a_x2, a_y1, a_y2) = match window.get_dimensions() {
             Ok(val) => val,
             Err(e) => {
-                warn!("{}", e);
+                warn!("{e}");
                 return false;
             }
         };
@@ -1006,7 +996,7 @@ impl dtvcc_service_decoder {
             let (b_x1, b_x2, b_y1, b_y2) = match win_compare.get_dimensions() {
                 Ok(val) => val,
                 Err(e) => {
-                    warn!("{}", e);
+                    warn!("{e}");
                     return false;
                 }
             };
@@ -1156,7 +1146,7 @@ impl dtvcc_service_decoder {
         let pd = match dtvcc_window_pd::new(window.attribs.print_direction) {
             Ok(val) => val,
             Err(e) => {
-                warn!("{}", e);
+                warn!("{e}");
                 return;
             }
         };