#include "libavutil/mathematics.h"
#include "libavutil/opt.h"
#include "libavutil/rational.h"
+#include "libavutil/time.h"
#include "libavutil/time_internal.h"
+#include "av1.h"
#include "avc.h"
#include "avformat.h"
#include "avio_internal.h"
int64_t start_pos;
int range_length, index_length;
int64_t time;
+ double prog_date_time;
int64_t duration;
int n;
} Segment;
typedef struct AdaptationSet {
char id[10];
+ char *descriptor;
enum AVMediaType media_type;
AVDictionary *metadata;
AVRational min_frame_rate, max_frame_rate;
int bit_rate;
SegmentType segment_type; /* segment type selected for this particular stream */
const char *format_name;
+ const char *extension_name;
const char *single_file_name; /* file names selected for this particular stream */
const char *init_seg_name;
const char *media_seg_name;
int64_t last_duration;
int64_t total_duration;
char availability_start_time[100];
+ time_t start_time_s;
char dirname[1024];
const char *single_file_name; /* file names as specified in options */
const char *init_seg_name;
int64_t timeout;
int index_correction;
char *format_options_str;
+ int global_sidx;
SegmentType segment_type_option; /* segment type as specified in options */
int ignore_io_errors;
+ int lhls;
+ int master_publish_rate;
+ int nr_of_streams_to_flush;
+ int nr_of_streams_flushed;
} DASHContext;
static struct codec_string {
return NULL;
}
+static const char *get_extension_str(SegmentType type, int single_file)
+{
+ switch (type) {
+
+ case SEGMENT_TYPE_MP4: return single_file ? "mp4" : "m4s";
+ case SEGMENT_TYPE_WEBM: return "webm";
+ default: return NULL;
+ }
+}
+
+static int handle_io_open_error(AVFormatContext *s, int err, char *url) {
+ DASHContext *c = s->priv_data;
+ char errbuf[AV_ERROR_MAX_STRING_SIZE];
+ av_strerror(err, errbuf, sizeof(errbuf));
+ av_log(s, c->ignore_io_errors ? AV_LOG_WARNING : AV_LOG_ERROR,
+ "Unable to open %s for writing: %s\n", url, errbuf);
+ return c->ignore_io_errors ? 0 : err;
+}
+
static inline SegmentType select_segment_type(SegmentType segment_type, enum AVCodecID codec_id)
{
if (segment_type == SEGMENT_TYPE_AUTO) {
av_log(s, AV_LOG_ERROR, "Could not select DASH segment type for stream %d\n", i);
return AVERROR_MUXER_NOT_FOUND;
}
+ os->extension_name = get_extension_str(segment_type, c->single_file);
+ if (!os->extension_name) {
+ av_log(s, AV_LOG_ERROR, "Could not get extension type for stream %d\n", i);
+ return AVERROR_MUXER_NOT_FOUND;
+ }
+
has_mp4_streams |= segment_type == SEGMENT_TYPE_MP4;
}
av_strlcatf(str, size, ".%02x%02x%02x",
extradata[1], extradata[2], extradata[3]);
av_free(tmpbuf);
+ } else if (!strcmp(str, "av01")) {
+ AV1SequenceParameters seq;
+ if (!par->extradata_size)
+ return;
+ if (ff_av1_parse_seq_header(&seq, par->extradata, par->extradata_size) < 0)
+ return;
+
+ av_strlcatf(str, size, ".%01u.%02u%s.%02u",
+ seq.profile, seq.level, seq.tier ? "H" : "M", seq.bitdepth);
+ if (seq.color_description_present_flag)
+ av_strlcatf(str, size, ".%01u.%01u%01u%01u.%02u.%02u.%02u.%01u",
+ seq.monochrome,
+ seq.chroma_subsampling_x, seq.chroma_subsampling_y, seq.chroma_sample_position,
+ seq.color_primaries, seq.transfer_characteristics, seq.matrix_coefficients,
+ seq.color_range);
}
}
-static int flush_dynbuf(OutputStream *os, int *range_length)
+static int flush_dynbuf(DASHContext *c, OutputStream *os, int *range_length)
{
uint8_t *buffer;
av_write_frame(os->ctx, NULL);
avio_flush(os->ctx->pb);
- // write out to file
- *range_length = avio_close_dyn_buf(os->ctx->pb, &buffer);
- os->ctx->pb = NULL;
- if (os->out)
- avio_write(os->out, buffer + os->written_len, *range_length - os->written_len);
- os->written_len = 0;
- av_free(buffer);
-
- // re-open buffer
- return avio_open_dyn_buf(&os->ctx->pb);
+ if (!c->single_file) {
+ // write out to file
+ *range_length = avio_close_dyn_buf(os->ctx->pb, &buffer);
+ os->ctx->pb = NULL;
+ if (os->out)
+ avio_write(os->out, buffer + os->written_len, *range_length - os->written_len);
+ os->written_len = 0;
+ av_free(buffer);
+
+ // re-open buffer
+ return avio_open_dyn_buf(&os->ctx->pb);
+ } else {
+ *range_length = avio_tell(os->ctx->pb) - os->pos;
+ return 0;
+ }
}
static void set_http_options(AVDictionary **options, DASHContext *c)
snprintf(playlist_name, string_size, "media_%d.m3u8", id);
}
+static void get_start_index_number(OutputStream *os, DASHContext *c,
+ int *start_index, int *start_number) {
+ *start_index = 0;
+ *start_number = 1;
+ if (c->window_size) {
+ *start_index = FFMAX(os->nb_segments - c->window_size, 0);
+ *start_number = FFMAX(os->segment_index - c->window_size, 1);
+ }
+}
+
+static void write_hls_media_playlist(OutputStream *os, AVFormatContext *s,
+ int representation_id, int final,
+ char *prefetch_url) {
+ DASHContext *c = s->priv_data;
+ int timescale = os->ctx->streams[0]->time_base.den;
+ char temp_filename_hls[1024];
+ char filename_hls[1024];
+ AVDictionary *http_opts = NULL;
+ int target_duration = 0;
+ int ret = 0;
+ const char *proto = avio_find_protocol_name(c->dirname);
+ int use_rename = proto && !strcmp(proto, "file");
+ int i, start_index, start_number;
+ double prog_date_time = 0;
+
+ get_start_index_number(os, c, &start_index, &start_number);
+
+ if (!c->hls_playlist || start_index >= os->nb_segments ||
+ os->segment_type != SEGMENT_TYPE_MP4)
+ return;
+
+ get_hls_playlist_name(filename_hls, sizeof(filename_hls),
+ c->dirname, representation_id);
+
+ snprintf(temp_filename_hls, sizeof(temp_filename_hls), use_rename ? "%s.tmp" : "%s", filename_hls);
+
+ set_http_options(&http_opts, c);
+ ret = dashenc_io_open(s, &c->m3u8_out, temp_filename_hls, &http_opts);
+ av_dict_free(&http_opts);
+ if (ret < 0) {
+ handle_io_open_error(s, ret, temp_filename_hls);
+ return;
+ }
+ for (i = start_index; i < os->nb_segments; i++) {
+ Segment *seg = os->segments[i];
+ double duration = (double) seg->duration / timescale;
+ if (target_duration <= duration)
+ target_duration = lrint(duration);
+ }
+
+ ff_hls_write_playlist_header(c->m3u8_out, 6, -1, target_duration,
+ start_number, PLAYLIST_TYPE_NONE, 0);
+
+ ff_hls_write_init_file(c->m3u8_out, os->initfile, c->single_file,
+ os->init_range_length, os->init_start_pos);
+
+ for (i = start_index; i < os->nb_segments; i++) {
+ Segment *seg = os->segments[i];
+
+ if (prog_date_time == 0) {
+ if (os->nb_segments == 1)
+ prog_date_time = c->start_time_s;
+ else
+ prog_date_time = seg->prog_date_time;
+ }
+ seg->prog_date_time = prog_date_time;
+
+ ret = ff_hls_write_file_entry(c->m3u8_out, 0, c->single_file,
+ (double) seg->duration / timescale, 0,
+ seg->range_length, seg->start_pos, NULL,
+ c->single_file ? os->initfile : seg->file,
+ &prog_date_time, 0, 0, 0);
+ if (ret < 0) {
+ av_log(os->ctx, AV_LOG_WARNING, "ff_hls_write_file_entry get error\n");
+ }
+ }
+
+ if (prefetch_url)
+ avio_printf(c->m3u8_out, "#EXT-X-PREFETCH:%s\n", prefetch_url);
+
+ if (final)
+ ff_hls_write_end_list(c->m3u8_out);
+
+ dashenc_io_close(s, &c->m3u8_out, temp_filename_hls);
+
+ if (use_rename)
+ if (avpriv_io_move(temp_filename_hls, filename_hls) < 0) {
+ av_log(os->ctx, AV_LOG_WARNING, "renaming file %s to %s failed\n\n", temp_filename_hls, filename_hls);
+ }
+}
+
static int flush_init_segment(AVFormatContext *s, OutputStream *os)
{
DASHContext *c = s->priv_data;
int ret, range_length;
- ret = flush_dynbuf(os, &range_length);
+ ret = flush_dynbuf(c, os, &range_length);
if (ret < 0)
return ret;
int i, j;
if (c->as) {
- for (i = 0; i < c->nb_as; i++)
+ for (i = 0; i < c->nb_as; i++) {
av_dict_free(&c->as[i].metadata);
+ av_freep(&c->as[i].descriptor);
+ }
av_freep(&c->as);
c->nb_as = 0;
}
return;
for (i = 0; i < s->nb_streams; i++) {
OutputStream *os = &c->streams[i];
- if (os->ctx && os->ctx_inited)
- av_write_trailer(os->ctx);
- if (os->ctx && os->ctx->pb)
- ffio_free_dyn_buf(&os->ctx->pb);
+ if (os->ctx && os->ctx->pb) {
+ if (!c->single_file)
+ ffio_free_dyn_buf(&os->ctx->pb);
+ else
+ avio_close(os->ctx->pb);
+ }
ff_format_io_close(s, &os->out);
if (os->ctx)
avformat_free_context(os->ctx);
int representation_id, int final)
{
DASHContext *c = s->priv_data;
- int i, start_index = 0, start_number = 1;
- if (c->window_size) {
- start_index = FFMAX(os->nb_segments - c->window_size, 0);
- start_number = FFMAX(os->segment_index - c->window_size, 1);
- }
+ int i, start_index, start_number;
+ get_start_index_number(os, c, &start_index, &start_number);
if (c->use_template) {
int timescale = c->use_timeline ? os->ctx->streams[0]->time_base.den : AV_TIME_BASE;
}
avio_printf(out, "\t\t\t\t</SegmentList>\n");
}
- if (c->hls_playlist && start_index < os->nb_segments && os->segment_type == SEGMENT_TYPE_MP4)
- {
- int timescale = os->ctx->streams[0]->time_base.den;
- char temp_filename_hls[1024];
- char filename_hls[1024];
- AVDictionary *http_opts = NULL;
- int target_duration = 0;
- int ret = 0;
- const char *proto = avio_find_protocol_name(c->dirname);
- int use_rename = proto && !strcmp(proto, "file");
-
- get_hls_playlist_name(filename_hls, sizeof(filename_hls),
- c->dirname, representation_id);
-
- snprintf(temp_filename_hls, sizeof(temp_filename_hls), use_rename ? "%s.tmp" : "%s", filename_hls);
-
- set_http_options(&http_opts, c);
- ret = dashenc_io_open(s, &c->m3u8_out, temp_filename_hls, &http_opts);
- av_dict_free(&http_opts);
- if (ret < 0) {
- av_log(s, AV_LOG_ERROR, "Unable to open %s for writing\n", temp_filename_hls);
- return;
- }
- for (i = start_index; i < os->nb_segments; i++) {
- Segment *seg = os->segments[i];
- double duration = (double) seg->duration / timescale;
- if (target_duration <= duration)
- target_duration = lrint(duration);
- }
-
- ff_hls_write_playlist_header(c->m3u8_out, 6, -1, target_duration,
- start_number, PLAYLIST_TYPE_NONE);
-
- ff_hls_write_init_file(c->m3u8_out, os->initfile, c->single_file,
- os->init_range_length, os->init_start_pos);
-
- for (i = start_index; i < os->nb_segments; i++) {
- Segment *seg = os->segments[i];
- ret = ff_hls_write_file_entry(c->m3u8_out, 0, c->single_file,
- (double) seg->duration / timescale, 0,
- seg->range_length, seg->start_pos, NULL,
- c->single_file ? os->initfile : seg->file,
- NULL);
- if (ret < 0) {
- av_log(os->ctx, AV_LOG_WARNING, "ff_hls_write_file_entry get error\n");
- }
- }
-
- if (final)
- ff_hls_write_end_list(c->m3u8_out);
-
- dashenc_io_close(s, &c->m3u8_out, temp_filename_hls);
-
- if (use_rename)
- if (avpriv_io_move(temp_filename_hls, filename_hls) < 0) {
- av_log(os->ctx, AV_LOG_WARNING, "renaming file %s to %s failed\n\n", temp_filename_hls, filename_hls);
- }
+ if (!c->lhls || final) {
+ write_hls_media_playlist(os, s, representation_id, final, NULL);
}
}
static void format_date_now(char *buf, int size)
{
- time_t t = time(NULL);
struct tm *ptm, tmbuf;
- ptm = gmtime_r(&t, &tmbuf);
+ int64_t time_us = av_gettime();
+ int64_t time_ms = time_us / 1000;
+ const time_t time_s = time_ms / 1000;
+ int millisec = time_ms - (time_s * 1000);
+ ptm = gmtime_r(&time_s, &tmbuf);
if (ptm) {
- if (!strftime(buf, size, "%Y-%m-%dT%H:%M:%SZ", ptm))
+ int len;
+ if (!strftime(buf, size, "%Y-%m-%dT%H:%M:%S", ptm)) {
buf[0] = '\0';
+ return;
+ }
+ len = strlen(buf);
+ snprintf(buf + len, size - len, ".%03dZ", millisec);
}
}
role = av_dict_get(as->metadata, "role", NULL, 0);
if (role)
avio_printf(out, "\t\t\t<Role schemeIdUri=\"urn:mpeg:dash:role:2011\" value=\"%s\"/>\n", role->value);
-
+ if (as->descriptor)
+ avio_printf(out, "\t\t\t%s\n", as->descriptor);
for (i = 0; i < s->nb_streams; i++) {
OutputStream *os = &c->streams[i];
char bandwidth_str[64] = {'\0'};
{
DASHContext *c = s->priv_data;
const char *p = c->adaptation_sets;
- enum { new_set, parse_id, parsing_streams } state;
+ enum { new_set, parse_id, parsing_streams, parse_descriptor } state;
AdaptationSet *as;
int i, n, ret;
}
// syntax id=0,streams=0,1,2 id=1,streams=3,4 and so on
+ // option id=0,descriptor=descriptor_str,streams=0,1,2 and so on
+ // descriptor is useful to the scheme defined by ISO/IEC 23009-1:2014/Amd.2:2015
+ // descriptor_str should be a self-closing xml tag.
state = new_set;
while (*p) {
if (*p == ' ') {
if (*p)
p++;
state = parse_id;
- } else if (state == parse_id && av_strstart(p, "streams=", &p)) {
+ } else if (state == parse_id && av_strstart(p, "descriptor=", &p)) {
+ n = strcspn(p, ">") + 1; //followed by one comma, so plus 1
+ if (n < strlen(p)) {
+ as->descriptor = av_strndup(p, n);
+ } else {
+ av_log(s, AV_LOG_ERROR, "Parse error, descriptor string should be a self-closing xml tag\n");
+ return AVERROR(EINVAL);
+ }
+ p += n;
+ if (*p)
+ p++;
+ state = parse_descriptor;
+ } else if ((state == parse_id || state == parse_descriptor) && av_strstart(p, "streams=", &p)) { //descriptor is optional
state = parsing_streams;
} else if (state == parsing_streams) {
AdaptationSet *as = &c->as[c->nb_as - 1];
ret = dashenc_io_open(s, &c->mpd_out, temp_filename, &opts);
av_dict_free(&opts);
if (ret < 0) {
- av_log(s, AV_LOG_ERROR, "Unable to open %s for writing\n", temp_filename);
- return c->ignore_io_errors ? 0 : ret;
+ return handle_io_open_error(s, ret, temp_filename);
}
out = c->mpd_out;
avio_printf(out, "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n");
return ret;
}
- if (c->hls_playlist && !c->master_playlist_created) {
+ if (c->hls_playlist) {
char filename_hls[1024];
const char *audio_group = "A1";
char audio_codec_str[128] = "\0";
int is_default = 1;
int max_audio_bitrate = 0;
+ // Publish master playlist only the configured rate
+ if (c->master_playlist_created && (!c->master_publish_rate ||
+ c->streams[0].segment_index % c->master_publish_rate))
+ return 0;
+
if (*c->dirname)
snprintf(filename_hls, sizeof(filename_hls), "%smaster.m3u8", c->dirname);
else
ret = dashenc_io_open(s, &c->m3u8_out, temp_filename, &opts);
av_dict_free(&opts);
if (ret < 0) {
- av_log(s, AV_LOG_ERROR, "Unable to open %s for writing\n", temp_filename);
- return c->ignore_io_errors ? 0 : ret;
+ return handle_io_open_error(s, ret, temp_filename);
}
ff_hls_write_playlist_version(c->m3u8_out, 7);
continue;
get_hls_playlist_name(playlist_file, sizeof(playlist_file), NULL, i);
ff_hls_write_audio_rendition(c->m3u8_out, (char *)audio_group,
- playlist_file, i, is_default);
+ playlist_file, NULL, i, is_default);
max_audio_bitrate = FFMAX(st->codecpar->bit_rate +
os->muxer_overhead, max_audio_bitrate);
if (!av_strnstr(audio_codec_str, os->codec_str, sizeof(audio_codec_str))) {
char *ptr;
char basename[1024];
+ c->nr_of_streams_to_flush = 0;
if (c->single_file_name)
c->single_file = 1;
if (c->single_file)
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");
+ return AVERROR_EXPERIMENTAL;
+ }
+
+ if (c->lhls && !c->streaming) {
+ av_log(s, AV_LOG_WARNING, "LHLS option will be ignored as streaming is not enabled\n");
+ c->lhls = 0;
+ }
+
+ if (c->lhls && !c->hls_playlist) {
+ av_log(s, AV_LOG_WARNING, "LHLS option will be ignored as hls_playlist is not enabled\n");
+ c->lhls = 0;
+ }
+
+ if (c->global_sidx && !c->single_file) {
+ av_log(s, AV_LOG_WARNING, "Global SIDX option will be ignored as single_file is not enabled\n");
+ c->global_sidx = 0;
+ }
+
+ if (c->global_sidx && c->streaming) {
+ av_log(s, AV_LOG_WARNING, "Global SIDX option will be ignored as streaming is enabled\n");
+ c->global_sidx = 0;
+ }
av_strlcpy(c->dirname, s->url, sizeof(c->dirname));
ptr = strrchr(c->dirname, '/');
return AVERROR(ENOMEM);
if (c->init_seg_name) {
- os->init_seg_name = av_strireplace(c->init_seg_name, "$ext$", os->format_name);
+ os->init_seg_name = av_strireplace(c->init_seg_name, "$ext$", os->extension_name);
if (!os->init_seg_name)
return AVERROR(ENOMEM);
}
if (c->media_seg_name) {
- os->media_seg_name = av_strireplace(c->media_seg_name, "$ext$", os->format_name);
+ os->media_seg_name = av_strireplace(c->media_seg_name, "$ext$", os->extension_name);
if (!os->media_seg_name)
return AVERROR(ENOMEM);
}
if (c->single_file_name) {
- os->single_file_name = av_strireplace(c->single_file_name, "$ext$", os->format_name);
+ os->single_file_name = av_strireplace(c->single_file_name, "$ext$", os->extension_name);
if (!os->single_file_name)
return AVERROR(ENOMEM);
}
"Override -init_seg_name and/or -media_seg_name and/or "
"-single_file_name to end with the extension .webm\n");
}
+ if (c->streaming) {
+ // Streaming not supported as matroskaenc buffers internally before writing the output
+ av_log(s, AV_LOG_WARNING, "One or more streams in WebM output format. Streaming option will be ignored\n");
+ c->streaming = 0;
+ }
}
ctx->oformat = av_guess_format(os->format_name, NULL, NULL);
ctx->avoid_negative_ts = s->avoid_negative_ts;
ctx->flags = s->flags;
- if ((ret = avio_open_dyn_buf(&ctx->pb)) < 0)
- return ret;
-
if (c->single_file) {
if (os->single_file_name)
ff_dash_fill_tmpl_params(os->initfile, sizeof(os->initfile), os->single_file_name, i, 0, os->bit_rate, 0);
}
snprintf(filename, sizeof(filename), "%s%s", c->dirname, os->initfile);
set_http_options(&opts, c);
- ret = s->io_open(s, &os->out, filename, AVIO_FLAG_WRITE, &opts);
+ if (!c->single_file) {
+ if ((ret = avio_open_dyn_buf(&ctx->pb)) < 0)
+ return ret;
+ ret = s->io_open(s, &os->out, filename, AVIO_FLAG_WRITE, &opts);
+ } else {
+ ctx->url = av_strdup(filename);
+ ret = avio_open2(&ctx->pb, filename, AVIO_FLAG_WRITE, NULL, &opts);
+ }
av_dict_free(&opts);
if (ret < 0)
return ret;
if (os->segment_type == SEGMENT_TYPE_MP4) {
if (c->streaming)
- av_dict_set(&opts, "movflags", "frag_every_frame+dash+delay_moov+global_sidx", 0);
- else
- av_dict_set(&opts, "movflags", "frag_custom+dash+delay_moov", 0);
+ // frag_every_frame : Allows lower latency streaming
+ // skip_sidx : Reduce bitrate overhead
+ // skip_trailer : Avoids growing memory usage with time
+ av_dict_set(&opts, "movflags", "frag_every_frame+dash+delay_moov+skip_sidx+skip_trailer", 0);
+ else {
+ if (c->global_sidx)
+ av_dict_set(&opts, "movflags", "frag_custom+dash+delay_moov+global_sidx+skip_trailer", 0);
+ else
+ av_dict_set(&opts, "movflags", "frag_custom+dash+delay_moov+skip_trailer", 0);
+ }
} else {
av_dict_set_int(&opts, "cluster_time_limit", c->seg_duration / 1000, 0);
av_dict_set_int(&opts, "cluster_size_limit", 5 * 1024 * 1024, 0); // set a large cluster size limit
os->max_pts = AV_NOPTS_VALUE;
os->last_dts = AV_NOPTS_VALUE;
os->segment_index = 1;
+
+ if (s->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
+ c->nr_of_streams_to_flush++;
}
if (!c->has_video && c->seg_duration <= 0) {
av_log(s, AV_LOG_WARNING, "no video stream and no seg duration set\n");
return AVERROR(EINVAL);
}
+
+ c->nr_of_streams_flushed = 0;
+
return 0;
}
}
static int update_stream_extradata(AVFormatContext *s, OutputStream *os,
- AVCodecParameters *par,
- AVRational *frame_rate)
+ AVPacket *pkt, AVRational *frame_rate)
{
+ AVCodecParameters *par = os->ctx->streams[0]->codecpar;
uint8_t *extradata;
+ int ret, extradata_size;
- if (os->ctx->streams[0]->codecpar->extradata_size || !par->extradata_size)
+ if (par->extradata_size)
return 0;
- extradata = av_malloc(par->extradata_size);
-
- if (!extradata)
- return AVERROR(ENOMEM);
+ extradata = av_packet_get_side_data(pkt, AV_PKT_DATA_NEW_EXTRADATA, &extradata_size);
+ if (!extradata_size)
+ return 0;
- memcpy(extradata, par->extradata, par->extradata_size);
+ ret = ff_alloc_extradata(par, extradata_size);
+ if (ret < 0)
+ return ret;
- os->ctx->streams[0]->codecpar->extradata = extradata;
- os->ctx->streams[0]->codecpar->extradata_size = par->extradata_size;
+ memcpy(par->extradata, extradata, extradata_size);
set_codec_str(s, par, frame_rate, os->codec_str, sizeof(os->codec_str));
av_dict_free(&http_opts);
ff_format_io_close(s, &out);
- } else if (unlink(filename) < 0) {
- av_log(s, AV_LOG_ERROR, "failed to delete %s: %s\n", filename, strerror(errno));
+ } else {
+ int res = avpriv_io_delete(filename);
+ if (res < 0) {
+ char errbuf[AV_ERROR_MAX_STRING_SIZE];
+ av_strerror(res, errbuf, sizeof(errbuf));
+ av_log(s, (res == AVERROR(ENOENT) ? AV_LOG_WARNING : AV_LOG_ERROR), "failed to delete %s: %s\n", filename, errbuf);
+ }
}
}
+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);
+ }
+
+ memcpy(filename, c->dirname, dirname_len);
+
+ 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);
+ }
+
+ memcpy(filename + dirname_len, file, file_len + 1); // include the terminating zero
+ dashenc_delete_file(s, filename);
+
+ return 0;
+}
+
+static inline void dashenc_delete_media_segments(AVFormatContext *s, OutputStream *os, int remove_count)
+{
+ for (int i = 0; i < remove_count; ++i) {
+ dashenc_delete_segment_file(s, os->segments[i]->file);
+
+ // Delete the segment regardless of whether the file was successfully deleted
+ av_free(os->segments[i]);
+ }
+
+ os->nb_segments -= remove_count;
+ memmove(os->segments, os->segments + remove_count, os->nb_segments * sizeof(*os->segments));
+}
+
static int dash_flush(AVFormatContext *s, int final, int stream)
{
DASHContext *c = s->priv_data;
snprintf(os->full_path, sizeof(os->full_path), "%s%s", c->dirname, os->initfile);
}
- ret = flush_dynbuf(os, &range_length);
+ ret = flush_dynbuf(c, os, &range_length);
if (ret < 0)
break;
os->packets_written = 0;
os->pos += range_length;
}
- if (c->window_size || (final && c->remove_at_exit)) {
+ if (c->window_size) {
+ for (i = 0; i < s->nb_streams; i++) {
+ OutputStream *os = &c->streams[i];
+ int remove_count = os->nb_segments - c->window_size - c->extra_window_size;
+ if (remove_count > 0)
+ dashenc_delete_media_segments(s, os, remove_count);
+ }
+ }
+
+ if (final) {
for (i = 0; i < s->nb_streams; i++) {
OutputStream *os = &c->streams[i];
- int j;
- int remove = os->nb_segments - c->window_size - c->extra_window_size;
- if (final && c->remove_at_exit)
- remove = os->nb_segments;
- if (remove > 0) {
- for (j = 0; j < remove; j++) {
- char filename[1024];
- snprintf(filename, sizeof(filename), "%s%s", c->dirname, os->segments[j]->file);
- dashenc_delete_file(s, filename);
- av_free(os->segments[j]);
+ if (os->ctx && os->ctx_inited) {
+ int64_t file_size = avio_tell(os->ctx->pb);
+ av_write_trailer(os->ctx);
+ if (c->global_sidx) {
+ int j, start_index, start_number;
+ int64_t sidx_size = avio_tell(os->ctx->pb) - file_size;
+ get_start_index_number(os, c, &start_index, &start_number);
+ if (start_index >= os->nb_segments ||
+ os->segment_type != SEGMENT_TYPE_MP4)
+ continue;
+ os->init_range_length += sidx_size;
+ for (j = start_index; j < os->nb_segments; j++) {
+ Segment *seg = os->segments[j];
+ seg->start_pos += sidx_size;
+ }
}
- os->nb_segments -= remove;
- memmove(os->segments, os->segments + remove, os->nb_segments * sizeof(*os->segments));
+
}
}
}
+ if (ret >= 0) {
+ if (c->has_video && !final) {
+ c->nr_of_streams_flushed++;
+ if (c->nr_of_streams_flushed != c->nr_of_streams_to_flush)
+ return ret;
- if (ret >= 0)
+ c->nr_of_streams_flushed = 0;
+ }
ret = write_manifest(s, final);
+ }
return ret;
}
int64_t seg_end_duration, elapsed_duration;
int ret;
- ret = update_stream_extradata(s, os, st->codecpar, &st->avg_frame_rate);
+ ret = update_stream_extradata(s, os, pkt, &st->avg_frame_rate);
if (ret < 0)
return ret;
os->first_pts = pkt->pts;
os->last_pts = pkt->pts;
- if (!c->availability_start_time[0])
+ if (!c->availability_start_time[0]) {
+ int64_t start_time_us = av_gettime();
+ c->start_time_s = start_time_us / 1000000;
format_date_now(c->availability_start_time,
sizeof(c->availability_start_time));
+ }
if (!os->availability_time_offset && pkt->duration) {
int64_t frame_duration = av_rescale_q(pkt->duration, st->time_base,
ret = dashenc_io_open(s, &os->out, os->temp_path, &opts);
av_dict_free(&opts);
if (ret < 0) {
- return c->ignore_io_errors ? 0 : ret;
+ return handle_io_open_error(s, ret, os->temp_path);
+ }
+ if (c->lhls) {
+ char *prefetch_url = use_rename ? NULL : os->filename;
+ write_hls_media_playlist(os, s, pkt->stream_index, 0, prefetch_url);
}
}
static int dash_write_trailer(AVFormatContext *s)
{
DASHContext *c = s->priv_data;
+ int i;
if (s->nb_streams > 0) {
OutputStream *os = &c->streams[0];
dash_flush(s, 1, -1);
if (c->remove_at_exit) {
- char filename[1024];
- int i;
- for (i = 0; i < s->nb_streams; i++) {
+ for (i = 0; i < s->nb_streams; ++i) {
OutputStream *os = &c->streams[i];
- snprintf(filename, sizeof(filename), "%s%s", c->dirname, os->initfile);
- dashenc_delete_file(s, filename);
+ dashenc_delete_media_segments(s, os, os->nb_segments);
+ dashenc_delete_segment_file(s, os->initfile);
+ if (c->hls_playlist && os->segment_type == SEGMENT_TYPE_MP4) {
+ char filename[1024];
+ get_hls_playlist_name(filename, sizeof(filename), c->dirname, i);
+ dashenc_delete_file(s, filename);
+ }
}
dashenc_delete_file(s, s->url);
if (c->hls_playlist && c->master_playlist_created) {
- for (i = 0; i < s->nb_streams; i++) {
- OutputStream *os = &c->streams[i];
- if (os->segment_type == SEGMENT_TYPE_MP4) {
- get_hls_playlist_name(filename, sizeof(filename), c->dirname, i);
- dashenc_delete_file(s, filename);
- }
- }
+ char filename[1024];
snprintf(filename, sizeof(filename), "%smaster.m3u8", c->dirname);
dashenc_delete_file(s, filename);
}
{ "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 },
{ "format_options","set list of options for the container format (mp4/webm) used for dash", OFFSET(format_options_str), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, E},
+ { "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 },
{ "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"},
{ "auto", "select segment file format based on codec", 0, AV_OPT_TYPE_CONST, {.i64 = SEGMENT_TYPE_AUTO }, 0, UINT_MAX, E, "segment_type"},
{ "mp4", "make segment file in ISOBMFF format", 0, AV_OPT_TYPE_CONST, {.i64 = SEGMENT_TYPE_MP4 }, 0, UINT_MAX, E, "segment_type"},
{ "webm", "make segment file in WebM format", 0, AV_OPT_TYPE_CONST, {.i64 = SEGMENT_TYPE_WEBM }, 0, UINT_MAX, E, "segment_type"},
{ "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 },
+ { "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 },
+ { "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},
{ NULL },
};
projects / ffmpeg / blobdiff