mux: mp4: add fragmented mp4 muxer
authorFrancois Cartegnie <fcvlcdev@free.fr>
Wed, 11 Jun 2014 17:06:36 +0000 (19:06 +0200)
committerFrancois Cartegnie <fcvlcdev@free.fr>
Sat, 30 Aug 2014 06:33:26 +0000 (15:33 +0900)
mp4stream tries to build stream with 1.5sec runs.
mp4frag aims files by creating a compatible index.

Might need for transcode tests (fragments are 1.5 sec only).
--sout-x264-keyint=30 --sout-avcodec-strict=-2

Streaming done using http, with fragment start used as iframes.

NEWS
modules/mux/Modules.am
modules/mux/mp4.c

diff --git a/NEWS b/NEWS
index c58fd4e..d56b014 100644 (file)
--- a/NEWS
+++ b/NEWS
@@ -16,6 +16,9 @@ Decoder:
 Demuxers:
  * Support HD-DVD .evo (H.264, VC-1, MPEG-2, PCM, AC-3, E-AC3, MLP, DTS)
 
+Muxers:
+ * Added fragmented/streamable MP4 muxer
+
 Service Discovery:
  * New NetBios service discovery using libdsm
 
index 0283ae3..ce39510 100644 (file)
@@ -1,7 +1,7 @@
 SOURCES_mux_dummy = dummy.c
 SOURCES_mux_avi = avi.c
 SOURCES_mux_ogg = ogg.c
-SOURCES_mux_mp4 = mp4.c ../demux/mpeg/mpeg_parser_helpers.h
+SOURCES_mux_mp4 = mp4.c ../demux/mpeg/mpeg_parser_helpers.h ../demux/mp4/libmp4.h
 SOURCES_mux_asf = asf.c ../demux/asf/libasf_guid.h
 SOURCES_mux_wav = wav.c
 SOURCES_mux_mpjpeg = mpjpeg.c
index 68b9ecb..cccdb13 100644 (file)
@@ -41,7 +41,9 @@
 #include <vlc_meta.h>
 
 #include "../demux/mpeg/mpeg_parser_helpers.h"
+#include "../demux/mp4/libmp4.h"
 
+#include "assert.h"
 /*****************************************************************************
  * Module descriptor
  *****************************************************************************/
@@ -53,6 +55,8 @@
 
 static int  Open   (vlc_object_t *);
 static void Close  (vlc_object_t *);
+static int  OpenFrag   (vlc_object_t *);
+static void CloseFrag  (vlc_object_t *);
 
 #define SOUT_CFG_PREFIX "sout-mp4-"
 
@@ -68,6 +72,16 @@ vlc_module_begin ()
     set_capability("sout mux", 5)
     add_shortcut("mp4", "mov", "3gp")
     set_callbacks(Open, Close)
+
+add_submodule ()
+    set_description(N_("Fragmented and streamable MP4 muxer"))
+    set_category(CAT_SOUT)
+    set_subcategory(SUBCAT_SOUT_MUX)
+    set_shortname("MP4 Frag")
+    add_shortcut("mp4frag", "mp4stream")
+    set_capability("sout mux", 0)
+    set_callbacks(OpenFrag, CloseFrag)
+
 vlc_module_end ()
 
 /*****************************************************************************
@@ -81,6 +95,7 @@ static int Control(sout_mux_t *, int, va_list);
 static int AddStream(sout_mux_t *, sout_input_t *);
 static int DelStream(sout_mux_t *, sout_input_t *);
 static int Mux      (sout_mux_t *);
+static int MuxFrag  (sout_mux_t *);
 
 /*****************************************************************************
  * Local prototypes
@@ -93,9 +108,32 @@ typedef struct
     mtime_t  i_pts_dts;
     mtime_t  i_length;
     unsigned int i_flags;
-
 } mp4_entry_t;
 
+typedef struct mp4_fragentry_t mp4_fragentry_t;
+
+struct mp4_fragentry_t
+{
+    block_t  *p_block;
+    uint32_t  i_run;
+    mp4_fragentry_t *p_next;
+};
+
+typedef struct mp4_fragindex_t
+{
+    uint64_t i_moofoffset;
+    mtime_t  i_time;
+    uint8_t  i_traf;
+    uint8_t  i_trun;
+    uint32_t i_sample;
+} mp4_fragindex_t;
+
+typedef struct mp4_fragqueue_t
+{
+    mp4_fragentry_t *p_first;
+    mp4_fragentry_t *p_last;
+} mp4_fragqueue_t;
+
 typedef struct
 {
     es_format_t   fmt;
@@ -109,7 +147,7 @@ typedef struct
 
     /* stats */
     int64_t      i_dts_start; /* applies to current segment only */
-    int64_t      i_duration;
+    int64_t      i_read_duration;
     uint32_t     i_timescale;
     mtime_t      i_starttime; /* the really first packet */
     bool         b_hasbframes;
@@ -120,7 +158,23 @@ typedef struct
 
     /* for spu */
     int64_t i_last_dts; /* applies to current segment only */
-
+    int64_t i_last_length;
+
+    /*** mp4frag ***/
+    bool         b_hasiframes;
+    uint32_t     i_trex_length;
+    uint32_t     i_trex_size;
+    uint32_t     i_tfhd_flags;
+
+    uint32_t         i_current_run;
+    mp4_fragentry_t *p_held_entry;
+    mp4_fragqueue_t  read;
+    mp4_fragqueue_t  towrite;
+    mtime_t          i_last_iframe_time;
+    mtime_t          i_written_duration;
+    mp4_fragindex_t *p_indexentries;
+    uint32_t         i_indexentriesmax;
+    uint32_t         i_indexentries;
 } mp4_stream_t;
 
 struct sout_mux_sys_t
@@ -132,10 +186,16 @@ struct sout_mux_sys_t
 
     uint64_t i_mdat_pos;
     uint64_t i_pos;
-    mtime_t  i_duration;
+    mtime_t  i_read_duration;
 
     unsigned int   i_nb_streams;
     mp4_stream_t **pp_streams;
