Merge branch 'CCExtractor:master' into test

Rahul-2k4 · web-flow · commit 9e816a10effc · 2025-12-19T22:02:35.000+05:30
diff --git a/CI_TRIAGE_DEC_2025.md b/CI_TRIAGE_DEC_2025.md
@@ -0,0 +1,26 @@
+# CI Test Triage - December 2025
+
+This PR is used to trigger CI runs and track the triage of failing regression tests.
+
+## Purpose
+
+Several PRs have been merged recently that improved CCExtractor behavior, but the Sample Platform
+considers them regressions because the "ground truth" baseline is outdated. This PR helps:
+
+1. Get a fresh CI run against current master
+2. Systematically analyze each failing test
+3. Determine whether to update ground truth or fix code
+
+## Merged Fixes
+
+The following PRs have been merged and this run verifies their combined effect:
+
+- **PR #1847**: Hardsubx crash fix, memory leak fixes, rcwt exit code fix
+- **PR #1848**: XDS empty content entries fix
+
+## Status
+
+- [x] PR #1847 merged
+- [x] PR #1848 merged
+- [ ] Verification CI run triggered
+- [ ] Results analyzed
diff --git a/src/ccextractor.c b/src/ccextractor.c
@@ -2,6 +2,8 @@
 /* CCExtractor, originally by carlos at ccextractor.org, now a lot of people.
 Credits: See AUTHORS.TXT
 License: GPL 2.0
+
+CI verification run: 2025-12-19T08:30 - Testing merged fixes from PRs #1847 and #1848
 */
 #include "ccextractor.h"
 #include <stdio.h>
