fix(mp4): Add HEVC/H.265 caption extraction for MP4 containers

PR #1852 added HEVC caption extraction for MPEG-TS containers,
but MP4/MKV containers weren't supported. This adds HEVC support
for MP4 containers using GPAC.

Changes:
- Add HEVC subtype definitions (hev1, hvc1)
- Add process_hevc_sample() to parse HEVC NAL units and extract CC
- Add process_hevc_track() to iterate through HEVC track samples
- Detect and process HEVC tracks in processmp4()
- Add store_hdcc() call to flush buffered CC data after each sample

The key fix was adding store_hdcc() after processing each sample.
Without this, CC data was being parsed but never output because
store_hdcc() is normally called from slice_header() which is
AVC-only.

Closes #1690 (for MP4 containers)

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

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

Author: cfsmp3

src/lib_ccx/mp4.c

@@ -3,6 +3,7 @@
 #include <stdlib.h>
 
 #include <gpac/isomedia.h>
+#include <gpac/mpeg4_odf.h>
 #include "lib_ccx.h"
 #include "utility.h"
 #include "ccx_encoders_common.h"
@@ -16,6 +17,14 @@
 
 #define GF_ISOM_SUBTYPE_C708 GF_4CC('c', '7', '0', '8')
 
+// HEVC subtypes (hev1, hvc1)
+#ifndef GF_ISOM_SUBTYPE_HEV1
+#define GF_ISOM_SUBTYPE_HEV1 GF_4CC('h', 'e', 'v', '1')
+#endif
+#ifndef GF_ISOM_SUBTYPE_HVC1
+#define GF_ISOM_SUBTYPE_HVC1 GF_4CC('h', 'v', 'c', '1')
+#endif
+
 static short bswap16(short v)
 {
 	return ((v >> 8) & 0x00FF) | ((v << 8) & 0xFF00);
@@ -101,6 +110,88 @@ static int process_avc_sample(struct lib_ccx_ctx *ctx, u32 timescale, GF_AVCConf
 
 	return status;
 }
+
+static int process_hevc_sample(struct lib_ccx_ctx *ctx, u32 timescale, GF_HEVCConfig *c, GF_ISOSample *s, struct cc_subtitle *sub)
+{
+	int status = 0;
+	u32 i;
+	s32 signed_cts = (s32)s->CTS_Offset;
+	struct lib_cc_decode *dec_ctx = NULL;
+	struct encoder_ctx *enc_ctx = NULL;
+
+	dec_ctx = update_decoder_list(ctx);
+	enc_ctx = update_encoder_list(ctx);
+
+	// Enable HEVC mode for NAL parsing
+	dec_ctx->avc_ctx->is_hevc = 1;
+
+	set_current_pts(dec_ctx->timing, (s->DTS + signed_cts) * MPEG_CLOCK_FREQ / timescale);
+	set_fts(dec_ctx->timing);
+
+	for (i = 0; i < s->dataLength;)
+	{
+		u32 nal_length;
+
+		if (i + c->nal_unit_size > s->dataLength)
+		{
+			mprint("Corrupted packet detected in process_hevc_sample. dataLength "
+			       "%u is less than index %u + nal_unit_size %u. Ignoring.\n",
+			       s->dataLength, i, c->nal_unit_size);
+			return status;
+		}
+		switch (c->nal_unit_size)
+		{
+			case 1:
+				nal_length = s->data[i];
+				break;
+			case 2:
+				nal_length = bswap16(*(short *)&s->data[i]);
+				break;
+			case 4:
+				nal_length = bswap32(*(long *)&s->data[i]);
+				break;
+			default:
+				mprint("Unexpected nal_unit_size %u in HEVC config\n", c->nal_unit_size);
+				return status;
+		}
+		const u32 previous_index = i;
+		i += c->nal_unit_size;
+		if (i + nal_length <= previous_index || i + nal_length > s->dataLength)
+		{
+			mprint("Corrupted sample detected in process_hevc_sample. dataLength %u "
+			       "is less than index %u + nal_unit_size %u + nal_length %u. Ignoring.\n",
+			       s->dataLength, previous_index, c->nal_unit_size, nal_length);
+			return status;
+		}
+
+		s_nalu_stats.total += 1;
+		temp_debug = 0;
+
+		if (nal_length > 0)
+		{
+			// For HEVC, NAL type is in bits [6:1] of byte 0
+			u8 nal_type = (s->data[i] >> 1) & 0x3F;
+			if (nal_type < 32)
+				s_nalu_stats.type[nal_type] += 1;
+			do_NAL(enc_ctx, dec_ctx, (unsigned char *)&(s->data[i]), nal_length, sub);
+		}
+		i += nal_length;
+	}
+	assert(i == s->dataLength);
+
+	// For HEVC, we need to flush CC data after each sample (unlike H.264 which does this in slice_header)
+	// This is because HEVC SEI messages contain the CC data and we don't parse slice headers
+	if (dec_ctx->avc_ctx->cc_count > 0)
+	{
+		// Store the CC data for processing
+		store_hdcc(enc_ctx, dec_ctx, dec_ctx->avc_ctx->cc_data, dec_ctx->avc_ctx->cc_count,
+			   dec_ctx->timing->current_tref, dec_ctx->timing->fts_now, sub);
+		dec_ctx->avc_ctx->cc_buffer_saved = CCX_TRUE;
+		dec_ctx->avc_ctx->cc_count = 0;
+	}
+
+	return status;
+}
 static int process_xdvb_track(struct lib_ccx_ctx *ctx, const char *basename, GF_ISOFile *f, u32 track, struct cc_subtitle *sub)
 {
 	u32 timescale, i, sample_count;
@@ -223,6 +314,83 @@ static int process_avc_track(struct lib_ccx_ctx *ctx, const char *basename, GF_I
 	return status;
 }
 
+static int process_hevc_track(struct lib_ccx_ctx *ctx, const char *basename, GF_ISOFile *f, u32 track, struct cc_subtitle *sub)
+{
+	u32 timescale, i, sample_count, last_sdi = 0;
+	int status;
+	GF_HEVCConfig *c = NULL;
+	struct lib_cc_decode *dec_ctx = NULL;
+
+	dec_ctx = update_decoder_list(ctx);
+
+	// Enable HEVC mode
+	dec_ctx->avc_ctx->is_hevc = 1;
+
+	if ((sample_count = gf_isom_get_sample_count(f, track)) < 1)
+	{
+		return 0;
+	}
+
+	timescale = gf_isom_get_media_timescale(f, track);
+
+	status = 0;
+
+	for (i = 0; i < sample_count; i++)
+	{
+		u32 sdi;
+
+		GF_ISOSample *s = gf_isom_get_sample(f, track, i + 1, &sdi);
+
+		if (s != NULL)
+		{
+			if (sdi != last_sdi)
+			{
+				if (c != NULL)
+				{
+					gf_odf_hevc_cfg_del(c);
+					c = NULL;
+				}
+
+				if ((c = gf_isom_hevc_config_get(f, track, sdi)) == NULL)
+				{
+					gf_isom_sample_del(&s);
+					status = -1;
+					break;
+				}
+
+				last_sdi = sdi;
+			}
+
+			status = process_hevc_sample(ctx, timescale, c, s, sub);
+
+			gf_isom_sample_del(&s);
+
+			if (status != 0)
+			{
+				break;
+			}
+		}
+
+		int progress = (int)((i * 100) / sample_count);
+		if (ctx->last_reported_progress != progress)
+		{
+			int cur_sec = (int)(get_fts(dec_ctx->timing, dec_ctx->current_field) / 1000);
+			activity_progress(progress, cur_sec / 60, cur_sec % 60);
+			ctx->last_reported_progress = progress;
+		}
+	}
+	int cur_sec = (int)(get_fts(dec_ctx->timing, dec_ctx->current_field) / 1000);
+	activity_progress(100, cur_sec / 60, cur_sec % 60);
+
+	if (c != NULL)
+	{
+		gf_odf_hevc_cfg_del(c);
+		c = NULL;
+	}
+
+	return status;
+}
+
 static char *format_duration(u64 dur, u32 timescale, char *szDur, size_t szDur_size)
 {
 	u32 h, m, s, ms;
@@ -544,7 +712,7 @@ int processmp4(struct lib_ccx_ctx *ctx, struct ccx_s_mp4Cfg *cfg, char *file)
 {
 	int mp4_ret = 0;
 	GF_ISOFile *f;
-	u32 i, j, track_count, avc_track_count, cc_track_count;
+	u32 i, j, track_count, avc_track_count, hevc_track_count, cc_track_count;
 	struct cc_subtitle dec_sub;
 	struct lib_cc_decode *dec_ctx = NULL;
 	struct encoder_ctx *enc_ctx = update_encoder_list(ctx);
@@ -575,6 +743,7 @@ int processmp4(struct lib_ccx_ctx *ctx, struct ccx_s_mp4Cfg *cfg, char *file)
 	track_count = gf_isom_get_track_count(f);
 
 	avc_track_count = 0;
+	hevc_track_count = 0;
 	cc_track_count = 0;
 
 	for (i = 0; i < track_count; i++)
@@ -589,9 +758,11 @@ int processmp4(struct lib_ccx_ctx *ctx, struct ccx_s_mp4Cfg *cfg, char *file)
 			cc_track_count++;
 		if (type == GF_ISOM_MEDIA_VISUAL && subtype == GF_ISOM_SUBTYPE_AVC_H264)
 			avc_track_count++;
+		if (type == GF_ISOM_MEDIA_VISUAL && (subtype == GF_ISOM_SUBTYPE_HEV1 || subtype == GF_ISOM_SUBTYPE_HVC1))
+			hevc_track_count++;
 	}
 
-	mprint("MP4: found %u tracks: %u avc and %u cc\n", track_count, avc_track_count, cc_track_count);
+	mprint("MP4: found %u tracks: %u avc, %u hevc and %u cc\n", track_count, avc_track_count, hevc_track_count, cc_track_count);
 
 	for (i = 0; i < track_count; i++)
 	{
@@ -661,6 +832,54 @@ int processmp4(struct lib_ccx_ctx *ctx, struct ccx_s_mp4Cfg *cfg, char *file)
 				}
 				break;
 
+			case MEDIA_TYPE(GF_ISOM_MEDIA_VISUAL, GF_ISOM_SUBTYPE_HEV1): // vide:hev1 (HEVC)
+			case MEDIA_TYPE(GF_ISOM_MEDIA_VISUAL, GF_ISOM_SUBTYPE_HVC1): // vide:hvc1 (HEVC)
+				if (cc_track_count && !cfg->mp4vidtrack)
+					continue;
+				// If there are multiple tracks, change fd for different tracks
+				if (hevc_track_count > 1)
+				{
+					switch_output_file(ctx, enc_ctx, i);
+				}
+				// Enable HEVC mode for caption extraction
+				dec_ctx->avc_ctx->is_hevc = 1;
+
+				// Process VPS/SPS/PPS from HEVC config to enable SEI parsing
+				GF_HEVCConfig *hevc_cnf = gf_isom_hevc_config_get(f, i + 1, 1);
+				if (hevc_cnf != NULL)
+				{
+					// Process parameter sets from config
+					for (j = 0; j < gf_list_count(hevc_cnf->param_array); j++)
+					{
+						GF_NALUFFParamArray *ar = (GF_NALUFFParamArray *)gf_list_get(hevc_cnf->param_array, j);
+						if (ar)
+						{
+							for (u32 k = 0; k < gf_list_count(ar->nalus); k++)
+							{
+								GF_NALUFFParam *sl = (GF_NALUFFParam *)gf_list_get(ar->nalus, k);
+								if (sl && sl->data && sl->size > 0)
+								{
+									do_NAL(enc_ctx, dec_ctx, (unsigned char *)sl->data, sl->size, &dec_sub);
+								}
+							}
+						}
+					}
+					gf_odf_hevc_cfg_del(hevc_cnf);
+				}
+				if (process_hevc_track(ctx, file, f, i + 1, &dec_sub) != 0)
+				{
+					mprint("Error on process_hevc_track()\n");
+					free(dec_ctx->xds_ctx);
+					return -3;
+				}
+				if (dec_sub.got_output)
+				{
+					mp4_ret = 1;
+					encode_sub(enc_ctx, &dec_sub);
+					dec_sub.got_output = 0;
+				}
+				break;
+
 			default:
 				if (type != GF_ISOM_MEDIA_CLOSED_CAPTION && type != GF_ISOM_MEDIA_SUBT && type != GF_ISOM_MEDIA_TEXT)
 					break; // ignore non cc track
@@ -794,6 +1013,11 @@ int processmp4(struct lib_ccx_ctx *ctx, struct ccx_s_mp4Cfg *cfg, char *file)
 	else
 		mprint("Found no AVC track(s). ");
 
+	if (hevc_track_count)
+		mprint("Found %d HEVC track(s). ", hevc_track_count);
+	else
+		mprint("Found no HEVC track(s). ");
+
 	if (cc_track_count)
 		mprint("Found %d CC track(s).\n", cc_track_count);
 	else