Compare revisions

Alaric Senat · Steve Lhomme · Alaric Senat · Steve Lhomme · Alaric Senat · Steve Lhomme
--- a/modules/mux/webvtt.c
+++ b/modules/mux/webvtt.c
@@ -188,7 +188,10 @@ static int Mux(sout_mux_t *mux)
        }

        if (data)
+        {
+            data->i_flags |= BLOCK_FLAG_HEADER;
            sout_AccessOutWrite(mux->p_access, data);
+        }
        sys->header_done = true;
    }


--- a/modules/stream_out/Makefile.am
+++ b/modules/stream_out/Makefile.am
@@ -40,7 +40,8 @@ libstream_out_hls_plugin_la_SOURCES = \
 	stream_out/hls/variant_maps.h stream_out/hls/variant_maps.c \
 	stream_out/hls/storage.h stream_out/hls/storage.c \
 	stream_out/hls/segments.h stream_out/hls/segments.c \
-	stream_out/hls/codecs.h stream_out/hls/codecs.c
+	stream_out/hls/codecs.h stream_out/hls/codecs.c \
+	stream_out/hls/subtitles_segmenter.c
 libstream_out_hls_plugin_la_LIBADD = libvlc_hxxxhelper.la

 sout_LTLIBRARIES = \

--- a/modules/stream_out/hls/codecs.c
+++ b/modules/stream_out/hls/codecs.c
@@ -55,6 +55,12 @@ static int FormatMP4A(struct vlc_memstream *ms, const es_format_t *fmt)
    return (wrote == -1) ? VLC_ENOMEM : VLC_SUCCESS;
 }

+static int FormatWebVTT(struct vlc_memstream *ms)
+{
+    const int written = vlc_memstream_puts(ms, "wvtt");
+    return (written <= 0) ? VLC_ENOMEM : VLC_SUCCESS;
+}
+
 int hls_codec_Format(struct vlc_memstream *ms, const es_format_t *fmt)
 {
    switch (fmt->i_codec)
@@ -63,6 +69,9 @@ int hls_codec_Format(struct vlc_memstream *ms, const es_format_t *fmt)
            return FormatAVC1(ms, fmt);
        case VLC_CODEC_MP4A:
            return FormatMP4A(ms, fmt);
+        case VLC_CODEC_TEXT:
+        case VLC_CODEC_WEBVTT:
+            return FormatWebVTT(ms);
        default:
            return VLC_ENOTSUP;
    }
@@ -70,5 +79,6 @@ int hls_codec_Format(struct vlc_memstream *ms, const es_format_t *fmt)

 bool hls_codec_IsSupported(const es_format_t *fmt)
 {
-    return fmt->i_codec == VLC_CODEC_H264 || fmt->i_codec == VLC_CODEC_MP4A;
+    return fmt->i_codec == VLC_CODEC_H264 || fmt->i_codec == VLC_CODEC_MP4A ||
+           fmt->i_codec == VLC_CODEC_TEXT || fmt->i_codec == VLC_CODEC_WEBVTT;
 }
--- a/modules/stream_out/hls/hls.c
+++ b/modules/stream_out/hls/hls.c
@@ -47,6 +47,7 @@ typedef struct
    block_t *begin;
    block_t **end;
    vlc_tick_t length;
+    block_t *last_header;
 } hls_block_chain_t;

 static inline void hls_block_chain_Reset(hls_block_chain_t *chain)
@@ -54,6 +55,7 @@ static inline void hls_block_chain_Reset(hls_block_chain_t *chain)
    chain->begin = NULL;
    chain->end = &chain->begin;
    chain->length = 0;
