diff --git a/.github/workflows/build_linux.yml b/.github/workflows/build_linux.yml
index 311fe3719..da8819fca 100644
--- a/.github/workflows/build_linux.yml
+++ b/.github/workflows/build_linux.yml
@@ -27,6 +27,10 @@ jobs:
     steps:
     - name: Install dependencies
       run: sudo apt update && sudo apt-get install libgpac-dev libtesseract-dev libavcodec-dev libavdevice-dev libx11-dev libxcb1-dev libxcb-shm0-dev
+    - name: Install Rust
+      run: |
+        curl --proto "=https" --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y
+
     - uses: actions/checkout@v6
     - name: build
       run: ./build -hardsubx
@@ -47,6 +51,10 @@ jobs:
     steps:
     - name: Install dependencies
       run: sudo apt update && sudo apt-get install libgpac-dev
+    - name: Install Rust
+      run: |
+        curl --proto "=https" --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y
+
     - uses: actions/checkout@v6
     - name: run autogen
       run: ./autogen.sh
@@ -65,6 +73,10 @@ jobs:
     steps:
     - name: Install dependencies
       run: sudo apt update && sudo apt-get install libgpac-dev
+    - name: Install Rust
+      run: |
+        curl --proto "=https" --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y
+
     - uses: actions/checkout@v6
     - name: cmake
       run: mkdir build && cd build && cmake ../src
@@ -79,8 +91,13 @@ jobs:
     - uses: actions/checkout@v6
     - name: Install dependencies
       run: sudo apt update && sudo apt install libgpac-dev libtesseract-dev libavformat-dev libavdevice-dev libswscale-dev yasm
+    - name: Install Rust
+      run: |
+        curl --proto "=https" --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y
+
     - name: cmake
       run: |
+
         mkdir build && cd build
         cmake -DWITH_OCR=ON -DWITH_HARDSUBX=ON ../src
     - name: build
@@ -94,6 +111,10 @@ jobs:
     steps:
       - name: Install dependencies
         run: sudo apt update && sudo apt-get install libgpac-dev
+    - name: Install Rust
+      run: |
+        curl --proto "=https" --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y
+
       - uses: actions/checkout@v6
       - name: cache 
         uses: actions/cache@v5
diff --git a/.github/workflows/build_mac.yml b/.github/workflows/build_mac.yml
index 8e01ec1cd..74bafe45e 100644
--- a/.github/workflows/build_mac.yml
+++ b/.github/workflows/build_mac.yml
@@ -64,6 +64,10 @@ jobs:
     runs-on: macos-latest
     steps:
     - uses: actions/checkout@v6
+    - name: Install Rust
+      run: |
+        curl --proto "=https" --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y
+        echo "$HOME/.cargo/bin" >> $GITHUB_PATH
     - name: dependencies
       run: brew install gpac
     - uses: actions/checkout@v6
@@ -78,6 +82,10 @@ jobs:
     runs-on: macos-latest
     steps:
     - uses: actions/checkout@v6
+    - name: Install Rust
+      run: |
+        curl --proto "=https" --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y
+        echo "$HOME/.cargo/bin" >> $GITHUB_PATH
     - name: Install dependencies
       run: brew install pkg-config autoconf automake libtool tesseract leptonica gpac ffmpeg
     - name: cmake
