b58a999dbe13dbce30a2ee9a08d8292888408e2e
[vlc.git] / modules / mux / mp4 / mp4.c
1 /*****************************************************************************
2  * mp4.c: mp4/mov muxer
3  *****************************************************************************
4  * Copyright (C) 2001, 2002, 2003, 2006 VLC authors and VideoLAN
5  *
6  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
7  *          Gildas Bazin <gbazin at videolan dot org>
8  *
9  * This program is free software; you can redistribute it and/or modify it
10  * under the terms of the GNU Lesser General Public License as published by
11  * the Free Software Foundation; either version 2.1 of the License, or
12  * (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17  * GNU Lesser General Public License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public License
20  * along with this program; if not, write to the Free Software Foundation,
21  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
22  *****************************************************************************/
23 #ifdef HAVE_CONFIG_H
24 # include "config.h"
25 #endif
26
27 /*****************************************************************************
28  * Preamble
29  *****************************************************************************/
30
31 #include <vlc_common.h>
32 #include <vlc_plugin.h>
33 #include <vlc_sout.h>
34 #include <vlc_block.h>
35
36 #include <assert.h>
37 #include <time.h>
38
39 #include <vlc_iso_lang.h>
40 #include <vlc_meta.h>
41
42 #include "../../demux/mp4/libmp4.h"
43 #include "libmp4mux.h"
44 #include "../../packetizer/hxxx_nal.h"
45 #include "../av1_pack.h"
46 #include "../extradata.h"
47
48 /*****************************************************************************
49  * Module descriptor
50  *****************************************************************************/
51 #define FASTSTART_TEXT N_("Create \"Fast Start\" files")
52 #define FASTSTART_LONGTEXT N_(\
53     "Create \"Fast Start\" files. " \
54     "\"Fast Start\" files are optimized for downloads and allow the user " \
55     "to start previewing the file while it is downloading.")
56
57 static int  Open   (vlc_object_t *);
58 static void Close  (vlc_object_t *);
59 static void CloseFrag  (vlc_object_t *);
60
61 #define SOUT_CFG_PREFIX "sout-mp4-"
62
63 vlc_module_begin ()
64     set_description(N_("MP4/MOV muxer"))
65     set_category(CAT_SOUT)
66     set_subcategory(SUBCAT_SOUT_MUX)
67     set_shortname("MP4")
68
69     add_bool(SOUT_CFG_PREFIX "faststart", false,
70               FASTSTART_TEXT, FASTSTART_LONGTEXT,
71               true)
72     set_capability("sout mux", 5)
73     add_shortcut("mp4", "mov", "3gp")
74     set_callbacks(Open, Close)
75
76 add_submodule ()
77     set_description(N_("Fragmented and streamable MP4 muxer"))
78     set_category(CAT_SOUT)
79     set_subcategory(SUBCAT_SOUT_MUX)
80     set_shortname("MP4 Frag")
81     add_shortcut("mp4frag", "mp4stream")
82     set_capability("sout mux", 0)
83     set_callbacks(Open, CloseFrag)
84
85 vlc_module_end ()
86
87 /*****************************************************************************
88  * Exported prototypes
89  *****************************************************************************/
90 static const char *const ppsz_sout_options[] = {
91     "faststart", NULL
92 };
93
94 static int Control(sout_mux_t *, int, va_list);
95 static int AddStream(sout_mux_t *, sout_input_t *);
96 static void DelStream(sout_mux_t *, sout_input_t *);
97 static int Mux      (sout_mux_t *);
98 static int MuxFrag  (sout_mux_t *);
99
100 /*****************************************************************************
101  * Local prototypes
102  *****************************************************************************/
103
104 typedef struct mp4_fragentry_t mp4_fragentry_t;
105
106 struct mp4_fragentry_t
107 {
108     block_t  *p_block;
109     uint32_t  i_run;
110     mp4_fragentry_t *p_next;
111 };
112
113 typedef struct mp4_fragindex_t
114 {
115     uint64_t i_moofoffset;
116     vlc_tick_t  i_time;
117     uint8_t  i_traf;
118     uint8_t  i_trun;
119     uint32_t i_sample;
120 } mp4_fragindex_t;
121
122 typedef struct mp4_fragqueue_t
123 {
124     mp4_fragentry_t *p_first;
125     mp4_fragentry_t *p_last;
126 } mp4_fragqueue_t;
127
128 typedef struct
129 {
130     mp4mux_trackinfo_t *tinfo;
131
132     mux_extradata_builder_t *extrabuilder;
133
134     /* index */
135     vlc_tick_t   i_length_neg;
136
137     /* applies to current segment only */
138     vlc_tick_t   i_first_dts;
139     vlc_tick_t   i_last_dts;
140     vlc_tick_t   i_last_pts;
141
142     /*** mp4frag ***/
143     bool         b_hasiframes;
144
145     uint32_t         i_current_run;
146     mp4_fragentry_t *p_held_entry;
147     mp4_fragqueue_t  read;
148     mp4_fragqueue_t  towrite;
149     vlc_tick_t       i_last_iframe_time;
150     vlc_tick_t       i_written_duration;
151     mp4_fragindex_t *p_indexentries;
152     uint32_t         i_indexentriesmax;
153     uint32_t         i_indexentries;
154 } mp4_stream_t;
155
156 typedef struct
157 {
158     mp4mux_handle_t *muxh;
159     bool b_3gp;
160     bool b_fast_start;
161
162     /* global */
163     bool     b_header_sent;
164
165     uint64_t i_mdat_pos;
166     uint64_t i_pos;
167     vlc_tick_t  i_read_duration;
168     vlc_tick_t  i_start_dts;
169
170     unsigned int   i_nb_streams;
171     mp4_stream_t **pp_streams;
172
173
174     /* mp4frag */
175     vlc_tick_t     i_written_duration;
176     uint32_t       i_mfhd_sequence;
177 } sout_mux_sys_t;
178
179 static void mp4_stream_Delete(mp4_stream_t *p_stream)
180 {
181     if(p_stream->extrabuilder)
182         mux_extradata_builder_Delete(p_stream->extrabuilder);
183
184     /* mp4 frag */
185     if (p_stream->p_held_entry)
186     {
187         block_Release(p_stream->p_held_entry->p_block);
188         free(p_stream->p_held_entry);
189     }
190     while(p_stream->read.p_first)
191     {
192         mp4_fragentry_t *p_next = p_stream->read.p_first->p_next;
193         block_Release(p_stream->read.p_first->p_block);
194         free(p_stream->read.p_first);
195         p_stream->read.p_first = p_next;
196     }
197     while(p_stream->towrite.p_first)
198     {
199         mp4_fragentry_t *p_next = p_stream->towrite.p_first->p_next;
200         block_Release(p_stream->towrite.p_first->p_block);
201         free(p_stream->towrite.p_first);
202         p_stream->towrite.p_first = p_next;
203     }
204     free(p_stream->p_indexentries);
205
206     free(p_stream);
207 }
208
209 static mp4_stream_t *mp4_stream_New(void)
210 {
211     mp4_stream_t *p_stream = calloc(1, sizeof(*p_stream));
212     if(p_stream)
213     {
214         p_stream->i_first_dts = VLC_TICK_INVALID;
215         p_stream->i_last_dts = VLC_TICK_INVALID;
216         p_stream->i_last_pts = VLC_TICK_INVALID;
217     }
218     return p_stream;
219 }
220
221 static void box_send(sout_mux_t *p_mux,  bo_t *box);
222
223 static block_t *ConvertSUBT(block_t *);
224 static bool CreateCurrentEdit(mp4_stream_t *, vlc_tick_t, bool);
225 static int MuxStream(sout_mux_t *p_mux, sout_input_t *p_input, mp4_stream_t *p_stream);
226
227 static int WriteSlowStartHeader(sout_mux_t *p_mux)
228 {
229     sout_mux_sys_t *p_sys = p_mux->p_sys;
230     bo_t *box;
231
232     if (!mp4mux_Is(p_sys->muxh, QUICKTIME))
233     {
234         /* Now add ftyp header */
235         box = mp4mux_GetFtyp(p_sys->muxh);
236         if(!box)
237             return VLC_ENOMEM;
238
239         p_sys->i_pos += bo_size(box);
240         p_sys->i_mdat_pos = p_sys->i_pos;
241         box_send(p_mux, box);
242     }
243
244     /* Now add mdat header */
245     box = box_new("mdat");
246     if(!box)
247         return VLC_ENOMEM;
248
249     bo_add_64be(box, 0); // enough to store an extended size
250
251     if(box->b)
252         p_sys->i_pos += bo_size(box);
253
254     box_send(p_mux, box);
255
256     return VLC_SUCCESS;
257 }
258
259 /*****************************************************************************
260  * Open:
261  *****************************************************************************/
262 static int Open(vlc_object_t *p_this)
263 {
264     sout_mux_t      *p_mux = (sout_mux_t*)p_this;
265     sout_mux_sys_t  *p_sys = malloc(sizeof(sout_mux_sys_t));
266     if (!p_sys)
267         return VLC_ENOMEM;
268
269     msg_Dbg(p_mux, "Mp4 muxer opened");
270     config_ChainParse(p_mux, SOUT_CFG_PREFIX, ppsz_sout_options, p_mux->p_cfg);
271
272     enum mp4mux_options options = 0;
273     if(p_mux->psz_mux)
274     {
275         if(!strcmp(p_mux->psz_mux, "mov"))
276             options |= QUICKTIME;
277         if(!strcmp(p_mux->psz_mux, "mp4frag") || !strcmp(p_mux->psz_mux, "mp4stream"))
278             options |= FRAGMENTED;
279     }
280
281     p_sys->b_3gp = p_mux->psz_mux && !strcmp(p_mux->psz_mux, "3gp");
282
283     p_sys->muxh = mp4mux_New(options);
284
285     p_sys->i_pos        = 0;
286     p_sys->i_nb_streams = 0;
287     p_sys->pp_streams   = NULL;
288     p_sys->i_mdat_pos   = 0;
289     p_sys->b_header_sent = false;
290
291     p_sys->i_read_duration   = 0;
292     p_sys->i_written_duration= 0;
293     p_sys->i_start_dts = VLC_TICK_INVALID;
294     p_sys->i_mfhd_sequence = 1;
295
296     p_mux->p_sys        = p_sys;
297     p_mux->pf_control   = Control;
298     p_mux->pf_addstream = AddStream;
299     p_mux->pf_delstream = DelStream;
300     p_mux->pf_mux       = (options & FRAGMENTED) ? MuxFrag : Mux;
301
302     if(p_sys->b_3gp)
303     {
304         mp4mux_SetBrand(p_sys->muxh, BRAND_3gp6, 0x0);
305         mp4mux_AddExtraBrand(p_sys->muxh, BRAND_3gp4);
306     }
307     else
308     {
309         mp4mux_SetBrand(p_sys->muxh, BRAND_isom, 0x0);
310     }
311
312     return VLC_SUCCESS;
313 }
314
315 /*****************************************************************************
316  * Close:
317  *****************************************************************************/
318 static void Close(vlc_object_t *p_this)
319 {
320     sout_mux_t      *p_mux = (sout_mux_t*)p_this;
321     sout_mux_sys_t  *p_sys = p_mux->p_sys;
322
323     msg_Dbg(p_mux, "Close");
324
325     /* Update mdat size */
326     bo_t bo;
327     if (!bo_init(&bo, 16))
328         goto cleanup;
329     if (p_sys->i_pos - p_sys->i_mdat_pos >= (((uint64_t)1)<<32)) {
330         /* Extended size */
331         bo_add_32be  (&bo, 1);
332         bo_add_fourcc(&bo, "mdat");
333         bo_add_64be  (&bo, p_sys->i_pos - p_sys->i_mdat_pos);
334     } else {
335         bo_add_32be  (&bo, 8);
336         bo_add_fourcc(&bo, "wide");
337         bo_add_32be  (&bo, p_sys->i_pos - p_sys->i_mdat_pos - 8);
338         bo_add_fourcc(&bo, "mdat");
339     }
340
341     sout_AccessOutSeek(p_mux->p_access, p_sys->i_mdat_pos);
342     sout_AccessOutWrite(p_mux->p_access, bo.b);
343
344     /* Create MOOV header */
345     bool b_64bitext = (p_sys->i_pos > UINT32_MAX);
346     if(b_64bitext)
347         mp4mux_Set64BitExt(p_sys->muxh);
348
349     uint64_t i_moov_pos = p_sys->i_pos;
350     bo_t *moov = mp4mux_GetMoov(p_sys->muxh, VLC_OBJECT(p_mux), 0);
351
352     /* Check we need to create "fast start" files */
353     p_sys->b_fast_start = var_GetBool(p_this, SOUT_CFG_PREFIX "faststart");
354     while (p_sys->b_fast_start && moov && moov->b)
355     {
356         /* Move data to the end of the file so we can fit the moov header
357          * at the start */
358         uint64_t i_mdatsize = p_sys->i_pos - p_sys->i_mdat_pos;
359
360         /* moving samples will need new moov with 64bit atoms ? */
361         if(!b_64bitext && p_sys->i_pos + bo_size(moov) > UINT32_MAX)
362         {
363             mp4mux_Set64BitExt(p_sys->muxh);
364             b_64bitext = true;
365             /* generate a new moov */
366             bo_t *moov64 = mp4mux_GetMoov(p_sys->muxh, VLC_OBJECT(p_mux), 0);
367             if(moov64)
368             {
369                 bo_free(moov);
370                 moov = moov64;
371             }
372         }
373         /* We now know our final MOOV size */
374
375         /* Fix-up samples to chunks table in MOOV header to they point to next MDAT location */
376         mp4mux_ShiftSamples(p_sys->muxh, bo_size(moov));
377         msg_Dbg(p_this,"Moving data by %"PRIu64, (uint64_t)bo_size(moov));
378         bo_t *shifted = mp4mux_GetMoov(p_sys->muxh, VLC_OBJECT(p_mux), 0);
379         if(!shifted)
380         {
381             /* fail */
382             p_sys->b_fast_start = false;
383             continue;
384         }
385         assert(bo_size(shifted) == bo_size(moov));
386         bo_free(moov);
387         moov = shifted;
388
389         /* Make space, move MDAT data by moov size towards the end */
390         while (i_mdatsize > 0)
391         {
392             size_t i_chunk = __MIN(32768, i_mdatsize);
393             block_t *p_buf = block_Alloc(i_chunk);
394             sout_AccessOutSeek(p_mux->p_access,
395                                 p_sys->i_mdat_pos + i_mdatsize - i_chunk);
396             ssize_t i_read = sout_AccessOutRead(p_mux->p_access, p_buf);
397             if (i_read < 0 || (size_t) i_read < i_chunk) {
398                 msg_Warn(p_this, "read() not supported by access output, "
399                           "won't create a fast start file");
400                 p_sys->b_fast_start = false;
401                 block_Release(p_buf);
402                 break;
403             }
404             sout_AccessOutSeek(p_mux->p_access, p_sys->i_mdat_pos + i_mdatsize +
405                                bo_size(moov) - i_chunk);
406             sout_AccessOutWrite(p_mux->p_access, p_buf);
407             i_mdatsize -= i_chunk;
408         }
409
410         if (!p_sys->b_fast_start) /* failed above */
411             continue;
412
413         /* Update pos pointers */
414         i_moov_pos = p_sys->i_mdat_pos;
415         p_sys->i_mdat_pos += bo_size(moov);
416
417         p_sys->b_fast_start = false;
418     }
419
420     /* Write MOOV header */
421     sout_AccessOutSeek(p_mux->p_access, i_moov_pos);
422     if (moov != NULL)
423         box_send(p_mux, moov);
424
425 cleanup:
426     /* Clean-up */
427     for (unsigned int i_trak = 0; i_trak < p_sys->i_nb_streams; i_trak++)
428         mp4_stream_Delete(p_sys->pp_streams[i_trak]);
429     TAB_CLEAN(p_sys->i_nb_streams, p_sys->pp_streams);
430     mp4mux_Delete(p_sys->muxh);
431     free(p_sys);
432 }
433
434 /*****************************************************************************
435  * Control:
436  *****************************************************************************/
437 static int Control(sout_mux_t *p_mux, int i_query, va_list args)
438 {
439     VLC_UNUSED(p_mux);
440     bool *pb_bool;
441
442     switch(i_query)
443     {
444     case MUX_CAN_ADD_STREAM_WHILE_MUXING:
445         pb_bool = va_arg(args, bool *);
446         *pb_bool = true;
447         return VLC_SUCCESS;
448
449     case MUX_GET_MIME:   /* Not needed, as not streamable */
450     default:
451         return VLC_EGENERIC;
452     }
453 }
454
455 /*****************************************************************************
456  * AddStream:
457  *****************************************************************************/
458 static int AddStream(sout_mux_t *p_mux, sout_input_t *p_input)
459 {
460     sout_mux_sys_t  *p_sys = p_mux->p_sys;
461     mp4_stream_t    *p_stream;
462
463     if(!mp4mux_CanMux(VLC_OBJECT(p_mux), p_input->p_fmt,
464                       mp4mux_Is(p_sys->muxh, QUICKTIME) ? BRAND_qt__ : BRAND_isom,
465                       mp4mux_Is(p_sys->muxh, FRAGMENTED)))
466     {
467         msg_Err(p_mux, "unsupported codec %4.4s in mp4",
468                  (char*)&p_input->p_fmt->i_codec);
469         return VLC_EGENERIC;
470     }
471
472     if(!(p_stream = mp4_stream_New()))
473         return VLC_ENOMEM;
474
475     uint32_t i_track_timescale = CLOCK_FREQ;
476     es_format_t trackfmt;
477     es_format_Init(&trackfmt, p_input->p_fmt->i_cat, p_input->p_fmt->i_codec);
478     es_format_Copy(&trackfmt, p_input->p_fmt);
479
480     switch( p_input->p_fmt->i_cat )
481     {
482     case AUDIO_ES:
483         if(!trackfmt.audio.i_rate)
484         {
485             msg_Warn( p_mux, "no audio rate given for stream %d, assuming 48KHz",
486                       p_sys->i_nb_streams );
487             trackfmt.audio.i_rate = 48000;
488         }
489         i_track_timescale = trackfmt.audio.i_rate;
490         break;
491     case VIDEO_ES:
492         if( !trackfmt.video.i_frame_rate ||
493             !trackfmt.video.i_frame_rate_base )
494         {
495             msg_Warn( p_mux, "Missing frame rate for stream %d, assuming 25fps",
496                       p_sys->i_nb_streams );
497             trackfmt.video.i_frame_rate = 25;
498             trackfmt.video.i_frame_rate_base = 1;
499         }
500
501         i_track_timescale = trackfmt.video.i_frame_rate *
502                             trackfmt.video.i_frame_rate_base;
503
504         if( i_track_timescale > CLOCK_FREQ )
505             i_track_timescale = CLOCK_FREQ;
506         else if( i_track_timescale < 90000 )
507             i_track_timescale = 90000;
508         break;
509     default:
510         break;
511     }
512
513     p_stream->tinfo = mp4mux_track_Add(p_sys->muxh, p_sys->i_nb_streams + 1,
514                                        &trackfmt, i_track_timescale);
515     es_format_Clean(&trackfmt);
516     if(!p_stream->tinfo)
517     {
518         free(p_stream);
519         return VLC_ENOMEM;
520     }
521
522     p_stream->extrabuilder = mux_extradata_builder_New(p_input->p_fmt->i_codec,
523                                                        EXTRADATA_ISOBMFF);
524
525     p_input->p_sys          = p_stream;
526
527     msg_Dbg(p_mux, "adding input");
528
529     TAB_APPEND(p_sys->i_nb_streams, p_sys->pp_streams, p_stream);
530     return VLC_SUCCESS;
531 }
532
533 /*****************************************************************************
534  * DelStream:
535  *****************************************************************************/
536 static void DelStream(sout_mux_t *p_mux, sout_input_t *p_input)
537 {
538     sout_mux_sys_t *p_sys = p_mux->p_sys;
539     mp4_stream_t *p_stream = (mp4_stream_t*)p_input->p_sys;
540
541     if(!mp4mux_Is(p_sys->muxh, FRAGMENTED))
542     {
543         while(block_FifoCount(p_input->p_fifo) > 0 &&
544               MuxStream(p_mux, p_input, p_stream) == VLC_SUCCESS) {};
545
546         if(CreateCurrentEdit(p_stream, p_sys->i_start_dts, false))
547             mp4mux_track_DebugEdits(VLC_OBJECT(p_mux), p_stream->tinfo);
548     }
549
550     msg_Dbg(p_mux, "removing input");
551 }
552
553 /*****************************************************************************
554  * Mux:
555  *****************************************************************************/
556 static bool CreateCurrentEdit(mp4_stream_t *p_stream, vlc_tick_t i_mux_start_dts,
557                               bool b_fragmented)
558 {
559     const mp4mux_edit_t *p_lastedit = mp4mux_track_GetLastEdit(p_stream->tinfo);
560
561     /* Never more than first empty edit for fragmented */
562     if(p_lastedit != NULL && b_fragmented)
563         return true;
564
565     const mp4mux_sample_t *p_lastsample = mp4mux_track_GetLastSample(p_stream->tinfo);
566     if(p_lastsample == NULL)
567         return true;
568
569     mp4mux_edit_t newedit;
570
571     if(p_lastedit == NULL)
572     {
573         newedit.i_start_time = 0;
574         newedit.i_start_offset = __MAX(0, p_stream->i_first_dts - i_mux_start_dts);
575     }
576     else
577     {
578         newedit.i_start_time = __MAX(0, p_lastedit->i_start_time + p_lastedit->i_duration);
579         newedit.i_start_offset = 0;
580     }
581
582     if(b_fragmented)
583     {
584         newedit.i_duration = 0;
585     }
586     else
587     {
588         if(p_stream->i_last_pts != VLC_TICK_INVALID)
589             newedit.i_duration = p_stream->i_last_pts - p_stream->i_first_dts;
590         else
591             newedit.i_duration = p_stream->i_last_dts - p_stream->i_first_dts;
592
593         newedit.i_duration += p_lastsample->i_length;
594     }
595
596     return mp4mux_track_AddEdit(p_stream->tinfo, &newedit);
597 }
598
599 static block_t * BlockDequeue(sout_input_t *p_input, mp4_stream_t *p_stream)
600 {
601     block_t *p_block = block_FifoGet(p_input->p_fifo);
602     if(unlikely(!p_block))
603         return NULL;
604
605     /* Create on the fly extradata as packetizer is not in the loop */
606     if(p_stream->extrabuilder && !mp4mux_track_HasSamplePriv(p_stream->tinfo))
607     {
608          mux_extradata_builder_Feed(p_stream->extrabuilder,
609                                     p_block->p_buffer, p_block->i_buffer);
610          const uint8_t *p_extra;
611          size_t i_extra = mux_extradata_builder_Get(p_stream->extrabuilder, &p_extra);
612          if(i_extra)
613             mp4mux_track_SetSamplePriv(p_stream->tinfo, p_extra, i_extra);
614     }
615
616     switch(mp4mux_track_GetFmt(p_stream->tinfo)->i_codec)
617     {
618         case VLC_CODEC_AV1:
619             p_block = AV1_Pack_Sample(p_block);
620             break;
621         case VLC_CODEC_H264:
622         case VLC_CODEC_HEVC:
623             p_block = hxxx_AnnexB_to_xVC(p_block, 4);
624             break;
625         case VLC_CODEC_SUBT:
626             p_block = ConvertSUBT(p_block);
627             break;
628         default:
629             break;
630     }
631
632     return p_block;
633 }
634
635 static inline vlc_tick_t dts_fb_pts( const block_t *p_data )
636 {
637     return p_data->i_dts != VLC_TICK_INVALID ? p_data->i_dts: p_data->i_pts;
638 }
639
640 static int MuxStream(sout_mux_t *p_mux, sout_input_t *p_input, mp4_stream_t *p_stream)
641 {
642     sout_mux_sys_t *p_sys = p_mux->p_sys;
643
644     block_t *p_data = BlockDequeue(p_input, p_stream);
645     if(!p_data)
646         return VLC_SUCCESS;
647
648     /* Reset reference dts in case of discontinuity (ex: gather sout) */
649     if (p_data->i_flags & BLOCK_FLAG_DISCONTINUITY &&
650         mp4mux_track_GetLastSample(p_stream->tinfo) != NULL)
651     {
652         if(p_stream->i_first_dts != VLC_TICK_INVALID)
653         {
654             if(!CreateCurrentEdit(p_stream, p_sys->i_start_dts,
655                                   mp4mux_Is(p_sys->muxh, FRAGMENTED)))
656             {
657                 block_Release( p_data );
658                 return VLC_ENOMEM;
659             }
660         }
661
662         p_stream->i_length_neg = 0;
663         p_stream->i_first_dts = VLC_TICK_INVALID;
664         p_stream->i_last_dts = VLC_TICK_INVALID;
665         p_stream->i_last_pts = VLC_TICK_INVALID;
666     }
667
668     /* Set current segment ranges */
669     if( p_stream->i_first_dts == VLC_TICK_INVALID )
670     {
671         p_stream->i_first_dts = dts_fb_pts( p_data );
672         if( p_sys->i_start_dts == VLC_TICK_INVALID )
673             p_sys->i_start_dts = p_stream->i_first_dts;
674     }
675
676     if (mp4mux_track_GetFmt(p_stream->tinfo)->i_cat != SPU_ES)
677     {
678         /* Fix length of the sample */
679         if (block_FifoCount(p_input->p_fifo) > 0)
680         {
681             block_t *p_next = block_FifoShow(p_input->p_fifo);
682             if ( p_next->i_flags & BLOCK_FLAG_DISCONTINUITY )
683             { /* we have no way to know real length except by decoding */
684                 if ( mp4mux_track_GetFmt(p_stream->tinfo)->i_cat == VIDEO_ES )
685                 {
686                     p_data->i_length = vlc_tick_from_samples(
687                             mp4mux_track_GetFmt(p_stream->tinfo)->video.i_frame_rate_base,
688                             mp4mux_track_GetFmt(p_stream->tinfo)->video.i_frame_rate );
689                     if( p_data->i_flags & BLOCK_FLAG_SINGLE_FIELD )
690                         p_data->i_length >>= 1;
691                     msg_Dbg( p_mux, "video track %u fixup to %"PRId64" for sample %u",
692                              mp4mux_track_GetID(p_stream->tinfo), p_data->i_length,
693                              mp4mux_track_GetSampleCount(p_stream->tinfo) );
694                 }
695                 else if ( mp4mux_track_GetFmt(p_stream->tinfo)->i_cat == AUDIO_ES &&
696                           mp4mux_track_GetFmt(p_stream->tinfo)->audio.i_rate &&
697                           p_data->i_nb_samples )
698                 {
699                     p_data->i_length = vlc_tick_from_samples(p_data->i_nb_samples,
700                             mp4mux_track_GetFmt(p_stream->tinfo)->audio.i_rate);
701                     msg_Dbg( p_mux, "audio track %u fixup to %"PRId64" for sample %u",
702                              mp4mux_track_GetID(p_stream->tinfo), p_data->i_length,
703                              mp4mux_track_GetSampleCount(p_stream->tinfo) );
704                 }
705                 else if ( p_data->i_length <= 0 )
706                 {
707                     msg_Warn( p_mux, "unknown length for track %u sample %u",
708                               mp4mux_track_GetID(p_stream->tinfo),
709                               mp4mux_track_GetSampleCount(p_stream->tinfo) );
710                     p_data->i_length = 1;
711                 }
712             }
713             else
714             {
715                 vlc_tick_t i_diff  = dts_fb_pts( p_next ) - dts_fb_pts( p_data );
716                 if (i_diff < VLC_TICK_FROM_SEC(1)) /* protection */
717                     p_data->i_length = i_diff;
718             }
719         }
720         if (p_data->i_length <= 0) {
721             msg_Warn(p_mux, "i_length <= 0");
722             p_stream->i_length_neg += p_data->i_length - 1;
723             p_data->i_length = 1;
724         } else if (p_stream->i_length_neg < 0) {
725             int64_t i_recover = __MIN(p_data->i_length / 4, - p_stream->i_length_neg);
726
727             p_data->i_length -= i_recover;
728             p_stream->i_length_neg += i_recover;
729         }
730     }
731     else /* SPU_ES */
732     {
733         const mp4mux_sample_t *p_lastsample = mp4mux_track_GetLastSample(p_stream->tinfo);
734         if (p_lastsample != NULL && p_lastsample->i_length == 0)
735         {
736             mp4mux_sample_t updated = *p_lastsample;
737             /* length of previous spu, stored in spu clearer */
738             int64_t i_length = dts_fb_pts( p_data ) - p_stream->i_last_dts;
739             if(i_length < 0)
740                 i_length = 0;
741             /* Fix entry */
742             updated.i_length = i_length;
743             mp4mux_track_UpdateLastSample(p_stream->tinfo, &updated);
744         }
745     }
746
747     /* Flag interlacing on first block */
748     if(mp4mux_track_GetFmt(p_stream->tinfo)->i_cat == VIDEO_ES &&
749        (p_data->i_flags & BLOCK_FLAG_INTERLACED_MASK) &&
750        mp4mux_track_GetInterlacing(p_stream->tinfo) == INTERLACING_NONE)
751     {
752         if(p_data->i_flags & BLOCK_FLAG_SINGLE_FIELD)
753             mp4mux_track_SetInterlacing(p_stream->tinfo, INTERLACING_SINGLE_FIELD);
754         else if(p_data->i_flags & BLOCK_FLAG_TOP_FIELD_FIRST)
755             mp4mux_track_SetInterlacing(p_stream->tinfo, INTERLACING_TOPBOTTOM);
756         else
757             mp4mux_track_SetInterlacing(p_stream->tinfo, INTERLACING_BOTTOMTOP);
758     }
759
760     /* Update (Not earlier for SPU!) */
761     p_stream->i_last_dts = dts_fb_pts( p_data );
762     if( p_data->i_pts > p_stream->i_last_pts )
763         p_stream->i_last_pts = p_data->i_pts;
764
765     /* add index entry */
766     mp4mux_sample_t sample;
767     sample.i_pos    = p_sys->i_pos;
768     sample.i_size   = p_data->i_buffer;
769
770     if ( p_data->i_dts != VLC_TICK_INVALID && p_data->i_pts > p_data->i_dts )
771         sample.i_pts_dts = p_data->i_pts - p_data->i_dts;
772     else
773         sample.i_pts_dts = 0;
774
775     sample.i_length = p_data->i_length;
776     sample.i_flags  = p_data->i_flags;
777
778     /* update */
779     p_stream->i_last_dts = dts_fb_pts( p_data );
780
781     /* write data */
782     if(mp4mux_track_AddSample(p_stream->tinfo, &sample))
783     {
784         p_sys->i_pos += p_data->i_buffer;
785         sout_AccessOutWrite(p_mux->p_access, p_data);
786     }
787
788     /* Add SPU clearing tag (duration tb fixed on next SPU or stream end )*/
789     if ( mp4mux_track_GetFmt(p_stream->tinfo)->i_cat == SPU_ES && sample.i_length > 0 )
790     {
791         block_t *p_empty = NULL;
792         if(mp4mux_track_GetFmt(p_stream->tinfo)->i_codec == VLC_CODEC_SUBT||
793            mp4mux_track_GetFmt(p_stream->tinfo)->i_codec == VLC_CODEC_QTXT||
794            mp4mux_track_GetFmt(p_stream->tinfo)->i_codec == VLC_CODEC_TX3G)
795         {
796             p_empty = block_Alloc(3);
797             if(p_empty)
798             {
799                 /* Write a " " */
800                 p_empty->p_buffer[0] = 0;
801                 p_empty->p_buffer[1] = 1;
802                 p_empty->p_buffer[2] = ' ';
803             }
804         }
805         else if(mp4mux_track_GetFmt(p_stream->tinfo)->i_codec == VLC_CODEC_TTML)
806         {
807             p_empty = block_Alloc(40);
808             if(p_empty)
809                 memcpy(p_empty->p_buffer, "<tt><body><div><p></p></div></body></tt>", 40);
810         }
811         else if(mp4mux_track_GetFmt(p_stream->tinfo)->i_codec == VLC_CODEC_WEBVTT)
812         {
813             p_empty = block_Alloc(8);
814             if(p_empty)
815                 memcpy(p_empty->p_buffer, "\x00\x00\x00\x08vtte", 8);
816         }
817
818         /* point to start of our empty */
819         p_stream->i_last_dts += sample.i_length;
820
821         if(p_empty)
822         {
823             /* Append a idx entry */
824             /* XXX: No need to grow the entry here */
825             mp4mux_sample_t closersample;
826             closersample.i_pos    = p_sys->i_pos;
827             closersample.i_size   = p_empty->i_buffer;
828             closersample.i_pts_dts= 0;
829             closersample.i_length = 0; /* will add dts diff later*/
830             closersample.i_flags  = 0;
831
832             if(mp4mux_track_AddSample(p_stream->tinfo, &closersample))
833             {
834                 p_sys->i_pos += p_empty->i_buffer;
835                 sout_AccessOutWrite(p_mux->p_access, p_empty);
836             }
837         }
838     }
839
840     /* Update the global segment/media duration */
841     if( mp4mux_track_GetDuration(p_stream->tinfo) > p_sys->i_read_duration )
842         p_sys->i_read_duration = mp4mux_track_GetDuration(p_stream->tinfo);
843
844     return VLC_SUCCESS;
845 }
846
847 static int Mux(sout_mux_t *p_mux)
848 {
849     sout_mux_sys_t *p_sys = p_mux->p_sys;
850     int i_ret = VLC_SUCCESS;
851
852     if(!p_sys->b_header_sent)
853     {
854         i_ret = WriteSlowStartHeader(p_mux);
855         if(i_ret != VLC_SUCCESS)
856             return i_ret;
857         p_sys->b_header_sent = true;
858     }
859
860     do
861     {
862         int i_stream = sout_MuxGetStream(p_mux, 2, NULL);
863         if (i_stream < 0)
864             break;
865
866         sout_input_t *p_input  = p_mux->pp_inputs[i_stream];
867         mp4_stream_t *p_stream = (mp4_stream_t*)p_input->p_sys;
868
869         i_ret = MuxStream(p_mux, p_input, p_stream);
870     } while( i_ret == VLC_SUCCESS );
871
872     return i_ret;
873 }
874
875 /*****************************************************************************
876  *
877  *****************************************************************************/
878 static block_t *ConvertSUBT(block_t *p_block)
879 {
880     p_block = block_Realloc(p_block, 2, p_block->i_buffer);
881     if( !p_block )
882         return NULL;
883     /* No trailling '\0' */
884     if (p_block->i_buffer > 2 && p_block->p_buffer[p_block->i_buffer-1] == '\0')
885         p_block->i_buffer--;
886
887     p_block->p_buffer[0] = ((p_block->i_buffer - 2) >> 8)&0xff;
888     p_block->p_buffer[1] = ((p_block->i_buffer - 2)     )&0xff;
889
890     return p_block;
891 }
892
893 static void box_send(sout_mux_t *p_mux,  bo_t *box)
894 {
895     assert(box != NULL);
896     if (box->b)
897         sout_AccessOutWrite(p_mux->p_access, box->b);
898     free(box);
899 }
900
901 /***************************************************************************
902     MP4 Live submodule
903 ****************************************************************************/
904 #define FRAGMENT_LENGTH  VLC_TICK_FROM_MS(1500)
905
906 #define ENQUEUE_ENTRY(object, entry) \
907     do {\
908         if (object.p_last)\
909             object.p_last->p_next = entry;\
910         object.p_last = entry;\
911         if (!object.p_first)\
912             object.p_first = entry;\
913     } while(0)
914
915 #define DEQUEUE_ENTRY(object, entry) \
916     do {\
917         entry = object.p_first;\
918         if (object.p_last == entry)\
919             object.p_last = NULL;\
920         object.p_first = object.p_first->p_next;\
921         entry->p_next = NULL;\
922     } while(0)
923
924 /* Creates mfra/traf index entries */
925 static void AddKeyframeEntry(mp4_stream_t *p_stream, const uint64_t i_moof_pos,
926                              const uint8_t i_traf, const uint32_t i_sample,
927                              const vlc_tick_t i_time)
928 {
929     /* alloc or realloc */
930     mp4_fragindex_t *p_entries = p_stream->p_indexentries;
931     if (p_stream->i_indexentries >= p_stream->i_indexentriesmax)
932     {
933         p_stream->i_indexentriesmax += 256;
934         p_entries = xrealloc(p_stream->p_indexentries,
935                              p_stream->i_indexentriesmax * sizeof(mp4_fragindex_t));
936         if (p_entries) /* realloc can fail */
937             p_stream->p_indexentries = p_entries;
938     }
939
940     vlc_tick_t i_last_entry_time;
941     if (p_stream->i_indexentries)
942         i_last_entry_time = p_stream->p_indexentries[p_stream->i_indexentries - 1].i_time;
943     else
944         i_last_entry_time = 0;
945
946     if (p_entries && i_time - i_last_entry_time >= VLC_TICK_FROM_SEC(2))
947     {
948         mp4_fragindex_t *p_indexentry = &p_stream->p_indexentries[p_stream->i_indexentries];
949         p_indexentry->i_time = i_time;
950         p_indexentry->i_moofoffset = i_moof_pos;
951         p_indexentry->i_sample = i_sample;
952         p_indexentry->i_traf = i_traf;
953         p_indexentry->i_trun = 1;
954         p_stream->i_indexentries++;
955     }
956 }
957
958 /* Creates moof box and traf/trun information.
959  * Single run per traf is absolutely not optimal as interleaving should be done
960  * using runs and not limiting moof size, but creating an relative offset only
961  * requires base_offset_is_moof and then comply to late iso brand spec which
962  * breaks clients. */
963 static bo_t *GetMoofBox(sout_mux_t *p_mux, size_t *pi_mdat_total_size,
964                         vlc_tick_t i_barrier_time, const uint64_t i_write_pos)
965 {
966     sout_mux_sys_t *p_sys = p_mux->p_sys;
967
968     bo_t            *moof, *mfhd;
969     size_t           i_fixupoffset = 0;
970
971     *pi_mdat_total_size = 0;
972
973     moof = box_new("moof");
974     if(!moof)
975         return NULL;
976
977     /* *** add /moof/mfhd *** */
978
979     mfhd = box_full_new("mfhd", 0, 0);
980     if(!mfhd)
981     {
982         bo_free(moof);
983         return NULL;
984     }
985     bo_add_32be(mfhd, p_sys->i_mfhd_sequence++);   // sequence number
986
987     box_gather(moof, mfhd);
988
989     for (unsigned int i_trak = 0; i_trak < p_sys->i_nb_streams; i_trak++)
990     {
991         mp4_stream_t *p_stream = p_sys->pp_streams[i_trak];
992
993         /* *** add /moof/traf *** */
994         bo_t *traf = box_new("traf");
995         if(!traf)
996             continue;
997         uint32_t i_sample = 0;
998         vlc_tick_t i_time = p_stream->i_written_duration;
999         bool b_allsamesize = true;
1000         bool b_allsamelength = true;
1001         if ( p_stream->read.p_first )
1002         {
1003             mp4_fragentry_t *p_entry = p_stream->read.p_first->p_next;
1004             while (p_entry && (b_allsamelength || b_allsamesize))
1005             {
1006                 /* compare against queue head */
1007                 b_allsamelength &= ( p_entry->p_block->i_length == p_stream->read.p_first->p_block->i_length );
1008                 b_allsamesize &= ( p_entry->p_block->i_buffer == p_stream->read.p_first->p_block->i_buffer );
1009                 p_entry = p_entry->p_next;
1010             }
1011         }
1012
1013         uint32_t i_tfhd_flags = 0x0;
1014         if (p_stream->read.p_first)
1015         {
1016             /* Current segment have all same duration value, different than trex's default */
1017             if (b_allsamelength &&
1018                 p_stream->read.p_first->p_block->i_length !=
1019                     mp4mux_track_GetDefaultSampleDuration(p_stream->tinfo) &&
1020                 p_stream->read.p_first->p_block->i_length)
1021                     i_tfhd_flags |= MP4_TFHD_DFLT_SAMPLE_DURATION;
1022
1023             /* Current segment have all same size value, different than trex's default */
1024             if (b_allsamesize &&
1025                 p_stream->read.p_first->p_block->i_buffer !=
1026                     mp4mux_track_GetDefaultSampleSize(p_stream->tinfo) &&
1027                 p_stream->read.p_first->p_block->i_buffer)
1028                     i_tfhd_flags |= MP4_TFHD_DFLT_SAMPLE_SIZE;
1029         }
1030         else
1031         {
1032             /* We have no samples */
1033             i_tfhd_flags |= MP4_TFHD_DURATION_IS_EMPTY;
1034         }
1035
1036         /* *** add /moof/traf/tfhd *** */
1037         bo_t *tfhd = box_full_new("tfhd", 0, i_tfhd_flags);
1038         if(!tfhd)
1039         {
1040             bo_free(traf);
1041             continue;
1042         }
1043         bo_add_32be(tfhd, mp4mux_track_GetID(p_stream->tinfo));
1044
1045         /* set the local sample duration default */
1046         if (i_tfhd_flags & MP4_TFHD_DFLT_SAMPLE_DURATION)
1047             bo_add_32be(tfhd, samples_from_vlc_tick(p_stream->read.p_first->p_block->i_length,
1048                                                     mp4mux_track_GetTimescale(p_stream->tinfo)));
1049
1050         /* set the local sample size default */
1051         if (i_tfhd_flags & MP4_TFHD_DFLT_SAMPLE_SIZE)
1052             bo_add_32be(tfhd, p_stream->read.p_first->p_block->i_buffer);
1053
1054         box_gather(traf, tfhd);
1055
1056         /* *** add /moof/traf/tfdt *** */
1057         bo_t *tfdt = box_full_new("tfdt", 1, 0);
1058         if(!tfdt)
1059         {
1060             bo_free(traf);
1061             continue;
1062         }
1063         bo_add_64be(tfdt, samples_from_vlc_tick(p_stream->i_written_duration,
1064                                                 mp4mux_track_GetTimescale(p_stream->tinfo)) );
1065         box_gather(traf, tfdt);
1066
1067         /* *** add /moof/traf/trun *** */
1068         if (p_stream->read.p_first)
1069         {
1070             uint32_t i_trun_flags = 0x0;
1071
1072             if (p_stream->b_hasiframes && !(p_stream->read.p_first->p_block->i_flags & BLOCK_FLAG_TYPE_I))
1073                 i_trun_flags |= MP4_TRUN_FIRST_FLAGS;
1074
1075             if (!b_allsamelength ||
1076                 ( !(i_tfhd_flags & MP4_TFHD_DFLT_SAMPLE_DURATION) &&
1077                     mp4mux_track_GetDefaultSampleDuration(p_stream->tinfo) == 0 ))
1078                 i_trun_flags |= MP4_TRUN_SAMPLE_DURATION;
1079
1080             if (!b_allsamesize ||
1081                 ( !(i_tfhd_flags & MP4_TFHD_DFLT_SAMPLE_SIZE) &&
1082                   mp4mux_track_GetDefaultSampleSize(p_stream->tinfo) == 0 ))
1083                 i_trun_flags |= MP4_TRUN_SAMPLE_SIZE;
1084
1085             if (mp4mux_track_HasBFrames(p_stream->tinfo))
1086                 i_trun_flags |= MP4_TRUN_SAMPLE_TIME_OFFSET;
1087
1088             if (i_fixupoffset == 0)
1089                 i_trun_flags |= MP4_TRUN_DATA_OFFSET;
1090
1091             bo_t *trun = box_full_new("trun", 0, i_trun_flags);
1092             if(!trun)
1093             {
1094                 bo_free(traf);
1095                 continue;
1096             }
1097
1098             /* count entries */
1099             uint32_t i_entry_count = 0;
1100             vlc_tick_t i_run_time = p_stream->i_written_duration;
1101             mp4_fragentry_t *p_entry = p_stream->read.p_first;
1102             while(p_entry)
1103             {
1104                 if ( i_barrier_time && i_run_time + p_entry->p_block->i_length > i_barrier_time )
1105                     break;
1106                 i_entry_count++;
1107                 i_run_time += p_entry->p_block->i_length;
1108                 p_entry = p_entry->p_next;
1109             }
1110             bo_add_32be(trun, i_entry_count); // sample count
1111
1112             if (i_trun_flags & MP4_TRUN_DATA_OFFSET)
1113             {
1114                 i_fixupoffset = bo_size(moof) + bo_size(traf) + bo_size(trun);
1115                 bo_add_32be(trun, 0xdeadbeef); // data offset
1116             }
1117
1118             if (i_trun_flags & MP4_TRUN_FIRST_FLAGS)
1119                 bo_add_32be(trun, 1<<16); // flag as non keyframe
1120
1121             while(p_stream->read.p_first && i_entry_count)
1122             {
1123                 DEQUEUE_ENTRY(p_stream->read, p_entry);
1124
1125                 if (i_trun_flags & MP4_TRUN_SAMPLE_DURATION)
1126                     bo_add_32be(trun, samples_from_vlc_tick(p_entry->p_block->i_length,
1127                                                             mp4mux_track_GetTimescale(p_stream->tinfo))); // sample duration
1128
1129                 if (i_trun_flags & MP4_TRUN_SAMPLE_SIZE)
1130                     bo_add_32be(trun, p_entry->p_block->i_buffer); // sample size
1131
1132                 if (i_trun_flags & MP4_TRUN_SAMPLE_TIME_OFFSET)
1133                 {
1134                     vlc_tick_t i_diff = 0;
1135                     if ( p_entry->p_block->i_dts  != VLC_TICK_INVALID &&
1136                          p_entry->p_block->i_pts > p_entry->p_block->i_dts )
1137                     {
1138                         i_diff = p_entry->p_block->i_pts - p_entry->p_block->i_dts;
1139                     }
1140                     bo_add_32be(trun, samples_from_vlc_tick(i_diff, mp4mux_track_GetTimescale(p_stream->tinfo))); // ctts
1141                 }
1142
1143                 *pi_mdat_total_size += p_entry->p_block->i_buffer;
1144
1145                 ENQUEUE_ENTRY(p_stream->towrite, p_entry);
1146                 i_entry_count--;
1147                 i_sample++;
1148
1149                 /* Add keyframe entry if needed */
1150                 if (p_stream->b_hasiframes && (p_entry->p_block->i_flags & BLOCK_FLAG_TYPE_I) &&
1151                     (mp4mux_track_GetFmt(p_stream->tinfo)->i_cat == VIDEO_ES ||
1152                      mp4mux_track_GetFmt(p_stream->tinfo)->i_cat == AUDIO_ES))
1153                 {
1154                     AddKeyframeEntry(p_stream, i_write_pos, i_trak, i_sample, i_time);
1155                 }
1156
1157                 i_time += p_entry->p_block->i_length;
1158             }
1159
1160             box_gather(traf, trun);
1161         }
1162
1163         box_gather(moof, traf);
1164     }
1165
1166     if(!moof->b)
1167     {
1168         bo_free(moof);
1169         return NULL;
1170     }
1171
1172     box_fix(moof, bo_size(moof));
1173
1174     /* do tfhd base data offset fixup */
1175     if (i_fixupoffset)
1176     {
1177         /* mdat will follow moof */
1178         bo_set_32be(moof, i_fixupoffset, bo_size(moof) + 8);
1179     }
1180
1181     /* set iframe flag, so the streaming server always starts from moof */
1182     moof->b->i_flags |= BLOCK_FLAG_TYPE_I;
1183
1184     return moof;
1185 }
1186
1187 static void WriteFragmentMDAT(sout_mux_t *p_mux, size_t i_total_size)
1188 {
1189     sout_mux_sys_t *p_sys = p_mux->p_sys;
1190
1191     /* Now add mdat header */
1192     bo_t *mdat = box_new("mdat");
1193     if(!mdat)
1194         return;
1195     /* force update of real size */
1196     assert(bo_size(mdat)==8);
1197     box_fix(mdat, bo_size(mdat) + i_total_size);
1198     p_sys->i_pos += bo_size(mdat);
1199     /* only write header */
1200     sout_AccessOutWrite(p_mux->p_access, mdat->b);
1201     free(mdat);
1202     /* Header and its size are written and good, now write content */
1203     for (unsigned int i_trak = 0; i_trak < p_sys->i_nb_streams; i_trak++)
1204     {
1205         mp4_stream_t *p_stream = p_sys->pp_streams[i_trak];
1206
1207         while(p_stream->towrite.p_first)
1208         {
1209             mp4_fragentry_t *p_entry = p_stream->towrite.p_first;
1210             p_sys->i_pos += p_entry->p_block->i_buffer;
1211             p_stream->i_written_duration += p_entry->p_block->i_length;
1212
1213             p_entry->p_block->i_flags &= ~BLOCK_FLAG_TYPE_I; // clear flag for http stream
1214             sout_AccessOutWrite(p_mux->p_access, p_entry->p_block);
1215
1216             p_stream->towrite.p_first = p_entry->p_next;
1217             free(p_entry);
1218             if (!p_stream->towrite.p_first)
1219                 p_stream->towrite.p_last = NULL;
1220         }
1221     }
1222 }
1223
1224 static bo_t *GetMfraBox(sout_mux_t *p_mux)
1225 {
1226     sout_mux_sys_t *p_sys = (sout_mux_sys_t*) p_mux->p_sys;
1227     bo_t *mfra = NULL;
1228     for (unsigned int i = 0; i < p_sys->i_nb_streams; i++)
1229     {
1230         mp4_stream_t *p_stream = p_sys->pp_streams[i];
1231         if (p_stream->i_indexentries)
1232         {
1233             bo_t *tfra = box_full_new("tfra", 0, 0x0);
1234             if (!tfra) continue;
1235             bo_add_32be(tfra, mp4mux_track_GetID(p_stream->tinfo));
1236             bo_add_32be(tfra, 0x3); // reserved + lengths (1,1,4)=>(0,0,3)
1237             bo_add_32be(tfra, p_stream->i_indexentries);
1238             for(uint32_t i_index=0; i_index<p_stream->i_indexentries; i_index++)
1239             {
1240                 const mp4_fragindex_t *p_indexentry = &p_stream->p_indexentries[i_index];
1241                 bo_add_32be(tfra, p_indexentry->i_time);
1242                 bo_add_32be(tfra, p_indexentry->i_moofoffset);
1243                 assert(sizeof(p_indexentry->i_traf)==1); /* guard against sys changes */
1244                 assert(sizeof(p_indexentry->i_trun)==1);
1245                 assert(sizeof(p_indexentry->i_sample)==4);
1246                 bo_add_8(tfra, p_indexentry->i_traf);
1247                 bo_add_8(tfra, p_indexentry->i_trun);
1248                 bo_add_32be(tfra, p_indexentry->i_sample);
1249             }
1250
1251             if (!mfra && !(mfra = box_new("mfra")))
1252             {
1253                 bo_free(tfra);
1254                 return NULL;
1255             }
1256
1257             box_gather(mfra,tfra);
1258         }
1259     }
1260     return mfra;
1261 }
1262
1263 static void FlushHeader(sout_mux_t *p_mux)
1264 {
1265     sout_mux_sys_t *p_sys = (sout_mux_sys_t*) p_mux->p_sys;
1266
1267     if(p_sys->i_pos >= (((uint64_t)0x1) << 32))
1268         mp4mux_Set64BitExt(p_sys->muxh);
1269
1270     /* Now add ftyp header */
1271     bo_t *ftyp = mp4mux_GetFtyp(p_sys->muxh);
1272     if(!ftyp)
1273         return;
1274
1275     bo_t *moov = mp4mux_GetMoov(p_sys->muxh, VLC_OBJECT(p_mux), 0);
1276
1277     /* merge into a single block */
1278     box_gather(ftyp, moov);
1279
1280     /* add header flag for streaming server */
1281     ftyp->b->i_flags |= BLOCK_FLAG_HEADER;
1282     p_sys->i_pos += bo_size(ftyp);
1283     box_send(p_mux, ftyp);
1284     p_sys->b_header_sent = true;
1285 }
1286
1287 static void WriteFragments(sout_mux_t *p_mux, bool b_flush)
1288 {
1289     sout_mux_sys_t *p_sys = (sout_mux_sys_t*) p_mux->p_sys;
1290     bo_t *moof = NULL;
1291     vlc_tick_t i_barrier_time = p_sys->i_written_duration + FRAGMENT_LENGTH;
1292     size_t i_mdat_size = 0;
1293     bool b_has_samples = false;
1294
1295     if(!p_sys->b_header_sent)
1296     {
1297         for (unsigned int j = 0; j < p_sys->i_nb_streams; j++)
1298         {
1299             mp4_stream_t *p_stream = p_sys->pp_streams[j];
1300             if(CreateCurrentEdit(p_stream, p_sys->i_start_dts, true))
1301                 mp4mux_track_DebugEdits(VLC_OBJECT(p_mux), p_stream->tinfo);
1302         }
1303     }
1304
1305     for (unsigned int i = 0; i < p_sys->i_nb_streams; i++)
1306     {
1307         const mp4_stream_t *p_stream = p_sys->pp_streams[i];
1308         if (p_stream->read.p_first)
1309         {
1310             b_has_samples = true;
1311
1312             /* set a barrier so we try to align to keyframe */
1313             if (p_stream->b_hasiframes &&
1314                     p_stream->i_last_iframe_time > p_stream->i_written_duration &&
1315                     (mp4mux_track_GetFmt(p_stream->tinfo)->i_cat == VIDEO_ES ||
1316                      mp4mux_track_GetFmt(p_stream->tinfo)->i_cat == AUDIO_ES) )
1317             {
1318                 i_barrier_time = __MIN(i_barrier_time, p_stream->i_last_iframe_time);
1319             }
1320         }
1321     }
1322
1323     if (!p_sys->b_header_sent)
1324         FlushHeader(p_mux);
1325
1326     if (b_has_samples)
1327         moof = GetMoofBox(p_mux, &i_mdat_size, (b_flush)?0:i_barrier_time, p_sys->i_pos);
1328
1329     if (moof && i_mdat_size == 0)
1330     {
1331         block_Release(moof->b);
1332         FREENULL(moof);
1333     }
1334
1335     if (moof)
1336     {
1337         msg_Dbg(p_mux, "writing moof @ %"PRId64, p_sys->i_pos);
1338         p_sys->i_pos += bo_size(moof);
1339         assert(moof->b->i_flags & BLOCK_FLAG_TYPE_I); /* http sout */
1340         box_send(p_mux, moof);
1341         msg_Dbg(p_mux, "writing mdat @ %"PRId64, p_sys->i_pos);
1342         WriteFragmentMDAT(p_mux, i_mdat_size);
1343
1344         /* update iframe point */
1345         for (unsigned int i = 0; i < p_sys->i_nb_streams; i++)
1346         {
1347             mp4_stream_t *p_stream = p_sys->pp_streams[i];
1348             p_stream->i_last_iframe_time = 0;
1349         }
1350     }
1351 }
1352
1353 /* Do an entry length fixup using only its own info.
1354  * This is the end boundary case. */
1355 static void LengthLocalFixup(sout_mux_t *p_mux, const mp4_stream_t *p_stream, block_t *p_entrydata)
1356 {
1357     if ( mp4mux_track_GetFmt(p_stream->tinfo)->i_cat == VIDEO_ES &&
1358          mp4mux_track_GetFmt(p_stream->tinfo)->video.i_frame_rate )
1359     {
1360         p_entrydata->i_length = vlc_tick_from_samples(
1361                 mp4mux_track_GetFmt(p_stream->tinfo)->video.i_frame_rate_base,
1362                 mp4mux_track_GetFmt(p_stream->tinfo)->video.i_frame_rate);
1363         msg_Dbg(p_mux, "video track %d fixup to %"PRId64" for sample %u",
1364                 mp4mux_track_GetID(p_stream->tinfo), p_entrydata->i_length,
1365                 mp4mux_track_GetSampleCount(p_stream->tinfo) - 1);
1366     }
1367     else if (mp4mux_track_GetFmt(p_stream->tinfo)->i_cat == AUDIO_ES &&
1368              mp4mux_track_GetFmt(p_stream->tinfo)->audio.i_rate &&
1369              p_entrydata->i_nb_samples && mp4mux_track_GetFmt(p_stream->tinfo)->audio.i_rate)
1370     {
1371         p_entrydata->i_length = vlc_tick_from_samples(p_entrydata->i_nb_samples,
1372                 mp4mux_track_GetFmt(p_stream->tinfo)->audio.i_rate);
1373         msg_Dbg(p_mux, "audio track %d fixup to %"PRId64" for sample %u",
1374                 mp4mux_track_GetID(p_stream->tinfo), p_entrydata->i_length,
1375                 mp4mux_track_GetSampleCount(p_stream->tinfo) - 1);
1376     }
1377     else
1378     {
1379         msg_Warn(p_mux, "unknown length for track %d sample %u",
1380                  mp4mux_track_GetID(p_stream->tinfo),
1381                  mp4mux_track_GetSampleCount(p_stream->tinfo) - 1);
1382         p_entrydata->i_length = 1;
1383     }
1384 }
1385
1386 static void CloseFrag(vlc_object_t *p_this)
1387 {
1388     sout_mux_t *p_mux = (sout_mux_t *) p_this;
1389     sout_mux_sys_t *p_sys = (sout_mux_sys_t*) p_mux->p_sys;
1390
1391     /* Flush remaining entries */
1392     for (unsigned int i = 0; i < p_sys->i_nb_streams; i++)
1393     {
1394         mp4_stream_t *p_stream = p_sys->pp_streams[i];
1395         if (p_stream->p_held_entry)
1396         {
1397             if (p_stream->p_held_entry->p_block->i_length < 1)
1398                 LengthLocalFixup(p_mux, p_stream, p_stream->p_held_entry->p_block);
1399             ENQUEUE_ENTRY(p_stream->read, p_stream->p_held_entry);
1400             p_stream->p_held_entry = NULL;
1401         }
1402     }
1403
1404     /* and force creating a fragment from it */
1405     WriteFragments(p_mux, true);
1406
1407     /* Write indexes, but only for non streamed content
1408        as they refer to moof by absolute position */
1409     if (!strcmp(p_mux->psz_mux, "mp4frag"))
1410     {
1411         bo_t *mfra = GetMfraBox(p_mux);
1412         if (mfra)
1413         {
1414             bo_t *mfro = box_full_new("mfro", 0, 0x0);
1415             if (mfro)
1416             {
1417                 if (mfra->b)
1418                 {
1419                     box_fix(mfra, bo_size(mfra));
1420                     bo_add_32be(mfro, bo_size(mfra) + MP4_MFRO_BOXSIZE);
1421                 }
1422                 box_gather(mfra, mfro);
1423             }
1424             box_send(p_mux, mfra);
1425         }
1426     }
1427
1428     for (unsigned int i = 0; i < p_sys->i_nb_streams; i++)
1429         mp4_stream_Delete(p_sys->pp_streams[i]);
1430     TAB_CLEAN(p_sys->i_nb_streams, p_sys->pp_streams);
1431     mp4mux_Delete(p_sys->muxh);
1432     free(p_sys);
1433 }
1434
1435 static int MuxFrag(sout_mux_t *p_mux)
1436 {
1437     sout_mux_sys_t *p_sys = (sout_mux_sys_t*) p_mux->p_sys;
1438
1439     int i_stream = sout_MuxGetStream(p_mux, 1, NULL);
1440     if (i_stream < 0)
1441         return VLC_SUCCESS;
1442
1443     sout_input_t *p_input  = p_mux->pp_inputs[i_stream];
1444     mp4_stream_t *p_stream = (mp4_stream_t*) p_input->p_sys;
1445     block_t *p_currentblock = BlockDequeue(p_input, p_stream);
1446     if( !p_currentblock )
1447         return VLC_SUCCESS;
1448
1449     /* Set time ranges */
1450     if( p_stream->i_first_dts == VLC_TICK_INVALID )
1451     {
1452         p_stream->i_first_dts = p_currentblock->i_dts;
1453         if( p_sys->i_start_dts == VLC_TICK_INVALID )
1454             p_sys->i_start_dts = p_currentblock->i_dts;
1455     }
1456
1457     /* If we have a previous entry for outgoing queue */
1458     if (p_stream->p_held_entry)
1459     {
1460         block_t *p_heldblock = p_stream->p_held_entry->p_block;
1461
1462         /* Fix previous block length from current */
1463         if (p_heldblock->i_length < 1)
1464         {
1465
1466             /* Fix using dts if not on a boundary */
1467             if ((p_currentblock->i_flags & BLOCK_FLAG_DISCONTINUITY) == 0)
1468                 p_heldblock->i_length = p_currentblock->i_dts - p_heldblock->i_dts;
1469
1470             if (p_heldblock->i_length < 1)
1471                 LengthLocalFixup(p_mux, p_stream, p_heldblock);
1472         }
1473
1474         /* enqueue */
1475         ENQUEUE_ENTRY(p_stream->read, p_stream->p_held_entry);
1476         p_stream->p_held_entry = NULL;
1477
1478         if (p_stream->b_hasiframes && (p_heldblock->i_flags & BLOCK_FLAG_TYPE_I) &&
1479             mp4mux_track_GetDuration(p_stream->tinfo) - p_sys->i_written_duration < FRAGMENT_LENGTH)
1480         {
1481             /* Flag the last iframe time, we'll use it as boundary so it will start
1482                next fragment */
1483             p_stream->i_last_iframe_time = mp4mux_track_GetDuration(p_stream->tinfo);
1484         }
1485
1486         /* update buffered time */
1487         mp4mux_track_ForceDuration(p_stream->tinfo,
1488                                  mp4mux_track_GetDuration(p_stream->tinfo) +
1489                                  __MAX(0, p_heldblock->i_length));
1490     }
1491
1492
1493     /* set temp entry */
1494     p_stream->p_held_entry = malloc(sizeof(mp4_fragentry_t));
1495     if (unlikely(!p_stream->p_held_entry))
1496         return VLC_ENOMEM;
1497
1498     p_stream->p_held_entry->p_block  = p_currentblock;
1499     p_stream->p_held_entry->i_run    = p_stream->i_current_run;
1500     p_stream->p_held_entry->p_next   = NULL;
1501
1502     if (mp4mux_track_GetFmt(p_stream->tinfo)->i_cat == VIDEO_ES )
1503     {
1504         if (!p_stream->b_hasiframes && (p_currentblock->i_flags & BLOCK_FLAG_TYPE_I))
1505             p_stream->b_hasiframes = true;
1506
1507         if (!mp4mux_track_HasBFrames(p_stream->tinfo) &&
1508             p_currentblock->i_dts != VLC_TICK_INVALID &&
1509             p_currentblock->i_pts > p_currentblock->i_dts)
1510                 mp4mux_track_SetHasBFrames(p_stream->tinfo);
1511     }
1512
1513     /* Update the global fragment/media duration */
1514     vlc_tick_t i_min_read_duration = mp4mux_track_GetDuration(p_stream->tinfo);
1515     vlc_tick_t i_min_written_duration = p_stream->i_written_duration;
1516     for (unsigned int i=0; i<p_sys->i_nb_streams; i++)
1517     {
1518         const mp4_stream_t *p_s = p_sys->pp_streams[i];
1519         if (mp4mux_track_GetFmt(p_stream->tinfo)->i_cat != VIDEO_ES &&
1520             mp4mux_track_GetFmt(p_stream->tinfo)->i_cat != AUDIO_ES)
1521             continue;
1522         if (mp4mux_track_GetDuration(p_s->tinfo) < i_min_read_duration)
1523             i_min_read_duration = mp4mux_track_GetDuration(p_s->tinfo);
1524
1525         if (p_s->i_written_duration < i_min_written_duration)
1526             i_min_written_duration = p_s->i_written_duration;
1527     }
1528     p_sys->i_read_duration = i_min_read_duration;
1529     p_sys->i_written_duration = i_min_written_duration;
1530
1531     /* we have prerolled enough to know all streams, and have enough date to create a fragment */
1532     if (p_stream->read.p_first && p_sys->i_read_duration - p_sys->i_written_duration >= FRAGMENT_LENGTH)
1533         WriteFragments(p_mux, false);
1534
1535     return VLC_SUCCESS;
1536 }