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