diff --git a/src/lib_ccx/ccx_decoders_xds.c b/src/lib_ccx/ccx_decoders_xds.c
@@ -472,14 +472,17 @@ void xds_do_content_advisory(struct cc_subtitle *sub, struct ccx_decoders_xds_co
 	if (!a1 && a0) // US TV parental guidelines
 	{
 		xdsprint(sub, ctx, age);
-		xdsprint(sub, ctx, content);
+		if (content[0]) // Only output content if not empty
+			xdsprint(sub, ctx, content);
 		if (changed)
 		{
 			ccx_common_logging.log_ftn("\rXDS: %s\n  ", age);
-			ccx_common_logging.log_ftn("\rXDS: %s\n  ", content);
+			if (content[0])
+				ccx_common_logging.log_ftn("\rXDS: %s\n  ", content);
 		}
 		ccx_common_logging.debug_ftn(CCX_DMT_DECODER_XDS, "\rXDS: %s\n", age);
-		ccx_common_logging.debug_ftn(CCX_DMT_DECODER_XDS, "\rXDS: %s\n", content);
+		if (content[0])
+			ccx_common_logging.debug_ftn(CCX_DMT_DECODER_XDS, "\rXDS: %s\n", content);
 	}
 	if (!a0 ||			  // MPA
 	    (a0 && a1 && !Da2 && !La3) || // Canadian English Language Rating
diff --git a/src/lib_ccx/general_loop.c b/src/lib_ccx/general_loop.c
@@ -1402,9 +1402,12 @@ int rcwt_loop(struct lib_ccx_ctx *ctx)
 	dec_sub = &dec_ctx->dec_sub;
 	telctx = dec_ctx->private_data;
 
-	/* Set minimum and current pts since rcwt has correct time */
+	/* Set minimum and current pts since rcwt has correct time.
+	 * Also set pts_set = 2 (MinPtsSet) so the Rust timing code knows
+	 * that min_pts is valid and can calculate fts_now properly. */
 	dec_ctx->timing->min_pts = 0;
 	dec_ctx->timing->current_pts = 0;
+	dec_ctx->timing->pts_set = 2; // 2 = min_pts set
 
 	// Loop until no more data is found
 	while (1)
@@ -1489,6 +1492,17 @@ int rcwt_loop(struct lib_ccx_ctx *ctx)
 	} // end while(1)
 
 	dbg_print(CCX_DMT_PARSE, "Processed %d bytes\n", bread);
+
+	/* Check if captions were found via other paths (CEA-608 writes directly
+	   to encoder without setting got_output). Similar to general_loop logic. */
+	if (!caps && enc_ctx != NULL)
+	{
+		if (enc_ctx->srt_counter || enc_ctx->cea_708_counter || dec_ctx->saw_caption_block)
+		{
+			caps = 1;
+		}
+	}
+
 	/* Free XDS context - similar to cleanup in general_loop */
 	free(dec_ctx->xds_ctx);
 	free(parsebuf);
diff --git a/src/lib_ccx/hardsubx.c b/src/lib_ccx/hardsubx.c
@@ -121,6 +121,8 @@ int hardsubx_process_data(struct lib_hardsubx_ctx *ctx, struct lib_ccx_ctx *ctx_
 
 	// Free the allocated memory for frame processing
 	av_free(ctx->rgb_buffer);
+	if (ctx->sws_ctx)
+		sws_freeContext(ctx->sws_ctx);
 	if (ctx->frame)
 		av_frame_free(&ctx->frame);
 	if (ctx->rgb_frame)
@@ -283,7 +285,7 @@ struct lib_hardsubx_ctx *_init_hardsubx(struct ccx_s_options *options)
 
 	free(pars_vec);
 	free(pars_values);
-	free(tessdata_path);
+	// Note: tessdata_path points to static string or getenv() result, do NOT free
 	if (ret != 0)
 	{
 		free(ctx);
@@ -336,8 +338,11 @@ void _dinit_hardsubx(struct lib_hardsubx_ctx **ctx)
 	TessBaseAPIEnd(lctx->tess_handle);
 	TessBaseAPIDelete(lctx->tess_handle);
 
+	// Free basefilename (allocated by get_basename in _init_hardsubx)
+	freep(&lctx->basefilename);
+
 	// Free subtitle
-	freep(lctx->dec_sub);
+	freep(&lctx->dec_sub);
 	freep(ctx);
 }
 
diff --git a/src/lib_ccx/hardsubx.h b/src/lib_ccx/hardsubx.h
@@ -116,6 +116,10 @@ int64_t convert_pts_to_s(int64_t pts, AVRational time_base);
 int is_valid_trailing_char(char c);
 char *prune_string(char *s);
 
+// Rust memory management - strings returned from Rust must be freed with this function
+// DO NOT use free() on strings returned from _process_frame_white_basic, _process_frame_color_basic, etc.
+void free_rust_c_string(char *ptr);
+
 #endif
 
 #endif
diff --git a/src/lib_ccx/hardsubx_decoder.c b/src/lib_ccx/hardsubx_decoder.c
@@ -210,6 +210,7 @@ void hardsubx_process_frames_linear(struct lib_hardsubx_ctx *ctx, struct encoder
 						if (dist < (0.2 * MIN(strlen(subtitle_text), strlen(prev_subtitle_text))))
 						{
 							dist = -1;
+							free_rust_c_string(subtitle_text);
 							subtitle_text = NULL;
 							prev_end_time = convert_pts_to_ms(ctx->packet.pts, ctx->format_ctx->streams[ctx->video_stream_id]->time_base);
 						}
@@ -219,6 +220,7 @@ void hardsubx_process_frames_linear(struct lib_hardsubx_ctx *ctx, struct encoder
 						add_cc_sub_text(ctx->dec_sub, prev_subtitle_text, prev_begin_time, prev_end_time, "", "BURN", CCX_ENC_UTF_8);
 						encode_sub(enc_ctx, ctx->dec_sub);
 						prev_begin_time = prev_end_time + 1;
+						free(prev_subtitle_text);
 						prev_subtitle_text = NULL;
 						prev_sub_encoded = 1;
 						prev_end_time = convert_pts_to_ms(ctx->packet.pts, ctx->format_ctx->streams[ctx->video_stream_id]->time_base);
@@ -252,6 +254,10 @@ void hardsubx_process_frames_linear(struct lib_hardsubx_ctx *ctx, struct encoder
 					prev_sub_encoded = 0;
 				}
 				prev_packet_pts = ctx->packet.pts;
+
+				// Free subtitle_text from this iteration (was allocated by Rust in _process_frame_*_basic)
+				free_rust_c_string(subtitle_text);
+				subtitle_text = NULL;
 			}
 		}
 		av_packet_unref(&ctx->packet);
@@ -263,6 +269,9 @@ void hardsubx_process_frames_linear(struct lib_hardsubx_ctx *ctx, struct encoder
 		encode_sub(enc_ctx, ctx->dec_sub);
 		prev_sub_encoded = 1;
 	}
+
+	// Cleanup
+	free(prev_subtitle_text);
 	activity_progress(100, cur_sec / 60, cur_sec % 60);
 }
 
@@ -488,6 +497,7 @@ void process_hardsubx_linear_frames_and_normal_subs(struct lib_hardsubx_ctx *har
 								if (dist < (0.2 * MIN(strlen(subtitle_text_hard), strlen(prev_subtitle_text_hard))))
 								{
 									dist = -1;
+									free_rust_c_string(subtitle_text_hard);
 									subtitle_text_hard = NULL;
 									prev_end_time_hard = convert_pts_to_ms(hard_ctx->packet.pts, hard_ctx->format_ctx->streams[hard_ctx->video_stream_id]->time_base);
 								}
@@ -497,6 +507,7 @@ void process_hardsubx_linear_frames_and_normal_subs(struct lib_hardsubx_ctx *har
 								add_cc_sub_text(hard_ctx->dec_sub, prev_subtitle_text_hard, prev_begin_time_hard, prev_end_time_hard, "", "BURN", CCX_ENC_UTF_8);
 								encode_sub(enc_ctx, hard_ctx->dec_sub);
 								prev_begin_time_hard = prev_end_time_hard + 1;
+								free(prev_subtitle_text_hard);
 								prev_subtitle_text_hard = NULL;
 								prev_sub_encoded_hard = 1;
 								prev_end_time_hard = convert_pts_to_ms(hard_ctx->packet.pts, hard_ctx->format_ctx->streams[hard_ctx->video_stream_id]->time_base);
@@ -517,6 +528,10 @@ void process_hardsubx_linear_frames_and_normal_subs(struct lib_hardsubx_ctx *har
 							prev_sub_encoded_hard = 0;
 						}
 						prev_packet_pts_hard = hard_ctx->packet.pts;
+
+						// Free subtitle_text_hard from this iteration (allocated by Rust)
+						free_rust_c_string(subtitle_text_hard);
+						subtitle_text_hard = NULL;
 					}
 				}
 			}
