falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
87405 Commits
32 Branches
743MB
Tree: c0fae3ff90
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'c0fae3ff90'
${ noResults }
FFmpeg/libavformat/dashenc.c

1131 lines
41KB
Raw Blame History 

  1. /*

  2.  * MPEG-DASH ISO BMFF segmenter

  3.  * Copyright (c) 2014 Martin Storsjo

  4.  *

  5.  * This file is part of FFmpeg.

  6.  *

  7.  * FFmpeg is free software; you can redistribute it and/or

  8.  * modify it under the terms of the GNU Lesser General Public

  9.  * License as published by the Free Software Foundation; either

  10.  * version 2.1 of the License, or (at your option) any later version.

  11.  *

  12.  * FFmpeg is distributed in the hope that it will be useful,

  13.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  14.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

  15.  * Lesser General Public License for more details.

  16.  *

  17.  * You should have received a copy of the GNU Lesser General Public

  18.  * License along with FFmpeg; if not, write to the Free Software

  19.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

  20.  */

  21. 

  22. #include "config.h"

  23. #if HAVE_UNISTD_H

  24. #include <unistd.h>

  25. #endif

  26. 

  27. #include "libavutil/avassert.h"

  28. #include "libavutil/avutil.h"

  29. #include "libavutil/avstring.h"

  30. #include "libavutil/intreadwrite.h"

  31. #include "libavutil/mathematics.h"

  32. #include "libavutil/opt.h"

  33. #include "libavutil/rational.h"

  34. #include "libavutil/time_internal.h"

  35. 

  36. #include "avc.h"

  37. #include "avformat.h"

  38. #include "avio_internal.h"

  39. #include "internal.h"

  40. #include "isom.h"

  41. #include "os_support.h"

  42. #include "url.h"

  43. #include "dash.h"

  44. 

  45. typedef struct Segment {

  46.     char file[1024];

  47.     int64_t start_pos;

  48.     int range_length, index_length;

  49.     int64_t time;

  50.     int duration;

  51.     int n;

  52. } Segment;

  53. 

  54. typedef struct AdaptationSet {

  55.     char id[10];

  56.     enum AVMediaType media_type;

  57. } AdaptationSet;

  58. 

  59. typedef struct OutputStream {

  60.     AVFormatContext *ctx;

  61.     int ctx_inited, as_idx;

  62.     uint8_t iobuf[32768];

  63.     AVIOContext *out;

  64.     int packets_written;

  65.     char initfile[1024];

  66.     int64_t init_start_pos;

  67.     int init_range_length;

  68.     int nb_segments, segments_size, segment_index;

  69.     Segment **segments;

  70.     int64_t first_pts, start_pts, max_pts;

  71.     int64_t last_dts;

  72.     int bit_rate;

  73.     char bandwidth_str[64];

  74. 

  75.     char codec_str[100];

  76. } OutputStream;

  77. 

  78. typedef struct DASHContext {

  79.     const AVClass *class;  /* Class for private options. */

  80.     char *adaptation_sets;

  81.     AdaptationSet *as;

  82.     int nb_as;

  83.     int window_size;

  84.     int extra_window_size;

  85.     int min_seg_duration;

  86.     int remove_at_exit;

  87.     int use_template;

  88.     int use_timeline;

  89.     int single_file;

  90.     OutputStream *streams;

  91.     int has_video;

  92.     int64_t last_duration;

  93.     int64_t total_duration;

  94.     char availability_start_time[100];

  95.     char dirname[1024];

  96.     const char *single_file_name;

  97.     const char *init_seg_name;

  98.     const char *media_seg_name;

  99.     AVRational min_frame_rate, max_frame_rate;

  100.     int ambiguous_frame_rate;

  101.     const char *utc_timing_url;

  102. } DASHContext;

  103. 

  104. static int dash_write(void *opaque, uint8_t *buf, int buf_size)

  105. {

  106.     OutputStream *os = opaque;

  107.     if (os->out)

  108.         avio_write(os->out, buf, buf_size);

  109.     return buf_size;

  110. }

  111. 

  112. // RFC 6381

  113. static void set_codec_str(AVFormatContext *s, AVCodecParameters *par,

  114.                           char *str, int size)

  115. {

  116.     const AVCodecTag *tags[2] = { NULL, NULL };

  117.     uint32_t tag;

  118.     if (par->codec_type == AVMEDIA_TYPE_VIDEO)

  119.         tags[0] = ff_codec_movvideo_tags;

  120.     else if (par->codec_type == AVMEDIA_TYPE_AUDIO)

  121.         tags[0] = ff_codec_movaudio_tags;

  122.     else

  123.         return;

  124. 

  125.     tag = av_codec_get_tag(tags, par->codec_id);

  126.     if (!tag)

  127.         return;

  128.     if (size < 5)

  129.         return;

  130. 

  131.     AV_WL32(str, tag);

  132.     str[4] = '\0';

  133.     if (!strcmp(str, "mp4a") || !strcmp(str, "mp4v")) {

  134.         uint32_t oti;

  135.         tags[0] = ff_mp4_obj_type;

  136.         oti = av_codec_get_tag(tags, par->codec_id);

  137.         if (oti)

  138.             av_strlcatf(str, size, ".%02"PRIx32, oti);

  139.         else

  140.             return;

  141. 

  142.         if (tag == MKTAG('m', 'p', '4', 'a')) {

  143.             if (par->extradata_size >= 2) {

  144.                 int aot = par->extradata[0] >> 3;

  145.                 if (aot == 31)

  146.                     aot = ((AV_RB16(par->extradata) >> 5) & 0x3f) + 32;

  147.                 av_strlcatf(str, size, ".%d", aot);

  148.             }

  149.         } else if (tag == MKTAG('m', 'p', '4', 'v')) {

  150.             // Unimplemented, should output ProfileLevelIndication as a decimal number

  151.             av_log(s, AV_LOG_WARNING, "Incomplete RFC 6381 codec string for mp4v\n");

  152.         }

  153.     } else if (!strcmp(str, "avc1")) {

  154.         uint8_t *tmpbuf = NULL;

  155.         uint8_t *extradata = par->extradata;

  156.         int extradata_size = par->extradata_size;

  157.         if (!extradata_size)

  158.             return;

  159.         if (extradata[0] != 1) {

  160.             AVIOContext *pb;

  161.             if (avio_open_dyn_buf(&pb) < 0)

  162.                 return;

  163.             if (ff_isom_write_avcc(pb, extradata, extradata_size) < 0) {

  164.                 ffio_free_dyn_buf(&pb);

  165.                 return;

  166.             }

  167.             extradata_size = avio_close_dyn_buf(pb, &extradata);

  168.             tmpbuf = extradata;

  169.         }

  170. 

  171.         if (extradata_size >= 4)

  172.             av_strlcatf(str, size, ".%02x%02x%02x",

  173.                         extradata[1], extradata[2], extradata[3]);

  174.         av_free(tmpbuf);

  175.     }

  176. }

  177. 

  178. static void dash_free(AVFormatContext *s)

  179. {

  180.     DASHContext *c = s->priv_data;

  181.     int i, j;

  182. 

  183.     if (c->as) {

  184.         av_freep(&c->as);

  185.         c->nb_as = 0;

  186.     }

  187. 

  188.     if (!c->streams)

  189.         return;

  190.     for (i = 0; i < s->nb_streams; i++) {

  191.         OutputStream *os = &c->streams[i];

  192.         if (os->ctx && os->ctx_inited)

  193.             av_write_trailer(os->ctx);

  194.         if (os->ctx && os->ctx->pb)

  195.             av_free(os->ctx->pb);

  196.         ff_format_io_close(s, &os->out);

  197.         if (os->ctx)

  198.             avformat_free_context(os->ctx);

  199.         for (j = 0; j < os->nb_segments; j++)

  200.             av_free(os->segments[j]);

  201.         av_free(os->segments);

  202.     }

  203.     av_freep(&c->streams);

  204. }

  205. 

  206. static void output_segment_list(OutputStream *os, AVIOContext *out, DASHContext *c)

  207. {

  208.     int i, start_index = 0, start_number = 1;

  209.     if (c->window_size) {

  210.         start_index  = FFMAX(os->nb_segments   - c->window_size, 0);

  211.         start_number = FFMAX(os->segment_index - c->window_size, 1);

  212.     }

  213. 

  214.     if (c->use_template) {

  215.         int timescale = c->use_timeline ? os->ctx->streams[0]->time_base.den : AV_TIME_BASE;

  216.         avio_printf(out, "\t\t\t\t<SegmentTemplate timescale=\"%d\" ", timescale);

  217.         if (!c->use_timeline)

  218.             avio_printf(out, "duration=\"%"PRId64"\" ", c->last_duration);

  219.         avio_printf(out, "initialization=\"%s\" media=\"%s\" startNumber=\"%d\">\n", c->init_seg_name, c->media_seg_name, c->use_timeline ? start_number : 1);

  220.         if (c->use_timeline) {

  221.             int64_t cur_time = 0;

  222.             avio_printf(out, "\t\t\t\t\t<SegmentTimeline>\n");

  223.             for (i = start_index; i < os->nb_segments; ) {

  224.                 Segment *seg = os->segments[i];

  225.                 int repeat = 0;

  226.                 avio_printf(out, "\t\t\t\t\t\t<S ");

  227.                 if (i == start_index || seg->time != cur_time) {

  228.                     cur_time = seg->time;

  229.                     avio_printf(out, "t=\"%"PRId64"\" ", seg->time);

  230.                 }

  231.                 avio_printf(out, "d=\"%d\" ", seg->duration);

  232.                 while (i + repeat + 1 < os->nb_segments &&

  233.                        os->segments[i + repeat + 1]->duration == seg->duration &&

  234.                        os->segments[i + repeat + 1]->time == os->segments[i + repeat]->time + os->segments[i + repeat]->duration)

  235.                     repeat++;

  236.                 if (repeat > 0)

  237.                     avio_printf(out, "r=\"%d\" ", repeat);

  238.                 avio_printf(out, "/>\n");

  239.                 i += 1 + repeat;

  240.                 cur_time += (1 + repeat) * seg->duration;

  241.             }

  242.             avio_printf(out, "\t\t\t\t\t</SegmentTimeline>\n");

  243.         }

  244.         avio_printf(out, "\t\t\t\t</SegmentTemplate>\n");

  245.     } else if (c->single_file) {

  246.         avio_printf(out, "\t\t\t\t<BaseURL>%s</BaseURL>\n", os->initfile);

  247.         avio_printf(out, "\t\t\t\t<SegmentList timescale=\"%d\" duration=\"%"PRId64"\" startNumber=\"%d\">\n", AV_TIME_BASE, c->last_duration, start_number);

  248.         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);

  249.         for (i = start_index; i < os->nb_segments; i++) {

  250.             Segment *seg = os->segments[i];

  251.             avio_printf(out, "\t\t\t\t\t<SegmentURL mediaRange=\"%"PRId64"-%"PRId64"\" ", seg->start_pos, seg->start_pos + seg->range_length - 1);

  252.             if (seg->index_length)

  253.                 avio_printf(out, "indexRange=\"%"PRId64"-%"PRId64"\" ", seg->start_pos, seg->start_pos + seg->index_length - 1);

  254.             avio_printf(out, "/>\n");

  255.         }

  256.         avio_printf(out, "\t\t\t\t</SegmentList>\n");

  257.     } else {

  258.         avio_printf(out, "\t\t\t\t<SegmentList timescale=\"%d\" duration=\"%"PRId64"\" startNumber=\"%d\">\n", AV_TIME_BASE, c->last_duration, start_number);

  259.         avio_printf(out, "\t\t\t\t\t<Initialization sourceURL=\"%s\" />\n", os->initfile);

  260.         for (i = start_index; i < os->nb_segments; i++) {

  261.             Segment *seg = os->segments[i];

  262.             avio_printf(out, "\t\t\t\t\t<SegmentURL media=\"%s\" />\n", seg->file);

  263.         }

  264.         avio_printf(out, "\t\t\t\t</SegmentList>\n");

  265.     }

  266. }

  267. 

  268. static char *xmlescape(const char *str) {

  269.     int outlen = strlen(str)*3/2 + 6;

  270.     char *out = av_realloc(NULL, outlen + 1);

  271.     int pos = 0;

  272.     if (!out)

  273.         return NULL;

  274.     for (; *str; str++) {

  275.         if (pos + 6 > outlen) {

  276.             char *tmp;

  277.             outlen = 2 * outlen + 6;

  278.             tmp = av_realloc(out, outlen + 1);

  279.             if (!tmp) {

  280.                 av_free(out);

  281.                 return NULL;

  282.             }

  283.             out = tmp;

  284.         }

  285.         if (*str == '&') {

  286.             memcpy(&out[pos], "&amp;", 5);

  287.             pos += 5;

  288.         } else if (*str == '<') {

  289.             memcpy(&out[pos], "&lt;", 4);

  290.             pos += 4;

  291.         } else if (*str == '>') {

  292.             memcpy(&out[pos], "&gt;", 4);

  293.             pos += 4;

  294.         } else if (*str == '\'') {

  295.             memcpy(&out[pos], "&apos;", 6);

  296.             pos += 6;

  297.         } else if (*str == '\"') {

  298.             memcpy(&out[pos], "&quot;", 6);

  299.             pos += 6;

  300.         } else {

  301.             out[pos++] = *str;

  302.         }

  303.     }

  304.     out[pos] = '\0';

  305.     return out;

  306. }

  307. 

  308. static void write_time(AVIOContext *out, int64_t time)

  309. {

  310.     int seconds = time / AV_TIME_BASE;

  311.     int fractions = time % AV_TIME_BASE;

  312.     int minutes = seconds / 60;

  313.     int hours = minutes / 60;

  314.     seconds %= 60;

  315.     minutes %= 60;

  316.     avio_printf(out, "PT");

  317.     if (hours)

  318.         avio_printf(out, "%dH", hours);

  319.     if (hours || minutes)

  320.         avio_printf(out, "%dM", minutes);

  321.     avio_printf(out, "%d.%dS", seconds, fractions / (AV_TIME_BASE / 10));

  322. }

  323. 

  324. static void format_date_now(char *buf, int size)

  325. {

  326.     time_t t = time(NULL);

  327.     struct tm *ptm, tmbuf;

  328.     ptm = gmtime_r(&t, &tmbuf);

  329.     if (ptm) {

  330.         if (!strftime(buf, size, "%Y-%m-%dT%H:%M:%SZ", ptm))

  331.             buf[0] = '\0';

  332.     }

  333. }

  334. 

  335. static int write_adaptation_set(AVFormatContext *s, AVIOContext *out, int as_index)

  336. {

  337.     DASHContext *c = s->priv_data;

  338.     AdaptationSet *as = &c->as[as_index];

  339.     int i;

  340. 

  341.     avio_printf(out, "\t\t<AdaptationSet id=\"%s\" contentType=\"%s\" segmentAlignment=\"true\" bitstreamSwitching=\"true\"",

  342.                 as->id, as->media_type == AVMEDIA_TYPE_VIDEO ? "video" : "audio");

  343.     if (as->media_type == AVMEDIA_TYPE_VIDEO && c->max_frame_rate.num && !c->ambiguous_frame_rate)

  344.         avio_printf(out, " %s=\"%d/%d\"", (av_cmp_q(c->min_frame_rate, c->max_frame_rate) < 0) ? "maxFrameRate" : "frameRate", c->max_frame_rate.num, c->max_frame_rate.den);

  345.     avio_printf(out, ">\n");

  346. 

  347.     for (i = 0; i < s->nb_streams; i++) {

  348.         OutputStream *os = &c->streams[i];

  349. 

  350.         if (os->as_idx - 1 != as_index)

  351.             continue;

  352. 

  353.         if (as->media_type == AVMEDIA_TYPE_VIDEO) {

  354.             AVStream *st = s->streams[i];

  355.             avio_printf(out, "\t\t\t<Representation id=\"%d\" mimeType=\"video/mp4\" codecs=\"%s\"%s width=\"%d\" height=\"%d\"",

  356.                 i, os->codec_str, os->bandwidth_str, s->streams[i]->codecpar->width, s->streams[i]->codecpar->height);

  357.             if (st->avg_frame_rate.num)

  358.                 avio_printf(out, " frameRate=\"%d/%d\"", st->avg_frame_rate.num, st->avg_frame_rate.den);

  359.             avio_printf(out, ">\n");

  360.         } else {

  361.             avio_printf(out, "\t\t\t<Representation id=\"%d\" mimeType=\"audio/mp4\" codecs=\"%s\"%s audioSamplingRate=\"%d\">\n",

  362.                 i, os->codec_str, os->bandwidth_str, s->streams[i]->codecpar->sample_rate);

  363.             avio_printf(out, "\t\t\t\t<AudioChannelConfiguration schemeIdUri=\"urn:mpeg:dash:23003:3:audio_channel_configuration:2011\" value=\"%d\" />\n",

  364.                 s->streams[i]->codecpar->channels);

  365.         }

  366.         output_segment_list(os, out, c);

  367.         avio_printf(out, "\t\t\t</Representation>\n");

  368.     }

  369.     avio_printf(out, "\t\t</AdaptationSet>\n");

  370. 

  371.     return 0;

  372. }

  373. 

  374. static int add_adaptation_set(AVFormatContext *s, AdaptationSet **as, enum AVMediaType type)

  375. {

  376.     DASHContext *c = s->priv_data;

  377. 

  378.     void *mem = av_realloc(c->as, sizeof(*c->as) * (c->nb_as + 1));

  379.     if (!mem)

  380.         return AVERROR(ENOMEM);

  381.     c->as = mem;

  382.     ++c->nb_as;

  383. 

  384.     *as = &c->as[c->nb_as - 1];

  385.     memset(*as, 0, sizeof(**as));

  386.     (*as)->media_type = type;

  387. 

  388.     return 0;

  389. }

  390. 

  391. static int adaptation_set_add_stream(AVFormatContext *s, int as_idx, int i)

  392. {

  393.     DASHContext *c = s->priv_data;

  394.     AdaptationSet *as = &c->as[as_idx - 1];

  395.     OutputStream *os = &c->streams[i];

  396. 

  397.     if (as->media_type != s->streams[i]->codecpar->codec_type) {

  398.         av_log(s, AV_LOG_ERROR, "Codec type of stream %d doesn't match AdaptationSet's media type\n", i);

  399.         return AVERROR(EINVAL);

  400.     } else if (os->as_idx) {

  401.         av_log(s, AV_LOG_ERROR, "Stream %d is already assigned to an AdaptationSet\n", i);

  402.         return AVERROR(EINVAL);

  403.     }

  404.     os->as_idx = as_idx;

  405. 

  406.     return 0;

  407. }

  408. 

  409. static int parse_adaptation_sets(AVFormatContext *s)

  410. {

  411.     DASHContext *c = s->priv_data;

  412.     const char *p = c->adaptation_sets;

  413.     enum { new_set, parse_id, parsing_streams } state;

  414.     AdaptationSet *as;

  415.     int i, n, ret;

  416.     enum AVMediaType types[] = { AVMEDIA_TYPE_VIDEO, AVMEDIA_TYPE_AUDIO, AVMEDIA_TYPE_UNKNOWN };

  417. 

  418.     // default: one AdaptationSet for each media type

  419.     if (!p) {

  420.         for (n = 0; types[n] != AVMEDIA_TYPE_UNKNOWN; n++) {

  421.             int as_idx = 0;

  422. 

  423.             for (i = 0; i < s->nb_streams; i++) {

  424.                 if (s->streams[i]->codecpar->codec_type != types[n])

  425.                     continue;

  426. 

  427.                 if (!as_idx) {

  428.                     if ((ret = add_adaptation_set(s, &as, types[n])) < 0)

  429.                         return ret;

  430.                     as_idx = c->nb_as;

  431. 

  432.                     snprintf(as->id, sizeof(as->id), "%d", i);

  433.                 }

  434.                 c->streams[i].as_idx = as_idx;

  435.             }

  436.         }

  437.         goto end;

  438.     }

  439. 

  440.     // syntax id=0,streams=0,1,2 id=1,streams=3,4 and so on

  441.     state = new_set;

  442.     while (*p) {

  443.         if (*p == ' ') {

  444.             p++;

  445.             continue;

  446.         } else if (state == new_set && av_strstart(p, "id=", &p)) {

  447. 

  448.             if ((ret = add_adaptation_set(s, &as, AVMEDIA_TYPE_UNKNOWN)) < 0)

  449.                 return ret;

  450. 

  451.             n = strcspn(p, ",");

  452.             snprintf(as->id, sizeof(as->id), "%.*s", n, p);

  453. 

  454.             p += n;

  455.             if (*p)

  456.                 p++;

  457.             state = parse_id;

  458.         } else if (state == parse_id && av_strstart(p, "streams=", &p)) {

  459.             state = parsing_streams;

  460.         } else if (state == parsing_streams) {

  461.             AdaptationSet *as = &c->as[c->nb_as - 1];

  462.             char idx_str[8], *end_str;

  463. 

  464.             n = strcspn(p, " ,");

  465.             snprintf(idx_str, sizeof(idx_str), "%.*s", n, p);

  466.             p += n;

  467. 

  468.             // if value is "a" or "v", map all streams of that type

  469.             if (as->media_type == AVMEDIA_TYPE_UNKNOWN && (idx_str[0] == 'v' || idx_str[0] == 'a')) {

  470.                 enum AVMediaType type = (idx_str[0] == 'v') ? AVMEDIA_TYPE_VIDEO : AVMEDIA_TYPE_AUDIO;

  471.                 av_log(s, AV_LOG_DEBUG, "Map all streams of type %s\n", idx_str);

  472. 

  473.                 for (i = 0; i < s->nb_streams; i++) {

  474.                     if (s->streams[i]->codecpar->codec_type != type)

  475.                         continue;

  476. 

  477.                     as->media_type = s->streams[i]->codecpar->codec_type;

  478. 

  479.                     if ((ret = adaptation_set_add_stream(s, c->nb_as, i)) < 0)

  480.                         return ret;

  481.                 }

  482.             } else { // select single stream

  483.                 i = strtol(idx_str, &end_str, 10);

  484.                 if (idx_str == end_str || i < 0 || i >= s->nb_streams) {

  485.                     av_log(s, AV_LOG_ERROR, "Selected stream \"%s\" not found!\n", idx_str);

  486.                     return AVERROR(EINVAL);

  487.                 }

  488.                 av_log(s, AV_LOG_DEBUG, "Map stream %d\n", i);

  489. 

  490.                 if (as->media_type == AVMEDIA_TYPE_UNKNOWN) {

  491.                     as->media_type = s->streams[i]->codecpar->codec_type;

  492.                 }

  493. 

  494.                 if ((ret = adaptation_set_add_stream(s, c->nb_as, i)) < 0)

  495.                     return ret;

  496.             }

  497. 

  498.             if (*p == ' ')

  499.                 state = new_set;

  500.             if (*p)

  501.                 p++;

  502.         } else {

  503.             return AVERROR(EINVAL);

  504.         }

  505.     }

  506. 

  507. end:

  508.     // check for unassigned streams

  509.     for (i = 0; i < s->nb_streams; i++) {

  510.         OutputStream *os = &c->streams[i];

  511.         if (!os->as_idx) {

  512.             av_log(s, AV_LOG_ERROR, "Stream %d is not mapped to an AdaptationSet\n", i);

  513.             return AVERROR(EINVAL);

  514.         }

  515.     }

  516.     return 0;

  517. }

  518. 

  519. static int write_manifest(AVFormatContext *s, int final)

  520. {

  521.     DASHContext *c = s->priv_data;

  522.     AVIOContext *out;

  523.     char temp_filename[1024];

  524.     int ret, i;

  525.     const char *proto = avio_find_protocol_name(s->filename);

  526.     int use_rename = proto && !strcmp(proto, "file");

  527.     static unsigned int warned_non_file = 0;

  528.     AVDictionaryEntry *title = av_dict_get(s->metadata, "title", NULL, 0);

  529. 

  530.     if (!use_rename && !warned_non_file++)

  531.         av_log(s, AV_LOG_ERROR, "Cannot use rename on non file protocol, this may lead to races and temporary partial files\n");

  532. 

  533.     snprintf(temp_filename, sizeof(temp_filename), use_rename ? "%s.tmp" : "%s", s->filename);

  534.     ret = s->io_open(s, &out, temp_filename, AVIO_FLAG_WRITE, NULL);

  535.     if (ret < 0) {

  536.         av_log(s, AV_LOG_ERROR, "Unable to open %s for writing\n", temp_filename);

  537.         return ret;

  538.     }

  539.     avio_printf(out, "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n");

  540.     avio_printf(out, "<MPD xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"\n"

  541.                 "\txmlns=\"urn:mpeg:dash:schema:mpd:2011\"\n"

  542.                 "\txmlns:xlink=\"http://www.w3.org/1999/xlink\"\n"

  543.                 "\txsi:schemaLocation=\"urn:mpeg:DASH:schema:MPD:2011 http://standards.iso.org/ittf/PubliclyAvailableStandards/MPEG-DASH_schema_files/DASH-MPD.xsd\"\n"

  544.                 "\tprofiles=\"urn:mpeg:dash:profile:isoff-live:2011\"\n"

  545.                 "\ttype=\"%s\"\n", final ? "static" : "dynamic");

  546.     if (final) {

  547.         avio_printf(out, "\tmediaPresentationDuration=\"");

  548.         write_time(out, c->total_duration);

  549.         avio_printf(out, "\"\n");

  550.     } else {

  551.         int64_t update_period = c->last_duration / AV_TIME_BASE;

  552.         char now_str[100];

  553.         if (c->use_template && !c->use_timeline)

  554.             update_period = 500;

  555.         avio_printf(out, "\tminimumUpdatePeriod=\"PT%"PRId64"S\"\n", update_period);

  556.         avio_printf(out, "\tsuggestedPresentationDelay=\"PT%"PRId64"S\"\n", c->last_duration / AV_TIME_BASE);

  557.         if (!c->availability_start_time[0] && s->nb_streams > 0 && c->streams[0].nb_segments > 0) {

  558.             format_date_now(c->availability_start_time, sizeof(c->availability_start_time));

  559.         }

  560.         if (c->availability_start_time[0])

  561.             avio_printf(out, "\tavailabilityStartTime=\"%s\"\n", c->availability_start_time);

  562.         format_date_now(now_str, sizeof(now_str));

  563.         if (now_str[0])

  564.             avio_printf(out, "\tpublishTime=\"%s\"\n", now_str);

  565.         if (c->window_size && c->use_template) {

  566.             avio_printf(out, "\ttimeShiftBufferDepth=\"");

  567.             write_time(out, c->last_duration * c->window_size);

  568.             avio_printf(out, "\"\n");

  569.         }

  570.     }

  571.     avio_printf(out, "\tminBufferTime=\"");

  572.     write_time(out, c->last_duration * 2);

  573.     avio_printf(out, "\">\n");

  574.     avio_printf(out, "\t<ProgramInformation>\n");

  575.     if (title) {

  576.         char *escaped = xmlescape(title->value);

  577.         avio_printf(out, "\t\t<Title>%s</Title>\n", escaped);

  578.         av_free(escaped);

  579.     }

  580.     avio_printf(out, "\t</ProgramInformation>\n");

  581.     if (c->utc_timing_url)

  582.         avio_printf(out, "\t<UTCTiming schemeIdUri=\"urn:mpeg:dash:utc:http-xsdate:2014\" value=\"%s\"/>\n", c->utc_timing_url);

  583. 

  584.     if (c->window_size && s->nb_streams > 0 && c->streams[0].nb_segments > 0 && !c->use_template) {

  585.         OutputStream *os = &c->streams[0];

  586.         int start_index = FFMAX(os->nb_segments - c->window_size, 0);

  587.         int64_t start_time = av_rescale_q(os->segments[start_index]->time, s->streams[0]->time_base, AV_TIME_BASE_Q);

  588.         avio_printf(out, "\t<Period id=\"0\" start=\"");

  589.         write_time(out, start_time);

  590.         avio_printf(out, "\">\n");

  591.     } else {

  592.         avio_printf(out, "\t<Period id=\"0\" start=\"PT0.0S\">\n");

  593.     }

  594. 

  595.     for (i = 0; i < c->nb_as; i++) {

  596.         if ((ret = write_adaptation_set(s, out, i)) < 0)

  597.             return ret;

  598.     }

  599.     avio_printf(out, "\t</Period>\n");

  600.     avio_printf(out, "</MPD>\n");

  601.     avio_flush(out);

  602.     ff_format_io_close(s, &out);

  603. 

  604.     if (use_rename)

  605.         return avpriv_io_move(temp_filename, s->filename);

  606. 

  607.     return 0;

  608. }

  609. 

  610. static int dash_init(AVFormatContext *s)

  611. {

  612.     DASHContext *c = s->priv_data;

  613.     int ret = 0, i;

  614.     AVOutputFormat *oformat;

  615.     char *ptr;

  616.     char basename[1024];

  617. 

  618.     if (c->single_file_name)

  619.         c->single_file = 1;

  620.     if (c->single_file)

  621.         c->use_template = 0;

  622.     c->ambiguous_frame_rate = 0;

  623. 

  624.     av_strlcpy(c->dirname, s->filename, sizeof(c->dirname));

  625.     ptr = strrchr(c->dirname, '/');

  626.     if (ptr) {

  627.         av_strlcpy(basename, &ptr[1], sizeof(basename));

  628.         ptr[1] = '\0';

  629.     } else {

  630.         c->dirname[0] = '\0';

  631.         av_strlcpy(basename, s->filename, sizeof(basename));

  632.     }

  633. 

  634.     ptr = strrchr(basename, '.');

  635.     if (ptr)

  636.         *ptr = '\0';

  637. 

  638.     oformat = av_guess_format("mp4", NULL, NULL);

  639.     if (!oformat)

  640.         return AVERROR_MUXER_NOT_FOUND;

  641. 

  642.     c->streams = av_mallocz(sizeof(*c->streams) * s->nb_streams);

  643.     if (!c->streams)

  644.         return AVERROR(ENOMEM);

  645. 

  646.     if ((ret = parse_adaptation_sets(s)) < 0)

  647.         return ret;

  648. 

  649.     for (i = 0; i < s->nb_streams; i++) {

  650.         OutputStream *os = &c->streams[i];

  651.         AVFormatContext *ctx;

  652.         AVStream *st;

  653.         AVDictionary *opts = NULL;

  654.         char filename[1024];

  655. 

  656.         os->bit_rate = s->streams[i]->codecpar->bit_rate;

  657.         if (os->bit_rate) {

  658.             snprintf(os->bandwidth_str, sizeof(os->bandwidth_str),

  659.                      " bandwidth=\"%d\"", os->bit_rate);

  660.         } else {

  661.             int level = s->strict_std_compliance >= FF_COMPLIANCE_STRICT ?

  662.                         AV_LOG_ERROR : AV_LOG_WARNING;

  663.             av_log(s, level, "No bit rate set for stream %d\n", i);

  664.             if (s->strict_std_compliance >= FF_COMPLIANCE_STRICT)

  665.                 return AVERROR(EINVAL);

  666.         }

  667. 

  668.         ctx = avformat_alloc_context();

  669.         if (!ctx)

  670.             return AVERROR(ENOMEM);

  671.         os->ctx = ctx;

  672.         ctx->oformat = oformat;

  673.         ctx->interrupt_callback = s->interrupt_callback;

  674.         ctx->opaque             = s->opaque;

  675.         ctx->io_close           = s->io_close;

  676.         ctx->io_open            = s->io_open;

  677. 

  678.         if (!(st = avformat_new_stream(ctx, NULL)))

  679.             return AVERROR(ENOMEM);

  680.         avcodec_parameters_copy(st->codecpar, s->streams[i]->codecpar);

  681.         st->sample_aspect_ratio = s->streams[i]->sample_aspect_ratio;

  682.         st->time_base = s->streams[i]->time_base;

  683.         ctx->avoid_negative_ts = s->avoid_negative_ts;

  684.         ctx->flags = s->flags;

  685. 

  686.         ctx->pb = avio_alloc_context(os->iobuf, sizeof(os->iobuf), AVIO_FLAG_WRITE, os, NULL, dash_write, NULL);

  687.         if (!ctx->pb)

  688.             return AVERROR(ENOMEM);

  689. 

  690.         if (c->single_file) {

  691.             if (c->single_file_name)

  692.                 ff_dash_fill_tmpl_params(os->initfile, sizeof(os->initfile), c->single_file_name, i, 0, os->bit_rate, 0);

  693.             else

  694.                 snprintf(os->initfile, sizeof(os->initfile), "%s-stream%d.m4s", basename, i);

  695.         } else {

  696.             ff_dash_fill_tmpl_params(os->initfile, sizeof(os->initfile), c->init_seg_name, i, 0, os->bit_rate, 0);

  697.         }

  698.         snprintf(filename, sizeof(filename), "%s%s", c->dirname, os->initfile);

  699.         ret = s->io_open(s, &os->out, filename, AVIO_FLAG_WRITE, NULL);

  700.         if (ret < 0)

  701.             return ret;

  702.         os->init_start_pos = 0;

  703. 

  704.         av_dict_set(&opts, "movflags", "frag_custom+dash+delay_moov", 0);

  705.         if ((ret = avformat_init_output(ctx, &opts)) < 0)

  706.             return ret;

  707.         os->ctx_inited = 1;

  708.         avio_flush(ctx->pb);

  709.         av_dict_free(&opts);

  710. 

  711.         av_log(s, AV_LOG_VERBOSE, "Representation %d init segment will be written to: %s\n", i, filename);

  712. 

  713.         s->streams[i]->time_base = st->time_base;

  714.         // If the muxer wants to shift timestamps, request to have them shifted

  715.         // already before being handed to this muxer, so we don't have mismatches

  716.         // between the MPD and the actual segments.

  717.         s->avoid_negative_ts = ctx->avoid_negative_ts;

  718.         if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {

  719.             AVRational avg_frame_rate = s->streams[i]->avg_frame_rate;

  720.             if (avg_frame_rate.num > 0) {

  721.                 if (av_cmp_q(avg_frame_rate, c->min_frame_rate) < 0)

  722.                     c->min_frame_rate = avg_frame_rate;

  723.                 if (av_cmp_q(c->max_frame_rate, avg_frame_rate) < 0)

  724.                     c->max_frame_rate = avg_frame_rate;

  725.             } else {

  726.                 c->ambiguous_frame_rate = 1;

  727.             }

  728.             c->has_video = 1;

  729.         }

  730. 

  731.         set_codec_str(s, st->codecpar, os->codec_str, sizeof(os->codec_str));

  732.         os->first_pts = AV_NOPTS_VALUE;

  733.         os->max_pts = AV_NOPTS_VALUE;

  734.         os->last_dts = AV_NOPTS_VALUE;

  735.         os->segment_index = 1;

  736.     }

  737. 

  738.     if (!c->has_video && c->min_seg_duration <= 0) {

  739.         av_log(s, AV_LOG_WARNING, "no video stream and no min seg duration set\n");

  740.         return AVERROR(EINVAL);

  741.     }

  742.     return 0;

  743. }

  744. 

  745. static int dash_write_header(AVFormatContext *s)

  746. {

  747.     DASHContext *c = s->priv_data;

  748.     int i, ret;

  749.     for (i = 0; i < s->nb_streams; i++) {

  750.         OutputStream *os = &c->streams[i];

  751.         if ((ret = avformat_write_header(os->ctx, NULL)) < 0) {

  752.             dash_free(s);

  753.             return ret;

  754.         }

  755.     }

  756.     ret = write_manifest(s, 0);

  757.     if (!ret)

  758.         av_log(s, AV_LOG_VERBOSE, "Manifest written to: %s\n", s->filename);

  759.     return ret;

  760. }

  761. 

  762. static int add_segment(OutputStream *os, const char *file,

  763.                        int64_t time, int duration,

  764.                        int64_t start_pos, int64_t range_length,

  765.                        int64_t index_length)

  766. {

  767.     int err;

  768.     Segment *seg;

  769.     if (os->nb_segments >= os->segments_size) {

  770.         os->segments_size = (os->segments_size + 1) * 2;

  771.         if ((err = av_reallocp(&os->segments, sizeof(*os->segments) *

  772.                                os->segments_size)) < 0) {

  773.             os->segments_size = 0;

  774.             os->nb_segments = 0;

  775.             return err;

  776.         }

  777.     }

  778.     seg = av_mallocz(sizeof(*seg));

  779.     if (!seg)

  780.         return AVERROR(ENOMEM);

  781.     av_strlcpy(seg->file, file, sizeof(seg->file));

  782.     seg->time = time;

  783.     seg->duration = duration;

  784.     if (seg->time < 0) { // If pts<0, it is expected to be cut away with an edit list

  785.         seg->duration += seg->time;

  786.         seg->time = 0;

  787.     }

  788.     seg->start_pos = start_pos;

  789.     seg->range_length = range_length;

  790.     seg->index_length = index_length;

  791.     os->segments[os->nb_segments++] = seg;

  792.     os->segment_index++;

  793.     return 0;

  794. }

  795. 

  796. static void write_styp(AVIOContext *pb)

  797. {

  798.     avio_wb32(pb, 24);

  799.     ffio_wfourcc(pb, "styp");

  800.     ffio_wfourcc(pb, "msdh");

  801.     avio_wb32(pb, 0); /* minor */

  802.     ffio_wfourcc(pb, "msdh");

  803.     ffio_wfourcc(pb, "msix");

  804. }

  805. 

  806. static void find_index_range(AVFormatContext *s, const char *full_path,

  807.                              int64_t pos, int *index_length)

  808. {

  809.     uint8_t buf[8];

  810.     AVIOContext *pb;

  811.     int ret;

  812. 

  813.     ret = s->io_open(s, &pb, full_path, AVIO_FLAG_READ, NULL);

  814.     if (ret < 0)

  815.         return;

  816.     if (avio_seek(pb, pos, SEEK_SET) != pos) {

  817.         ff_format_io_close(s, &pb);

  818.         return;

  819.     }

  820.     ret = avio_read(pb, buf, 8);

  821.     ff_format_io_close(s, &pb);

  822.     if (ret < 8)

  823.         return;

  824.     if (AV_RL32(&buf[4]) != MKTAG('s', 'i', 'd', 'x'))

  825.         return;

  826.     *index_length = AV_RB32(&buf[0]);

  827. }

  828. 

  829. static int update_stream_extradata(AVFormatContext *s, OutputStream *os,

  830.                                    AVCodecParameters *par)

  831. {

  832.     uint8_t *extradata;

  833. 

  834.     if (os->ctx->streams[0]->codecpar->extradata_size || !par->extradata_size)

  835.         return 0;

  836. 

  837.     extradata = av_malloc(par->extradata_size);

  838. 

  839.     if (!extradata)

  840.         return AVERROR(ENOMEM);

  841. 

  842.     memcpy(extradata, par->extradata, par->extradata_size);

  843. 

  844.     os->ctx->streams[0]->codecpar->extradata = extradata;

  845.     os->ctx->streams[0]->codecpar->extradata_size = par->extradata_size;

  846. 

  847.     set_codec_str(s, par, os->codec_str, sizeof(os->codec_str));

  848. 

  849.     return 0;

  850. }

  851. 

  852. static int dash_flush(AVFormatContext *s, int final, int stream)

  853. {

  854.     DASHContext *c = s->priv_data;

  855.     int i, ret = 0;

  856. 

  857.     const char *proto = avio_find_protocol_name(s->filename);

  858.     int use_rename = proto && !strcmp(proto, "file");

  859. 

  860.     int cur_flush_segment_index = 0;

  861.     if (stream >= 0)

  862.         cur_flush_segment_index = c->streams[stream].segment_index;

  863. 

  864.     for (i = 0; i < s->nb_streams; i++) {

  865.         OutputStream *os = &c->streams[i];

  866.         char filename[1024] = "", full_path[1024], temp_path[1024];

  867.         int64_t start_pos;

  868.         int range_length, index_length = 0;

  869. 

  870.         if (!os->packets_written)

  871.             continue;

  872. 

  873.         // Flush the single stream that got a keyframe right now.

  874.         // Flush all audio streams as well, in sync with video keyframes,

  875.         // but not the other video streams.

  876.         if (stream >= 0 && i != stream) {

  877.             if (s->streams[i]->codecpar->codec_type != AVMEDIA_TYPE_AUDIO)

  878.                 continue;

  879.             // Make sure we don't flush audio streams multiple times, when

  880.             // all video streams are flushed one at a time.

  881.             if (c->has_video && os->segment_index > cur_flush_segment_index)

  882.                 continue;

  883.         }

  884. 

  885.         if (!os->init_range_length) {

  886.             av_write_frame(os->ctx, NULL);

  887.             os->init_range_length = avio_tell(os->ctx->pb);

  888.             if (!c->single_file)

  889.                 ff_format_io_close(s, &os->out);

  890.         }

  891. 

  892.         start_pos = avio_tell(os->ctx->pb);

  893. 

  894.         if (!c->single_file) {

  895.             ff_dash_fill_tmpl_params(filename, sizeof(filename), c->media_seg_name, i, os->segment_index, os->bit_rate, os->start_pts);

  896.             snprintf(full_path, sizeof(full_path), "%s%s", c->dirname, filename);

  897.             snprintf(temp_path, sizeof(temp_path), use_rename ? "%s.tmp" : "%s", full_path);

  898.             ret = s->io_open(s, &os->out, temp_path, AVIO_FLAG_WRITE, NULL);

  899.             if (ret < 0)

  900.                 break;

  901.             write_styp(os->ctx->pb);

  902.         } else {

  903.             snprintf(full_path, sizeof(full_path), "%s%s", c->dirname, os->initfile);

  904.         }

  905. 

  906.         av_write_frame(os->ctx, NULL);

  907.         avio_flush(os->ctx->pb);

  908.         os->packets_written = 0;

  909. 

  910.         range_length = avio_tell(os->ctx->pb) - start_pos;

  911.         if (c->single_file) {

  912.             find_index_range(s, full_path, start_pos, &index_length);

  913.         } else {

  914.             ff_format_io_close(s, &os->out);

  915. 

  916.             if (use_rename) {

  917.                 ret = avpriv_io_move(temp_path, full_path);

  918.                 if (ret < 0)

  919.                     break;

  920.             }

  921.         }

  922. 

  923.         if (!os->bit_rate) {

  924.             // calculate average bitrate of first segment

  925.             int64_t bitrate = (int64_t) range_length * 8 * AV_TIME_BASE / (os->max_pts - os->start_pts);

  926.             if (bitrate >= 0) {

  927.                 os->bit_rate = bitrate;

  928.                 snprintf(os->bandwidth_str, sizeof(os->bandwidth_str),

  929.                      " bandwidth=\"%d\"", os->bit_rate);

  930.             }

  931.         }

  932.         add_segment(os, filename, os->start_pts, os->max_pts - os->start_pts, start_pos, range_length, index_length);

  933.         av_log(s, AV_LOG_VERBOSE, "Representation %d media segment %d written to: %s\n", i, os->segment_index, full_path);

  934.     }

  935. 

  936.     if (c->window_size || (final && c->remove_at_exit)) {

  937.         for (i = 0; i < s->nb_streams; i++) {

  938.             OutputStream *os = &c->streams[i];

  939.             int j;

  940.             int remove = os->nb_segments - c->window_size - c->extra_window_size;

  941.             if (final && c->remove_at_exit)

  942.                 remove = os->nb_segments;

  943.             if (remove > 0) {

  944.                 for (j = 0; j < remove; j++) {

  945.                     char filename[1024];

  946.                     snprintf(filename, sizeof(filename), "%s%s", c->dirname, os->segments[j]->file);

  947.                     unlink(filename);

  948.                     av_free(os->segments[j]);

  949.                 }

  950.                 os->nb_segments -= remove;

  951.                 memmove(os->segments, os->segments + remove, os->nb_segments * sizeof(*os->segments));

  952.             }

  953.         }

  954.     }

  955. 

  956.     if (ret >= 0)

  957.         ret = write_manifest(s, final);

  958.     return ret;

  959. }

  960. 

  961. static int dash_write_packet(AVFormatContext *s, AVPacket *pkt)

  962. {

  963.     DASHContext *c = s->priv_data;

  964.     AVStream *st = s->streams[pkt->stream_index];

  965.     OutputStream *os = &c->streams[pkt->stream_index];

  966.     int ret;

  967. 

  968.     ret = update_stream_extradata(s, os, st->codecpar);

  969.     if (ret < 0)

  970.         return ret;

  971. 

  972.     // Fill in a heuristic guess of the packet duration, if none is available.

  973.     // The mp4 muxer will do something similar (for the last packet in a fragment)

  974.     // if nothing is set (setting it for the other packets doesn't hurt).

  975.     // By setting a nonzero duration here, we can be sure that the mp4 muxer won't

  976.     // invoke its heuristic (this doesn't have to be identical to that algorithm),

  977.     // so that we know the exact timestamps of fragments.

  978.     if (!pkt->duration && os->last_dts != AV_NOPTS_VALUE)

  979.         pkt->duration = pkt->dts - os->last_dts;

  980.     os->last_dts = pkt->dts;

  981. 

  982.     // If forcing the stream to start at 0, the mp4 muxer will set the start

  983.     // timestamps to 0. Do the same here, to avoid mismatches in duration/timestamps.

  984.     if (os->first_pts == AV_NOPTS_VALUE &&

  985.         s->avoid_negative_ts == AVFMT_AVOID_NEG_TS_MAKE_ZERO) {

  986.         pkt->pts -= pkt->dts;

  987.         pkt->dts  = 0;

  988.     }

  989. 

  990.     if (os->first_pts == AV_NOPTS_VALUE)

  991.         os->first_pts = pkt->pts;

  992. 

  993.     if ((!c->has_video || st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) &&

  994.         pkt->flags & AV_PKT_FLAG_KEY && os->packets_written &&

  995.         av_compare_ts(pkt->pts - os->start_pts, st->time_base,

  996.                       c->min_seg_duration, AV_TIME_BASE_Q) >= 0) {

  997.         int64_t prev_duration = c->last_duration;

  998. 

  999.         c->last_duration = av_rescale_q(pkt->pts - os->start_pts,

  1000.                                         st->time_base,

  1001.                                         AV_TIME_BASE_Q);

  1002.         c->total_duration = av_rescale_q(pkt->pts - os->first_pts,

  1003.                                          st->time_base,

  1004.                                          AV_TIME_BASE_Q);

  1005. 

  1006.         if ((!c->use_timeline || !c->use_template) && prev_duration) {

  1007.             if (c->last_duration < prev_duration*9/10 ||

  1008.                 c->last_duration > prev_duration*11/10) {

  1009.                 av_log(s, AV_LOG_WARNING,

  1010.                        "Segment durations differ too much, enable use_timeline "

  1011.                        "and use_template, or keep a stricter keyframe interval\n");

  1012.             }

  1013.         }

  1014. 

  1015.         if ((ret = dash_flush(s, 0, pkt->stream_index)) < 0)

  1016.             return ret;

  1017.     }

  1018. 

  1019.     if (!os->packets_written) {

  1020.         // If we wrote a previous segment, adjust the start time of the segment

  1021.         // to the end of the previous one (which is the same as the mp4 muxer

  1022.         // does). This avoids gaps in the timeline.

  1023.         if (os->max_pts != AV_NOPTS_VALUE)

  1024.             os->start_pts = os->max_pts;

  1025.         else

  1026.             os->start_pts = pkt->pts;

  1027.     }

  1028.     if (os->max_pts == AV_NOPTS_VALUE)

  1029.         os->max_pts = pkt->pts + pkt->duration;

  1030.     else

  1031.         os->max_pts = FFMAX(os->max_pts, pkt->pts + pkt->duration);

  1032.     os->packets_written++;

  1033.     return ff_write_chained(os->ctx, 0, pkt, s, 0);

  1034. }

  1035. 

  1036. static int dash_write_trailer(AVFormatContext *s)

  1037. {

  1038.     DASHContext *c = s->priv_data;

  1039. 

  1040.     if (s->nb_streams > 0) {

  1041.         OutputStream *os = &c->streams[0];

  1042.         // If no segments have been written so far, try to do a crude

  1043.         // guess of the segment duration

  1044.         if (!c->last_duration)

  1045.             c->last_duration = av_rescale_q(os->max_pts - os->start_pts,

  1046.                                             s->streams[0]->time_base,

  1047.                                             AV_TIME_BASE_Q);

  1048.         c->total_duration = av_rescale_q(os->max_pts - os->first_pts,

  1049.                                          s->streams[0]->time_base,

  1050.                                          AV_TIME_BASE_Q);

  1051.     }

  1052.     dash_flush(s, 1, -1);

  1053. 

  1054.     if (c->remove_at_exit) {

  1055.         char filename[1024];

  1056.         int i;

  1057.         for (i = 0; i < s->nb_streams; i++) {

  1058.             OutputStream *os = &c->streams[i];

  1059.             snprintf(filename, sizeof(filename), "%s%s", c->dirname, os->initfile);

  1060.             unlink(filename);

  1061.         }

  1062.         unlink(s->filename);

  1063.     }

  1064. 

  1065.     return 0;

  1066. }

  1067. 

  1068. static int dash_check_bitstream(struct AVFormatContext *s, const AVPacket *avpkt)

  1069. {

  1070.     DASHContext *c = s->priv_data;

  1071.     OutputStream *os = &c->streams[avpkt->stream_index];

  1072.     AVFormatContext *oc = os->ctx;

  1073.     if (oc->oformat->check_bitstream) {

  1074.         int ret;

  1075.         AVPacket pkt = *avpkt;

  1076.         pkt.stream_index = 0;

  1077.         ret = oc->oformat->check_bitstream(oc, &pkt);

  1078.         if (ret == 1) {

  1079.             AVStream *st = s->streams[avpkt->stream_index];

  1080.             AVStream *ost = oc->streams[0];

  1081.             st->internal->bsfcs = ost->internal->bsfcs;

  1082.             st->internal->nb_bsfcs = ost->internal->nb_bsfcs;

  1083.             ost->internal->bsfcs = NULL;

  1084.             ost->internal->nb_bsfcs = 0;

  1085.         }

  1086.         return ret;

  1087.     }

  1088.     return 1;

  1089. }

  1090. 

  1091. #define OFFSET(x) offsetof(DASHContext, x)

  1092. #define E AV_OPT_FLAG_ENCODING_PARAM

  1093. static const AVOption options[] = {

  1094.     { "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 },

  1095.     { "window_size", "number of segments kept in the manifest", OFFSET(window_size), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, E },

  1096.     { "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 },

  1097.     { "min_seg_duration", "minimum segment duration (in microseconds)", OFFSET(min_seg_duration), AV_OPT_TYPE_INT64, { .i64 = 5000000 }, 0, INT_MAX, E },

  1098.     { "remove_at_exit", "remove all segments when finished", OFFSET(remove_at_exit), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, E },

  1099.     { "use_template", "Use SegmentTemplate instead of SegmentList", OFFSET(use_template), AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1, E },

  1100.     { "use_timeline", "Use SegmentTimeline in SegmentTemplate", OFFSET(use_timeline), AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1, E },

  1101.     { "single_file", "Store all segments in one file, accessed using byte ranges", OFFSET(single_file), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, E },

  1102.     { "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 },

  1103.     { "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 },

  1104.     { "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 },

  1105.     { "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 },

  1106.     { NULL },

  1107. };

  1108. 

  1109. static const AVClass dash_class = {

  1110.     .class_name = "dash muxer",

  1111.     .item_name  = av_default_item_name,

  1112.     .option     = options,

  1113.     .version    = LIBAVUTIL_VERSION_INT,

  1114. };

  1115. 

  1116. AVOutputFormat ff_dash_muxer = {

  1117.     .name           = "dash",

  1118.     .long_name      = NULL_IF_CONFIG_SMALL("DASH Muxer"),

  1119.     .priv_data_size = sizeof(DASHContext),

  1120.     .audio_codec    = AV_CODEC_ID_AAC,

  1121.     .video_codec    = AV_CODEC_ID_H264,

  1122.     .flags          = AVFMT_GLOBALHEADER | AVFMT_NOFILE | AVFMT_TS_NEGATIVE,

  1123.     .init           = dash_init,

  1124.     .write_header   = dash_write_header,

  1125.     .write_packet   = dash_write_packet,

  1126.     .write_trailer  = dash_write_trailer,

  1127.     .deinit         = dash_free,

  1128.     .check_bitstream = dash_check_bitstream,

  1129.     .priv_class     = &dash_class,

  1130. };