44 #if CONFIG_HTTP_PROTOCOL
69 #define MPD_PROFILE_DASH 1
70 #define MPD_PROFILE_DVB 2
150 #if FF_API_DASH_MIN_SEG_DURATION
231 if (!*pb || !http_base_proto || !
c->http_persistent) {
233 #if CONFIG_HTTP_PROTOCOL
252 if (!http_base_proto || !
c->http_persistent) {
254 #if CONFIG_HTTP_PROTOCOL
267 if (
formats[
i].segment_type == segment_type)
278 default:
return NULL;
287 "Unable to open %s for writing: %s\n", url, errbuf);
288 return c->ignore_io_errors ? 0 : err;
308 int has_mp4_streams = 0;
309 for (
int i = 0;
i <
s->nb_streams; ++
i) {
312 c->segment_type_option,
s->streams[
i]->codecpar->codec_id);
328 if (
c->hls_playlist && !has_mp4_streams) {
338 if (!filename || !extension)
340 dot = strrchr(filename,
'.');
341 if (dot && !strcmp(dot + 1, extension))
397 if (!strcmp(
str,
"mp4a") || !strcmp(
str,
"mp4v")) {
406 if (
tag ==
MKTAG(
'm',
'p',
'4',
'a')) {
413 }
else if (
tag ==
MKTAG(
'm',
'p',
'4',
'v')) {
417 }
else if (!strcmp(
str,
"avc1")) {
423 if (extradata[0] != 1) {
435 if (extradata_size >= 4)
437 extradata[1], extradata[2], extradata[3]);
439 }
else if (!strcmp(
str,
"av01")) {
469 if (!
c->single_file) {
493 if (
c->http_persistent)
500 const char *base_url,
int id) {
502 snprintf(playlist_name, string_size,
"%smedia_%d.m3u8", base_url,
id);
504 snprintf(playlist_name, string_size,
"media_%d.m3u8",
id);
508 int *start_index,
int *start_number) {
511 if (
c->window_size) {
518 int representation_id,
int final,
519 char *prefetch_url) {
522 char temp_filename_hls[1024];
523 char filename_hls[1024];
525 int target_duration = 0;
528 int use_rename = proto && !strcmp(proto,
"file");
529 int i, start_index, start_number;
530 double prog_date_time = 0;
534 if (!
c->hls_playlist || start_index >= os->
nb_segments ||
539 c->dirname, representation_id);
541 snprintf(temp_filename_hls,
sizeof(temp_filename_hls), use_rename ?
"%s.tmp" :
"%s", filename_hls);
566 if (prog_date_time == 0) {
568 prog_date_time =
c->start_time_s;
575 (
double) seg->
duration / timescale, 0,
578 &prog_date_time, 0, 0, 0);
585 avio_printf(
c->m3u8_out,
"#EXT-X-PREFETCH:%s\n", prefetch_url);
599 int ret, range_length;
606 if (!
c->single_file) {
620 for (
i = 0;
i <
c->nb_as;
i++) {
630 for (
i = 0;
i <
s->nb_streams;
i++) {
656 int representation_id,
int final)
659 int i, start_index, start_number;
662 if (
c->use_template) {
664 avio_printf(
out,
"\t\t\t\t<SegmentTemplate timescale=\"%d\" ", timescale);
665 if (!
c->use_timeline) {
675 if (
c->presentation_time_offset)
676 avio_printf(
out,
" presentationTimeOffset=\"%"PRId64
"\"",
c->presentation_time_offset);
678 if (
c->use_timeline) {
685 if (
i == start_index || seg->
time != cur_time) {
686 cur_time = seg->
time;
698 cur_time += (1 + repeat) * seg->
duration;
703 }
else if (
c->single_file) {
724 if (!
c->lhls ||
final) {
731 int outlen = strlen(
str)*3/2 + 6;
737 if (
pos + 6 > outlen) {
739 outlen = 2 * outlen + 6;
748 memcpy(&
out[
pos],
"&", 5);
750 }
else if (*
str ==
'<') {
751 memcpy(&
out[
pos],
"<", 4);
753 }
else if (*
str ==
'>') {
754 memcpy(&
out[
pos],
">", 4);
756 }
else if (*
str ==
'\'') {
757 memcpy(&
out[
pos],
"'", 6);
759 }
else if (*
str ==
'\"') {
760 memcpy(&
out[
pos],
""", 6);
774 int minutes = seconds / 60;
775 int hours = minutes / 60;
781 if (hours || minutes)
788 struct tm *ptm, tmbuf;
789 int64_t time_ms = time_us / 1000;
790 const time_t time_s = time_ms / 1000;
791 int millisec = time_ms - (time_s * 1000);
795 if (!strftime(buf,
size,
"%Y-%m-%dT%H:%M:%S", ptm)) {
812 avio_printf(
out,
"\t\t<AdaptationSet id=\"%d\" contentType=\"%s\" startWithSAP=\"1\" segmentAlignment=\"true\" bitstreamSwitching=\"true\"",
830 avio_printf(
out,
"\t\t\t<EssentialProperty id=\"%d\" schemeIdUri=\"http://dashif.org/guidelines/trickmode\" value=\"%d\"/>\n", as->
id, as->
trick_idx);
833 avio_printf(
out,
"\t\t\t<Role schemeIdUri=\"urn:mpeg:dash:role:2011\" value=\"%s\"/>\n", role->
value);
836 for (
i = 0;
i <
s->nb_streams;
i++) {
839 char bandwidth_str[64] = {
'\0'};
841 if (os->
as_idx - 1 != as_index)
845 snprintf(bandwidth_str,
sizeof(bandwidth_str),
" bandwidth=\"%d\"", os->
bit_rate);
848 snprintf(bandwidth_str,
sizeof(bandwidth_str),
" bandwidth=\"%d\"", average_bit_rate);
853 avio_printf(
out,
"\t\t\t<Representation id=\"%d\" mimeType=\"video/%s\" codecs=\"%s\"%s width=\"%d\" height=\"%d\"",
871 avio_printf(
out,
"\t\t\t<Representation id=\"%d\" mimeType=\"audio/%s\" codecs=\"%s\"%s audioSamplingRate=\"%d\">\n",
873 avio_printf(
out,
"\t\t\t\t<AudioChannelConfiguration schemeIdUri=\"urn:mpeg:dash:23003:3:audio_channel_configuration:2011\" value=\"%d\" />\n",
874 s->streams[
i]->codecpar->channels);
877 avio_printf(
out,
"\t\t\t\t<ProducerReferenceTime id=\"%d\" inband=\"true\" type=\"%s\" wallClockTime=\"%s\" presentationTime=\"%"PRId64
"\">\n",
879 avio_printf(
out,
"\t\t\t\t\t<UTCTiming schemeIdUri=\"urn:mpeg:dash:utc:http-xsdate:2014\" value=\"%s\"/>\n",
c->utc_timing_url);
908 *as = &
c->as[
c->nb_as - 1];
909 memset(*as, 0,
sizeof(**as));
910 (*as)->media_type =
type;
911 (*as)->frag_type = -1;
912 (*as)->trick_idx = -1;
923 if (as->
media_type !=
s->streams[
i]->codecpar->codec_type) {
924 av_log(
s,
AV_LOG_ERROR,
"Codec type of stream %d doesn't match AdaptationSet's media type\n",
i);
931 av_log(
s,
AV_LOG_ERROR,
"DVB-DASH profile allows a max of 16 Representations per Adaptation Set\n");
943 const char *p =
c->adaptation_sets;
944 enum { new_set, parse_default, parsing_streams, parse_seg_duration, parse_frag_duration }
state;
950 for (
i = 0;
i <
s->nb_streams;
i++) {
955 c->streams[
i].as_idx =
c->nb_as;
975 char id_str[10], *end_str;
978 snprintf(id_str,
sizeof(id_str),
"%.*s", n, p);
980 i = strtol(id_str, &end_str, 10);
981 if (id_str == end_str || i < 0 || i >
c->nb_as) {
993 state = parse_default;
995 state = parse_seg_duration;
997 state = parse_frag_duration;
998 }
else if (
state == parse_seg_duration ||
state == parse_frag_duration) {
1002 n = strcspn(p,
",");
1014 if (
state == parse_seg_duration)
1018 state = parse_default;
1022 n = strcspn(p,
",");
1023 snprintf(type_str,
sizeof(type_str),
"%.*s", n, p);
1028 if (!strcmp(type_str,
"duration"))
1030 else if (!strcmp(type_str,
"pframes"))
1032 else if (!strcmp(type_str,
"every_frame"))
1034 else if (!strcmp(type_str,
"none"))
1037 av_log(
s,
AV_LOG_ERROR,
"Unable to parse option value \"%s\" as fragment type\n", type_str);
1040 state = parse_default;
1042 n = strcspn(p,
">") + 1;
1043 if (n < strlen(p)) {
1046 av_log(
s,
AV_LOG_ERROR,
"Parse error, descriptor string should be a self-closing xml tag\n");
1052 state = parse_default;
1054 char trick_id_str[10], *end_str;
1056 n = strcspn(p,
",");
1057 snprintf(trick_id_str,
sizeof(trick_id_str),
"%.*s", n, p);
1060 as->
trick_idx = strtol(trick_id_str, &end_str, 10);
1061 if (trick_id_str == end_str || as->
trick_idx < 0)
1066 state = parse_default;
1068 state = parsing_streams;
1069 }
else if (
state == parsing_streams) {
1071 char idx_str[8], *end_str;
1073 n = strcspn(p,
" ,");
1074 snprintf(idx_str,
sizeof(idx_str),
"%.*s", n, p);
1082 for (
i = 0;
i <
s->nb_streams;
i++) {
1083 if (
s->streams[
i]->codecpar->codec_type !=
type)
1092 i = strtol(idx_str, &end_str, 10);
1093 if (idx_str == end_str || i < 0 || i >=
s->nb_streams) {
1118 for (
i = 0;
i <
s->nb_streams;
i++) {
1127 for (
i = 0;
i <
c->nb_as;
i++) {
1131 for (n = 0; n <
c->nb_as; n++) {
1135 if (n >=
c->nb_as) {
1148 char temp_filename[1024];
1151 int use_rename = proto && !strcmp(proto,
"file");
1152 static unsigned int warned_non_file = 0;
1156 if (!use_rename && !warned_non_file++)
1157 av_log(
s,
AV_LOG_ERROR,
"Cannot use rename on non file protocol, this may lead to races and temporary partial files\n");
1159 snprintf(temp_filename,
sizeof(temp_filename), use_rename ?
"%s.tmp" :
"%s",
s->url);
1167 avio_printf(
out,
"<?xml version=\"1.0\" encoding=\"utf-8\"?>\n");
1168 avio_printf(
out,
"<MPD xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"\n"
1169 "\txmlns=\"urn:mpeg:dash:schema:mpd:2011\"\n"
1170 "\txmlns:xlink=\"http://www.w3.org/1999/xlink\"\n"
1171 "\txsi:schemaLocation=\"urn:mpeg:DASH:schema:MPD:2011 http://standards.iso.org/ittf/PubliclyAvailableStandards/MPEG-DASH_schema_files/DASH-MPD.xsd\"\n"
1176 avio_printf(
out,
"%s",
"urn:dvb:dash:profile:dvb-dash:2014\"\n");
1178 final ?
"static" :
"dynamic");
1186 if (
c->use_template && !
c->use_timeline)
1187 update_period = 500;
1188 if (
c->update_period)
1189 update_period =
c->update_period;
1190 avio_printf(
out,
"\tminimumUpdatePeriod=\"PT%"PRId64
"S\"\n", update_period);
1193 if (
c->availability_start_time[0])
1194 avio_printf(
out,
"\tavailabilityStartTime=\"%s\"\n",
c->availability_start_time);
1198 if (
c->window_size &&
c->use_template) {
1208 write_time(
out,
c->ldash &&
c->max_gop_size ?
c->max_gop_size :
c->last_duration * 2);
1219 if (!
final &&
c->target_latency &&
c->target_latency_refid >= 0) {
1220 avio_printf(
out,
"\t\t<Latency target=\"%"PRId64
"\"",
c->target_latency / 1000);
1221 if (
s->nb_streams > 1)
1227 avio_printf(
out,
"\t\t<PlaybackRate min=\"%.2f\" max=\"%.2f\"/>\n",
1231 if (
c->window_size &&
s->nb_streams > 0 &&
c->streams[0].nb_segments > 0 && !
c->use_template) {
1242 for (
i = 0;
i <
c->nb_as;
i++) {
1248 if (
c->utc_timing_url)
1249 avio_printf(
out,
"\t<UTCTiming schemeIdUri=\"urn:mpeg:dash:utc:http-xsdate:2014\" value=\"%s\"/>\n",
c->utc_timing_url);
1256 if ((ret =
ff_rename(temp_filename,
s->url,
s)) < 0)
1260 if (
c->hls_playlist) {
1261 char filename_hls[1024];
1262 const char *audio_group =
"A1";
1263 char audio_codec_str[128] =
"\0";
1265 int max_audio_bitrate = 0;
1268 if (
c->master_playlist_created && (!
c->master_publish_rate ||
1269 c->streams[0].segment_index %
c->master_publish_rate))
1273 snprintf(filename_hls,
sizeof(filename_hls),
"%s%s",
c->dirname,
c->hls_master_name);
1275 snprintf(filename_hls,
sizeof(filename_hls),
"%s",
c->hls_master_name);
1277 snprintf(temp_filename,
sizeof(temp_filename), use_rename ?
"%s.tmp" :
"%s", filename_hls);
1288 for (
i = 0;
i <
s->nb_streams;
i++) {
1289 char playlist_file[64];
1298 playlist_file,
NULL,
i, is_default);
1302 if (strlen(audio_codec_str))
1303 av_strlcat(audio_codec_str,
",",
sizeof(audio_codec_str));
1309 for (
i = 0;
i <
s->nb_streams;
i++) {
1310 char playlist_file[64];
1311 char codec_str[128];
1314 char *agroup =
NULL;
1315 char *codec_str_ptr =
NULL;
1328 if (max_audio_bitrate) {
1329 agroup = (
char *)audio_group;
1330 stream_bitrate += max_audio_bitrate;
1331 av_strlcat(codec_str,
",",
sizeof(codec_str));
1332 av_strlcat(codec_str, audio_codec_str,
sizeof(codec_str));
1335 codec_str_ptr = codec_str;
1339 playlist_file, agroup,
1344 if ((ret =
ff_rename(temp_filename, filename_hls,
s)) < 0)
1346 c->master_playlist_created = 1;
1365 char basename[1024];
1367 c->nr_of_streams_to_flush = 0;
1368 if (
c->single_file_name)
1371 c->use_template = 0;
1377 #if FF_API_DASH_MIN_SEG_DURATION
1378 if (
c->min_seg_duration != 5000000) {
1379 av_log(
s,
AV_LOG_WARNING,
"The min_seg_duration option is deprecated and will be removed. Please use the -seg_duration\n");
1380 c->seg_duration =
c->min_seg_duration;
1385 "LHLS is experimental, Please set -strict experimental in order to enable it.\n");
1389 if (
c->lhls && !
c->streaming) {
1394 if (
c->lhls && !
c->hls_playlist) {
1399 if (
c->ldash && !
c->streaming) {
1404 if (
c->target_latency && !
c->streaming) {
1406 c->target_latency = 0;
1409 if (
c->global_sidx && !
c->single_file) {
1414 if (
c->global_sidx &&
c->streaming) {
1423 if (
c->write_prft < 0) {
1424 c->write_prft =
c->ldash;
1429 if (
c->write_prft && !
c->utc_timing_url) {
1430 av_log(
s,
AV_LOG_WARNING,
"Producer Reference Time element option will be ignored as utc_timing_url is not set\n");
1434 if (
c->write_prft && !
c->streaming) {
1435 av_log(
s,
AV_LOG_WARNING,
"Producer Reference Time element option will be ignored as streaming is not enabled\n");
1439 if (
c->ldash && !
c->write_prft) {
1440 av_log(
s,
AV_LOG_WARNING,
"Low Latency mode enabled without Producer Reference Time element option! Resulting manifest may not be complaint\n");
1443 if (
c->target_latency && !
c->write_prft) {
1444 av_log(
s,
AV_LOG_WARNING,
"Target latency option will be ignored as Producer Reference Time element will not be written\n");
1445 c->target_latency = 0;
1448 if (
av_cmp_q(
c->max_playback_rate,
c->min_playback_rate) < 0) {
1449 av_log(
s,
AV_LOG_WARNING,
"Minimum playback rate value is higer than the Maximum. Both will be ignored\n");
1450 c->min_playback_rate =
c->max_playback_rate = (
AVRational) {1, 1};
1454 ptr = strrchr(
c->dirname,
'/');
1456 av_strlcpy(basename, &ptr[1],
sizeof(basename));
1459 c->dirname[0] =
'\0';
1463 ptr = strrchr(basename,
'.');
1467 c->streams =
av_mallocz(
sizeof(*
c->streams) *
s->nb_streams);
1477 for (
i = 0;
i <
s->nb_streams;
i++) {
1483 char filename[1024];
1485 os->
bit_rate =
s->streams[
i]->codecpar->bit_rate;
1498 if (
c->init_seg_name) {
1503 if (
c->media_seg_name) {
1508 if (
c->single_file_name) {
1519 "One or many segment file names doesn't end with .webm. "
1520 "Override -init_seg_name and/or -media_seg_name and/or "
1521 "-single_file_name to end with the extension .webm\n");
1525 av_log(
s,
AV_LOG_WARNING,
"One or more streams in WebM output format. Streaming option will be ignored\n");
1564 if (
c->single_file) {
1574 if (!
c->single_file) {
1615 av_log(
s,
AV_LOG_WARNING,
"frag_type set to P-Frame reordering, but no parser found for stream %d\n",
i);
1663 AVRational avg_frame_rate =
s->streams[
i]->avg_frame_rate;
1665 if (avg_frame_rate.
num > 0) {
1689 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);
1705 c->nr_of_streams_to_flush++;
1708 if (!
c->has_video &&
c->seg_duration <= 0) {
1715 c->nr_of_streams_flushed = 0;
1716 c->target_latency_refid = -1;
1725 for (
i = 0;
i <
s->nb_streams;
i++) {
1743 int64_t index_length,
int next_exp_index)
1762 if (seg->
time < 0) {
1810 *index_length =
AV_RB32(&buf[0]);
1825 if (!extradata_size)
1832 memcpy(par->
extradata, extradata, extradata_size);
1843 if (http_base_proto) {
1888 for (
int i = 0;
i < remove_count; ++
i) {
1905 int use_rename = proto && !strcmp(proto,
"file");
1907 int cur_flush_segment_index = 0, next_exp_index = -1;
1909 cur_flush_segment_index =
c->streams[stream].segment_index;
1912 if (
c->use_template && !
c->use_timeline &&
c->index_correction &&
1916 c->streams[stream].first_pts,
1917 s->streams[stream]->time_base,
1919 next_exp_index = (pts_diff /
c->streams[stream].seg_duration) + 1;
1923 for (
i = 0;
i <
s->nb_streams;
i++) {
1926 int range_length, index_length = 0;
1935 if (stream >= 0 &&
i != stream) {
1955 if (
c->single_file) {
1982 os->
pos += range_length;
1985 if (
c->window_size) {
1986 for (
i = 0;
i <
s->nb_streams;
i++) {
1988 int remove_count = os->
nb_segments -
c->window_size -
c->extra_window_size;
1989 if (remove_count > 0)
1995 for (
i = 0;
i <
s->nb_streams;
i++) {
2000 if (
c->global_sidx) {
2001 int j, start_index, start_number;
2018 if (
c->has_video && !
final) {
2019 c->nr_of_streams_flushed++;
2020 if (
c->nr_of_streams_flushed !=
c->nr_of_streams_to_flush)
2023 c->nr_of_streams_flushed = 0;
2049 if (
c->target_latency_refid < 0)
2062 int64_t seg_end_duration, elapsed_duration;
2087 if (
c->write_prft) {
2098 if (!
c->availability_start_time[0]) {
2100 c->start_time_s = start_time_us / 1000000;
2102 sizeof(
c->availability_start_time), start_time_us);
2128 if (
c->use_template && !
c->use_timeline) {
2164 "Segment durations differ too much, enable use_timeline "
2165 "and use_template, or keep a stricter keyframe interval\n");
2235 int use_rename = proto && !strcmp(proto,
"file");
2245 use_rename ?
"%s.tmp" :
"%s", os->
full_path);
2279 if (
s->nb_streams > 0) {
2283 if (!
c->last_duration)
2285 s->streams[0]->time_base,
2288 s->streams[0]->time_base,
2293 if (
c->remove_at_exit) {
2294 for (
i = 0;
i <
s->nb_streams; ++
i) {
2299 char filename[1024];
2306 if (
c->hls_playlist &&
c->master_playlist_created) {
2307 char filename[1024];
2308 snprintf(filename,
sizeof(filename),
"%s%s",
c->dirname,
c->hls_master_name);
2337 #define OFFSET(x) offsetof(DASHContext, x)
2338 #define E AV_OPT_FLAG_ENCODING_PARAM
2340 {
"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 },
2341 {
"window_size",
"number of segments kept in the manifest",
OFFSET(window_size),
AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX,
E },
2342 {
"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 },
2343 #if FF_API_DASH_MIN_SEG_DURATION
2344 {
"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 },
2346 {
"seg_duration",
"segment duration (in seconds, fractional value can be set)",
OFFSET(seg_duration),
AV_OPT_TYPE_DURATION, { .i64 = 5000000 }, 0, INT_MAX,
E },
2347 {
"frag_duration",
"fragment duration (in seconds, fractional value can be set)",
OFFSET(frag_duration),
AV_OPT_TYPE_DURATION, { .i64 = 0 }, 0, INT_MAX,
E },
2352 {
"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"},
2353 {
"remove_at_exit",
"remove all segments when finished",
OFFSET(remove_at_exit),
AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1,
E },
2354 {
"use_template",
"Use SegmentTemplate instead of SegmentList",
OFFSET(use_template),
AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1,
E },
2355 {
"use_timeline",
"Use SegmentTimeline in SegmentTemplate",
OFFSET(use_timeline),
AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1,
E },
2356 {
"single_file",
"Store all segments in one file, accessed using byte ranges",
OFFSET(single_file),
AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1,
E },
2357 {
"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 },
2358 {
"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 },
2359 {
"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 },
2360 {
"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 },
2363 {
"http_persistent",
"Use persistent HTTP connections",
OFFSET(http_persistent),
AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1,
E },
2364 {
"hls_playlist",
"Generate HLS playlist files(master.m3u8, media_%d.m3u8)",
OFFSET(hls_playlist),
AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1,
E },
2365 {
"hls_master_name",
"HLS master playlist name",
OFFSET(hls_master_name),
AV_OPT_TYPE_STRING, {.str =
"master.m3u8"}, 0, 0,
E },
2366 {
"streaming",
"Enable/Disable streaming mode of output. Each frame will be moof fragment",
OFFSET(streaming),
AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1,
E },
2367 {
"timeout",
"set timeout for socket I/O operations",
OFFSET(timeout),
AV_OPT_TYPE_DURATION, { .i64 = -1 }, -1, INT_MAX, .flags =
E },
2368 {
"index_correction",
"Enable/Disable segment index correction logic",
OFFSET(index_correction),
AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1,
E },
2369 {
"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},
2370 {
"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 },
2375 {
"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 },
2376 {
"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 },
2377 {
"ldash",
"Enable Low-latency dash. Constrains the value of a few elements",
OFFSET(ldash),
AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1,
E },
2378 {
"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},
2379 {
"write_prft",
"Write producer reference time element",
OFFSET(write_prft),
AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1,
E},
2384 {
"target_latency",
"Set desired target latency for Low-latency dash",
OFFSET(target_latency),
AV_OPT_TYPE_DURATION, { .i64 = 0 }, 0, INT_MAX,
E },
2385 {
"min_playback_rate",
"Set desired minimum playback rate",
OFFSET(min_playback_rate),
AV_OPT_TYPE_RATIONAL, { .dbl = 1.0 }, 0.5, 1.5,
E },
2386 {
"max_playback_rate",
"Set desired maximum playback rate",
OFFSET(max_playback_rate),
AV_OPT_TYPE_RATIONAL, { .dbl = 1.0 }, 0.5, 1.5,
E },
2387 {
"update_period",
"Set the mpd update interval",
OFFSET(update_period),
AV_OPT_TYPE_INT64, {.i64 = 0}, 0, INT64_MAX,
E},
2401 .extensions =
"mpd",
int ff_av1_parse_seq_header(AV1SequenceParameters *seq, const uint8_t *buf, int size)
Parses a Sequence Header from the the provided buffer.
simple assert() macros that are a bit more flexible than ISO C assert().
#define av_assert0(cond)
assert() equivalent, that is always enabled.
int ff_isom_write_avcc(AVIOContext *pb, const uint8_t *data, int len)
#define FF_COMPLIANCE_EXPERIMENTAL
Allow nonstandardized experimental things.
#define FF_COMPLIANCE_STRICT
Strictly conform to all the things in the spec no matter what consequences.
#define PARSER_FLAG_COMPLETE_FRAMES
int ffurl_shutdown(URLContext *h, int flags)
Signal the URLContext that we are done reading or writing the stream.
int avpriv_io_delete(const char *url)
Delete a resource.
const char * avio_find_protocol_name(const char *url)
Return the name of the protocol that will handle the passed URL.
int ff_rename(const char *url_src, const char *url_dst, void *logctx)
Wrap avpriv_io_move and log if error happens.
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
void avio_wb32(AVIOContext *s, unsigned int val)
#define AVIO_FLAG_READ
read-only
#define AVIO_FLAG_WRITE
write-only
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
int avio_printf(AVIOContext *s, const char *fmt,...) av_printf_format(2
Writes a formatted string to the context.
int avio_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer)
Return the written size and a pointer to the buffer.
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
int avio_close(AVIOContext *s)
Close the resource accessed by the AVIOContext s and free it.
void avio_flush(AVIOContext *s)
Force flushing of buffered data.
int avio_open_dyn_buf(AVIOContext **s)
Open a write only memory stream.
int avio_open2(AVIOContext **s, const char *url, int flags, const AVIOInterruptCB *int_cb, AVDictionary **options)
Create and initialize a AVIOContext for accessing the resource indicated by url.
int avio_get_dyn_buf(AVIOContext *s, uint8_t **pbuffer)
Return the written size and a pointer to the buffer.
void ffio_free_dyn_buf(AVIOContext **s)
Free a dynamic buffer.
static av_always_inline void ffio_wfourcc(AVIOContext *pb, const uint8_t *s)
URLContext * ffio_geturlcontext(AVIOContext *s)
Return the URLContext associated with the AVIOContext.
uint8_t * av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type, buffer_size_t *size)
uint8_t * av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type, buffer_size_t size)
static av_cold int init(AVCodecContext *avctx)
size_t av_strlcatf(char *dst, size_t size, const char *fmt,...)
Convenience header that includes libavutil's core.
void av_bprintf(AVBPrint *buf, const char *fmt,...)
void av_bprint_init(AVBPrint *buf, unsigned size_init, unsigned size_max)
int av_bprint_finalize(AVBPrint *buf, char **ret_str)
Finalize a print buffer.
#define AV_BPRINT_SIZE_UNLIMITED
static int av_bprint_is_complete(const AVBPrint *buf)
Test if the print buffer is complete (not truncated).
#define flags(name, subs,...)
int avcodec_parameters_copy(AVCodecParameters *dst, const AVCodecParameters *src)
Copy the contents of src to dst.
#define MKTAG(a, b, c, d)
void ff_dash_fill_tmpl_params(char *dst, size_t buffer_size, const char *template, int rep_id, int number, int bit_rate, int64_t time)
static void write_time(AVIOContext *out, int64_t time)
AVOutputFormat ff_dash_muxer
static int dict_copy_entry(AVDictionary **dst, const AVDictionary *src, const char *key)
static char * xmlescape(const char *str)
static int dash_parse_prft(DASHContext *c, AVPacket *pkt)
static const AVOption options[]
static int init_segment_types(AVFormatContext *s)
static void get_start_index_number(OutputStream *os, DASHContext *c, int *start_index, int *start_number)
static int update_stream_extradata(AVFormatContext *s, OutputStream *os, AVPacket *pkt, AVRational *frame_rate)
static const AVClass dash_class
static void dash_free(AVFormatContext *s)
static int dashenc_delete_segment_file(AVFormatContext *s, const char *file)
static int dash_flush(AVFormatContext *s, int final, int stream)
static void dashenc_io_close(AVFormatContext *s, AVIOContext **pb, char *filename)
static int dash_init(AVFormatContext *s)
static const char * get_format_str(SegmentType segment_type)
static int dashenc_io_open(AVFormatContext *s, AVIOContext **pb, char *filename, AVDictionary **options)
static int add_adaptation_set(AVFormatContext *s, AdaptationSet **as, enum AVMediaType type)
static void output_segment_list(OutputStream *os, AVIOContext *out, AVFormatContext *s, int representation_id, int final)
static void dashenc_delete_media_segments(AVFormatContext *s, OutputStream *os, int remove_count)
static int dash_write_packet(AVFormatContext *s, AVPacket *pkt)
static int flush_dynbuf(DASHContext *c, OutputStream *os, int *range_length)
static void get_hls_playlist_name(char *playlist_name, int string_size, const char *base_url, int id)
static void find_index_range(AVFormatContext *s, const char *full_path, int64_t pos, int *index_length)
static int parse_adaptation_sets(AVFormatContext *s)
static const char * get_extension_str(SegmentType type, int single_file)
static void write_hls_media_playlist(OutputStream *os, AVFormatContext *s, int representation_id, int final, char *prefetch_url)
static struct codec_string codecs[]
static void write_styp(AVIOContext *pb)
static int dash_write_header(AVFormatContext *s)
static void set_vp9_codec_str(AVFormatContext *s, AVCodecParameters *par, AVRational *frame_rate, char *str, int size)
static int add_segment(OutputStream *os, const char *file, int64_t time, int64_t duration, int64_t start_pos, int64_t range_length, int64_t index_length, int next_exp_index)
static int dash_check_bitstream(struct AVFormatContext *s, const AVPacket *avpkt)
static int handle_io_open_error(AVFormatContext *s, int err, char *url)
static int check_file_extension(const char *filename, const char *extension)
static void set_http_options(AVDictionary **options, DASHContext *c)
static int dash_write_trailer(AVFormatContext *s)
static void format_date(char *buf, int size, int64_t time_us)
static void dashenc_delete_file(AVFormatContext *s, char *filename)
static int adaptation_set_add_stream(AVFormatContext *s, int as_idx, int i)
static SegmentType select_segment_type(SegmentType segment_type, enum AVCodecID codec_id)
static int write_manifest(AVFormatContext *s, int final)
static void set_codec_str(AVFormatContext *s, AVCodecParameters *par, AVRational *frame_rate, char *str, int size)
static int write_adaptation_set(AVFormatContext *s, AVIOContext *out, int as_index, int final)
static int flush_init_segment(AVFormatContext *s, OutputStream *os)
static void write_packet(OutputFile *of, AVPacket *pkt, OutputStream *ost, int unqueue)
static int64_t start_time
static void write_header(FFV1Context *f)
AVCodecID
Identify the syntax and semantics of the bitstream.
int avcodec_parameters_to_context(AVCodecContext *codec, const AVCodecParameters *par)
Fill the codec context based on the values from the supplied codec parameters.
AVCodecContext * avcodec_alloc_context3(const AVCodec *codec)
Allocate an AVCodecContext and set its fields to default values.
void avcodec_free_context(AVCodecContext **avctx)
Free the codec context and everything associated with it and write NULL to the provided pointer.
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
@ AV_PKT_DATA_PRFT
Producer Reference Time data corresponding to the AVProducerReferenceTime struct, usually exported by...
@ AV_PKT_DATA_NEW_EXTRADATA
The AV_PKT_DATA_NEW_EXTRADATA is used to notify the codec or the format that the extradata buffer was...
AVCodecParserContext * av_parser_init(int codec_id)
void av_parser_close(AVCodecParserContext *s)
int av_parser_parse2(AVCodecParserContext *s, AVCodecContext *avctx, uint8_t **poutbuf, int *poutbuf_size, const uint8_t *buf, int buf_size, int64_t pts, int64_t dts, int64_t pos)
Parse a packet.
void avformat_free_context(AVFormatContext *s)
Free an AVFormatContext and all its streams.
AVFormatContext * avformat_alloc_context(void)
Allocate an AVFormatContext.
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
av_warn_unused_result int avformat_init_output(AVFormatContext *s, AVDictionary **options)
Allocate the stream private data and initialize the codec, but do not write the header.
av_warn_unused_result int avformat_write_header(AVFormatContext *s, AVDictionary **options)
Allocate the stream private data and write the stream header to an output media file.
ff_const59 AVOutputFormat * av_guess_format(const char *short_name, const char *filename, const char *mime_type)
Return the output format in the list of registered output formats which best matches the provided par...
int av_write_trailer(AVFormatContext *s)
Write the stream trailer to an output media file and free the file private data.
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
Write a packet to an output media file.
unsigned int av_codec_get_tag(const struct AVCodecTag *const *tags, enum AVCodecID id)
Get the codec tag for the given codec id id.
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values.
int av_dict_copy(AVDictionary **dst, const AVDictionary *src, int flags)
Copy entries from one AVDictionary struct into another.
#define AV_DICT_APPEND
If the entry already exists, append to it.
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
#define AV_DICT_DONT_OVERWRITE
Don't overwrite existing entries.
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
int av_dict_set_int(AVDictionary **pm, const char *key, int64_t value, int flags)
Convenience wrapper for av_dict_set that converts the value to a string and stores it.
#define AV_ERROR_MAX_STRING_SIZE
#define AVERROR_EXPERIMENTAL
Requested feature is flagged experimental. Set strict_std_compliance if you really want to use it.
int av_strerror(int errnum, char *errbuf, size_t errbuf_size)
Put a description of the AVERROR code errnum in errbuf.
#define AVERROR_MUXER_NOT_FOUND
Muxer not found.
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
#define AV_LOG_WARNING
Something somehow does not look correct.
#define AV_LOG_VERBOSE
Detailed information.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
const char * av_default_item_name(void *ptr)
Return the context name.
int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)
Reduce a fraction.
static double av_q2d(AVRational a)
Convert an AVRational to a double.
static int av_cmp_q(AVRational a, AVRational b)
Compare two rationals.
AVRational av_div_q(AVRational b, AVRational c)
Divide one rational by another.
int av_compare_ts(int64_t ts_a, AVRational tb_a, int64_t ts_b, AVRational tb_b)
Compare two timestamps each in its own time base.
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
void * av_realloc(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory.
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
char * av_strdup(const char *s)
Duplicate a string.
int av_reallocp_array(void *ptr, size_t nmemb, size_t size)
Allocate, reallocate, or free an array through a pointer to a pointer.
char * av_strndup(const char *s, size_t len)
Duplicate a substring of a string.
@ AVMEDIA_TYPE_UNKNOWN
Usually treated as AVMEDIA_TYPE_DATA.
@ AV_PICTURE_TYPE_I
Intra.
@ AV_PICTURE_TYPE_P
Predicted.
size_t av_strlcat(char *dst, const char *src, size_t size)
Append the string src to the string dst, but to a total length of no more than size - 1 bytes,...
int av_strstart(const char *str, const char *pfx, const char **ptr)
Return non-zero if pfx is a prefix of str.
size_t av_strlcpy(char *dst, const char *src, size_t size)
Copy the string src to dst, but no more than size - 1 bytes, and null-terminate dst.
char * av_strnstr(const char *haystack, const char *needle, size_t hay_length)
Locate the first occurrence of the string needle in the string haystack where not more than hay_lengt...
char * av_strireplace(const char *str, const char *from, const char *to)
Locale-independent strings replace.
#define AV_NOPTS_VALUE
Undefined timestamp value.
#define AV_TIME_BASE
Internal time base represented as integer.
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
#define LIBAVUTIL_VERSION_INT
void ff_hls_write_playlist_version(AVIOContext *out, int version)
void ff_hls_write_playlist_header(AVIOContext *out, int version, int allowcache, int target_duration, int64_t sequence, uint32_t playlist_type, int iframe_mode)
int ff_hls_write_file_entry(AVIOContext *out, int insert_discont, int byterange_mode, double duration, int round_duration, int64_t size, int64_t pos, const char *baseurl, const char *filename, double *prog_date_time, int64_t video_keyframe_size, int64_t video_keyframe_pos, int iframe_mode)
void ff_hls_write_init_file(AVIOContext *out, const char *filename, int byterange_mode, int64_t size, int64_t pos)
void ff_hls_write_audio_rendition(AVIOContext *out, const char *agroup, const char *filename, const char *language, int name_id, int is_default)
void ff_hls_write_stream_info(AVStream *st, AVIOContext *out, int bandwidth, const char *filename, const char *agroup, const char *codecs, const char *ccgroup, const char *sgroup)
void ff_hls_write_end_list(AVIOContext *out)
int ff_http_do_new_request(URLContext *h, const char *uri)
Send a new HTTP request, reusing the old connection.
const AVCodecTag ff_mp4_obj_type[]
const AVCodecTag ff_codec_movaudio_tags[]
const AVCodecTag ff_codec_movvideo_tags[]
common internal API header
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
static int check_bitstream(AVFormatContext *s, AVStream *st, AVPacket *pkt)
#define AV_OPT_FLAG_ENCODING_PARAM
a generic parameter which can be set by the user for muxing or encoding
miscellaneous OS support macros and functions.
int av_parse_time(int64_t *timeval, const char *timestr, int duration)
Parse timestr and return in *time a corresponding number of microseconds.
Utilties for rational number calculation.
uint8_t color_description_present_flag
uint8_t chroma_sample_position
uint8_t transfer_characteristics
uint8_t chroma_subsampling_x
uint8_t chroma_subsampling_y
uint8_t matrix_coefficients
Describe the class of an AVClass context structure.
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
main external API structure.
This struct describes the properties of an encoded stream.
int extradata_size
Size of the extradata content in bytes.
enum AVFieldOrder field_order
Video only.
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
enum AVMediaType codec_type
General type of the encoded data.
int video_delay
Video only.
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
int avoid_negative_ts
Avoid negative timestamps during muxing.
AVIOContext * pb
I/O context.
int flags
Flags modifying the (de)muxer behaviour.
int strict_std_compliance
Allow non-standard and experimental extension.
AVIOInterruptCB interrupt_callback
Custom interrupt callbacks for the I/O layer.
char * url
input or output URL.
ff_const59 struct AVOutputFormat * oformat
The output container format.
void(* io_close)(struct AVFormatContext *s, AVIOContext *pb)
A callback for closing the streams opened with AVFormatContext.io_open().
AVStream ** streams
A list of all streams in the file.
int(* io_open)(struct AVFormatContext *s, AVIOContext **pb, const char *url, int flags, AVDictionary **options)
A callback for opening new IO streams.
This structure stores compressed data.
int flags
A combination of AV_PKT_FLAG values.
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
int64_t pos
byte position in stream, -1 if unknown
This structure supplies correlation between a packet timestamp and a wall clock production time.
int64_t wallclock
A UTC timestamp, in microseconds, since Unix epoch (e.g, av_gettime()).
Rational number (pair of numerator and denominator).
AVBSFContext * bsfc
bitstream filter to run on stream
AVCodecParameters * codecpar
Codec parameters associated with this stream.
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
AVRational avg_frame_rate
Average framerate.
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
AVStreamInternal * internal
An opaque field for libavformat internal usage.
AVRational min_frame_rate
enum AVMediaType media_type
int64_t max_frag_duration
AVRational max_frame_rate
const char * utc_timing_url
const char * single_file_name
int64_t max_segment_duration
AVRational min_playback_rate
const char * init_seg_name
int64_t presentation_time_offset
int nr_of_streams_flushed
int master_playlist_created
const char * media_seg_name
int nr_of_streams_to_flush
SegmentType segment_type_option
AVDictionary * format_options
AVRational max_playback_rate
const char * hls_master_name
uint64_t availability_start_time
AVCodecParserContext * parser
const char * init_seg_name
const char * media_seg_name
int first_segment_bit_rate
char producer_reference_time_str[100]
const char * extension_name
double availability_time_offset
int64_t total_pkt_duration
const char * single_file_name
AVCodecContext * parser_avctx
AVProducerReferenceTime producer_reference_time
int64_t av_gettime(void)
Get the current time in microseconds.
unbuffered private I/O API
static int write_trailer(AVFormatContext *s1)
int ff_isom_get_vpcc_features(AVFormatContext *s, AVCodecParameters *par, AVRational *frame_rate, VPCC *vpcc)
internal header for VPx codec configuration utilities.