+
+    /* mp4frag */
+    bool           b_fragmented;
+    bool           b_header_sent;
+    mtime_t        i_written_duration;
+    uint32_t       i_mfhd_sequence;
 };
 
 typedef struct bo_t
@@ -195,7 +255,8 @@ static int Open(vlc_object_t *p_this)
     p_sys->i_mdat_pos   = 0;
     p_sys->b_mov        = p_mux->psz_mux && !strcmp(p_mux->psz_mux, "mov");
     p_sys->b_3gp        = p_mux->psz_mux && !strcmp(p_mux->psz_mux, "3gp");
-    p_sys->i_duration   = 0;
+    p_sys->i_read_duration   = 0;
+    p_sys->b_fragmented = false;
 
     if (!p_sys->b_mov) {
         /* Now add ftyp header */
@@ -413,15 +474,42 @@ static int AddStream(sout_mux_t *p_mux, sout_input_t *p_input)
     p_stream->entry         =
         calloc(p_stream->i_entry_max, sizeof(mp4_entry_t));
     p_stream->i_dts_start   = 0;
-    p_stream->i_duration    = 0;
-    if (p_stream->fmt.i_cat == AUDIO_ES)
+    p_stream->i_read_duration    = 0;
+    switch( p_stream->fmt.i_cat )
+    {
+    case AUDIO_ES:
         p_stream->i_timescale = p_stream->fmt.audio.i_rate;
-    else
+        break;
+    case VIDEO_ES:
+        p_stream->i_timescale = p_stream->fmt.video.i_frame_rate * 1000 /
+                                p_stream->fmt.video.i_frame_rate_base;
+        break;
+    default:
         p_stream->i_timescale = CLOCK_FREQ;
-    p_stream->i_starttime   = p_sys->i_duration;
+        break;
+    }
+
+    p_stream->i_starttime   = p_sys->i_read_duration;
     p_stream->b_hasbframes  = false;
 
     p_stream->i_last_dts    = 0;
+    p_stream->i_last_length = 0;
+
+    p_stream->b_hasiframes  = false;
+    p_stream->i_trex_length = 0;
+    p_stream->i_trex_size   = 0;
+
+    p_stream->i_current_run = 0;
+    p_stream->read.p_first  = NULL;
+    p_stream->read.p_last   = NULL;
+    p_stream->towrite.p_first = NULL;
+    p_stream->towrite.p_last  = NULL;
+    p_stream->p_held_entry    = NULL;
+    p_stream->i_last_iframe_time = 0;
+    p_stream->i_written_duration = 0;
+    p_stream->p_indexentries     = NULL;
+    p_stream->i_indexentriesmax  = 0;
+    p_stream->i_indexentries     = 0;
 
     p_input->p_sys          = p_stream;
 
@@ -559,7 +647,8 @@ static int Mux(sout_mux_t *p_mux)
         }
 
         /* update */
-        p_stream->i_duration += __MAX( 0, p_data->i_length );
+        p_stream->i_read_duration += __MAX( 0, p_data->i_length );
+        p_stream->i_last_length = p_data->i_length;
         p_sys->i_pos += p_data->i_buffer;
 
         /* Save the DTS for SPU */
@@ -603,15 +692,15 @@ static int Mux(sout_mux_t *p_mux)
             }
 
             /* Fix duration = current segment starttime + duration within */
-            p_stream->i_duration = p_stream->i_starttime + ( p_stream->i_last_dts - p_stream->i_dts_start );
+            p_stream->i_read_duration = p_stream->i_starttime + ( p_stream->i_last_dts - p_stream->i_dts_start );
         }
     }
 
     /* Update the global segment/media duration */
     for ( unsigned int i=0; i<p_sys->i_nb_streams; i++ )
     {
-        if ( p_sys->pp_streams[i]->i_duration > p_sys->i_duration )
-            p_sys->i_duration = p_sys->pp_streams[i]->i_duration;
+        if ( p_sys->pp_streams[i]->i_read_duration > p_sys->i_read_duration )
+            p_sys->i_read_duration = p_sys->pp_streams[i]->i_read_duration;
     }
 
     return(VLC_SUCCESS);
@@ -684,8 +773,8 @@ static bo_t *GetESDS(mp4_stream_t *p_stream)
         }
     }
 
-    if (p_stream->i_duration > 0)
-        i_bitrate_avg = INT64_C(8000000) * i_bitrate_avg / p_stream->i_duration;
+    if (p_stream->i_read_duration > 0)
+        i_bitrate_avg = INT64_C(8000000) * i_bitrate_avg / p_stream->i_read_duration;
     else
         i_bitrate_avg = 0;
     if (i_bitrate_max <= 1)
@@ -1449,7 +1538,7 @@ static bo_t *GetStblBox(sout_mux_t *p_mux, mp4_stream_t *p_stream)
                 break;
 
         bo_add_32be(stts, i - i_first); // sample-count
-        bo_add_32be(stts, i_delta * p_stream->i_timescale / CLOCK_FREQ ); // sample-delta
+        bo_add_32be(stts, (uint64_t)i_delta  * p_stream->i_timescale / CLOCK_FREQ); // sample-delta
     }
     bo_fix_32be(stts, 12, i_index);
 
@@ -1577,13 +1666,18 @@ static bo_t *GetMoovBox(sout_mux_t *p_mux)
     moov = box_new("moov");
 
     /* Create general info */
