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#include "config_components.h" 25#if HAVE_UNISTD_H 26#include <unistd.h> 27#endif 28 29#include "libavutil/avassert.h" 30#include "libavutil/avutil.h" 31#include "libavutil/avstring.h" 32#include "libavutil/bprint.h" 33#include "libavutil/intreadwrite.h" 34#include "libavutil/mathematics.h" 35#include "libavutil/opt.h" 36#include "libavutil/parseutils.h" 37#include "libavutil/rational.h" 38#include "libavutil/time.h" 39#include "libavutil/time_internal.h" 40 41#include "av1.h" 42#include "avc.h" 43#include "avformat.h" 44#include "avio_internal.h" 45#include "hlsplaylist.h" 46#if CONFIG_HTTP_PROTOCOL 47#include "http.h" 48#endif 49#include "internal.h" 50#include "isom.h" 51#include "mux.h" 52#include "os_support.h" 53#include "url.h" 54#include "vpcc.h" 55#include "dash.h" 56 57typedef enum { 58 SEGMENT_TYPE_AUTO = 0, 59 SEGMENT_TYPE_MP4, 60 SEGMENT_TYPE_WEBM, 61 SEGMENT_TYPE_NB 62} SegmentType; 63 64enum { 65 FRAG_TYPE_NONE = 0, 66 FRAG_TYPE_EVERY_FRAME, 67 FRAG_TYPE_DURATION, 68 FRAG_TYPE_PFRAMES, 69 FRAG_TYPE_NB 70}; 71 72#define MPD_PROFILE_DASH 1 73#define MPD_PROFILE_DVB 2 74 75typedef struct Segment { 76 char file[1024]; 77 int64_t start_pos; 78 int range_length, index_length; 79 int64_t time; 80 double prog_date_time; 81 int64_t duration; 82 int n; 83} Segment; 84 85typedef struct AdaptationSet { 86 int id; 87 char *descriptor; 88 int64_t seg_duration; 89 int64_t frag_duration; 90 int frag_type; 91 enum AVMediaType media_type; 92 AVDictionary *metadata; 93 AVRational min_frame_rate, max_frame_rate; 94 int ambiguous_frame_rate; 95 int64_t max_frag_duration; 96 int max_width, max_height; 97 int nb_streams; 98 AVRational par; 99 int trick_idx; 100} AdaptationSet; 101 102typedef struct OutputStream { 103 AVFormatContext *ctx; 104 int ctx_inited, as_idx; 105 AVIOContext *out; 106 AVCodecParserContext *parser; 107 AVCodecContext *parser_avctx; 108 int packets_written; 109 char initfile[1024]; 110 int64_t init_start_pos, pos; 111 int init_range_length; 112 int nb_segments, segments_size, segment_index; 113 int64_t seg_duration; 114 int64_t frag_duration; 115 int64_t last_duration; 116 Segment **segments; 117 int64_t first_pts, start_pts, max_pts; 118 int64_t last_dts, last_pts; 119 int last_flags; 120 int bit_rate; 121 int first_segment_bit_rate; 122 SegmentType segment_type; /* segment type selected for this particular stream */ 123 const char *format_name; 124 const char *extension_name; 125 const char *single_file_name; /* file names selected for this particular stream */ 126 const char *init_seg_name; 127 const char *media_seg_name; 128 129 char codec_str[100]; 130 int written_len; 131 char filename[1024]; 132 char full_path[1024]; 133 char temp_path[1024]; 134 double availability_time_offset; 135 AVProducerReferenceTime producer_reference_time; 136 char producer_reference_time_str[100]; 137 int total_pkt_size; 138 int64_t total_pkt_duration; 139 int muxer_overhead; 140 int frag_type; 141 int64_t gop_size; 142 AVRational sar; 143 int coding_dependency; 144} OutputStream; 145 146typedef struct DASHContext { 147 const AVClass *class; /* Class for private options. */ 148 char *adaptation_sets; 149 AdaptationSet *as; 150 int nb_as; 151 int window_size; 152 int extra_window_size; 153 int64_t seg_duration; 154 int64_t frag_duration; 155 int remove_at_exit; 156 int use_template; 157 int use_timeline; 158 int single_file; 159 OutputStream *streams; 160 int has_video; 161 int64_t last_duration; 162 int64_t total_duration; 163 char availability_start_time[100]; 164 time_t start_time_s; 165 int64_t presentation_time_offset; 166 char dirname[1024]; 167 const char *single_file_name; /* file names as specified in options */ 168 const char *init_seg_name; 169 const char *media_seg_name; 170 const char *utc_timing_url; 171 const char *method; 172 const char *user_agent; 173 AVDictionary *http_opts; 174 int hls_playlist; 175 const char *hls_master_name; 176 int http_persistent; 177 int master_playlist_created; 178 AVIOContext *mpd_out; 179 AVIOContext *m3u8_out; 180 int streaming; 181 int64_t timeout; 182 int index_correction; 183 AVDictionary *format_options; 184 int global_sidx; 185 SegmentType segment_type_option; /* segment type as specified in options */ 186 int ignore_io_errors; 187 int lhls; 188 int ldash; 189 int master_publish_rate; 190 int nr_of_streams_to_flush; 191 int nr_of_streams_flushed; 192 int frag_type; 193 int write_prft; 194 int64_t max_gop_size; 195 int64_t max_segment_duration; 196 int profile; 197 int64_t target_latency; 198 int target_latency_refid; 199 AVRational min_playback_rate; 200 AVRational max_playback_rate; 201 int64_t update_period; 202} DASHContext; 203 204static struct codec_string { 205 int id; 206 const char *str; 207} codecs[] = { 208 { AV_CODEC_ID_VP8, "vp8" }, 209 { AV_CODEC_ID_VP9, "vp9" }, 210 { AV_CODEC_ID_VORBIS, "vorbis" }, 211 { AV_CODEC_ID_OPUS, "opus" }, 212 { AV_CODEC_ID_FLAC, "flac" }, 213 { 0, NULL } 214}; 215 216static struct format_string { 217 SegmentType segment_type; 218 const char *str; 219} formats[] = { 220 { SEGMENT_TYPE_AUTO, "auto" }, 221 { SEGMENT_TYPE_MP4, "mp4" }, 222 { SEGMENT_TYPE_WEBM, "webm" }, 223 { 0, NULL } 224}; 225 226static int dashenc_io_open(AVFormatContext *s, AVIOContext **pb, char *filename, 227 AVDictionary **options) { 228 DASHContext *c = s->priv_data; 229 int http_base_proto = filename ? ff_is_http_proto(filename) : 0; 230 int err = AVERROR_MUXER_NOT_FOUND; 231 if (!*pb || !http_base_proto || !c->http_persistent) { 232 err = s->io_open(s, pb, filename, AVIO_FLAG_WRITE, options); 233#if CONFIG_HTTP_PROTOCOL 234 } else { 235 URLContext *http_url_context = ffio_geturlcontext(*pb); 236 av_assert0(http_url_context); 237 err = ff_http_do_new_request(http_url_context, filename); 238 if (err < 0) 239 ff_format_io_close(s, pb); 240#endif 241 } 242 return err; 243} 244 245static void dashenc_io_close(AVFormatContext *s, AVIOContext **pb, char *filename) { 246 DASHContext *c = s->priv_data; 247 int http_base_proto = filename ? ff_is_http_proto(filename) : 0; 248 249 if (!*pb) 250 return; 251 252 if (!http_base_proto || !c->http_persistent) { 253 ff_format_io_close(s, pb); 254#if CONFIG_HTTP_PROTOCOL 255 } else { 256 URLContext *http_url_context = ffio_geturlcontext(*pb); 257 av_assert0(http_url_context); 258 avio_flush(*pb); 259 ffurl_shutdown(http_url_context, AVIO_FLAG_WRITE); 260#endif 261 } 262} 263 264static const char *get_format_str(SegmentType segment_type) { 265 int i; 266 for (i = 0; i < SEGMENT_TYPE_NB; i++) 267 if (formats[i].segment_type == segment_type) 268 return formats[i].str; 269 return NULL; 270} 271 272static const char *get_extension_str(SegmentType type, int single_file) 273{ 274 switch (type) { 275 276 case SEGMENT_TYPE_MP4: return single_file ? "mp4" : "m4s"; 277 case SEGMENT_TYPE_WEBM: return "webm"; 278 default: return NULL; 279 } 280} 281 282static int handle_io_open_error(AVFormatContext *s, int err, char *url) { 283 DASHContext *c = s->priv_data; 284 char errbuf[AV_ERROR_MAX_STRING_SIZE]; 285 av_strerror(err, errbuf, sizeof(errbuf)); 286 av_log(s, c->ignore_io_errors ? AV_LOG_WARNING : AV_LOG_ERROR, 287 "Unable to open %s for writing: %s\n", url, errbuf); 288 return c->ignore_io_errors ? 0 : err; 289} 290 291static inline SegmentType select_segment_type(SegmentType segment_type, enum AVCodecID codec_id) 292{ 293 if (segment_type == SEGMENT_TYPE_AUTO) { 294 if (codec_id == AV_CODEC_ID_OPUS || codec_id == AV_CODEC_ID_VORBIS || 295 codec_id == AV_CODEC_ID_VP8 || codec_id == AV_CODEC_ID_VP9) { 296 segment_type = SEGMENT_TYPE_WEBM; 297 } else { 298 segment_type = SEGMENT_TYPE_MP4; 299 } 300 } 301 302 return segment_type; 303} 304 305static int init_segment_types(AVFormatContext *s) 306{ 307 DASHContext *c = s->priv_data; 308 int has_mp4_streams = 0; 309 for (int i = 0; i < s->nb_streams; ++i) { 310 OutputStream *os = &c->streams[i]; 311 SegmentType segment_type = select_segment_type( 312 c->segment_type_option, s->streams[i]->codecpar->codec_id); 313 os->segment_type = segment_type; 314 os->format_name = get_format_str(segment_type); 315 if (!os->format_name) { 316 av_log(s, AV_LOG_ERROR, "Could not select DASH segment type for stream %d\n", i); 317 return AVERROR_MUXER_NOT_FOUND; 318 } 319 os->extension_name = get_extension_str(segment_type, c->single_file); 320 if (!os->extension_name) { 321 av_log(s, AV_LOG_ERROR, "Could not get extension type for stream %d\n", i); 322 return AVERROR_MUXER_NOT_FOUND; 323 } 324 325 has_mp4_streams |= segment_type == SEGMENT_TYPE_MP4; 326 } 327 328 if (c->hls_playlist && !has_mp4_streams) { 329 av_log(s, AV_LOG_WARNING, "No mp4 streams, disabling HLS manifest generation\n"); 330 c->hls_playlist = 0; 331 } 332 333 return 0; 334} 335 336static void set_vp9_codec_str(AVFormatContext *s, AVCodecParameters *par, 337 AVRational *frame_rate, char *str, int size) { 338 VPCC vpcc; 339 int ret = ff_isom_get_vpcc_features(s, par, frame_rate, &vpcc); 340 if (ret == 0) { 341 av_strlcatf(str, size, "vp09.%02d.%02d.%02d", 342 vpcc.profile, vpcc.level, vpcc.bitdepth); 343 } else { 344 // Default to just vp9 in case of error while finding out profile or level 345 av_log(s, AV_LOG_WARNING, "Could not find VP9 profile and/or level\n"); 346 av_strlcpy(str, "vp9", size); 347 } 348 return; 349} 350 351static void set_codec_str(AVFormatContext *s, AVCodecParameters *par, 352 AVRational *frame_rate, char *str, int size) 353{ 354 const AVCodecTag *tags[2] = { NULL, NULL }; 355 uint32_t tag; 356 int i; 357 358 // common Webm codecs are not part of RFC 6381 359 for (i = 0; codecs[i].id; i++) 360 if (codecs[i].id == par->codec_id) { 361 if (codecs[i].id == AV_CODEC_ID_VP9) { 362 set_vp9_codec_str(s, par, frame_rate, str, size); 363 } else { 364 av_strlcpy(str, codecs[i].str, size); 365 } 366 return; 367 } 368 369 // for codecs part of RFC 6381 370 if (par->codec_type == AVMEDIA_TYPE_VIDEO) 371 tags[0] = ff_codec_movvideo_tags; 372 else if (par->codec_type == AVMEDIA_TYPE_AUDIO) 373 tags[0] = ff_codec_movaudio_tags; 374 else 375 return; 376 377 tag = par->codec_tag; 378 if (!tag) 379 tag = av_codec_get_tag(tags, par->codec_id); 380 if (!tag) 381 return; 382 if (size < 5) 383 return; 384 385 AV_WL32(str, tag); 386 str[4] = '\0'; 387 if (!strcmp(str, "mp4a") || !strcmp(str, "mp4v")) { 388 uint32_t oti; 389 tags[0] = ff_mp4_obj_type; 390 oti = av_codec_get_tag(tags, par->codec_id); 391 if (oti) 392 av_strlcatf(str, size, ".%02"PRIx32, oti); 393 else 394 return; 395 396 if (tag == MKTAG('m', 'p', '4', 'a')) { 397 if (par->extradata_size >= 2) { 398 int aot = par->extradata[0] >> 3; 399 if (aot == 31) 400 aot = ((AV_RB16(par->extradata) >> 5) & 0x3f) + 32; 401 av_strlcatf(str, size, ".%d", aot); 402 } 403 } else if (tag == MKTAG('m', 'p', '4', 'v')) { 404 // Unimplemented, should output ProfileLevelIndication as a decimal number 405 av_log(s, AV_LOG_WARNING, "Incomplete RFC 6381 codec string for mp4v\n"); 406 } 407 } else if (!strcmp(str, "avc1")) { 408 uint8_t *tmpbuf = NULL; 409 uint8_t *extradata = par->extradata; 410 int extradata_size = par->extradata_size; 411 if (!extradata_size) 412 return; 413 if (extradata[0] != 1) { 414 AVIOContext *pb; 415 if (avio_open_dyn_buf(&pb) < 0) 416 return; 417 if (ff_isom_write_avcc(pb, extradata, extradata_size) < 0) { 418 ffio_free_dyn_buf(&pb); 419 return; 420 } 421 extradata_size = avio_close_dyn_buf(pb, &extradata); 422 tmpbuf = extradata; 423 } 424 425 if (extradata_size >= 4) 426 av_strlcatf(str, size, ".%02x%02x%02x", 427 extradata[1], extradata[2], extradata[3]); 428 av_free(tmpbuf); 429 } else if (!strcmp(str, "av01")) { 430 AV1SequenceParameters seq; 431 if (!par->extradata_size) 432 return; 433 if (ff_av1_parse_seq_header(&seq, par->extradata, par->extradata_size) < 0) 434 return; 435 436 av_strlcatf(str, size, ".%01u.%02u%s.%02u", 437 seq.profile, seq.level, seq.tier ? "H" : "M", seq.bitdepth); 438 if (seq.color_description_present_flag) 439 av_strlcatf(str, size, ".%01u.%01u%01u%01u.%02u.%02u.%02u.%01u", 440 seq.monochrome, 441 seq.chroma_subsampling_x, seq.chroma_subsampling_y, seq.chroma_sample_position, 442 seq.color_primaries, seq.transfer_characteristics, seq.matrix_coefficients, 443 seq.color_range); 444 } 445} 446 447static int flush_dynbuf(DASHContext *c, OutputStream *os, int *range_length) 448{ 449 uint8_t *buffer; 450 451 if (!os->ctx->pb) { 452 return AVERROR(EINVAL); 453 } 454 455 // flush 456 av_write_frame(os->ctx, NULL); 457 avio_flush(os->ctx->pb); 458 459 if (!c->single_file) { 460 // write out to file 461 *range_length = avio_close_dyn_buf(os->ctx->pb, &buffer); 462 os->ctx->pb = NULL; 463 if (os->out) 464 avio_write(os->out, buffer + os->written_len, *range_length - os->written_len); 465 os->written_len = 0; 466 av_free(buffer); 467 468 // re-open buffer 469 return avio_open_dyn_buf(&os->ctx->pb); 470 } else { 471 *range_length = avio_tell(os->ctx->pb) - os->pos; 472 return 0; 473 } 474} 475 476static void set_http_options(AVDictionary **options, DASHContext *c) 477{ 478 if (c->method) 479 av_dict_set(options, "method", c->method, 0); 480 av_dict_copy(options, c->http_opts, 0); 481 if (c->user_agent) 482 av_dict_set(options, "user_agent", c->user_agent, 0); 483 if (c->http_persistent) 484 av_dict_set_int(options, "multiple_requests", 1, 0); 485 if (c->timeout >= 0) 486 av_dict_set_int(options, "timeout", c->timeout, 0); 487} 488 489static void get_hls_playlist_name(char *playlist_name, int string_size, 490 const char *base_url, int id) { 491 if (base_url) 492 snprintf(playlist_name, string_size, "%smedia_%d.m3u8", base_url, id); 493 else 494 snprintf(playlist_name, string_size, "media_%d.m3u8", id); 495} 496 497static void get_start_index_number(OutputStream *os, DASHContext *c, 498 int *start_index, int *start_number) { 499 *start_index = 0; 500 *start_number = 1; 501 if (c->window_size) { 502 *start_index = FFMAX(os->nb_segments - c->window_size, 0); 503 *start_number = FFMAX(os->segment_index - c->window_size, 1); 504 } 505} 506 507static void write_hls_media_playlist(OutputStream *os, AVFormatContext *s, 508 int representation_id, int final, 509 char *prefetch_url) { 510 DASHContext *c = s->priv_data; 511 int timescale = os->ctx->streams[0]->time_base.den; 512 char temp_filename_hls[1024]; 513 char filename_hls[1024]; 514 AVDictionary *http_opts = NULL; 515 int target_duration = 0; 516 int ret = 0; 517 const char *proto = avio_find_protocol_name(c->dirname); 518 int use_rename = proto && !strcmp(proto, "file"); 519 int i, start_index, start_number; 520 double prog_date_time = 0; 521 522 get_start_index_number(os, c, &start_index, &start_number); 523 524 if (!c->hls_playlist || start_index >= os->nb_segments || 525 os->segment_type != SEGMENT_TYPE_MP4) 526 return; 527 528 get_hls_playlist_name(filename_hls, sizeof(filename_hls), 529 c->dirname, representation_id); 530 531 snprintf(temp_filename_hls, sizeof(temp_filename_hls), use_rename ? "%s.tmp" : "%s", filename_hls); 532 533 set_http_options(&http_opts, c); 534 ret = dashenc_io_open(s, &c->m3u8_out, temp_filename_hls, &http_opts); 535 av_dict_free(&http_opts); 536 if (ret < 0) { 537 handle_io_open_error(s, ret, temp_filename_hls); 538 return; 539 } 540 for (i = start_index; i < os->nb_segments; i++) { 541 Segment *seg = os->segments[i]; 542 double duration = (double) seg->duration / timescale; 543 if (target_duration <= duration) 544 target_duration = lrint(duration); 545 } 546 547 ff_hls_write_playlist_header(c->m3u8_out, 6, -1, target_duration, 548 start_number, PLAYLIST_TYPE_NONE, 0); 549 550 ff_hls_write_init_file(c->m3u8_out, os->initfile, c->single_file, 551 os->init_range_length, os->init_start_pos); 552 553 for (i = start_index; i < os->nb_segments; i++) { 554 Segment *seg = os->segments[i]; 555 556 if (fabs(prog_date_time) < 1e-7) { 557 if (os->nb_segments == 1) 558 prog_date_time = c->start_time_s; 559 else 560 prog_date_time = seg->prog_date_time; 561 } 562 seg->prog_date_time = prog_date_time; 563 564 ret = ff_hls_write_file_entry(c->m3u8_out, 0, c->single_file, 565 (double) seg->duration / timescale, 0, 566 seg->range_length, seg->start_pos, NULL, 567 c->single_file ? os->initfile : seg->file, 568 &prog_date_time, 0, 0, 0); 569 if (ret < 0) { 570 av_log(os->ctx, AV_LOG_WARNING, "ff_hls_write_file_entry get error\n"); 571 } 572 } 573 574 if (prefetch_url) 575 avio_printf(c->m3u8_out, "#EXT-X-PREFETCH:%s\n", prefetch_url); 576 577 if (final) 578 ff_hls_write_end_list(c->m3u8_out); 579 580 dashenc_io_close(s, &c->m3u8_out, temp_filename_hls); 581 582 if (use_rename) 583 ff_rename(temp_filename_hls, filename_hls, os->ctx); 584} 585 586static int flush_init_segment(AVFormatContext *s, OutputStream *os) 587{ 588 DASHContext *c = s->priv_data; 589 int ret, range_length; 590 591 ret = flush_dynbuf(c, os, &range_length); 592 if (ret < 0) 593 return ret; 594 595 os->pos = os->init_range_length = range_length; 596 if (!c->single_file) { 597 char filename[1024]; 598 snprintf(filename, sizeof(filename), "%s%s", c->dirname, os->initfile); 599 dashenc_io_close(s, &os->out, filename); 600 } 601 return 0; 602} 603 604static void dash_free(AVFormatContext *s) 605{ 606 DASHContext *c = s->priv_data; 607 int i, j; 608 609 if (c->as) { 610 for (i = 0; i < c->nb_as; i++) { 611 av_dict_free(&c->as[i].metadata); 612 av_freep(&c->as[i].descriptor); 613 } 614 av_freep(&c->as); 615 c->nb_as = 0; 616 } 617 618 if (!c->streams) 619 return; 620 for (i = 0; i < s->nb_streams; i++) { 621 OutputStream *os = &c->streams[i]; 622 if (os->ctx && os->ctx->pb) { 623 if (!c->single_file) 624 ffio_free_dyn_buf(&os->ctx->pb); 625 else 626 avio_close(os->ctx->pb); 627 } 628 ff_format_io_close(s, &os->out); 629 avformat_free_context(os->ctx); 630 avcodec_free_context(&os->parser_avctx); 631 av_parser_close(os->parser); 632 for (j = 0; j < os->nb_segments; j++) 633 av_free(os->segments[j]); 634 av_free(os->segments); 635 av_freep(&os->single_file_name); 636 av_freep(&os->init_seg_name); 637 av_freep(&os->media_seg_name); 638 } 639 av_freep(&c->streams); 640 641 ff_format_io_close(s, &c->mpd_out); 642 ff_format_io_close(s, &c->m3u8_out); 643} 644 645static void output_segment_list(OutputStream *os, AVIOContext *out, AVFormatContext *s, 646 int representation_id, int final) 647{ 648 DASHContext *c = s->priv_data; 649 int i, start_index, start_number; 650 get_start_index_number(os, c, &start_index, &start_number); 651 652 if (c->use_template) { 653 int timescale = c->use_timeline ? os->ctx->streams[0]->time_base.den : AV_TIME_BASE; 654 avio_printf(out, "\t\t\t\t<SegmentTemplate timescale=\"%d\" ", timescale); 655 if (!c->use_timeline) { 656 avio_printf(out, "duration=\"%"PRId64"\" ", os->seg_duration); 657 if (c->streaming && os->availability_time_offset) 658 avio_printf(out, "availabilityTimeOffset=\"%.3f\" ", 659 os->availability_time_offset); 660 } 661 if (c->streaming && os->availability_time_offset && !final) 662 avio_printf(out, "availabilityTimeComplete=\"false\" "); 663 664 avio_printf(out, "initialization=\"%s\" media=\"%s\" startNumber=\"%d\"", os->init_seg_name, os->media_seg_name, c->use_timeline ? start_number : 1); 665 if (c->presentation_time_offset) 666 avio_printf(out, " presentationTimeOffset=\"%"PRId64"\"", c->presentation_time_offset); 667 avio_printf(out, ">\n"); 668 if (c->use_timeline) { 669 int64_t cur_time = 0; 670 avio_printf(out, "\t\t\t\t\t<SegmentTimeline>\n"); 671 for (i = start_index; i < os->nb_segments; ) { 672 Segment *seg = os->segments[i]; 673 int repeat = 0; 674 avio_printf(out, "\t\t\t\t\t\t<S "); 675 if (i == start_index || seg->time != cur_time) { 676 cur_time = seg->time; 677 avio_printf(out, "t=\"%"PRId64"\" ", seg->time); 678 } 679 avio_printf(out, "d=\"%"PRId64"\" ", seg->duration); 680 while (i + repeat + 1 < os->nb_segments && 681 os->segments[i + repeat + 1]->duration == seg->duration && 682 os->segments[i + repeat + 1]->time == os->segments[i + repeat]->time + os->segments[i + repeat]->duration) 683 repeat++; 684 if (repeat > 0) 685 avio_printf(out, "r=\"%d\" ", repeat); 686 avio_printf(out, "/>\n"); 687 i += 1 + repeat; 688 cur_time += (1 + repeat) * seg->duration; 689 } 690 avio_printf(out, "\t\t\t\t\t</SegmentTimeline>\n"); 691 } 692 avio_printf(out, "\t\t\t\t</SegmentTemplate>\n"); 693 } else if (c->single_file) { 694 avio_printf(out, "\t\t\t\t<BaseURL>%s</BaseURL>\n", os->initfile); 695 avio_printf(out, "\t\t\t\t<SegmentList timescale=\"%d\" duration=\"%"PRId64"\" startNumber=\"%d\">\n", AV_TIME_BASE, FFMIN(os->seg_duration, os->last_duration), start_number); 696 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); 697 for (i = start_index; i < os->nb_segments; i++) { 698 Segment *seg = os->segments[i]; 699 avio_printf(out, "\t\t\t\t\t<SegmentURL mediaRange=\"%"PRId64"-%"PRId64"\" ", seg->start_pos, seg->start_pos + seg->range_length - 1); 700 if (seg->index_length) 701 avio_printf(out, "indexRange=\"%"PRId64"-%"PRId64"\" ", seg->start_pos, seg->start_pos + seg->index_length - 1); 702 avio_printf(out, "/>\n"); 703 } 704 avio_printf(out, "\t\t\t\t</SegmentList>\n"); 705 } else { 706 avio_printf(out, "\t\t\t\t<SegmentList timescale=\"%d\" duration=\"%"PRId64"\" startNumber=\"%d\">\n", AV_TIME_BASE, FFMIN(os->seg_duration, os->last_duration), start_number); 707 avio_printf(out, "\t\t\t\t\t<Initialization sourceURL=\"%s\" />\n", os->initfile); 708 for (i = start_index; i < os->nb_segments; i++) { 709 Segment *seg = os->segments[i]; 710 avio_printf(out, "\t\t\t\t\t<SegmentURL media=\"%s\" />\n", seg->file); 711 } 712 avio_printf(out, "\t\t\t\t</SegmentList>\n"); 713 } 714 if (!c->lhls || final) { 715 write_hls_media_playlist(os, s, representation_id, final, NULL); 716 } 717 718} 719 720static char *xmlescape(const char *str) { 721 int outlen = strlen(str)*3/2 + 6; 722 char *out = av_realloc(NULL, outlen + 1); 723 int pos = 0; 724 if (!out) 725 return NULL; 726 for (; *str; str++) { 727 if (pos + 6 > outlen) { 728 char *tmp; 729 outlen = 2 * outlen + 6; 730 tmp = av_realloc(out, outlen + 1); 731 if (!tmp) { 732 av_free(out); 733 return NULL; 734 } 735 out = tmp; 736 } 737 if (*str == '&') { 738 memcpy(&out[pos], "&", 5); 739 pos += 5; 740 } else if (*str == '<') { 741 memcpy(&out[pos], "<", 4); 742 pos += 4; 743 } else if (*str == '>') { 744 memcpy(&out[pos], ">", 4); 745 pos += 4; 746 } else if (*str == '\'') { 747 memcpy(&out[pos], "'", 6); 748 pos += 6; 749 } else if (*str == '\"') { 750 memcpy(&out[pos], """, 6); 751 pos += 6; 752 } else { 753 out[pos++] = *str; 754 } 755 } 756 out[pos] = '\0'; 757 return out; 758} 759 760static void write_time(AVIOContext *out, int64_t time) 761{ 762 int seconds = time / AV_TIME_BASE; 763 int fractions = time % AV_TIME_BASE; 764 int minutes = seconds / 60; 765 int hours = minutes / 60; 766 seconds %= 60; 767 minutes %= 60; 768 avio_printf(out, "PT"); 769 if (hours) 770 avio_printf(out, "%dH", hours); 771 if (hours || minutes) 772 avio_printf(out, "%dM", minutes); 773 avio_printf(out, "%d.%dS", seconds, fractions / (AV_TIME_BASE / 10)); 774} 775 776static void format_date(char *buf, int size, int64_t time_us) 777{ 778 struct tm *ptm, tmbuf; 779 int64_t time_ms = time_us / 1000; 780 const time_t time_s = time_ms / 1000; 781 int millisec = time_ms - (time_s * 1000); 782 ptm = gmtime_r(&time_s, &tmbuf); 783 if (ptm) { 784 int len; 785 if (!strftime(buf, size, "%Y-%m-%dT%H:%M:%S", ptm)) { 786 buf[0] = '\0'; 787 return; 788 } 789 len = strlen(buf); 790 snprintf(buf + len, size - len, ".%03dZ", millisec); 791 } 792} 793 794static int write_adaptation_set(AVFormatContext *s, AVIOContext *out, int as_index, 795 int final) 796{ 797 DASHContext *c = s->priv_data; 798 AdaptationSet *as = &c->as[as_index]; 799 AVDictionaryEntry *lang, *role; 800 int i; 801 802 avio_printf(out, "\t\t<AdaptationSet id=\"%d\" contentType=\"%s\" startWithSAP=\"1\" segmentAlignment=\"true\" bitstreamSwitching=\"true\"", 803 as->id, as->media_type == AVMEDIA_TYPE_VIDEO ? "video" : "audio"); 804 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) 805 avio_printf(out, " maxFrameRate=\"%d/%d\"", as->max_frame_rate.num, as->max_frame_rate.den); 806 else 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)) 807 avio_printf(out, " frameRate=\"%d/%d\"", as->max_frame_rate.num, as->max_frame_rate.den); 808 if (as->media_type == AVMEDIA_TYPE_VIDEO) { 809 avio_printf(out, " maxWidth=\"%d\" maxHeight=\"%d\"", as->max_width, as->max_height); 810 avio_printf(out, " par=\"%d:%d\"", as->par.num, as->par.den); 811 } 812 lang = av_dict_get(as->metadata, "language", NULL, 0); 813 if (lang) 814 avio_printf(out, " lang=\"%s\"", lang->value); 815 avio_printf(out, ">\n"); 816 817 if (!final && c->ldash && as->max_frag_duration && !(c->profile & MPD_PROFILE_DVB)) 818 avio_printf(out, "\t\t\t<Resync dT=\"%"PRId64"\" type=\"0\"/>\n", as->max_frag_duration); 819 if (as->trick_idx >= 0) 820 avio_printf(out, "\t\t\t<EssentialProperty id=\"%d\" schemeIdUri=\"http://dashif.org/guidelines/trickmode\" value=\"%d\"/>\n", as->id, as->trick_idx); 821 role = av_dict_get(as->metadata, "role", NULL, 0); 822 if (role) 823 avio_printf(out, "\t\t\t<Role schemeIdUri=\"urn:mpeg:dash:role:2011\" value=\"%s\"/>\n", role->value); 824 if (as->descriptor) 825 avio_printf(out, "\t\t\t%s\n", as->descriptor); 826 for (i = 0; i < s->nb_streams; i++) { 827 AVStream *st = s->streams[i]; 828 OutputStream *os = &c->streams[i]; 829 char bandwidth_str[64] = {'\0'}; 830 831 if (os->as_idx - 1 != as_index) 832 continue; 833 834 if (os->bit_rate > 0) 835 snprintf(bandwidth_str, sizeof(bandwidth_str), " bandwidth=\"%d\"", os->bit_rate); 836 else if (final) { 837 int average_bit_rate = os->pos * 8 * AV_TIME_BASE / c->total_duration; 838 snprintf(bandwidth_str, sizeof(bandwidth_str), " bandwidth=\"%d\"", average_bit_rate); 839 } else if (os->first_segment_bit_rate > 0) 840 snprintf(bandwidth_str, sizeof(bandwidth_str), " bandwidth=\"%d\"", os->first_segment_bit_rate); 841 842 if (as->media_type == AVMEDIA_TYPE_VIDEO) { 843 avio_printf(out, "\t\t\t<Representation id=\"%d\" mimeType=\"video/%s\" codecs=\"%s\"%s width=\"%d\" height=\"%d\"", 844 i, os->format_name, os->codec_str, bandwidth_str, s->streams[i]->codecpar->width, s->streams[i]->codecpar->height); 845 if (st->codecpar->field_order == AV_FIELD_UNKNOWN) 846 avio_printf(out, " scanType=\"unknown\""); 847 else if (st->codecpar->field_order != AV_FIELD_PROGRESSIVE) 848 avio_printf(out, " scanType=\"interlaced\""); 849 avio_printf(out, " sar=\"%d:%d\"", os->sar.num, os->sar.den); 850 if (st->avg_frame_rate.num && av_cmp_q(as->min_frame_rate, as->max_frame_rate) < 0) 851 avio_printf(out, " frameRate=\"%d/%d\"", st->avg_frame_rate.num, st->avg_frame_rate.den); 852 if (as->trick_idx >= 0) { 853 AdaptationSet *tas = &c->as[as->trick_idx]; 854 if (!as->ambiguous_frame_rate && !tas->ambiguous_frame_rate) 855 avio_printf(out, " maxPlayoutRate=\"%d\"", FFMAX((int)av_q2d(av_div_q(tas->min_frame_rate, as->min_frame_rate)), 1)); 856 } 857 if (!os->coding_dependency) 858 avio_printf(out, " codingDependency=\"false\""); 859 avio_printf(out, ">\n"); 860 } else { 861 avio_printf(out, "\t\t\t<Representation id=\"%d\" mimeType=\"audio/%s\" codecs=\"%s\"%s audioSamplingRate=\"%d\">\n", 862 i, os->format_name, os->codec_str, bandwidth_str, s->streams[i]->codecpar->sample_rate); 863 avio_printf(out, "\t\t\t\t<AudioChannelConfiguration schemeIdUri=\"urn:mpeg:dash:23003:3:audio_channel_configuration:2011\" value=\"%d\" />\n", 864 s->streams[i]->codecpar->ch_layout.nb_channels); 865 } 866 if (!final && c->write_prft && os->producer_reference_time_str[0]) { 867 avio_printf(out, "\t\t\t\t<ProducerReferenceTime id=\"%d\" inband=\"true\" type=\"%s\" wallClockTime=\"%s\" presentationTime=\"%"PRId64"\">\n", 868 i, os->producer_reference_time.flags ? "captured" : "encoder", os->producer_reference_time_str, c->presentation_time_offset); 869 avio_printf(out, "\t\t\t\t\t<UTCTiming schemeIdUri=\"urn:mpeg:dash:utc:http-xsdate:2014\" value=\"%s\"/>\n", c->utc_timing_url); 870 avio_printf(out, "\t\t\t\t</ProducerReferenceTime>\n"); 871 } 872 if (!final && c->ldash && os->gop_size && os->frag_type != FRAG_TYPE_NONE && !(c->profile & MPD_PROFILE_DVB) && 873 (os->frag_type != FRAG_TYPE_DURATION || os->frag_duration != os->seg_duration)) 874 avio_printf(out, "\t\t\t\t<Resync dT=\"%"PRId64"\" type=\"1\"/>\n", os->gop_size); 875 output_segment_list(os, out, s, i, final); 876 avio_printf(out, "\t\t\t</Representation>\n"); 877 } 878 avio_printf(out, "\t\t</AdaptationSet>\n"); 879 880 return 0; 881} 882 883static int add_adaptation_set(AVFormatContext *s, AdaptationSet **as, enum AVMediaType type) 884{ 885 DASHContext *c = s->priv_data; 886 void *mem; 887 888 if (c->profile & MPD_PROFILE_DVB && (c->nb_as + 1) > 16) { 889 av_log(s, AV_LOG_ERROR, "DVB-DASH profile allows a max of 16 Adaptation Sets\n"); 890 return AVERROR(EINVAL); 891 } 892 mem = av_realloc(c->as, sizeof(*c->as) * (c->nb_as + 1)); 893 if (!mem) 894 return AVERROR(ENOMEM); 895 c->as = mem; 896 ++c->nb_as; 897 898 *as = &c->as[c->nb_as - 1]; 899 memset(*as, 0, sizeof(**as)); 900 (*as)->media_type = type; 901 (*as)->frag_type = -1; 902 (*as)->trick_idx = -1; 903 904 return 0; 905} 906 907static int adaptation_set_add_stream(AVFormatContext *s, int as_idx, int i) 908{ 909 DASHContext *c = s->priv_data; 910 AdaptationSet *as = &c->as[as_idx - 1]; 911 OutputStream *os = &c->streams[i]; 912 913 if (as->media_type != s->streams[i]->codecpar->codec_type) { 914 av_log(s, AV_LOG_ERROR, "Codec type of stream %d doesn't match AdaptationSet's media type\n", i); 915 return AVERROR(EINVAL); 916 } else if (os->as_idx) { 917 av_log(s, AV_LOG_ERROR, "Stream %d is already assigned to an AdaptationSet\n", i); 918 return AVERROR(EINVAL); 919 } 920 if (c->profile & MPD_PROFILE_DVB && (as->nb_streams + 1) > 16) { 921 av_log(s, AV_LOG_ERROR, "DVB-DASH profile allows a max of 16 Representations per Adaptation Set\n"); 922 return AVERROR(EINVAL); 923 } 924 os->as_idx = as_idx; 925 ++as->nb_streams; 926 927 return 0; 928} 929 930static int parse_adaptation_sets(AVFormatContext *s) 931{ 932 DASHContext *c = s->priv_data; 933 const char *p = c->adaptation_sets; 934 enum { new_set, parse_default, parsing_streams, parse_seg_duration, parse_frag_duration } state; 935 AdaptationSet *as; 936 int i, n, ret; 937 938 // default: one AdaptationSet for each stream 939 if (!p) { 940 for (i = 0; i < s->nb_streams; i++) { 941 if ((ret = add_adaptation_set(s, &as, s->streams[i]->codecpar->codec_type)) < 0) 942 return ret; 943 as->id = i; 944 945 c->streams[i].as_idx = c->nb_as; 946 ++as->nb_streams; 947 } 948 goto end; 949 } 950 951 // syntax id=0,streams=0,1,2 id=1,streams=3,4 and so on 952 // option id=0,descriptor=descriptor_str,streams=0,1,2 and so on 953 // option id=0,seg_duration=2.5,frag_duration=0.5,streams=0,1,2 954 // id=1,trick_id=0,seg_duration=10,frag_type=none,streams=3 and so on 955 // descriptor is useful to the scheme defined by ISO/IEC 23009-1:2014/Amd.2:2015 956 // descriptor_str should be a self-closing xml tag. 957 // seg_duration and frag_duration have the same syntax as the global options of 958 // the same name, and the former have precedence over them if set. 959 state = new_set; 960 while (*p) { 961 if (*p == ' ') { 962 p++; 963 continue; 964 } else if (state == new_set && av_strstart(p, "id=", &p)) { 965 char id_str[10], *end_str; 966 967 n = strcspn(p, ","); 968 snprintf(id_str, sizeof(id_str), "%.*s", n, p); 969 970 i = strtol(id_str, &end_str, 10); 971 if (id_str == end_str || i < 0 || i > c->nb_as) { 972 av_log(s, AV_LOG_ERROR, "\"%s\" is not a valid value for an AdaptationSet id\n", id_str); 973 return AVERROR(EINVAL); 974 } 975 976 if ((ret = add_adaptation_set(s, &as, AVMEDIA_TYPE_UNKNOWN)) < 0) 977 return ret; 978 as->id = i; 979 980 p += n; 981 if (*p) 982 p++; 983 state = parse_default; 984 } else if (state != new_set && av_strstart(p, "seg_duration=", &p)) { 985 state = parse_seg_duration; 986 } else if (state != new_set && av_strstart(p, "frag_duration=", &p)) { 987 state = parse_frag_duration; 988 } else if (state == parse_seg_duration || state == parse_frag_duration) { 989 char str[32]; 990 int64_t usecs = 0; 991 992 n = strcspn(p, ","); 993 snprintf(str, sizeof(str), "%.*s", n, p); 994 p += n; 995 if (*p) 996 p++; 997 998 ret = av_parse_time(&usecs, str, 1); 999 if (ret < 0) { 1000 av_log(s, AV_LOG_ERROR, "Unable to parse option value \"%s\" as duration\n", str); 1001 return ret; 1002 } 1003 1004 if (state == parse_seg_duration) 1005 as->seg_duration = usecs; 1006 else 1007 as->frag_duration = usecs; 1008 state = parse_default; 1009 } else if (state != new_set && av_strstart(p, "frag_type=", &p)) { 1010 char type_str[16]; 1011 1012 n = strcspn(p, ","); 1013 snprintf(type_str, sizeof(type_str), "%.*s", n, p); 1014 p += n; 1015 if (*p) 1016 p++; 1017 1018 if (!strcmp(type_str, "duration")) 1019 as->frag_type = FRAG_TYPE_DURATION; 1020 else if (!strcmp(type_str, "pframes")) 1021 as->frag_type = FRAG_TYPE_PFRAMES; 1022 else if (!strcmp(type_str, "every_frame")) 1023 as->frag_type = FRAG_TYPE_EVERY_FRAME; 1024 else if (!strcmp(type_str, "none")) 1025 as->frag_type = FRAG_TYPE_NONE; 1026 else { 1027 av_log(s, AV_LOG_ERROR, "Unable to parse option value \"%s\" as fragment type\n", type_str); 1028 return ret; 1029 } 1030 state = parse_default; 1031 } else if (state != new_set && av_strstart(p, "descriptor=", &p)) { 1032 n = strcspn(p, ">") + 1; //followed by one comma, so plus 1 1033 if (n < strlen(p)) { 1034 as->descriptor = av_strndup(p, n); 1035 } else { 1036 av_log(s, AV_LOG_ERROR, "Parse error, descriptor string should be a self-closing xml tag\n"); 1037 return AVERROR(EINVAL); 1038 } 1039 p += n; 1040 if (*p) 1041 p++; 1042 state = parse_default; 1043 } else if ((state != new_set) && av_strstart(p, "trick_id=", &p)) { 1044 char trick_id_str[10], *end_str; 1045 1046 n = strcspn(p, ","); 1047 snprintf(trick_id_str, sizeof(trick_id_str), "%.*s", n, p); 1048 p += n; 1049 1050 as->trick_idx = strtol(trick_id_str, &end_str, 10); 1051 if (trick_id_str == end_str || as->trick_idx < 0) 1052 return AVERROR(EINVAL); 1053 1054 if (*p) 1055 p++; 1056 state = parse_default; 1057 } else if ((state != new_set) && av_strstart(p, "streams=", &p)) { //descriptor and durations are optional 1058 state = parsing_streams; 1059 } else if (state == parsing_streams) { 1060 AdaptationSet *as = &c->as[c->nb_as - 1]; 1061 char idx_str[8], *end_str; 1062 1063 n = strcspn(p, " ,"); 1064 snprintf(idx_str, sizeof(idx_str), "%.*s", n, p); 1065 p += n; 1066 1067 // if value is "a" or "v", map all streams of that type 1068 if (as->media_type == AVMEDIA_TYPE_UNKNOWN && (idx_str[0] == 'v' || idx_str[0] == 'a')) { 1069 enum AVMediaType type = (idx_str[0] == 'v') ? AVMEDIA_TYPE_VIDEO : AVMEDIA_TYPE_AUDIO; 1070 av_log(s, AV_LOG_DEBUG, "Map all streams of type %s\n", idx_str); 1071 1072 for (i = 0; i < s->nb_streams; i++) { 1073 if (s->streams[i]->codecpar->codec_type != type) 1074 continue; 1075 1076 as->media_type = s->streams[i]->codecpar->codec_type; 1077 1078 if ((ret = adaptation_set_add_stream(s, c->nb_as, i)) < 0) 1079 return ret; 1080 } 1081 } else { // select single stream 1082 i = strtol(idx_str, &end_str, 10); 1083 if (idx_str == end_str || i < 0 || i >= s->nb_streams) { 1084 av_log(s, AV_LOG_ERROR, "Selected stream \"%s\" not found!\n", idx_str); 1085 return AVERROR(EINVAL); 1086 } 1087 av_log(s, AV_LOG_DEBUG, "Map stream %d\n", i); 1088 1089 if (as->media_type == AVMEDIA_TYPE_UNKNOWN) { 1090 as->media_type = s->streams[i]->codecpar->codec_type; 1091 } 1092 1093 if ((ret = adaptation_set_add_stream(s, c->nb_as, i)) < 0) 1094 return ret; 1095 } 1096 1097 if (*p == ' ') 1098 state = new_set; 1099 if (*p) 1100 p++; 1101 } else { 1102 return AVERROR(EINVAL); 1103 } 1104 } 1105 1106end: 1107 // check for unassigned streams 1108 for (i = 0; i < s->nb_streams; i++) { 1109 OutputStream *os = &c->streams[i]; 1110 if (!os->as_idx) { 1111 av_log(s, AV_LOG_ERROR, "Stream %d is not mapped to an AdaptationSet\n", i); 1112 return AVERROR(EINVAL); 1113 } 1114 } 1115 1116 // check references for trick mode AdaptationSet 1117 for (i = 0; i < c->nb_as; i++) { 1118 as = &c->as[i]; 1119 if (as->trick_idx < 0) 1120 continue; 1121 for (n = 0; n < c->nb_as; n++) { 1122 if (c->as[n].id == as->trick_idx) 1123 break; 1124 } 1125 if (n >= c->nb_as) { 1126 av_log(s, AV_LOG_ERROR, "reference AdaptationSet id \"%d\" not found for trick mode AdaptationSet id \"%d\"\n", as->trick_idx, as->id); 1127 return AVERROR(EINVAL); 1128 } 1129 } 1130 1131 return 0; 1132} 1133 1134static int write_manifest(AVFormatContext *s, int final) 1135{ 1136 DASHContext *c = s->priv_data; 1137 AVIOContext *out; 1138 char temp_filename[1024]; 1139 int ret, i; 1140 const char *proto = avio_find_protocol_name(s->url); 1141 int use_rename = proto && !strcmp(proto, "file"); 1142 static unsigned int warned_non_file = 0; 1143 AVDictionaryEntry *title = av_dict_get(s->metadata, "title", NULL, 0); 1144 AVDictionary *opts = NULL; 1145 1146 if (!use_rename && !warned_non_file++) 1147 av_log(s, AV_LOG_ERROR, "Cannot use rename on non file protocol, this may lead to races and temporary partial files\n"); 1148 1149 snprintf(temp_filename, sizeof(temp_filename), use_rename ? "%s.tmp" : "%s", s->url); 1150 set_http_options(&opts, c); 1151 ret = dashenc_io_open(s, &c->mpd_out, temp_filename, &opts); 1152 av_dict_free(&opts); 1153 if (ret < 0) { 1154 return handle_io_open_error(s, ret, temp_filename); 1155 } 1156 out = c->mpd_out; 1157 avio_printf(out, "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"); 1158 avio_printf(out, "<MPD xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"\n" 1159 "\txmlns=\"urn:mpeg:dash:schema:mpd:2011\"\n" 1160 "\txmlns:xlink=\"http://www.w3.org/1999/xlink\"\n" 1161 "\txsi:schemaLocation=\"urn:mpeg:DASH:schema:MPD:2011 http://standards.iso.org/ittf/PubliclyAvailableStandards/MPEG-DASH_schema_files/DASH-MPD.xsd\"\n" 1162 "\tprofiles=\""); 1163 if (c->profile & MPD_PROFILE_DASH) 1164 avio_printf(out, "%s%s", "urn:mpeg:dash:profile:isoff-live:2011", c->profile & MPD_PROFILE_DVB ? "," : "\"\n"); 1165 if (c->profile & MPD_PROFILE_DVB) 1166 avio_printf(out, "%s", "urn:dvb:dash:profile:dvb-dash:2014\"\n"); 1167 avio_printf(out, "\ttype=\"%s\"\n", 1168 final ? "static" : "dynamic"); 1169 if (final) { 1170 avio_printf(out, "\tmediaPresentationDuration=\""); 1171 write_time(out, c->total_duration); 1172 avio_printf(out, "\"\n"); 1173 } else { 1174 int64_t update_period = c->last_duration / AV_TIME_BASE; 1175 char now_str[100]; 1176 if (c->use_template && !c->use_timeline) 1177 update_period = 500; 1178 if (c->update_period) 1179 update_period = c->update_period; 1180 avio_printf(out, "\tminimumUpdatePeriod=\"PT%"PRId64"S\"\n", update_period); 1181 if (!c->ldash) 1182 avio_printf(out, "\tsuggestedPresentationDelay=\"PT%"PRId64"S\"\n", c->last_duration / AV_TIME_BASE); 1183 if (c->availability_start_time[0]) 1184 avio_printf(out, "\tavailabilityStartTime=\"%s\"\n", c->availability_start_time); 1185 format_date(now_str, sizeof(now_str), av_gettime()); 1186 if (now_str[0]) 1187 avio_printf(out, "\tpublishTime=\"%s\"\n", now_str); 1188 if (c->window_size && c->use_template) { 1189 avio_printf(out, "\ttimeShiftBufferDepth=\""); 1190 write_time(out, c->last_duration * c->window_size); 1191 avio_printf(out, "\"\n"); 1192 } 1193 } 1194 avio_printf(out, "\tmaxSegmentDuration=\""); 1195 write_time(out, c->max_segment_duration); 1196 avio_printf(out, "\"\n"); 1197 avio_printf(out, "\tminBufferTime=\""); 1198 write_time(out, c->ldash && c->max_gop_size ? c->max_gop_size : c->last_duration * 2); 1199 avio_printf(out, "\">\n"); 1200 avio_printf(out, "\t<ProgramInformation>\n"); 1201 if (title) { 1202 char *escaped = xmlescape(title->value); 1203 avio_printf(out, "\t\t<Title>%s</Title>\n", escaped); 1204 av_free(escaped); 1205 } 1206 avio_printf(out, "\t</ProgramInformation>\n"); 1207 1208 avio_printf(out, "\t<ServiceDescription id=\"0\">\n"); 1209 if (!final && c->target_latency && c->target_latency_refid >= 0) { 1210 avio_printf(out, "\t\t<Latency target=\"%"PRId64"\"", c->target_latency / 1000); 1211 if (s->nb_streams > 1) 1212 avio_printf(out, " referenceId=\"%d\"", c->target_latency_refid); 1213 avio_printf(out, "/>\n"); 1214 } 1215 if (av_cmp_q(c->min_playback_rate, (AVRational) {1, 1}) || 1216 av_cmp_q(c->max_playback_rate, (AVRational) {1, 1})) 1217 avio_printf(out, "\t\t<PlaybackRate min=\"%.2f\" max=\"%.2f\"/>\n", 1218 av_q2d(c->min_playback_rate), av_q2d(c->max_playback_rate)); 1219 avio_printf(out, "\t</ServiceDescription>\n"); 1220 1221 if (c->window_size && s->nb_streams > 0 && c->streams[0].nb_segments > 0 && !c->use_template) { 1222 OutputStream *os = &c->streams[0]; 1223 int start_index = FFMAX(os->nb_segments - c->window_size, 0); 1224 int64_t start_time = av_rescale_q(os->segments[start_index]->time, s->streams[0]->time_base, AV_TIME_BASE_Q); 1225 avio_printf(out, "\t<Period id=\"0\" start=\""); 1226 write_time(out, start_time); 1227 avio_printf(out, "\">\n"); 1228 } else { 1229 avio_printf(out, "\t<Period id=\"0\" start=\"PT0.0S\">\n"); 1230 } 1231 1232 for (i = 0; i < c->nb_as; i++) { 1233 if ((ret = write_adaptation_set(s, out, i, final)) < 0) 1234 return ret; 1235 } 1236 avio_printf(out, "\t</Period>\n"); 1237 1238 if (c->utc_timing_url) 1239 avio_printf(out, "\t<UTCTiming schemeIdUri=\"urn:mpeg:dash:utc:http-xsdate:2014\" value=\"%s\"/>\n", c->utc_timing_url); 1240 1241 avio_printf(out, "</MPD>\n"); 1242 avio_flush(out); 1243 dashenc_io_close(s, &c->mpd_out, temp_filename); 1244 1245 if (use_rename) { 1246 if ((ret = ff_rename(temp_filename, s->url, s)) < 0) 1247 return ret; 1248 } 1249 1250 if (c->hls_playlist) { 1251 char filename_hls[1024]; 1252 1253 // Publish master playlist only the configured rate 1254 if (c->master_playlist_created && (!c->master_publish_rate || 1255 c->streams[0].segment_index % c->master_publish_rate)) 1256 return 0; 1257 1258 if (*c->dirname) 1259 snprintf(filename_hls, sizeof(filename_hls), "%s%s", c->dirname, c->hls_master_name); 1260 else 1261 snprintf(filename_hls, sizeof(filename_hls), "%s", c->hls_master_name); 1262 1263 snprintf(temp_filename, sizeof(temp_filename), use_rename ? "%s.tmp" : "%s", filename_hls); 1264 1265 set_http_options(&opts, c); 1266 ret = dashenc_io_open(s, &c->m3u8_out, temp_filename, &opts); 1267 av_dict_free(&opts); 1268 if (ret < 0) { 1269 return handle_io_open_error(s, ret, temp_filename); 1270 } 1271 1272 ff_hls_write_playlist_version(c->m3u8_out, 7); 1273 1274 if (c->has_video) { 1275 // treat audio streams as alternative renditions for video streams 1276 const char *audio_group = "A1"; 1277 char audio_codec_str[128] = "\0"; 1278 int is_default = 1; 1279 int max_audio_bitrate = 0; 1280 1281 for (i = 0; i < s->nb_streams; i++) { 1282 char playlist_file[64]; 1283 AVStream *st = s->streams[i]; 1284 OutputStream *os = &c->streams[i]; 1285 if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO) 1286 continue; 1287 if (os->segment_type != SEGMENT_TYPE_MP4) 1288 continue; 1289 get_hls_playlist_name(playlist_file, sizeof(playlist_file), NULL, i); 1290 ff_hls_write_audio_rendition(c->m3u8_out, (char *)audio_group, 1291 playlist_file, NULL, i, is_default); 1292 max_audio_bitrate = FFMAX(st->codecpar->bit_rate + 1293 os->muxer_overhead, max_audio_bitrate); 1294 if (!av_strnstr(audio_codec_str, os->codec_str, sizeof(audio_codec_str))) { 1295 if (strlen(audio_codec_str)) 1296 av_strlcat(audio_codec_str, ",", sizeof(audio_codec_str)); 1297 av_strlcat(audio_codec_str, os->codec_str, sizeof(audio_codec_str)); 1298 } 1299 is_default = 0; 1300 } 1301 1302 for (i = 0; i < s->nb_streams; i++) { 1303 char playlist_file[64]; 1304 char codec_str[128]; 1305 AVStream *st = s->streams[i]; 1306 OutputStream *os = &c->streams[i]; 1307 char *agroup = NULL; 1308 int stream_bitrate = os->muxer_overhead; 1309 if (os->bit_rate > 0) 1310 stream_bitrate += os->bit_rate; 1311 else if (final) 1312 stream_bitrate += os->pos * 8 * AV_TIME_BASE / c->total_duration; 1313 else if (os->first_segment_bit_rate > 0) 1314 stream_bitrate += os->first_segment_bit_rate; 1315 if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO) 1316 continue; 1317 if (os->segment_type != SEGMENT_TYPE_MP4) 1318 continue; 1319 av_strlcpy(codec_str, os->codec_str, sizeof(codec_str)); 1320 if (max_audio_bitrate) { 1321 agroup = (char *)audio_group; 1322 stream_bitrate += max_audio_bitrate; 1323 av_strlcat(codec_str, ",", sizeof(codec_str)); 1324 av_strlcat(codec_str, audio_codec_str, sizeof(codec_str)); 1325 } 1326 get_hls_playlist_name(playlist_file, sizeof(playlist_file), NULL, i); 1327 ff_hls_write_stream_info(st, c->m3u8_out, stream_bitrate, 1328 playlist_file, agroup, 1329 codec_str, NULL, NULL); 1330 } 1331 1332 } else { 1333 // treat audio streams as separate renditions 1334 1335 for (i = 0; i < s->nb_streams; i++) { 1336 char playlist_file[64]; 1337 char codec_str[128]; 1338 AVStream *st = s->streams[i]; 1339 OutputStream *os = &c->streams[i]; 1340 int stream_bitrate = os->muxer_overhead; 1341 if (os->bit_rate > 0) 1342 stream_bitrate += os->bit_rate; 1343 else if (final) 1344 stream_bitrate += os->pos * 8 * AV_TIME_BASE / c->total_duration; 1345 else if (os->first_segment_bit_rate > 0) 1346 stream_bitrate += os->first_segment_bit_rate; 1347 if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO) 1348 continue; 1349 if (os->segment_type != SEGMENT_TYPE_MP4) 1350 continue; 1351 av_strlcpy(codec_str, os->codec_str, sizeof(codec_str)); 1352 get_hls_playlist_name(playlist_file, sizeof(playlist_file), NULL, i); 1353 ff_hls_write_stream_info(st, c->m3u8_out, stream_bitrate, 1354 playlist_file, NULL, 1355 codec_str, NULL, NULL); 1356 } 1357 } 1358 1359 dashenc_io_close(s, &c->m3u8_out, temp_filename); 1360 if (use_rename) 1361 if ((ret = ff_rename(temp_filename, filename_hls, s)) < 0) 1362 return ret; 1363 c->master_playlist_created = 1; 1364 } 1365 1366 return 0; 1367} 1368 1369static int dict_copy_entry(AVDictionary **dst, const AVDictionary *src, const char *key) 1370{ 1371 AVDictionaryEntry *entry = av_dict_get(src, key, NULL, 0); 1372 if (entry) 1373 av_dict_set(dst, key, entry->value, AV_DICT_DONT_OVERWRITE); 1374 return 0; 1375} 1376 1377static int dash_init(AVFormatContext *s) 1378{ 1379 DASHContext *c = s->priv_data; 1380 int ret = 0, i; 1381 char *ptr; 1382 char basename[1024]; 1383 1384 c->nr_of_streams_to_flush = 0; 1385 if (c->single_file_name) 1386 c->single_file = 1; 1387 if (c->single_file) 1388 c->use_template = 0; 1389 1390 if (!c->profile) { 1391 av_log(s, AV_LOG_ERROR, "At least one profile must be enabled.\n"); 1392 return AVERROR(EINVAL); 1393 } 1394 if (c->lhls && s->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) { 1395 av_log(s, AV_LOG_ERROR, 1396 "LHLS is experimental, Please set -strict experimental in order to enable it.\n"); 1397 return AVERROR_EXPERIMENTAL; 1398 } 1399 1400 if (c->lhls && !c->streaming) { 1401 av_log(s, AV_LOG_WARNING, "Enabling streaming as LHLS is enabled\n"); 1402 c->streaming = 1; 1403 } 1404 1405 if (c->lhls && !c->hls_playlist) { 1406 av_log(s, AV_LOG_INFO, "Enabling hls_playlist as LHLS is enabled\n"); 1407 c->hls_playlist = 1; 1408 } 1409 1410 if (c->ldash && !c->streaming) { 1411 av_log(s, AV_LOG_WARNING, "Enabling streaming as LDash is enabled\n"); 1412 c->streaming = 1; 1413 } 1414 1415 if (c->target_latency && !c->streaming) { 1416 av_log(s, AV_LOG_WARNING, "Target latency option will be ignored as streaming is not enabled\n"); 1417 c->target_latency = 0; 1418 } 1419 1420 if (c->global_sidx && !c->single_file) { 1421 av_log(s, AV_LOG_WARNING, "Global SIDX option will be ignored as single_file is not enabled\n"); 1422 c->global_sidx = 0; 1423 } 1424 1425 if (c->global_sidx && c->streaming) { 1426 av_log(s, AV_LOG_WARNING, "Global SIDX option will be ignored as streaming is enabled\n"); 1427 c->global_sidx = 0; 1428 } 1429 if (c->frag_type == FRAG_TYPE_NONE && c->streaming) { 1430 av_log(s, AV_LOG_VERBOSE, "Changing frag_type from none to every_frame as streaming is enabled\n"); 1431 c->frag_type = FRAG_TYPE_EVERY_FRAME; 1432 } 1433 1434 if (c->write_prft < 0) { 1435 c->write_prft = c->ldash; 1436 if (c->ldash) 1437 av_log(s, AV_LOG_VERBOSE, "Enabling Producer Reference Time element for Low Latency mode\n"); 1438 } 1439 1440 if (c->write_prft && !c->utc_timing_url) { 1441 av_log(s, AV_LOG_WARNING, "Producer Reference Time element option will be ignored as utc_timing_url is not set\n"); 1442 c->write_prft = 0; 1443 } 1444 1445 if (c->write_prft && !c->streaming) { 1446 av_log(s, AV_LOG_WARNING, "Producer Reference Time element option will be ignored as streaming is not enabled\n"); 1447 c->write_prft = 0; 1448 } 1449 1450 if (c->ldash && !c->write_prft) { 1451 av_log(s, AV_LOG_WARNING, "Low Latency mode enabled without Producer Reference Time element option! Resulting manifest may not be complaint\n"); 1452 } 1453 1454 if (c->target_latency && !c->write_prft) { 1455 av_log(s, AV_LOG_WARNING, "Target latency option will be ignored as Producer Reference Time element will not be written\n"); 1456 c->target_latency = 0; 1457 } 1458 1459 if (av_cmp_q(c->max_playback_rate, c->min_playback_rate) < 0) { 1460 av_log(s, AV_LOG_WARNING, "Minimum playback rate value is higer than the Maximum. Both will be ignored\n"); 1461 c->min_playback_rate = c->max_playback_rate = (AVRational) {1, 1}; 1462 } 1463 1464 av_strlcpy(c->dirname, s->url, sizeof(c->dirname)); 1465 ptr = strrchr(c->dirname, '/'); 1466 if (ptr) { 1467 av_strlcpy(basename, &ptr[1], sizeof(basename)); 1468 ptr[1] = '\0'; 1469 } else { 1470 c->dirname[0] = '\0'; 1471 av_strlcpy(basename, s->url, sizeof(basename)); 1472 } 1473 1474 ptr = strrchr(basename, '.'); 1475 if (ptr) 1476 *ptr = '\0'; 1477 1478 c->streams = av_mallocz(sizeof(*c->streams) * s->nb_streams); 1479 if (!c->streams) 1480 return AVERROR(ENOMEM); 1481 1482 if ((ret = parse_adaptation_sets(s)) < 0) 1483 return ret; 1484 1485 if ((ret = init_segment_types(s)) < 0) 1486 return ret; 1487 1488 for (i = 0; i < s->nb_streams; i++) { 1489 OutputStream *os = &c->streams[i]; 1490 AdaptationSet *as = &c->as[os->as_idx - 1]; 1491 AVFormatContext *ctx; 1492 AVStream *st; 1493 AVDictionary *opts = NULL; 1494 char filename[1024]; 1495 1496 os->bit_rate = s->streams[i]->codecpar->bit_rate; 1497 if (!os->bit_rate) { 1498 int level = s->strict_std_compliance >= FF_COMPLIANCE_STRICT ? 1499 AV_LOG_ERROR : AV_LOG_WARNING; 1500 av_log(s, level, "No bit rate set for stream %d\n", i); 1501 if (s->strict_std_compliance >= FF_COMPLIANCE_STRICT) 1502 return AVERROR(EINVAL); 1503 } 1504 1505 // copy AdaptationSet language and role from stream metadata 1506 dict_copy_entry(&as->metadata, s->streams[i]->metadata, "language"); 1507 dict_copy_entry(&as->metadata, s->streams[i]->metadata, "role"); 1508 1509 if (c->init_seg_name) { 1510 os->init_seg_name = av_strireplace(c->init_seg_name, "$ext$", os->extension_name); 1511 if (!os->init_seg_name) 1512 return AVERROR(ENOMEM); 1513 } 1514 if (c->media_seg_name) { 1515 os->media_seg_name = av_strireplace(c->media_seg_name, "$ext$", os->extension_name); 1516 if (!os->media_seg_name) 1517 return AVERROR(ENOMEM); 1518 } 1519 if (c->single_file_name) { 1520 os->single_file_name = av_strireplace(c->single_file_name, "$ext$", os->extension_name); 1521 if (!os->single_file_name) 1522 return AVERROR(ENOMEM); 1523 } 1524 1525 if (os->segment_type == SEGMENT_TYPE_WEBM) { 1526 if ((!c->single_file && !av_match_ext(os->init_seg_name, os->format_name)) || 1527 (!c->single_file && !av_match_ext(os->media_seg_name, os->format_name)) || 1528 ( c->single_file && !av_match_ext(os->single_file_name, os->format_name))) { 1529 av_log(s, AV_LOG_WARNING, 1530 "One or many segment file names doesn't end with .webm. " 1531 "Override -init_seg_name and/or -media_seg_name and/or " 1532 "-single_file_name to end with the extension .webm\n"); 1533 } 1534 if (c->streaming) { 1535 // Streaming not supported as matroskaenc buffers internally before writing the output 1536 av_log(s, AV_LOG_WARNING, "One or more streams in WebM output format. Streaming option will be ignored\n"); 1537 c->streaming = 0; 1538 } 1539 } 1540 1541 os->ctx = ctx = avformat_alloc_context(); 1542 if (!ctx) 1543 return AVERROR(ENOMEM); 1544 1545 ctx->oformat = av_guess_format(os->format_name, NULL, NULL); 1546 if (!ctx->oformat) 1547 return AVERROR_MUXER_NOT_FOUND; 1548 ctx->interrupt_callback = s->interrupt_callback; 1549 ctx->opaque = s->opaque; 1550 ctx->io_close = s->io_close; 1551 ctx->io_close2 = s->io_close2; 1552 ctx->io_open = s->io_open; 1553 ctx->strict_std_compliance = s->strict_std_compliance; 1554 1555 if (!(st = avformat_new_stream(ctx, NULL))) 1556 return AVERROR(ENOMEM); 1557 avcodec_parameters_copy(st->codecpar, s->streams[i]->codecpar); 1558 st->sample_aspect_ratio = s->streams[i]->sample_aspect_ratio; 1559 st->time_base = s->streams[i]->time_base; 1560 st->avg_frame_rate = s->streams[i]->avg_frame_rate; 1561 ctx->avoid_negative_ts = s->avoid_negative_ts; 1562 ctx->flags = s->flags; 1563 1564 os->parser = av_parser_init(st->codecpar->codec_id); 1565 if (os->parser) { 1566 os->parser_avctx = avcodec_alloc_context3(NULL); 1567 if (!os->parser_avctx) 1568 return AVERROR(ENOMEM); 1569 ret = avcodec_parameters_to_context(os->parser_avctx, st->codecpar); 1570 if (ret < 0) 1571 return ret; 1572 // We only want to parse frame headers 1573 os->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES; 1574 } 1575 1576 if (c->single_file) { 1577 if (os->single_file_name) 1578 ff_dash_fill_tmpl_params(os->initfile, sizeof(os->initfile), os->single_file_name, i, 0, os->bit_rate, 0); 1579 else 1580 snprintf(os->initfile, sizeof(os->initfile), "%s-stream%d.%s", basename, i, os->format_name); 1581 } else { 1582 ff_dash_fill_tmpl_params(os->initfile, sizeof(os->initfile), os->init_seg_name, i, 0, os->bit_rate, 0); 1583 } 1584 snprintf(filename, sizeof(filename), "%s%s", c->dirname, os->initfile); 1585 set_http_options(&opts, c); 1586 if (!c->single_file) { 1587 if ((ret = avio_open_dyn_buf(&ctx->pb)) < 0) 1588 return ret; 1589 ret = s->io_open(s, &os->out, filename, AVIO_FLAG_WRITE, &opts); 1590 } else { 1591 ctx->url = av_strdup(filename); 1592 ret = avio_open2(&ctx->pb, filename, AVIO_FLAG_WRITE, NULL, &opts); 1593 } 1594 av_dict_free(&opts); 1595 if (ret < 0) 1596 return ret; 1597 os->init_start_pos = 0; 1598 1599 av_dict_copy(&opts, c->format_options, 0); 1600 if (!as->seg_duration) 1601 as->seg_duration = c->seg_duration; 1602 if (!as->frag_duration) 1603 as->frag_duration = c->frag_duration; 1604 if (as->frag_type < 0) 1605 as->frag_type = c->frag_type; 1606 os->seg_duration = as->seg_duration; 1607 os->frag_duration = as->frag_duration; 1608 os->frag_type = as->frag_type; 1609 1610 c->max_segment_duration = FFMAX(c->max_segment_duration, as->seg_duration); 1611 1612 if (c->profile & MPD_PROFILE_DVB && (os->seg_duration > 15000000 || os->seg_duration < 960000)) { 1613 av_log(s, AV_LOG_ERROR, "Segment duration %"PRId64" is outside the allowed range for DVB-DASH profile\n", os->seg_duration); 1614 return AVERROR(EINVAL); 1615 } 1616 1617 if (os->frag_type == FRAG_TYPE_DURATION && !os->frag_duration) { 1618 av_log(s, AV_LOG_WARNING, "frag_type set to duration for stream %d but no frag_duration set\n", i); 1619 os->frag_type = c->streaming ? FRAG_TYPE_EVERY_FRAME : FRAG_TYPE_NONE; 1620 } 1621 if (os->frag_type == FRAG_TYPE_DURATION && os->frag_duration > os->seg_duration) { 1622 av_log(s, AV_LOG_ERROR, "Fragment duration %"PRId64" is longer than Segment duration %"PRId64"\n", os->frag_duration, os->seg_duration); 1623 return AVERROR(EINVAL); 1624 } 1625 if (os->frag_type == FRAG_TYPE_PFRAMES && (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO || !os->parser)) { 1626 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && !os->parser) 1627 av_log(s, AV_LOG_WARNING, "frag_type set to P-Frame reordering, but no parser found for stream %d\n", i); 1628 os->frag_type = c->streaming ? FRAG_TYPE_EVERY_FRAME : FRAG_TYPE_NONE; 1629 } 1630 if (os->frag_type != FRAG_TYPE_PFRAMES && as->trick_idx < 0) 1631 // Set this now if a parser isn't used 1632 os->coding_dependency = 1; 1633 1634 if (os->segment_type == SEGMENT_TYPE_MP4) { 1635 if (c->streaming) 1636 // skip_sidx : Reduce bitrate overhead 1637 // skip_trailer : Avoids growing memory usage with time 1638 av_dict_set(&opts, "movflags", "+dash+delay_moov+skip_sidx+skip_trailer", AV_DICT_APPEND); 1639 else { 1640 if (c->global_sidx) 1641 av_dict_set(&opts, "movflags", "+dash+delay_moov+global_sidx+skip_trailer", AV_DICT_APPEND); 1642 else 1643 av_dict_set(&opts, "movflags", "+dash+delay_moov+skip_trailer", AV_DICT_APPEND); 1644 } 1645 if (os->frag_type == FRAG_TYPE_EVERY_FRAME) 1646 av_dict_set(&opts, "movflags", "+frag_every_frame", AV_DICT_APPEND); 1647 else 1648 av_dict_set(&opts, "movflags", "+frag_custom", AV_DICT_APPEND); 1649 if (os->frag_type == FRAG_TYPE_DURATION) 1650 av_dict_set_int(&opts, "frag_duration", os->frag_duration, 0); 1651 if (c->write_prft) 1652 av_dict_set(&opts, "write_prft", "wallclock", 0); 1653 } else { 1654 av_dict_set_int(&opts, "cluster_time_limit", c->seg_duration / 1000, 0); 1655 av_dict_set_int(&opts, "cluster_size_limit", 5 * 1024 * 1024, 0); // set a large cluster size limit 1656 av_dict_set_int(&opts, "dash", 1, 0); 1657 av_dict_set_int(&opts, "dash_track_number", i + 1, 0); 1658 av_dict_set_int(&opts, "live", 1, 0); 1659 } 1660 ret = avformat_init_output(ctx, &opts); 1661 av_dict_free(&opts); 1662 if (ret < 0) 1663 return ret; 1664 os->ctx_inited = 1; 1665 avio_flush(ctx->pb); 1666 1667 av_log(s, AV_LOG_VERBOSE, "Representation %d init segment will be written to: %s\n", i, filename); 1668 1669 s->streams[i]->time_base = st->time_base; 1670 // If the muxer wants to shift timestamps, request to have them shifted 1671 // already before being handed to this muxer, so we don't have mismatches 1672 // between the MPD and the actual segments. 1673 s->avoid_negative_ts = ctx->avoid_negative_ts; 1674 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) { 1675 AVRational avg_frame_rate = s->streams[i]->avg_frame_rate; 1676 AVRational par; 1677 if (avg_frame_rate.num > 0) { 1678 if (av_cmp_q(avg_frame_rate, as->min_frame_rate) < 0) 1679 as->min_frame_rate = avg_frame_rate; 1680 if (av_cmp_q(as->max_frame_rate, avg_frame_rate) < 0) 1681 as->max_frame_rate = avg_frame_rate; 1682 } else { 1683 as->ambiguous_frame_rate = 1; 1684 } 1685 1686 if (st->codecpar->width > as->max_width) 1687 as->max_width = st->codecpar->width; 1688 if (st->codecpar->height > as->max_height) 1689 as->max_height = st->codecpar->height; 1690 1691 if (st->sample_aspect_ratio.num) 1692 os->sar = st->sample_aspect_ratio; 1693 else 1694 os->sar = (AVRational){1,1}; 1695 av_reduce(&par.num, &par.den, 1696 st->codecpar->width * (int64_t)os->sar.num, 1697 st->codecpar->height * (int64_t)os->sar.den, 1698 1024 * 1024); 1699 1700 if (as->par.num && av_cmp_q(par, as->par)) { 1701 av_log(s, AV_LOG_ERROR, "Conflicting stream aspect ratios values in Adaptation Set %d. Please ensure all adaptation sets have the same aspect ratio\n", os->as_idx); 1702 return AVERROR(EINVAL); 1703 } 1704 as->par = par; 1705 1706 c->has_video = 1; 1707 } 1708 1709 set_codec_str(s, st->codecpar, &st->avg_frame_rate, os->codec_str, 1710 sizeof(os->codec_str)); 1711 os->first_pts = AV_NOPTS_VALUE; 1712 os->max_pts = AV_NOPTS_VALUE; 1713 os->last_dts = AV_NOPTS_VALUE; 1714 os->segment_index = 1; 1715 1716 if (s->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) 1717 c->nr_of_streams_to_flush++; 1718 } 1719 1720 if (!c->has_video && c->seg_duration <= 0) { 1721 av_log(s, AV_LOG_WARNING, "no video stream and no seg duration set\n"); 1722 return AVERROR(EINVAL); 1723 } 1724 if (!c->has_video && c->frag_type == FRAG_TYPE_PFRAMES) 1725 av_log(s, AV_LOG_WARNING, "no video stream and P-frame fragmentation set\n"); 1726 1727 c->nr_of_streams_flushed = 0; 1728 c->target_latency_refid = -1; 1729 1730 return 0; 1731} 1732 1733static int dash_write_header(AVFormatContext *s) 1734{ 1735 DASHContext *c = s->priv_data; 1736 int i, ret; 1737 for (i = 0; i < s->nb_streams; i++) { 1738 OutputStream *os = &c->streams[i]; 1739 if ((ret = avformat_write_header(os->ctx, NULL)) < 0) 1740 return ret; 1741 1742 // Flush init segment 1743 // Only for WebM segment, since for mp4 delay_moov is set and 1744 // the init segment is thus flushed after the first packets. 1745 if (os->segment_type == SEGMENT_TYPE_WEBM && 1746 (ret = flush_init_segment(s, os)) < 0) 1747 return ret; 1748 } 1749 return ret; 1750} 1751 1752static int add_segment(OutputStream *os, const char *file, 1753 int64_t time, int64_t duration, 1754 int64_t start_pos, int64_t range_length, 1755 int64_t index_length, int next_exp_index) 1756{ 1757 int err; 1758 Segment *seg; 1759 if (os->nb_segments >= os->segments_size) { 1760 os->segments_size = (os->segments_size + 1) * 2; 1761 if ((err = av_reallocp_array(&os->segments, sizeof(*os->segments), 1762 os->segments_size)) < 0) { 1763 os->segments_size = 0; 1764 os->nb_segments = 0; 1765 return err; 1766 } 1767 } 1768 seg = av_mallocz(sizeof(*seg)); 1769 if (!seg) 1770 return AVERROR(ENOMEM); 1771 av_strlcpy(seg->file, file, sizeof(seg->file)); 1772 seg->time = time; 1773 seg->duration = duration; 1774 if (seg->time < 0) { // If pts<0, it is expected to be cut away with an edit list 1775 seg->duration += seg->time; 1776 seg->time = 0; 1777 } 1778 seg->start_pos = start_pos; 1779 seg->range_length = range_length; 1780 seg->index_length = index_length; 1781 os->segments[os->nb_segments++] = seg; 1782 os->segment_index++; 1783 //correcting the segment index if it has fallen behind the expected value 1784 if (os->segment_index < next_exp_index) { 1785 av_log(NULL, AV_LOG_WARNING, "Correcting the segment index after file %s: current=%d corrected=%d\n", 1786 file, os->segment_index, next_exp_index); 1787 os->segment_index = next_exp_index; 1788 } 1789 return 0; 1790} 1791 1792static void write_styp(AVIOContext *pb) 1793{ 1794 avio_wb32(pb, 24); 1795 ffio_wfourcc(pb, "styp"); 1796 ffio_wfourcc(pb, "msdh"); 1797 avio_wb32(pb, 0); /* minor */ 1798 ffio_wfourcc(pb, "msdh"); 1799 ffio_wfourcc(pb, "msix"); 1800} 1801 1802static void find_index_range(AVFormatContext *s, const char *full_path, 1803 int64_t pos, int *index_length) 1804{ 1805 uint8_t buf[8]; 1806 AVIOContext *pb; 1807 int ret; 1808 1809 ret = s->io_open(s, &pb, full_path, AVIO_FLAG_READ, NULL); 1810 if (ret < 0) 1811 return; 1812 if (avio_seek(pb, pos, SEEK_SET) != pos) { 1813 ff_format_io_close(s, &pb); 1814 return; 1815 } 1816 ret = avio_read(pb, buf, 8); 1817 ff_format_io_close(s, &pb); 1818 if (ret < 8) 1819 return; 1820 if (AV_RL32(&buf[4]) != MKTAG('s', 'i', 'd', 'x')) 1821 return; 1822 *index_length = AV_RB32(&buf[0]); 1823} 1824 1825static int update_stream_extradata(AVFormatContext *s, OutputStream *os, 1826 AVPacket *pkt, AVRational *frame_rate) 1827{ 1828 AVCodecParameters *par = os->ctx->streams[0]->codecpar; 1829 uint8_t *extradata; 1830 size_t extradata_size; 1831 int ret; 1832 1833 if (par->extradata_size) 1834 return 0; 1835 1836 extradata = av_packet_get_side_data(pkt, AV_PKT_DATA_NEW_EXTRADATA, &extradata_size); 1837 if (!extradata_size) 1838 return 0; 1839 1840 ret = ff_alloc_extradata(par, extradata_size); 1841 if (ret < 0) 1842 return ret; 1843 1844 memcpy(par->extradata, extradata, extradata_size); 1845 1846 set_codec_str(s, par, frame_rate, os->codec_str, sizeof(os->codec_str)); 1847 1848 return 0; 1849} 1850 1851static void dashenc_delete_file(AVFormatContext *s, char *filename) { 1852 DASHContext *c = s->priv_data; 1853 int http_base_proto = ff_is_http_proto(filename); 1854 1855 if (http_base_proto) { 1856 AVIOContext *out = NULL; 1857 AVDictionary *http_opts = NULL; 1858 1859 set_http_options(&http_opts, c); 1860 av_dict_set(&http_opts, "method", "DELETE", 0); 1861 1862 if (dashenc_io_open(s, &out, filename, &http_opts) < 0) { 1863 av_log(s, AV_LOG_ERROR, "failed to delete %s\n", filename); 1864 } 1865 1866 av_dict_free(&http_opts); 1867 ff_format_io_close(s, &out); 1868 } else { 1869 int res = ffurl_delete(filename); 1870 if (res < 0) { 1871 char errbuf[AV_ERROR_MAX_STRING_SIZE]; 1872 av_strerror(res, errbuf, sizeof(errbuf)); 1873 av_log(s, (res == AVERROR(ENOENT) ? AV_LOG_WARNING : AV_LOG_ERROR), "failed to delete %s: %s\n", filename, errbuf); 1874 } 1875 } 1876} 1877 1878static int dashenc_delete_segment_file(AVFormatContext *s, const char* file) 1879{ 1880 DASHContext *c = s->priv_data; 1881 AVBPrint buf; 1882 1883 av_bprint_init(&buf, 0, AV_BPRINT_SIZE_UNLIMITED); 1884 1885 av_bprintf(&buf, "%s%s", c->dirname, file); 1886 if (!av_bprint_is_complete(&buf)) { 1887 av_bprint_finalize(&buf, NULL); 1888 av_log(s, AV_LOG_WARNING, "Out of memory for filename\n"); 1889 return AVERROR(ENOMEM); 1890 } 1891 1892 dashenc_delete_file(s, buf.str); 1893 1894 av_bprint_finalize(&buf, NULL); 1895 return 0; 1896} 1897 1898static inline void dashenc_delete_media_segments(AVFormatContext *s, OutputStream *os, int remove_count) 1899{ 1900 for (int i = 0; i < remove_count; ++i) { 1901 dashenc_delete_segment_file(s, os->segments[i]->file); 1902 1903 // Delete the segment regardless of whether the file was successfully deleted 1904 av_free(os->segments[i]); 1905 } 1906 1907 os->nb_segments -= remove_count; 1908 memmove(os->segments, os->segments + remove_count, os->nb_segments * sizeof(*os->segments)); 1909} 1910 1911static int dash_flush(AVFormatContext *s, int final, int stream) 1912{ 1913 DASHContext *c = s->priv_data; 1914 int i, ret = 0; 1915 1916 const char *proto = avio_find_protocol_name(s->url); 1917 int use_rename = proto && !strcmp(proto, "file"); 1918 1919 int cur_flush_segment_index = 0, next_exp_index = -1; 1920 if (stream >= 0) { 1921 cur_flush_segment_index = c->streams[stream].segment_index; 1922 1923 //finding the next segment's expected index, based on the current pts value 1924 if (c->use_template && !c->use_timeline && c->index_correction && 1925 c->streams[stream].last_pts != AV_NOPTS_VALUE && 1926 c->streams[stream].first_pts != AV_NOPTS_VALUE) { 1927 int64_t pts_diff = av_rescale_q(c->streams[stream].last_pts - 1928 c->streams[stream].first_pts, 1929 s->streams[stream]->time_base, 1930 AV_TIME_BASE_Q); 1931 next_exp_index = (pts_diff / c->streams[stream].seg_duration) + 1; 1932 } 1933 } 1934 1935 for (i = 0; i < s->nb_streams; i++) { 1936 OutputStream *os = &c->streams[i]; 1937 AVStream *st = s->streams[i]; 1938 int range_length, index_length = 0; 1939 int64_t duration; 1940 1941 if (!os->packets_written) 1942 continue; 1943 1944 // Flush the single stream that got a keyframe right now. 1945 // Flush all audio streams as well, in sync with video keyframes, 1946 // but not the other video streams. 1947 if (stream >= 0 && i != stream) { 1948 if (s->streams[stream]->codecpar->codec_type != AVMEDIA_TYPE_VIDEO && 1949 s->streams[i]->codecpar->codec_type != AVMEDIA_TYPE_VIDEO) 1950 continue; 1951 if (s->streams[i]->codecpar->codec_type != AVMEDIA_TYPE_AUDIO) 1952 continue; 1953 // Make sure we don't flush audio streams multiple times, when 1954 // all video streams are flushed one at a time. 1955 if (c->has_video && os->segment_index > cur_flush_segment_index) 1956 continue; 1957 } 1958 1959 if (c->single_file) 1960 snprintf(os->full_path, sizeof(os->full_path), "%s%s", c->dirname, os->initfile); 1961 1962 ret = flush_dynbuf(c, os, &range_length); 1963 if (ret < 0) 1964 break; 1965 os->packets_written = 0; 1966 1967 if (c->single_file) { 1968 find_index_range(s, os->full_path, os->pos, &index_length); 1969 } else { 1970 dashenc_io_close(s, &os->out, os->temp_path); 1971 1972 if (use_rename) { 1973 ret = ff_rename(os->temp_path, os->full_path, os->ctx); 1974 if (ret < 0) 1975 break; 1976 } 1977 } 1978 1979 duration = av_rescale_q(os->max_pts - os->start_pts, st->time_base, AV_TIME_BASE_Q); 1980 os->last_duration = FFMAX(os->last_duration, duration); 1981 1982 if (!os->muxer_overhead && os->max_pts > os->start_pts) 1983 os->muxer_overhead = ((int64_t) (range_length - os->total_pkt_size) * 1984 8 * AV_TIME_BASE) / duration; 1985 os->total_pkt_size = 0; 1986 os->total_pkt_duration = 0; 1987 1988 if (!os->bit_rate && !os->first_segment_bit_rate) { 1989 os->first_segment_bit_rate = (int64_t) range_length * 8 * AV_TIME_BASE / duration; 1990 } 1991 add_segment(os, os->filename, os->start_pts, os->max_pts - os->start_pts, os->pos, range_length, index_length, next_exp_index); 1992 av_log(s, AV_LOG_VERBOSE, "Representation %d media segment %d written to: %s\n", i, os->segment_index, os->full_path); 1993 1994 os->pos += range_length; 1995 } 1996 1997 if (c->window_size) { 1998 for (i = 0; i < s->nb_streams; i++) { 1999 OutputStream *os = &c->streams[i]; 2000 int remove_count = os->nb_segments - c->window_size - c->extra_window_size; 2001 if (remove_count > 0) 2002 dashenc_delete_media_segments(s, os, remove_count); 2003 } 2004 } 2005 2006 if (final) { 2007 for (i = 0; i < s->nb_streams; i++) { 2008 OutputStream *os = &c->streams[i]; 2009 if (os->ctx && os->ctx_inited) { 2010 int64_t file_size = avio_tell(os->ctx->pb); 2011 av_write_trailer(os->ctx); 2012 if (c->global_sidx) { 2013 int j, start_index, start_number; 2014 int64_t sidx_size = avio_tell(os->ctx->pb) - file_size; 2015 get_start_index_number(os, c, &start_index, &start_number); 2016 if (start_index >= os->nb_segments || 2017 os->segment_type != SEGMENT_TYPE_MP4) 2018 continue; 2019 os->init_range_length += sidx_size; 2020 for (j = start_index; j < os->nb_segments; j++) { 2021 Segment *seg = os->segments[j]; 2022 seg->start_pos += sidx_size; 2023 } 2024 } 2025 2026 } 2027 } 2028 } 2029 if (ret >= 0) { 2030 if (c->has_video && !final) { 2031 c->nr_of_streams_flushed++; 2032 if (c->nr_of_streams_flushed != c->nr_of_streams_to_flush) 2033 return ret; 2034 2035 c->nr_of_streams_flushed = 0; 2036 } 2037 // In streaming mode the manifest is written at the beginning 2038 // of the segment instead 2039 if (!c->streaming || final) 2040 ret = write_manifest(s, final); 2041 } 2042 return ret; 2043} 2044 2045static int dash_parse_prft(DASHContext *c, AVPacket *pkt) 2046{ 2047 OutputStream *os = &c->streams[pkt->stream_index]; 2048 AVProducerReferenceTime *prft; 2049 size_t side_data_size; 2050 2051 prft = (AVProducerReferenceTime *)av_packet_get_side_data(pkt, AV_PKT_DATA_PRFT, &side_data_size); 2052 if (!prft || side_data_size != sizeof(AVProducerReferenceTime) || (prft->flags && prft->flags != 24)) { 2053 // No encoder generated or user provided capture time AVProducerReferenceTime side data. Instead 2054 // of letting the mov muxer generate one, do it here so we can also use it for the manifest. 2055 prft = (AVProducerReferenceTime *)av_packet_new_side_data(pkt, AV_PKT_DATA_PRFT, 2056 sizeof(AVProducerReferenceTime)); 2057 if (!prft) 2058 return AVERROR(ENOMEM); 2059 prft->wallclock = av_gettime(); 2060 prft->flags = 24; 2061 } 2062 if (os->first_pts == AV_NOPTS_VALUE) { 2063 os->producer_reference_time = *prft; 2064 if (c->target_latency_refid < 0) 2065 c->target_latency_refid = pkt->stream_index; 2066 } 2067 2068 return 0; 2069} 2070 2071static int dash_write_packet(AVFormatContext *s, AVPacket *pkt) 2072{ 2073 DASHContext *c = s->priv_data; 2074 AVStream *st = s->streams[pkt->stream_index]; 2075 OutputStream *os = &c->streams[pkt->stream_index]; 2076 AdaptationSet *as = &c->as[os->as_idx - 1]; 2077 int64_t seg_end_duration, elapsed_duration; 2078 int ret; 2079 2080 ret = update_stream_extradata(s, os, pkt, &st->avg_frame_rate); 2081 if (ret < 0) 2082 return ret; 2083 2084 // Fill in a heuristic guess of the packet duration, if none is available. 2085 // The mp4 muxer will do something similar (for the last packet in a fragment) 2086 // if nothing is set (setting it for the other packets doesn't hurt). 2087 // By setting a nonzero duration here, we can be sure that the mp4 muxer won't 2088 // invoke its heuristic (this doesn't have to be identical to that algorithm), 2089 // so that we know the exact timestamps of fragments. 2090 if (!pkt->duration && os->last_dts != AV_NOPTS_VALUE) 2091 pkt->duration = pkt->dts - os->last_dts; 2092 os->last_dts = pkt->dts; 2093 2094 // If forcing the stream to start at 0, the mp4 muxer will set the start 2095 // timestamps to 0. Do the same here, to avoid mismatches in duration/timestamps. 2096 if (os->first_pts == AV_NOPTS_VALUE && 2097 s->avoid_negative_ts == AVFMT_AVOID_NEG_TS_MAKE_ZERO) { 2098 pkt->pts -= pkt->dts; 2099 pkt->dts = 0; 2100 } 2101 2102 if (c->write_prft) { 2103 ret = dash_parse_prft(c, pkt); 2104 if (ret < 0) 2105 return ret; 2106 } 2107 2108 if (os->first_pts == AV_NOPTS_VALUE) { 2109 os->first_pts = pkt->pts; 2110 } 2111 os->last_pts = pkt->pts; 2112 2113 if (!c->availability_start_time[0]) { 2114 int64_t start_time_us = av_gettime(); 2115 c->start_time_s = start_time_us / 1000000; 2116 format_date(c->availability_start_time, 2117 sizeof(c->availability_start_time), start_time_us); 2118 } 2119 2120 if (!os->packets_written) 2121 os->availability_time_offset = 0; 2122 2123 if (!os->availability_time_offset && 2124 ((os->frag_type == FRAG_TYPE_DURATION && os->seg_duration != os->frag_duration) || 2125 (os->frag_type == FRAG_TYPE_EVERY_FRAME && pkt->duration))) { 2126 AdaptationSet *as = &c->as[os->as_idx - 1]; 2127 int64_t frame_duration = 0; 2128 2129 switch (os->frag_type) { 2130 case FRAG_TYPE_DURATION: 2131 frame_duration = os->frag_duration; 2132 break; 2133 case FRAG_TYPE_EVERY_FRAME: 2134 frame_duration = av_rescale_q(pkt->duration, st->time_base, AV_TIME_BASE_Q); 2135 break; 2136 } 2137 2138 os->availability_time_offset = ((double) os->seg_duration - 2139 frame_duration) / AV_TIME_BASE; 2140 as->max_frag_duration = FFMAX(frame_duration, as->max_frag_duration); 2141 } 2142 2143 if (c->use_template && !c->use_timeline) { 2144 elapsed_duration = pkt->pts - os->first_pts; 2145 seg_end_duration = (int64_t) os->segment_index * os->seg_duration; 2146 } else { 2147 elapsed_duration = pkt->pts - os->start_pts; 2148 seg_end_duration = os->seg_duration; 2149 } 2150 2151 if (os->parser && 2152 (os->frag_type == FRAG_TYPE_PFRAMES || 2153 as->trick_idx >= 0)) { 2154 // Parse the packets only in scenarios where it's needed 2155 uint8_t *data; 2156 int size; 2157 av_parser_parse2(os->parser, os->parser_avctx, 2158 &data, &size, pkt->data, pkt->size, 2159 pkt->pts, pkt->dts, pkt->pos); 2160 2161 os->coding_dependency |= os->parser->pict_type != AV_PICTURE_TYPE_I; 2162 } 2163 2164 if (pkt->flags & AV_PKT_FLAG_KEY && os->packets_written && 2165 av_compare_ts(elapsed_duration, st->time_base, 2166 seg_end_duration, AV_TIME_BASE_Q) >= 0) { 2167 if (!c->has_video || st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) { 2168 c->last_duration = av_rescale_q(pkt->pts - os->start_pts, 2169 st->time_base, 2170 AV_TIME_BASE_Q); 2171 c->total_duration = av_rescale_q(pkt->pts - os->first_pts, 2172 st->time_base, 2173 AV_TIME_BASE_Q); 2174 2175 if ((!c->use_timeline || !c->use_template) && os->last_duration) { 2176 if (c->last_duration < os->last_duration*9/10 || 2177 c->last_duration > os->last_duration*11/10) { 2178 av_log(s, AV_LOG_WARNING, 2179 "Segment durations differ too much, enable use_timeline " 2180 "and use_template, or keep a stricter keyframe interval\n"); 2181 } 2182 } 2183 } 2184 2185 if (c->write_prft && os->producer_reference_time.wallclock && !os->producer_reference_time_str[0]) 2186 format_date(os->producer_reference_time_str, 2187 sizeof(os->producer_reference_time_str), 2188 os->producer_reference_time.wallclock); 2189 2190 if ((ret = dash_flush(s, 0, pkt->stream_index)) < 0) 2191 return ret; 2192 } 2193 2194 if (!os->packets_written) { 2195 // If we wrote a previous segment, adjust the start time of the segment 2196 // to the end of the previous one (which is the same as the mp4 muxer 2197 // does). This avoids gaps in the timeline. 2198 if (os->max_pts != AV_NOPTS_VALUE) 2199 os->start_pts = os->max_pts; 2200 else 2201 os->start_pts = pkt->pts; 2202 } 2203 if (os->max_pts == AV_NOPTS_VALUE) 2204 os->max_pts = pkt->pts + pkt->duration; 2205 else 2206 os->max_pts = FFMAX(os->max_pts, pkt->pts + pkt->duration); 2207 2208 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && 2209 os->frag_type == FRAG_TYPE_PFRAMES && 2210 os->packets_written) { 2211 av_assert0(os->parser); 2212 if ((os->parser->pict_type == AV_PICTURE_TYPE_P && 2213 st->codecpar->video_delay && 2214 !(os->last_flags & AV_PKT_FLAG_KEY)) || 2215 pkt->flags & AV_PKT_FLAG_KEY) { 2216 ret = av_write_frame(os->ctx, NULL); 2217 if (ret < 0) 2218 return ret; 2219 2220 if (!os->availability_time_offset) { 2221 int64_t frag_duration = av_rescale_q(os->total_pkt_duration, st->time_base, 2222 AV_TIME_BASE_Q); 2223 os->availability_time_offset = ((double) os->seg_duration - 2224 frag_duration) / AV_TIME_BASE; 2225 as->max_frag_duration = FFMAX(frag_duration, as->max_frag_duration); 2226 } 2227 } 2228 } 2229 2230 if (pkt->flags & AV_PKT_FLAG_KEY && (os->packets_written || os->nb_segments) && !os->gop_size && as->trick_idx < 0) { 2231 os->gop_size = os->last_duration + av_rescale_q(os->total_pkt_duration, st->time_base, AV_TIME_BASE_Q); 2232 c->max_gop_size = FFMAX(c->max_gop_size, os->gop_size); 2233 } 2234 2235 if ((ret = ff_write_chained(os->ctx, 0, pkt, s, 0)) < 0) 2236 return ret; 2237 2238 os->packets_written++; 2239 os->total_pkt_size += pkt->size; 2240 os->total_pkt_duration += pkt->duration; 2241 os->last_flags = pkt->flags; 2242 2243 if (!os->init_range_length) 2244 flush_init_segment(s, os); 2245 2246 //open the output context when the first frame of a segment is ready 2247 if (!c->single_file && os->packets_written == 1) { 2248 AVDictionary *opts = NULL; 2249 const char *proto = avio_find_protocol_name(s->url); 2250 int use_rename = proto && !strcmp(proto, "file"); 2251 if (os->segment_type == SEGMENT_TYPE_MP4) 2252 write_styp(os->ctx->pb); 2253 os->filename[0] = os->full_path[0] = os->temp_path[0] = '\0'; 2254 ff_dash_fill_tmpl_params(os->filename, sizeof(os->filename), 2255 os->media_seg_name, pkt->stream_index, 2256 os->segment_index, os->bit_rate, os->start_pts); 2257 snprintf(os->full_path, sizeof(os->full_path), "%s%s", c->dirname, 2258 os->filename); 2259 snprintf(os->temp_path, sizeof(os->temp_path), 2260 use_rename ? "%s.tmp" : "%s", os->full_path); 2261 set_http_options(&opts, c); 2262 ret = dashenc_io_open(s, &os->out, os->temp_path, &opts); 2263 av_dict_free(&opts); 2264 if (ret < 0) { 2265 return handle_io_open_error(s, ret, os->temp_path); 2266 } 2267 2268 // in streaming mode, the segments are available for playing 2269 // before fully written but the manifest is needed so that 2270 // clients and discover the segment filenames. 2271 if (c->streaming) { 2272 write_manifest(s, 0); 2273 } 2274 2275 if (c->lhls) { 2276 char *prefetch_url = use_rename ? NULL : os->filename; 2277 write_hls_media_playlist(os, s, pkt->stream_index, 0, prefetch_url); 2278 } 2279 } 2280 2281 //write out the data immediately in streaming mode 2282 if (c->streaming && os->segment_type == SEGMENT_TYPE_MP4) { 2283 int len = 0; 2284 uint8_t *buf = NULL; 2285 avio_flush(os->ctx->pb); 2286 len = avio_get_dyn_buf (os->ctx->pb, &buf); 2287 if (os->out) { 2288 avio_write(os->out, buf + os->written_len, len - os->written_len); 2289 avio_flush(os->out); 2290 } 2291 os->written_len = len; 2292 } 2293 2294 return ret; 2295} 2296 2297static int dash_write_trailer(AVFormatContext *s) 2298{ 2299 DASHContext *c = s->priv_data; 2300 int i; 2301 2302 if (s->nb_streams > 0) { 2303 OutputStream *os = &c->streams[0]; 2304 // If no segments have been written so far, try to do a crude 2305 // guess of the segment duration 2306 if (!c->last_duration) 2307 c->last_duration = av_rescale_q(os->max_pts - os->start_pts, 2308 s->streams[0]->time_base, 2309 AV_TIME_BASE_Q); 2310 c->total_duration = av_rescale_q(os->max_pts - os->first_pts, 2311 s->streams[0]->time_base, 2312 AV_TIME_BASE_Q); 2313 } 2314 dash_flush(s, 1, -1); 2315 2316 if (c->remove_at_exit) { 2317 for (i = 0; i < s->nb_streams; ++i) { 2318 OutputStream *os = &c->streams[i]; 2319 dashenc_delete_media_segments(s, os, os->nb_segments); 2320 dashenc_delete_segment_file(s, os->initfile); 2321 if (c->hls_playlist && os->segment_type == SEGMENT_TYPE_MP4) { 2322 char filename[1024]; 2323 get_hls_playlist_name(filename, sizeof(filename), c->dirname, i); 2324 dashenc_delete_file(s, filename); 2325 } 2326 } 2327 dashenc_delete_file(s, s->url); 2328 2329 if (c->hls_playlist && c->master_playlist_created) { 2330 char filename[1024]; 2331 snprintf(filename, sizeof(filename), "%s%s", c->dirname, c->hls_master_name); 2332 dashenc_delete_file(s, filename); 2333 } 2334 } 2335 2336 return 0; 2337} 2338 2339static int dash_check_bitstream(AVFormatContext *s, AVStream *st, 2340 const AVPacket *avpkt) 2341{ 2342 DASHContext *c = s->priv_data; 2343 OutputStream *os = &c->streams[st->index]; 2344 AVFormatContext *oc = os->ctx; 2345 if (oc->oformat->check_bitstream) { 2346 AVStream *const ost = oc->streams[0]; 2347 int ret; 2348 ret = oc->oformat->check_bitstream(oc, ost, avpkt); 2349 if (ret == 1) { 2350 FFStream *const sti = ffstream(st); 2351 FFStream *const osti = ffstream(ost); 2352 sti->bsfc = osti->bsfc; 2353 osti->bsfc = NULL; 2354 } 2355 return ret; 2356 } 2357 return 1; 2358} 2359 2360#define OFFSET(x) offsetof(DASHContext, x) 2361#define E AV_OPT_FLAG_ENCODING_PARAM 2362static const AVOption options[] = { 2363 { "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 }, 2364 { "window_size", "number of segments kept in the manifest", OFFSET(window_size), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, E }, 2365 { "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 }, 2366 { "seg_duration", "segment duration (in seconds, fractional value can be set)", OFFSET(seg_duration), AV_OPT_TYPE_DURATION, { .i64 = 5000000 }, 0, INT_MAX, E }, 2367 { "frag_duration", "fragment duration (in seconds, fractional value can be set)", OFFSET(frag_duration), AV_OPT_TYPE_DURATION, { .i64 = 0 }, 0, INT_MAX, E }, 2368 { "frag_type", "set type of interval for fragments", OFFSET(frag_type), AV_OPT_TYPE_INT, {.i64 = FRAG_TYPE_NONE }, 0, FRAG_TYPE_NB - 1, E, "frag_type"}, 2369 { "none", "one fragment per segment", 0, AV_OPT_TYPE_CONST, {.i64 = FRAG_TYPE_NONE }, 0, UINT_MAX, E, "frag_type"}, 2370 { "every_frame", "fragment at every frame", 0, AV_OPT_TYPE_CONST, {.i64 = FRAG_TYPE_EVERY_FRAME }, 0, UINT_MAX, E, "frag_type"}, 2371 { "duration", "fragment at specific time intervals", 0, AV_OPT_TYPE_CONST, {.i64 = FRAG_TYPE_DURATION }, 0, UINT_MAX, E, "frag_type"}, 2372 { "pframes", "fragment at keyframes and following P-Frame reordering (Video only, experimental)", 0, AV_OPT_TYPE_CONST, {.i64 = FRAG_TYPE_PFRAMES }, 0, UINT_MAX, E, "frag_type"}, 2373 { "remove_at_exit", "remove all segments when finished", OFFSET(remove_at_exit), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, E }, 2374 { "use_template", "Use SegmentTemplate instead of SegmentList", OFFSET(use_template), AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1, E }, 2375 { "use_timeline", "Use SegmentTimeline in SegmentTemplate", OFFSET(use_timeline), AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1, E }, 2376 { "single_file", "Store all segments in one file, accessed using byte ranges", OFFSET(single_file), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, E }, 2377 { "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 }, 2378 { "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 }, 2379 { "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 }, 2380 { "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 }, 2381 { "method", "set the HTTP method", OFFSET(method), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, E }, 2382 { "http_user_agent", "override User-Agent field in HTTP header", OFFSET(user_agent), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, E}, 2383 { "http_persistent", "Use persistent HTTP connections", OFFSET(http_persistent), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, E }, 2384 { "hls_playlist", "Generate HLS playlist files(master.m3u8, media_%d.m3u8)", OFFSET(hls_playlist), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, E }, 2385 { "hls_master_name", "HLS master playlist name", OFFSET(hls_master_name), AV_OPT_TYPE_STRING, {.str = "master.m3u8"}, 0, 0, E }, 2386 { "streaming", "Enable/Disable streaming mode of output. Each frame will be moof fragment", OFFSET(streaming), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, E }, 2387 { "timeout", "set timeout for socket I/O operations", OFFSET(timeout), AV_OPT_TYPE_DURATION, { .i64 = -1 }, -1, INT_MAX, .flags = E }, 2388 { "index_correction", "Enable/Disable segment index correction logic", OFFSET(index_correction), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, E }, 2389 { "format_options","set list of options for the container format (mp4/webm) used for dash", OFFSET(format_options), AV_OPT_TYPE_DICT, {.str = NULL}, 0, 0, E}, 2390 { "global_sidx", "Write global SIDX atom. Applicable only for single file, mp4 output, non-streaming mode", OFFSET(global_sidx), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, E }, 2391 { "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"}, 2392 { "auto", "select segment file format based on codec", 0, AV_OPT_TYPE_CONST, {.i64 = SEGMENT_TYPE_AUTO }, 0, UINT_MAX, E, "segment_type"}, 2393 { "mp4", "make segment file in ISOBMFF format", 0, AV_OPT_TYPE_CONST, {.i64 = SEGMENT_TYPE_MP4 }, 0, UINT_MAX, E, "segment_type"}, 2394 { "webm", "make segment file in WebM format", 0, AV_OPT_TYPE_CONST, {.i64 = SEGMENT_TYPE_WEBM }, 0, UINT_MAX, E, "segment_type"}, 2395 { "ignore_io_errors", "Ignore IO errors during open and write. Useful for long-duration runs with network output", OFFSET(ignore_io_errors), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, E }, 2396 { "lhls", "Enable Low-latency HLS(Experimental). Adds #EXT-X-PREFETCH tag with current segment's URI", OFFSET(lhls), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, E }, 2397 { "ldash", "Enable Low-latency dash. Constrains the value of a few elements", OFFSET(ldash), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, E }, 2398 { "master_m3u8_publish_rate", "Publish master playlist every after this many segment intervals", OFFSET(master_publish_rate), AV_OPT_TYPE_INT, {.i64 = 0}, 0, UINT_MAX, E}, 2399 { "write_prft", "Write producer reference time element", OFFSET(write_prft), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, E}, 2400 { "mpd_profile", "Set profiles. Elements and values used in the manifest may be constrained by them", OFFSET(profile), AV_OPT_TYPE_FLAGS, {.i64 = MPD_PROFILE_DASH }, 0, UINT_MAX, E, "mpd_profile"}, 2401 { "dash", "MPEG-DASH ISO Base media file format live profile", 0, AV_OPT_TYPE_CONST, {.i64 = MPD_PROFILE_DASH }, 0, UINT_MAX, E, "mpd_profile"}, 2402 { "dvb_dash", "DVB-DASH profile", 0, AV_OPT_TYPE_CONST, {.i64 = MPD_PROFILE_DVB }, 0, UINT_MAX, E, "mpd_profile"}, 2403 { "http_opts", "HTTP protocol options", OFFSET(http_opts), AV_OPT_TYPE_DICT, { .str = NULL }, 0, 0, E }, 2404 { "target_latency", "Set desired target latency for Low-latency dash", OFFSET(target_latency), AV_OPT_TYPE_DURATION, { .i64 = 0 }, 0, INT_MAX, E }, 2405 { "min_playback_rate", "Set desired minimum playback rate", OFFSET(min_playback_rate), AV_OPT_TYPE_RATIONAL, { .dbl = 1.0 }, 0.5, 1.5, E }, 2406 { "max_playback_rate", "Set desired maximum playback rate", OFFSET(max_playback_rate), AV_OPT_TYPE_RATIONAL, { .dbl = 1.0 }, 0.5, 1.5, E }, 2407 { "update_period", "Set the mpd update interval", OFFSET(update_period), AV_OPT_TYPE_INT64, {.i64 = 0}, 0, INT64_MAX, E}, 2408 { NULL }, 2409}; 2410 2411static const AVClass dash_class = { 2412 .class_name = "dash muxer", 2413 .item_name = av_default_item_name, 2414 .option = options, 2415 .version = LIBAVUTIL_VERSION_INT, 2416}; 2417 2418const AVOutputFormat ff_dash_muxer = { 2419 .name = "dash", 2420 .long_name = NULL_IF_CONFIG_SMALL("DASH Muxer"), 2421 .extensions = "mpd", 2422 .priv_data_size = sizeof(DASHContext), 2423 .audio_codec = AV_CODEC_ID_AAC, 2424 .video_codec = AV_CODEC_ID_H264, 2425 .flags = AVFMT_GLOBALHEADER | AVFMT_NOFILE | AVFMT_TS_NEGATIVE, 2426 .init = dash_init, 2427 .write_header = dash_write_header, 2428 .write_packet = dash_write_packet, 2429 .write_trailer = dash_write_trailer, 2430 .deinit = dash_free, 2431 .check_bitstream = dash_check_bitstream, 2432 .priv_class = &dash_class, 2433}; 2434