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

1585 lines
59KB
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_MP4 = 0,

  53.     SEGMENT_TYPE_WEBM,

  54.     SEGMENT_TYPE_NB

  55. } SegmentType;

  56. 

  57. typedef struct Segment {

  58.     char file[1024];

  59.     int64_t start_pos;

  60.     int range_length, index_length;

  61.     int64_t time;

  62.     int duration;

  63.     int n;

  64. } Segment;

  65. 

  66. typedef struct AdaptationSet {

  67.     char id[10];

  68.     enum AVMediaType media_type;

  69.     AVDictionary *metadata;

  70.     AVRational min_frame_rate, max_frame_rate;

  71.     int ambiguous_frame_rate;

  72. } AdaptationSet;

  73. 

  74. typedef struct OutputStream {

  75.     AVFormatContext *ctx;

  76.     int ctx_inited, as_idx;

  77.     AVIOContext *out;

  78.     int packets_written;

  79.     char initfile[1024];

  80.     int64_t init_start_pos, pos;

  81.     int init_range_length;

  82.     int nb_segments, segments_size, segment_index;

  83.     Segment **segments;

  84.     int64_t first_pts, start_pts, max_pts;

  85.     int64_t last_dts, last_pts;

  86.     int bit_rate;

  87. 

  88.     char codec_str[100];

  89.     int written_len;

  90.     char filename[1024];

  91.     char full_path[1024];

  92.     char temp_path[1024];

  93.     double availability_time_offset;

  94.     int total_pkt_size;

  95.     int muxer_overhead;

  96. } OutputStream;

  97. 

  98. typedef struct DASHContext {

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

  100.     char *adaptation_sets;

  101.     AdaptationSet *as;

  102.     int nb_as;

  103.     int window_size;

  104.     int extra_window_size;

  105. #if FF_API_DASH_MIN_SEG_DURATION

  106.     int min_seg_duration;

  107. #endif

  108.     int64_t seg_duration;

  109.     int remove_at_exit;

  110.     int use_template;

  111.     int use_timeline;

  112.     int single_file;

  113.     OutputStream *streams;

  114.     int has_video;

  115.     int64_t last_duration;

  116.     int64_t total_duration;

  117.     char availability_start_time[100];

  118.     char dirname[1024];

  119.     const char *single_file_name;

  120.     const char *init_seg_name;

  121.     const char *media_seg_name;

  122.     const char *utc_timing_url;

  123.     const char *method;

  124.     const char *user_agent;

  125.     int hls_playlist;

  126.     int http_persistent;

  127.     int master_playlist_created;

  128.     AVIOContext *mpd_out;

  129.     AVIOContext *m3u8_out;

  130.     int streaming;

  131.     int64_t timeout;

  132.     int index_correction;

  133.     char *format_options_str;

  134.     SegmentType segment_type;

  135.     const char *format_name;

  136. } DASHContext;

  137. 

  138. static struct codec_string {

  139.     int id;

  140.     const char *str;

  141. } codecs[] = {

  142.     { AV_CODEC_ID_VP8, "vp8" },

  143.     { AV_CODEC_ID_VP9, "vp9" },

  144.     { AV_CODEC_ID_VORBIS, "vorbis" },

  145.     { AV_CODEC_ID_OPUS, "opus" },

  146.     { 0, NULL }

  147. };

  148. 

  149. static struct format_string {

  150.     SegmentType segment_type;

  151.     const char *str;

  152. } formats[] = {

  153.     { SEGMENT_TYPE_MP4, "mp4" },

  154.     { SEGMENT_TYPE_WEBM, "webm" },

  155.     { 0, NULL }

  156. };

  157. 

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

  159.                            AVDictionary **options) {

  160.     DASHContext *c = s->priv_data;

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

  162.     int err = AVERROR_MUXER_NOT_FOUND;

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

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

  165. #if CONFIG_HTTP_PROTOCOL

  166.     } else {

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

  168.         av_assert0(http_url_context);

  169.         err = ff_http_do_new_request(http_url_context, filename);

  170. #endif

  171.     }

  172.     return err;

  173. }

  174. 

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

  176.     DASHContext *c = s->priv_data;

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

  178. 

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

  180.         ff_format_io_close(s, pb);

  181. #if CONFIG_HTTP_PROTOCOL

  182.     } else {

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

  184.         av_assert0(http_url_context);

  185.         avio_flush(*pb);

  186.         ffurl_shutdown(http_url_context, AVIO_FLAG_WRITE);

  187. #endif

  188.     }

  189. }

  190. 

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

  192.     int i;

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

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

  195.             return formats[i].str;

  196.     return NULL;

  197. }

  198. 

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

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

  201.     VPCC vpcc;

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

  203.     if (ret == 0) {

  204.         av_strlcatf(str, size, "vp09.%02x.%02x.%02x",

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

  206.     } else {

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

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

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

  210.     }

  211.     return;

  212. }

  213. 

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

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

  216. {

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

  218.     uint32_t tag;

  219.     int i;

  220. 

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

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

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

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

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

  226.             } else {

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

  228.             }

  229.             return;

  230.         }

  231. 

  232.     // for codecs part of RFC 6381

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

  234.         tags[0] = ff_codec_movvideo_tags;

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

  236.         tags[0] = ff_codec_movaudio_tags;

  237.     else

  238.         return;

  239. 

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

  241.     if (!tag)

  242.         return;

  243.     if (size < 5)

  244.         return;

  245. 

  246.     AV_WL32(str, tag);

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

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

  249.         uint32_t oti;

  250.         tags[0] = ff_mp4_obj_type;

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

  252.         if (oti)

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

  254.         else

  255.             return;

  256. 

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

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

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

  260.                 if (aot == 31)

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

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

  263.             }

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

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

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

  267.         }

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

  269.         uint8_t *tmpbuf = NULL;

  270.         uint8_t *extradata = par->extradata;

  271.         int extradata_size = par->extradata_size;

  272.         if (!extradata_size)

  273.             return;

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

  275.             AVIOContext *pb;

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

  277.                 return;

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

  279.                 ffio_free_dyn_buf(&pb);

  280.                 return;

  281.             }

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

  283.             tmpbuf = extradata;

  284.         }

  285. 

  286.         if (extradata_size >= 4)

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

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

  289.         av_free(tmpbuf);

  290.     }

  291. }

  292. 

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

  294. {

  295.     uint8_t *buffer;

  296. 

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

  298.         return AVERROR(EINVAL);

  299.     }

  300. 

  301.     // flush

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

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

  304. 

  305.     // write out to file

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

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

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

  309.     os->written_len = 0;

  310.     av_free(buffer);

  311. 

  312.     // re-open buffer

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

  314. }

  315. 

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

  317. {

  318.     if (c->method)

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

  320.     if (c->user_agent)

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

  322.     if (c->http_persistent)

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

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

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

  326. }

  327. 

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

  329.                                   const char *base_url, int id) {

  330.     if (base_url)

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

  332.     else

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

  334. }

  335. 

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

  337. {

  338.     DASHContext *c = s->priv_data;

  339.     int ret, range_length;

  340. 

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

  342.     if (ret < 0)

  343.         return ret;

  344. 

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

  346.     if (!c->single_file)

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

  348.     return 0;

  349. }

  350. 

  351. static void dash_free(AVFormatContext *s)

  352. {

  353.     DASHContext *c = s->priv_data;

  354.     int i, j;

  355. 

  356.     if (c->as) {

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

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

  359.         av_freep(&c->as);

  360.         c->nb_as = 0;

  361.     }

  362. 

  363.     if (!c->streams)

  364.         return;

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

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

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

  368.             av_write_trailer(os->ctx);

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

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

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

  372.         if (os->ctx)

  373.             avformat_free_context(os->ctx);

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

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

  376.         av_free(os->segments);

  377.     }

  378.     av_freep(&c->streams);

  379. 

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

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

  382. }

  383. 

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

  385.                                 int representation_id, int final)

  386. {

  387.     DASHContext *c = s->priv_data;

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

  389.     if (c->window_size) {

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

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

  392.     }

  393. 

  394.     if (c->use_template) {

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

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

  397.         if (!c->use_timeline) {

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

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

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

  401.                             os->availability_time_offset);

  402.         }

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

  404.         if (c->use_timeline) {

  405.             int64_t cur_time = 0;

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

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

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

  409.                 int repeat = 0;

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

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

  412.                     cur_time = seg->time;

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

  414.                 }

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

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

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

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

  419.                     repeat++;

  420.                 if (repeat > 0)

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

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

  423.                 i += 1 + repeat;

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

  425.             }

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

  427.         }

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

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

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

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

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

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

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

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

  436.             if (seg->index_length)

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

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

  439.         }

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

  441.     } else {

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

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

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

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

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

  447.         }

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

  449.     }

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

  451.     {

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

  453.         char temp_filename_hls[1024];

  454.         char filename_hls[1024];

  455.         AVDictionary *http_opts = NULL;

  456.         int target_duration = 0;

  457.         int ret = 0;

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

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

  460. 

  461.         get_hls_playlist_name(filename_hls, sizeof(filename_hls),

  462.                               c->dirname, representation_id);

  463. 

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

  465. 

  466.         set_http_options(&http_opts, c);

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

  468.         av_dict_free(&http_opts);

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

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

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

  472.             if (target_duration <= duration)

  473.                 target_duration = lrint(duration);

  474.         }

  475. 

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

  477.                                      start_number, PLAYLIST_TYPE_NONE);

  478. 

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

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

  481. 

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

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

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

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

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

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

  488.                                     NULL);

  489.             if (ret < 0) {

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

  491.             }

  492.         }

  493. 

  494.         if (final)

  495.             ff_hls_write_end_list(c->m3u8_out);

  496. 

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

  498. 

  499.         if (use_rename)

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

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

  502.             }

  503.     }

  504. 

  505. }

  506. 

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

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

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

  510.     int pos = 0;

  511.     if (!out)

  512.         return NULL;

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

  514.         if (pos + 6 > outlen) {

  515.             char *tmp;

  516.             outlen = 2 * outlen + 6;

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

  518.             if (!tmp) {

  519.                 av_free(out);

  520.                 return NULL;

  521.             }

  522.             out = tmp;

  523.         }

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

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

  526.             pos += 5;

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

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

  529.             pos += 4;

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

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

  532.             pos += 4;

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

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

  535.             pos += 6;

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

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

  538.             pos += 6;

  539.         } else {

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

  541.         }

  542.     }

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

  544.     return out;

  545. }

  546. 

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

  548. {

  549.     int seconds = time / AV_TIME_BASE;

  550.     int fractions = time % AV_TIME_BASE;

  551.     int minutes = seconds / 60;

  552.     int hours = minutes / 60;

  553.     seconds %= 60;

  554.     minutes %= 60;

  555.     avio_printf(out, "PT");

  556.     if (hours)

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

  558.     if (hours || minutes)

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

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

  561. }

  562. 

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

  564. {

  565.     time_t t = time(NULL);

  566.     struct tm *ptm, tmbuf;

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

  568.     if (ptm) {

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

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

  571.     }

  572. }

  573. 

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

  575.                                 int final)

  576. {

  577.     DASHContext *c = s->priv_data;

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

  579.     AVDictionaryEntry *lang, *role;

  580.     int i;

  581. 

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

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

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

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

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

  587.     if (lang)

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

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

  590. 

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

  592.     if (role)

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

  594. 

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

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

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

  598. 

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

  600.             continue;

  601. 

  602.         if (os->bit_rate > 0)

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

  604.                      os->bit_rate + os->muxer_overhead);

  605. 

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

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

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

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

  610.             if (st->avg_frame_rate.num)

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

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

  613.         } else {

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

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

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

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

  618.         }

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

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

  621.     }

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

  623. 

  624.     return 0;

  625. }

  626. 

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

  628. {

  629.     DASHContext *c = s->priv_data;

  630. 

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

  632.     if (!mem)

  633.         return AVERROR(ENOMEM);

  634.     c->as = mem;

  635.     ++c->nb_as;

  636. 

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

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

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

  640. 

  641.     return 0;

  642. }

  643. 

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

  645. {

  646.     DASHContext *c = s->priv_data;

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

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

  649. 

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

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

  652.         return AVERROR(EINVAL);

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

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

  655.         return AVERROR(EINVAL);

  656.     }

  657.     os->as_idx = as_idx;

  658. 

  659.     return 0;

  660. }

  661. 

  662. static int parse_adaptation_sets(AVFormatContext *s)

  663. {

  664.     DASHContext *c = s->priv_data;

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

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

  667.     AdaptationSet *as;

  668.     int i, n, ret;

  669. 

  670.     // default: one AdaptationSet for each stream

  671.     if (!p) {

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

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

  674.                 return ret;

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

  676. 

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

  678.         }

  679.         goto end;

  680.     }

  681. 

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

  683.     state = new_set;

  684.     while (*p) {

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

  686.             p++;

  687.             continue;

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

  689. 

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

  691.                 return ret;

  692. 

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

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

  695. 

  696.             p += n;

  697.             if (*p)

  698.                 p++;

  699.             state = parse_id;

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

  701.             state = parsing_streams;

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

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

  704.             char idx_str[8], *end_str;

  705. 

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

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

  708.             p += n;

  709. 

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

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

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

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

  714. 

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

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

  717.                         continue;

  718. 

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

  720. 

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

  722.                         return ret;

  723.                 }

  724.             } else { // select single stream

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

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

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

  728.                     return AVERROR(EINVAL);

  729.                 }

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

  731. 

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

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

  734.                 }

  735. 

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

  737.                     return ret;

  738.             }

  739. 

  740.             if (*p == ' ')

  741.                 state = new_set;

  742.             if (*p)

  743.                 p++;

  744.         } else {

  745.             return AVERROR(EINVAL);

  746.         }

  747.     }

  748. 

  749. end:

  750.     // check for unassigned streams

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

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

  753.         if (!os->as_idx) {

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

  755.             return AVERROR(EINVAL);

  756.         }

  757.     }

  758.     return 0;

  759. }

  760. 

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

  762. {

  763.     DASHContext *c = s->priv_data;

  764.     AVIOContext *out;

  765.     char temp_filename[1024];

  766.     int ret, i;

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

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

  769.     static unsigned int warned_non_file = 0;

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

  771.     AVDictionary *opts = NULL;

  772. 

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

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

  775. 

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

  777.     set_http_options(&opts, c);

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

  779.     if (ret < 0) {

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

  781.         return ret;

  782.     }

  783.     out = c->mpd_out;

  784.     av_dict_free(&opts);

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

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

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

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

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

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

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

  792.     if (final) {

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

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

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

  796.     } else {

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

  798.         char now_str[100];

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

  800.             update_period = 500;

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

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

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

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

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

  806.         if (now_str[0])

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

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

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

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

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

  812.         }

  813.     }

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

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

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

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

  818.     if (title) {

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

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

  821.         av_free(escaped);

  822.     }

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

  824. 

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

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

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

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

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

  830.         write_time(out, start_time);

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

  832.     } else {

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

  834.     }

  835. 

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

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

  838.             return ret;

  839.     }

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

  841. 

  842.     if (c->utc_timing_url)

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

  844. 

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

  846.     avio_flush(out);

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

  848. 

  849.     if (use_rename) {

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

  851.             return ret;

  852.     }

  853. 

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

  855.         char filename_hls[1024];

  856.         const char *audio_group = "A1";

  857.         int is_default = 1;

  858.         int max_audio_bitrate = 0;

  859. 

  860.         if (*c->dirname)

  861.             snprintf(filename_hls, sizeof(filename_hls), "%s/master.m3u8", c->dirname);

  862.         else

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

  864. 

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

  866. 

  867.         set_http_options(&opts, c);

  868.         ret = avio_open2(&out, temp_filename, AVIO_FLAG_WRITE, NULL, &opts);

  869.         if (ret < 0) {

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

  871.             return ret;

  872.         }

  873.         av_dict_free(&opts);

  874. 

  875.         ff_hls_write_playlist_version(out, 7);

  876. 

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

  878.             char playlist_file[64];

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

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

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

  882.                 continue;

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

  884.             ff_hls_write_audio_rendition(out, (char *)audio_group,

  885.                                          playlist_file, i, is_default);

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

  887.                                       os->muxer_overhead, max_audio_bitrate);

  888.             is_default = 0;

  889.         }

  890. 

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

  892.             char playlist_file[64];

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

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

  895.             char *agroup = NULL;

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

  897.             if ((st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) && max_audio_bitrate) {

  898.                 agroup = (char *)audio_group;

  899.                 stream_bitrate += max_audio_bitrate;

  900.             }

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

  902.             ff_hls_write_stream_info(st, out, stream_bitrate, playlist_file, agroup, NULL, NULL);

  903.         }

  904.         avio_close(out);

  905.         if (use_rename)

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

  907.                 return ret;

  908.         c->master_playlist_created = 1;

  909.     }

  910. 

  911.     return 0;

  912. }

  913. 

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

  915. {

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

  917.     if (entry)

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

  919.     return 0;

  920. }

  921. 

  922. static int dash_init(AVFormatContext *s)

  923. {

  924.     DASHContext *c = s->priv_data;

  925.     int ret = 0, i;

  926.     char *ptr;

  927.     char basename[1024];

  928. 

  929.     if (c->single_file_name)

  930.         c->single_file = 1;

  931.     if (c->single_file)

  932.         c->use_template = 0;

  933. 

  934. #if FF_API_DASH_MIN_SEG_DURATION

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

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

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

  938.     }

  939. #endif

  940. 

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

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

  943.     if (ptr) {

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

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

  946.     } else {

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

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

  949.     }

  950. 

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

  952.     if (ptr)

  953.         *ptr = '\0';

  954. 

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

  956.     if (!c->streams)

  957.         return AVERROR(ENOMEM);

  958. 

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

  960.         return ret;

  961. 

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

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

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

  965.         AVFormatContext *ctx;

  966.         AVStream *st;

  967.         AVDictionary *opts = NULL;

  968.         char filename[1024];

  969. 

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

  971.         if (!os->bit_rate) {

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

  973.                         AV_LOG_ERROR : AV_LOG_WARNING;

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

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

  976.                 return AVERROR(EINVAL);

  977.         }

  978. 

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

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

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

  982. 

  983.         ctx = avformat_alloc_context();

  984.         if (!ctx)

  985.             return AVERROR(ENOMEM);

  986. 

  987.         c->format_name = get_format_str(c->segment_type);

  988.         if (!c->format_name)

  989.             return AVERROR_MUXER_NOT_FOUND;

  990.         ctx->oformat = av_guess_format(c->format_name, NULL, NULL);

  991.         if (!ctx->oformat)

  992.             return AVERROR_MUXER_NOT_FOUND;

  993.         os->ctx = ctx;

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

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

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

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

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

  999. 

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

  1001.             return AVERROR(ENOMEM);

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

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

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

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

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

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

  1008. 

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

  1010.             return ret;

  1011. 

  1012.         if (c->single_file) {

  1013.             if (c->single_file_name)

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

  1015.             else

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

  1017.         } else {

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

  1019.         }

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

  1021.         set_http_options(&opts, c);

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

  1023.         if (ret < 0)

  1024.             return ret;

  1025.         av_dict_free(&opts);

  1026.         os->init_start_pos = 0;

  1027. 

  1028.         if (c->format_options_str) {

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

  1030.             if (ret < 0)

  1031.                 return ret;

  1032.         }

  1033. 

  1034.         if (c->segment_type == SEGMENT_TYPE_MP4) {

  1035.             if (c->streaming)

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

  1037.             else

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

  1039.         } else {

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

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

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

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

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

  1045.         }

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

  1047.             return ret;

  1048.         os->ctx_inited = 1;

  1049.         avio_flush(ctx->pb);

  1050.         av_dict_free(&opts);

  1051. 

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

  1053. 

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

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

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

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

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

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

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

  1061.             if (avg_frame_rate.num > 0) {

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

  1063.                     as->min_frame_rate = avg_frame_rate;

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

  1065.                     as->max_frame_rate = avg_frame_rate;

  1066.             } else {

  1067.                 as->ambiguous_frame_rate = 1;

  1068.             }

  1069.             c->has_video = 1;

  1070.         }

  1071. 

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

  1073.                       sizeof(os->codec_str));

  1074.         os->first_pts = AV_NOPTS_VALUE;

  1075.         os->max_pts = AV_NOPTS_VALUE;

  1076.         os->last_dts = AV_NOPTS_VALUE;

  1077.         os->segment_index = 1;

  1078.     }

  1079. 

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

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

  1082.         return AVERROR(EINVAL);

  1083.     }

  1084.     return 0;

  1085. }

  1086. 

  1087. static int dash_write_header(AVFormatContext *s)

  1088. {

  1089.     DASHContext *c = s->priv_data;

  1090.     int i, ret;

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

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

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

  1094.             return ret;

  1095. 

  1096.         // Flush init segment

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

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

  1099.         if (c->segment_type == SEGMENT_TYPE_WEBM &&

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

  1101.             return ret;

  1102.     }

  1103.     return ret;

  1104. }

  1105. 

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

  1107.                        int64_t time, int duration,

  1108.                        int64_t start_pos, int64_t range_length,

  1109.                        int64_t index_length, int next_exp_index)

  1110. {

  1111.     int err;

  1112.     Segment *seg;

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

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

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

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

  1117.             os->segments_size = 0;

  1118.             os->nb_segments = 0;

  1119.             return err;

  1120.         }

  1121.     }

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

  1123.     if (!seg)

  1124.         return AVERROR(ENOMEM);

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

  1126.     seg->time = time;

  1127.     seg->duration = duration;

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

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

  1130.         seg->time = 0;

  1131.     }

  1132.     seg->start_pos = start_pos;

  1133.     seg->range_length = range_length;

  1134.     seg->index_length = index_length;

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

  1136.     os->segment_index++;

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

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

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

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

  1141.         os->segment_index = next_exp_index;

  1142.     }

  1143.     return 0;

  1144. }

  1145. 

  1146. static void write_styp(AVIOContext *pb)

  1147. {

  1148.     avio_wb32(pb, 24);

  1149.     ffio_wfourcc(pb, "styp");

  1150.     ffio_wfourcc(pb, "msdh");

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

  1152.     ffio_wfourcc(pb, "msdh");

  1153.     ffio_wfourcc(pb, "msix");

  1154. }

  1155. 

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

  1157.                              int64_t pos, int *index_length)

  1158. {

  1159.     uint8_t buf[8];

  1160.     AVIOContext *pb;

  1161.     int ret;

  1162. 

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

  1164.     if (ret < 0)

  1165.         return;

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

  1167.         ff_format_io_close(s, &pb);

  1168.         return;

  1169.     }

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

  1171.     ff_format_io_close(s, &pb);

  1172.     if (ret < 8)

  1173.         return;

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

  1175.         return;

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

  1177. }

  1178. 

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

  1180.                                    AVCodecParameters *par,

  1181.                                    AVRational *frame_rate)

  1182. {

  1183.     uint8_t *extradata;

  1184. 

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

  1186.         return 0;

  1187. 

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

  1189. 

  1190.     if (!extradata)

  1191.         return AVERROR(ENOMEM);

  1192. 

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

  1194. 

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

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

  1197. 

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

  1199. 

  1200.     return 0;

  1201. }

  1202. 

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

  1204.     DASHContext *c = s->priv_data;

  1205.     int http_base_proto = ff_is_http_proto(filename);

  1206. 

  1207.     if (http_base_proto) {

  1208.         AVIOContext *out = NULL;

  1209.         AVDictionary *http_opts = NULL;

  1210. 

  1211.         set_http_options(&http_opts, c);

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

  1213. 

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

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

  1216.         }

  1217. 

  1218.         av_dict_free(&http_opts);

  1219.         dashenc_io_close(s, &out, filename);

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

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

  1222.     }

  1223. }

  1224. 

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

  1226. {

  1227.     DASHContext *c = s->priv_data;

  1228.     int i, ret = 0;

  1229. 

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

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

  1232. 

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

  1234.     if (stream >= 0) {

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

  1236. 

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

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

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

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

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

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

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

  1244.                                             AV_TIME_BASE_Q);

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

  1246.         }

  1247.     }

  1248. 

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

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

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

  1252.         int range_length, index_length = 0;

  1253. 

  1254.         if (!os->packets_written)

  1255.             continue;

  1256. 

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

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

  1259.         // but not the other video streams.

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

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

  1262.                 continue;

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

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

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

  1266.                 continue;

  1267.         }

  1268. 

  1269.         if (!c->single_file) {

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

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

  1272.         } else {

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

  1274.         }

  1275. 

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

  1277.         if (ret < 0)

  1278.             break;

  1279.         os->packets_written = 0;

  1280. 

  1281.         if (c->single_file) {

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

  1283.         } else {

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

  1285. 

  1286.             if (use_rename) {

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

  1288.                 if (ret < 0)

  1289.                     break;

  1290.             }

  1291.         }

  1292. 

  1293.         if (!os->muxer_overhead)

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

  1295.                                   8 * AV_TIME_BASE) /

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

  1297.                                               st->time_base, AV_TIME_BASE_Q);

  1298.         os->total_pkt_size = 0;

  1299. 

  1300.         if (!os->bit_rate) {

  1301.             // calculate average bitrate of first segment

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

  1303.                                                                                        st->time_base,

  1304.                                                                                        AV_TIME_BASE_Q);

  1305.             if (bitrate >= 0)

  1306.                 os->bit_rate = bitrate;

  1307.         }

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

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

  1310. 

  1311.         os->pos += range_length;

  1312.     }

  1313. 

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

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

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

  1317.             int j;

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

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

  1320.                 remove = os->nb_segments;

  1321.             if (remove > 0) {

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

  1323.                     char filename[1024];

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

  1325.                     dashenc_delete_file(s, filename);

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

  1327.                 }

  1328.                 os->nb_segments -= remove;

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

  1330.             }

  1331.         }

  1332.     }

  1333. 

  1334.     if (ret >= 0)

  1335.         ret = write_manifest(s, final);

  1336.     return ret;

  1337. }

  1338. 

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

  1340. {

  1341.     DASHContext *c = s->priv_data;

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

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

  1344.     int64_t seg_end_duration, elapsed_duration;

  1345.     int ret;

  1346. 

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

  1348.     if (ret < 0)

  1349.         return ret;

  1350. 

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

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

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

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

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

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

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

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

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

  1360. 

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

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

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

  1364.         s->avoid_negative_ts == AVFMT_AVOID_NEG_TS_MAKE_ZERO) {

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

  1366.         pkt->dts  = 0;

  1367.     }

  1368. 

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

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

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

  1372. 

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

  1374.         format_date_now(c->availability_start_time,

  1375.                         sizeof(c->availability_start_time));

  1376. 

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

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

  1379.                                               AV_TIME_BASE_Q);

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

  1381.                                          frame_duration) / AV_TIME_BASE;

  1382.     }

  1383. 

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

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

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

  1387.     } else {

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

  1389.         seg_end_duration = c->seg_duration;

  1390.     }

  1391. 

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

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

  1394.         av_compare_ts(elapsed_duration, st->time_base,

  1395.                       seg_end_duration, AV_TIME_BASE_Q) >= 0) {

  1396.         int64_t prev_duration = c->last_duration;

  1397. 

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

  1399.                                         st->time_base,

  1400.                                         AV_TIME_BASE_Q);

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

  1402.                                          st->time_base,

  1403.                                          AV_TIME_BASE_Q);

  1404. 

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

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

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

  1408.                 av_log(s, AV_LOG_WARNING,

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

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

  1411.             }

  1412.         }

  1413. 

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

  1415.             return ret;

  1416.     }

  1417. 

  1418.     if (!os->packets_written) {

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

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

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

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

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

  1424.         else

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

  1426.     }

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

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

  1429.     else

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

  1431.     os->packets_written++;

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

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

  1434.         return ret;

  1435. 

  1436.     if (!os->init_range_length)

  1437.         flush_init_segment(s, os);

  1438. 

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

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

  1441.         AVDictionary *opts = NULL;

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

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

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

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

  1446.                                  c->media_seg_name, pkt->stream_index,

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

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

  1449.                  os->filename);

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

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

  1452.         set_http_options(&opts, c);

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

  1454.         if (ret < 0)

  1455.             return ret;

  1456.         av_dict_free(&opts);

  1457.     }

  1458. 

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

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

  1461.         int len = 0;

  1462.         uint8_t *buf = NULL;

  1463.         if (!os->written_len)

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

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

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

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

  1468.         os->written_len = len;

  1469.         avio_flush(os->out);

  1470.     }

  1471. 

  1472.     return ret;

  1473. }

  1474. 

  1475. static int dash_write_trailer(AVFormatContext *s)

  1476. {

  1477.     DASHContext *c = s->priv_data;

  1478. 

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

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

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

  1482.         // guess of the segment duration

  1483.         if (!c->last_duration)

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

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

  1486.                                             AV_TIME_BASE_Q);

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

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

  1489.                                          AV_TIME_BASE_Q);

  1490.     }

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

  1492. 

  1493.     if (c->remove_at_exit) {

  1494.         char filename[1024];

  1495.         int i;

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

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

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

  1499.             dashenc_delete_file(s, filename);

  1500.         }

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

  1502.     }

  1503. 

  1504.     return 0;

  1505. }

  1506. 

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

  1508. {

  1509.     DASHContext *c = s->priv_data;

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

  1511.     AVFormatContext *oc = os->ctx;

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

  1513.         int ret;

  1514.         AVPacket pkt = *avpkt;

  1515.         pkt.stream_index = 0;

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

  1517.         if (ret == 1) {

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

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

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

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

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

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

  1524.         }

  1525.         return ret;

  1526.     }

  1527.     return 1;

  1528. }

  1529. 

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

  1531. #define E AV_OPT_FLAG_ENCODING_PARAM

  1532. static const AVOption options[] = {

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

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

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

  1536. #if FF_API_DASH_MIN_SEG_DURATION

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

  1538. #endif

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  1559.     { NULL },

  1560. };

  1561. 

  1562. static const AVClass dash_class = {

  1563.     .class_name = "dash muxer",

  1564.     .item_name  = av_default_item_name,

  1565.     .option     = options,

  1566.     .version    = LIBAVUTIL_VERSION_INT,

  1567. };

  1568. 

  1569. AVOutputFormat ff_dash_muxer = {

  1570.     .name           = "dash",

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

  1572.     .extensions     = "mpd",

  1573.     .priv_data_size = sizeof(DASHContext),

  1574.     .audio_codec    = AV_CODEC_ID_AAC,

  1575.     .video_codec    = AV_CODEC_ID_H264,

  1576.     .flags          = AVFMT_GLOBALHEADER | AVFMT_NOFILE | AVFMT_TS_NEGATIVE,

  1577.     .init           = dash_init,

  1578.     .write_header   = dash_write_header,

  1579.     .write_packet   = dash_write_packet,

  1580.     .write_trailer  = dash_write_trailer,

  1581.     .deinit         = dash_free,

  1582.     .check_bitstream = dash_check_bitstream,

  1583.     .priv_class     = &dash_class,

  1584. };