@@ -529,6 +544,9 @@ void process_hardsubx_linear_frames_and_normal_subs(struct lib_hardsubx_ctx *har
 		encode_sub(enc_ctx, hard_ctx->dec_sub);
 		prev_sub_encoded_hard = 1;
 	}
+
+	// Cleanup
+	free(prev_subtitle_text_hard);
 	activity_progress(100, cur_sec / 60, cur_sec % 60);
 }
 
diff --git a/src/lib_ccx/wtv_functions.c b/src/lib_ccx/wtv_functions.c
@@ -436,8 +436,18 @@ LLONG get_data(struct lib_ccx_ctx *ctx, struct wtv_chunked_buffer *cb, struct de
 			dbg_print(CCX_DMT_PARSE, "TIME: %ld\n", time);
 			if (time != -1 && time != WTV_CC_TIMESTAMP_MAGIC)
 			{ // Ignore -1 timestamps
-				set_current_pts(dec_ctx->timing, time_to_pes_time(time));
-				dec_ctx->timing->pts_set = 1;
+				LLONG pes_time = time_to_pes_time(time);
+				set_current_pts(dec_ctx->timing, pes_time);
+				// Set min_pts and sync_pts on first valid timestamp to enable fts_now calculation
+				if (dec_ctx->timing->min_pts == 0x01FFFFFFFF || pes_time < dec_ctx->timing->min_pts)
+				{
+					dec_ctx->timing->min_pts = pes_time;
+					// Also set sync_pts to prevent PTS jump detection from triggering
+					// when pts_set becomes MinPtsSet (sync_pts - current_pts would be huge otherwise)
+					dec_ctx->timing->sync_pts = pes_time;
+				}
+				// pts_set = 2 (MinPtsSet) is required for proper fts_now calculation
+				dec_ctx->timing->pts_set = 2;
 				frames_since_ref_time = 0;
 				set_fts(dec_ctx->timing);
 			}
diff --git a/src/rust/lib_ccxr/src/util/encoding.rs b/src/rust/lib_ccxr/src/util/encoding.rs
@@ -584,7 +584,7 @@ fn latin1_to_line21(c: Latin1Char) -> Line21Char {
         0xbf => 0x83, // Inverted (open) question mark
         0xa2 => 0x85, // Cents symbol
         0xa3 => 0x86, // Pounds sterling
-        0xb6 => 0x87, // Music note (pilcrow in Latin-1)
+        b'#' => 0x87, // Music note (# in Latin-1)
         0xe0 => 0x88, // lowercase a, grave accent
         0x20 => 0x89, // transparent space
         0xe8 => 0x8a, // lowercase e, grave accent
@@ -682,7 +682,7 @@ pub fn line21_to_latin1(c: Line21Char) -> Latin1Char {
             0x84 => UNAVAILABLE_CHAR, // Trademark symbol (TM) - Does not exist in Latin 1
             0x85 => 0xa2,             // Cents symbol
             0x86 => 0xa3,             // Pounds sterling
-            0x87 => 0xb6,             // Music note - Not in latin 1, so we use 'pilcrow'
+            0x87 => b'#',             // Music note - Not in latin 1, so we use '#'
             0x88 => 0xe0,             // lowercase a, grave accent
             0x89 => 0x20,             // transparent space, we make it regular
             0x8a => 0xe8,             // lowercase e, grave accent
diff --git a/src/rust/src/hardsubx/classifier.rs b/src/rust/src/hardsubx/classifier.rs
@@ -22,40 +22,49 @@ use log::warn;
 /// # Safety
 /// The function accepts and dereferences a raw pointer
 /// The function also makes calls to functions whose safety is not guaranteed
-/// The function returns a raw pointer which is a string made in C
+/// The function returns a raw pointer which is a string allocated by Rust
+/// The caller must free this with the appropriate method (or let Rust handle it)
 /// ctx should be not null
 #[no_mangle]
 pub unsafe extern "C" fn get_ocr_text_simple_threshold(
     ctx: *mut lib_hardsubx_ctx,
     image: *mut Pix,
     threshold: std::os::raw::c_float,
 ) -> *mut ::std::os::raw::c_char {
-    let mut text_out: *mut ::std::os::raw::c_char;
-
     TessBaseAPISetImage2((*ctx).tess_handle, image);
 
     if TessBaseAPIRecognize((*ctx).tess_handle, null::<ETEXT_DESC>() as *mut ETEXT_DESC) != 0 {
         warn!("Error in Tesseract recognition, skipping frame\n");
-        null::<c_char>() as *mut c_char
-    } else {
-        text_out = TessBaseAPIGetUTF8Text((*ctx).tess_handle);
+        return null::<c_char>() as *mut c_char;
+    }
 
-        if text_out == null::<c_char>() as *mut c_char {
-            warn!("Error getting text, skipping frame\n");
-        }
+    let tess_text = TessBaseAPIGetUTF8Text((*ctx).tess_handle);
 
-        if threshold > 0.0 {
-            // non-zero conf, only then we'll make the call to check for confidence
-            let conf = TessBaseAPIMeanTextConf((*ctx).tess_handle);
+    if tess_text == null::<c_char>() as *mut c_char {
+        warn!("Error getting text, skipping frame\n");
+        return null::<c_char>() as *mut c_char;
+    }
 
-            if (conf as std::os::raw::c_float) < threshold {
-                text_out = null::<c_char>() as *mut c_char;
-            } else {
-                (*ctx).cur_conf = conf as std::os::raw::c_float;
-            }
+    if threshold > 0.0 {
+        // non-zero conf, only then we'll make the call to check for confidence
+        let conf = TessBaseAPIMeanTextConf((*ctx).tess_handle);
+
+        if (conf as std::os::raw::c_float) < threshold {
+            TessDeleteText(tess_text);
+            return null::<c_char>() as *mut c_char;
+        } else {
+            (*ctx).cur_conf = conf as std::os::raw::c_float;
         }
-        text_out
     }
+
+    // Convert Tesseract string to Rust-owned string, then free Tesseract's allocation
+    let rust_string = ffi::CStr::from_ptr(tess_text)
+        .to_string_lossy()
+        .into_owned();
+    TessDeleteText(tess_text);
+
+    // Return a Rust-allocated C string that can be safely freed with standard free()
+    string_to_c_char(&rust_string)
 }
 
 /// basically the get_oct_text_simple function without threshold
diff --git a/src/rust/src/hardsubx/decoder.rs b/src/rust/src/hardsubx/decoder.rs
@@ -32,6 +32,18 @@ static HARDSUBX_OCRMODE_WORD: i32 = 1;
 //     HARDSUBX_OCRMODE_LETTER
 // };
 
+/// Helper function to convert a Rust-allocated C string to an owned String
+/// Takes ownership of the memory and frees it properly
+unsafe fn cstring_to_owned(ptr: *mut c_char) -> String {
+    if ptr.is_null() {
+        return String::new();
+    }
+    match ffi::CString::from_raw(ptr).into_string() {
+        Ok(s) => s,
+        Err(_) => String::new(),
+    }
+}
+
 /// # Safety
 /// dereferences a raw pointer
 /// calls functions that are not necessarily safe
@@ -40,29 +52,15 @@ pub unsafe fn dispatch_classifier_functions(ctx: *mut lib_hardsubx_ctx, im: *mut
     match (*ctx).ocr_mode {
         0 => {
             let ret_char_arr = get_ocr_text_simple_threshold(ctx, im, (*ctx).conf_thresh);
-            let text_out_result = ffi::CString::from_raw(ret_char_arr).into_string();
-            match text_out_result {
-                Ok(T) => T,
-                Err(_E) => "".to_string(),
-            }
+            cstring_to_owned(ret_char_arr)
         }
         1 => {
             let ret_char_arr = get_ocr_text_wordwise_threshold(ctx, im, (*ctx).conf_thresh);
-            if ret_char_arr.is_null() {
-                "".to_string()
-            } else {
-                ffi::CStr::from_ptr(ret_char_arr)
-                    .to_string_lossy()
-                    .into_owned()
-            }
+            cstring_to_owned(ret_char_arr)
         }
         2 => {
             let ret_char_arr = get_ocr_text_letterwise_threshold(ctx, im, (*ctx).conf_thresh);
-            let text_out_result = ffi::CString::from_raw(ret_char_arr).into_string();
-            match text_out_result {
-                Ok(T) => T,
-                Err(_E) => "".to_string(),
-            }
+            cstring_to_owned(ret_char_arr)
         }
 
         _ => {
diff --git a/src/rust/src/libccxr_exports/demuxer.rs b/src/rust/src/libccxr_exports/demuxer.rs
@@ -427,10 +427,15 @@ pub unsafe extern "C" fn ccxr_demuxer_open(ctx: *mut ccx_demuxer, file: *const c
     if ctx.is_null() {
         return -1;
     }
-    let c_str = CStr::from_ptr(file);
-    let file_str = match c_str.to_str() {
-        Ok(s) => s,
-        Err(_) => return -1,
+
+    // Handle NULL file pointer (e.g., when using --udp or --tcp network input)
+    let file_str = if !file.is_null() {
+        match CStr::from_ptr(file).to_str() {
+            Ok(s) => s,
+            Err(_) => return -1,
+        }
+    } else {
+        ""
     };
 
     let mut demux_ctx = copy_demuxer_from_c_to_rust(ctx);
diff --git a/src/rust/src/utils.rs b/src/rust/src/utils.rs
@@ -38,7 +38,8 @@ pub fn string_to_c_char(a: &str) -> *mut ::std::os::raw::c_char {
 /// # Safety
 /// The pointer must have been allocated by `string_to_c_char` (i.e., `CString::into_raw`)
 /// or be null. Passing a pointer allocated by C's malloc will cause undefined behavior.
-pub unsafe fn free_rust_c_string(ptr: *mut ::std::os::raw::c_char) {
+#[no_mangle]
+pub unsafe extern "C" fn free_rust_c_string(ptr: *mut ::std::os::raw::c_char) {
     if !ptr.is_null() {
         // Reclaim ownership and drop the CString, which frees the memory
         let _ = ffi::CString::from_raw(ptr);

Original file line number	Diff line number	Diff line change
`@@ -472,14 +472,17 @@ void xds_do_content_advisory(struct cc_subtitle *sub, struct ccx_decoders_xds_co`
`472`	`472`	`if (!a1 && a0) // US TV parental guidelines`
`473`	`473`	`{`
`474`	`474`	`xdsprint(sub, ctx, age);`
`475`		`- xdsprint(sub, ctx, content);`
	`475`	`+ if (content[0]) // Only output content if not empty`
	`476`	`+ xdsprint(sub, ctx, content);`
`476`	`477`	`if (changed)`
`477`	`478`	`{`
`478`	`479`	`ccx_common_logging.log_ftn("\rXDS: %s\n ", age);`
`479`		`- ccx_common_logging.log_ftn("\rXDS: %s\n ", content);`
	`480`	`+ if (content[0])`
	`481`	`+ ccx_common_logging.log_ftn("\rXDS: %s\n ", content);`
`480`	`482`	`}`
`481`	`483`	`ccx_common_logging.debug_ftn(CCX_DMT_DECODER_XDS, "\rXDS: %s\n", age);`
`482`		`- ccx_common_logging.debug_ftn(CCX_DMT_DECODER_XDS, "\rXDS: %s\n", content);`
	`484`	`+ if (content[0])`
	`485`	`+ ccx_common_logging.debug_ftn(CCX_DMT_DECODER_XDS, "\rXDS: %s\n", content);`
`483`	`486`	`}`
`484`	`487`	`if (!a0 \|\| // MPA`
`485`	`488`	`(a0 && a1 && !Da2 && !La3) \|\| // Canadian English Language Rating`
Original file line number	Diff line number	Diff line change
`@@ -210,6 +210,7 @@ void hardsubx_process_frames_linear(struct lib_hardsubx_ctx *ctx, struct encoder`
`210`	`210`	`if (dist < (0.2 * MIN(strlen(subtitle_text), strlen(prev_subtitle_text))))`
`211`	`211`	`{`
`212`	`212`	`dist = -1;`
	`213`	`+ free_rust_c_string(subtitle_text);`
`213`	`214`	`subtitle_text = NULL;`
`214`	`215`	`prev_end_time = convert_pts_to_ms(ctx->packet.pts, ctx->format_ctx->streams[ctx->video_stream_id]->time_base);`
`215`	`216`	`}`
`@@ -219,6 +220,7 @@ void hardsubx_process_frames_linear(struct lib_hardsubx_ctx *ctx, struct encoder`
`219`	`220`	`add_cc_sub_text(ctx->dec_sub, prev_subtitle_text, prev_begin_time, prev_end_time, "", "BURN", CCX_ENC_UTF_8);`
`220`	`221`	`encode_sub(enc_ctx, ctx->dec_sub);`
`221`	`222`	`prev_begin_time = prev_end_time + 1;`
	`223`	`+ free(prev_subtitle_text);`
`222`	`224`	`prev_subtitle_text = NULL;`
`223`	`225`	`prev_sub_encoded = 1;`
`224`	`226`	`prev_end_time = convert_pts_to_ms(ctx->packet.pts, ctx->format_ctx->streams[ctx->video_stream_id]->time_base);`
`@@ -252,6 +254,10 @@ void hardsubx_process_frames_linear(struct lib_hardsubx_ctx *ctx, struct encoder`
`252`	`254`	`prev_sub_encoded = 0;`
`253`	`255`	`}`
`254`	`256`	`prev_packet_pts = ctx->packet.pts;`
	`257`	`+`
	`258`	`+ // Free subtitle_text from this iteration (was allocated by Rust in _process_frame_*_basic)`
	`259`	`+ free_rust_c_string(subtitle_text);`
	`260`	`+ subtitle_text = NULL;`
`255`	`261`	`}`
`256`	`262`	`}`
`257`	`263`	`av_packet_unref(&ctx->packet);`
`@@ -263,6 +269,9 @@ void hardsubx_process_frames_linear(struct lib_hardsubx_ctx *ctx, struct encoder`
`263`	`269`	`encode_sub(enc_ctx, ctx->dec_sub);`
`264`	`270`	`prev_sub_encoded = 1;`
`265`	`271`	`}`
	`272`	`+`
	`273`	`+ // Cleanup`
	`274`	`+ free(prev_subtitle_text);`
`266`	`275`	`activity_progress(100, cur_sec / 60, cur_sec % 60);`
`267`	`276`	`}`
`268`	`277`
`@@ -488,6 +497,7 @@ void process_hardsubx_linear_frames_and_normal_subs(struct lib_hardsubx_ctx *har`
`488`	`497`	`if (dist < (0.2 * MIN(strlen(subtitle_text_hard), strlen(prev_subtitle_text_hard))))`
`489`	`498`	`{`
`490`	`499`	`dist = -1;`
	`500`	`+ free_rust_c_string(subtitle_text_hard);`
`491`	`501`	`subtitle_text_hard = NULL;`
`492`	`502`	`prev_end_time_hard = convert_pts_to_ms(hard_ctx->packet.pts, hard_ctx->format_ctx->streams[hard_ctx->video_stream_id]->time_base);`
`493`	`503`	`}`
`@@ -497,6 +507,7 @@ void process_hardsubx_linear_frames_and_normal_subs(struct lib_hardsubx_ctx *har`
`497`	`507`	`add_cc_sub_text(hard_ctx->dec_sub, prev_subtitle_text_hard, prev_begin_time_hard, prev_end_time_hard, "", "BURN", CCX_ENC_UTF_8);`
`498`	`508`	`encode_sub(enc_ctx, hard_ctx->dec_sub);`
`499`	`509`	`prev_begin_time_hard = prev_end_time_hard + 1;`
	`510`	`+ free(prev_subtitle_text_hard);`
`500`	`511`	`prev_subtitle_text_hard = NULL;`
`501`	`512`	`prev_sub_encoded_hard = 1;`
`502`	`513`	`prev_end_time_hard = convert_pts_to_ms(hard_ctx->packet.pts, hard_ctx->format_ctx->streams[hard_ctx->video_stream_id]->time_base);`
`@@ -517,6 +528,10 @@ void process_hardsubx_linear_frames_and_normal_subs(struct lib_hardsubx_ctx *har`
`517`	`528`	`prev_sub_encoded_hard = 0;`
`518`	`529`	`}`
`519`	`530`	`prev_packet_pts_hard = hard_ctx->packet.pts;`
	`531`	`+`
	`532`	`+ // Free subtitle_text_hard from this iteration (allocated by Rust)`
	`533`	`+ free_rust_c_string(subtitle_text_hard);`
	`534`	`+ subtitle_text_hard = NULL;`
`520`	`535`	`}`
`521`	`536`	`}`
`522`	`537`	`}`
`@@ -529,6 +544,9 @@ void process_hardsubx_linear_frames_and_normal_subs(struct lib_hardsubx_ctx *har`
`529`	`544`	`encode_sub(enc_ctx, hard_ctx->dec_sub);`
`530`	`545`	`prev_sub_encoded_hard = 1;`
`531`	`546`	`}`
	`547`	`+`
	`548`	`+ // Cleanup`
	`549`	`+ free(prev_subtitle_text_hard);`
`532`	`550`	`activity_progress(100, cur_sec / 60, cur_sec % 60);`
`533`	`551`	`}`
`534`	`552`