-    for (unsigned int i_trak = 0; i_trak < p_sys->i_nb_streams; i_trak++) {
-        mp4_stream_t *p_stream = p_sys->pp_streams[i_trak];
-        i_movie_duration = __MAX(i_movie_duration, p_stream->i_duration);
-    }
-    msg_Dbg(p_mux, "movie duration %"PRId64"s", i_movie_duration / CLOCK_FREQ);
+    if ( !p_sys->b_fragmented )
+    {
+        for (unsigned int i_trak = 0; i_trak < p_sys->i_nb_streams; i_trak++) {
+            mp4_stream_t *p_stream = p_sys->pp_streams[i_trak];
+            i_movie_duration = __MAX(i_movie_duration, p_stream->i_read_duration);
+        }
+        msg_Dbg(p_mux, "movie duration %"PRId64"s", i_movie_duration / CLOCK_FREQ);
 
-    i_movie_duration = i_movie_duration * i_movie_timescale / CLOCK_FREQ;
+        i_movie_duration = i_movie_duration * i_movie_timescale / CLOCK_FREQ;
+    }
+    else
+        i_movie_duration = 0;
 
     /* *** add /moov/mvhd *** */
     if (!p_sys->b_64_ext) {
@@ -1620,6 +1714,12 @@ static bo_t *GetMoovBox(sout_mux_t *p_mux)
     for (unsigned int i_trak = 0; i_trak < p_sys->i_nb_streams; i_trak++) {
         mp4_stream_t *p_stream = p_sys->pp_streams[i_trak];
 
+        mtime_t i_stream_duration;
+        if ( !p_sys->b_fragmented )
+            i_stream_duration = p_stream->i_read_duration * i_movie_timescale / CLOCK_FREQ;
+        else
+            i_stream_duration = 0;
+
         /* *** add /moov/trak *** */
         bo_t *trak = box_new("trak");
 
@@ -1635,8 +1735,7 @@ static bo_t *GetMoovBox(sout_mux_t *p_mux)
             bo_add_32be(tkhd, i_timestamp);       // modification time
             bo_add_32be(tkhd, p_stream->i_track_id);
             bo_add_32be(tkhd, 0);                     // reserved 0
-            bo_add_32be(tkhd, p_stream->i_duration *
-                         (int64_t)i_movie_timescale / CLOCK_FREQ); // duration
+            bo_add_32be(tkhd, i_stream_duration); // duration
         } else {
             if (p_sys->b_mov)
                 tkhd = box_full_new("tkhd", 1, 0x0f);
@@ -1647,8 +1746,7 @@ static bo_t *GetMoovBox(sout_mux_t *p_mux)
             bo_add_64be(tkhd, i_timestamp);       // modification time
             bo_add_32be(tkhd, p_stream->i_track_id);
             bo_add_32be(tkhd, 0);                     // reserved 0
-            bo_add_64be(tkhd, p_stream->i_duration *
-                         (int64_t)i_movie_timescale / CLOCK_FREQ); // duration
+            bo_add_64be(tkhd, i_stream_duration); // duration
         }
 
         for (int i = 0; i < 2; i++)
@@ -1699,39 +1797,42 @@ static bo_t *GetMoovBox(sout_mux_t *p_mux)
         box_gather(trak, tkhd);
 
         /* *** add /moov/trak/edts and elst */
-        bo_t *edts = box_new("edts");
-        bo_t *elst = box_full_new("elst", p_sys->b_64_ext ? 1 : 0, 0);
-        if (p_stream->i_starttime > 0) {
-            bo_add_32be(elst, 2);
-
+        if ( !p_sys->b_fragmented )
+        {
+            bo_t *edts = box_new("edts");
+            bo_t *elst = box_full_new("elst", p_sys->b_64_ext ? 1 : 0, 0);
+            if (p_stream->i_starttime > 0) {
+                bo_add_32be(elst, 2);
+
+                if (p_sys->b_64_ext) {
+                    bo_add_64be(elst, p_stream->i_starttime *
+                                i_movie_timescale / CLOCK_FREQ);
+                    bo_add_64be(elst, -1);
+                } else {
+                    bo_add_32be(elst, p_stream->i_starttime *
+                                i_movie_timescale / CLOCK_FREQ);
+                    bo_add_32be(elst, -1);
+                }
+                bo_add_16be(elst, 1);
+                bo_add_16be(elst, 0);
+            } else {
+                bo_add_32be(elst, 1);
+            }
             if (p_sys->b_64_ext) {
-                bo_add_64be(elst, p_stream->i_starttime *
-                             i_movie_timescale / CLOCK_FREQ);
-                bo_add_64be(elst, -1);
+                bo_add_64be(elst, p_stream->i_read_duration *
+                            i_movie_timescale / CLOCK_FREQ);
+                bo_add_64be(elst, 0);
             } else {
-                bo_add_32be(elst, p_stream->i_starttime *
-                             i_movie_timescale / CLOCK_FREQ);
-                bo_add_32be(elst, -1);
+                bo_add_32be(elst, p_stream->i_read_duration *
+                            i_movie_timescale / CLOCK_FREQ);
+                bo_add_32be(elst, 0);
             }
             bo_add_16be(elst, 1);
             bo_add_16be(elst, 0);
-        } else {
-            bo_add_32be(elst, 1);
-        }
-        if (p_sys->b_64_ext) {
-            bo_add_64be(elst, p_stream->i_duration *
-                         i_movie_timescale / CLOCK_FREQ);
-            bo_add_64be(elst, 0);
-        } else {
-            bo_add_32be(elst, p_stream->i_duration *
-                         i_movie_timescale / CLOCK_FREQ);
-            bo_add_32be(elst, 0);
-        }
-        bo_add_16be(elst, 1);
-        bo_add_16be(elst, 0);
 
-        box_gather(edts, elst);
-        box_gather(trak, edts);
+            box_gather(edts, elst);
+            box_gather(trak, edts);
+        }
 
         /* *** add /moov/trak/mdia *** */
         bo_t *mdia = box_new("mdia");
@@ -1743,15 +1844,13 @@ static bo_t *GetMoovBox(sout_mux_t *p_mux)
             bo_add_32be(mdhd, i_timestamp);   // creation time
             bo_add_32be(mdhd, i_timestamp);   // modification time
             bo_add_32be(mdhd, p_stream->i_timescale); // timescale
-            bo_add_32be(mdhd, p_stream->i_duration * (int64_t)p_stream->i_timescale /
-                               CLOCK_FREQ);  // duration
+            bo_add_32be(mdhd, i_stream_duration);  // duration
         } else {
             mdhd = box_full_new("mdhd", 1, 0);
             bo_add_64be(mdhd, i_timestamp);   // creation time
             bo_add_64be(mdhd, i_timestamp);   // modification time
             bo_add_32be(mdhd, p_stream->i_timescale); // timescale
-            bo_add_64be(mdhd, p_stream->i_duration * (int64_t)p_stream->i_timescale /
-                               CLOCK_FREQ);  // duration
+            bo_add_64be(mdhd, i_stream_duration);  // duration
         }
 
         if (p_stream->fmt.psz_language) {
@@ -1859,7 +1958,16 @@ static bo_t *GetMoovBox(sout_mux_t *p_mux)
         box_gather(minf, dinf);
 
         /* add stbl */
-        bo_t *stbl = GetStblBox(p_mux, p_stream);
+        bo_t *stbl;
+        if ( p_sys->b_fragmented )
+        {
+            uint32_t i_backup = p_stream->i_entry_count;
+            p_stream->i_entry_count = 0;
+            stbl = GetStblBox(p_mux, p_stream);
+            p_stream->i_entry_count = i_backup;
+        }
+        else
+            stbl = GetStblBox(p_mux, p_stream);
 
         /* append stbl to minf */
         p_stream->i_stco_pos += minf->len;
@@ -1881,6 +1989,33 @@ static bo_t *GetMoovBox(sout_mux_t *p_mux)
     /* Add user data tags */
     box_gather(moov, GetUdtaTag(p_mux));
 
+    if ( p_sys->b_fragmented )
+    {
+        bo_t *mvex = box_new("mvex");
+        for (unsigned int i_trak = 0; i_trak < p_sys->i_nb_streams; i_trak++)
+        {
+            mp4_stream_t *p_stream = p_sys->pp_streams[i_trak];
+
+            /* Try to find some defaults */
+            if ( p_stream->i_entry_count )
+            {
+                // FIXME: find highest occurence
+                p_stream->i_trex_length = p_stream->entry[0].i_length;
+                p_stream->i_trex_size = p_stream->entry[0].i_size;
+            }
+
+            /* *** add /mvex/trex *** */
+            bo_t *trex = box_full_new("trex", 0, 0);
+            bo_add_32be(trex, p_stream->i_track_id);
+            bo_add_32be(trex, 1); // sample desc index
+            bo_add_32be(trex, (uint64_t)p_stream->i_trex_length * p_stream->i_timescale / CLOCK_FREQ); // sample duration
+            bo_add_32be(trex, p_stream->i_trex_size); // sample size
+            bo_add_32be(trex, 0); // sample flags
+            box_gather(mvex, trex);
+        }
+        box_gather(moov, mvex);
+    }
+
     box_fix(moov);
     return moov;
 }
