diff --git a/src/lib_ccx/ccx_encoders_webvtt.c b/src/lib_ccx/ccx_encoders_webvtt.c
index 68f161579..0f48704ff 100644
--- a/src/lib_ccx/ccx_encoders_webvtt.c
+++ b/src/lib_ccx/ccx_encoders_webvtt.c
@@ -230,13 +230,37 @@ void write_webvtt_header(struct encoder_ctx *context)
 	else
 	{
 		// Must have another newline if X-TIMESTAMP-MAP is not used
-		if (ccx_options.enc_cfg.line_terminator_lf == 1) // If -lf parameter is set.
+		// if (ccx_options.enc_cfg.line_terminator_lf == 1) // If -lf parameter is set.
+		// {
+		// 	write_wrapped(context->out->fh, "\n", 1);
+		// }
+		// else
+		// {
+		// 	write_wrapped(context->out->fh, "\r\n", 2);
+		// }
+				// Issue #1743: write default X-TIMESTAMP-MAP when timing info is unavailable
+		if (ccx_options.timestamp_map)
 		{
-			write_wrapped(context->out->fh, "\n", 1);
+			const char *default_header =
+			    ccx_options.enc_cfg.line_terminator_lf
+				? "X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:0\n\n"
+				: "X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:0\r\n\r\n";
+
+			write_wrapped(context->out->fh,
+				      default_header,
+				      strlen(default_header));
 		}
 		else
 		{
-			write_wrapped(context->out->fh, "\r\n", 2);
+			// Must have another newline if X-TIMESTAMP-MAP is not used
+			if (ccx_options.enc_cfg.line_terminator_lf == 1)
+			{
+				write_wrapped(context->out->fh, "\n", 1);
+			}
+			else
+			{
+				write_wrapped(context->out->fh, "\r\n", 2);
+			}
 		}
 	}
 