+    chain->last_header = NULL;
 }

 /**
@@ -64,7 +66,7 @@ typedef struct hls_playlist
    unsigned int id;

    const struct hls_config *config;
-    size_t *current_memory_cached_ref;
+    enum hls_playlist_type type;

    sout_access_out_t *access;
    sout_mux_t *mux;
@@ -145,8 +147,6 @@ typedef struct
    httpd_url_t *http_manifest;

    vlc_tick_t first_pcr;
-    vlc_tick_t last_pcr;
-    vlc_tick_t last_segment;

    size_t current_memory_cached;
 } sout_stream_sys_t;
@@ -301,10 +301,12 @@ static struct hls_storage *GenerateMainManifest(const sout_stream_sys_t *sys)
    static const char *const TRACK_TYPES[] = {
        [VIDEO_ES] = "VIDEO",
        [AUDIO_ES] = "AUDIO",
+        [SPU_ES] = "SUBTITLES",
    };
    static const char *const GROUP_IDS[] = {
        [VIDEO_ES] = "video",
        [AUDIO_ES] = "audio",
+        [SPU_ES] = "subtitles",
    };

    const hls_playlist_t *playlist;
@@ -312,7 +314,8 @@ static struct hls_storage *GenerateMainManifest(const sout_stream_sys_t *sys)
    {
        const hls_track_t *track = MediaGetTrack(playlist);
        const es_format_t *fmt = &track->input->fmt;
-        assert(fmt->i_cat == VIDEO_ES || fmt->i_cat == AUDIO_ES);
+        assert(fmt->i_cat == VIDEO_ES || fmt->i_cat == AUDIO_ES ||
+               fmt->i_cat == SPU_ES);

        MANIFEST_START_TAG("#EXT-X-MEDIA")
            const char *track_type = TRACK_TYPES[fmt->i_cat];
@@ -360,6 +363,7 @@ static struct hls_storage *GenerateMainManifest(const sout_stream_sys_t *sys)

            MANIFEST_ADD_ATTRIBUTE("VIDEO=\"%s\"", GROUP_IDS[VIDEO_ES]);
            MANIFEST_ADD_ATTRIBUTE("AUDIO=\"%s\"", GROUP_IDS[AUDIO_ES]);
+            MANIFEST_ADD_ATTRIBUTE("SUBTITLES=\"%s\"", GROUP_IDS[SPU_ES]);
        MANIFEST_END_TAG

        if (vlc_memstream_printf(&out, "%s\n", playlist->url) < 0)
@@ -462,35 +466,161 @@ static int UpdatePlaylistManifest(hls_playlist_t *playlist)
    return VLC_SUCCESS;
 }

+static hls_block_chain_t ExtractCommonSegment(hls_block_chain_t *muxed_output,
+                                              vlc_tick_t max_segment_length)
+{
+    hls_block_chain_t segment = {.begin = muxed_output->begin};
+
+    block_t *prev = NULL;
+    for (block_t *it = muxed_output->begin; it != NULL; it = it->p_next)
+    {
+        if (segment.length + it->i_length > max_segment_length)
+        {
+            muxed_output->begin = it;
+
+            if (prev != NULL)
+                prev->p_next = NULL;
+            return segment;
+        }
+        segment.length += it->i_length;
+        muxed_output->length -= it->i_length;
+        prev = it;
+    }
+
+    hls_block_chain_Reset(muxed_output);
+    return segment;
+}
+
+static hls_block_chain_t ExtractSubtitleSegment(hls_block_chain_t *muxed_output,
+                                                vlc_tick_t segment_length)
+{
+    hls_block_chain_t segment = {.begin = muxed_output->begin,
+                                 .length = segment_length};
+    for (block_t *it = muxed_output->begin; it != NULL; it = it->p_next)
+    {
+        /* Subtitle segments are segmented at mux level by the
+         * hls_sub_segmenter. They have varying length so we use the header flag
+         * to extract them properly. */
+        if (it->p_next != NULL && it->p_next->i_flags & BLOCK_FLAG_HEADER)
+        {
+            muxed_output->begin = it->p_next;
+            muxed_output->last_header = it->p_next;
+            it->p_next = NULL;
+            return segment;
+        }
+        muxed_output->length -= it->i_length;
+    }
+    hls_block_chain_Reset(muxed_output);
+    return segment;
+}
+
+static hls_block_chain_t ExtractSegment(hls_playlist_t *playlist)
+{
+    const vlc_tick_t seglen = playlist->config->segment_length;
+    if (playlist->type == HLS_PLAYLIST_TYPE_WEBVTT)
+        return ExtractSubtitleSegment(&playlist->muxed_output, seglen);
+    return ExtractCommonSegment(&playlist->muxed_output, seglen);
+}
+
+static int ExtractAndAddSegment(hls_playlist_t *playlist,
+                                sout_stream_sys_t *sys)
+{
+    hls_block_chain_t segment = ExtractSegment(playlist);
+
+    if (hls_config_IsMemStorageEnabled(&sys->config) &&
+        hls_segment_queue_IsAtMaxCapacity(&playlist->segments))
+    {
+        const hls_segment_t *to_be_removed =
+            hls_segment_GetFirst(&playlist->segments);
+        sys->current_memory_cached -=
+            hls_storage_GetSize(to_be_removed->storage);
+    }
+
+    const int status = hls_segment_queue_NewSegment(
+        &playlist->segments, segment.begin, segment.length);
+    if (unlikely(status != VLC_SUCCESS))
+    {
+        vlc_error(playlist->logger,
+                  "Segment '%u' creation failed",
+                  playlist->segments.total_segments + 1);
+        return status;
+    }
+
+    vlc_debug(playlist->logger,
+              "Segment '%u' created",
+              playlist->segments.total_segments);
+
+    return UpdatePlaylistManifest(playlist);
+}
+
+static bool IsSegmentReady(enum hls_playlist_type type,
+                           hls_block_chain_t *buffer,
+                           vlc_tick_t seglen)
+{
+    /* The subtitle header outputs one header per segment.  Let's wait until we
+     * received the next header before considering the current segment
+     * finished. */
+    if( type == HLS_PLAYLIST_TYPE_WEBVTT)
+        return buffer->begin != buffer->last_header;
+
+    /* Only consider full segments as ready for now. */
+    return buffer->length >= seglen;
+}
+
 static ssize_t AccessOutWrite(sout_access_out_t *access, block_t *block)
 {
-    hls_playlist_t *playlist = access->p_sys;
+    sout_stream_sys_t *sys = access->p_sys;

    size_t size = 0;
-    block_ChainProperties(block, NULL, &size, NULL);
+    vlc_tick_t length;
+    block_ChainProperties(block, NULL, &size, &length);

-    if (hls_config_IsMemStorageEnabled(playlist->config))
+    if (hls_config_IsMemStorageEnabled(&sys->config))
    {
-        *playlist->current_memory_cached_ref += size;
-        if (*playlist->current_memory_cached_ref >=
-            playlist->config->max_memory)
+        sys->current_memory_cached += size;
+        if (sys->current_memory_cached >= sys->config.max_memory)
        {
-            vlc_error(playlist->logger,
-                      "Maximum memory capacity (%zuKb) for segment storage was "
-                      "reached. The HLS server will stop creating segments. "
-                      "Please refer to the max-memory option for more info.",
-                      BYTES_TO_KB(playlist->config->max_memory));
+            msg_Err(access,
+                    "Maximum memory capacity (%zuKb) for segment storage was "
+                    "reached. The HLS server will stop creating segments. "
+                    "Please refer to the max-memory option for more info.",
+                    BYTES_TO_KB(sys->config.max_memory));
            block_ChainRelease(block);
            return -1;
        }
    }

-    block_ChainLastAppend(&playlist->muxed_output.end, block);
+    bool segments_ready = true;
+    hls_playlist_t *it;
+    hls_playlists_foreach(it)
+    {
+        /* Append the muxed output to the playlist tied to this access call. */
+        if (it->access == access)
+        {
+            block_ChainLastAppend(&it->muxed_output.end, block);
+            it->muxed_output.length += length;
+            if (block->i_flags & BLOCK_FLAG_HEADER)
+                it->muxed_output.last_header = block;
+        }
+
+        if (!IsSegmentReady(
+                it->type, &it->muxed_output, sys->config.segment_length))
+            segments_ready = false;
+    }
+
+
+    if (segments_ready)
+    {
+        hls_playlists_foreach (it)
+        {
+            if (ExtractAndAddSegment(it, sys) != VLC_SUCCESS)
+                return -1;
+        }
+    }
    return size;
 }