diff --git a/.gitignore b/.gitignore
index bdb5246d4..c8df9be92 100644
--- a/.gitignore
+++ b/.gitignore
@@ -156,6 +156,21 @@ windows/*/CACHEDIR.TAG
 windows/.rustc_info.json
 linux/configure~
 
+# local junk
+build-system/
+*.backup
+*.save
+*.patch
+*.a
+README.srt
+no_subs.ts
+
+fix_hardsubx.cmake
+fix_libraries.cmake
+mac/configure~
+*.current
+
+
 # Plans and temporary files
 plans/
 tess.log
diff --git a/mac/build.command b/mac/build.command
index e0aab469a..f69d9daf1 100755
--- a/mac/build.command
+++ b/mac/build.command
@@ -106,7 +106,7 @@ if [[ "$ENABLE_OCR" == "true" ]]; then
     BLD_INCLUDE="$BLD_INCLUDE `pkg-config --cflags --silence-errors tesseract`"
 fi
 
-SRC_CCX="$(find ../src/lib_ccx -name '*.c')"
+SRC_CCX="$(find ../src/lib_ccx -name '*.c' | grep -v ccx_encoders_smptett.c)"
 SRC_LIB_HASH="$(find ../src/thirdparty/lib_hash -name '*.c')"
 SRC_LIBPNG="$(find ../src/thirdparty/libpng -name '*.c')"
 SRC_UTF8="../src/thirdparty/utf8proc/utf8proc.c"
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 1896b3492..fa9b91225 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -246,11 +246,25 @@ add_executable (ccextractor ${SOURCEFILE} ${FREETYPE_SOURCE} ${UTF8PROC_SOURCE})
 # Build with Rust library
 ########################################################
 
-if (PKG_CONFIG_FOUND)
-  add_subdirectory (rust)
-  set (EXTRA_LIBS ${EXTRA_LIBS} ccx_rust)
-endif (PKG_CONFIG_FOUND)
+# Rust is REQUIRED for DTVCC and SMPTE-TT functionality
+find_program(CARGO cargo PATHS $ENV{HOME}/.cargo/bin REQUIRED)
+message(STATUS "Found cargo: ${CARGO}")
+
+# Build Rust library using Corrosion (in rust/CMakeLists.txt)
+add_subdirectory(rust)
+
+# Platform-specific system libraries needed for Rust
+if(APPLE)
+    set(RUST_EXTRA_LIBS pthread dl m "-framework Security" "-framework CoreFoundation")
+elseif(WIN32)
+    set(RUST_EXTRA_LIBS ws2_32 userenv bcrypt ntdll)
+else()
+    set(RUST_EXTRA_LIBS pthread dl m)
+endif()
 
+set(EXTRA_LIBS ${EXTRA_LIBS} ccx_rust ${RUST_EXTRA_LIBS})
+set(RUST_AVAILABLE TRUE)
+message(STATUS "Rust available, using Rust implementations")
 
 target_link_libraries (ccextractor ${EXTRA_LIBS})
 target_include_directories (ccextractor PUBLIC ${EXTRA_INCLUDES})
diff --git a/src/lib_ccx/CMakeLists.txt b/src/lib_ccx/CMakeLists.txt
index befb4f18b..c643a1ab9 100644
--- a/src/lib_ccx/CMakeLists.txt
+++ b/src/lib_ccx/CMakeLists.txt
@@ -59,6 +59,9 @@ endif (WITH_OCR)
 
 aux_source_directory ("${PROJECT_SOURCE_DIR}/lib_ccx/" SOURCEFILE)
 
+# Rust is available, using Rust SMPTE-TT implementation
+list(REMOVE_ITEM SOURCEFILE "${PROJECT_SOURCE_DIR}/lib_ccx/ccx_encoders_smptett.c")
+
 add_library (ccx ${SOURCEFILE} ccx_dtvcc.h ccx_dtvcc.c ccx_encoders_mcc.c ccx_encoders_mcc.h)
 target_link_libraries (ccx ${EXTRA_LIBS})
 target_include_directories (ccx PUBLIC ${EXTRA_INCLUDES})
diff --git a/src/lib_ccx/ccx_encoders_smptett.c.bak b/src/lib_ccx/ccx_encoders_smptett.c.bak
new file mode 100644
index 000000000..7c5f90ddf
--- /dev/null
+++ b/src/lib_ccx/ccx_encoders_smptett.c.bak
@@ -0,0 +1,411 @@
+/*
+	Produces minimally-compliant SMPTE Timed Text (W3C TTML)
+	format-compatible output
+
+	See http://www.w3.org/TR/ttaf1-dfxp/ and
+	https://www.smpte.org/sites/default/files/st2052-1-2010.pdf
+
+	Copyright (C) 2012 John Kemp
+
+	This program is free software; you can redistribute it and/or
+	modify it under the terms of the GNU General Public License
+	as published by the Free Software Foundation; either version 2
+	of the License, or (at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program; if not, write to the Free Software
+	Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+*/
+#include "lib_ccx.h"
+#include "ccx_common_option.h"
+#include "ccx_encoders_common.h"
+#include <png.h>
+#include "ocr.h"
+#include "utility.h"
+#include "ccx_encoders_helpers.h"
+
+void write_stringz_as_smptett(char *string, struct encoder_ctx *context, LLONG ms_start, LLONG ms_end)
+{
+	int used;
+	unsigned h1, m1, s1, ms1;
+	unsigned h2, m2, s2, ms2;
+	int len = strlen(string);
+	unsigned char *unescaped = (unsigned char *)malloc(len + 1);
+	unsigned char *el = (unsigned char *)malloc(len * 3 + 1); // Be generous
+	int pos_r = 0;
+	int pos_w = 0;
+	char str[1024];
+
+	if (el == NULL || unescaped == NULL)
+		fatal(EXIT_NOT_ENOUGH_MEMORY, "In write_stringz_as_smptett() - not enough memory.\n");
+
+	millis_to_time(ms_start, &h1, &m1, &s1, &ms1);
+	millis_to_time(ms_end - 1, &h2, &m2, &s2, &ms2);
+
+	sprintf((char *)str, "<p begin=\"%02u:%02u:%02u.%03u\" end=\"%02u:%02u:%02u.%03u\">\r\n", h1, m1, s1, ms1, h2, m2, s2, ms2);
+	if (context->encoding != CCX_ENC_UNICODE)
+	{
+		dbg_print(CCX_DMT_DECODER_608, "\r%s\n", str);
+	}
+	used = encode_line(context, context->buffer, (unsigned char *)str);
+	write_wrapped(context->out->fh, context->buffer, used);
+	// 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')
+		{
+			unescaped[pos_w] = 0;
+			pos_r += 2;
+		}
+		else
+		{
+			unescaped[pos_w] = string[pos_r];
+			pos_r++;
+		}
+		pos_w++;
+	}
+	unescaped[pos_w] = 0;
+	// Now read the unescaped string (now several string'z and write them)
+	unsigned char *begin = unescaped;
+	while (begin < unescaped + len)
+	{
+		unsigned int u = encode_line(context, el, begin);
+		if (context->encoding != CCX_ENC_UNICODE)
+		{
+			dbg_print(CCX_DMT_DECODER_608, "\r");
+			dbg_print(CCX_DMT_DECODER_608, "%s\n", context->subline);
+		}
+		write_wrapped(context->out->fh, el, u);
+		// write (wb->fh, encoded_br, encoded_br_length);
+
+		write_wrapped(context->out->fh, context->encoded_crlf, context->encoded_crlf_length);
+		begin += strlen((const char *)begin) + 1;
+	}
+
+	sprintf((char *)str, "</p>\n");
+	if (context->encoding != CCX_ENC_UNICODE)
+	{
+		dbg_print(CCX_DMT_DECODER_608, "\r%s\n", str);
+	}
+	used = encode_line(context, context->buffer, (unsigned char *)str);
+	write_wrapped(context->out->fh, context->buffer, used);
+
+	free(el);
+	free(unescaped);
+}
+
+int write_cc_bitmap_as_smptett(struct cc_subtitle *sub, struct encoder_ctx *context)
+{
+	int ret = 0;
+#ifdef ENABLE_OCR
+	struct cc_bitmap *rect;
+	// char timeline[128];
+	int i, len = 0;
+
+	if (sub->nb_data == 0)
+		return 0;
+
+	rect = sub->data;
+
+	if (sub->flags & SUB_EOD_MARKER)
+		context->prev_start = sub->start_time;
+
+	for (i = sub->nb_data - 1; i >= 0; i--)
+	{
+		if (rect[i].ocr_text && *(rect[i].ocr_text))
+		{
+			if (context->prev_start != -1 || !(sub->flags & SUB_EOD_MARKER))
+			{
+				char *buf = (char *)context->buffer;
+				unsigned h1, m1, s1, ms1;
+				unsigned h2, m2, s2, ms2;
+				millis_to_time(sub->start_time, &h1, &m1, &s1, &ms1);
+				millis_to_time(sub->end_time - 1, &h2, &m2, &s2, &ms2); // -1 To prevent overlapping with next line.
+				sprintf((char *)context->buffer, "<p begin=\"%02u:%02u:%02u.%03u\" end=\"%02u:%02u:%02u.%03u\">\n", h1, m1, s1, ms1, h2, m2, s2, ms2);
+				write_wrapped(context->out->fh, buf, strlen(buf));
+				len = strlen(rect[i].ocr_text);
+				write_wrapped(context->out->fh, rect[i].ocr_text, len);
+				write_wrapped(context->out->fh, context->encoded_crlf, context->encoded_crlf_length);
+				sprintf(buf, "</p>\n");
+				write_wrapped(context->out->fh, buf, strlen(buf));
+			}
+		}
+	}
+	for (i = 0, rect = sub->data; i < sub->nb_data; i++, rect++)
+	{
+		freep(&rect->data0);
+		freep(&rect->data1);
+	}
+#endif
+
+	sub->nb_data = 0;
+	freep(&sub->data);
+	return ret;
+}
+
+int write_cc_subtitle_as_smptett(struct cc_subtitle *sub, struct encoder_ctx *context)
+{
+	int ret = 0;
+	struct cc_subtitle *osub = sub;
+	struct cc_subtitle *lsub = sub;
+	while (sub)
+	{
+		if (sub->type == CC_TEXT)
+		{
+			write_stringz_as_smptett(sub->data, context, sub->start_time, sub->end_time);
+			freep(&sub->data);
+			sub->nb_data = 0;
+		}
+		lsub = sub;
+		sub = sub->next;
+	}
+	while (lsub != osub)
+	{
+		sub = lsub->prev;
+		freep(&lsub);
+		lsub = sub;
+	}
+
+	return ret;
+}
+
+int write_cc_buffer_as_smptett(struct eia608_screen *data, struct encoder_ctx *context)
+{
+	int used;
+	unsigned h1, m1, s1, ms1;
+	unsigned h2, m2, s2, ms2;
+	int wrote_something = 0;
+	char str[1024];
+
+	millis_to_time(data->start_time, &h1, &m1, &s1, &ms1);
+	millis_to_time(data->end_time - 1, &h2, &m2, &s2, &ms2);
+
+	for (int row = 0; row < 15; row++)
+	{
+		if (data->row_used[row])
+		{
+			float row1 = 0;
+			float col1 = 0;
+			int firstcol = -1;
+
+			// ROWS is actually 90% of the screen size
+			// Add +10% because row 0 is at position 10%
+			row1 = ((100 * row) / (ROWS / 0.8)) + 10;
+
+			for (int column = 0; column < COLUMNS; column++)
+			{
+				int unicode = 0;
+				get_char_in_unicode((unsigned char *)&unicode, data->characters[row][column]);
+				// if (COL_TRANSPARENT != data->colors[row][column])
+				if (unicode != 0x20)
+				{
+					if (firstcol < 0)
+					{
+						firstcol = column;
+					}
+				}
+			}
+			// COLUMNS is actually 90% of the screen size
+			// Add +10% because column 0 is at position 10%
+			col1 = ((100 * firstcol) / (COLUMNS / 0.8)) + 10;
+
+			if (firstcol >= 0)
+			{
+				wrote_something = 1;
+
+				sprintf(str, "      <p begin=\"%02u:%02u:%02u.%03u\" end=\"%02u:%02u:%02u.%03u\" tts:origin=\"%1.3f%% %1.3f%%\">\n        <span>", h1, m1, s1, ms1, h2, m2, s2, ms2, col1, row1);
+				if (context->encoding != CCX_ENC_UNICODE)
+				{
+					dbg_print(CCX_DMT_DECODER_608, "\r%s\n", str);
+				}
+				used = encode_line(context, context->buffer, (unsigned char *)str);
+				write_wrapped(context->out->fh, context->buffer, used);
+				// Trimming subs because the position is defined by "tts:origin"
+				int old_trim_subs = context->trim_subs;
+				context->trim_subs = 1;
+				if (context->encoding != CCX_ENC_UNICODE)
+				{
+					dbg_print(CCX_DMT_DECODER_608, "\r");
+					dbg_print(CCX_DMT_DECODER_608, "%s\n", context->subline);
+				}
+
+				get_decoder_line_encoded(context, context->subline, row, data);
+
+				char *final = malloc(strlen((const char *)(context->subline)) + 1000); // Being overly generous? :P
+				char *temp = malloc(strlen((const char *)(context->subline)) + 1000);
+				*final = 0;
+				*temp = 0;
+				/*
+					final	: stores formatted HTML sentence. This will be written in subtitle file.
+					temp	: stored temporary sentences required while formatting
+
+					+1000 because huge <span> and <style> tags are added. This will just prevent overflow (hopefully).
+				*/
+
+				int style = 0;
+
+				/*
+
+				0 = None or font colour
+				1 = italics
+				2 = bold
+				3 = underline
+
+				*/
+
+				// Now, searching for first occurrence of <i> OR <u> OR <b>
+
+				char *start = strstr((const char *)(context->subline), "<i>");
+				if (start == NULL)
+				{
+					start = strstr((const char *)(context->subline), "<b>");
+
+					if (start == NULL)
+					{
+						start = strstr((const char *)(context->subline), "<u>");
+						style = 3; // underline
+					}
+					else
+						style = 2; // bold
+				}
+				else
+					style = 1; // italics
+
+				if (start != NULL) // subtitle has style associated with it, will need formatting.
+				{
+					char *end_tag;
+					if (style == 1)
+					{
+						end_tag = "</i>";
+					}
+					else if (style == 2)
+					{
+						end_tag = "</b>";
+					}
+					else
+					{
+						end_tag = "</u>";
+					}
+
+					char *end = strstr((const char *)(context->subline), end_tag); // occurrence of closing tag (</i> OR </b> OR </u>)
+
+					if (end == NULL)
+					{
+						// Incorrect styling, writing as it is
+						strcpy(final, (const char *)(context->subline));
+					}
+					else
+					{
+						int start_index = start - (char *)(context->subline);
+						int end_index = end - (char *)(context->subline);
+
+						strncat(final, (const char *)(context->subline), start_index); // copying content before opening tag e.g. <i>
+
+						strcat(final, "<span>"); // adding <span> : replacement of <i>
+
+						// The content in italics is between <i> and </i>, i.e. between (start_index + 3) and end_index.
+
+						strncat(temp, (const char *)(context->subline) + start_index + 3, end_index - start_index - 3); // the content in italics
+
+						strcat(final, temp); // attaching to final sentence.
+
+						if (style == 1)
+							strcpy(temp, "<style tts:backgroundColor=\"#000000FF\" tts:fontSize=\"18px\" tts:fontStyle=\"italic\"/> </span>");
+
+						else if (style == 2)
+							strcpy(temp, "<style tts:backgroundColor=\"#000000FF\" tts:fontSize=\"18px\" tts:fontWeight=\"bold\"/> </span>");
+
+						else
+							strcpy(temp, "<style tts:backgroundColor=\"#000000FF\" tts:fontSize=\"18px\" tts:textDecoration=\"underline\"/> </span>");
+
+						strcat(final, temp); // adding appropriate style tag.
+
+						sprintf(temp, "%s", (const char *)(context->subline) + end_index + 4); // finding remaining sentence.
+
+						strcat(final, temp); // adding remaining sentence.
+					}
+				}
+				else // No style or Font Color
+				{
+
+					start = strstr((const char *)(context->subline), "<font color"); // spec : <font color="#xxxxxx"> cc </font>
+					if (start != NULL)						 // font color attribute is present
+					{
+						char *end = strstr((const char *)(context->subline), "</font>");
+						if (end == NULL)
+						{
+							// Incorrect styling, writing as it is
+							strcpy(final, (const char *)(context->subline));
+						}
+
+						else
+						{
+							int start_index = start - (char *)(context->subline);
+							int end_index = end - (char *)(context->subline);
+
+							strncat(final, (const char *)(context->subline), start_index); // copying content before opening tag e.g. <font ..>
+
+							strcat(final, "<span>"); // adding <span> : replacement of <font ..>
+
+							char *temp_pointer = strchr((const char *)(context->subline), '#'); // locating color code
+
+							char color_code[7];
+							strncpy(color_code, temp_pointer + 1, 6); // obtained color code
+							color_code[6] = '\0';
+
+							temp_pointer = strchr((const char *)(context->subline), '>'); // The content is in between <font ..> and </font>
+
+							strncat(temp, temp_pointer + 1, end_index - (temp_pointer - (char *)(context->subline) + 1));
+
+							strcat(final, temp); // attaching to final sentence.
+
+							sprintf(temp, "<style tts:backgroundColor=\"#FFFF00FF\" tts:color=\"%s\" tts:fontSize=\"18px\"/></span>", color_code);
+
+							strcat(final, temp); // adding font color tag
+
+							sprintf(temp, "%s", (const char *)(context->subline) + end_index + 7); // finding remaining sentence.
+
+							strcat(final, temp); // adding remaining sentence
+						}
+					}
+
+					else
+					{
+						// NO styling, writing as it is
+						strcpy(final, (const char *)(context->subline));
+					}
+				}
+
+				write_wrapped(context->out->fh, final, strlen(final));
+
+				write_wrapped(context->out->fh, context->encoded_crlf, context->encoded_crlf_length);
+				context->trim_subs = old_trim_subs;
+
+				sprintf(str, "        <style tts:backgroundColor=\"#000000FF\" tts:fontSize=\"18px\"/></span>\n      </p>\n");
+				if (context->encoding != CCX_ENC_UNICODE)
+				{
+					dbg_print(CCX_DMT_DECODER_608, "\r%s\n", str);
+				}
+				used = encode_line(context, context->buffer, (unsigned char *)str);
+				write_wrapped(context->out->fh, context->buffer, used);
+
+				if (context->encoding != CCX_ENC_UNICODE)
+				{
+					dbg_print(CCX_DMT_DECODER_608, "\r%s\n", str);
+				}
+				used = encode_line(context, context->buffer, (unsigned char *)str);
+				// write (wb->fh, enc_buffer,enc_buffer_used);
+
+				freep(&final);
+				freep(&temp);
+			}
+		}
+	}
+
+	return wrote_something;
+}
diff --git a/src/rust/src/encoder/mod.rs b/src/rust/src/encoder/mod.rs
index 853abae5a..5d2d75853 100644
--- a/src/rust/src/encoder/mod.rs
+++ b/src/rust/src/encoder/mod.rs
@@ -7,6 +7,8 @@ use std::os::raw::{c_int, c_uchar};
 pub mod common;
 pub mod g608;
 pub mod simplexml;
