Commit ee789427 authored by François Cartegnie's avatar François Cartegnie 🤞

mux: mp4: add fragmented mp4 muxer

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.
parent c03f0964
......@@ -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
......
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
......
......@@ -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(