fix(mcc): Add MCC output support for raw caption files

Previously, when using -out=mcc with raw input files (-in=raw),
CCExtractor would print "Output format not supported" and produce
no output. This was because the raw file processing path decoded
CEA-608 data to text, but MCC format requires raw cc_data bytes.

The fix adds a new code path that bypasses the 608 decoder when
MCC output is requested:

- Added process_raw_for_mcc() helper function that:
  - Converts 2-byte raw pairs to 3-byte cc_data format
  - Wraps each CC pair in CDP format via mcc_encode_cc_data()
  - Maintains proper timing at 29.97fps

- Modified raw_loop() to detect MCC output and use the new path

Test results with McPoodle raw files:
- Before: "Output format not supported" (exit code 10)
- After: Valid MCC file with proper timing and CDP-wrapped data

Fixes #1542

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <[email protected]>

Author: cfsmp3

src/lib_ccx/general_loop.c

@@ -8,6 +8,7 @@
 
 #include "dvb_subtitle_decoder.h"
 #include "ccx_encoders_common.h"
+#include "ccx_encoders_mcc.h"
 #include "activity.h"
 #include "utility.h"
 #include "ccx_demuxer.h"
@@ -520,6 +521,50 @@ void process_hex(struct lib_ccx_ctx *ctx, char *filename)
 	fclose(fr);
 }
 #endif
+
+/* Process raw caption data (2-byte pairs) and encode directly to MCC format.
+ * This bypasses the 608 decoder and writes raw cc_data to MCC.
+ * Used when -out=mcc is specified with raw input files (issue #1542). */
+static size_t process_raw_for_mcc(struct encoder_ctx *enc_ctx, struct lib_cc_decode *dec_ctx,
+				  unsigned char *buffer, size_t len)
+{
+	unsigned char cc_data[3];
+	size_t i;
+	size_t pairs_processed = 0;
+
+	// Set frame rate to 29.97fps (code 4) for raw 608 captions
+	// This is needed for proper MCC timing
+	if (dec_ctx->current_frame_rate == 0)
+		dec_ctx->current_frame_rate = 4; // CCX_FR_29_97
+
+	cc_data[0] = 0x04; // Field 1, cc_valid=1, cc_type=0 (NTSC field 1)
+
+	for (i = 0; i < len; i += 2)
+	{
+		// Skip broadcast header (0xff 0xff)
+		if (!dec_ctx->saw_caption_block && buffer[i] == 0xff && buffer[i + 1] == 0xff)
+			continue;
+
+		dec_ctx->saw_caption_block = 1;
+		cc_data[1] = buffer[i];
+		cc_data[2] = buffer[i + 1];
+
+		// Update timing for this CC pair (each pair is one frame at 29.97fps)
+		// Timing: 1001/30 ms per pair = ~33.37ms
+		set_fts(enc_ctx->timing);
+
+		// Encode this CC pair to MCC format
+		mcc_encode_cc_data(enc_ctx, dec_ctx, cc_data, 1);
+
+		// Advance timing for next pair
+		add_current_pts(enc_ctx->timing, 1001 * (MPEG_CLOCK_FREQ / 1000) / 30);
+
+		pairs_processed++;
+	}
+
+	return pairs_processed;
+}
+
 // Raw file process
 int raw_loop(struct lib_ccx_ctx *ctx)
 {
@@ -529,11 +574,20 @@ int raw_loop(struct lib_ccx_ctx *ctx)
 	struct encoder_ctx *enc_ctx = update_encoder_list(ctx);
 	struct lib_cc_decode *dec_ctx = NULL;
 	int caps = 0;
-	int is_dvdraw = 0; // Flag to track if this is DVD raw format
+	int is_dvdraw = 0;     // Flag to track if this is DVD raw format
+	int is_mcc_output = 0; // Flag for MCC output format
 
 	dec_ctx = update_decoder_list(ctx);
 	dec_sub = &dec_ctx->dec_sub;
 
+	// Check if MCC output is requested (issue #1542)
+	if (enc_ctx && dec_ctx->write_format == CCX_OF_MCC)
+	{
+		is_mcc_output = 1;
+		// Share timing context between decoder and encoder for MCC
+		enc_ctx->timing = dec_ctx->timing;
+	}
+
 	// For raw mode, timing is derived from the caption block counter (cb_field1).
 	// We set min_pts=0 and pts_set=MinPtsSet so set_fts() will calculate fts_now.
 	// Initialize timing for raw mode - no video PTS, just caption block counting.
@@ -559,7 +613,15 @@ int raw_loop(struct lib_ccx_ctx *ctx)
 			mprint("Detected McPoodle's DVD raw format\n");
 		}
 
-		if (is_dvdraw)
+		if (is_mcc_output && !is_dvdraw)
+		{
+			// For MCC output, encode raw data directly without decoding
+			// This preserves the original CEA-608 byte pairs in CDP format
+			size_t pairs = process_raw_for_mcc(enc_ctx, dec_ctx, data->buffer, data->len);
+			if (pairs > 0)
+				caps = 1;
+		}
+		else if (is_dvdraw)
 		{
 			// Use Rust implementation - handles timing internally
 			ret = ccxr_process_dvdraw(dec_ctx, dec_sub, data->buffer, (unsigned int)data->len);
@@ -577,7 +639,7 @@ int raw_loop(struct lib_ccx_ctx *ctx)
 			set_fts(dec_ctx->timing);
 		}
 
-		if (dec_sub->got_output)
+		if (!is_mcc_output && dec_sub->got_output)
 		{
 			caps = 1;
 			encode_sub(enc_ctx, dec_sub);