diff --git a/src/lib_ccx/ttml.c b/src/lib_ccx/ttml.c
new file mode 100644
index 000000000..28f9a47f4
--- /dev/null
+++ b/src/lib_ccx/ttml.c
@@ -0,0 +1,124 @@
+#include "ttml.h"
+#include "ccx_encoders_common.h"
+#include "utility.h"
+#include "ccx_common_timing.h"
+#include <string.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+// Initialize TTML encoder context
+void ttml_init(struct ttml_ctx *ctx, struct encoder_ctx *parent)
+{
+    ctx->parent = parent;
+    ctx->wrote_header = 0;
+    ctx->last_start_time = 0;
+    ctx->last_end_time = 0;
+}
+
+// Write TTML XML header
+int ttml_write_header(struct ttml_ctx *ctx)
+{
+    if (ctx->wrote_header)
+        return 0;
+    
+    const char *header = 
+        "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
+        "<tt xmlns=\"http://www.w3.org/ns/ttml\"\n"
+        "    xmlns:tts=\"http://www.w3.org/ns/ttml#styling\">\n"
+        "  <head>\n"
+        "    <styling>\n"
+        "      <style xml:id=\"defaultStyle\" tts:fontFamily=\"monospace\" "
+        "tts:fontSize=\"1c\" tts:color=\"white\"/>\n"
+        "    </styling>\n"
+        "  </head>\n"
+        "  <body>\n"
+        "    <div>\n";
+    
+    write(ctx->parent->out->fh, header, strlen(header));
+    ctx->wrote_header = 1;
+    return 0;
+}
+
+// Write TTML footer
+int ttml_write_footer(struct ttml_ctx *ctx)
+{
+    const char *footer = 
+        "    </div>\n"
+        "  </body>\n"
+        "</tt>\n";
+    
+    write(ctx->parent->out->fh, footer, strlen(footer));
+    return 0;
+}
+
+// Convert timestamp to TTML format (HH:MM:SS.mmm)
+static void timestamp_to_ttml(int64_t timestamp, char *buffer, size_t bufsize)
+{
+    int hours = (int)(timestamp / 3600000);
+    int minutes = (int)((timestamp % 3600000) / 60000);
+    int seconds = (int)((timestamp % 60000) / 1000);
+    int milliseconds = (int)(timestamp % 1000);
+    
+    snprintf(buffer, bufsize, "%02d:%02d:%02d.%03d", 
+             hours, minutes, seconds, milliseconds);
+}
+
+// Write a single subtitle entry in TTML format
+int ttml_write_subtitle(struct ttml_ctx *ctx, struct cc_subtitle *sub)
+{
+    if (!ctx->wrote_header)
+        ttml_write_header(ctx);
+    
+    char start_time[32];
+    char end_time[32];
+    
+    timestamp_to_ttml(sub->start_time, start_time, sizeof(start_time));
+    timestamp_to_ttml(sub->end_time, end_time, sizeof(end_time));
+    
+    // Write opening tag
+    char buffer[256];
+    snprintf(buffer, sizeof(buffer),
+             "      <p begin=\"%s\" end=\"%s\" style=\"defaultStyle\">\n",
+             start_time, end_time);
+    write(ctx->parent->out->fh, buffer, strlen(buffer));
+    
+    // Write subtitle text (with proper XML escaping)
+    for (int i = 0; i < sub->nb_data; i++) {
+        unsigned char c = sub->data[i];
+        
+        if (c == '<')
+            write(ctx->parent->out->fh, "&lt;", 4);
+        else if (c == '>')
+            write(ctx->parent->out->fh, "&gt;", 4);
+        else if (c == '&')
+            write(ctx->parent->out->fh, "&amp;", 5);
+        else if (c == '"')
+            write(ctx->parent->out->fh, "&quot;", 6);
+        else if (c == '\n')
+            write(ctx->parent->out->fh, "<br/>", 5);
+        else
+            write(ctx->parent->out->fh, &c, 1);
+    }
+    
+    // Write closing tag
+    const char *close_tag = "\n      </p>\n";
+    write(ctx->parent->out->fh, close_tag, strlen(close_tag));
+    
+    return 0;
+}
+
+// Main write function called by encoder framework
+int write_ttml(struct cc_subtitle *sub, struct encoder_ctx *context)
+{
+    struct ttml_ctx *ctx = (struct ttml_ctx *)context->private_data;
+    
+    if (!ctx) {
+        ctx = (struct ttml_ctx *)malloc(sizeof(struct ttml_ctx));
+        if (!ctx)
+            return -1;
+        ttml_init(ctx, context);
+        context->private_data = ctx;
+    }
+    
+    return ttml_write_subtitle(ctx, sub);
+}
diff --git a/src/lib_ccx/ttml.h b/src/lib_ccx/ttml.h
new file mode 100644
index 000000000..13e118349
--- /dev/null
+++ b/src/lib_ccx/ttml.h
@@ -0,0 +1,30 @@
+#ifndef TTML_H
+#define TTML_H
+
+#include "ccx_common_platform.h"
+#include "ccx_encoders_common.h"
+
+// TTML encoder context
+struct ttml_ctx {
+    struct encoder_ctx *parent;
+    int wrote_header;
+    int64_t last_start_time;
+    int64_t last_end_time;
+};
+
+// Initialize TTML encoder
+void ttml_init(struct ttml_ctx *ctx, struct encoder_ctx *parent);
+
+// Write TTML header
+int ttml_write_header(struct ttml_ctx *ctx);
+
+// Write TTML subtitle entry
+int ttml_write_subtitle(struct ttml_ctx *ctx, struct cc_subtitle *sub);
+
+// Write TTML footer
+int ttml_write_footer(struct ttml_ctx *ctx);
+
+// Encode a single screen to TTML
+int write_ttml(struct cc_subtitle *sub, struct encoder_ctx *context);
+
+#endif // TTML_H
diff --git a/src/lib_ccx/ttml_isobmff.c b/src/lib_ccx/ttml_isobmff.c
new file mode 100644
index 000000000..043ddd7e3
--- /dev/null
+++ b/src/lib_ccx/ttml_isobmff.c
@@ -0,0 +1,207 @@
+#include "ttml_isobmff.h"
+#include "lib_ccx.h"
+#include "utility.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+/**
+ * Detect TTML tracks in ISO-BMFF container
+ * According to ISO 14496-30, TTML tracks have:
+ * - Handler type: 'subt' 
+ * - Sample entry: 'stpp'
+ */
+int detect_ttml_isobmff_tracks(GF_ISOFile *isom_file, struct lib_ccx_ctx *ctx)
+{
+    uint32_t track_count;
+    uint32_t ttml_track_count = 0;
+    
+    if (!isom_file) {
+        mprint("Error: NULL ISO file handle\n");
+        return -1;
+    }
+    
+    track_count = gf_isom_get_track_count(isom_file);
+    mprint("Total tracks in file: %u\n", track_count);
+    
+    for (uint32_t i = 1; i <= track_count; i++) {
+        u32 handler_type = gf_isom_get_media_type(isom_file, i);
+        u32 subtype = gf_isom_get_media_subtype(isom_file, i, 1);
+        
+        // Check for TTML track (handler='subt', subtype='stpp')
+        if (handler_type == GF_ISOM_HANDLER_TYPE_SUBT && 
+            subtype == GF_ISOM_SUBTYPE_STPP) {
+            mprint("Found TTML track (ISO-BMFF): Track ID %u\n", i);
+            ttml_track_count++;
+            
+            // Validate this track
+            ttml_isobmff_track_t track_info;
+            memset(&track_info, 0, sizeof(track_info));
+            
+            int validation_result = validate_ttml_isobmff_track(isom_file, i, &track_info);
+            
+            if (validation_result == TTML_VALID) {
+                mprint("  ✓ Track %u: VALID TTML structure\n", i);
+                mprint("    - Timescale: %u\n", track_info.timescale);
+                mprint("    - Samples: %u\n", track_info.sample_count);
+                if (track_info.namespace_uri) {
+                    mprint("    - Namespace: %s\n", track_info.namespace_uri);
+                }
+            } else {
+                mprint("  ✗ Track %u: VALIDATION FAILED (error code: %d)\n", i, validation_result);
+            }
+            
+            free_ttml_track_info(&track_info);
+        }
+    }
+    
+    if (ttml_track_count == 0) {
+        mprint("No TTML tracks found in ISO-BMFF container\n");
+    } else {
+        mprint("Total TTML tracks found: %u\n", ttml_track_count);
+    }
+    
+    return ttml_track_count;
+}
+
+/**
+ * Validate TTML track structure according to ISO 14496-30
+ */
+int validate_ttml_isobmff_track(GF_ISOFile *isom_file, uint32_t track_num, ttml_isobmff_track_t *track_info)
+{
+    if (!isom_file || !track_info) {
+        return TTML_INVALID_SAMPLE_STRUCTURE;
+    }
+    
+    // Get track information
+    track_info->track_id = gf_isom_get_track_id(isom_file, track_num);
+    track_info->timescale = gf_isom_get_media_timescale(isom_file, track_num);
+    track_info->sample_count = gf_isom_get_sample_count(isom_file, track_num);
+    
+    // Validate timescale (must be > 0)
+    if (track_info->timescale == 0) {
+        mprint("    Error: Invalid timescale (0)\n");
+        return TTML_INVALID_TIMING;
+    }
+    
+    // Validate sample count
+    if (track_info->sample_count == 0) {
+        mprint("    Warning: Track has no samples\n");
+    }
+    
+    // Try to get namespace from sample description
+    // In a full implementation, we would parse the stpp box structure
+    // For now, we check basic structure validity
+    
+    // Check if handler type is correct
+    u32 handler_type = gf_isom_get_media_type(isom_file, track_num);
+    if (handler_type != GF_ISOM_HANDLER_TYPE_SUBT) {
+        mprint("    Error: Invalid handler type\n");
+        return TTML_MISSING_REQUIRED_BOX;
+    }
+    
+    // Check if sample entry is stpp
+    u32 subtype = gf_isom_get_media_subtype(isom_file, track_num, 1);
+    if (subtype != GF_ISOM_SUBTYPE_STPP) {
+        mprint("    Error: Invalid sample entry (expected 'stpp')\n");
+        return TTML_MISSING_REQUIRED_BOX;
+    }
+    // Set as valid
+    track_info->is_valid = 1;
+    
+    return TTML_VALID;
+}
+
+/**
+ * Extract TTML content from ISO-BMFF track
+ */
+int extract_ttml_from_isobmff(GF_ISOFile *isom_file, uint32_t track_num, const char *output_file)
+{
+    FILE *out_fp = NULL;
+    GF_ISOSample *sample = NULL;
+    uint32_t sample_count;
+    
+    if (!isom_file || !output_file) {
+        return -1;
+    }
+    
+    sample_count = gf_isom_get_sample_count(isom_file, track_num);
+    
+    out_fp = fopen(output_file, "wb");
+    if (!out_fp) {
+        mprint("Error: Cannot open output file %s\n", output_file);
+        return -1;
+    }
+    
+    // Write TTML XML header
+    fprintf(out_fp, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
+    fprintf(out_fp, "<tt xmlns=\"http://www.w3.org/ns/ttml\">\n");
+    fprintf(out_fp, "<body>\n");
+    
+    // Extract each sample
+    for (uint32_t i = 1; i <= sample_count; i++) {
+        sample = gf_isom_get_sample(isom_file, track_num, i, NULL);
+        
+        if (sample && sample->data && sample->dataLength > 0) {
+            // Write sample data (TTML XML fragments)
+            fwrite(sample->data, 1, sample->dataLength, out_fp);
+            fprintf(out_fp, "\n");
+        }
+        
+        if (sample) {
+            gf_isom_sample_del(&sample);
+        }
+    }
+    
+    fprintf(out_fp, "</body>\n");
+    fprintf(out_fp, "</tt>\n");
+    
+    fclose(out_fp);
+    
+    mprint("TTML content extracted to: %s\n", output_file);
+    
+    return 0;
+}
+
+/**
+ * Free allocated resources
+ */
+void free_ttml_track_info(ttml_isobmff_track_t *track)
+{
+    if (track) {
+        if (track->namespace_uri) {
+            free(track->namespace_uri);
+            track->namespace_uri = NULL;
+        }
+        if (track->schema_location) {
+            free(track->schema_location);
+            track->schema_location = NULL;
+        }
+    }
+}
+
+/**
+ * Process TTML track - main entry point
+ */
+int process_ttml_track(struct lib_ccx_ctx *ctx, GF_ISOFile *isom_file, uint32_t track_num)
+{
+    ttml_isobmff_track_t track_info;
+    memset(&track_info, 0, sizeof(track_info));
+    
+    int validation_result = validate_ttml_isobmff_track(isom_file, track_num, &track_info);
+    
+    if (validation_result != TTML_VALID) {
+        mprint("TTML track validation failed\n");
+        free_ttml_track_info(&track_info);
+        return -1;
+    }
+    
+    // If validation requested, we're done
+    // if (ctx->extract_only) {
+    //     mprint("TTML track structure is VALID per ISO 14496-30\n");
+    // }
+    
+    free_ttml_track_info(&track_info);
+    
+    return 0;
+}
diff --git a/src/lib_ccx/ttml_isobmff.h b/src/lib_ccx/ttml_isobmff.h
new file mode 100644
index 000000000..975ebf6e2
--- /dev/null
+++ b/src/lib_ccx/ttml_isobmff.h
@@ -0,0 +1,39 @@
+#ifndef TTML_ISOBMFF_H
+#define TTML_ISOBMFF_H
+
+#include "ccx_common_platform.h"
+#include "ccx_common_structs.h"
+#include <gpac/isomedia.h>
+#include "lib_ccx.h"
+
+
+// TTML track types according to ISO 14496-30
+#define GF_ISOM_SUBTYPE_STPP GF_4CC('s', 't', 'p', 'p')  // TTML in ISO-BMFF
+#define GF_ISOM_HANDLER_TYPE_SUBT GF_4CC('s', 'u', 'b', 't') // Subtitle handler
+
+// TTML ISO-BMFF Track Structure
+typedef struct {
+    uint32_t track_id;
+    uint32_t timescale;
+    char *namespace_uri;
+    char *schema_location;
+    uint8_t is_valid;
+    uint32_t sample_count;
+} ttml_isobmff_track_t;
+
+// Validation error codes
+#define TTML_VALID 0
+#define TTML_INVALID_NAMESPACE 1
+#define TTML_INVALID_TIMING 2
+#define TTML_MISSING_REQUIRED_BOX 3
+#define TTML_INVALID_SAMPLE_STRUCTURE 4
+#define TTML_ERROR_NO_TRACK 5
+
+// Function declarations
+int detect_ttml_isobmff_tracks(GF_ISOFile *isom_file, struct lib_ccx_ctx *ctx);
+int validate_ttml_isobmff_track(GF_ISOFile *isom_file, uint32_t track_num, ttml_isobmff_track_t *track_info);
+int extract_ttml_from_isobmff(GF_ISOFile *isom_file, uint32_t track_num, const char *output_file);
+void free_ttml_track_info(ttml_isobmff_track_t *track);
+int process_ttml_track(struct lib_ccx_ctx *ctx, GF_ISOFile *isom_file, uint32_t track_num);
+
+#endif // TTML_ISOBMFF_H
