X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=libavformat%2Fdashenc.c;h=0ceaa5fdfd4f1993cedbb65cb98686d3d212d579;hb=626535f6a169e2d821b969e0ea77125ba7482113;hp=a7f35063a80b811d703811d9f87ec414ced837e2;hpb=d2a33f665cf0e889ba2824085d203739caa0534d;p=ffmpeg diff --git a/libavformat/dashenc.c b/libavformat/dashenc.c index a7f35063a80..0ceaa5fdfd4 100644 --- a/libavformat/dashenc.c +++ b/libavformat/dashenc.c @@ -115,6 +115,7 @@ typedef struct OutputStream { int64_t last_dts, last_pts; int last_flags; int bit_rate; + int first_segment_bit_rate; SegmentType segment_type; /* segment type selected for this particular stream */ const char *format_name; const char *extension_name; @@ -128,7 +129,7 @@ typedef struct OutputStream { char full_path[1024]; char temp_path[1024]; double availability_time_offset; - int64_t producer_reference_time; + AVProducerReferenceTime producer_reference_time; char producer_reference_time_str[100]; int total_pkt_size; int64_t total_pkt_duration; @@ -146,9 +147,6 @@ typedef struct DASHContext { int nb_as; int window_size; int extra_window_size; -#if FF_API_DASH_MIN_SEG_DURATION - int min_seg_duration; -#endif int64_t seg_duration; int64_t frag_duration; int remove_at_exit; @@ -171,6 +169,7 @@ typedef struct DASHContext { const char *user_agent; AVDictionary *http_opts; int hls_playlist; + const char *hls_master_name; int http_persistent; int master_playlist_created; AVIOContext *mpd_out; @@ -190,9 +189,13 @@ typedef struct DASHContext { int frag_type; int write_prft; int64_t max_gop_size; + int64_t max_segment_duration; int profile; int64_t target_latency; int target_latency_refid; + AVRational min_playback_rate; + AVRational max_playback_rate; + int64_t update_period; } DASHContext; static struct codec_string { @@ -662,8 +665,7 @@ static void output_segment_list(OutputStream *os, AVIOContext *out, AVFormatCont avio_printf(out, "availabilityTimeOffset=\"%.3f\" ", os->availability_time_offset); } - if (c->ldash && !final && os->frag_type != FRAG_TYPE_NONE && - (os->frag_type != FRAG_TYPE_DURATION || os->frag_duration != os->seg_duration)) + if (c->streaming && os->availability_time_offset && !final) avio_printf(out, "availabilityTimeComplete=\"false\" "); avio_printf(out, "initialization=\"%s\" media=\"%s\" startNumber=\"%d\"", os->init_seg_name, os->media_seg_name, c->use_timeline ? start_number : 1); @@ -804,7 +806,7 @@ static int write_adaptation_set(AVFormatContext *s, AVIOContext *out, int as_ind AVDictionaryEntry *lang, *role; int i; - avio_printf(out, "\t\tid, as->media_type == AVMEDIA_TYPE_VIDEO ? "video" : "audio"); 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) avio_printf(out, " maxFrameRate=\"%d/%d\"", as->max_frame_rate.num, as->max_frame_rate.den); @@ -819,7 +821,7 @@ static int write_adaptation_set(AVFormatContext *s, AVIOContext *out, int as_ind avio_printf(out, " lang=\"%s\"", lang->value); avio_printf(out, ">\n"); - if (!final && c->ldash && as->max_frag_duration) + if (!final && c->ldash && as->max_frag_duration && !(c->profile & MPD_PROFILE_DVB)) avio_printf(out, "\t\t\t\n", as->max_frag_duration); if (as->trick_idx >= 0) avio_printf(out, "\t\t\t\n", as->id, as->trick_idx); @@ -837,8 +839,12 @@ static int write_adaptation_set(AVFormatContext *s, AVIOContext *out, int as_ind continue; if (os->bit_rate > 0) - snprintf(bandwidth_str, sizeof(bandwidth_str), " bandwidth=\"%d\"", - os->bit_rate); + snprintf(bandwidth_str, sizeof(bandwidth_str), " bandwidth=\"%d\"", os->bit_rate); + else if (final) { + int average_bit_rate = os->pos * 8 * AV_TIME_BASE / c->total_duration; + snprintf(bandwidth_str, sizeof(bandwidth_str), " bandwidth=\"%d\"", average_bit_rate); + } else if (os->first_segment_bit_rate > 0) + snprintf(bandwidth_str, sizeof(bandwidth_str), " bandwidth=\"%d\"", os->first_segment_bit_rate); if (as->media_type == AVMEDIA_TYPE_VIDEO) { avio_printf(out, "\t\t\tstreams[i]->codecpar->channels); } if (!final && c->write_prft && os->producer_reference_time_str[0]) { - avio_printf(out, "\t\t\t\t\n", - i, os->producer_reference_time_str, c->presentation_time_offset); + avio_printf(out, "\t\t\t\t\n", + i, os->producer_reference_time.flags ? "captured" : "encoder", os->producer_reference_time_str, c->presentation_time_offset); avio_printf(out, "\t\t\t\t\t\n", c->utc_timing_url); avio_printf(out, "\t\t\t\t\n"); } - if (!final && c->ldash && os->gop_size && os->frag_type != FRAG_TYPE_NONE && + if (!final && c->ldash && os->gop_size && os->frag_type != FRAG_TYPE_NONE && !(c->profile & MPD_PROFILE_DVB) && (os->frag_type != FRAG_TYPE_DURATION || os->frag_duration != os->seg_duration)) avio_printf(out, "\t\t\t\t\n", os->gop_size); output_segment_list(os, out, s, i, final); @@ -1176,6 +1182,8 @@ static int write_manifest(AVFormatContext *s, int final) char now_str[100]; if (c->use_template && !c->use_timeline) update_period = 500; + if (c->update_period) + update_period = c->update_period; avio_printf(out, "\tminimumUpdatePeriod=\"PT%"PRId64"S\"\n", update_period); if (!c->ldash) avio_printf(out, "\tsuggestedPresentationDelay=\"PT%"PRId64"S\"\n", c->last_duration / AV_TIME_BASE); @@ -1190,6 +1198,9 @@ static int write_manifest(AVFormatContext *s, int final) avio_printf(out, "\"\n"); } } + avio_printf(out, "\tmaxSegmentDuration=\""); + write_time(out, c->max_segment_duration); + avio_printf(out, "\"\n"); avio_printf(out, "\tminBufferTime=\""); write_time(out, c->ldash && c->max_gop_size ? c->max_gop_size : c->last_duration * 2); avio_printf(out, "\">\n"); @@ -1200,14 +1211,19 @@ static int write_manifest(AVFormatContext *s, int final) av_free(escaped); } avio_printf(out, "\t\n"); + + avio_printf(out, "\t\n"); if (!final && c->target_latency && c->target_latency_refid >= 0) { - avio_printf(out, "\t\n"); avio_printf(out, "\t\ttarget_latency / 1000); if (s->nb_streams > 1) avio_printf(out, " referenceId=\"%d\"", c->target_latency_refid); avio_printf(out, "/>\n"); - avio_printf(out, "\t\n"); } + if (av_cmp_q(c->min_playback_rate, (AVRational) {1, 1}) || + av_cmp_q(c->max_playback_rate, (AVRational) {1, 1})) + avio_printf(out, "\t\t\n", + av_q2d(c->min_playback_rate), av_q2d(c->max_playback_rate)); + avio_printf(out, "\t\n"); if (c->window_size && s->nb_streams > 0 && c->streams[0].nb_segments > 0 && !c->use_template) { OutputStream *os = &c->streams[0]; @@ -1251,9 +1267,9 @@ static int write_manifest(AVFormatContext *s, int final) return 0; if (*c->dirname) - snprintf(filename_hls, sizeof(filename_hls), "%smaster.m3u8", c->dirname); + snprintf(filename_hls, sizeof(filename_hls), "%s%s", c->dirname, c->hls_master_name); else - snprintf(filename_hls, sizeof(filename_hls), "master.m3u8"); + snprintf(filename_hls, sizeof(filename_hls), "%s", c->hls_master_name); snprintf(temp_filename, sizeof(temp_filename), use_rename ? "%s.tmp" : "%s", filename_hls); @@ -1294,7 +1310,13 @@ static int write_manifest(AVFormatContext *s, int final) OutputStream *os = &c->streams[i]; char *agroup = NULL; char *codec_str_ptr = NULL; - int stream_bitrate = st->codecpar->bit_rate + os->muxer_overhead; + int stream_bitrate = os->muxer_overhead; + if (os->bit_rate > 0) + stream_bitrate += os->bit_rate; + else if (final) + stream_bitrate += os->pos * 8 * AV_TIME_BASE / c->total_duration; + else if (os->first_segment_bit_rate > 0) + stream_bitrate += os->first_segment_bit_rate; if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO) continue; if (os->segment_type != SEGMENT_TYPE_MP4) @@ -1312,7 +1334,7 @@ static int write_manifest(AVFormatContext *s, int final) get_hls_playlist_name(playlist_file, sizeof(playlist_file), NULL, i); ff_hls_write_stream_info(st, c->m3u8_out, stream_bitrate, playlist_file, agroup, - codec_str_ptr, NULL); + codec_str_ptr, NULL, NULL); } dashenc_io_close(s, &c->m3u8_out, temp_filename); if (use_rename) @@ -1349,12 +1371,6 @@ static int dash_init(AVFormatContext *s) av_log(s, AV_LOG_ERROR, "At least one profile must be enabled.\n"); return AVERROR(EINVAL); } -#if FF_API_DASH_MIN_SEG_DURATION - if (c->min_seg_duration != 5000000) { - av_log(s, AV_LOG_WARNING, "The min_seg_duration option is deprecated and will be removed. Please use the -seg_duration\n"); - c->seg_duration = c->min_seg_duration; - } -#endif if (c->lhls && s->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) { av_log(s, AV_LOG_ERROR, "LHLS is experimental, Please set -strict experimental in order to enable it.\n"); @@ -1395,6 +1411,12 @@ static int dash_init(AVFormatContext *s) c->frag_type = FRAG_TYPE_EVERY_FRAME; } + if (c->write_prft < 0) { + c->write_prft = c->ldash; + if (c->ldash) + av_log(s, AV_LOG_VERBOSE, "Enabling Producer Reference Time element for Low Latency mode\n"); + } + if (c->write_prft && !c->utc_timing_url) { av_log(s, AV_LOG_WARNING, "Producer Reference Time element option will be ignored as utc_timing_url is not set\n"); c->write_prft = 0; @@ -1405,11 +1427,20 @@ static int dash_init(AVFormatContext *s) c->write_prft = 0; } + if (c->ldash && !c->write_prft) { + av_log(s, AV_LOG_WARNING, "Low Latency mode enabled without Producer Reference Time element option! Resulting manifest may not be complaint\n"); + } + if (c->target_latency && !c->write_prft) { av_log(s, AV_LOG_WARNING, "Target latency option will be ignored as Producer Reference Time element will not be written\n"); c->target_latency = 0; } + if (av_cmp_q(c->max_playback_rate, c->min_playback_rate) < 0) { + av_log(s, AV_LOG_WARNING, "Minimum playback rate value is higer than the Maximum. Both will be ignored\n"); + c->min_playback_rate = c->max_playback_rate = (AVRational) {1, 1}; + } + av_strlcpy(c->dirname, s->url, sizeof(c->dirname)); ptr = strrchr(c->dirname, '/'); if (ptr) { @@ -1519,8 +1550,7 @@ static int dash_init(AVFormatContext *s) return ret; // We only want to parse frame headers os->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES; - } else - os->coding_dependency = 1; + } if (c->single_file) { if (os->single_file_name) @@ -1556,6 +1586,8 @@ static int dash_init(AVFormatContext *s) os->frag_duration = as->frag_duration; os->frag_type = as->frag_type; + c->max_segment_duration = FFMAX(c->max_segment_duration, as->seg_duration); + if (c->profile & MPD_PROFILE_DVB && (os->seg_duration > 15000000 || os->seg_duration < 960000)) { av_log(s, AV_LOG_ERROR, "Segment duration %"PRId64" is outside the allowed range for DVB-DASH profile\n", os->seg_duration); return AVERROR(EINVAL); @@ -1574,6 +1606,9 @@ static int dash_init(AVFormatContext *s) av_log(s, AV_LOG_WARNING, "frag_type set to P-Frame reordering, but no parser found for stream %d\n", i); os->frag_type = c->streaming ? FRAG_TYPE_EVERY_FRAME : FRAG_TYPE_NONE; } + if (os->frag_type != FRAG_TYPE_PFRAMES && as->trick_idx < 0) + // Set this now if a parser isn't used + os->coding_dependency = 1; if (os->segment_type == SEGMENT_TYPE_MP4) { if (c->streaming) @@ -1642,7 +1677,7 @@ static int dash_init(AVFormatContext *s) 1024 * 1024); if (as->par.num && av_cmp_q(par, as->par)) { - av_log(s, AV_LOG_ERROR, "Conflicting stream par values in Adaptation Set %d\n", os->as_idx); + 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); return AVERROR(EINVAL); } as->par = par; @@ -1702,7 +1737,7 @@ static int add_segment(OutputStream *os, const char *file, Segment *seg; if (os->nb_segments >= os->segments_size) { os->segments_size = (os->segments_size + 1) * 2; - if ((err = av_reallocp(&os->segments, sizeof(*os->segments) * + if ((err = av_reallocp_array(&os->segments, sizeof(*os->segments), os->segments_size)) < 0) { os->segments_size = 0; os->nb_segments = 0; @@ -1771,7 +1806,8 @@ static int update_stream_extradata(AVFormatContext *s, OutputStream *os, { AVCodecParameters *par = os->ctx->streams[0]->codecpar; uint8_t *extradata; - int ret, extradata_size; + size_t extradata_size; + int ret; if (par->extradata_size) return 0; @@ -1821,28 +1857,20 @@ static void dashenc_delete_file(AVFormatContext *s, char *filename) { static int dashenc_delete_segment_file(AVFormatContext *s, const char* file) { DASHContext *c = s->priv_data; - size_t dirname_len, file_len; - char filename[1024]; - - dirname_len = strlen(c->dirname); - if (dirname_len >= sizeof(filename)) { - av_log(s, AV_LOG_WARNING, "Cannot delete segments as the directory path is too long: %"PRIu64" characters: %s\n", - (uint64_t)dirname_len, c->dirname); - return AVERROR(ENAMETOOLONG); - } + AVBPrint buf; - memcpy(filename, c->dirname, dirname_len); + av_bprint_init(&buf, 0, AV_BPRINT_SIZE_UNLIMITED); - file_len = strlen(file); - if ((dirname_len + file_len) >= sizeof(filename)) { - av_log(s, AV_LOG_WARNING, "Cannot delete segments as the path is too long: %"PRIu64" characters: %s%s\n", - (uint64_t)(dirname_len + file_len), c->dirname, file); - return AVERROR(ENAMETOOLONG); + av_bprintf(&buf, "%s%s", c->dirname, file); + if (!av_bprint_is_complete(&buf)) { + av_bprint_finalize(&buf, NULL); + av_log(s, AV_LOG_WARNING, "Out of memory for filename\n"); + return AVERROR(ENOMEM); } - memcpy(filename + dirname_len, file, file_len + 1); // include the terminating zero - dashenc_delete_file(s, filename); + dashenc_delete_file(s, buf.str); + av_bprint_finalize(&buf, NULL); return 0; } @@ -1887,6 +1915,7 @@ static int dash_flush(AVFormatContext *s, int final, int stream) OutputStream *os = &c->streams[i]; AVStream *st = s->streams[i]; int range_length, index_length = 0; + int64_t duration; if (!os->packets_written) continue; @@ -1906,12 +1935,8 @@ static int dash_flush(AVFormatContext *s, int final, int stream) continue; } - if (!c->single_file) { - if (os->segment_type == SEGMENT_TYPE_MP4 && !os->written_len) - write_styp(os->ctx->pb); - } else { + if (c->single_file) snprintf(os->full_path, sizeof(os->full_path), "%s%s", c->dirname, os->initfile); - } ret = flush_dynbuf(c, os, &range_length); if (ret < 0) @@ -1930,25 +1955,17 @@ static int dash_flush(AVFormatContext *s, int final, int stream) } } - os->last_duration = FFMAX(os->last_duration, av_rescale_q(os->max_pts - os->start_pts, - st->time_base, - AV_TIME_BASE_Q)); + duration = av_rescale_q(os->max_pts - os->start_pts, st->time_base, AV_TIME_BASE_Q); + os->last_duration = FFMAX(os->last_duration, duration); if (!os->muxer_overhead && os->max_pts > os->start_pts) os->muxer_overhead = ((int64_t) (range_length - os->total_pkt_size) * - 8 * AV_TIME_BASE) / - av_rescale_q(os->max_pts - os->start_pts, - st->time_base, AV_TIME_BASE_Q); + 8 * AV_TIME_BASE) / duration; os->total_pkt_size = 0; os->total_pkt_duration = 0; - if (!os->bit_rate) { - // calculate average bitrate of first segment - int64_t bitrate = (int64_t) range_length * 8 * AV_TIME_BASE / av_rescale_q(os->max_pts - os->start_pts, - st->time_base, - AV_TIME_BASE_Q); - if (bitrate >= 0) - os->bit_rate = bitrate; + if (!os->bit_rate && !os->first_segment_bit_rate) { + os->first_segment_bit_rate = (int64_t) range_length * 8 * AV_TIME_BASE / duration; } add_segment(os, os->filename, os->start_pts, os->max_pts - os->start_pts, os->pos, range_length, index_length, next_exp_index); av_log(s, AV_LOG_VERBOSE, "Representation %d media segment %d written to: %s\n", i, os->segment_index, os->full_path); @@ -2001,6 +2018,32 @@ static int dash_flush(AVFormatContext *s, int final, int stream) return ret; } +static int dash_parse_prft(DASHContext *c, AVPacket *pkt) +{ + OutputStream *os = &c->streams[pkt->stream_index]; + AVProducerReferenceTime *prft; + size_t side_data_size; + + prft = (AVProducerReferenceTime *)av_packet_get_side_data(pkt, AV_PKT_DATA_PRFT, &side_data_size); + if (!prft || side_data_size != sizeof(AVProducerReferenceTime) || (prft->flags && prft->flags != 24)) { + // No encoder generated or user provided capture time AVProducerReferenceTime side data. Instead + // of letting the mov muxer generate one, do it here so we can also use it for the manifest. + prft = (AVProducerReferenceTime *)av_packet_new_side_data(pkt, AV_PKT_DATA_PRFT, + sizeof(AVProducerReferenceTime)); + if (!prft) + return AVERROR(ENOMEM); + prft->wallclock = av_gettime(); + prft->flags = 24; + } + if (os->first_pts == AV_NOPTS_VALUE) { + os->producer_reference_time = *prft; + if (c->target_latency_refid < 0) + c->target_latency_refid = pkt->stream_index; + } + + return 0; +} + static int dash_write_packet(AVFormatContext *s, AVPacket *pkt) { DASHContext *c = s->priv_data; @@ -2032,15 +2075,13 @@ static int dash_write_packet(AVFormatContext *s, AVPacket *pkt) pkt->dts = 0; } + if (c->write_prft) { + ret = dash_parse_prft(c, pkt); + if (ret < 0) + return ret; + } + if (os->first_pts == AV_NOPTS_VALUE) { - int side_data_size; - AVProducerReferenceTime *prft = (AVProducerReferenceTime *)av_packet_get_side_data(pkt, AV_PKT_DATA_PRFT, - &side_data_size); - if (prft && side_data_size == sizeof(AVProducerReferenceTime) && !prft->flags) { - os->producer_reference_time = prft->wallclock; - if (c->target_latency_refid < 0) - c->target_latency_refid = pkt->stream_index; - } os->first_pts = pkt->pts; } os->last_pts = pkt->pts; @@ -2100,27 +2141,27 @@ static int dash_write_packet(AVFormatContext *s, AVPacket *pkt) av_compare_ts(elapsed_duration, st->time_base, seg_end_duration, AV_TIME_BASE_Q) >= 0) { if (!c->has_video || st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) { - c->last_duration = av_rescale_q(pkt->pts - os->start_pts, - st->time_base, - AV_TIME_BASE_Q); - c->total_duration = av_rescale_q(pkt->pts - os->first_pts, - st->time_base, - AV_TIME_BASE_Q); - - if ((!c->use_timeline || !c->use_template) && os->last_duration) { - if (c->last_duration < os->last_duration*9/10 || - c->last_duration > os->last_duration*11/10) { - av_log(s, AV_LOG_WARNING, - "Segment durations differ too much, enable use_timeline " - "and use_template, or keep a stricter keyframe interval\n"); + c->last_duration = av_rescale_q(pkt->pts - os->start_pts, + st->time_base, + AV_TIME_BASE_Q); + c->total_duration = av_rescale_q(pkt->pts - os->first_pts, + st->time_base, + AV_TIME_BASE_Q); + + if ((!c->use_timeline || !c->use_template) && os->last_duration) { + if (c->last_duration < os->last_duration*9/10 || + c->last_duration > os->last_duration*11/10) { + av_log(s, AV_LOG_WARNING, + "Segment durations differ too much, enable use_timeline " + "and use_template, or keep a stricter keyframe interval\n"); + } } } - } - if (c->write_prft && os->producer_reference_time && !os->producer_reference_time_str[0]) + if (c->write_prft && os->producer_reference_time.wallclock && !os->producer_reference_time_str[0]) format_date(os->producer_reference_time_str, sizeof(os->producer_reference_time_str), - os->producer_reference_time); + os->producer_reference_time.wallclock); if ((ret = dash_flush(s, 0, pkt->stream_index)) < 0) return ret; @@ -2183,6 +2224,8 @@ static int dash_write_packet(AVFormatContext *s, AVPacket *pkt) AVDictionary *opts = NULL; const char *proto = avio_find_protocol_name(s->url); int use_rename = proto && !strcmp(proto, "file"); + if (os->segment_type == SEGMENT_TYPE_MP4) + write_styp(os->ctx->pb); os->filename[0] = os->full_path[0] = os->temp_path[0] = '\0'; ff_dash_fill_tmpl_params(os->filename, sizeof(os->filename), os->media_seg_name, pkt->stream_index, @@ -2207,8 +2250,6 @@ static int dash_write_packet(AVFormatContext *s, AVPacket *pkt) if (c->streaming && os->segment_type == SEGMENT_TYPE_MP4) { int len = 0; uint8_t *buf = NULL; - if (!os->written_len) - write_styp(os->ctx->pb); avio_flush(os->ctx->pb); len = avio_get_dyn_buf (os->ctx->pb, &buf); if (os->out) { @@ -2255,7 +2296,7 @@ static int dash_write_trailer(AVFormatContext *s) if (c->hls_playlist && c->master_playlist_created) { char filename[1024]; - snprintf(filename, sizeof(filename), "%smaster.m3u8", c->dirname); + snprintf(filename, sizeof(filename), "%s%s", c->dirname, c->hls_master_name); dashenc_delete_file(s, filename); } } @@ -2276,10 +2317,8 @@ static int dash_check_bitstream(struct AVFormatContext *s, const AVPacket *avpkt if (ret == 1) { AVStream *st = s->streams[avpkt->stream_index]; AVStream *ost = oc->streams[0]; - st->internal->bsfcs = ost->internal->bsfcs; - st->internal->nb_bsfcs = ost->internal->nb_bsfcs; - ost->internal->bsfcs = NULL; - ost->internal->nb_bsfcs = 0; + st->internal->bsfc = ost->internal->bsfc; + ost->internal->bsfc = NULL; } return ret; } @@ -2292,9 +2331,6 @@ static const AVOption options[] = { { "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 }, { "window_size", "number of segments kept in the manifest", OFFSET(window_size), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, E }, { "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 }, -#if FF_API_DASH_MIN_SEG_DURATION - { "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 }, -#endif { "seg_duration", "segment duration (in seconds, fractional value can be set)", OFFSET(seg_duration), AV_OPT_TYPE_DURATION, { .i64 = 5000000 }, 0, INT_MAX, E }, { "frag_duration", "fragment duration (in seconds, fractional value can be set)", OFFSET(frag_duration), AV_OPT_TYPE_DURATION, { .i64 = 0 }, 0, INT_MAX, E }, { "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"}, @@ -2314,6 +2350,7 @@ static const AVOption options[] = { { "http_user_agent", "override User-Agent field in HTTP header", OFFSET(user_agent), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, E}, { "http_persistent", "Use persistent HTTP connections", OFFSET(http_persistent), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, E }, { "hls_playlist", "Generate HLS playlist files(master.m3u8, media_%d.m3u8)", OFFSET(hls_playlist), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, E }, + { "hls_master_name", "HLS master playlist name", OFFSET(hls_master_name), AV_OPT_TYPE_STRING, {.str = "master.m3u8"}, 0, 0, E }, { "streaming", "Enable/Disable streaming mode of output. Each frame will be moof fragment", OFFSET(streaming), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, E }, { "timeout", "set timeout for socket I/O operations", OFFSET(timeout), AV_OPT_TYPE_DURATION, { .i64 = -1 }, -1, INT_MAX, .flags = E }, { "index_correction", "Enable/Disable segment index correction logic", OFFSET(index_correction), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, E }, @@ -2327,12 +2364,15 @@ static const AVOption options[] = { { "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 }, { "ldash", "Enable Low-latency dash. Constrains the value of a few elements", OFFSET(ldash), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, E }, { "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}, - { "write_prft", "Write producer reference time element", OFFSET(write_prft), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, E}, + { "write_prft", "Write producer reference time element", OFFSET(write_prft), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, E}, { "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"}, { "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"}, { "dvb_dash", "DVB-DASH profile", 0, AV_OPT_TYPE_CONST, {.i64 = MPD_PROFILE_DVB }, 0, UINT_MAX, E, "mpd_profile"}, { "http_opts", "HTTP protocol options", OFFSET(http_opts), AV_OPT_TYPE_DICT, { .str = NULL }, 0, 0, E }, { "target_latency", "Set desired target latency for Low-latency dash", OFFSET(target_latency), AV_OPT_TYPE_DURATION, { .i64 = 0 }, 0, INT_MAX, E }, + { "min_playback_rate", "Set desired minimum playback rate", OFFSET(min_playback_rate), AV_OPT_TYPE_RATIONAL, { .dbl = 1.0 }, 0.5, 1.5, E }, + { "max_playback_rate", "Set desired maximum playback rate", OFFSET(max_playback_rate), AV_OPT_TYPE_RATIONAL, { .dbl = 1.0 }, 0.5, 1.5, E }, + { "update_period", "Set the mpd update interval", OFFSET(update_period), AV_OPT_TYPE_INT64, {.i64 = 0}, 0, INT64_MAX, E}, { NULL }, };