+pub mod smptett;
+
 /// # Safety
 /// This function is unsafe because it deferences to raw pointers and performs operations on pointer slices.
 #[no_mangle]
diff --git a/src/rust/src/encoder/smptett.rs b/src/rust/src/encoder/smptett.rs
new file mode 100644
index 000000000..6a707a8d9
--- /dev/null
+++ b/src/rust/src/encoder/smptett.rs
@@ -0,0 +1,482 @@
+use crate::bindings::{
+    cc_subtitle, ccx_encoding_type_CCX_ENC_UNICODE, eia608_screen, encoder_ctx, subtype_CC_TEXT,
+};
+use crate::encoder::common::{encode_line, write_raw};
+use crate::libccxr_exports::time::ccxr_millis_to_time;
+use lib_ccxr::debug;
+use lib_ccxr::util::log::DebugMessageFlag;
+
+use std::ffi::CStr;
+use std::io;
+use std::os::raw::{c_char, c_int, c_void};
+
+// Constants from C code
+const ROWS: i32 = 15;
+const COLUMNS: i32 = 32;
+
+fn escape_xml(s: &str) -> String {
+    let mut out = String::with_capacity(s.len());
+    for c in s.chars() {
+        match c {
+            '&' => out.push_str("&amp;"),
+            '<' => out.push_str("&lt;"),
+            '>' => out.push_str("&gt;"),
+            '"' => out.push_str("&quot;"),
+            '\'' => out.push_str("&apos;"),
+            _ => out.push(c),
+        }
+    }
+    out
+}
+
+/// Write data to file descriptor with retry logic
+fn write_wrapped(fd: c_int, buf: &[u8]) -> Result<(), io::Error> {
+    let mut remaining = buf.len();
+    let mut current_buf = buf.as_ptr();
+
+    while remaining > 0 {
+        let written = write_raw(fd, current_buf as *const c_void, remaining);
+        if written == -1 {
+            return Err(io::Error::last_os_error());
+        }
+        unsafe {
+            current_buf = current_buf.add(written as usize);
+        }
+        remaining -= written as usize;
+    }
+
+    Ok(())
+}
+
+/// Internal implementation of write_stringz_as_smptett
+fn write_stringz_as_smptett_internal(
+    text: &str,
+    context: &mut encoder_ctx,
+    ms_start: i64,
+    ms_end: i64,
+) {
+    let (mut h1, mut m1, mut s1, mut ms1) = (0, 0, 0, 0);
+    let (mut h2, mut m2, mut s2, mut ms2) = (0, 0, 0, 0);
+
+    unsafe {
+        ccxr_millis_to_time(ms_start, &mut h1, &mut m1, &mut s1, &mut ms1);
+        ccxr_millis_to_time(ms_end - 1, &mut h2, &mut m2, &mut s2, &mut ms2);
+    }
+
+    // Convert raw pointer buffer → Rust slice
+    let buffer: &mut [u8] =
+        unsafe { std::slice::from_raw_parts_mut(context.buffer, context.capacity as usize) };
+
+    let header = format!(
+        "<p begin=\"{:02}:{:02}:{:02}.{:03}\" end=\"{:02}:{:02}:{:02}.{:03}\">\r\n",
+        h1, m1, s1, ms1, h2, m2, s2, ms2
+    );
+
+    if context.encoding != ccx_encoding_type_CCX_ENC_UNICODE {
+        debug!(msg_type = DebugMessageFlag::DECODER_608; "\r{}\n", header.trim_end());
+    }
+
+    let used = encode_line(context, buffer, header.as_bytes());
+    unsafe {
+        let out = &*context.out;
+        let _ = write_wrapped(out.fh, &buffer[..used as usize]);
+    }
+
+    // Process lines - split by \n in the string
+    for line in text.split('\n') {
+        if !line.is_empty() {
+            let escaped = escape_xml(line);
+            let used = encode_line(context, buffer, escaped.as_bytes());
+
+            if context.encoding != ccx_encoding_type_CCX_ENC_UNICODE {
+                debug!(msg_type = DebugMessageFlag::DECODER_608; "\r{}\n", escaped);
+            }
+
+            unsafe {
+                let out = &*context.out;
+                let _ = write_wrapped(out.fh, &buffer[..used as usize]);
+
+                // Write CRLF
+                let crlf_slice = std::slice::from_raw_parts(
+                    context.encoded_crlf.as_ptr(),
+                    context.encoded_crlf_length as usize,
+                );
+                let _ = write_wrapped(out.fh, crlf_slice);
+            }
+        }
+    }
+
+    let footer = b"</p>\n";
+    let used = encode_line(context, buffer, footer);
+
+    if context.encoding != ccx_encoding_type_CCX_ENC_UNICODE {
+        debug!(msg_type = DebugMessageFlag::DECODER_608; "\r</p>\n");
+    }
+
+    unsafe {
+        let out = &*context.out;
+        let _ = write_wrapped(out.fh, &buffer[..used as usize]);
+    }
+}
+
+/// C-callable wrapper for write_stringz_as_smptett
+/// # Safety
+/// This function is unsafe because it dereferences raw pointers
+#[no_mangle]
+pub unsafe extern "C" fn write_stringz_as_smptett(
+    text: *const c_char,
+    context: *mut encoder_ctx,
+    ms_start: i64,
+    ms_end: i64,
+) {
+    if text.is_null() || context.is_null() {
+        return;
+    }
+
+    let text_str = match CStr::from_ptr(text).to_str() {
+        Ok(s) => s,
+        Err(_) => return,
+    };
+
+    write_stringz_as_smptett_internal(text_str, &mut *context, ms_start, ms_end);
+}
+
+/// Write EIA-608 screen buffer as SMPTE-TT
+/// # Safety
+/// This function is unsafe because it dereferences raw pointers and performs FFI operations
+#[no_mangle]
+pub unsafe extern "C" fn write_cc_buffer_as_smptett(
+    data: *mut eia608_screen,
+    context: *mut encoder_ctx,
+) -> c_int {
+    if data.is_null() || context.is_null() {
+        return 0;
+    }
+    let data = &mut *data;
+    let context = &mut *context;
+
+    let (mut h1, mut m1, mut s1, mut ms1) = (0, 0, 0, 0);
+    let (mut h2, mut m2, mut s2, mut ms2) = (0, 0, 0, 0);
+    let mut wrote_something = 0;
+
+    ccxr_millis_to_time(data.start_time, &mut h1, &mut m1, &mut s1, &mut ms1);
+    ccxr_millis_to_time(data.end_time - 1, &mut h2, &mut m2, &mut s2, &mut ms2);
+
+    let buffer: &mut [u8] =
+        std::slice::from_raw_parts_mut(context.buffer, context.capacity as usize);
+
+    for row in 0..15 {
+        if data.row_used[row] == 0 {
+            continue;
+        }
+
+        // Calculate row position (10% + row position in 80% of screen)
+        let row1 = ((100.0 * row as f32) / (ROWS as f32 / 0.8)) + 10.0;
+
+        // Find first non-space column
+        let mut firstcol = -1;
+        for column in 0..COLUMNS as usize {
+            let ch = data.characters[row][column];
+            // Check for non-space character (0x20 is space)
+            if ch != 0x20 && ch != 0 {
+                firstcol = column as i32;
+                break;
+            }
+        }
+
+        if firstcol < 0 {
+            continue;
+        }
+
+        // Calculate column position
+        let col1 = ((100.0 * firstcol as f32) / (COLUMNS as f32 / 0.8)) + 10.0;
+
+        wrote_something = 1;
+
+        // Write opening tag with positioning
+        let opening = format!(
+            "      <p begin=\"{:02}:{:02}:{:02}.{:03}\" end=\"{:02}:{:02}:{:02}.{:03}\" tts:origin=\"{:.3}% {:.3}%\">\n        <span>",
+            h1, m1, s1, ms1, h2, m2, s2, ms2, col1, row1
+        );
+
+        if context.encoding != ccx_encoding_type_CCX_ENC_UNICODE {
+            debug!(msg_type = DebugMessageFlag::DECODER_608; "\r{}\n", opening.trim_end());
+        }
+
+        let used = encode_line(context, buffer, opening.as_bytes());
+        let out = &*context.out;
+        let _ = write_wrapped(out.fh, &buffer[..used as usize]);
+
+        // Get the decoded line - store it in context.subline
+        extern "C" {
+            fn get_decoder_line_encoded(
+                ctx: *mut encoder_ctx,
+                buf: *mut u8,
+                line_num: c_int,
+                data: *const eia608_screen,
+            ) -> u32;
+        }
+
+        get_decoder_line_encoded(
+            context as *mut encoder_ctx,
+            context.subline,
+            row as c_int,
+            data as *const eia608_screen,
+        );
+
+        // Convert subline to Rust string for processing
+        let line_text = {
+            let subline_slice = std::slice::from_raw_parts(
+                context.subline,
+                4096, // Max line length
+            );
+            let null_pos = subline_slice.iter().position(|&b| b == 0).unwrap_or(4096);
+            String::from_utf8_lossy(&subline_slice[..null_pos]).to_string()
+        };
+
+        // Process styling (italics, bold, underline, colors)
+        let formatted = process_line_styling(&line_text);
+
+        let used = encode_line(context, buffer, formatted.as_bytes());
+        let out = &*context.out;
+        let _ = write_wrapped(out.fh, &buffer[..used as usize]);
+
+        // Write CRLF
+        let crlf_slice = std::slice::from_raw_parts(
+            context.encoded_crlf.as_ptr(),
+            context.encoded_crlf_length as usize,
+        );
+        let _ = write_wrapped(out.fh, crlf_slice);
+
+        // Write closing tags
+        let closing = b"        <style tts:backgroundColor=\"#000000FF\" tts:fontSize=\"18px\"/></span>\n      </p>\n";
+        let used = encode_line(context, buffer, closing);
+
+        if context.encoding != ccx_encoding_type_CCX_ENC_UNICODE {
+            debug!(msg_type = DebugMessageFlag::DECODER_608; "\r{}\n", 
+                std::str::from_utf8(closing).unwrap_or(""));
+        }
+
+        let out = &*context.out;
+        let _ = write_wrapped(out.fh, &buffer[..used as usize]);
+    }
+
+    wrote_something
+}
+
+fn process_line_styling(line: &str) -> String {
+    let mut result = String::new();
+
+    // Check for italics
+    if let Some(start_pos) = line.find("<i>") {
+        if let Some(end_pos) = line.find("</i>") {
+            result.push_str(&line[..start_pos]);
+            result.push_str("<span>");
+            result.push_str(&line[start_pos + 3..end_pos]);
+            result.push_str("<style tts:backgroundColor=\"#000000FF\" tts:fontSize=\"18px\" tts:fontStyle=\"italic\"/> </span>");
+            result.push_str(&line[end_pos + 4..]);
+            return result;
+        }
+    }
+
+    // Check for bold
+    if let Some(start_pos) = line.find("<b>") {
+        if let Some(end_pos) = line.find("</b>") {
+            result.push_str(&line[..start_pos]);
+            result.push_str("<span>");
+            result.push_str(&line[start_pos + 3..end_pos]);
+            result.push_str("<style tts:backgroundColor=\"#000000FF\" tts:fontSize=\"18px\" tts:fontWeight=\"bold\"/> </span>");
+            result.push_str(&line[end_pos + 4..]);
+            return result;
+        }
+    }
+
+    // Check for underline
+    if let Some(start_pos) = line.find("<u>") {
+        if let Some(end_pos) = line.find("</u>") {
+            result.push_str(&line[..start_pos]);
+            result.push_str("<span>");
+            result.push_str(&line[start_pos + 3..end_pos]);
+            result.push_str("<style tts:backgroundColor=\"#000000FF\" tts:fontSize=\"18px\" tts:textDecoration=\"underline\"/> </span>");
+            result.push_str(&line[end_pos + 4..]);
+            return result;
+        }
+    }
+
+    // Check for font color
+    if let Some(start_pos) = line.find("<font color") {
+        if let Some(end_pos) = line.find("</font>") {
+            result.push_str(&line[..start_pos]);
+            result.push_str("<span>");
+
+            // Extract color code
+            if let Some(color_start) = line[start_pos..].find('#') {
+                let color_pos = start_pos + color_start;
+                if color_pos + 7 <= line.len() {
+                    let color_code = &line[color_pos + 1..color_pos + 7];
+
+                    // Find content start (after '>')
+                    if let Some(content_start) = line[start_pos..end_pos].find('>') {
+                        let content_pos = start_pos + content_start + 1;
+                        result.push_str(&line[content_pos..end_pos]);
+                        result.push_str(&format!(
+                            "<style tts:backgroundColor=\"#FFFF00FF\" tts:color=\"{}\" tts:fontSize=\"18px\"/></span>",
+                            color_code
+                        ));
+                        result.push_str(&line[end_pos + 7..]);
+                        return result;
+                    }
+                }
+            }
+        }
+    }
+
+    // No styling found, return as is
+    line.to_string()
+}
+
+/// Write subtitle as SMPTE-TT
+/// # Safety
+/// This function is unsafe because it dereferences raw pointers and performs FFI operations
+#[no_mangle]
+pub unsafe extern "C" fn write_cc_subtitle_as_smptett(
+    sub: *mut cc_subtitle,
+    context: *mut encoder_ctx,
+) -> c_int {
+    if sub.is_null() || context.is_null() {
+        return 0;
+    }
+    let sub = &mut *sub;
+    let context = &mut *context;
+
+    let mut current = sub as *mut cc_subtitle;
+    let original = current;
+
+    // Process all subtitles in the linked list
+    while !current.is_null() {
+        let sub_ref = &mut *current;
+
+        // Check if it's CC_TEXT type (subtype_CC_TEXT = 0)
+        if sub_ref.type_ == subtype_CC_TEXT {
+            if !sub_ref.data.is_null() {
+                // Convert C string to Rust string
+                let c_str = CStr::from_ptr(sub_ref.data as *const i8);
+                if let Ok(text) = c_str.to_str() {
+                    write_stringz_as_smptett_internal(
+                        text,
+                        context,
+                        sub_ref.start_time,
+                        sub_ref.end_time,
+                    );
+                }
+
+                // Free the data using C free
+                extern "C" {
+                    fn free(ptr: *mut c_void);
+                }
+                free(sub_ref.data);
+                sub_ref.data = std::ptr::null_mut();
+            }
+            sub_ref.nb_data = 0;
+        }
+
+        current = sub_ref.next;
+    }
+
+    // Free the subtitle list (going backwards to original)
+    current = original;
+    while !current.is_null() {
+        let sub_ref = &mut *current;
+        let next = sub_ref.next;
+
+        if current != original {
+            extern "C" {
+                fn free(ptr: *mut c_void);
+            }
+            free(current as *mut c_void);
+        }
+
+        current = next;
+    }
+
+    0
+}
+
+/// Write bitmap subtitle as SMPTE-TT
+/// # Safety
+/// This function is unsafe because it dereferences raw pointers and performs FFI operations
+#[no_mangle]
+pub unsafe extern "C" fn write_cc_bitmap_as_smptett(
+    sub: *mut cc_subtitle,
+    _context: *mut encoder_ctx,
+) -> c_int {
+    if sub.is_null() {
+        return 0;
+    }
+    let sub = &mut *sub;
+
+    #[cfg(feature = "hardsubx_ocr")]
+    {
+        // Would implement bitmap OCR handling here similar to C code
+        // For now, just clean up
+        if !sub.data.is_null() {
+            extern "C" {
+                fn free(ptr: *mut c_void);
+            }
+            free(sub.data);
+            sub.data = std::ptr::null_mut();
+        }
+        sub.nb_data = 0;
+        0
+    }
+
+    #[cfg(not(feature = "hardsubx_ocr"))]
+    {
+        // Without OCR, just clean up and return
+        if !sub.data.is_null() {
+            extern "C" {
+                fn free(ptr: *mut c_void);
+            }
+            free(sub.data);
+            sub.data = std::ptr::null_mut();
+        }
+        sub.nb_data = 0;
+        0
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_smptett_escape_basic() {
+        assert_eq!(escape_xml("a & b < c"), "a &amp; b &lt; c");
+        assert_eq!(
+            escape_xml("\"quote\" 'apos' & < >"),
+            "&quot;quote&quot; &apos;apos&apos; &amp; &lt; &gt;"
+        );
+    }
+
+    #[test]
+    fn test_styling_italic() {
+        let input = "This is <i>italic</i> text";
+        let output = process_line_styling(input);
+        assert!(output.contains("<span>"));
+        assert!(output.contains("fontStyle=\"italic\""));
+    }
+
+    #[test]
+    fn test_styling_bold() {
+        let input = "This is <b>bold</b> text";
+        let output = process_line_styling(input);
+        assert!(output.contains("fontWeight=\"bold\""));
+    }
+
+    #[test]
+    fn test_no_styling() {
+        let input = "Plain text";
+        let output = process_line_styling(input);
+        assert_eq!(output, "Plain text");
+    }
+}