-static sout_access_out_t *CreateAccessOut(sout_stream_t *stream,
-                                          hls_playlist_t *sys)
+static sout_access_out_t *CreateAccessOut(sout_stream_t *stream)
 {
    sout_access_out_t *access = vlc_object_create(stream, sizeof(*access));
    if (unlikely(access == NULL))
@@ -505,7 +635,7 @@ static sout_access_out_t *CreateAccessOut(sout_stream_t *stream,

    access->p_cfg = NULL;
    access->p_module = NULL;
-    access->p_sys = sys;
+    access->p_sys = stream->p_sys;
    access->psz_path = NULL;

    access->pf_control = NULL;
@@ -527,7 +657,22 @@ static inline char *FormatPlaylistManifestURL(const hls_playlist_t *playlist)
    return url;
 }

-static hls_playlist_t *CreatePlaylist(sout_stream_t *stream)
+static sout_mux_t *CreatePlaylistMuxer(sout_access_out_t *access,
+                                       enum hls_playlist_type type,
+                                       const struct hls_config *config)
+{
+    switch(type)
+    {
+        case HLS_PLAYLIST_TYPE_TS:
+            return sout_MuxNew(access, "ts");
+        case HLS_PLAYLIST_TYPE_WEBVTT:
+            return CreateSubtitleSegmenter(access, config);
+    }
+    return NULL;
+}
+
+static hls_playlist_t *CreatePlaylist(sout_stream_t *stream,
+                                      enum hls_playlist_type type)
 {
    sout_stream_sys_t *sys = stream->p_sys;

@@ -535,18 +680,18 @@ static hls_playlist_t *CreatePlaylist(sout_stream_t *stream)
    if (unlikely(playlist == NULL))
        return NULL;

-    playlist->access = CreateAccessOut(stream, playlist);
+    playlist->access = CreateAccessOut(stream);
    if (unlikely(playlist->access == NULL))
        goto access_err;

-    playlist->mux = sout_MuxNew(playlist->access, "ts");
+    playlist->mux = CreatePlaylistMuxer(playlist->access, type, &sys->config);
    if (unlikely(playlist->mux == NULL))
        goto mux_err;

    playlist->id = sys->playlist_created_count;
+    playlist->type = type;
    playlist->config = &sys->config;
    playlist->ended = false;
-    playlist->current_memory_cached_ref = &sys->current_memory_cached;

    playlist->url = FormatPlaylistManifestURL(playlist);
    if (unlikely(playlist->url == NULL))
@@ -560,6 +705,7 @@ static hls_playlist_t *CreatePlaylist(sout_stream_t *stream)

    struct hls_segment_queue_config config = {
        .playlist_id = playlist->id,
+        .playlist_type = type,
        .httpd_ref = sys->http_host,
        .httpd_callback = HTTPCallback,
    };
@@ -626,9 +772,11 @@ static void DeletePlaylist(hls_playlist_t *playlist)
    free(playlist);
 }

-static hls_playlist_t *AddPlaylist(sout_stream_t *stream, struct vlc_list *head)
+static hls_playlist_t *AddPlaylist(sout_stream_t *stream,
+                                   enum hls_playlist_type type,
+                                   struct vlc_list *head)
 {
-    hls_playlist_t *variant = CreatePlaylist(stream);
+    hls_playlist_t *variant = CreatePlaylist(stream, type);
    if (variant == NULL)
        return NULL;

@@ -654,11 +802,15 @@ Add(sout_stream_t *stream, const es_format_t *fmt, const char *es_id)
    if (map != NULL)
    {
        if (map->playlist_ref == NULL)
-            map->playlist_ref = AddPlaylist(stream, &sys->variant_playlists);
+            map->playlist_ref = AddPlaylist(stream, HLS_PLAYLIST_TYPE_TS, &sys->variant_playlists);
        playlist = map->playlist_ref;
    }
+    else if (fmt->i_cat == SPU_ES)
+        playlist = AddPlaylist(
+            stream, HLS_PLAYLIST_TYPE_WEBVTT, &sys->media_playlists);
    else
-        playlist = AddPlaylist(stream, &sys->media_playlists);
+        playlist =
+            AddPlaylist(stream, HLS_PLAYLIST_TYPE_TS, &sys->media_playlists);

    if (playlist == NULL)
        return NULL;
@@ -709,61 +861,6 @@ error:
    return NULL;
 }

-static hls_block_chain_t ExtractSegment(hls_playlist_t *playlist,
-                                        vlc_tick_t max_segment_length)
-{
-    hls_block_chain_t segment = {.begin = playlist->muxed_output.begin};
-
-    block_t *prev = NULL;
-    for (block_t *it = playlist->muxed_output.begin; it != NULL;
-         it = it->p_next)
-    {
-        if (segment.length + it->i_length > max_segment_length)
-        {
-            playlist->muxed_output.begin = it;
-
-            if (prev != NULL)
-                prev->p_next = NULL;
-            return segment;
-        }
-        segment.length += it->i_length;
-        prev = it;
-    }
-
-    hls_block_chain_Reset(&playlist->muxed_output);
-    return segment;
-}
-
-static void ExtractAndAddSegment(hls_playlist_t *playlist,
-                                 vlc_tick_t last_segment_time)
-{
-    hls_block_chain_t segment = ExtractSegment(playlist, last_segment_time);
-
-    if (hls_config_IsMemStorageEnabled(playlist->config) &&
-        hls_segment_queue_IsAtMaxCapacity(&playlist->segments))
-    {
-        const hls_segment_t *to_be_removed =
-            hls_segment_GetFirst(&playlist->segments);
-        *playlist->current_memory_cached_ref -=
-            hls_storage_GetSize(to_be_removed->storage);
-    }
-
-    const int status = hls_segment_queue_NewSegment(
-        &playlist->segments, segment.begin, segment.length);
-    if (unlikely(status != VLC_SUCCESS))
-    {
-        vlc_error(playlist->logger,
-                  "Segment '%u' creation failed",
-                  playlist->segments.total_segments + 1);
-        return;
-    }
-
-    vlc_debug(playlist->logger,
-              "Segment '%u' created",
-              playlist->segments.total_segments);
-
-    UpdatePlaylistManifest(playlist);
-}
 static void Del(sout_stream_t *stream, void *id)
 {
    sout_stream_sys_t *sys = stream->p_sys;
@@ -780,7 +877,7 @@ static void Del(sout_stream_t *stream, void *id)
            map->playlist_ref = NULL;

        track->playlist_ref->ended = true;
-        ExtractAndAddSegment(track->playlist_ref, sys->config.segment_length);
+        ExtractAndAddSegment(track->playlist_ref, sys);
        UpdatePlaylistManifest(track->playlist_ref);

        DeletePlaylist(track->playlist_ref);
@@ -796,17 +893,11 @@ static int Send(sout_stream_t *stream, void *id, vlc_frame_t *frame)
    (void)stream;
 }

-/**
- * PCR events are used to have a reliable stream time status. Segmenting is done
- * after a PCR testifying that we are above the segment limit arrives.
- */
+/** PCR events are used to have a reliable stream time status. */
 static void SetPCR(sout_stream_t *stream, vlc_tick_t pcr)
 {
    sout_stream_sys_t *sys = stream->p_sys;

-    const vlc_tick_t last_pcr = sys->last_pcr;
-    sys->last_pcr = pcr;
-
    if (sys->first_pcr == VLC_TICK_INVALID)
    {
        sys->first_pcr = pcr;
@@ -814,23 +905,13 @@ static void SetPCR(sout_stream_t *stream, vlc_tick_t pcr)
    }

    const vlc_tick_t stream_time = pcr - sys->first_pcr;
-    const vlc_tick_t current_seglen = stream_time - sys->last_segment;
-
-    const vlc_tick_t pcr_gap = pcr - last_pcr;
-    /* PCR and segment length aren't necessarily aligned. Testing segment length
-     * with a **next** PCR  approximation will avoid piling up data:
-     *
-     * |------x#|-----x##|----x###| time
-     * ^ PCR  ^ Segment end     ^ Buffer expanding
-     *
-     * The segments are then a little shorter than they could be.
-     */
-    if (current_seglen + pcr_gap >= sys->config.segment_length)
+    const hls_playlist_t *playlist;
+    vlc_list_foreach_const (playlist, &sys->media_playlists, node)
    {
-        hls_playlist_t *playlist;
-        hls_playlists_foreach (playlist)
-            ExtractAndAddSegment(playlist, sys->config.segment_length);
-        sys->last_segment = stream_time;
+        if (playlist->type != HLS_PLAYLIST_TYPE_WEBVTT)
+            continue;
+
+        hls_sub_segmenter_SignalStreamUpdate(playlist->mux, stream_time);
    }
 }

@@ -974,8 +1055,6 @@ static int Open(vlc_object_t *this)
    vlc_list_init(&sys->media_playlists);

    sys->first_pcr = VLC_TICK_INVALID;
-    sys->last_pcr = VLC_TICK_INVALID;
-    sys->last_segment = 0;

    sys->current_memory_cached = 0;


--- a/modules/stream_out/hls/hls.h
+++ b/modules/stream_out/hls/hls.h
@@ -20,6 +20,12 @@
 #ifndef HLS_H
 #define HLS_H

+enum hls_playlist_type
+{
+    HLS_PLAYLIST_TYPE_TS,
+    HLS_PLAYLIST_TYPE_WEBVTT,
+};
+
 struct hls_config
 {
    char *base_url;
@@ -45,4 +51,9 @@ hls_config_IsMemStorageEnabled(const struct hls_config *config)
    return config->outdir == NULL;
 }

+struct hls_sub_segmenter;
+sout_mux_t *CreateSubtitleSegmenter(sout_access_out_t *access,
+                                    const struct hls_config *config);
+void hls_sub_segmenter_SignalStreamUpdate(sout_mux_t *, vlc_tick_t);
+
 #endif
--- a/modules/stream_out/hls/segments.c
+++ b/modules/stream_out/hls/segments.c
@@ -42,12 +42,33 @@ static void hls_segment_Destroy(hls_segment_t *segment)
    free(segment);
 }

