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;
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;
int target_latency_refid;
AVRational min_playback_rate;
AVRational max_playback_rate;
+ int64_t update_period;
} DASHContext;
static struct codec_string {
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\t<Representation id=\"%d\" mimeType=\"video/%s\" codecs=\"%s\"%s width=\"%d\" height=\"%d\"",
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);
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);
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)
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;
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;
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;
}
OutputStream *os = &c->streams[i];
AVStream *st = s->streams[i];
int range_length, index_length = 0;
+ int64_t duration;
if (!os->packets_written)
continue;
}
}
- 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);
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.wallclock && !os->producer_reference_time_str[0])
format_date(os->producer_reference_time_str,
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);
}
}
{ "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 },
{ "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 },
};