avformat/dashenc: Added support for Low-latency HLS(Experimental)
[ffmpeg.git] / libavformat / dashenc.c
1 /*
2  * MPEG-DASH ISO BMFF segmenter
3  * Copyright (c) 2014 Martin Storsjo
4  * Copyright (c) 2018 Akamai Technologies, Inc.
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22
23 #include "config.h"
24 #if HAVE_UNISTD_H
25 #include <unistd.h>
26 #endif
27
28 #include "libavutil/avassert.h"
29 #include "libavutil/avutil.h"
30 #include "libavutil/avstring.h"
31 #include "libavutil/intreadwrite.h"
32 #include "libavutil/mathematics.h"
33 #include "libavutil/opt.h"
34 #include "libavutil/rational.h"
35 #include "libavutil/time_internal.h"
36
37 #include "avc.h"
38 #include "avformat.h"
39 #include "avio_internal.h"
40 #include "hlsplaylist.h"
41 #if CONFIG_HTTP_PROTOCOL
42 #include "http.h"
43 #endif
44 #include "internal.h"
45 #include "isom.h"
46 #include "os_support.h"
47 #include "url.h"
48 #include "vpcc.h"
49 #include "dash.h"
50
51 typedef enum {
52     SEGMENT_TYPE_AUTO = 0,
53     SEGMENT_TYPE_MP4,
54     SEGMENT_TYPE_WEBM,
55     SEGMENT_TYPE_NB
56 } SegmentType;
57
58 typedef struct Segment {
59     char file[1024];
60     int64_t start_pos;
61     int range_length, index_length;
62     int64_t time;
63     int64_t duration;
64     int n;
65 } Segment;
66
67 typedef struct AdaptationSet {
68     char id[10];
69     enum AVMediaType media_type;
70     AVDictionary *metadata;
71     AVRational min_frame_rate, max_frame_rate;
72     int ambiguous_frame_rate;
73 } AdaptationSet;
74
75 typedef struct OutputStream {
76     AVFormatContext *ctx;
77     int ctx_inited, as_idx;
78     AVIOContext *out;
79     int packets_written;
80     char initfile[1024];
81     int64_t init_start_pos, pos;
82     int init_range_length;
83     int nb_segments, segments_size, segment_index;
84     Segment **segments;
85     int64_t first_pts, start_pts, max_pts;
86     int64_t last_dts, last_pts;
87     int bit_rate;
88     SegmentType segment_type;  /* segment type selected for this particular stream */
89     const char *format_name;
90     const char *single_file_name;  /* file names selected for this particular stream */
91     const char *init_seg_name;
92     const char *media_seg_name;
93
94     char codec_str[100];
95     int written_len;
96     char filename[1024];
97     char full_path[1024];
98     char temp_path[1024];
99     double availability_time_offset;
100     int total_pkt_size;
101     int muxer_overhead;
102 } OutputStream;
103
104 typedef struct DASHContext {
105     const AVClass *class;  /* Class for private options. */
106     char *adaptation_sets;
107     AdaptationSet *as;
108     int nb_as;
109     int window_size;
110     int extra_window_size;
111 #if FF_API_DASH_MIN_SEG_DURATION
112     int min_seg_duration;
113 #endif
114     int64_t seg_duration;
115     int remove_at_exit;
116     int use_template;
117     int use_timeline;
118     int single_file;
119     OutputStream *streams;
120     int has_video;
121     int64_t last_duration;
122     int64_t total_duration;
123     char availability_start_time[100];
124     char dirname[1024];
125     const char *single_file_name;  /* file names as specified in options */
126     const char *init_seg_name;
127     const char *media_seg_name;
128     const char *utc_timing_url;
129     const char *method;
130     const char *user_agent;
131     int hls_playlist;
132     int http_persistent;
133     int master_playlist_created;
134     AVIOContext *mpd_out;
135     AVIOContext *m3u8_out;
136     int streaming;
137     int64_t timeout;
138     int index_correction;
139     char *format_options_str;
140     SegmentType segment_type_option;  /* segment type as specified in options */
141     int ignore_io_errors;
142     int lhls;
143 } DASHContext;
144
145 static struct codec_string {
146     int id;
147     const char *str;
148 } codecs[] = {
149     { AV_CODEC_ID_VP8, "vp8" },
150     { AV_CODEC_ID_VP9, "vp9" },
151     { AV_CODEC_ID_VORBIS, "vorbis" },
152     { AV_CODEC_ID_OPUS, "opus" },
153     { AV_CODEC_ID_FLAC, "flac" },
154     { 0, NULL }
155 };
156
157 static struct format_string {
158     SegmentType segment_type;
159     const char *str;
160 } formats[] = {
161     { SEGMENT_TYPE_AUTO, "auto" },
162     { SEGMENT_TYPE_MP4, "mp4" },
163     { SEGMENT_TYPE_WEBM, "webm" },
164     { 0, NULL }
165 };
166
167 static int dashenc_io_open(AVFormatContext *s, AVIOContext **pb, char *filename,
168                            AVDictionary **options) {
169     DASHContext *c = s->priv_data;
170     int http_base_proto = filename ? ff_is_http_proto(filename) : 0;
171     int err = AVERROR_MUXER_NOT_FOUND;
172     if (!*pb || !http_base_proto || !c->http_persistent) {
173         err = s->io_open(s, pb, filename, AVIO_FLAG_WRITE, options);
174 #if CONFIG_HTTP_PROTOCOL
175     } else {
176         URLContext *http_url_context = ffio_geturlcontext(*pb);
177         av_assert0(http_url_context);
178         err = ff_http_do_new_request(http_url_context, filename);
179         if (err < 0)
180             ff_format_io_close(s, pb);
181 #endif
182     }
183     return err;
184 }
185
186 static void dashenc_io_close(AVFormatContext *s, AVIOContext **pb, char *filename) {
187     DASHContext *c = s->priv_data;
188     int http_base_proto = filename ? ff_is_http_proto(filename) : 0;
189
190     if (!*pb)
191         return;
192
193     if (!http_base_proto || !c->http_persistent) {
194         ff_format_io_close(s, pb);
195 #if CONFIG_HTTP_PROTOCOL
196     } else {
197         URLContext *http_url_context = ffio_geturlcontext(*pb);
198         av_assert0(http_url_context);
199         avio_flush(*pb);
200         ffurl_shutdown(http_url_context, AVIO_FLAG_WRITE);
201 #endif
202     }
203 }
204
205 static const char *get_format_str(SegmentType segment_type) {
206     int i;
207     for (i = 0; i < SEGMENT_TYPE_NB; i++)
208         if (formats[i].segment_type == segment_type)
209             return formats[i].str;
210     return NULL;
211 }
212
213 static int handle_io_open_error(AVFormatContext *s, int err, char *url) {
214     DASHContext *c = s->priv_data;
215     char errbuf[AV_ERROR_MAX_STRING_SIZE];
216     av_strerror(err, errbuf, sizeof(errbuf));
217     av_log(s, c->ignore_io_errors ? AV_LOG_WARNING : AV_LOG_ERROR,
218            "Unable to open %s for writing: %s\n", url, errbuf);
219     return c->ignore_io_errors ? 0 : err;
220 }
221
222 static inline SegmentType select_segment_type(SegmentType segment_type, enum AVCodecID codec_id)
223 {
224     if (segment_type == SEGMENT_TYPE_AUTO) {
225         if (codec_id == AV_CODEC_ID_OPUS || codec_id == AV_CODEC_ID_VORBIS ||
226             codec_id == AV_CODEC_ID_VP8 || codec_id == AV_CODEC_ID_VP9) {
227             segment_type = SEGMENT_TYPE_WEBM;
228         } else {
229             segment_type = SEGMENT_TYPE_MP4;
230         }
231     }
232
233     return segment_type;
234 }
235
236 static int init_segment_types(AVFormatContext *s)
237 {
238     DASHContext *c = s->priv_data;
239     int has_mp4_streams = 0;
240     for (int i = 0; i < s->nb_streams; ++i) {
241         OutputStream *os = &c->streams[i];
242         SegmentType segment_type = select_segment_type(
243             c->segment_type_option, s->streams[i]->codecpar->codec_id);
244         os->segment_type = segment_type;
245         os->format_name = get_format_str(segment_type);
246         if (!os->format_name) {
247             av_log(s, AV_LOG_ERROR, "Could not select DASH segment type for stream %d\n", i);
248             return AVERROR_MUXER_NOT_FOUND;
249         }
250         has_mp4_streams |= segment_type == SEGMENT_TYPE_MP4;
251     }
252
253     if (c->hls_playlist && !has_mp4_streams) {
254          av_log(s, AV_LOG_WARNING, "No mp4 streams, disabling HLS manifest generation\n");
255          c->hls_playlist = 0;
256     }
257
258     return 0;
259 }
260
261 static int check_file_extension(const char *filename, const char *extension) {
262     char *dot;
263     if (!filename || !extension)
264         return -1;
265     dot = strrchr(filename, '.');
266     if (dot && !strcmp(dot + 1, extension))
267         return 0;
268     return -1;
269 }
270
271 static void set_vp9_codec_str(AVFormatContext *s, AVCodecParameters *par,
272                               AVRational *frame_rate, char *str, int size) {
273     VPCC vpcc;
274     int ret = ff_isom_get_vpcc_features(s, par, frame_rate, &vpcc);
275     if (ret == 0) {
276         av_strlcatf(str, size, "vp09.%02d.%02d.%02d",
277                     vpcc.profile, vpcc.level, vpcc.bitdepth);
278     } else {
279         // Default to just vp9 in case of error while finding out profile or level
280         av_log(s, AV_LOG_WARNING, "Could not find VP9 profile and/or level\n");
281         av_strlcpy(str, "vp9", size);
282     }
283     return;
284 }
285
286 static void set_codec_str(AVFormatContext *s, AVCodecParameters *par,
287                           AVRational *frame_rate, char *str, int size)
288 {
289     const AVCodecTag *tags[2] = { NULL, NULL };
290     uint32_t tag;
291     int i;
292
293     // common Webm codecs are not part of RFC 6381
294     for (i = 0; codecs[i].id; i++)
295         if (codecs[i].id == par->codec_id) {
296             if (codecs[i].id == AV_CODEC_ID_VP9) {
297                 set_vp9_codec_str(s, par, frame_rate, str, size);
298             } else {
299                 av_strlcpy(str, codecs[i].str, size);
300             }
301             return;
302         }
303
304     // for codecs part of RFC 6381
305     if (par->codec_type == AVMEDIA_TYPE_VIDEO)
306         tags[0] = ff_codec_movvideo_tags;
307     else if (par->codec_type == AVMEDIA_TYPE_AUDIO)
308         tags[0] = ff_codec_movaudio_tags;
309     else
310         return;
311
312     tag = par->codec_tag;
313     if (!tag)
314         tag = av_codec_get_tag(tags, par->codec_id);
315     if (!tag)
316         return;
317     if (size < 5)
318         return;
319
320     AV_WL32(str, tag);
321     str[4] = '\0';
322     if (!strcmp(str, "mp4a") || !strcmp(str, "mp4v")) {
323         uint32_t oti;
324         tags[0] = ff_mp4_obj_type;
325         oti = av_codec_get_tag(tags, par->codec_id);
326         if (oti)
327             av_strlcatf(str, size, ".%02"PRIx32, oti);
328         else
329             return;
330
331         if (tag == MKTAG('m', 'p', '4', 'a')) {
332             if (par->extradata_size >= 2) {
333                 int aot = par->extradata[0] >> 3;
334                 if (aot == 31)
335                     aot = ((AV_RB16(par->extradata) >> 5) & 0x3f) + 32;
336                 av_strlcatf(str, size, ".%d", aot);
337             }
338         } else if (tag == MKTAG('m', 'p', '4', 'v')) {
339             // Unimplemented, should output ProfileLevelIndication as a decimal number
340             av_log(s, AV_LOG_WARNING, "Incomplete RFC 6381 codec string for mp4v\n");
341         }
342     } else if (!strcmp(str, "avc1")) {
343         uint8_t *tmpbuf = NULL;
344         uint8_t *extradata = par->extradata;
345         int extradata_size = par->extradata_size;
346         if (!extradata_size)
347             return;
348         if (extradata[0] != 1) {
349             AVIOContext *pb;
350             if (avio_open_dyn_buf(&pb) < 0)
351                 return;
352             if (ff_isom_write_avcc(pb, extradata, extradata_size) < 0) {
353                 ffio_free_dyn_buf(&pb);
354                 return;
355             }
356             extradata_size = avio_close_dyn_buf(pb, &extradata);
357             tmpbuf = extradata;
358         }
359
360         if (extradata_size >= 4)
361             av_strlcatf(str, size, ".%02x%02x%02x",
362                         extradata[1], extradata[2], extradata[3]);
363         av_free(tmpbuf);
364     }
365 }
366
367 static int flush_dynbuf(OutputStream *os, int *range_length)
368 {
369     uint8_t *buffer;
370
371     if (!os->ctx->pb) {
372         return AVERROR(EINVAL);
373     }
374
375     // flush
376     av_write_frame(os->ctx, NULL);
377     avio_flush(os->ctx->pb);
378
379     // write out to file
380     *range_length = avio_close_dyn_buf(os->ctx->pb, &buffer);
381     os->ctx->pb = NULL;
382     if (os->out)
383         avio_write(os->out, buffer + os->written_len, *range_length - os->written_len);
384     os->written_len = 0;
385     av_free(buffer);
386
387     // re-open buffer
388     return avio_open_dyn_buf(&os->ctx->pb);
389 }
390
391 static void set_http_options(AVDictionary **options, DASHContext *c)
392 {
393     if (c->method)
394         av_dict_set(options, "method", c->method, 0);
395     if (c->user_agent)
396         av_dict_set(options, "user_agent", c->user_agent, 0);
397     if (c->http_persistent)
398         av_dict_set_int(options, "multiple_requests", 1, 0);
399     if (c->timeout >= 0)
400         av_dict_set_int(options, "timeout", c->timeout, 0);
401 }
402
403 static void get_hls_playlist_name(char *playlist_name, int string_size,
404                                   const char *base_url, int id) {
405     if (base_url)
406         snprintf(playlist_name, string_size, "%smedia_%d.m3u8", base_url, id);
407     else
408         snprintf(playlist_name, string_size, "media_%d.m3u8", id);
409 }
410
411 static void get_start_index_number(OutputStream *os, DASHContext *c,
412                                    int *start_index, int *start_number) {
413     *start_index = 0;
414     *start_number = 1;
415     if (c->window_size) {
416         *start_index  = FFMAX(os->nb_segments   - c->window_size, 0);
417         *start_number = FFMAX(os->segment_index - c->window_size, 1);
418     }
419 }
420
421 static void write_hls_media_playlist(OutputStream *os, AVFormatContext *s,
422                                      int representation_id, int final,
423                                      char *prefetch_url) {
424     DASHContext *c = s->priv_data;
425     int timescale = os->ctx->streams[0]->time_base.den;
426     char temp_filename_hls[1024];
427     char filename_hls[1024];
428     AVDictionary *http_opts = NULL;
429     int target_duration = 0;
430     int ret = 0;
431     const char *proto = avio_find_protocol_name(c->dirname);
432     int use_rename = proto && !strcmp(proto, "file");
433     int i, start_index, start_number;
434
435     get_start_index_number(os, c, &start_index, &start_number);
436
437     if (!c->hls_playlist || start_index >= os->nb_segments ||
438         os->segment_type != SEGMENT_TYPE_MP4)
439         return;
440
441     get_hls_playlist_name(filename_hls, sizeof(filename_hls),
442                           c->dirname, representation_id);
443
444     snprintf(temp_filename_hls, sizeof(temp_filename_hls), use_rename ? "%s.tmp" : "%s", filename_hls);
445
446     set_http_options(&http_opts, c);
447     ret = dashenc_io_open(s, &c->m3u8_out, temp_filename_hls, &http_opts);
448     av_dict_free(&http_opts);
449     if (ret < 0) {
450         handle_io_open_error(s, ret, temp_filename_hls);
451         return;
452     }
453     for (i = start_index; i < os->nb_segments; i++) {
454         Segment *seg = os->segments[i];
455         double duration = (double) seg->duration / timescale;
456         if (target_duration <= duration)
457             target_duration = lrint(duration);
458     }
459
460     ff_hls_write_playlist_header(c->m3u8_out, 6, -1, target_duration,
461                                  start_number, PLAYLIST_TYPE_NONE);
462
463     ff_hls_write_init_file(c->m3u8_out, os->initfile, c->single_file,
464                            os->init_range_length, os->init_start_pos);
465
466     for (i = start_index; i < os->nb_segments; i++) {
467         Segment *seg = os->segments[i];
468         ret = ff_hls_write_file_entry(c->m3u8_out, 0, c->single_file,
469                                 (double) seg->duration / timescale, 0,
470                                 seg->range_length, seg->start_pos, NULL,
471                                 c->single_file ? os->initfile : seg->file,
472                                 NULL);
473         if (ret < 0) {
474             av_log(os->ctx, AV_LOG_WARNING, "ff_hls_write_file_entry get error\n");
475         }
476     }
477
478     if (prefetch_url)
479         avio_printf(c->m3u8_out, "#EXT-X-PREFETCH:%s\n", prefetch_url);
480
481     if (final)
482         ff_hls_write_end_list(c->m3u8_out);
483
484     dashenc_io_close(s, &c->m3u8_out, temp_filename_hls);
485
486     if (use_rename)
487         if (avpriv_io_move(temp_filename_hls, filename_hls) < 0) {
488             av_log(os->ctx, AV_LOG_WARNING, "renaming file %s to %s failed\n\n", temp_filename_hls, filename_hls);
489         }
490 }
491
492 static int flush_init_segment(AVFormatContext *s, OutputStream *os)
493 {
494     DASHContext *c = s->priv_data;
495     int ret, range_length;
496
497     ret = flush_dynbuf(os, &range_length);
498     if (ret < 0)
499         return ret;
500
501     os->pos = os->init_range_length = range_length;
502     if (!c->single_file) {
503         char filename[1024];
504         snprintf(filename, sizeof(filename), "%s%s", c->dirname, os->initfile);
505         dashenc_io_close(s, &os->out, filename);
506     }
507     return 0;
508 }
509
510 static void dash_free(AVFormatContext *s)
511 {
512     DASHContext *c = s->priv_data;
513     int i, j;
514
515     if (c->as) {
516         for (i = 0; i < c->nb_as; i++)
517             av_dict_free(&c->as[i].metadata);
518         av_freep(&c->as);
519         c->nb_as = 0;
520     }
521
522     if (!c->streams)
523         return;
524     for (i = 0; i < s->nb_streams; i++) {
525         OutputStream *os = &c->streams[i];
526         if (os->ctx && os->ctx->pb)
527             ffio_free_dyn_buf(&os->ctx->pb);
528         ff_format_io_close(s, &os->out);
529         if (os->ctx)
530             avformat_free_context(os->ctx);
531         for (j = 0; j < os->nb_segments; j++)
532             av_free(os->segments[j]);
533         av_free(os->segments);
534         av_freep(&os->single_file_name);
535         av_freep(&os->init_seg_name);
536         av_freep(&os->media_seg_name);
537     }
538     av_freep(&c->streams);
539
540     ff_format_io_close(s, &c->mpd_out);
541     ff_format_io_close(s, &c->m3u8_out);
542 }
543
544 static void output_segment_list(OutputStream *os, AVIOContext *out, AVFormatContext *s,
545                                 int representation_id, int final)
546 {
547     DASHContext *c = s->priv_data;
548     int i, start_index, start_number;
549     get_start_index_number(os, c, &start_index, &start_number);
550
551     if (c->use_template) {
552         int timescale = c->use_timeline ? os->ctx->streams[0]->time_base.den : AV_TIME_BASE;
553         avio_printf(out, "\t\t\t\t<SegmentTemplate timescale=\"%d\" ", timescale);
554         if (!c->use_timeline) {
555             avio_printf(out, "duration=\"%"PRId64"\" ", c->seg_duration);
556             if (c->streaming && os->availability_time_offset)
557                 avio_printf(out, "availabilityTimeOffset=\"%.3f\" ",
558                             os->availability_time_offset);
559         }
560         avio_printf(out, "initialization=\"%s\" media=\"%s\" startNumber=\"%d\">\n", os->init_seg_name, os->media_seg_name, c->use_timeline ? start_number : 1);
561         if (c->use_timeline) {
562             int64_t cur_time = 0;
563             avio_printf(out, "\t\t\t\t\t<SegmentTimeline>\n");
564             for (i = start_index; i < os->nb_segments; ) {
565                 Segment *seg = os->segments[i];
566                 int repeat = 0;
567                 avio_printf(out, "\t\t\t\t\t\t<S ");
568                 if (i == start_index || seg->time != cur_time) {
569                     cur_time = seg->time;
570                     avio_printf(out, "t=\"%"PRId64"\" ", seg->time);
571                 }
572                 avio_printf(out, "d=\"%"PRId64"\" ", seg->duration);
573                 while (i + repeat + 1 < os->nb_segments &&
574                        os->segments[i + repeat + 1]->duration == seg->duration &&
575                        os->segments[i + repeat + 1]->time == os->segments[i + repeat]->time + os->segments[i + repeat]->duration)
576                     repeat++;
577                 if (repeat > 0)
578                     avio_printf(out, "r=\"%d\" ", repeat);
579                 avio_printf(out, "/>\n");
580                 i += 1 + repeat;
581                 cur_time += (1 + repeat) * seg->duration;
582             }
583             avio_printf(out, "\t\t\t\t\t</SegmentTimeline>\n");
584         }
585         avio_printf(out, "\t\t\t\t</SegmentTemplate>\n");
586     } else if (c->single_file) {
587         avio_printf(out, "\t\t\t\t<BaseURL>%s</BaseURL>\n", os->initfile);
588         avio_printf(out, "\t\t\t\t<SegmentList timescale=\"%d\" duration=\"%"PRId64"\" startNumber=\"%d\">\n", AV_TIME_BASE, c->last_duration, start_number);
589         avio_printf(out, "\t\t\t\t\t<Initialization range=\"%"PRId64"-%"PRId64"\" />\n", os->init_start_pos, os->init_start_pos + os->init_range_length - 1);
590         for (i = start_index; i < os->nb_segments; i++) {
591             Segment *seg = os->segments[i];
592             avio_printf(out, "\t\t\t\t\t<SegmentURL mediaRange=\"%"PRId64"-%"PRId64"\" ", seg->start_pos, seg->start_pos + seg->range_length - 1);
593             if (seg->index_length)
594                 avio_printf(out, "indexRange=\"%"PRId64"-%"PRId64"\" ", seg->start_pos, seg->start_pos + seg->index_length - 1);
595             avio_printf(out, "/>\n");
596         }
597         avio_printf(out, "\t\t\t\t</SegmentList>\n");
598     } else {
599         avio_printf(out, "\t\t\t\t<SegmentList timescale=\"%d\" duration=\"%"PRId64"\" startNumber=\"%d\">\n", AV_TIME_BASE, c->last_duration, start_number);
600         avio_printf(out, "\t\t\t\t\t<Initialization sourceURL=\"%s\" />\n", os->initfile);
601         for (i = start_index; i < os->nb_segments; i++) {
602             Segment *seg = os->segments[i];
603             avio_printf(out, "\t\t\t\t\t<SegmentURL media=\"%s\" />\n", seg->file);
604         }
605         avio_printf(out, "\t\t\t\t</SegmentList>\n");
606     }
607     if (!c->lhls || final) {
608         write_hls_media_playlist(os, s, representation_id, final, NULL);
609     }
610
611 }
612
613 static char *xmlescape(const char *str) {
614     int outlen = strlen(str)*3/2 + 6;
615     char *out = av_realloc(NULL, outlen + 1);
616     int pos = 0;
617     if (!out)
618         return NULL;
619     for (; *str; str++) {
620         if (pos + 6 > outlen) {
621             char *tmp;
622             outlen = 2 * outlen + 6;
623             tmp = av_realloc(out, outlen + 1);
624             if (!tmp) {
625                 av_free(out);
626                 return NULL;
627             }
628             out = tmp;
629         }
630         if (*str == '&') {
631             memcpy(&out[pos], "&amp;", 5);
632             pos += 5;
633         } else if (*str == '<') {
634             memcpy(&out[pos], "&lt;", 4);
635             pos += 4;
636         } else if (*str == '>') {
637             memcpy(&out[pos], "&gt;", 4);
638             pos += 4;
639         } else if (*str == '\'') {
640             memcpy(&out[pos], "&apos;", 6);
641             pos += 6;
642         } else if (*str == '\"') {
643             memcpy(&out[pos], "&quot;", 6);
644             pos += 6;
645         } else {
646             out[pos++] = *str;
647         }
648     }
649     out[pos] = '\0';
650     return out;
651 }
652
653 static void write_time(AVIOContext *out, int64_t time)
654 {
655     int seconds = time / AV_TIME_BASE;
656     int fractions = time % AV_TIME_BASE;
657     int minutes = seconds / 60;
658     int hours = minutes / 60;
659     seconds %= 60;
660     minutes %= 60;
661     avio_printf(out, "PT");
662     if (hours)
663         avio_printf(out, "%dH", hours);
664     if (hours || minutes)
665         avio_printf(out, "%dM", minutes);
666     avio_printf(out, "%d.%dS", seconds, fractions / (AV_TIME_BASE / 10));
667 }
668
669 static void format_date_now(char *buf, int size)
670 {
671     time_t t = time(NULL);
672     struct tm *ptm, tmbuf;
673     ptm = gmtime_r(&t, &tmbuf);
674     if (ptm) {
675         if (!strftime(buf, size, "%Y-%m-%dT%H:%M:%SZ", ptm))
676             buf[0] = '\0';
677     }
678 }
679
680 static int write_adaptation_set(AVFormatContext *s, AVIOContext *out, int as_index,
681                                 int final)
682 {
683     DASHContext *c = s->priv_data;
684     AdaptationSet *as = &c->as[as_index];
685     AVDictionaryEntry *lang, *role;
686     int i;
687
688     avio_printf(out, "\t\t<AdaptationSet id=\"%s\" contentType=\"%s\" segmentAlignment=\"true\" bitstreamSwitching=\"true\"",
689                 as->id, as->media_type == AVMEDIA_TYPE_VIDEO ? "video" : "audio");
690     if (as->media_type == AVMEDIA_TYPE_VIDEO && as->max_frame_rate.num && !as->ambiguous_frame_rate && av_cmp_q(as->min_frame_rate, as->max_frame_rate) < 0)
691         avio_printf(out, " maxFrameRate=\"%d/%d\"", as->max_frame_rate.num, as->max_frame_rate.den);
692     lang = av_dict_get(as->metadata, "language", NULL, 0);
693     if (lang)
694         avio_printf(out, " lang=\"%s\"", lang->value);
695     avio_printf(out, ">\n");
696
697     role = av_dict_get(as->metadata, "role", NULL, 0);
698     if (role)
699         avio_printf(out, "\t\t\t<Role schemeIdUri=\"urn:mpeg:dash:role:2011\" value=\"%s\"/>\n", role->value);
700
701     for (i = 0; i < s->nb_streams; i++) {
702         OutputStream *os = &c->streams[i];
703         char bandwidth_str[64] = {'\0'};
704
705         if (os->as_idx - 1 != as_index)
706             continue;
707
708         if (os->bit_rate > 0)
709             snprintf(bandwidth_str, sizeof(bandwidth_str), " bandwidth=\"%d\"",
710                      os->bit_rate);
711
712         if (as->media_type == AVMEDIA_TYPE_VIDEO) {
713             AVStream *st = s->streams[i];
714             avio_printf(out, "\t\t\t<Representation id=\"%d\" mimeType=\"video/%s\" codecs=\"%s\"%s width=\"%d\" height=\"%d\"",
715                 i, os->format_name, os->codec_str, bandwidth_str, s->streams[i]->codecpar->width, s->streams[i]->codecpar->height);
716             if (st->avg_frame_rate.num)
717                 avio_printf(out, " frameRate=\"%d/%d\"", st->avg_frame_rate.num, st->avg_frame_rate.den);
718             avio_printf(out, ">\n");
719         } else {
720             avio_printf(out, "\t\t\t<Representation id=\"%d\" mimeType=\"audio/%s\" codecs=\"%s\"%s audioSamplingRate=\"%d\">\n",
721                 i, os->format_name, os->codec_str, bandwidth_str, s->streams[i]->codecpar->sample_rate);
722             avio_printf(out, "\t\t\t\t<AudioChannelConfiguration schemeIdUri=\"urn:mpeg:dash:23003:3:audio_channel_configuration:2011\" value=\"%d\" />\n",
723                 s->streams[i]->codecpar->channels);
724         }
725         output_segment_list(os, out, s, i, final);
726         avio_printf(out, "\t\t\t</Representation>\n");
727     }
728     avio_printf(out, "\t\t</AdaptationSet>\n");
729
730     return 0;
731 }
732
733 static int add_adaptation_set(AVFormatContext *s, AdaptationSet **as, enum AVMediaType type)
734 {
735     DASHContext *c = s->priv_data;
736
737     void *mem = av_realloc(c->as, sizeof(*c->as) * (c->nb_as + 1));
738     if (!mem)
739         return AVERROR(ENOMEM);
740     c->as = mem;
741     ++c->nb_as;
742
743     *as = &c->as[c->nb_as - 1];
744     memset(*as, 0, sizeof(**as));
745     (*as)->media_type = type;
746
747     return 0;
748 }
749
750 static int adaptation_set_add_stream(AVFormatContext *s, int as_idx, int i)
751 {
752     DASHContext *c = s->priv_data;
753     AdaptationSet *as = &c->as[as_idx - 1];
754     OutputStream *os = &c->streams[i];
755
756     if (as->media_type != s->streams[i]->codecpar->codec_type) {
757         av_log(s, AV_LOG_ERROR, "Codec type of stream %d doesn't match AdaptationSet's media type\n", i);
758         return AVERROR(EINVAL);
759     } else if (os->as_idx) {
760         av_log(s, AV_LOG_ERROR, "Stream %d is already assigned to an AdaptationSet\n", i);
761         return AVERROR(EINVAL);
762     }
763     os->as_idx = as_idx;
764
765     return 0;
766 }
767
768 static int parse_adaptation_sets(AVFormatContext *s)
769 {
770     DASHContext *c = s->priv_data;
771     const char *p = c->adaptation_sets;
772     enum { new_set, parse_id, parsing_streams } state;
773     AdaptationSet *as;
774     int i, n, ret;
775
776     // default: one AdaptationSet for each stream
777     if (!p) {
778         for (i = 0; i < s->nb_streams; i++) {
779             if ((ret = add_adaptation_set(s, &as, s->streams[i]->codecpar->codec_type)) < 0)
780                 return ret;
781             snprintf(as->id, sizeof(as->id), "%d", i);
782
783             c->streams[i].as_idx = c->nb_as;
784         }
785         goto end;
786     }
787
788     // syntax id=0,streams=0,1,2 id=1,streams=3,4 and so on
789     state = new_set;
790     while (*p) {
791         if (*p == ' ') {
792             p++;
793             continue;
794         } else if (state == new_set && av_strstart(p, "id=", &p)) {
795
796             if ((ret = add_adaptation_set(s, &as, AVMEDIA_TYPE_UNKNOWN)) < 0)
797                 return ret;
798
799             n = strcspn(p, ",");
800             snprintf(as->id, sizeof(as->id), "%.*s", n, p);
801
802             p += n;
803             if (*p)
804                 p++;
805             state = parse_id;
806         } else if (state == parse_id && av_strstart(p, "streams=", &p)) {
807             state = parsing_streams;
808         } else if (state == parsing_streams) {
809             AdaptationSet *as = &c->as[c->nb_as - 1];
810             char idx_str[8], *end_str;
811
812             n = strcspn(p, " ,");
813             snprintf(idx_str, sizeof(idx_str), "%.*s", n, p);
814             p += n;
815
816             // if value is "a" or "v", map all streams of that type
817             if (as->media_type == AVMEDIA_TYPE_UNKNOWN && (idx_str[0] == 'v' || idx_str[0] == 'a')) {
818                 enum AVMediaType type = (idx_str[0] == 'v') ? AVMEDIA_TYPE_VIDEO : AVMEDIA_TYPE_AUDIO;
819                 av_log(s, AV_LOG_DEBUG, "Map all streams of type %s\n", idx_str);
820
821                 for (i = 0; i < s->nb_streams; i++) {
822                     if (s->streams[i]->codecpar->codec_type != type)
823                         continue;
824
825                     as->media_type = s->streams[i]->codecpar->codec_type;
826
827                     if ((ret = adaptation_set_add_stream(s, c->nb_as, i)) < 0)
828                         return ret;
829                 }
830             } else { // select single stream
831                 i = strtol(idx_str, &end_str, 10);
832                 if (idx_str == end_str || i < 0 || i >= s->nb_streams) {
833                     av_log(s, AV_LOG_ERROR, "Selected stream \"%s\" not found!\n", idx_str);
834                     return AVERROR(EINVAL);
835                 }
836                 av_log(s, AV_LOG_DEBUG, "Map stream %d\n", i);
837
838                 if (as->media_type == AVMEDIA_TYPE_UNKNOWN) {
839                     as->media_type = s->streams[i]->codecpar->codec_type;
840                 }
841
842                 if ((ret = adaptation_set_add_stream(s, c->nb_as, i)) < 0)
843                     return ret;
844             }
845
846             if (*p == ' ')
847                 state = new_set;
848             if (*p)
849                 p++;
850         } else {
851             return AVERROR(EINVAL);
852         }
853     }
854
855 end:
856     // check for unassigned streams
857     for (i = 0; i < s->nb_streams; i++) {
858         OutputStream *os = &c->streams[i];
859         if (!os->as_idx) {
860             av_log(s, AV_LOG_ERROR, "Stream %d is not mapped to an AdaptationSet\n", i);
861             return AVERROR(EINVAL);
862         }
863     }
864     return 0;
865 }
866
867 static int write_manifest(AVFormatContext *s, int final)
868 {
869     DASHContext *c = s->priv_data;
870     AVIOContext *out;
871     char temp_filename[1024];
872     int ret, i;
873     const char *proto = avio_find_protocol_name(s->url);
874     int use_rename = proto && !strcmp(proto, "file");
875     static unsigned int warned_non_file = 0;
876     AVDictionaryEntry *title = av_dict_get(s->metadata, "title", NULL, 0);
877     AVDictionary *opts = NULL;
878
879     if (!use_rename && !warned_non_file++)
880         av_log(s, AV_LOG_ERROR, "Cannot use rename on non file protocol, this may lead to races and temporary partial files\n");
881
882     snprintf(temp_filename, sizeof(temp_filename), use_rename ? "%s.tmp" : "%s", s->url);
883     set_http_options(&opts, c);
884     ret = dashenc_io_open(s, &c->mpd_out, temp_filename, &opts);
885     av_dict_free(&opts);
886     if (ret < 0) {
887         return handle_io_open_error(s, ret, temp_filename);
888     }
889     out = c->mpd_out;
890     avio_printf(out, "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n");
891     avio_printf(out, "<MPD xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"\n"
892                 "\txmlns=\"urn:mpeg:dash:schema:mpd:2011\"\n"
893                 "\txmlns:xlink=\"http://www.w3.org/1999/xlink\"\n"
894                 "\txsi:schemaLocation=\"urn:mpeg:DASH:schema:MPD:2011 http://standards.iso.org/ittf/PubliclyAvailableStandards/MPEG-DASH_schema_files/DASH-MPD.xsd\"\n"
895                 "\tprofiles=\"urn:mpeg:dash:profile:isoff-live:2011\"\n"
896                 "\ttype=\"%s\"\n", final ? "static" : "dynamic");
897     if (final) {
898         avio_printf(out, "\tmediaPresentationDuration=\"");
899         write_time(out, c->total_duration);
900         avio_printf(out, "\"\n");
901     } else {
902         int64_t update_period = c->last_duration / AV_TIME_BASE;
903         char now_str[100];
904         if (c->use_template && !c->use_timeline)
905             update_period = 500;
906         avio_printf(out, "\tminimumUpdatePeriod=\"PT%"PRId64"S\"\n", update_period);
907         avio_printf(out, "\tsuggestedPresentationDelay=\"PT%"PRId64"S\"\n", c->last_duration / AV_TIME_BASE);
908         if (c->availability_start_time[0])
909             avio_printf(out, "\tavailabilityStartTime=\"%s\"\n", c->availability_start_time);
910         format_date_now(now_str, sizeof(now_str));
911         if (now_str[0])
912             avio_printf(out, "\tpublishTime=\"%s\"\n", now_str);
913         if (c->window_size && c->use_template) {
914             avio_printf(out, "\ttimeShiftBufferDepth=\"");
915             write_time(out, c->last_duration * c->window_size);
916             avio_printf(out, "\"\n");
917         }
918     }
919     avio_printf(out, "\tminBufferTime=\"");
920     write_time(out, c->last_duration * 2);
921     avio_printf(out, "\">\n");
922     avio_printf(out, "\t<ProgramInformation>\n");
923     if (title) {
924         char *escaped = xmlescape(title->value);
925         avio_printf(out, "\t\t<Title>%s</Title>\n", escaped);
926         av_free(escaped);
927     }
928     avio_printf(out, "\t</ProgramInformation>\n");
929
930     if (c->window_size && s->nb_streams > 0 && c->streams[0].nb_segments > 0 && !c->use_template) {
931         OutputStream *os = &c->streams[0];
932         int start_index = FFMAX(os->nb_segments - c->window_size, 0);
933         int64_t start_time = av_rescale_q(os->segments[start_index]->time, s->streams[0]->time_base, AV_TIME_BASE_Q);
934         avio_printf(out, "\t<Period id=\"0\" start=\"");
935         write_time(out, start_time);
936         avio_printf(out, "\">\n");
937     } else {
938         avio_printf(out, "\t<Period id=\"0\" start=\"PT0.0S\">\n");
939     }
940
941     for (i = 0; i < c->nb_as; i++) {
942         if ((ret = write_adaptation_set(s, out, i, final)) < 0)
943             return ret;
944     }
945     avio_printf(out, "\t</Period>\n");
946
947     if (c->utc_timing_url)
948         avio_printf(out, "\t<UTCTiming schemeIdUri=\"urn:mpeg:dash:utc:http-xsdate:2014\" value=\"%s\"/>\n", c->utc_timing_url);
949
950     avio_printf(out, "</MPD>\n");
951     avio_flush(out);
952     dashenc_io_close(s, &c->mpd_out, temp_filename);
953
954     if (use_rename) {
955         if ((ret = avpriv_io_move(temp_filename, s->url)) < 0)
956             return ret;
957     }
958
959     if (c->hls_playlist && !c->master_playlist_created) {
960         char filename_hls[1024];
961         const char *audio_group = "A1";
962         char audio_codec_str[128] = "\0";
963         int is_default = 1;
964         int max_audio_bitrate = 0;
965
966         if (*c->dirname)
967             snprintf(filename_hls, sizeof(filename_hls), "%smaster.m3u8", c->dirname);
968         else
969             snprintf(filename_hls, sizeof(filename_hls), "master.m3u8");
970
971         snprintf(temp_filename, sizeof(temp_filename), use_rename ? "%s.tmp" : "%s", filename_hls);
972
973         set_http_options(&opts, c);
974         ret = dashenc_io_open(s, &c->m3u8_out, temp_filename, &opts);
975         av_dict_free(&opts);
976         if (ret < 0) {
977             return handle_io_open_error(s, ret, temp_filename);
978         }
979
980         ff_hls_write_playlist_version(c->m3u8_out, 7);
981
982         for (i = 0; i < s->nb_streams; i++) {
983             char playlist_file[64];
984             AVStream *st = s->streams[i];
985             OutputStream *os = &c->streams[i];
986             if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO)
987                 continue;
988             if (os->segment_type != SEGMENT_TYPE_MP4)
989                 continue;
990             get_hls_playlist_name(playlist_file, sizeof(playlist_file), NULL, i);
991             ff_hls_write_audio_rendition(c->m3u8_out, (char *)audio_group,
992                                          playlist_file, i, is_default);
993             max_audio_bitrate = FFMAX(st->codecpar->bit_rate +
994                                       os->muxer_overhead, max_audio_bitrate);
995             if (!av_strnstr(audio_codec_str, os->codec_str, sizeof(audio_codec_str))) {
996                 if (strlen(audio_codec_str))
997                     av_strlcat(audio_codec_str, ",", sizeof(audio_codec_str));
998                 av_strlcat(audio_codec_str, os->codec_str, sizeof(audio_codec_str));
999             }
1000             is_default = 0;
1001         }
1002
1003         for (i = 0; i < s->nb_streams; i++) {
1004             char playlist_file[64];
1005             char codec_str[128];
1006             AVStream *st = s->streams[i];
1007             OutputStream *os = &c->streams[i];
1008             char *agroup = NULL;
1009             char *codec_str_ptr = NULL;
1010             int stream_bitrate = st->codecpar->bit_rate + os->muxer_overhead;
1011             if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
1012                 continue;
1013             if (os->segment_type != SEGMENT_TYPE_MP4)
1014                 continue;
1015             av_strlcpy(codec_str, os->codec_str, sizeof(codec_str));
1016             if (max_audio_bitrate) {
1017                 agroup = (char *)audio_group;
1018                 stream_bitrate += max_audio_bitrate;
1019                 av_strlcat(codec_str, ",", sizeof(codec_str));
1020                 av_strlcat(codec_str, audio_codec_str, sizeof(codec_str));
1021             }
1022             if (st->codecpar->codec_id != AV_CODEC_ID_HEVC) {
1023                 codec_str_ptr = codec_str;
1024             }
1025             get_hls_playlist_name(playlist_file, sizeof(playlist_file), NULL, i);
1026             ff_hls_write_stream_info(st, c->m3u8_out, stream_bitrate,
1027                                      playlist_file, agroup,
1028                                      codec_str_ptr, NULL);
1029         }
1030         dashenc_io_close(s, &c->m3u8_out, temp_filename);
1031         if (use_rename)
1032             if ((ret = avpriv_io_move(temp_filename, filename_hls)) < 0)
1033                 return ret;
1034         c->master_playlist_created = 1;
1035     }
1036
1037     return 0;
1038 }
1039
1040 static int dict_copy_entry(AVDictionary **dst, const AVDictionary *src, const char *key)
1041 {
1042     AVDictionaryEntry *entry = av_dict_get(src, key, NULL, 0);
1043     if (entry)
1044         av_dict_set(dst, key, entry->value, AV_DICT_DONT_OVERWRITE);
1045     return 0;
1046 }
1047
1048 static int dash_init(AVFormatContext *s)
1049 {
1050     DASHContext *c = s->priv_data;
1051     int ret = 0, i;
1052     char *ptr;
1053     char basename[1024];
1054
1055     if (c->single_file_name)
1056         c->single_file = 1;
1057     if (c->single_file)
1058         c->use_template = 0;
1059
1060 #if FF_API_DASH_MIN_SEG_DURATION
1061     if (c->min_seg_duration != 5000000) {
1062         av_log(s, AV_LOG_WARNING, "The min_seg_duration option is deprecated and will be removed. Please use the -seg_duration\n");
1063         c->seg_duration = c->min_seg_duration;
1064     }
1065 #endif
1066     if (c->lhls && s->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
1067         av_log(s, AV_LOG_ERROR,
1068                "LHLS is experimental, Please set -strict experimental in order to enable it.\n");
1069         return AVERROR_EXPERIMENTAL;
1070     }
1071
1072     if (c->lhls && !c->streaming) {
1073         av_log(s, AV_LOG_WARNING, "LHLS option will be ignored as streaming is not enabled\n");
1074         c->lhls = 0;
1075     }
1076
1077     if (c->lhls && !c->hls_playlist) {
1078         av_log(s, AV_LOG_WARNING, "LHLS option will be ignored as hls_playlist is not enabled\n");
1079         c->lhls = 0;
1080     }
1081
1082     av_strlcpy(c->dirname, s->url, sizeof(c->dirname));
1083     ptr = strrchr(c->dirname, '/');
1084     if (ptr) {
1085         av_strlcpy(basename, &ptr[1], sizeof(basename));
1086         ptr[1] = '\0';
1087     } else {
1088         c->dirname[0] = '\0';
1089         av_strlcpy(basename, s->url, sizeof(basename));
1090     }
1091
1092     ptr = strrchr(basename, '.');
1093     if (ptr)
1094         *ptr = '\0';
1095
1096     c->streams = av_mallocz(sizeof(*c->streams) * s->nb_streams);
1097     if (!c->streams)
1098         return AVERROR(ENOMEM);
1099
1100     if ((ret = parse_adaptation_sets(s)) < 0)
1101         return ret;
1102
1103     if ((ret = init_segment_types(s)) < 0)
1104         return ret;
1105
1106     for (i = 0; i < s->nb_streams; i++) {
1107         OutputStream *os = &c->streams[i];
1108         AdaptationSet *as = &c->as[os->as_idx - 1];
1109         AVFormatContext *ctx;
1110         AVStream *st;
1111         AVDictionary *opts = NULL;
1112         char filename[1024];
1113
1114         os->bit_rate = s->streams[i]->codecpar->bit_rate;
1115         if (!os->bit_rate) {
1116             int level = s->strict_std_compliance >= FF_COMPLIANCE_STRICT ?
1117                         AV_LOG_ERROR : AV_LOG_WARNING;
1118             av_log(s, level, "No bit rate set for stream %d\n", i);
1119             if (s->strict_std_compliance >= FF_COMPLIANCE_STRICT)
1120                 return AVERROR(EINVAL);
1121         }
1122
1123         // copy AdaptationSet language and role from stream metadata
1124         dict_copy_entry(&as->metadata, s->streams[i]->metadata, "language");
1125         dict_copy_entry(&as->metadata, s->streams[i]->metadata, "role");
1126
1127         ctx = avformat_alloc_context();
1128         if (!ctx)
1129             return AVERROR(ENOMEM);
1130
1131         if (c->init_seg_name) {
1132             os->init_seg_name = av_strireplace(c->init_seg_name, "$ext$", os->format_name);
1133             if (!os->init_seg_name)
1134                 return AVERROR(ENOMEM);
1135         }
1136         if (c->media_seg_name) {
1137             os->media_seg_name = av_strireplace(c->media_seg_name, "$ext$", os->format_name);
1138             if (!os->media_seg_name)
1139                 return AVERROR(ENOMEM);
1140         }
1141         if (c->single_file_name) {
1142             os->single_file_name = av_strireplace(c->single_file_name, "$ext$", os->format_name);
1143             if (!os->single_file_name)
1144                 return AVERROR(ENOMEM);
1145         }
1146
1147         if (os->segment_type == SEGMENT_TYPE_WEBM) {
1148             if ((!c->single_file && check_file_extension(os->init_seg_name, os->format_name) != 0) ||
1149                 (!c->single_file && check_file_extension(os->media_seg_name, os->format_name) != 0) ||
1150                 (c->single_file && check_file_extension(os->single_file_name, os->format_name) != 0)) {
1151                 av_log(s, AV_LOG_WARNING,
1152                        "One or many segment file names doesn't end with .webm. "
1153                        "Override -init_seg_name and/or -media_seg_name and/or "
1154                        "-single_file_name to end with the extension .webm\n");
1155             }
1156         }
1157
1158         ctx->oformat = av_guess_format(os->format_name, NULL, NULL);
1159         if (!ctx->oformat)
1160             return AVERROR_MUXER_NOT_FOUND;
1161         os->ctx = ctx;
1162         ctx->interrupt_callback    = s->interrupt_callback;
1163         ctx->opaque                = s->opaque;
1164         ctx->io_close              = s->io_close;
1165         ctx->io_open               = s->io_open;
1166         ctx->strict_std_compliance = s->strict_std_compliance;
1167
1168         if (!(st = avformat_new_stream(ctx, NULL)))
1169             return AVERROR(ENOMEM);
1170         avcodec_parameters_copy(st->codecpar, s->streams[i]->codecpar);
1171         st->sample_aspect_ratio = s->streams[i]->sample_aspect_ratio;
1172         st->time_base = s->streams[i]->time_base;
1173         st->avg_frame_rate = s->streams[i]->avg_frame_rate;
1174         ctx->avoid_negative_ts = s->avoid_negative_ts;
1175         ctx->flags = s->flags;
1176
1177         if ((ret = avio_open_dyn_buf(&ctx->pb)) < 0)
1178             return ret;
1179
1180         if (c->single_file) {
1181             if (os->single_file_name)
1182                 ff_dash_fill_tmpl_params(os->initfile, sizeof(os->initfile), os->single_file_name, i, 0, os->bit_rate, 0);
1183             else
1184                 snprintf(os->initfile, sizeof(os->initfile), "%s-stream%d.%s", basename, i, os->format_name);
1185         } else {
1186             ff_dash_fill_tmpl_params(os->initfile, sizeof(os->initfile), os->init_seg_name, i, 0, os->bit_rate, 0);
1187         }
1188         snprintf(filename, sizeof(filename), "%s%s", c->dirname, os->initfile);
1189         set_http_options(&opts, c);
1190         ret = s->io_open(s, &os->out, filename, AVIO_FLAG_WRITE, &opts);
1191         av_dict_free(&opts);
1192         if (ret < 0)
1193             return ret;
1194         os->init_start_pos = 0;
1195
1196         if (c->format_options_str) {
1197             ret = av_dict_parse_string(&opts, c->format_options_str, "=", ":", 0);
1198             if (ret < 0)
1199                 return ret;
1200         }
1201
1202         if (os->segment_type == SEGMENT_TYPE_MP4) {
1203             if (c->streaming)
1204                 av_dict_set(&opts, "movflags", "frag_every_frame+dash+delay_moov+skip_sidx", 0);
1205             else
1206                 av_dict_set(&opts, "movflags", "frag_custom+dash+delay_moov", 0);
1207         } else {
1208             av_dict_set_int(&opts, "cluster_time_limit", c->seg_duration / 1000, 0);
1209             av_dict_set_int(&opts, "cluster_size_limit", 5 * 1024 * 1024, 0); // set a large cluster size limit
1210             av_dict_set_int(&opts, "dash", 1, 0);
1211             av_dict_set_int(&opts, "dash_track_number", i + 1, 0);
1212             av_dict_set_int(&opts, "live", 1, 0);
1213         }
1214         ret = avformat_init_output(ctx, &opts);
1215         av_dict_free(&opts);
1216         if (ret < 0)
1217             return ret;
1218         os->ctx_inited = 1;
1219         avio_flush(ctx->pb);
1220
1221         av_log(s, AV_LOG_VERBOSE, "Representation %d init segment will be written to: %s\n", i, filename);
1222
1223         s->streams[i]->time_base = st->time_base;
1224         // If the muxer wants to shift timestamps, request to have them shifted
1225         // already before being handed to this muxer, so we don't have mismatches
1226         // between the MPD and the actual segments.
1227         s->avoid_negative_ts = ctx->avoid_negative_ts;
1228         if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
1229             AVRational avg_frame_rate = s->streams[i]->avg_frame_rate;
1230             if (avg_frame_rate.num > 0) {
1231                 if (av_cmp_q(avg_frame_rate, as->min_frame_rate) < 0)
1232                     as->min_frame_rate = avg_frame_rate;
1233                 if (av_cmp_q(as->max_frame_rate, avg_frame_rate) < 0)
1234                     as->max_frame_rate = avg_frame_rate;
1235             } else {
1236                 as->ambiguous_frame_rate = 1;
1237             }
1238             c->has_video = 1;
1239         }
1240
1241         set_codec_str(s, st->codecpar, &st->avg_frame_rate, os->codec_str,
1242                       sizeof(os->codec_str));
1243         os->first_pts = AV_NOPTS_VALUE;
1244         os->max_pts = AV_NOPTS_VALUE;
1245         os->last_dts = AV_NOPTS_VALUE;
1246         os->segment_index = 1;
1247     }
1248
1249     if (!c->has_video && c->seg_duration <= 0) {
1250         av_log(s, AV_LOG_WARNING, "no video stream and no seg duration set\n");
1251         return AVERROR(EINVAL);
1252     }
1253     return 0;
1254 }
1255
1256 static int dash_write_header(AVFormatContext *s)
1257 {
1258     DASHContext *c = s->priv_data;
1259     int i, ret;
1260     for (i = 0; i < s->nb_streams; i++) {
1261         OutputStream *os = &c->streams[i];
1262         if ((ret = avformat_write_header(os->ctx, NULL)) < 0)
1263             return ret;
1264
1265         // Flush init segment
1266         // Only for WebM segment, since for mp4 delay_moov is set and
1267         // the init segment is thus flushed after the first packets.
1268         if (os->segment_type == SEGMENT_TYPE_WEBM &&
1269             (ret = flush_init_segment(s, os)) < 0)
1270             return ret;
1271     }
1272     return ret;
1273 }
1274
1275 static int add_segment(OutputStream *os, const char *file,
1276                        int64_t time, int64_t duration,
1277                        int64_t start_pos, int64_t range_length,
1278                        int64_t index_length, int next_exp_index)
1279 {
1280     int err;
1281     Segment *seg;
1282     if (os->nb_segments >= os->segments_size) {
1283         os->segments_size = (os->segments_size + 1) * 2;
1284         if ((err = av_reallocp(&os->segments, sizeof(*os->segments) *
1285                                os->segments_size)) < 0) {
1286             os->segments_size = 0;
1287             os->nb_segments = 0;
1288             return err;
1289         }
1290     }
1291     seg = av_mallocz(sizeof(*seg));
1292     if (!seg)
1293         return AVERROR(ENOMEM);
1294     av_strlcpy(seg->file, file, sizeof(seg->file));
1295     seg->time = time;
1296     seg->duration = duration;
1297     if (seg->time < 0) { // If pts<0, it is expected to be cut away with an edit list
1298         seg->duration += seg->time;
1299         seg->time = 0;
1300     }
1301     seg->start_pos = start_pos;
1302     seg->range_length = range_length;
1303     seg->index_length = index_length;
1304     os->segments[os->nb_segments++] = seg;
1305     os->segment_index++;
1306     //correcting the segment index if it has fallen behind the expected value
1307     if (os->segment_index < next_exp_index) {
1308         av_log(NULL, AV_LOG_WARNING, "Correcting the segment index after file %s: current=%d corrected=%d\n",
1309                file, os->segment_index, next_exp_index);
1310         os->segment_index = next_exp_index;
1311     }
1312     return 0;
1313 }
1314
1315 static void write_styp(AVIOContext *pb)
1316 {
1317     avio_wb32(pb, 24);
1318     ffio_wfourcc(pb, "styp");
1319     ffio_wfourcc(pb, "msdh");
1320     avio_wb32(pb, 0); /* minor */
1321     ffio_wfourcc(pb, "msdh");
1322     ffio_wfourcc(pb, "msix");
1323 }
1324
1325 static void find_index_range(AVFormatContext *s, const char *full_path,
1326                              int64_t pos, int *index_length)
1327 {
1328     uint8_t buf[8];
1329     AVIOContext *pb;
1330     int ret;
1331
1332     ret = s->io_open(s, &pb, full_path, AVIO_FLAG_READ, NULL);
1333     if (ret < 0)
1334         return;
1335     if (avio_seek(pb, pos, SEEK_SET) != pos) {
1336         ff_format_io_close(s, &pb);
1337         return;
1338     }
1339     ret = avio_read(pb, buf, 8);
1340     ff_format_io_close(s, &pb);
1341     if (ret < 8)
1342         return;
1343     if (AV_RL32(&buf[4]) != MKTAG('s', 'i', 'd', 'x'))
1344         return;
1345     *index_length = AV_RB32(&buf[0]);
1346 }
1347
1348 static int update_stream_extradata(AVFormatContext *s, OutputStream *os,
1349                                    AVCodecParameters *par,
1350                                    AVRational *frame_rate)
1351 {
1352     uint8_t *extradata;
1353
1354     if (os->ctx->streams[0]->codecpar->extradata_size || !par->extradata_size)
1355         return 0;
1356
1357     extradata = av_malloc(par->extradata_size);
1358
1359     if (!extradata)
1360         return AVERROR(ENOMEM);
1361
1362     memcpy(extradata, par->extradata, par->extradata_size);
1363
1364     os->ctx->streams[0]->codecpar->extradata = extradata;
1365     os->ctx->streams[0]->codecpar->extradata_size = par->extradata_size;
1366
1367     set_codec_str(s, par, frame_rate, os->codec_str, sizeof(os->codec_str));
1368
1369     return 0;
1370 }
1371
1372 static void dashenc_delete_file(AVFormatContext *s, char *filename) {
1373     DASHContext *c = s->priv_data;
1374     int http_base_proto = ff_is_http_proto(filename);
1375
1376     if (http_base_proto) {
1377         AVIOContext *out = NULL;
1378         AVDictionary *http_opts = NULL;
1379
1380         set_http_options(&http_opts, c);
1381         av_dict_set(&http_opts, "method", "DELETE", 0);
1382
1383         if (dashenc_io_open(s, &out, filename, &http_opts) < 0) {
1384             av_log(s, AV_LOG_ERROR, "failed to delete %s\n", filename);
1385         }
1386
1387         av_dict_free(&http_opts);
1388         ff_format_io_close(s, &out);
1389     } else {
1390         int res = avpriv_io_delete(filename);
1391         if (res < 0) {
1392             char errbuf[AV_ERROR_MAX_STRING_SIZE];
1393             av_strerror(res, errbuf, sizeof(errbuf));
1394             av_log(s, (res == AVERROR(ENOENT) ? AV_LOG_WARNING : AV_LOG_ERROR), "failed to delete %s: %s\n", filename, errbuf);
1395         }
1396     }
1397 }
1398
1399 static int dashenc_delete_segment_file(AVFormatContext *s, const char* file)
1400 {
1401     DASHContext *c = s->priv_data;
1402     size_t dirname_len, file_len;
1403     char filename[1024];
1404
1405     dirname_len = strlen(c->dirname);
1406     if (dirname_len >= sizeof(filename)) {
1407         av_log(s, AV_LOG_WARNING, "Cannot delete segments as the directory path is too long: %"PRIu64" characters: %s\n",
1408             (uint64_t)dirname_len, c->dirname);
1409         return AVERROR(ENAMETOOLONG);
1410     }
1411
1412     memcpy(filename, c->dirname, dirname_len);
1413
1414     file_len = strlen(file);
1415     if ((dirname_len + file_len) >= sizeof(filename)) {
1416         av_log(s, AV_LOG_WARNING, "Cannot delete segments as the path is too long: %"PRIu64" characters: %s%s\n",
1417             (uint64_t)(dirname_len + file_len), c->dirname, file);
1418         return AVERROR(ENAMETOOLONG);
1419     }
1420
1421     memcpy(filename + dirname_len, file, file_len + 1); // include the terminating zero
1422     dashenc_delete_file(s, filename);
1423
1424     return 0;
1425 }
1426
1427 static inline void dashenc_delete_media_segments(AVFormatContext *s, OutputStream *os, int remove_count)
1428 {
1429     for (int i = 0; i < remove_count; ++i) {
1430         dashenc_delete_segment_file(s, os->segments[i]->file);
1431
1432         // Delete the segment regardless of whether the file was successfully deleted
1433         av_free(os->segments[i]);
1434     }
1435
1436     os->nb_segments -= remove_count;
1437     memmove(os->segments, os->segments + remove_count, os->nb_segments * sizeof(*os->segments));
1438 }
1439
1440 static int dash_flush(AVFormatContext *s, int final, int stream)
1441 {
1442     DASHContext *c = s->priv_data;
1443     int i, ret = 0;
1444
1445     const char *proto = avio_find_protocol_name(s->url);
1446     int use_rename = proto && !strcmp(proto, "file");
1447
1448     int cur_flush_segment_index = 0, next_exp_index = -1;
1449     if (stream >= 0) {
1450         cur_flush_segment_index = c->streams[stream].segment_index;
1451
1452         //finding the next segment's expected index, based on the current pts value
1453         if (c->use_template && !c->use_timeline && c->index_correction &&
1454             c->streams[stream].last_pts != AV_NOPTS_VALUE &&
1455             c->streams[stream].first_pts != AV_NOPTS_VALUE) {
1456             int64_t pts_diff = av_rescale_q(c->streams[stream].last_pts -
1457                                             c->streams[stream].first_pts,
1458                                             s->streams[stream]->time_base,
1459                                             AV_TIME_BASE_Q);
1460             next_exp_index = (pts_diff / c->seg_duration) + 1;
1461         }
1462     }
1463
1464     for (i = 0; i < s->nb_streams; i++) {
1465         OutputStream *os = &c->streams[i];
1466         AVStream *st = s->streams[i];
1467         int range_length, index_length = 0;
1468
1469         if (!os->packets_written)
1470             continue;
1471
1472         // Flush the single stream that got a keyframe right now.
1473         // Flush all audio streams as well, in sync with video keyframes,
1474         // but not the other video streams.
1475         if (stream >= 0 && i != stream) {
1476             if (s->streams[i]->codecpar->codec_type != AVMEDIA_TYPE_AUDIO)
1477                 continue;
1478             // Make sure we don't flush audio streams multiple times, when
1479             // all video streams are flushed one at a time.
1480             if (c->has_video && os->segment_index > cur_flush_segment_index)
1481                 continue;
1482         }
1483
1484         if (!c->single_file) {
1485             if (os->segment_type == SEGMENT_TYPE_MP4 && !os->written_len)
1486                 write_styp(os->ctx->pb);
1487         } else {
1488             snprintf(os->full_path, sizeof(os->full_path), "%s%s", c->dirname, os->initfile);
1489         }
1490
1491         ret = flush_dynbuf(os, &range_length);
1492         if (ret < 0)
1493             break;
1494         os->packets_written = 0;
1495
1496         if (c->single_file) {
1497             find_index_range(s, os->full_path, os->pos, &index_length);
1498         } else {
1499             dashenc_io_close(s, &os->out, os->temp_path);
1500
1501             if (use_rename) {
1502                 ret = avpriv_io_move(os->temp_path, os->full_path);
1503                 if (ret < 0)
1504                     break;
1505             }
1506         }
1507
1508         if (!os->muxer_overhead)
1509             os->muxer_overhead = ((int64_t) (range_length - os->total_pkt_size) *
1510                                   8 * AV_TIME_BASE) /
1511                                  av_rescale_q(os->max_pts - os->start_pts,
1512                                               st->time_base, AV_TIME_BASE_Q);
1513         os->total_pkt_size = 0;
1514
1515         if (!os->bit_rate) {
1516             // calculate average bitrate of first segment
1517             int64_t bitrate = (int64_t) range_length * 8 * AV_TIME_BASE / av_rescale_q(os->max_pts - os->start_pts,
1518                                                                                        st->time_base,
1519                                                                                        AV_TIME_BASE_Q);
1520             if (bitrate >= 0)
1521                 os->bit_rate = bitrate;
1522         }
1523         add_segment(os, os->filename, os->start_pts, os->max_pts - os->start_pts, os->pos, range_length, index_length, next_exp_index);
1524         av_log(s, AV_LOG_VERBOSE, "Representation %d media segment %d written to: %s\n", i, os->segment_index, os->full_path);
1525
1526         os->pos += range_length;
1527     }
1528
1529     if (c->window_size) {
1530         for (i = 0; i < s->nb_streams; i++) {
1531             OutputStream *os = &c->streams[i];
1532             int remove_count = os->nb_segments - c->window_size - c->extra_window_size;
1533             if (remove_count > 0)
1534                 dashenc_delete_media_segments(s, os, remove_count);
1535         }
1536     }
1537
1538     if (ret >= 0)
1539         ret = write_manifest(s, final);
1540     return ret;
1541 }
1542
1543 static int dash_write_packet(AVFormatContext *s, AVPacket *pkt)
1544 {
1545     DASHContext *c = s->priv_data;
1546     AVStream *st = s->streams[pkt->stream_index];
1547     OutputStream *os = &c->streams[pkt->stream_index];
1548     int64_t seg_end_duration, elapsed_duration;
1549     int ret;
1550
1551     ret = update_stream_extradata(s, os, st->codecpar, &st->avg_frame_rate);
1552     if (ret < 0)
1553         return ret;
1554
1555     // Fill in a heuristic guess of the packet duration, if none is available.
1556     // The mp4 muxer will do something similar (for the last packet in a fragment)
1557     // if nothing is set (setting it for the other packets doesn't hurt).
1558     // By setting a nonzero duration here, we can be sure that the mp4 muxer won't
1559     // invoke its heuristic (this doesn't have to be identical to that algorithm),
1560     // so that we know the exact timestamps of fragments.
1561     if (!pkt->duration && os->last_dts != AV_NOPTS_VALUE)
1562         pkt->duration = pkt->dts - os->last_dts;
1563     os->last_dts = pkt->dts;
1564
1565     // If forcing the stream to start at 0, the mp4 muxer will set the start
1566     // timestamps to 0. Do the same here, to avoid mismatches in duration/timestamps.
1567     if (os->first_pts == AV_NOPTS_VALUE &&
1568         s->avoid_negative_ts == AVFMT_AVOID_NEG_TS_MAKE_ZERO) {
1569         pkt->pts -= pkt->dts;
1570         pkt->dts  = 0;
1571     }
1572
1573     if (os->first_pts == AV_NOPTS_VALUE)
1574         os->first_pts = pkt->pts;
1575     os->last_pts = pkt->pts;
1576
1577     if (!c->availability_start_time[0])
1578         format_date_now(c->availability_start_time,
1579                         sizeof(c->availability_start_time));
1580
1581     if (!os->availability_time_offset && pkt->duration) {
1582         int64_t frame_duration = av_rescale_q(pkt->duration, st->time_base,
1583                                               AV_TIME_BASE_Q);
1584          os->availability_time_offset = ((double) c->seg_duration -
1585                                          frame_duration) / AV_TIME_BASE;
1586     }
1587
1588     if (c->use_template && !c->use_timeline) {
1589         elapsed_duration = pkt->pts - os->first_pts;
1590         seg_end_duration = (int64_t) os->segment_index * c->seg_duration;
1591     } else {
1592         elapsed_duration = pkt->pts - os->start_pts;
1593         seg_end_duration = c->seg_duration;
1594     }
1595
1596     if ((!c->has_video || st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) &&
1597         pkt->flags & AV_PKT_FLAG_KEY && os->packets_written &&
1598         av_compare_ts(elapsed_duration, st->time_base,
1599                       seg_end_duration, AV_TIME_BASE_Q) >= 0) {
1600         int64_t prev_duration = c->last_duration;
1601
1602         c->last_duration = av_rescale_q(pkt->pts - os->start_pts,
1603                                         st->time_base,
1604                                         AV_TIME_BASE_Q);
1605         c->total_duration = av_rescale_q(pkt->pts - os->first_pts,
1606                                          st->time_base,
1607                                          AV_TIME_BASE_Q);
1608
1609         if ((!c->use_timeline || !c->use_template) && prev_duration) {
1610             if (c->last_duration < prev_duration*9/10 ||
1611                 c->last_duration > prev_duration*11/10) {
1612                 av_log(s, AV_LOG_WARNING,
1613                        "Segment durations differ too much, enable use_timeline "
1614                        "and use_template, or keep a stricter keyframe interval\n");
1615             }
1616         }
1617
1618         if ((ret = dash_flush(s, 0, pkt->stream_index)) < 0)
1619             return ret;
1620     }
1621
1622     if (!os->packets_written) {
1623         // If we wrote a previous segment, adjust the start time of the segment
1624         // to the end of the previous one (which is the same as the mp4 muxer
1625         // does). This avoids gaps in the timeline.
1626         if (os->max_pts != AV_NOPTS_VALUE)
1627             os->start_pts = os->max_pts;
1628         else
1629             os->start_pts = pkt->pts;
1630     }
1631     if (os->max_pts == AV_NOPTS_VALUE)
1632         os->max_pts = pkt->pts + pkt->duration;
1633     else
1634         os->max_pts = FFMAX(os->max_pts, pkt->pts + pkt->duration);
1635     os->packets_written++;
1636     os->total_pkt_size += pkt->size;
1637     if ((ret = ff_write_chained(os->ctx, 0, pkt, s, 0)) < 0)
1638         return ret;
1639
1640     if (!os->init_range_length)
1641         flush_init_segment(s, os);
1642
1643     //open the output context when the first frame of a segment is ready
1644     if (!c->single_file && os->packets_written == 1) {
1645         AVDictionary *opts = NULL;
1646         const char *proto = avio_find_protocol_name(s->url);
1647         int use_rename = proto && !strcmp(proto, "file");
1648         os->filename[0] = os->full_path[0] = os->temp_path[0] = '\0';
1649         ff_dash_fill_tmpl_params(os->filename, sizeof(os->filename),
1650                                  os->media_seg_name, pkt->stream_index,
1651                                  os->segment_index, os->bit_rate, os->start_pts);
1652         snprintf(os->full_path, sizeof(os->full_path), "%s%s", c->dirname,
1653                  os->filename);
1654         snprintf(os->temp_path, sizeof(os->temp_path),
1655                  use_rename ? "%s.tmp" : "%s", os->full_path);
1656         set_http_options(&opts, c);
1657         ret = dashenc_io_open(s, &os->out, os->temp_path, &opts);
1658         av_dict_free(&opts);
1659         if (ret < 0) {
1660             return handle_io_open_error(s, ret, os->temp_path);
1661         }
1662         if (c->lhls) {
1663             char *prefetch_url = use_rename ? NULL : os->filename;
1664             write_hls_media_playlist(os, s, pkt->stream_index, 0, prefetch_url);
1665         }
1666     }
1667
1668     //write out the data immediately in streaming mode
1669     if (c->streaming && os->segment_type == SEGMENT_TYPE_MP4) {
1670         int len = 0;
1671         uint8_t *buf = NULL;
1672         if (!os->written_len)
1673             write_styp(os->ctx->pb);
1674         avio_flush(os->ctx->pb);
1675         len = avio_get_dyn_buf (os->ctx->pb, &buf);
1676         if (os->out) {
1677             avio_write(os->out, buf + os->written_len, len - os->written_len);
1678             avio_flush(os->out);
1679         }
1680         os->written_len = len;
1681     }
1682
1683     return ret;
1684 }
1685
1686 static int dash_write_trailer(AVFormatContext *s)
1687 {
1688     DASHContext *c = s->priv_data;
1689     int i;
1690
1691     if (s->nb_streams > 0) {
1692         OutputStream *os = &c->streams[0];
1693         // If no segments have been written so far, try to do a crude
1694         // guess of the segment duration
1695         if (!c->last_duration)
1696             c->last_duration = av_rescale_q(os->max_pts - os->start_pts,
1697                                             s->streams[0]->time_base,
1698                                             AV_TIME_BASE_Q);
1699         c->total_duration = av_rescale_q(os->max_pts - os->first_pts,
1700                                          s->streams[0]->time_base,
1701                                          AV_TIME_BASE_Q);
1702     }
1703     dash_flush(s, 1, -1);
1704
1705     for (i = 0; i < s->nb_streams; ++i) {
1706         OutputStream *os = &c->streams[i];
1707         if (os->ctx && os->ctx_inited) {
1708             av_write_trailer(os->ctx);
1709         }
1710
1711         if (c->remove_at_exit) {
1712             dashenc_delete_media_segments(s, os, os->nb_segments);
1713             dashenc_delete_segment_file(s, os->initfile);
1714         }
1715     }
1716
1717     if (c->remove_at_exit) {
1718         dashenc_delete_file(s, s->url);
1719
1720         if (c->hls_playlist && c->master_playlist_created) {
1721             char filename[1024];
1722             for (i = 0; i < s->nb_streams; ++i) {
1723                 OutputStream *os = &c->streams[i];
1724                 if (os->segment_type == SEGMENT_TYPE_MP4) {
1725                     get_hls_playlist_name(filename, sizeof(filename), c->dirname, i);
1726                     dashenc_delete_file(s, filename);
1727                 }
1728             }
1729             snprintf(filename, sizeof(filename), "%smaster.m3u8", c->dirname);
1730             dashenc_delete_file(s, filename);
1731         }
1732     }
1733
1734     return 0;
1735 }
1736
1737 static int dash_check_bitstream(struct AVFormatContext *s, const AVPacket *avpkt)
1738 {
1739     DASHContext *c = s->priv_data;
1740     OutputStream *os = &c->streams[avpkt->stream_index];
1741     AVFormatContext *oc = os->ctx;
1742     if (oc->oformat->check_bitstream) {
1743         int ret;
1744         AVPacket pkt = *avpkt;
1745         pkt.stream_index = 0;
1746         ret = oc->oformat->check_bitstream(oc, &pkt);
1747         if (ret == 1) {
1748             AVStream *st = s->streams[avpkt->stream_index];
1749             AVStream *ost = oc->streams[0];
1750             st->internal->bsfcs = ost->internal->bsfcs;
1751             st->internal->nb_bsfcs = ost->internal->nb_bsfcs;
1752             ost->internal->bsfcs = NULL;
1753             ost->internal->nb_bsfcs = 0;
1754         }
1755         return ret;
1756     }
1757     return 1;
1758 }
1759
1760 #define OFFSET(x) offsetof(DASHContext, x)
1761 #define E AV_OPT_FLAG_ENCODING_PARAM
1762 static const AVOption options[] = {
1763     { "adaptation_sets", "Adaptation sets. Syntax: id=0,streams=0,1,2 id=1,streams=3,4 and so on", OFFSET(adaptation_sets), AV_OPT_TYPE_STRING, { 0 }, 0, 0, AV_OPT_FLAG_ENCODING_PARAM },
1764     { "window_size", "number of segments kept in the manifest", OFFSET(window_size), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, E },
1765     { "extra_window_size", "number of segments kept outside of the manifest before removing from disk", OFFSET(extra_window_size), AV_OPT_TYPE_INT, { .i64 = 5 }, 0, INT_MAX, E },
1766 #if FF_API_DASH_MIN_SEG_DURATION
1767     { "min_seg_duration", "minimum segment duration (in microseconds) (will be deprecated)", OFFSET(min_seg_duration), AV_OPT_TYPE_INT, { .i64 = 5000000 }, 0, INT_MAX, E },
1768 #endif
1769     { "seg_duration", "segment duration (in seconds, fractional value can be set)", OFFSET(seg_duration), AV_OPT_TYPE_DURATION, { .i64 = 5000000 }, 0, INT_MAX, E },
1770     { "remove_at_exit", "remove all segments when finished", OFFSET(remove_at_exit), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, E },
1771     { "use_template", "Use SegmentTemplate instead of SegmentList", OFFSET(use_template), AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1, E },
1772     { "use_timeline", "Use SegmentTimeline in SegmentTemplate", OFFSET(use_timeline), AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1, E },
1773     { "single_file", "Store all segments in one file, accessed using byte ranges", OFFSET(single_file), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, E },
1774     { "single_file_name", "DASH-templated name to be used for baseURL. Implies storing all segments in one file, accessed using byte ranges", OFFSET(single_file_name), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, E },
1775     { "init_seg_name", "DASH-templated name to used for the initialization segment", OFFSET(init_seg_name), AV_OPT_TYPE_STRING, {.str = "init-stream$RepresentationID$.$ext$"}, 0, 0, E },
1776     { "media_seg_name", "DASH-templated name to used for the media segments", OFFSET(media_seg_name), AV_OPT_TYPE_STRING, {.str = "chunk-stream$RepresentationID$-$Number%05d$.$ext$"}, 0, 0, E },
1777     { "utc_timing_url", "URL of the page that will return the UTC timestamp in ISO format", OFFSET(utc_timing_url), AV_OPT_TYPE_STRING, { 0 }, 0, 0, E },
1778     { "method", "set the HTTP method", OFFSET(method), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, E },
1779     { "http_user_agent", "override User-Agent field in HTTP header", OFFSET(user_agent), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, E},
1780     { "http_persistent", "Use persistent HTTP connections", OFFSET(http_persistent), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, E },
1781     { "hls_playlist", "Generate HLS playlist files(master.m3u8, media_%d.m3u8)", OFFSET(hls_playlist), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, E },
1782     { "streaming", "Enable/Disable streaming mode of output. Each frame will be moof fragment", OFFSET(streaming), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, E },
1783     { "timeout", "set timeout for socket I/O operations", OFFSET(timeout), AV_OPT_TYPE_DURATION, { .i64 = -1 }, -1, INT_MAX, .flags = E },
1784     { "index_correction", "Enable/Disable segment index correction logic", OFFSET(index_correction), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, E },
1785     { "format_options","set list of options for the container format (mp4/webm) used for dash", OFFSET(format_options_str), AV_OPT_TYPE_STRING, {.str = NULL},  0, 0, E},
1786     { "dash_segment_type", "set dash segment files type", OFFSET(segment_type_option), AV_OPT_TYPE_INT, {.i64 = SEGMENT_TYPE_AUTO }, 0, SEGMENT_TYPE_NB - 1, E, "segment_type"},
1787     { "auto", "select segment file format based on codec", 0, AV_OPT_TYPE_CONST, {.i64 = SEGMENT_TYPE_AUTO }, 0, UINT_MAX,   E, "segment_type"},
1788     { "mp4", "make segment file in ISOBMFF format", 0, AV_OPT_TYPE_CONST, {.i64 = SEGMENT_TYPE_MP4 }, 0, UINT_MAX,   E, "segment_type"},
1789     { "webm", "make segment file in WebM format", 0, AV_OPT_TYPE_CONST, {.i64 = SEGMENT_TYPE_WEBM }, 0, UINT_MAX,   E, "segment_type"},
1790     { "ignore_io_errors", "Ignore IO errors during open and write. Useful for long-duration runs with network output", OFFSET(ignore_io_errors), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, E },
1791     { "lhls", "Enable Low-latency HLS(Experimental). Adds #EXT-X-PREFETCH tag with current segment's URI", OFFSET(lhls), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, E },
1792     { NULL },
1793 };
1794
1795 static const AVClass dash_class = {
1796     .class_name = "dash muxer",
1797     .item_name  = av_default_item_name,
1798     .option     = options,
1799     .version    = LIBAVUTIL_VERSION_INT,
1800 };
1801
1802 AVOutputFormat ff_dash_muxer = {
1803     .name           = "dash",
1804     .long_name      = NULL_IF_CONFIG_SMALL("DASH Muxer"),
1805     .extensions     = "mpd",
1806     .priv_data_size = sizeof(DASHContext),
1807     .audio_codec    = AV_CODEC_ID_AAC,
1808     .video_codec    = AV_CODEC_ID_H264,
1809     .flags          = AVFMT_GLOBALHEADER | AVFMT_NOFILE | AVFMT_TS_NEGATIVE,
1810     .init           = dash_init,
1811     .write_header   = dash_write_header,
1812     .write_packet   = dash_write_packet,
1813     .write_trailer  = dash_write_trailer,
1814     .deinit         = dash_free,
1815     .check_bitstream = dash_check_bitstream,
1816     .priv_class     = &dash_class,
1817 };