+static const char *
+hls_segment_queue_GetFileExtension(enum hls_playlist_type type)
+{
+    switch (type)
+    {
+        case HLS_PLAYLIST_TYPE_TS:
+            return "ts";
+        case HLS_PLAYLIST_TYPE_WEBVTT:
+            return "vtt";
+        default:
+            vlc_assert_unreachable();
+    }
+}
+
 void hls_segment_queue_Init(hls_segment_queue_t *queue,
                            const struct hls_segment_queue_config *config,
                            const struct hls_config *hls_config)
 {
-    memcpy(&queue->config, config, sizeof(*config));
+    queue->playlist_id = config->playlist_id;
    queue->total_segments = 0;
+
+    queue->httpd_ref = config->httpd_ref;
+    queue->httpd_callback = config->httpd_callback;
+
+    queue->file_extension =
+        hls_segment_queue_GetFileExtension(config->playlist_type);
+
    queue->hls_config = hls_config;

    vlc_list_init(&queue->segments);
@@ -71,10 +92,11 @@ int hls_segment_queue_NewSegment(hls_segment_queue_t *queue,
    segment->length = length;

    if (asprintf(&segment->url,
-                 "%s/playlist-%u-%u.ts",
+                 "%s/playlist-%u-%u.%s",
                 queue->hls_config->base_url,
-                 queue->config.playlist_id,
-                 segment->id) == -1)
+                 queue->playlist_id,
+                 segment->id,
+                 queue->file_extension) == -1)
    {
        segment->url = NULL;
        goto nomem;
@@ -89,16 +111,16 @@ int hls_segment_queue_NewSegment(hls_segment_queue_t *queue,
    if (unlikely(segment->storage == NULL))
        goto nomem;

-    if (queue->config.httpd_ref != NULL)
+    if (queue->httpd_ref != NULL)
    {
        segment->http_url =
-            httpd_UrlNew(queue->config.httpd_ref, segment->url, NULL, NULL);
+            httpd_UrlNew(queue->httpd_ref, segment->url, NULL, NULL);
        if (segment->http_url == NULL)
            goto nomem;

        httpd_UrlCatch(segment->http_url,
                       HTTPD_MSG_GET,
-                       queue->config.httpd_callback,
+                       queue->httpd_callback,
                       (httpd_callback_sys_t *)segment->storage);
    }
    else

--- a/modules/stream_out/hls/segments.h
+++ b/modules/stream_out/hls/segments.h
@@ -39,6 +39,7 @@ typedef struct hls_segment
 struct hls_segment_queue_config
 {
    unsigned int playlist_id;
+    enum hls_playlist_type playlist_type;

    httpd_host_t *httpd_ref;
    httpd_callback_t httpd_callback;
@@ -46,9 +47,14 @@ struct hls_segment_queue_config

 typedef struct
 {
-    struct hls_segment_queue_config config;
+    unsigned int playlist_id;
    unsigned int total_segments;

+    httpd_host_t *httpd_ref;
+    httpd_callback_t httpd_callback;
+
+    const char *file_extension;
+
    const struct hls_config *hls_config;

    struct vlc_list segments;

--- a/modules/stream_out/hls/subtitles_segmenter.c
+++ b/modules/stream_out/hls/subtitles_segmenter.c
+/*****************************************************************************
+ * subtitle_segmenter.c: Create subtitle segments
+ *****************************************************************************
+ * Copyright (C) 2024 VLC authors and VideoLAN
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser 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.
+ *****************************************************************************/
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <assert.h>
+
+#include <vlc_common.h>
+
+#include <vlc_block.h>
+#include <vlc_frame.h>
+#include <vlc_sout.h>
+#include <vlc_tick.h>
+
+#include "hls.h"
+
+/**
+ * The hls_sub_segmenter is a meta-muxer used to create subtitles segments. It
+ * handles subtitle frames splitting, re-creation of the subtitles muxer and
+ * empty segments creation when no data is available.
+ */
+struct hls_sub_segmenter
+{
+    sout_mux_t owner;
+
+    const struct hls_config *config;
+    sout_mux_t *spu_muxer;
+    sout_input_t *spu_muxer_input;
+    bool segment_empty;
+    vlc_tick_t last_segment;
+    vlc_tick_t last_stream_update;
+};
+
+static int hls_sub_segmenter_ResetMuxer(struct hls_sub_segmenter *segmenter,
+                                        sout_input_t *owner_input)
+{
+    if (segmenter->spu_muxer_input != NULL)
+        sout_MuxDeleteStream(segmenter->spu_muxer, segmenter->spu_muxer_input);
+    if (segmenter->spu_muxer != NULL)
+        sout_MuxDelete(segmenter->spu_muxer);
+
+    segmenter->segment_empty = true;
+
+    segmenter->spu_muxer = sout_MuxNew(segmenter->owner.p_access, "webvtt");
+    if (segmenter->spu_muxer == NULL)
+        return VLC_EGENERIC;
+
+    segmenter->spu_muxer_input =
+        sout_MuxAddStream(segmenter->spu_muxer, &owner_input->fmt);
+
+    // Disable mux caching.
+    segmenter->spu_muxer->b_waiting_stream = false;
+    return VLC_SUCCESS;
+}
+
+static int hls_sub_segmenter_EndSegment(struct hls_sub_segmenter *segmenter,
+                                        sout_input_t *input)
+{
+    segmenter->last_segment += segmenter->config->segment_length;
+    return hls_sub_segmenter_ResetMuxer(segmenter, input);
+}
+
+static int hls_sub_segmenter_EndEmptySegment(
+    struct hls_sub_segmenter *segmenter, sout_input_t *input, vlc_tick_t len)
+{
+    char *vtt_header = strdup("WEBVTT\n\n");
+    if (unlikely(vtt_header == NULL))
+        return VLC_ENOMEM;
+
+    block_t *empty_segment = block_heap_Alloc(vtt_header, strlen(vtt_header));
+    if (unlikely(empty_segment == NULL))
+        return VLC_ENOMEM;
+
+    empty_segment->i_flags |= BLOCK_FLAG_HEADER;
+    empty_segment->i_length = len;
+    if (sout_AccessOutWrite(segmenter->spu_muxer->p_access, empty_segment) < 0)
+        return VLC_EGENERIC;
+
+    return hls_sub_segmenter_EndSegment(segmenter, input);
+}
+
+static int hls_sub_segmenter_Add(sout_mux_t *mux, sout_input_t *input)
+{
+    struct hls_sub_segmenter *segmenter = mux->p_sys;
+    hls_sub_segmenter_ResetMuxer(segmenter, input);
+    return VLC_SUCCESS;
+}
+
+static int hls_sub_segmenter_MuxSend(struct hls_sub_segmenter *segmenter,
+                                     vlc_frame_t *spu)
+{
+    segmenter->segment_empty = false;
+    return sout_MuxSendBuffer(
+        segmenter->spu_muxer, segmenter->spu_muxer_input, spu);
+}
+
+static void hls_sub_segmenter_Del(sout_mux_t *mux, sout_input_t *input)
+{
+    struct hls_sub_segmenter *segmenter = mux->p_sys;
+
+    if (segmenter->last_segment != segmenter->last_stream_update)
+    {
+        const vlc_tick_t seglen =
+            segmenter->last_stream_update - segmenter->last_segment;
+
+        if (!vlc_fifo_IsEmpty(input->p_fifo))
+        {
+            /* Drain the last ephemeral SPU. */
+            vlc_frame_t *ephemeral = vlc_fifo_Get(input->p_fifo);
+            assert(ephemeral->i_length == VLC_TICK_INVALID);
+            ephemeral->i_length = seglen;
+            hls_sub_segmenter_MuxSend(segmenter, ephemeral);
+        }
+        else if (segmenter->segment_empty)
+        {
+            /* Drain an empty last segment. */
+            hls_sub_segmenter_EndEmptySegment(segmenter, input, seglen);
+        }
+    }
+
+    if (segmenter->spu_muxer_input != NULL)
+        sout_MuxDeleteStream(segmenter->spu_muxer, segmenter->spu_muxer_input);
+    if (segmenter->spu_muxer != NULL)
+        sout_MuxDelete(segmenter->spu_muxer);
+}
+
+static vlc_frame_t* hls_sub_segmenter_CutEphemeral(vlc_frame_t *ephemeral, vlc_tick_t length)
+{
+    vlc_frame_t *cut = vlc_frame_Duplicate(ephemeral);
+    if (unlikely(cut == NULL))
+        return NULL;
+
+    cut->i_length = length;
+    ephemeral->i_pts += cut->i_length;
+    return cut;
+}
+
+/**
+ * Should be called at frequent PCR interval.
+ *
+ * Creates empty segments when no data is sent to the muxer for a time superior
+ * to segment length. 
+ */
+void hls_sub_segmenter_SignalStreamUpdate(sout_mux_t *mux,
+                                          vlc_tick_t stream_time)
+{
+    if (mux->i_nb_inputs == 0)
+        return;
+
+    sout_input_t *owner_input = mux->pp_inputs[0];
+
+    struct hls_sub_segmenter *segmenter = mux->p_sys;
+    segmenter->last_stream_update = stream_time;
+    if (stream_time - segmenter->last_segment <
+        segmenter->config->segment_length)
+        return;
+
+    if (!vlc_fifo_IsEmpty(owner_input->p_fifo))
+    {
+        vlc_frame_t *ephemeral = vlc_fifo_Show(owner_input->p_fifo);
+
+        /* The segmenter should only keep ephemeral SPUs in queue. */
+        assert(ephemeral->i_length == VLC_TICK_INVALID);
+
+        const vlc_tick_t eph_len =
+            (segmenter->last_segment + segmenter->config->segment_length) -
+            ephemeral->i_pts;
+        vlc_frame_t *cut = hls_sub_segmenter_CutEphemeral(ephemeral, eph_len);
+        if (likely(cut != NULL))
+            hls_sub_segmenter_MuxSend(segmenter, cut);
+    }
+
+    if (!segmenter->segment_empty)
+    {
+        hls_sub_segmenter_EndSegment(segmenter, owner_input);
+        return;
+    }
+
+    hls_sub_segmenter_EndEmptySegment(
+        segmenter, owner_input, segmenter->config->segment_length);
+}
+
+static int
+hls_sub_segmenter_ProcessSingleFrame(struct hls_sub_segmenter *segmenter,
+                                     sout_input_t *owner_input,
+                                     vlc_frame_t *spu)
+{
+    const vlc_tick_t seglen = segmenter->config->segment_length;
+    if (spu->i_pts >= segmenter->last_segment + seglen)
+        hls_sub_segmenter_EndSegment(segmenter, owner_input);
+
+    // If the subtitle overlaps between segments, we have to split it.
+    while (spu->i_pts + spu->i_length > segmenter->last_segment + seglen)
+    {
+        vlc_frame_t *capped_spu = vlc_frame_Duplicate(spu);
+        if (unlikely(capped_spu == NULL))
+        {
+            vlc_frame_Release(spu);
+            return VLC_ENOMEM;
+        }
+
+        // Extra time not fitting in the current segment.
+        const vlc_tick_t extra_time =
+            (spu->i_pts - VLC_TICK_0 + spu->i_length) -
+            segmenter->last_segment - seglen;
+
+        // Shorten the copy length so it fits the current segment.
+        capped_spu->i_length -= extra_time;
+
+        if (spu->i_dts != VLC_TICK_INVALID)
+            spu->i_dts += capped_spu->i_length;
+        spu->i_pts += capped_spu->i_length;
+        spu->i_length = extra_time;
+
+        const int status = hls_sub_segmenter_MuxSend(segmenter, capped_spu);
+        if (status != VLC_SUCCESS)
+        {
+            vlc_frame_Release(spu);
+            return status;
+        }
+        hls_sub_segmenter_EndSegment(segmenter, owner_input);
+    }
+    return hls_sub_segmenter_MuxSend(segmenter, spu);
+}
+
+static int hls_sub_segmenter_Process(sout_mux_t *mux)
+{
+    struct hls_sub_segmenter *segmenter = mux->p_sys;
+
+    if (mux->i_nb_inputs == 0)
+        return VLC_SUCCESS;
+
+    sout_input_t *input = mux->pp_inputs[0];
+
+    vlc_fifo_Lock(input->p_fifo);
+    vlc_frame_t *chain = vlc_fifo_DequeueAllUnlocked(input->p_fifo);
+
+    int status = VLC_SUCCESS;
+    while (chain != NULL)
+    {
+        if (chain->i_length == VLC_TICK_INVALID)
+        {
+            /* Ephemeral SPUs length depends on the next SPUs timestamps. */
+            if (chain->p_next == NULL)
+            {
+                vlc_fifo_QueueUnlocked(input->p_fifo, chain);
+                break;
+            }
+            else
+            {
+                chain->i_length = chain->p_next->i_pts - chain->i_pts;
+            }
+        }
+
+        vlc_frame_t *next = chain->p_next;
+        chain->p_next = NULL;
+        status =
+            hls_sub_segmenter_ProcessSingleFrame(segmenter, input, chain);
+        if (status != VLC_SUCCESS)
+        {
+            vlc_frame_ChainRelease(next);
+            break;
+        }
+        chain = next;
+    }
+    vlc_fifo_Unlock(input->p_fifo);
+    return status;
+}
+
+static int hls_sub_segmenter_Control(sout_mux_t *mux, int query, va_list args)
+{
+    if (query != MUX_CAN_ADD_STREAM_WHILE_MUXING)
+        return VLC_ENOTSUP;
+
+    *(va_arg(args, bool *)) = false;
+    return VLC_SUCCESS;
+    (void)mux;
+}
+
+sout_mux_t *CreateSubtitleSegmenter(sout_access_out_t *access,
+                                    const struct hls_config *config)
+{
+    struct hls_sub_segmenter *segmenter =
+        vlc_object_create(access, sizeof(*segmenter));
+    if (unlikely(segmenter == NULL))
+        return NULL;
+
+    sout_mux_t *mux = &segmenter->owner;
+    mux->psz_mux = strdup("hls-sub-segmenter");
+    if (unlikely(mux->psz_mux == NULL))
+    {
+        vlc_object_delete(mux);
+        return NULL;
+    }
+
+    mux->p_module = NULL;
+    mux->p_cfg = NULL;
+    mux->i_nb_inputs = 0;
+    mux->pp_inputs = NULL;
+    mux->b_add_stream_any_time = false;
+    mux->b_waiting_stream = true;
+    mux->i_add_stream_start = VLC_TICK_INVALID;
+    mux->p_sys = segmenter;
+    mux->p_access = access;
+
+    mux->pf_addstream = hls_sub_segmenter_Add;
+    mux->pf_delstream = hls_sub_segmenter_Del;
+    mux->pf_mux = hls_sub_segmenter_Process;
+    mux->pf_control = hls_sub_segmenter_Control;
+
+    segmenter->config = config;
+    segmenter->spu_muxer = NULL;
+    segmenter->segment_empty = true;
+    segmenter->last_segment = VLC_TICK_0;
+    segmenter->last_stream_update = VLC_TICK_INVALID;
+    return &segmenter->owner;
+}
--- a/test/Makefile.am
+++ b/test/Makefile.am
@@ -57,6 +57,7 @@ check_PROGRAMS = \
 	test_modules_tls \
 	test_modules_stream_out_transcode \
 	test_modules_mux_webvtt \
+	test_modules_stream_out_hls_subtitles_segmenter \
 	$(NULL)

 if HAVE_GL
@@ -303,6 +304,12 @@ test_modules_stream_out_pcr_sync_LDADD = $(LIBVLCCORE)
 test_modules_mux_webvtt_SOURCES = modules/mux/webvtt.c
 test_modules_mux_webvtt_LDADD = $(LIBVLCCORE) $(LIBVLC)

+test_modules_stream_out_hls_subtitles_segmenter_SOURCES = \
+	modules/stream_out/hls/subtitles_segmenter.c \
+	../modules/stream_out/hls/hls.h \
+	../modules/stream_out/hls/subtitles_segmenter.c
+test_modules_stream_out_hls_subtitles_segmenter_LDADD = $(LIBVLCCORE) $(LIBVLC)
+
 checkall:
 	$(MAKE) check_PROGRAMS="$(check_PROGRAMS) $(EXTRA_PROGRAMS)" check


--- a/test/modules/stream_out/hls/subtitles_segmenter.c
+++ b/test/modules/stream_out/hls/subtitles_segmenter.c
+/*****************************************************************************
+ * subtitles_segmenter.c: HLS subtitle segmentation unit tests
+ *****************************************************************************
+ * Copyright (C) 2024 VLC authors and VideoLAN
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser 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.
+ *****************************************************************************/
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <vlc_common.h>
+
+#include <vlc_block.h>
+#include <vlc_plugin.h>
+#include <vlc_sout.h>
+
+#include "../../../libvlc/test.h"
+#include "../../modules/stream_out/hls/hls.h"
+#include "../lib/libvlc_internal.h"
+
+struct test_scenario
+{
+    vlc_tick_t segment_length;
+
+    unsigned bytes_reported;
+    const char *expected;
+
+    void (*report_sub)(block_t *);
+    void (*send_sub)(sout_mux_t *, sout_input_t *);
+};
+
+static struct test_scenario *CURRENT_SCENARIO = NULL;
+
+static ssize_t AccessOutWrite(sout_access_out_t *access, block_t *block)
+{
+    struct test_scenario *cb = access->p_sys;
+    assert(block->p_next == NULL);
+
+    cb->report_sub(block);
+
+    const ssize_t r = block->i_buffer;
+    block_ChainRelease(block);
+    return r;
+}
+
+static sout_access_out_t *CreateAccessOut(vlc_object_t *parent,
+                                          const struct test_scenario *cb)
+{
+    sout_access_out_t *access = vlc_object_create(parent, sizeof(*access));
+    if (unlikely(access == NULL))
+        return NULL;
+
+    access->psz_access = strdup("mock");
+    if (unlikely(access->psz_access == NULL))
+    {
+        vlc_object_delete(access);
+        return NULL;
+    }
+
+    access->p_cfg = NULL;
+    access->p_module = NULL;
+    access->p_sys = (void *)cb;
+    access->psz_path = NULL;
+
+    access->pf_control = NULL;
+    access->pf_read = NULL;
+    access->pf_seek = NULL;
+    access->pf_write = AccessOutWrite;
+    return access;
+}
+
+static vlc_frame_t *
+make_spu(const char *text, vlc_tick_t start, vlc_tick_t stop)
+{
+    char *owned_txt = strdup(text);
+    assert(owned_txt != NULL);
+
+    vlc_frame_t *spu = vlc_frame_heap_Alloc(owned_txt, strlen(owned_txt));
+    spu->i_pts = spu->i_dts = start + VLC_TICK_0;
+    if (stop != VLC_TICK_INVALID)
+        spu->i_length = stop - start;
+    else
+        spu->i_length = VLC_TICK_INVALID;
+    return spu;
+}
+static vlc_frame_t *make_ephemer_spu(const char *text, vlc_tick_t start)
+{
+    return make_spu(text, start, VLC_TICK_INVALID);
+}
+
+#define NO_SPLIT_EXPECTED                                                      \
+    "WEBVTT\n\n"                                                               \
+    "00:00:00.000 --> 00:00:03.000\n"                                          \
+    "Hello world\n\n"
+static void send_no_split(sout_mux_t *mux, sout_input_t *input)
+{
+    vlc_frame_t *spu = make_spu("Hello world", 0, VLC_TICK_FROM_SEC(3));
+    const int status = sout_MuxSendBuffer(mux, input, spu);
+    assert(status == VLC_SUCCESS);
+}
+
+#define ONE_SPLIT_EXPECTED                                                     \
+    "WEBVTT\n\n"                                                               \
+    "00:00:00.000 --> 00:00:04.000\n"                                          \
+    "Hello world\n\n"                                                          \
+    "WEBVTT\n\n"                                                               \
+    "00:00:04.000 --> 00:00:06.000\n"                                          \
+    "Hello world\n\n"
+static void send_one_split(sout_mux_t *mux, sout_input_t *input)
+{
+    vlc_frame_t *spu = make_spu("Hello world", 0, VLC_TICK_FROM_SEC(6));
+    const int status = sout_MuxSendBuffer(mux, input, spu);
+    assert(status == VLC_SUCCESS);
+}
+
+#define FIVE_SPLITS_EXPECTED                                                   \
+    "WEBVTT\n\n"                                                               \
+    "00:00:01.500 --> 00:00:02.000\n"                                          \
+    "Hello world\n\n"                                                          \
+    "WEBVTT\n\n"                                                               \
+    "00:00:02.000 --> 00:00:04.000\n"                                          \
+    "Hello world\n\n"                                                          \
+    "WEBVTT\n\n"                                                               \
+    "00:00:04.000 --> 00:00:06.000\n"                                          \
+    "Hello world\n\n"                                                          \
+    "WEBVTT\n\n"                                                               \
+    "00:00:06.000 --> 00:00:08.000\n"                                          \
+    "Hello world\n\n"                                                          \
+    "WEBVTT\n\n"                                                               \
+    "00:00:08.000 --> 00:00:09.500\n"                                          \
+    "Hello world\n\n"
+static void send_five_splits(sout_mux_t *mux, sout_input_t *input)
+{
+    vlc_frame_t *spu =
+        make_spu("Hello world", VLC_TICK_FROM_MS(1500), VLC_TICK_FROM_MS(9500));
+    const int status = sout_MuxSendBuffer(mux, input, spu);
+    assert(status == VLC_SUCCESS);
+}
+
+#define NOTHING_FOR_FIVE_SEC_EXPECTED                                          \
+    "WEBVTT\n\n"                                                               \
+    "WEBVTT\n\n"                                                               \
+    "WEBVTT\n\n"
+static void send_nothing_for_five_sec(sout_mux_t *mux, sout_input_t *input)
+{
+    for (vlc_tick_t stream_time = VLC_TICK_0;
+         stream_time < VLC_TICK_FROM_MS(5300);
+         stream_time += VLC_TICK_FROM_MS(150))
+    {
+        hls_sub_segmenter_SignalStreamUpdate(mux, stream_time);
+    }
+    (void)input;
+}
+
+#define BEGIN_HOLE_EXPECTED                                                    \
+    "WEBVTT\n\n"                                                               \
+    "WEBVTT\n\n"                                                               \
+    "WEBVTT\n\n"                                                               \
+    "WEBVTT\n\n"                                                               \
+    "00:00:07.500 --> 00:00:08.000\n"                                          \
+    "Hello world\n\n"                                                          \
+    "WEBVTT\n\n"                                                               \
+    "00:00:08.300 --> 00:00:10.000\n"                                          \
+    "Hello world\n\n"                                                          \
+    "WEBVTT\n\n"                                                               \
+    "00:00:10.000 --> 00:00:11.500\n"                                          \
+    "Hello world\n\n"
+static void send_begin_hole(sout_mux_t *mux, sout_input_t *input)
+{
+    for (vlc_tick_t stream_time = VLC_TICK_0;
+         stream_time < VLC_TICK_FROM_MS(6150);
+         stream_time += VLC_TICK_FROM_MS(150))
+    {
+        hls_sub_segmenter_SignalStreamUpdate(mux, stream_time);
+    }
+
+    vlc_frame_t *spu =
+        make_spu("Hello world", VLC_TICK_FROM_MS(7500), VLC_TICK_FROM_MS(8000));
+    int status = sout_MuxSendBuffer(mux, input, spu);
+    assert(status == VLC_SUCCESS);
+
+    spu = make_spu(
+        "Hello world", VLC_TICK_FROM_MS(8300), VLC_TICK_FROM_MS(11500));
+    status = sout_MuxSendBuffer(mux, input, spu);
+    assert(status == VLC_SUCCESS);
+}
+
+#define MIDDLE_HOLE_EXPECTED                                                   \
+    "WEBVTT\n\n"                                                               \
+    "00:00:01.500 --> 00:00:02.000\n"                                          \
+    "Hello world\n\n"                                                          \
+    "WEBVTT\n\n"                                                               \
+    "00:00:02.000 --> 00:00:02.300\n"                                          \
+    "Hello world\n\n"                                                          \
+    "00:00:02.300 --> 00:00:03.000\n"                                          \
+    "Hello world\n\n"                                                          \
+    "WEBVTT\n\n"                                                               \
+    "WEBVTT\n\n"                                                               \
+    "WEBVTT\n\n"                                                               \
+    "00:00:11.000 --> 00:00:11.500\n"                                          \
+    "Hello world\n\n"
+static void send_middle_hole(sout_mux_t *mux, sout_input_t *input)
+{
+    vlc_frame_t *spu =
+        make_spu("Hello world", VLC_TICK_FROM_MS(1500), VLC_TICK_FROM_MS(2300));
+    int status = sout_MuxSendBuffer(mux, input, spu);
+    assert(status == VLC_SUCCESS);
+
+    spu =
+        make_spu("Hello world", VLC_TICK_FROM_MS(2300), VLC_TICK_FROM_MS(3000));
+    status = sout_MuxSendBuffer(mux, input, spu);
+    assert(status == VLC_SUCCESS);
+
+    for (vlc_tick_t stream_time = VLC_TICK_FROM_MS(3000) + VLC_TICK_0;
+         stream_time < VLC_TICK_FROM_MS(10000);
+         stream_time += VLC_TICK_FROM_MS(150))
+    {
+        hls_sub_segmenter_SignalStreamUpdate(mux, stream_time);
+    }
+
+    spu = make_spu(
+        "Hello world", VLC_TICK_FROM_MS(11000), VLC_TICK_FROM_MS(11500));
+    status = sout_MuxSendBuffer(mux, input, spu);
+    assert(status == VLC_SUCCESS);
+}
+
+#define END_HOLE_EXPECTED                                                      \
+    "WEBVTT\n\n"                                                               \
+    "00:00:01.500 --> 00:00:02.000\n"                                          \
+    "Hello world\n\n"                                                          \
+    "WEBVTT\n\n"                                                               \
+    "00:00:02.000 --> 00:00:02.300\n"                                          \
+    "Hello world\n\n"                                                          \
+    "00:00:02.300 --> 00:00:03.000\n"                                          \
+    "Hello world\n\n"                                                          \
+    "WEBVTT\n\n"                                                               \
+    "WEBVTT\n\n"                                                               \
+    "WEBVTT\n\n"
+static void send_end_hole(sout_mux_t *mux, sout_input_t *input)
+{
+    vlc_frame_t *spu =
+        make_spu("Hello world", VLC_TICK_FROM_MS(1500), VLC_TICK_FROM_MS(2300));
+    int status = sout_MuxSendBuffer(mux, input, spu);
+    assert(status == VLC_SUCCESS);
+
+    spu =
+        make_spu("Hello world", VLC_TICK_FROM_MS(2300), VLC_TICK_FROM_MS(3000));
+    status = sout_MuxSendBuffer(mux, input, spu);
+    assert(status == VLC_SUCCESS);
+
+    for (vlc_tick_t stream_time = VLC_TICK_FROM_MS(3000) + VLC_TICK_0;
+         stream_time < VLC_TICK_FROM_MS(10000);
+         stream_time += VLC_TICK_FROM_MS(150))
+    {
+        hls_sub_segmenter_SignalStreamUpdate(mux, stream_time);
+    }
+}
+
+#define EPHEMER_NO_SPLIT_EXPECTED                                              \
+    "WEBVTT\n\n"                                                               \
+    "00:00:01.500 --> 00:00:02.000\n"                                          \
+    "Hello world\n\n"                                                          \
+    "WEBVTT\n\n"                                                               \
+    "00:00:02.000 --> 00:00:02.300\n"                                          \
+    "Hello world\n\n"                                                          \
+    "00:00:02.300 --> 00:00:03.100\n"                                          \
+    "Hello world\n\n"                                                          \
+    "00:00:03.100 --> 00:00:04.000\n"                                          \
+    "Hello world\n\n"                                                          \
+    "WEBVTT\n\n"                                                               \
+    "00:00:04.000 --> 00:00:05.500\n"                                          \
+    "Hello world\n\n"
+static void send_ephemer_no_split(sout_mux_t *mux, sout_input_t *input)
+{
+    vlc_frame_t *spu = make_ephemer_spu("Hello world", VLC_TICK_FROM_MS(1500));
+    int status = sout_MuxSendBuffer(mux, input, spu);
+    assert(status == VLC_SUCCESS);
+
+    spu = make_ephemer_spu("Hello world", VLC_TICK_FROM_MS(2300));
+    status = sout_MuxSendBuffer(mux, input, spu);
+    assert(status == VLC_SUCCESS);
+    hls_sub_segmenter_SignalStreamUpdate(mux,
+                                         VLC_TICK_FROM_MS(2300) + VLC_TICK_0);
+
+    spu = make_ephemer_spu("Hello world", VLC_TICK_FROM_MS(3100));
+    status = sout_MuxSendBuffer(mux, input, spu);
+    assert(status == VLC_SUCCESS);
+    hls_sub_segmenter_SignalStreamUpdate(mux,
+                                         VLC_TICK_FROM_MS(3100) + VLC_TICK_0);
+
+    spu = make_ephemer_spu("Hello world", VLC_TICK_FROM_MS(4000));
+    status = sout_MuxSendBuffer(mux, input, spu);
+    assert(status == VLC_SUCCESS);
+    hls_sub_segmenter_SignalStreamUpdate(mux,
+                                         VLC_TICK_FROM_MS(4000) + VLC_TICK_0);
+
+    hls_sub_segmenter_SignalStreamUpdate(mux,
+                                         VLC_TICK_FROM_MS(5500) + VLC_TICK_0);
+}
+
+#define LONG_EPHEMER_EXPECTED                                                  \
+    "WEBVTT\n\n"                                                               \
+    "00:00:01.500 --> 00:00:02.000\n"                                          \
+    "Hello world\n\n"                                                          \
+    "WEBVTT\n\n"                                                               \
+    "00:00:02.000 --> 00:00:04.000\n"                                          \
+    "Hello world\n\n"                                                          \
+    "WEBVTT\n\n"                                                               \
+    "00:00:04.000 --> 00:00:06.000\n"                                          \
+    "Hello world\n\n"                                                          \
+    "WEBVTT\n\n"                                                               \
+    "00:00:06.000 --> 00:00:08.000\n"                                          \
+    "Hello world\n\n"                                                          \
+    "WEBVTT\n\n"                                                               \
+    "00:00:08.000 --> 00:00:09.500\n"                                          \
+    "Hello world\n\n"
+static void send_long_ephemer(sout_mux_t *mux, sout_input_t *input)
+{
+    vlc_frame_t *spu = make_ephemer_spu("Hello world", VLC_TICK_FROM_MS(1500));
+    int status = sout_MuxSendBuffer(mux, input, spu);
+    assert(status == VLC_SUCCESS);
+
+    for (vlc_tick_t stream_time = VLC_TICK_FROM_MS(1500);
+         stream_time <= VLC_TICK_FROM_MS(9500);
+         stream_time += VLC_TICK_FROM_MS(100))
+    {
+        hls_sub_segmenter_SignalStreamUpdate(mux, stream_time + VLC_TICK_0);
+    }
+}
+
+static void default_report(block_t *sub)
+{
+    const char *expected =
+        CURRENT_SCENARIO->expected + CURRENT_SCENARIO->bytes_reported;
+
+    const int cmp =
+        strncmp(expected, (const char *)sub->p_buffer, sub->i_buffer);
+    assert(cmp == 0);
+    CURRENT_SCENARIO->bytes_reported += sub->i_buffer;
+}
+
+static struct test_scenario TEST_SCENARIOS[] = {
+    {
+        .segment_length = VLC_TICK_FROM_SEC(4),
+        .send_sub = send_no_split,
+        .report_sub = default_report,
+        .expected = NO_SPLIT_EXPECTED,
+    },
+    {
+        .segment_length = VLC_TICK_FROM_SEC(4),
+        .send_sub = send_one_split,
+        .report_sub = default_report,
+        .expected = ONE_SPLIT_EXPECTED,
+    },
+    {
+        .segment_length = VLC_TICK_FROM_SEC(2),
+        .send_sub = send_five_splits,
+        .report_sub = default_report,
+        .expected = FIVE_SPLITS_EXPECTED,
+    },
+    {
+        .segment_length = VLC_TICK_FROM_SEC(2),
+        .send_sub = send_nothing_for_five_sec,
+        .report_sub = default_report,
+        .expected = NOTHING_FOR_FIVE_SEC_EXPECTED,
+    },
+    {
+        .segment_length = VLC_TICK_FROM_SEC(2),
+        .send_sub = send_begin_hole,
+        .report_sub = default_report,
+        .expected = BEGIN_HOLE_EXPECTED,
+    },
+    {
+        .segment_length = VLC_TICK_FROM_SEC(2),
+        .send_sub = send_middle_hole,
+        .report_sub = default_report,
+        .expected = MIDDLE_HOLE_EXPECTED,
+    },
+    {
+        .segment_length = VLC_TICK_FROM_SEC(2),
+        .send_sub = send_end_hole,
+        .report_sub = default_report,
+        .expected = END_HOLE_EXPECTED,
+    },
+    {
+        .segment_length = VLC_TICK_FROM_SEC(2),
+        .send_sub = send_ephemer_no_split,
+        .report_sub = default_report,
+        .expected = EPHEMER_NO_SPLIT_EXPECTED,
+    },
+    {
+        .segment_length = VLC_TICK_FROM_SEC(2),
+        .send_sub = send_long_ephemer,
+        .report_sub = default_report,
+        .expected = LONG_EPHEMER_EXPECTED,
+    },
+};
+
+static void RunTests(libvlc_instance_t *instance)
+{
+    for (size_t i = 0; i < ARRAY_SIZE(TEST_SCENARIOS); ++i)
+    {
+        CURRENT_SCENARIO = &TEST_SCENARIOS[i];
+        sout_access_out_t *access = CreateAccessOut(
+            VLC_OBJECT(instance->p_libvlc_int), CURRENT_SCENARIO);
+        assert(access != NULL);
+
+        const struct hls_config config = {
+            .segment_length = CURRENT_SCENARIO->segment_length,
+        };
+        sout_mux_t *mux = CreateSubtitleSegmenter(access, &config);
+        assert(mux != NULL);
+
+        es_format_t fmt;
+        es_format_Init(&fmt, SPU_ES, VLC_CODEC_TEXT);
+        sout_input_t *input = sout_MuxAddStream(mux, &fmt);
+        assert(input != NULL);
+
+        // Disable mux caching.
+        mux->b_waiting_stream = false;
+
+        CURRENT_SCENARIO->send_sub(mux, input);
+
+        sout_MuxDeleteStream(mux, input);
+
+        assert(CURRENT_SCENARIO->bytes_reported ==
+               strlen(CURRENT_SCENARIO->expected));
+
+        sout_MuxDelete(mux);
+        sout_AccessOutDelete(access);
+    }
+}
+
+int main(void)
+{
+    test_init();
+
+    const char *const args[] = {
+        "-vvv",
+    };
+    libvlc_instance_t *vlc = libvlc_new(ARRAY_SIZE(args), args);
+    if (vlc == NULL)
+        return 1;
+
+    RunTests(vlc);
+
+    libvlc_release(vlc);
+}
No results found