Merge branch 'master' into fix/networking-debug-out-and-stderr

Author: Varadraj75

docs/CHANGES.TXT

@@ -1,6 +1,7 @@
 0.96.7 (unreleased)
 -------------------
 - Fix: Replace DEBUG_OUT 0/1 integer toggle in networking.c with CMake opt-in (-DNETWORKING_DEBUG=ON); fix 3 error messages using printf() instead of fprintf(stderr) (#2174)
+- Fix: Remove strdup() memory leaks in WebVTT styling encoder, fix invalid CSS rgba(0,256,0) green value, fix missing free(unescaped) on write-error path (#2154)
 - Fix: Prevent crash in Rust timing module when logging out-of-range PTS/FTS timestamps from malformed streams.
 
 0.96.6 (2026-02-19)

src/lib_ccx/ccx_encoders_srt.c

@@ -47,7 +47,7 @@ static int write_stringz_as_srt_to_output(char *string, struct encoder_ctx *cont
 	// Scan for \n in the string and replace it with a 0
 	while (pos_r < len)
 	{
-		if (string[pos_r] == '\\' && string[pos_r + 1] == 'n')
+		if (pos_r < len - 1 && string[pos_r] == '\\' && string[pos_r + 1] == 'n')
 		{
 			unescaped[pos_w] = 0;
 			pos_r += 2;
@@ -62,7 +62,7 @@ static int write_stringz_as_srt_to_output(char *string, struct encoder_ctx *cont
 	unescaped[pos_w] = 0;
 	// Now read the unescaped string (now several string'z and write them)
 	unsigned char *begin = unescaped;
-	while (begin < unescaped + len)
+	while (begin < unescaped + pos_w)
 	{
 		unsigned int u = encode_line(context, el, begin);
 		if (context->encoding != CCX_ENC_UNICODE)

src/lib_ccx/ccx_encoders_webvtt.c

@@ -94,7 +94,7 @@ static const char *webvtt_inline_css = "\r\nSTYLE\n\n"
 				       "  background-color: rgba(255, 255, 255, 0.5);\n"
 				       "}\n"
 				       "::cue(c.bg_green.bg_semi-transparent) {\n"
-				       "  background-color: rgba(0, 256, 0, 0.5);\n"
+				       "  background-color: rgba(0, 255, 0, 0.5);\n"
 				       "}\n"
 				       "::cue(c.bg_blue.bg_semi-transparent) {\n"
 				       "  background-color: rgba(0, 0, 255, 0.5);\n"
@@ -189,6 +189,7 @@ int write_stringz_as_webvtt(char *string, struct encoder_ctx *context, LLONG ms_
 		if (written != context->encoded_crlf_length)
 		{
 			free(el);
+			free(unescaped);
 			return -1;
 		}
 		begin += strlen((const char *)begin) + 1;
@@ -502,16 +503,16 @@ int write_cc_buffer_as_webvtt(struct eia608_screen *data, struct encoder_ctx *co
 					if (open_font != FONT_REGULAR)
 					{
 						if (open_font & FONT_ITALICS)
-							write_wrapped(context->out->fh, strdup("<i>"), 3);
+							write_wrapped(context->out->fh, "<i>", 3);
 						if (open_font & FONT_UNDERLINED)
-							write_wrapped(context->out->fh, strdup("<u>"), 3);
+							write_wrapped(context->out->fh, "<u>", 3);
 					}
 
 					// opening events for colors
 					int open_color = color_events[j] & 0xFF; // Last 16 bytes
 					if (open_color != COL_WHITE)
 					{
-						write_wrapped(context->out->fh, strdup("<c."), 3);
+						write_wrapped(context->out->fh, "<c.", 3);
 						write_wrapped(context->out->fh, color_text[open_color][0], strlen(color_text[open_color][0]));
 						write_wrapped(context->out->fh, ">", 1);
 					}
@@ -532,17 +533,17 @@ int write_cc_buffer_as_webvtt(struct eia608_screen *data, struct encoder_ctx *co
 					int close_color = color_events[j] >> 16; // First 16 bytes
 					if (close_color != COL_WHITE)
 					{
-						write_wrapped(context->out->fh, strdup("</c>"), 4);
+						write_wrapped(context->out->fh, "</c>", 4);
 					}
 
 					// closing events for fonts
 					int close_font = font_events[j] >> 16; // First 16 bytes
 					if (close_font != FONT_REGULAR)
 					{
 						if (close_font & FONT_UNDERLINED)
-							write_wrapped(context->out->fh, strdup("</u>"), 4);
+							write_wrapped(context->out->fh, "</u>", 4);
 						if (close_font & FONT_ITALICS)
-							write_wrapped(context->out->fh, strdup("</i>"), 4);
+							write_wrapped(context->out->fh, "</i>", 4);
 					}
 				}
 			}

src/lib_ccx/utility.c

@@ -269,6 +269,13 @@ void sleep_secs(int secs)
 #endif
 }
 
+#ifndef DISABLE_RUST
+extern int ccxr_hex_to_int(char high, char low);
+int hex_to_int(char high, char low)
+{
+	return ccxr_hex_to_int(high, low);
+}
+#else
 int hex_to_int(char high, char low)
 {
 	unsigned char h, l;
@@ -286,6 +293,15 @@ int hex_to_int(char high, char low)
 		return -1;
 	return h * 16 + l;
 }
+#endif
+
+#ifndef DISABLE_RUST
+extern int ccxr_hex_string_to_int(const char *string, int len);
+int hex_string_to_int(char *string, int len)
+{
+	return ccxr_hex_string_to_int(string, len);
+}
+#else
 int hex_string_to_int(char *string, int len)
 {
 	int total_return = 0;
@@ -302,6 +318,7 @@ int hex_string_to_int(char *string, int len)
 	}
 	return total_return;
 }
+#endif
 
 #ifndef _WIN32
 void m_signal(int sig, void (*func)(int))

src/rust/lib_ccxr/src/util/hex.rs

@@ -0,0 +1,51 @@
+/// Converts a single hex character to its integer value.
+/// Returns None if the character is not valid (0-9, a-f, or A-F).
+fn hex_char_to_val(c: char) -> Option<i32> {
+    match c {
+        '0'..='9' => Some(c as i32 - '0' as i32),
+        'a'..='f' => Some(c as i32 - 'a' as i32 + 10),
+        'A'..='F' => Some(c as i32 - 'A' as i32 + 10),
+        _ => None,
+    }
+}
+
+/// Converts two hex characters into a combined integer value.
+/// Returns None if either character is invalid.
+pub fn hex_to_int(high: char, low: char) -> Option<i32> {
+    let h = hex_char_to_val(high)?;
+    let l = hex_char_to_val(low)?;
+    Some(h * 16 + l)
+}
+
+pub fn hex_string_to_int(string: &str, len: usize) -> Option<i32> {
+    let mut result = 0;
+    for c in string.chars().take(len) {
+        result = result * 16 + hex_char_to_val(c)?;
+    }
+    Some(result)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_hex_to_int() {
+        assert_eq!(hex_to_int('4', 'f'), Some(79));
+        assert_eq!(hex_to_int('0', '0'), Some(0));
+        assert_eq!(hex_to_int('f', 'f'), Some(255));
+        assert_eq!(hex_to_int('A', 'F'), Some(175));
+        assert_eq!(hex_to_int('z', '1'), None);
+    }
+
+    #[test]
+    fn test_hex_string_to_int() {
+        assert_eq!(hex_string_to_int("4f", 2), Some(79));
+        assert_eq!(hex_string_to_int("ff", 2), Some(255));
+        assert_eq!(hex_string_to_int("00", 2), Some(0));
+        assert_eq!(hex_string_to_int("ffff", 4), Some(65535));
+        assert_eq!(hex_string_to_int("4f", 1), Some(4));
+        assert_eq!(hex_string_to_int("FF", 2), Some(255));
+        assert_eq!(hex_string_to_int("zz", 2), None);
+    }
+}

src/rust/lib_ccxr/src/util/mod.rs

@@ -13,6 +13,7 @@
 pub mod bits;
 pub mod encoders_helper;
 pub mod encoding;
+pub mod hex;
 pub mod levenshtein;
 pub mod log;
 pub mod time;

src/rust/src/encoder/g608.rs

@@ -191,9 +191,20 @@ pub fn write_cc_buffer_as_g608(data: &eia608_screen, context: &mut encoder_ctx)
     }
 
     // Create timeline string for timestamps
-    let timestamp_line = format!(
-        "{h1:02}:{m1:02}:{s1:02},{ms1:03} --> {h2:02}:{m2:02}:{s2:02},{ms2:03}{encoded_clrf}"
-    );
+    let is_webvtt = context.write_format == crate::bindings::ccx_output_format::CCX_OF_WEBVTT;
+
+    let timestamp_line = if is_webvtt {
+        // WebVTT Standard requires dots instead of commas for milliseconds
+        // and supports trailing settings (e.g., vertical text direction, alignment)
+        format!(
+            "{h1:02}:{m1:02}:{s1:02}.{ms1:03} --> {h2:02}:{m2:02}:{s2:02}.{ms2:03}{encoded_clrf}"
+        )
+    } else {
+        // Legacy SRT Standard requires commas
+        format!(
+            "{h1:02}:{m1:02}:{s1:02},{ms1:03} --> {h2:02}:{m2:02}:{s2:02},{ms2:03}{encoded_clrf}"
+        )
+    };
 
     // Encode and write timestamp line
     let used = encode_line(context, buffer_slice, timestamp_line.as_bytes());

src/rust/src/libccxr_exports/mod.rs

@@ -129,3 +129,4 @@ pub unsafe extern "C" fn ccxr_levenshtein_dist_char(
 
     ans.min(c_int::MAX as usize) as c_int
 }
+pub mod util;

src/rust/src/libccxr_exports/util.rs

@@ -0,0 +1,27 @@
+use std::ffi::{c_char, c_int};
+
+/// Rust equivalent for `hex_to_int` function in C. Uses C-native types as input and output.
+///
+/// # Safety
+///
+/// `high` and `low` must be valid ASCII characters. Invalid characters will
+/// return -1 rather than causing undefined behavior.
+#[no_mangle]
+pub unsafe extern "C" fn ccxr_hex_to_int(high: c_char, low: c_char) -> c_int {
+    lib_ccxr::util::hex::hex_to_int(high as u8 as char, low as u8 as char).unwrap_or(-1)
+}
+
+/// Rust equivalent for `hex_string_to_int` function in C. Uses C-native types as input and output.
+///
+/// # Safety
+///
+/// `string` must be a valid null-terminated C string. If null, returns -1.
+/// Invalid hex characters will return -1 rather than causing undefined behavior.
+#[no_mangle]
+pub unsafe extern "C" fn ccxr_hex_string_to_int(string: *const c_char, len: c_int) -> c_int {
+    if string.is_null() {
+        return -1;
+    }
+    let s = std::ffi::CStr::from_ptr(string).to_str().unwrap_or("");
+    lib_ccxr::util::hex::hex_string_to_int(s, len as usize).unwrap_or(-1)
+}