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.
92503 Commits
32 Branches
637MB
Tree: d290bb0c54
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'd290bb0c54'
${ noResults }
FFmpeg/libavformat/dashenc.c

1689 lines
63KB
Raw Blame History 

  1. /*

  2.  * MPEG-DASH ISO BMFF segmenter

  3.  * Copyright (c) 2014 Martin Storsjo

  4.  * Copyright (c) 2018 Akamai Technologies, Inc.

  5.  *

  6.  * This file is part of FFmpeg.

  7.  *

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

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

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

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

  12.  *

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

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

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

  16.  * Lesser General Public License for more details.

  17.  *

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

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

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

  21.  */

  22. 

  23. #include "config.h"

  24. #if HAVE_UNISTD_H

  25. #include <unistd.h>

  26. #endif

  27. 

  28. #include "libavutil/avassert.h"

  29. #include "libavutil/avutil.h"

  30. #include "libavutil/avstring.h"

  31. #include "libavutil/intreadwrite.h"

  32. #include "libavutil/mathematics.h"

  33. #include "libavutil/opt.h"

  34. #include "libavutil/rational.h"

  35. #include "libavutil/time_internal.h"

  36. 

  37. #include "avc.h"

  38. #include "avformat.h"

  39. #include "avio_internal.h"

  40. #include "hlsplaylist.h"

  41. #if CONFIG_HTTP_PROTOCOL

  42. #include "http.h"

  43. #endif

  44. #include "internal.h"

  45. #include "isom.h"

  46. #include "os_support.h"

  47. #include "url.h"

  48. #include "vpcc.h"

  49. #include "dash.h"

  50. 

  51. typedef enum {

  52.     SEGMENT_TYPE_AUTO = 0,

  53.     SEGMENT_TYPE_MP4,

  54.     SEGMENT_TYPE_WEBM,

  55.     SEGMENT_TYPE_NB

  56. } SegmentType;

  57. 

  58. typedef struct Segment {

  59.     char file[1024];

  60.     int64_t start_pos;

  61.     int range_length, index_length;

  62.     int64_t time;

  63.     int duration;

  64.     int n;

  65. } Segment;

  66. 

  67. typedef struct AdaptationSet {

  68.     char id[10];

  69.     enum AVMediaType media_type;

  70.     AVDictionary *metadata;

  71.     AVRational min_frame_rate, max_frame_rate;

  72.     int ambiguous_frame_rate;

  73. } AdaptationSet;

  74. 

  75. typedef struct OutputStream {

  76.     AVFormatContext *ctx;

  77.     int ctx_inited, as_idx;

  78.     AVIOContext *out;

  79.     int packets_written;

  80.     char initfile[1024];

  81.     int64_t init_start_pos, pos;

  82.     int init_range_length;

  83.     int nb_segments, segments_size, segment_index;

  84.     Segment **segments;

  85.     int64_t first_pts, start_pts, max_pts;

  86.     int64_t last_dts, last_pts;

  87.     int bit_rate;

  88.     SegmentType segment_type;  /* segment type selected for this particular stream */

  89.     const char *format_name;

  90.     const char *single_file_name;  /* file names selected for this particular stream */

  91.     const char *init_seg_name;

  92.     const char *media_seg_name;

  93. 

  94.     char codec_str[100];

  95.     int written_len;

  96.     char filename[1024];

  97.     char full_path[1024];

  98.     char temp_path[1024];

  99.     double availability_time_offset;

  100.     int total_pkt_size;

  101.     int muxer_overhead;

  102. } OutputStream;

  103. 

  104. typedef struct DASHContext {

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

  106.     char *adaptation_sets;

  107.     AdaptationSet *as;

  108.     int nb_as;

  109.     int window_size;

  110.     int extra_window_size;

  111. #if FF_API_DASH_MIN_SEG_DURATION

  112.     int min_seg_duration;

  113. #endif

  114.     int64_t seg_duration;

  115.     int remove_at_exit;

  116.     int use_template;

  117.     int use_timeline;

  118.     int single_file;

  119.     OutputStream *streams;

  120.     int has_video;

  121.     int64_t last_duration;

  122.     int64_t total_duration;

  123.     char availability_start_time[100];

  124.     char dirname[1024];

  125.     const char *single_file_name;  /* file names as specified in options */

  126.     const char *init_seg_name;

  127.     const char *media_seg_name;

  128.     const char *utc_timing_url;

  129.     const char *method;

  130.     const char *user_agent;

  131.     int hls_playlist;

  132.     int http_persistent;

  133.     int master_playlist_created;

  134.     AVIOContext *mpd_out;

  135.     AVIOContext *m3u8_out;

  136.     int streaming;

  137.     int64_t timeout;

  138.     int index_correction;

  139.     char *format_options_str;

  140.     SegmentType segment_type_option;  /* segment type as specified in options */

  141. } DASHContext;

  142. 

  143. static struct codec_string {

  144.     int id;

  145.     const char *str;

  146. } codecs[] = {

  147.     { AV_CODEC_ID_VP8, "vp8" },

  148.     { AV_CODEC_ID_VP9, "vp9" },

  149.     { AV_CODEC_ID_VORBIS, "vorbis" },

  150.     { AV_CODEC_ID_OPUS, "opus" },

  151.     { AV_CODEC_ID_FLAC, "flac" },

  152.     { 0, NULL }

  153. };

  154. 

  155. static struct format_string {

  156.     SegmentType segment_type;

  157.     const char *str;

  158. } formats[] = {

  159.     { SEGMENT_TYPE_AUTO, "auto" },

  160.     { SEGMENT_TYPE_MP4, "mp4" },

  161.     { SEGMENT_TYPE_WEBM, "webm" },

  162.     { 0, NULL }

  163. };

  164. 

  165. static int dashenc_io_open(AVFormatContext *s, AVIOContext **pb, char *filename,

  166.                            AVDictionary **options) {

  167.     DASHContext *c = s->priv_data;

  168.     int http_base_proto = filename ? ff_is_http_proto(filename) : 0;

  169.     int err = AVERROR_MUXER_NOT_FOUND;

  170.     if (!*pb || !http_base_proto || !c->http_persistent) {

  171.         err = s->io_open(s, pb, filename, AVIO_FLAG_WRITE, options);

  172. #if CONFIG_HTTP_PROTOCOL

  173.     } else {

  174.         URLContext *http_url_context = ffio_geturlcontext(*pb);

  175.         av_assert0(http_url_context);

  176.         err = ff_http_do_new_request(http_url_context, filename);

  177. #endif

  178.     }

  179.     return err;

  180. }

  181. 

  182. static void dashenc_io_close(AVFormatContext *s, AVIOContext **pb, char *filename) {

  183.     DASHContext *c = s->priv_data;

  184.     int http_base_proto = filename ? ff_is_http_proto(filename) : 0;

  185. 

  186.     if (!http_base_proto || !c->http_persistent) {

  187.         ff_format_io_close(s, pb);

  188. #if CONFIG_HTTP_PROTOCOL

  189.     } else {

  190.         URLContext *http_url_context = ffio_geturlcontext(*pb);

  191.         av_assert0(http_url_context);

  192.         avio_flush(*pb);

  193.         ffurl_shutdown(http_url_context, AVIO_FLAG_WRITE);

  194. #endif

  195.     }

  196. }

  197. 

  198. static const char *get_format_str(SegmentType segment_type) {

  199.     int i;

  200.     for (i = 0; i < SEGMENT_TYPE_NB; i++)

  201.         if (formats[i].segment_type == segment_type)

  202.             return formats[i].str;

  203.     return NULL;

  204. }

  205. 

  206. static inline SegmentType select_segment_type(SegmentType segment_type, enum AVCodecID codec_id)

  207. {

  208.     if (segment_type == SEGMENT_TYPE_AUTO) {

  209.         if (codec_id == AV_CODEC_ID_OPUS || codec_id == AV_CODEC_ID_VORBIS ||

  210.             codec_id == AV_CODEC_ID_VP8 || codec_id == AV_CODEC_ID_VP9) {

  211.             segment_type = SEGMENT_TYPE_WEBM;

  212.         } else {

  213.             segment_type = SEGMENT_TYPE_MP4;

  214.         }

  215.     }

  216. 

  217.     return segment_type;

  218. }

  219. 

  220. static int init_segment_types(AVFormatContext *s)

  221. {

  222.     DASHContext *c = s->priv_data;

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

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

  225.         SegmentType segment_type = select_segment_type(

  226.             c->segment_type_option, s->streams[i]->codecpar->codec_id);

  227.         os->segment_type = segment_type;

  228.         os->format_name = get_format_str(segment_type);

  229.         if (!os->format_name) {

  230.             av_log(s, AV_LOG_ERROR, "Could not select DASH segment type for stream %d\n", i);

  231.             return AVERROR_MUXER_NOT_FOUND;

  232.         }

  233.     }

  234. 

  235.     return 0;

  236. }

  237. 

  238. static int check_file_extension(const char *filename, const char *extension) {

  239.     char *dot;

  240.     if (!filename || !extension)

  241.         return -1;

  242.     dot = strrchr(filename, '.');

  243.     if (dot && !strcmp(dot + 1, extension))

  244.         return 0;

  245.     return -1;

  246. }

  247. 

  248. static void set_vp9_codec_str(AVFormatContext *s, AVCodecParameters *par,

  249.                               AVRational *frame_rate, char *str, int size) {

  250.     VPCC vpcc;

  251.     int ret = ff_isom_get_vpcc_features(s, par, frame_rate, &vpcc);

  252.     if (ret == 0) {

  253.         av_strlcatf(str, size, "vp09.%02d.%02d.%02d",

  254.                     vpcc.profile, vpcc.level, vpcc.bitdepth);

  255.     } else {

  256.         // Default to just vp9 in case of error while finding out profile or level

  257.         av_log(s, AV_LOG_WARNING, "Could not find VP9 profile and/or level\n");

  258.         av_strlcpy(str, "vp9", size);

  259.     }

  260.     return;

  261. }

  262. 

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

  264.                           AVRational *frame_rate, char *str, int size)

  265. {

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

  267.     uint32_t tag;

  268.     int i;

  269. 

  270.     // common Webm codecs are not part of RFC 6381

  271.     for (i = 0; codecs[i].id; i++)

  272.         if (codecs[i].id == par->codec_id) {

  273.             if (codecs[i].id == AV_CODEC_ID_VP9) {

  274.                 set_vp9_codec_str(s, par, frame_rate, str, size);

  275.             } else {

  276.                 av_strlcpy(str, codecs[i].str, size);

  277.             }

  278.             return;

  279.         }

  280. 

  281.     // for codecs part of RFC 6381

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

  283.         tags[0] = ff_codec_movvideo_tags;

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

  285.         tags[0] = ff_codec_movaudio_tags;

  286.     else

  287.         return;

  288. 

  289.     tag = par->codec_tag;

  290.     if (!tag)

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

  292.     if (!tag)

  293.         return;

  294.     if (size < 5)

  295.         return;

  296. 

  297.     AV_WL32(str, tag);

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

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

  300.         uint32_t oti;

  301.         tags[0] = ff_mp4_obj_type;

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

  303.         if (oti)

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

  305.         else

  306.             return;

  307. 

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

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

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

  311.                 if (aot == 31)

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

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

  314.             }

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

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

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

  318.         }

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

  320.         uint8_t *tmpbuf = NULL;

  321.         uint8_t *extradata = par->extradata;

  322.         int extradata_size = par->extradata_size;

  323.         if (!extradata_size)

  324.             return;

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

  326.             AVIOContext *pb;

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

  328.                 return;

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

  330.                 ffio_free_dyn_buf(&pb);

  331.                 return;

  332.             }

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

  334.             tmpbuf = extradata;

  335.         }

  336. 

  337.         if (extradata_size >= 4)

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

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

  340.         av_free(tmpbuf);

  341.     }

  342. }

  343. 

  344. static int flush_dynbuf(OutputStream *os, int *range_length)

  345. {

  346.     uint8_t *buffer;

  347. 

  348.     if (!os->ctx->pb) {

  349.         return AVERROR(EINVAL);

  350.     }

  351. 

  352.     // flush

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

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

  355. 

  356.     // write out to file

  357.     *range_length = avio_close_dyn_buf(os->ctx->pb, &buffer);

  358.     os->ctx->pb = NULL;

  359.     avio_write(os->out, buffer + os->written_len, *range_length - os->written_len);

  360.     os->written_len = 0;

  361.     av_free(buffer);

  362. 

  363.     // re-open buffer

  364.     return avio_open_dyn_buf(&os->ctx->pb);

  365. }

  366. 

  367. static void set_http_options(AVDictionary **options, DASHContext *c)

  368. {

  369.     if (c->method)

  370.         av_dict_set(options, "method", c->method, 0);

  371.     if (c->user_agent)

  372.         av_dict_set(options, "user_agent", c->user_agent, 0);

  373.     if (c->http_persistent)

  374.         av_dict_set_int(options, "multiple_requests", 1, 0);

  375.     if (c->timeout >= 0)

  376.         av_dict_set_int(options, "timeout", c->timeout, 0);

  377. }

  378. 

  379. static void get_hls_playlist_name(char *playlist_name, int string_size,

  380.                                   const char *base_url, int id) {

  381.     if (base_url)

  382.         snprintf(playlist_name, string_size, "%smedia_%d.m3u8", base_url, id);

  383.     else

  384.         snprintf(playlist_name, string_size, "media_%d.m3u8", id);

  385. }

  386. 

  387. static int flush_init_segment(AVFormatContext *s, OutputStream *os)

  388. {

  389.     DASHContext *c = s->priv_data;

  390.     int ret, range_length;

  391. 

  392.     ret = flush_dynbuf(os, &range_length);

  393.     if (ret < 0)

  394.         return ret;

  395. 

  396.     os->pos = os->init_range_length = range_length;

  397.     if (!c->single_file) {

  398.         char filename[1024];

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

  400.         dashenc_io_close(s, &os->out, filename);

  401.     }

  402.     return 0;

  403. }

  404. 

  405. static void dash_free(AVFormatContext *s)

  406. {

  407.     DASHContext *c = s->priv_data;

  408.     int i, j;

  409. 

  410.     if (c->as) {

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

  412.             av_dict_free(&c->as[i].metadata);

  413.         av_freep(&c->as);

  414.         c->nb_as = 0;

  415.     }

  416. 

  417.     if (!c->streams)

  418.         return;

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

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

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

  422.             av_write_trailer(os->ctx);

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

  424.             ffio_free_dyn_buf(&os->ctx->pb);

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

  426.         if (os->ctx)

  427.             avformat_free_context(os->ctx);

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

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

  430.         av_free(os->segments);

  431.         av_freep(&os->single_file_name);

  432.         av_freep(&os->init_seg_name);

  433.         av_freep(&os->media_seg_name);

  434.     }

  435.     av_freep(&c->streams);

  436. 

  437.     ff_format_io_close(s, &c->mpd_out);

  438.     ff_format_io_close(s, &c->m3u8_out);

  439. }

  440. 

  441. static void output_segment_list(OutputStream *os, AVIOContext *out, AVFormatContext *s,

  442.                                 int representation_id, int final)

  443. {

  444.     DASHContext *c = s->priv_data;

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

  446.     if (c->window_size) {

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

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

  449.     }

  450. 

  451.     if (c->use_template) {

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

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

  454.         if (!c->use_timeline) {

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

  456.             if (c->streaming && os->availability_time_offset)

  457.                 avio_printf(out, "availabilityTimeOffset=\"%.3f\" ",

  458.                             os->availability_time_offset);

  459.         }

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

  461.         if (c->use_timeline) {

  462.             int64_t cur_time = 0;

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

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

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

  466.                 int repeat = 0;

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

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

  469.                     cur_time = seg->time;

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

  471.                 }

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

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

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

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

  476.                     repeat++;

  477.                 if (repeat > 0)

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

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

  480.                 i += 1 + repeat;

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

  482.             }

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

  484.         }

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

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

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

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

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

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

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

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

  493.             if (seg->index_length)

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

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

  496.         }

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

  498.     } else {

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

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

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

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

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

  504.         }

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

  506.     }

  507.     if (c->hls_playlist && start_index < os->nb_segments)

  508.     {

  509.         int timescale = os->ctx->streams[0]->time_base.den;

  510.         char temp_filename_hls[1024];

  511.         char filename_hls[1024];

  512.         AVDictionary *http_opts = NULL;

  513.         int target_duration = 0;

  514.         int ret = 0;

  515.         const char *proto = avio_find_protocol_name(c->dirname);

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

  517. 

  518.         get_hls_playlist_name(filename_hls, sizeof(filename_hls),

  519.                               c->dirname, representation_id);

  520. 

  521.         snprintf(temp_filename_hls, sizeof(temp_filename_hls), use_rename ? "%s.tmp" : "%s", filename_hls);

  522. 

  523.         set_http_options(&http_opts, c);

  524.         dashenc_io_open(s, &c->m3u8_out, temp_filename_hls, &http_opts);

  525.         av_dict_free(&http_opts);

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

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

  528.             double duration = (double) seg->duration / timescale;

  529.             if (target_duration <= duration)

  530.                 target_duration = lrint(duration);

  531.         }

  532. 

  533.         ff_hls_write_playlist_header(c->m3u8_out, 6, -1, target_duration,

  534.                                      start_number, PLAYLIST_TYPE_NONE);

  535. 

  536.         ff_hls_write_init_file(c->m3u8_out, os->initfile, c->single_file,

  537.                                os->init_range_length, os->init_start_pos);

  538. 

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

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

  541.             ret = ff_hls_write_file_entry(c->m3u8_out, 0, c->single_file,

  542.                                     (double) seg->duration / timescale, 0,

  543.                                     seg->range_length, seg->start_pos, NULL,

  544.                                     c->single_file ? os->initfile : seg->file,

  545.                                     NULL);

  546.             if (ret < 0) {

  547.                 av_log(os->ctx, AV_LOG_WARNING, "ff_hls_write_file_entry get error\n");

  548.             }

  549.         }

  550. 

  551.         if (final)

  552.             ff_hls_write_end_list(c->m3u8_out);

  553. 

  554.         dashenc_io_close(s, &c->m3u8_out, temp_filename_hls);

  555. 

  556.         if (use_rename)

  557.             if (avpriv_io_move(temp_filename_hls, filename_hls) < 0) {

  558.                 av_log(os->ctx, AV_LOG_WARNING, "renaming file %s to %s failed\n\n", temp_filename_hls, filename_hls);

  559.             }

  560.     }

  561. 

  562. }

  563. 

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

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

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

  567.     int pos = 0;

  568.     if (!out)

  569.         return NULL;

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

  571.         if (pos + 6 > outlen) {

  572.             char *tmp;

  573.             outlen = 2 * outlen + 6;

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

  575.             if (!tmp) {

  576.                 av_free(out);

  577.                 return NULL;

  578.             }

  579.             out = tmp;

  580.         }

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

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

  583.             pos += 5;

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

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

  586.             pos += 4;

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

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

  589.             pos += 4;

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

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

  592.             pos += 6;

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

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

  595.             pos += 6;

  596.         } else {

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

  598.         }

  599.     }

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

  601.     return out;

  602. }

  603. 

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

  605. {

  606.     int seconds = time / AV_TIME_BASE;

  607.     int fractions = time % AV_TIME_BASE;

  608.     int minutes = seconds / 60;

  609.     int hours = minutes / 60;

  610.     seconds %= 60;

  611.     minutes %= 60;

  612.     avio_printf(out, "PT");

  613.     if (hours)

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

  615.     if (hours || minutes)

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

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

  618. }

  619. 

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

  621. {

  622.     time_t t = time(NULL);

  623.     struct tm *ptm, tmbuf;

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

  625.     if (ptm) {

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

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

  628.     }

  629. }

  630. 

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

  632.                                 int final)

  633. {

  634.     DASHContext *c = s->priv_data;

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

  636.     AVDictionaryEntry *lang, *role;

  637.     int i;

  638. 

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

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

  641.     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)

  642.         avio_printf(out, " maxFrameRate=\"%d/%d\"", as->max_frame_rate.num, as->max_frame_rate.den);

  643.     lang = av_dict_get(as->metadata, "language", NULL, 0);

  644.     if (lang)

  645.         avio_printf(out, " lang=\"%s\"", lang->value);

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

  647. 

  648.     role = av_dict_get(as->metadata, "role", NULL, 0);

  649.     if (role)

  650.         avio_printf(out, "\t\t\t<Role schemeIdUri=\"urn:mpeg:dash:role:2011\" value=\"%s\"/>\n", role->value);

  651. 

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

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

  654.         char bandwidth_str[64] = {'\0'};

  655. 

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

  657.             continue;

  658. 

  659.         if (os->bit_rate > 0)

  660.             snprintf(bandwidth_str, sizeof(bandwidth_str), " bandwidth=\"%d\"",

  661.                      os->bit_rate);

  662. 

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

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

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

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

  667.             if (st->avg_frame_rate.num)

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

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

  670.         } else {

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

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

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

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

  675.         }

  676.         output_segment_list(os, out, s, i, final);

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

  678.     }

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

  680. 

  681.     return 0;

  682. }

  683. 

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

  685. {

  686.     DASHContext *c = s->priv_data;

  687. 

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

  689.     if (!mem)

  690.         return AVERROR(ENOMEM);

  691.     c->as = mem;

  692.     ++c->nb_as;

  693. 

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

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

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

  697. 

  698.     return 0;

  699. }

  700. 

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

  702. {

  703.     DASHContext *c = s->priv_data;

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

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

  706. 

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

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

  709.         return AVERROR(EINVAL);

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

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

  712.         return AVERROR(EINVAL);

  713.     }

  714.     os->as_idx = as_idx;

  715. 

  716.     return 0;

  717. }

  718. 

  719. static int parse_adaptation_sets(AVFormatContext *s)

  720. {

  721.     DASHContext *c = s->priv_data;

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

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

  724.     AdaptationSet *as;

  725.     int i, n, ret;

  726. 

  727.     // default: one AdaptationSet for each stream

  728.     if (!p) {

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

  730.             if ((ret = add_adaptation_set(s, &as, s->streams[i]->codecpar->codec_type)) < 0)

  731.                 return ret;

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

  733. 

  734.             c->streams[i].as_idx = c->nb_as;

  735.         }

  736.         goto end;

  737.     }

  738. 

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

  740.     state = new_set;

  741.     while (*p) {

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

  743.             p++;

  744.             continue;

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

  746. 

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

  748.                 return ret;

  749. 

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

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

  752. 

  753.             p += n;

  754.             if (*p)

  755.                 p++;

  756.             state = parse_id;

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

  758.             state = parsing_streams;

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

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

  761.             char idx_str[8], *end_str;

  762. 

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

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

  765.             p += n;

  766. 

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

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

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

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

  771. 

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

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

  774.                         continue;

  775. 

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

  777. 

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

  779.                         return ret;

  780.                 }

  781.             } else { // select single stream

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

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

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

  785.                     return AVERROR(EINVAL);

  786.                 }

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

  788. 

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

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

  791.                 }

  792. 

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

  794.                     return ret;

  795.             }

  796. 

  797.             if (*p == ' ')

  798.                 state = new_set;

  799.             if (*p)

  800.                 p++;

  801.         } else {

  802.             return AVERROR(EINVAL);

  803.         }

  804.     }

  805. 

  806. end:

  807.     // check for unassigned streams

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

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

  810.         if (!os->as_idx) {

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

  812.             return AVERROR(EINVAL);

  813.         }

  814.     }

  815.     return 0;

  816. }

  817. 

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

  819. {

  820.     DASHContext *c = s->priv_data;

  821.     AVIOContext *out;

  822.     char temp_filename[1024];

  823.     int ret, i;

  824.     const char *proto = avio_find_protocol_name(s->url);

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

  826.     static unsigned int warned_non_file = 0;

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

  828.     AVDictionary *opts = NULL;

  829. 

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

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

  832. 

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

  834.     set_http_options(&opts, c);

  835.     ret = dashenc_io_open(s, &c->mpd_out, temp_filename, &opts);

  836.     av_dict_free(&opts);

  837.     if (ret < 0) {

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

  839.         return ret;

  840.     }

  841.     out = c->mpd_out;

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

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

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

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

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

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

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

  849.     if (final) {

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

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

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

  853.     } else {

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

  855.         char now_str[100];

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

  857.             update_period = 500;

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

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

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

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

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

  863.         if (now_str[0])

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

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

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

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

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

  869.         }

  870.     }

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

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

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

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

  875.     if (title) {

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

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

  878.         av_free(escaped);

  879.     }

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

  881. 

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

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

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

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

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

  887.         write_time(out, start_time);

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

  889.     } else {

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

  891.     }

  892. 

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

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

  895.             return ret;

  896.     }

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

  898. 

  899.     if (c->utc_timing_url)

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

  901. 

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

  903.     avio_flush(out);

  904.     dashenc_io_close(s, &c->mpd_out, temp_filename);

  905. 

  906.     if (use_rename) {

  907.         if ((ret = avpriv_io_move(temp_filename, s->url)) < 0)

  908.             return ret;

  909.     }

  910. 

  911.     if (c->hls_playlist && !c->master_playlist_created) {

  912.         char filename_hls[1024];

  913.         const char *audio_group = "A1";

  914.         char audio_codec_str[128] = "\0";

  915.         int is_default = 1;

  916.         int max_audio_bitrate = 0;

  917. 

  918.         if (*c->dirname)

  919.             snprintf(filename_hls, sizeof(filename_hls), "%smaster.m3u8", c->dirname);

  920.         else

  921.             snprintf(filename_hls, sizeof(filename_hls), "master.m3u8");

  922. 

  923.         snprintf(temp_filename, sizeof(temp_filename), use_rename ? "%s.tmp" : "%s", filename_hls);

  924. 

  925.         set_http_options(&opts, c);

  926.         ret = dashenc_io_open(s, &c->m3u8_out, temp_filename, &opts);

  927.         av_dict_free(&opts);

  928.         if (ret < 0) {

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

  930.             return ret;

  931.         }

  932. 

  933.         ff_hls_write_playlist_version(c->m3u8_out, 7);

  934. 

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

  936.             char playlist_file[64];

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

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

  939.             if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO)

  940.                 continue;

  941.             get_hls_playlist_name(playlist_file, sizeof(playlist_file), NULL, i);

  942.             ff_hls_write_audio_rendition(c->m3u8_out, (char *)audio_group,

  943.                                          playlist_file, i, is_default);

  944.             max_audio_bitrate = FFMAX(st->codecpar->bit_rate +

  945.                                       os->muxer_overhead, max_audio_bitrate);

  946.             if (!av_strnstr(audio_codec_str, os->codec_str, sizeof(audio_codec_str))) {

  947.                 if (strlen(audio_codec_str))

  948.                     av_strlcat(audio_codec_str, ",", sizeof(audio_codec_str));

  949.                 av_strlcat(audio_codec_str, os->codec_str, sizeof(audio_codec_str));

  950.             }

  951.             is_default = 0;

  952.         }

  953. 

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

  955.             char playlist_file[64];

  956.             char codec_str[128];

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

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

  959.             char *agroup = NULL;

  960.             char *codec_str_ptr = NULL;

  961.             int stream_bitrate = st->codecpar->bit_rate + os->muxer_overhead;

  962.             if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)

  963.                 continue;

  964.             av_strlcpy(codec_str, os->codec_str, sizeof(codec_str));

  965.             if (max_audio_bitrate) {

  966.                 agroup = (char *)audio_group;

  967.                 stream_bitrate += max_audio_bitrate;

  968.                 av_strlcat(codec_str, ",", sizeof(codec_str));

  969.                 av_strlcat(codec_str, audio_codec_str, sizeof(codec_str));

  970.             }

  971.             if (st->codecpar->codec_id != AV_CODEC_ID_HEVC) {

  972.                 codec_str_ptr = codec_str;

  973.             }

  974.             get_hls_playlist_name(playlist_file, sizeof(playlist_file), NULL, i);

  975.             ff_hls_write_stream_info(st, c->m3u8_out, stream_bitrate,

  976.                                      playlist_file, agroup,

  977.                                      codec_str_ptr, NULL);

  978.         }

  979.         dashenc_io_close(s, &c->m3u8_out, temp_filename);

  980.         if (use_rename)

  981.             if ((ret = avpriv_io_move(temp_filename, filename_hls)) < 0)

  982.                 return ret;

  983.         c->master_playlist_created = 1;

  984.     }

  985. 

  986.     return 0;

  987. }

  988. 

  989. static int dict_copy_entry(AVDictionary **dst, const AVDictionary *src, const char *key)

  990. {

  991.     AVDictionaryEntry *entry = av_dict_get(src, key, NULL, 0);

  992.     if (entry)

  993.         av_dict_set(dst, key, entry->value, AV_DICT_DONT_OVERWRITE);

  994.     return 0;

  995. }

  996. 

  997. static int dash_init(AVFormatContext *s)

  998. {

  999.     DASHContext *c = s->priv_data;

  1000.     int ret = 0, i;

  1001.     char *ptr;

  1002.     char basename[1024];

  1003. 

  1004.     if (c->single_file_name)

  1005.         c->single_file = 1;

  1006.     if (c->single_file)

  1007.         c->use_template = 0;

  1008. 

  1009. #if FF_API_DASH_MIN_SEG_DURATION

  1010.     if (c->min_seg_duration != 5000000) {

  1011.         av_log(s, AV_LOG_WARNING, "The min_seg_duration option is deprecated and will be removed. Please use the -seg_duration\n");

  1012.         c->seg_duration = c->min_seg_duration;

  1013.     }

  1014. #endif

  1015. 

  1016.     av_strlcpy(c->dirname, s->url, sizeof(c->dirname));

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

  1018.     if (ptr) {

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

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

  1021.     } else {

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

  1023.         av_strlcpy(basename, s->url, sizeof(basename));

  1024.     }

  1025. 

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

  1027.     if (ptr)

  1028.         *ptr = '\0';

  1029. 

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

  1031.     if (!c->streams)

  1032.         return AVERROR(ENOMEM);

  1033. 

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

  1035.         return ret;

  1036. 

  1037.     if ((ret = init_segment_types(s)) < 0)

  1038.         return ret;

  1039. 

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

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

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

  1043.         AVFormatContext *ctx;

  1044.         AVStream *st;

  1045.         AVDictionary *opts = NULL;

  1046.         char filename[1024];

  1047. 

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

  1049.         if (!os->bit_rate) {

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

  1051.                         AV_LOG_ERROR : AV_LOG_WARNING;

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

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

  1054.                 return AVERROR(EINVAL);

  1055.         }

  1056. 

  1057.         // copy AdaptationSet language and role from stream metadata

  1058.         dict_copy_entry(&as->metadata, s->streams[i]->metadata, "language");

  1059.         dict_copy_entry(&as->metadata, s->streams[i]->metadata, "role");

  1060. 

  1061.         ctx = avformat_alloc_context();

  1062.         if (!ctx)

  1063.             return AVERROR(ENOMEM);

  1064. 

  1065.         if (c->init_seg_name) {

  1066.             os->init_seg_name = av_strireplace(c->init_seg_name, "$ext$", os->format_name);

  1067.             if (!os->init_seg_name)

  1068.                 return AVERROR(ENOMEM);

  1069.         }

  1070.         if (c->media_seg_name) {

  1071.             os->media_seg_name = av_strireplace(c->media_seg_name, "$ext$", os->format_name);

  1072.             if (!os->media_seg_name)

  1073.                 return AVERROR(ENOMEM);

  1074.         }

  1075.         if (c->single_file_name) {

  1076.             os->single_file_name = av_strireplace(c->single_file_name, "$ext$", os->format_name);

  1077.             if (!os->single_file_name)

  1078.                 return AVERROR(ENOMEM);

  1079.         }

  1080. 

  1081.         if (os->segment_type == SEGMENT_TYPE_WEBM) {

  1082.             if ((!c->single_file && check_file_extension(os->init_seg_name, os->format_name) != 0) ||

  1083.                 (!c->single_file && check_file_extension(os->media_seg_name, os->format_name) != 0) ||

  1084.                 (c->single_file && check_file_extension(os->single_file_name, os->format_name) != 0)) {

  1085.                 av_log(s, AV_LOG_WARNING,

  1086.                        "One or many segment file names doesn't end with .webm. "

  1087.                        "Override -init_seg_name and/or -media_seg_name and/or "

  1088.                        "-single_file_name to end with the extension .webm\n");

  1089.             }

  1090.         }

  1091. 

  1092.         ctx->oformat = av_guess_format(os->format_name, NULL, NULL);

  1093.         if (!ctx->oformat)

  1094.             return AVERROR_MUXER_NOT_FOUND;

  1095.         os->ctx = ctx;

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

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

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

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

  1100.         ctx->strict_std_compliance = s->strict_std_compliance;

  1101. 

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

  1103.             return AVERROR(ENOMEM);

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

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

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

  1107.         st->avg_frame_rate = s->streams[i]->avg_frame_rate;

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

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

  1110. 

  1111.         if ((ret = avio_open_dyn_buf(&ctx->pb)) < 0)

  1112.             return ret;

  1113. 

  1114.         if (c->single_file) {

  1115.             if (os->single_file_name)

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

  1117.             else

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

  1119.         } else {

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

  1121.         }

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

  1123.         set_http_options(&opts, c);

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

  1125.         av_dict_free(&opts);

  1126.         if (ret < 0)

  1127.             return ret;

  1128.         os->init_start_pos = 0;

  1129. 

  1130.         if (c->format_options_str) {

  1131.             ret = av_dict_parse_string(&opts, c->format_options_str, "=", ":", 0);

  1132.             if (ret < 0)

  1133.                 return ret;

  1134.         }

  1135. 

  1136.         if (os->segment_type == SEGMENT_TYPE_MP4) {

  1137.             if (c->streaming)

  1138.                 av_dict_set(&opts, "movflags", "frag_every_frame+dash+delay_moov+global_sidx", 0);

  1139.             else

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

  1141.         } else {

  1142.             av_dict_set_int(&opts, "cluster_time_limit", c->seg_duration / 1000, 0);

  1143.             av_dict_set_int(&opts, "cluster_size_limit", 5 * 1024 * 1024, 0); // set a large cluster size limit

  1144.             av_dict_set_int(&opts, "dash", 1, 0);

  1145.             av_dict_set_int(&opts, "dash_track_number", i + 1, 0);

  1146.             av_dict_set_int(&opts, "live", 1, 0);

  1147.         }

  1148.         ret = avformat_init_output(ctx, &opts);

  1149.         av_dict_free(&opts);

  1150.         if (ret < 0)

  1151.             return ret;

  1152.         os->ctx_inited = 1;

  1153.         avio_flush(ctx->pb);

  1154. 

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

  1156. 

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

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

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

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

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

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

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

  1164.             if (avg_frame_rate.num > 0) {

  1165.                 if (av_cmp_q(avg_frame_rate, as->min_frame_rate) < 0)

  1166.                     as->min_frame_rate = avg_frame_rate;

  1167.                 if (av_cmp_q(as->max_frame_rate, avg_frame_rate) < 0)

  1168.                     as->max_frame_rate = avg_frame_rate;

  1169.             } else {

  1170.                 as->ambiguous_frame_rate = 1;

  1171.             }

  1172.             c->has_video = 1;

  1173.         }

  1174. 

  1175.         set_codec_str(s, st->codecpar, &st->avg_frame_rate, os->codec_str,

  1176.                       sizeof(os->codec_str));

  1177.         os->first_pts = AV_NOPTS_VALUE;

  1178.         os->max_pts = AV_NOPTS_VALUE;

  1179.         os->last_dts = AV_NOPTS_VALUE;

  1180.         os->segment_index = 1;

  1181.     }

  1182. 

  1183.     if (!c->has_video && c->seg_duration <= 0) {

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

  1185.         return AVERROR(EINVAL);

  1186.     }

  1187.     return 0;

  1188. }

  1189. 

  1190. static int dash_write_header(AVFormatContext *s)

  1191. {

  1192.     DASHContext *c = s->priv_data;

  1193.     int i, ret;

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

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

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

  1197.             return ret;

  1198. 

  1199.         // Flush init segment

  1200.         // Only for WebM segment, since for mp4 delay_moov is set and

  1201.         // the init segment is thus flushed after the first packets.

  1202.         if (os->segment_type == SEGMENT_TYPE_WEBM &&

  1203.             (ret = flush_init_segment(s, os)) < 0)

  1204.             return ret;

  1205.     }

  1206.     return ret;

  1207. }

  1208. 

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

  1210.                        int64_t time, int duration,

  1211.                        int64_t start_pos, int64_t range_length,

  1212.                        int64_t index_length, int next_exp_index)

  1213. {

  1214.     int err;

  1215.     Segment *seg;

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

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

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

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

  1220.             os->segments_size = 0;

  1221.             os->nb_segments = 0;

  1222.             return err;

  1223.         }

  1224.     }

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

  1226.     if (!seg)

  1227.         return AVERROR(ENOMEM);

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

  1229.     seg->time = time;

  1230.     seg->duration = duration;

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

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

  1233.         seg->time = 0;

  1234.     }

  1235.     seg->start_pos = start_pos;

  1236.     seg->range_length = range_length;

  1237.     seg->index_length = index_length;

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

  1239.     os->segment_index++;

  1240.     //correcting the segment index if it has fallen behind the expected value

  1241.     if (os->segment_index < next_exp_index) {

  1242.         av_log(NULL, AV_LOG_WARNING, "Correcting the segment index after file %s: current=%d corrected=%d\n",

  1243.                file, os->segment_index, next_exp_index);

  1244.         os->segment_index = next_exp_index;

  1245.     }

  1246.     return 0;

  1247. }

  1248. 

  1249. static void write_styp(AVIOContext *pb)

  1250. {

  1251.     avio_wb32(pb, 24);

  1252.     ffio_wfourcc(pb, "styp");

  1253.     ffio_wfourcc(pb, "msdh");

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

  1255.     ffio_wfourcc(pb, "msdh");

  1256.     ffio_wfourcc(pb, "msix");

  1257. }

  1258. 

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

  1260.                              int64_t pos, int *index_length)

  1261. {

  1262.     uint8_t buf[8];

  1263.     AVIOContext *pb;

  1264.     int ret;

  1265. 

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

  1267.     if (ret < 0)

  1268.         return;

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

  1270.         ff_format_io_close(s, &pb);

  1271.         return;

  1272.     }

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

  1274.     ff_format_io_close(s, &pb);

  1275.     if (ret < 8)

  1276.         return;

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

  1278.         return;

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

  1280. }

  1281. 

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

  1283.                                    AVCodecParameters *par,

  1284.                                    AVRational *frame_rate)

  1285. {

  1286.     uint8_t *extradata;

  1287. 

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

  1289.         return 0;

  1290. 

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

  1292. 

  1293.     if (!extradata)

  1294.         return AVERROR(ENOMEM);

  1295. 

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

  1297. 

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

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

  1300. 

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

  1302. 

  1303.     return 0;

  1304. }

  1305. 

  1306. static void dashenc_delete_file(AVFormatContext *s, char *filename) {

  1307.     DASHContext *c = s->priv_data;

  1308.     int http_base_proto = ff_is_http_proto(filename);

  1309. 

  1310.     if (http_base_proto) {

  1311.         AVIOContext *out = NULL;

  1312.         AVDictionary *http_opts = NULL;

  1313. 

  1314.         set_http_options(&http_opts, c);

  1315.         av_dict_set(&http_opts, "method", "DELETE", 0);

  1316. 

  1317.         if (dashenc_io_open(s, &out, filename, &http_opts) < 0) {

  1318.             av_log(s, AV_LOG_ERROR, "failed to delete %s\n", filename);

  1319.         }

  1320. 

  1321.         av_dict_free(&http_opts);

  1322.         ff_format_io_close(s, &out);

  1323.     } else if (unlink(filename) < 0) {

  1324.         av_log(s, AV_LOG_ERROR, "failed to delete %s: %s\n", filename, strerror(errno));

  1325.     }

  1326. }

  1327. 

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

  1329. {

  1330.     DASHContext *c = s->priv_data;

  1331.     int i, ret = 0;

  1332. 

  1333.     const char *proto = avio_find_protocol_name(s->url);

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

  1335. 

  1336.     int cur_flush_segment_index = 0, next_exp_index = -1;

  1337.     if (stream >= 0) {

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

  1339. 

  1340.         //finding the next segment's expected index, based on the current pts value

  1341.         if (c->use_template && !c->use_timeline && c->index_correction &&

  1342.             c->streams[stream].last_pts != AV_NOPTS_VALUE &&

  1343.             c->streams[stream].first_pts != AV_NOPTS_VALUE) {

  1344.             int64_t pts_diff = av_rescale_q(c->streams[stream].last_pts -

  1345.                                             c->streams[stream].first_pts,

  1346.                                             s->streams[stream]->time_base,

  1347.                                             AV_TIME_BASE_Q);

  1348.             next_exp_index = (pts_diff / c->seg_duration) + 1;

  1349.         }

  1350.     }

  1351. 

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

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

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

  1355.         int range_length, index_length = 0;

  1356. 

  1357.         if (!os->packets_written)

  1358.             continue;

  1359. 

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

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

  1362.         // but not the other video streams.

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

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

  1365.                 continue;

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

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

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

  1369.                 continue;

  1370.         }

  1371. 

  1372.         if (!c->single_file) {

  1373.             if (os->segment_type == SEGMENT_TYPE_MP4 && !os->written_len)

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

  1375.         } else {

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

  1377.         }

  1378. 

  1379.         ret = flush_dynbuf(os, &range_length);

  1380.         if (ret < 0)

  1381.             break;

  1382.         os->packets_written = 0;

  1383. 

  1384.         if (c->single_file) {

  1385.             find_index_range(s, os->full_path, os->pos, &index_length);

  1386.         } else {

  1387.             dashenc_io_close(s, &os->out, os->temp_path);

  1388. 

  1389.             if (use_rename) {

  1390.                 ret = avpriv_io_move(os->temp_path, os->full_path);

  1391.                 if (ret < 0)

  1392.                     break;

  1393.             }

  1394.         }

  1395. 

  1396.         if (!os->muxer_overhead)

  1397.             os->muxer_overhead = ((int64_t) (range_length - os->total_pkt_size) *

  1398.                                   8 * AV_TIME_BASE) /

  1399.                                  av_rescale_q(os->max_pts - os->start_pts,

  1400.                                               st->time_base, AV_TIME_BASE_Q);

  1401.         os->total_pkt_size = 0;

  1402. 

  1403.         if (!os->bit_rate) {

  1404.             // calculate average bitrate of first segment

  1405.             int64_t bitrate = (int64_t) range_length * 8 * AV_TIME_BASE / av_rescale_q(os->max_pts - os->start_pts,

  1406.                                                                                        st->time_base,

  1407.                                                                                        AV_TIME_BASE_Q);

  1408.             if (bitrate >= 0)

  1409.                 os->bit_rate = bitrate;

  1410.         }

  1411.         add_segment(os, os->filename, os->start_pts, os->max_pts - os->start_pts, os->pos, range_length, index_length, next_exp_index);

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

  1413. 

  1414.         os->pos += range_length;

  1415.     }

  1416. 

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

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

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

  1420.             int j;

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

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

  1423.                 remove = os->nb_segments;

  1424.             if (remove > 0) {

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

  1426.                     char filename[1024];

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

  1428.                     dashenc_delete_file(s, filename);

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

  1430.                 }

  1431.                 os->nb_segments -= remove;

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

  1433.             }

  1434.         }

  1435.     }

  1436. 

  1437.     if (ret >= 0)

  1438.         ret = write_manifest(s, final);

  1439.     return ret;

  1440. }

  1441. 

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

  1443. {

  1444.     DASHContext *c = s->priv_data;

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

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

  1447.     int64_t seg_end_duration, elapsed_duration;

  1448.     int ret;

  1449. 

  1450.     ret = update_stream_extradata(s, os, st->codecpar, &st->avg_frame_rate);

  1451.     if (ret < 0)

  1452.         return ret;

  1453. 

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

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

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

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

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

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

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

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

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

  1463. 

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

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

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

  1467.         s->avoid_negative_ts == AVFMT_AVOID_NEG_TS_MAKE_ZERO) {

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

  1469.         pkt->dts  = 0;

  1470.     }

  1471. 

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

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

  1474.     os->last_pts = pkt->pts;

  1475. 

  1476.     if (!c->availability_start_time[0])

  1477.         format_date_now(c->availability_start_time,

  1478.                         sizeof(c->availability_start_time));

  1479. 

  1480.     if (!os->availability_time_offset && pkt->duration) {

  1481.         int64_t frame_duration = av_rescale_q(pkt->duration, st->time_base,

  1482.                                               AV_TIME_BASE_Q);

  1483.          os->availability_time_offset = ((double) c->seg_duration -

  1484.                                          frame_duration) / AV_TIME_BASE;

  1485.     }

  1486. 

  1487.     if (c->use_template && !c->use_timeline) {

  1488.         elapsed_duration = pkt->pts - os->first_pts;

  1489.         seg_end_duration = (int64_t) os->segment_index * c->seg_duration;

  1490.     } else {

  1491.         elapsed_duration = pkt->pts - os->start_pts;

  1492.         seg_end_duration = c->seg_duration;

  1493.     }

  1494. 

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

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

  1497.         av_compare_ts(elapsed_duration, st->time_base,

  1498.                       seg_end_duration, AV_TIME_BASE_Q) >= 0) {

  1499.         int64_t prev_duration = c->last_duration;

  1500. 

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

  1502.                                         st->time_base,

  1503.                                         AV_TIME_BASE_Q);

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

  1505.                                          st->time_base,

  1506.                                          AV_TIME_BASE_Q);

  1507. 

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

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

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

  1511.                 av_log(s, AV_LOG_WARNING,

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

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

  1514.             }

  1515.         }

  1516. 

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

  1518.             return ret;

  1519.     }

  1520. 

  1521.     if (!os->packets_written) {

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

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

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

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

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

  1527.         else

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

  1529.     }

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

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

  1532.     else

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

  1534.     os->packets_written++;

  1535.     os->total_pkt_size += pkt->size;

  1536.     if ((ret = ff_write_chained(os->ctx, 0, pkt, s, 0)) < 0)

  1537.         return ret;

  1538. 

  1539.     if (!os->init_range_length)

  1540.         flush_init_segment(s, os);

  1541. 

  1542.     //open the output context when the first frame of a segment is ready

  1543.     if (!c->single_file && os->packets_written == 1) {

  1544.         AVDictionary *opts = NULL;

  1545.         const char *proto = avio_find_protocol_name(s->url);

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

  1547.         os->filename[0] = os->full_path[0] = os->temp_path[0] = '\0';

  1548.         ff_dash_fill_tmpl_params(os->filename, sizeof(os->filename),

  1549.                                  os->media_seg_name, pkt->stream_index,

  1550.                                  os->segment_index, os->bit_rate, os->start_pts);

  1551.         snprintf(os->full_path, sizeof(os->full_path), "%s%s", c->dirname,

  1552.                  os->filename);

  1553.         snprintf(os->temp_path, sizeof(os->temp_path),

  1554.                  use_rename ? "%s.tmp" : "%s", os->full_path);

  1555.         set_http_options(&opts, c);

  1556.         ret = dashenc_io_open(s, &os->out, os->temp_path, &opts);

  1557.         av_dict_free(&opts);

  1558.         if (ret < 0)

  1559.             return ret;

  1560.     }

  1561. 

  1562.     //write out the data immediately in streaming mode

  1563.     if (c->streaming && os->segment_type == SEGMENT_TYPE_MP4) {

  1564.         int len = 0;

  1565.         uint8_t *buf = NULL;

  1566.         if (!os->written_len)

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

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

  1569.         len = avio_get_dyn_buf (os->ctx->pb, &buf);

  1570.         avio_write(os->out, buf + os->written_len, len - os->written_len);

  1571.         os->written_len = len;

  1572.         avio_flush(os->out);

  1573.     }

  1574. 

  1575.     return ret;

  1576. }

  1577. 

  1578. static int dash_write_trailer(AVFormatContext *s)

  1579. {

  1580.     DASHContext *c = s->priv_data;

  1581. 

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

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

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

  1585.         // guess of the segment duration

  1586.         if (!c->last_duration)

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

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

  1589.                                             AV_TIME_BASE_Q);

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

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

  1592.                                          AV_TIME_BASE_Q);

  1593.     }

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

  1595. 

  1596.     if (c->remove_at_exit) {

  1597.         char filename[1024];

  1598.         int i;

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

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

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

  1602.             dashenc_delete_file(s, filename);

  1603.         }

  1604.         dashenc_delete_file(s, s->url);

  1605.     }

  1606. 

  1607.     return 0;

  1608. }

  1609. 

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

  1611. {

  1612.     DASHContext *c = s->priv_data;

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

  1614.     AVFormatContext *oc = os->ctx;

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

  1616.         int ret;

  1617.         AVPacket pkt = *avpkt;

  1618.         pkt.stream_index = 0;

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

  1620.         if (ret == 1) {

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

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

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

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

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

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

  1627.         }

  1628.         return ret;

  1629.     }

  1630.     return 1;

  1631. }

  1632. 

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

  1634. #define E AV_OPT_FLAG_ENCODING_PARAM

  1635. static const AVOption options[] = {

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

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

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

  1639. #if FF_API_DASH_MIN_SEG_DURATION

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

  1641. #endif

  1642.     { "seg_duration", "segment duration (in seconds, fractional value can be set)", OFFSET(seg_duration), AV_OPT_TYPE_DURATION, { .i64 = 5000000 }, 0, INT_MAX, E },

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

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

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

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

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

  1648.     { "init_seg_name", "DASH-templated name to used for the initialization segment", OFFSET(init_seg_name), AV_OPT_TYPE_STRING, {.str = "init-stream$RepresentationID$.$ext$"}, 0, 0, E },

  1649.     { "media_seg_name", "DASH-templated name to used for the media segments", OFFSET(media_seg_name), AV_OPT_TYPE_STRING, {.str = "chunk-stream$RepresentationID$-$Number%05d$.$ext$"}, 0, 0, E },

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

  1651.     { "method", "set the HTTP method", OFFSET(method), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, E },

  1652.     { "http_user_agent", "override User-Agent field in HTTP header", OFFSET(user_agent), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, E},

  1653.     { "http_persistent", "Use persistent HTTP connections", OFFSET(http_persistent), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, E },

  1654.     { "hls_playlist", "Generate HLS playlist files(master.m3u8, media_%d.m3u8)", OFFSET(hls_playlist), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, E },

  1655.     { "streaming", "Enable/Disable streaming mode of output. Each frame will be moof fragment", OFFSET(streaming), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, E },

  1656.     { "timeout", "set timeout for socket I/O operations", OFFSET(timeout), AV_OPT_TYPE_DURATION, { .i64 = -1 }, -1, INT_MAX, .flags = E },

  1657.     { "index_correction", "Enable/Disable segment index correction logic", OFFSET(index_correction), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, E },

  1658.     { "format_options","set list of options for the container format (mp4/webm) used for dash", OFFSET(format_options_str), AV_OPT_TYPE_STRING, {.str = NULL},  0, 0, E},

  1659.     { "dash_segment_type", "set dash segment files type", OFFSET(segment_type_option), AV_OPT_TYPE_INT, {.i64 = SEGMENT_TYPE_AUTO }, 0, SEGMENT_TYPE_NB - 1, E, "segment_type"},

  1660.     { "auto", "select segment file format based on codec", 0, AV_OPT_TYPE_CONST, {.i64 = SEGMENT_TYPE_AUTO }, 0, UINT_MAX,   E, "segment_type"},

  1661.     { "mp4", "make segment file in ISOBMFF format", 0, AV_OPT_TYPE_CONST, {.i64 = SEGMENT_TYPE_MP4 }, 0, UINT_MAX,   E, "segment_type"},

  1662.     { "webm", "make segment file in WebM format", 0, AV_OPT_TYPE_CONST, {.i64 = SEGMENT_TYPE_WEBM }, 0, UINT_MAX,   E, "segment_type"},

  1663.     { NULL },

  1664. };

  1665. 

  1666. static const AVClass dash_class = {

  1667.     .class_name = "dash muxer",

  1668.     .item_name  = av_default_item_name,

  1669.     .option     = options,

  1670.     .version    = LIBAVUTIL_VERSION_INT,

  1671. };

  1672. 

  1673. AVOutputFormat ff_dash_muxer = {

  1674.     .name           = "dash",

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

  1676.     .extensions     = "mpd",

  1677.     .priv_data_size = sizeof(DASHContext),

  1678.     .audio_codec    = AV_CODEC_ID_AAC,

  1679.     .video_codec    = AV_CODEC_ID_H264,

  1680.     .flags          = AVFMT_GLOBALHEADER | AVFMT_NOFILE | AVFMT_TS_NEGATIVE,

  1681.     .init           = dash_init,

  1682.     .write_header   = dash_write_header,

  1683.     .write_packet   = dash_write_packet,

  1684.     .write_trailer  = dash_write_trailer,

  1685.     .deinit         = dash_free,

  1686.     .check_bitstream = dash_check_bitstream,

  1687.     .priv_class     = &dash_class,

  1688. };