@@ -2020,3 +2155,636 @@ static int64_t get_timestamp(void)
 
     return i_timestamp;
 }
+
+/***************************************************************************
+    MP4 Live submodule
+****************************************************************************/
+#define FRAGMENT_LENGTH  (CLOCK_FREQ * 3/2)
+
+#define ENQUEUE_ENTRY(object, entry) \
+    do {\
+        if (object.p_last)\
+            object.p_last->p_next = entry;\
+        object.p_last = entry;\
+        if (!object.p_first)\
+            object.p_first = entry;\
+    } while(0)
+
+#define DEQUEUE_ENTRY(object, entry) \
+    do {\
+        entry = object.p_first;\
+        if (object.p_last == entry)\
+            object.p_last = NULL;\
+        object.p_first = object.p_first->p_next;\
+        entry->p_next = NULL;\
+    } while(0)
+
+/* Creates mfra/traf index entries */
+static void AddKeyframeEntry(mp4_stream_t *p_stream, const uint64_t i_moof_pos,
+                             const uint8_t i_traf, const uint32_t i_sample,
+                             const mtime_t i_time)
+{
+    /* alloc or realloc */
+    mp4_fragindex_t *p_entries = p_stream->p_indexentries;
+    if (p_stream->i_indexentries >= p_stream->i_indexentriesmax)
+    {
+        p_stream->i_indexentriesmax += 256;
+        p_entries = xrealloc(p_stream->p_indexentries,
+                             p_stream->i_indexentriesmax * sizeof(mp4_fragindex_t));
+        if (p_entries) /* realloc can fail */
+            p_stream->p_indexentries = p_entries;
+    }
+
+    mtime_t i_last_entry_time;
+    if (p_stream->i_indexentries)
+        i_last_entry_time = p_stream->p_indexentries[p_stream->i_indexentries - 1].i_time;
+    else
+        i_last_entry_time = 0;
+
+    if (p_entries && i_time - i_last_entry_time >= CLOCK_FREQ * 2)
+    {
+        mp4_fragindex_t *p_indexentry = &p_stream->p_indexentries[p_stream->i_indexentries];
+        p_indexentry->i_time = i_time;
+        p_indexentry->i_moofoffset = i_moof_pos;
+        p_indexentry->i_sample = i_sample;
+        p_indexentry->i_traf = i_traf;
+        p_indexentry->i_trun = 1;
+        p_stream->i_indexentries++;
+    }
+}
+
+/* Creates moof box and traf/trun information.
+ * Single run per traf is absolutely not optimal as interleaving should be done
+ * using runs and not limiting moof size, but creating an relative offset only
+ * requires base_offset_is_moof and then comply to late iso brand spec which
+ * breaks clients. */
+static bo_t *GetMoofBox(sout_mux_t *p_mux, size_t *pi_mdat_total_size,
+                        mtime_t i_barrier_time, const uint64_t i_write_pos)
+{
+    sout_mux_sys_t *p_sys = p_mux->p_sys;
+
+    bo_t            *moof, *mfhd;
+    size_t           i_fixupoffset = 0;
+
+    *pi_mdat_total_size = 0;
+
+    moof = box_new("moof");
+
+    /* *** add /moof/mfhd *** */
+
+    mfhd = box_full_new("mfhd", 0, 0);
+    bo_add_32be(mfhd, p_sys->i_mfhd_sequence++);   // sequence number
+
+    box_gather(moof, mfhd);
+
+    for (unsigned int i_trak = 0; i_trak < p_sys->i_nb_streams; i_trak++)
+    {
+        mp4_stream_t *p_stream = p_sys->pp_streams[i_trak];
+
+        /* *** add /moof/traf *** */
+        bo_t *traf = box_new("traf");
+
+        uint32_t i_sample = 0;
+        mtime_t i_time = p_stream->i_written_duration;
+        bool b_allsamesize = true;
+        bool b_allsamelength = true;
+        if ( p_stream->read.p_first )
+        {
+            mp4_fragentry_t *p_entry = p_stream->read.p_first->p_next;
+            while (p_entry && (b_allsamelength || b_allsamesize))
+            {
+                /* compare against queue head */
+                b_allsamelength &= ( p_entry->p_block->i_length == p_stream->read.p_first->p_block->i_length );
+                b_allsamesize &= ( p_entry->p_block->i_buffer == p_stream->read.p_first->p_block->i_buffer );
+                p_entry = p_entry->p_next;
+            }
+        }
+
+        uint16_t i_tfhd_flags = 0x0;
+        if (p_stream->read.p_first)
+        {
+            /* Current segment have all same duration value, different than trex's default */
+            if (b_allsamelength &&
+                p_stream->read.p_first->p_block->i_length != p_stream->i_trex_length &&
+                p_stream->read.p_first->p_block->i_length)
+                    i_tfhd_flags |= MP4_TFHD_DFLT_SAMPLE_DURATION;
+
+            /* Current segment have all same size value, different than trex's default */
+            if (b_allsamesize &&
+                p_stream->read.p_first->p_block->i_buffer != p_stream->i_trex_size &&
+                p_stream->read.p_first->p_block->i_buffer)
+                    i_tfhd_flags |= MP4_TFHD_DFLT_SAMPLE_SIZE;
+        }
+        else
+        {
+            /* We have no samples */
+            i_tfhd_flags |= MP4_TFHD_DURATION_IS_EMPTY;
+        }
+
+        /* *** add /moof/traf/tfhd *** */
+        bo_t *tfhd = box_full_new("tfhd", 0, i_tfhd_flags);
+        bo_add_32be(tfhd, p_stream->i_track_id);
+
+        /* set the local sample duration default */
+        if (i_tfhd_flags & MP4_TFHD_DFLT_SAMPLE_DURATION)
+            bo_add_32be(tfhd, p_stream->read.p_first->p_block->i_length * p_stream->i_timescale / CLOCK_FREQ);
+
+        /* set the local sample size default */
+        if (i_tfhd_flags & MP4_TFHD_DFLT_SAMPLE_SIZE)
+            bo_add_32be(tfhd, p_stream->read.p_first->p_block->i_buffer);
+
+        box_gather(traf, tfhd);
+
+        /* *** add /moof/traf/trun *** */
+        if (p_stream->read.p_first)
+        {
+            uint16_t i_trun_flags = 0x0;
+
+            if (p_stream->b_hasiframes && !(p_stream->read.p_first->p_block->i_flags & BLOCK_FLAG_TYPE_I))
+                i_trun_flags |= MP4_TRUN_FIRST_FLAGS;
+
+            if (!b_allsamelength ||
+                ( !(i_tfhd_flags & MP4_TFHD_DFLT_SAMPLE_DURATION) && p_stream->i_trex_length == 0 ))
+                i_trun_flags |= MP4_TRUN_SAMPLE_DURATION;
+
+            if (!b_allsamesize ||
+                ( !(i_tfhd_flags & MP4_TFHD_DFLT_SAMPLE_SIZE) && p_stream->i_trex_size == 0 ))
+                i_trun_flags |= MP4_TRUN_SAMPLE_SIZE;
+
+            if (p_stream->b_hasbframes)
+                i_trun_flags |= MP4_TRUN_SAMPLE_TIME_OFFSET;
+
+            if (i_fixupoffset == 0)
+                i_trun_flags |= MP4_TRUN_DATA_OFFSET;
+
+            bo_t *trun = box_full_new("trun", 0, i_trun_flags);
+
+            /* count entries */
+            uint32_t i_entry_count = 0;
+            mtime_t i_run_time = p_stream->i_written_duration;
+            mp4_fragentry_t *p_entry = p_stream->read.p_first;
+            while(p_entry)
+            {
+                if ( i_barrier_time && i_run_time + p_entry->p_block->i_length > i_barrier_time )
+                    break;
+                i_entry_count++;
+                i_run_time += p_entry->p_block->i_length;
+                p_entry = p_entry->p_next;
+            }
+            bo_add_32be(trun, i_entry_count); // sample count
+
+            if (i_trun_flags & MP4_TRUN_DATA_OFFSET)
+            {
+                i_fixupoffset = moof->len + traf->len + trun->len;
+                bo_add_32be(trun, 0xdeadbeef); // data offset
+            }
+
+            if (i_trun_flags & MP4_TRUN_FIRST_FLAGS)
+                bo_add_32be(trun, 1<<16); // flag as non keyframe
+
+            while(p_stream->read.p_first && i_entry_count)
+            {
+                DEQUEUE_ENTRY(p_stream->read, p_entry);
+
+                if (i_trun_flags & MP4_TRUN_SAMPLE_DURATION)
+                    bo_add_32be(trun, p_entry->p_block->i_length * p_stream->i_timescale / CLOCK_FREQ); // sample duration
+
+                if (i_trun_flags & MP4_TRUN_SAMPLE_SIZE)
+                    bo_add_32be(trun, p_entry->p_block->i_buffer); // sample size
+
+                if (i_trun_flags & MP4_TRUN_SAMPLE_TIME_OFFSET)
+                {
+                    uint32_t i_diff = 0;
+                    if ( p_entry->p_block->i_dts  > VLC_TS_INVALID &&
+                         p_entry->p_block->i_pts > p_entry->p_block->i_dts )
+                    {
+                        i_diff = p_entry->p_block->i_pts - p_entry->p_block->i_dts;
+                    }
+                    bo_add_32be(trun, i_diff * p_stream->i_timescale / CLOCK_FREQ); // ctts
+                }
+
+                *pi_mdat_total_size += p_entry->p_block->i_buffer;
+
+                ENQUEUE_ENTRY(p_stream->towrite, p_entry);
+                i_entry_count--;
+                i_sample++;
+
+                /* Add keyframe entry if needed */
+                if (p_stream->b_hasiframes && (p_entry->p_block->i_flags & BLOCK_FLAG_TYPE_I) &&
+                    (p_stream->fmt.i_cat == VIDEO_ES || p_stream->fmt.i_cat == AUDIO_ES))
+                {
+                    AddKeyframeEntry(p_stream, i_write_pos, i_trak, i_sample, i_time);
+                }
+
+                i_time += p_entry->p_block->i_length;
+            }
+
+            box_gather(traf, trun);
+        }
+
+        box_gather(moof, traf);
+    }
+
+    box_fix(moof);
+
+    /* do tfhd base data offset fixup */
+    if (i_fixupoffset)
+    {
+        /* mdat will follow moof */
+        SetDWBE(moof->b->p_buffer + i_fixupoffset, moof->len + 8);
+    }
+
+    /* set iframe flag, so the streaming server always starts from moof */
+    moof->b->i_flags |= BLOCK_FLAG_TYPE_I;
+
+    return moof;
+}
+
+static void WriteFragmentMDAT(sout_mux_t *p_mux, size_t i_total_size)
+{
+    sout_mux_sys_t *p_sys = p_mux->p_sys;
+
+    /* Now add mdat header */
+    bo_t *mdat = box_new("mdat");
+    /* force update of real size */
+    mdat->b->i_buffer = mdat->len;
+    assert(mdat->len==8);
+    mdat->len += i_total_size;
+    box_fix(mdat);
+    p_sys->i_pos += mdat->b->i_buffer;
+    /* only write header */
+    sout_AccessOutWrite(p_mux->p_access, mdat->b);
+    free(mdat);
+    /* Header and its size are written and good, now write content */
+    for (unsigned int i_trak = 0; i_trak < p_sys->i_nb_streams; i_trak++)
+    {
+        mp4_stream_t *p_stream = p_sys->pp_streams[i_trak];
+
+        while(p_stream->towrite.p_first)
+        {
+            mp4_fragentry_t *p_entry = p_stream->towrite.p_first;
+            p_sys->i_pos += p_entry->p_block->i_buffer;
+            p_stream->i_written_duration += p_entry->p_block->i_length;
+
+            p_entry->p_block->i_flags &= ~BLOCK_FLAG_TYPE_I; // clear flag for http stream
+            sout_AccessOutWrite(p_mux->p_access, p_entry->p_block);
+
+            p_stream->towrite.p_first = p_entry->p_next;
+            free(p_entry);
+            if (!p_stream->towrite.p_first)
+                p_stream->towrite.p_last = NULL;
+        }
+    }
+}
+
+static bo_t *GetMfraBox(sout_mux_t *p_mux)
+{
+    sout_mux_sys_t *p_sys = (sout_mux_sys_t*) p_mux->p_sys;
+    bo_t *mfra = NULL;
+    for (unsigned int i = 0; i < p_sys->i_nb_streams; i++)
+    {
+        mp4_stream_t *p_stream = p_sys->pp_streams[i];
+        if (p_stream->i_indexentries)
+        {
+            bo_t *tfra = box_full_new("tfra", 0, 0x0);
+            if (!tfra) continue;
+            bo_add_32be(tfra, p_stream->i_track_id);
+            bo_add_32be(tfra, 0x3); // reserved + lengths (1,1,4)=>(0,0,3)
+            bo_add_32be(tfra, p_stream->i_indexentries);
+            for(uint32_t i_index=0; i_index<p_stream->i_indexentries; i_index++)
+            {
+                const mp4_fragindex_t *p_indexentry = &p_stream->p_indexentries[i_index];
+                bo_add_32be(tfra, p_indexentry->i_time);
+                bo_add_32be(tfra, p_indexentry->i_moofoffset);
+                assert(sizeof(p_indexentry->i_traf==1)); /* guard against sys changes */
+                assert(sizeof(p_indexentry->i_trun==1));
+                assert(sizeof(p_indexentry->i_sample==4));
+                bo_add_8(tfra, p_indexentry->i_traf);
+                bo_add_8(tfra, p_indexentry->i_trun);
+                bo_add_32be(tfra, p_indexentry->i_sample);
+            }
+
+            if (!mfra && !(mfra = box_new("mfra")))
+            {
+                box_free(tfra);
+                return NULL;
+            }
+
+            box_gather(mfra,tfra);
+        }
+    }
+    return mfra;
+}
+
+static void FlushHeader(sout_mux_t *p_mux)
+{
+    sout_mux_sys_t *p_sys = (sout_mux_sys_t*) p_mux->p_sys;
+
+    /* Now add ftyp header */
+    bo_t *ftyp = box_new("ftyp");
+    bo_add_fourcc(ftyp, "isom");
+    bo_add_32be  (ftyp, 0); // minor version
+    box_fix(ftyp);
+
+    bo_t *moov = GetMoovBox(p_mux);
+
+    /* merge into a single block */
+    box_gather(ftyp, moov);
+
+    /* add header flag for streaming server */
+    ftyp->b->i_flags |= BLOCK_FLAG_HEADER;
+    p_sys->i_pos += ftyp->len;
+    box_send(p_mux, ftyp);
+    p_sys->b_header_sent = true;
+}
+
+static int OpenFrag(vlc_object_t *p_this)
+{
+    sout_mux_t *p_mux = (sout_mux_t*) p_this;
+    sout_mux_sys_t *p_sys = malloc(sizeof(sout_mux_sys_t));
+    if (!p_sys)
+        return VLC_ENOMEM;
+
+    p_mux->p_sys = (sout_mux_sys_t *) p_sys;
+    p_mux->pf_control   = Control;
+    p_mux->pf_addstream = AddStream;
+    p_mux->pf_delstream = DelStream;
+    p_mux->pf_mux       = MuxFrag;
+
+    /* unused */
+    p_sys->b_mov        = false;
+    p_sys->b_3gp        = false;
+    p_sys->b_64_ext     = false;
+    /* !unused */
+
+    p_sys->i_pos        = 0;
+    p_sys->i_nb_streams = 0;
+    p_sys->pp_streams   = NULL;
+    p_sys->i_mdat_pos   = 0;
+    p_sys->i_read_duration   = 0;
+    p_sys->i_written_duration= 0;
+
+    p_sys->b_header_sent = false;
+    p_sys->b_fragmented  = true;
+    p_sys->i_mfhd_sequence = 1;
+
+    return VLC_SUCCESS;
+}
+
+static void WriteFragments(sout_mux_t *p_mux, bool b_flush)
+{
+    sout_mux_sys_t *p_sys = (sout_mux_sys_t*) p_mux->p_sys;
+    bo_t *moof = NULL;
+    mtime_t i_barrier_time = p_sys->i_written_duration + FRAGMENT_LENGTH;
+    size_t i_mdat_size = 0;
+    bool b_has_samples = false;
+
+    for (unsigned int i = 0; i < p_sys->i_nb_streams; i++)
+    {
+        const mp4_stream_t *p_stream = p_sys->pp_streams[i];
+        if (p_stream->read.p_first)
+        {
+            b_has_samples = true;
+
+            /* set a barrier so we try to align to keyframe */
+            if (p_stream->b_hasiframes &&
+                    p_stream->i_last_iframe_time > p_stream->i_written_duration &&
+                    (p_stream->fmt.i_cat == VIDEO_ES ||
+                     p_stream->fmt.i_cat == AUDIO_ES) )
+            {
+                i_barrier_time = __MIN(i_barrier_time, p_stream->i_last_iframe_time);
+            }
+        }
+    }
+
+    if (!p_sys->b_header_sent)
+        FlushHeader(p_mux);
+
+    if (b_has_samples)
+        moof = GetMoofBox(p_mux, &i_mdat_size, (b_flush)?0:i_barrier_time, p_sys->i_pos);
+
+    if (moof && i_mdat_size == 0)
+    {
+        block_Release(moof->b);
+        FREENULL(moof);
+    }
+
+    if (moof)
+    {
+        msg_Dbg(p_mux, "writing moof @ %"PRId64, p_sys->i_pos);
+        p_sys->i_pos += moof->len;
+        assert(moof->b->i_flags & BLOCK_FLAG_TYPE_I); /* http sout */
+        box_send(p_mux, moof);
+        msg_Dbg(p_mux, "writing mdat @ %"PRId64, p_sys->i_pos);
+        WriteFragmentMDAT(p_mux, i_mdat_size);
+
+        /* update iframe point */
+        for (unsigned int i = 0; i < p_sys->i_nb_streams; i++)
+        {
+            mp4_stream_t *p_stream = p_sys->pp_streams[i];
+            p_stream->i_last_iframe_time = 0;
+        }
+    }
+}
+
+/* Do an entry length fixup using only its own info.
+ * This is the end boundary case. */
+static void LengthLocalFixup(sout_mux_t *p_mux, const mp4_stream_t *p_stream, block_t *p_entrydata)
+{
+    if ( p_stream->fmt.i_cat == VIDEO_ES )
+    {
+        p_entrydata->i_length = CLOCK_FREQ *
+                p_stream->fmt.video.i_frame_rate_base /
+                p_stream->fmt.video.i_frame_rate;
+        msg_Dbg(p_mux, "video track %d fixup to %"PRId64" for sample %u",
+                p_stream->i_track_id, p_entrydata->i_length, p_stream->i_entry_count - 1);
+    }
+    else if (p_stream->fmt.i_cat == AUDIO_ES &&
+             p_stream->fmt.audio.i_rate &&
+             p_entrydata->i_nb_samples)
+    {
+        p_entrydata->i_length = CLOCK_FREQ * p_entrydata->i_nb_samples /
+                p_stream->fmt.audio.i_rate;
+        msg_Dbg(p_mux, "audio track %d fixup to %"PRId64" for sample %u",
+                p_stream->i_track_id, p_entrydata->i_length, p_stream->i_entry_count - 1);
+    }
+    else
+    {
+        msg_Warn(p_mux, "unknown length for track %d sample %u",
+                 p_stream->i_track_id, p_stream->i_entry_count - 1);
+        p_entrydata->i_length = 1;
+    }
+}
+
+static void CleanupFrag(sout_mux_sys_t *p_sys)
+{
+    for (unsigned int i = 0; i < p_sys->i_nb_streams; i++)
+    {
+        mp4_stream_t *p_stream = p_sys->pp_streams[i];
+        if (p_stream->p_held_entry)
+        {
+            block_Release(p_stream->p_held_entry->p_block);
+            free(p_stream->p_held_entry);
+        }
+        while(p_stream->read.p_first)
+        {
+            mp4_fragentry_t *p_next = p_stream->read.p_first->p_next;
+            block_Release(p_stream->read.p_first->p_block);
+            free(p_stream->read.p_first);
+            p_stream->read.p_first = p_next;
+        }
+        while(p_stream->towrite.p_first)
+        {
+            mp4_fragentry_t *p_next = p_stream->towrite.p_first->p_next;
+            block_Release(p_stream->towrite.p_first->p_block);
+            free(p_stream->towrite.p_first);
+            p_stream->towrite.p_first = p_next;
+        }
+        free(p_stream->p_indexentries);
+    }
+    free(p_sys);
+}
+
+static void CloseFrag(vlc_object_t *p_this)
+{
+    sout_mux_t *p_mux = (sout_mux_t *) p_this;
+    sout_mux_sys_t *p_sys = (sout_mux_sys_t*) p_mux->p_sys;
+
+    /* Flush remaining entries */
+    for (unsigned int i = 0; i < p_sys->i_nb_streams; i++)
+    {
+        mp4_stream_t *p_stream = p_sys->pp_streams[i];
+        if (p_stream->p_held_entry)
+        {
+            if (p_stream->p_held_entry->p_block->i_length < 1)
+                LengthLocalFixup(p_mux, p_stream, p_stream->p_held_entry->p_block);
+            ENQUEUE_ENTRY(p_stream->read, p_stream->p_held_entry);
+            p_stream->p_held_entry = NULL;
+        }
+    }
+
+    /* and force creating a fragment from it */
+    WriteFragments(p_mux, true);
+
+    /* Write indexes, but only for non streamed content
+       as they refer to moof by absolute position */
+    if (!strcmp(p_mux->psz_mux, "mp4frag"))
+    {
+        bo_t *mfra = GetMfraBox(p_mux);
+        if (mfra)
+        {
+            bo_t *mfro = box_full_new("mfro", 0, 0x0);
+            if (mfro)
+            {
+                box_fix(mfra);
+                bo_add_32be(mfro, mfra->len + MP4_MFRO_BOXSIZE);
+                box_gather(mfra, mfro);
+            }
+            box_send(p_mux, mfra);
+        }
+    }
+
+    CleanupFrag(p_sys);
+}
+
+static int MuxFrag(sout_mux_t *p_mux)
+{
+    sout_mux_sys_t *p_sys = (sout_mux_sys_t*) p_mux->p_sys;
+
+    int i_stream = sout_MuxGetStream(p_mux, 1, NULL);
+    if (i_stream < 0)
+        return VLC_SUCCESS;
+    sout_input_t *p_input  = p_mux->pp_inputs[i_stream];
+    mp4_stream_t *p_stream = (mp4_stream_t*) p_input->p_sys;
+    block_t *p_currentblock = block_FifoGet(p_input->p_fifo);
+
+    /* do block conversion */
+    switch(p_stream->fmt.i_codec)
+    {
+    case VLC_CODEC_H264:
+    case VLC_CODEC_HEVC:
+        p_currentblock = ConvertFromAnnexB(p_currentblock);
+        break;
+    case VLC_CODEC_SUBT:
+        p_currentblock = ConvertSUBT(p_currentblock);
+        break;
+    default:
+        break;
+    }
+
+    /* If we have a previous entry for outgoing queue */
+    if (p_stream->p_held_entry)
+    {
+        block_t *p_heldblock = p_stream->p_held_entry->p_block;
+
+        /* Fix previous block length from current */
+        if (p_heldblock->i_length < 1)
+        {
+
+            /* Fix using dts if not on a boundary */
+            if ((p_currentblock->i_flags & BLOCK_FLAG_DISCONTINUITY) == 0)
+                p_heldblock->i_length = p_currentblock->i_dts - p_heldblock->i_dts;
+
+            if (p_heldblock->i_length < 1)
+                LengthLocalFixup(p_mux, p_stream, p_heldblock);
+        }
+
+        /* enqueue */
+        ENQUEUE_ENTRY(p_stream->read, p_stream->p_held_entry);
+        p_stream->p_held_entry = NULL;
+
+        if (p_stream->b_hasiframes && (p_heldblock->i_flags & BLOCK_FLAG_TYPE_I) &&
+            p_stream->i_read_duration - p_sys->i_written_duration < FRAGMENT_LENGTH)
+        {
+            /* Flag the last iframe time, we'll use it as boundary so it will start
+               next fragment */
+            p_stream->i_last_iframe_time = p_stream->i_read_duration;
+        }
+
+        /* update buffered time */
+        p_stream->i_read_duration += __MAX(0, p_heldblock->i_length);
+    }
+
+
+    /* set temp entry */
+    p_stream->p_held_entry = malloc(sizeof(mp4_fragentry_t));
+    if (unlikely(!p_stream->p_held_entry))
+        return VLC_ENOMEM;
+
+    p_stream->p_held_entry->p_block  = p_currentblock;
+    p_stream->p_held_entry->i_run    = p_stream->i_current_run;
+    p_stream->p_held_entry->p_next   = NULL;
+
+    if (p_stream->fmt.i_cat == VIDEO_ES )
+    {
+        if (!p_stream->b_hasiframes && (p_currentblock->i_flags & BLOCK_FLAG_TYPE_I))
+            p_stream->b_hasiframes = true;
+
+        if (!p_stream->b_hasbframes && p_currentblock->i_dts > VLC_TS_INVALID &&
+            p_currentblock->i_pts > p_currentblock->i_dts)
+            p_stream->b_hasbframes = true;
+    }
+
+    /* Update the global fragment/media duration */
+    mtime_t i_min_read_duration = p_stream->i_read_duration;
+    mtime_t i_min_written_duration = p_stream->i_written_duration;
+    for (unsigned int i=0; i<p_sys->i_nb_streams; i++)
+    {
+        const mp4_stream_t *p_s = p_sys->pp_streams[i];
+        if (p_s->fmt.i_cat != VIDEO_ES && p_s->fmt.i_cat != AUDIO_ES)
+            continue;
+        if (p_s->i_read_duration < i_min_read_duration)
+            i_min_read_duration = p_s->i_read_duration;
+
+        if (p_s->i_written_duration < i_min_written_duration)
+            i_min_written_duration = p_s->i_written_duration;
+    }
+    p_sys->i_read_duration = i_min_read_duration;
+    p_sys->i_written_duration = i_min_written_duration;
+
+    /* we have prerolled enough to know all streams, and have enough date to create a fragment */
+    if (p_stream->read.p_first && p_sys->i_read_duration - p_sys->i_written_duration >= FRAGMENT_LENGTH)
+        WriteFragments(p_mux, false);
+
+    return VLC_SUCCESS;
+}