44 #if CONFIG_HTTP_PROTOCOL 69 #define MPD_PROFILE_DASH 1 70 #define MPD_PROFILE_DVB 2 128 char full_path[1024];
129 char temp_path[1024];
132 char producer_reference_time_str[100];
149 #if FF_API_DASH_MIN_SEG_DURATION 150 int min_seg_duration;
162 char availability_start_time[100];
230 #if CONFIG_HTTP_PROTOCOL 251 #if CONFIG_HTTP_PROTOCOL 264 if (
formats[i].segment_type == segment_type)
275 default:
return NULL;
284 "Unable to open %s for writing: %s\n", url, errbuf);
305 int has_mp4_streams = 0;
335 if (!filename || !extension)
337 dot = strrchr(filename,
'.');
338 if (dot && !strcmp(dot + 1, extension))
394 if (!strcmp(str,
"mp4a") || !strcmp(str,
"mp4v")) {
403 if (tag ==
MKTAG(
'm',
'p',
'4',
'a')) {
410 }
else if (tag ==
MKTAG(
'm',
'p',
'4',
'v')) {
414 }
else if (!strcmp(str,
"avc1")) {
420 if (extradata[0] != 1) {
432 if (extradata_size >= 4)
434 extradata[1], extradata[2], extradata[3]);
436 }
else if (!strcmp(str,
"av01")) {
446 av_strlcatf(str, size,
".%01u.%01u%01u%01u.%02u.%02u.%02u.%01u",
497 const char *base_url,
int id) {
499 snprintf(playlist_name, string_size,
"%smedia_%d.m3u8", base_url,
id);
501 snprintf(playlist_name, string_size,
"media_%d.m3u8",
id);
505 int *start_index,
int *start_number) {
515 int representation_id,
int final,
516 char *prefetch_url) {
519 char temp_filename_hls[1024];
520 char filename_hls[1024];
522 int target_duration = 0;
525 int use_rename = proto && !strcmp(proto,
"file");
526 int i, start_index, start_number;
536 c->
dirname, representation_id);
538 snprintf(temp_filename_hls,
sizeof(temp_filename_hls), use_rename ?
"%s.tmp" :
"%s", filename_hls);
550 if (target_duration <= duration)
551 target_duration =
lrint(duration);
563 if (prog_date_time == 0) {
572 (
double) seg->
duration / timescale, 0,
575 &prog_date_time, 0, 0, 0);
617 for (i = 0; i < c->
nb_as; i++) {
653 int representation_id,
int final)
656 int i, start_index, start_number;
661 avio_printf(out,
"\t\t\t\t<SegmentTemplate timescale=\"%d\" ", timescale);
665 avio_printf(out,
"availabilityTimeOffset=\"%.3f\" ",
669 avio_printf(out,
"availabilityTimeComplete=\"false\" ");
682 if (i == start_index || seg->
time != cur_time) {
683 cur_time = seg->
time;
695 cur_time += (1 + repeat) * seg->
duration;
697 avio_printf(out,
"\t\t\t\t\t</SegmentTimeline>\n");
717 avio_printf(out,
"\t\t\t\t\t<SegmentURL media=\"%s\" />\n", seg->
file);
721 if (!c->
lhls ||
final) {
728 int outlen = strlen(str)*3/2 + 6;
733 for (; *
str; str++) {
734 if (pos + 6 > outlen) {
736 outlen = 2 * outlen + 6;
745 memcpy(&out[pos],
"&", 5);
747 }
else if (*str ==
'<') {
748 memcpy(&out[pos],
"<", 4);
750 }
else if (*str ==
'>') {
751 memcpy(&out[pos],
">", 4);
753 }
else if (*str ==
'\'') {
754 memcpy(&out[pos],
"'", 6);
756 }
else if (*str ==
'\"') {
757 memcpy(&out[pos],
""", 6);
771 int minutes = seconds / 60;
772 int hours = minutes / 60;
778 if (hours || minutes)
785 struct tm *ptm, tmbuf;
786 int64_t time_ms = time_us / 1000;
787 const time_t time_s = time_ms / 1000;
788 int millisec = time_ms - (time_s * 1000);
792 if (!strftime(buf, size,
"%Y-%m-%dT%H:%M:%S", ptm)) {
797 snprintf(buf + len, size - len,
".%03dZ", millisec);
809 avio_printf(out,
"\t\t<AdaptationSet id=\"%d\" contentType=\"%s\" startWithSAP=\"1\" segmentAlignment=\"true\" bitstreamSwitching=\"true\"",
827 avio_printf(out,
"\t\t\t<EssentialProperty id=\"%d\" schemeIdUri=\"http://dashif.org/guidelines/trickmode\" value=\"%d\"/>\n", as->
id, as->
trick_idx);
830 avio_printf(out,
"\t\t\t<Role schemeIdUri=\"urn:mpeg:dash:role:2011\" value=\"%s\"/>\n", role->
value);
836 char bandwidth_str[64] = {
'\0'};
838 if (os->
as_idx - 1 != as_index)
842 snprintf(bandwidth_str,
sizeof(bandwidth_str),
" bandwidth=\"%d\"",
846 avio_printf(out,
"\t\t\t<Representation id=\"%d\" mimeType=\"video/%s\" codecs=\"%s\"%s width=\"%d\" height=\"%d\"",
864 avio_printf(out,
"\t\t\t<Representation id=\"%d\" mimeType=\"audio/%s\" codecs=\"%s\"%s audioSamplingRate=\"%d\">\n",
866 avio_printf(out,
"\t\t\t\t<AudioChannelConfiguration schemeIdUri=\"urn:mpeg:dash:23003:3:audio_channel_configuration:2011\" value=\"%d\" />\n",
870 avio_printf(out,
"\t\t\t\t<ProducerReferenceTime id=\"%d\" inband=\"true\" type=\"%s\" wallClockTime=\"%s\" presentationTime=\"%"PRId64
"\">\n",
872 avio_printf(out,
"\t\t\t\t\t<UTCTiming schemeIdUri=\"urn:mpeg:dash:utc:http-xsdate:2014\" value=\"%s\"/>\n", c->
utc_timing_url);
873 avio_printf(out,
"\t\t\t\t</ProducerReferenceTime>\n");
902 memset(*as, 0,
sizeof(**as));
903 (*as)->media_type =
type;
904 (*as)->frag_type = -1;
905 (*as)->trick_idx = -1;
917 av_log(s,
AV_LOG_ERROR,
"Codec type of stream %d doesn't match AdaptationSet's media type\n", i);
924 av_log(s,
AV_LOG_ERROR,
"DVB-DASH profile allows a max of 16 Representations per Adaptation Set\n");
937 enum { new_set, parse_default, parsing_streams, parse_seg_duration, parse_frag_duration }
state;
967 }
else if (state == new_set &&
av_strstart(p,
"id=", &p)) {
968 char id_str[10], *end_str;
971 snprintf(id_str,
sizeof(id_str),
"%.*s", n, p);
973 i = strtol(id_str, &end_str, 10);
974 if (id_str == end_str || i < 0 || i > c->
nb_as) {
975 av_log(s,
AV_LOG_ERROR,
"\"%s\" is not a valid value for an AdaptationSet id\n", id_str);
986 state = parse_default;
987 }
else if (state != new_set &&
av_strstart(p,
"seg_duration=", &p)) {
988 state = parse_seg_duration;
989 }
else if (state != new_set &&
av_strstart(p,
"frag_duration=", &p)) {
990 state = parse_frag_duration;
991 }
else if (state == parse_seg_duration || state == parse_frag_duration) {
996 snprintf(str,
sizeof(str),
"%.*s", n, p);
1007 if (state == parse_seg_duration)
1011 state = parse_default;
1012 }
else if (state != new_set &&
av_strstart(p,
"frag_type=", &p)) {
1015 n = strcspn(p,
",");
1016 snprintf(type_str,
sizeof(type_str),
"%.*s", n, p);
1021 if (!strcmp(type_str,
"duration"))
1023 else if (!strcmp(type_str,
"pframes"))
1025 else if (!strcmp(type_str,
"every_frame"))
1027 else if (!strcmp(type_str,
"none"))
1030 av_log(s,
AV_LOG_ERROR,
"Unable to parse option value \"%s\" as fragment type\n", type_str);
1033 state = parse_default;
1034 }
else if (state != new_set &&
av_strstart(p,
"descriptor=", &p)) {
1035 n = strcspn(p,
">") + 1;
1036 if (n < strlen(p)) {
1039 av_log(s,
AV_LOG_ERROR,
"Parse error, descriptor string should be a self-closing xml tag\n");
1045 state = parse_default;
1046 }
else if ((state != new_set) &&
av_strstart(p,
"trick_id=", &p)) {
1047 char trick_id_str[10], *end_str;
1049 n = strcspn(p,
",");
1050 snprintf(trick_id_str,
sizeof(trick_id_str),
"%.*s", n, p);
1053 as->
trick_idx = strtol(trick_id_str, &end_str, 10);
1054 if (trick_id_str == end_str || as->
trick_idx < 0)
1059 state = parse_default;
1060 }
else if ((state != new_set) &&
av_strstart(p,
"streams=", &p)) {
1061 state = parsing_streams;
1062 }
else if (state == parsing_streams) {
1064 char idx_str[8], *end_str;
1066 n = strcspn(p,
" ,");
1067 snprintf(idx_str,
sizeof(idx_str),
"%.*s", n, p);
1085 i = strtol(idx_str, &end_str, 10);
1086 if (idx_str == end_str || i < 0 || i >= s->
nb_streams) {
1120 for (i = 0; i < c->
nb_as; i++) {
1124 for (n = 0; n < c->
nb_as; n++) {
1128 if (n >= c->
nb_as) {
1141 char temp_filename[1024];
1144 int use_rename = proto && !strcmp(proto,
"file");
1145 static unsigned int warned_non_file = 0;
1149 if (!use_rename && !warned_non_file++)
1150 av_log(s,
AV_LOG_ERROR,
"Cannot use rename on non file protocol, this may lead to races and temporary partial files\n");
1152 snprintf(temp_filename,
sizeof(temp_filename), use_rename ?
"%s.tmp" :
"%s", s->
url);
1160 avio_printf(out,
"<?xml version=\"1.0\" encoding=\"utf-8\"?>\n");
1161 avio_printf(out,
"<MPD xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"\n" 1162 "\txmlns=\"urn:mpeg:dash:schema:mpd:2011\"\n" 1163 "\txmlns:xlink=\"http://www.w3.org/1999/xlink\"\n" 1164 "\txsi:schemaLocation=\"urn:mpeg:DASH:schema:MPD:2011 http://standards.iso.org/ittf/PubliclyAvailableStandards/MPEG-DASH_schema_files/DASH-MPD.xsd\"\n" 1169 avio_printf(out,
"%s",
"urn:dvb:dash:profile:dvb-dash:2014\"\n");
1171 final ?
"static" :
"dynamic");
1173 avio_printf(out,
"\tmediaPresentationDuration=\"");
1180 update_period = 500;
1181 avio_printf(out,
"\tminimumUpdatePeriod=\"PT%"PRId64
"S\"\n", update_period);
1188 avio_printf(out,
"\tpublishTime=\"%s\"\n", now_str);
1204 avio_printf(out,
"\t\t<Title>%s</Title>\n", escaped);
1209 avio_printf(out,
"\t<ServiceDescription id=\"0\">\n");
1218 avio_printf(out,
"\t\t<PlaybackRate min=\"%.2f\" max=\"%.2f\"/>\n",
1230 avio_printf(out,
"\t<Period id=\"0\" start=\"PT0.0S\">\n");
1233 for (i = 0; i < c->
nb_as; i++) {
1240 avio_printf(out,
"\t<UTCTiming schemeIdUri=\"urn:mpeg:dash:utc:http-xsdate:2014\" value=\"%s\"/>\n", c->
utc_timing_url);
1252 char filename_hls[1024];
1253 const char *audio_group =
"A1";
1254 char audio_codec_str[128] =
"\0";
1256 int max_audio_bitrate = 0;
1264 snprintf(filename_hls,
sizeof(filename_hls),
"%smaster.m3u8", c->
dirname);
1266 snprintf(filename_hls,
sizeof(filename_hls),
"master.m3u8");
1268 snprintf(temp_filename,
sizeof(temp_filename), use_rename ?
"%s.tmp" :
"%s", filename_hls);
1280 char playlist_file[64];
1289 playlist_file,
NULL, i, is_default);
1293 if (strlen(audio_codec_str))
1294 av_strlcat(audio_codec_str,
",",
sizeof(audio_codec_str));
1301 char playlist_file[64];
1302 char codec_str[128];
1305 char *agroup =
NULL;
1306 char *codec_str_ptr =
NULL;
1313 if (max_audio_bitrate) {
1314 agroup = (
char *)audio_group;
1315 stream_bitrate += max_audio_bitrate;
1316 av_strlcat(codec_str,
",",
sizeof(codec_str));
1317 av_strlcat(codec_str, audio_codec_str,
sizeof(codec_str));
1320 codec_str_ptr = codec_str;
1324 playlist_file, agroup,
1329 if ((ret =
ff_rename(temp_filename, filename_hls, s)) < 0)
1350 char basename[1024];
1362 #if FF_API_DASH_MIN_SEG_DURATION 1363 if (c->min_seg_duration != 5000000) {
1364 av_log(s,
AV_LOG_WARNING,
"The min_seg_duration option is deprecated and will be removed. Please use the -seg_duration\n");
1370 "LHLS is experimental, Please set -strict experimental in order to enable it.\n");
1390 av_log(s,
AV_LOG_WARNING,
"Target latency option will be ignored as streaming is not enabled\n");
1395 av_log(s,
AV_LOG_WARNING,
"Global SIDX option will be ignored as single_file is not enabled\n");
1404 av_log(s,
AV_LOG_VERBOSE,
"Changing frag_type from none to every_frame as streaming is enabled\n");
1415 av_log(s,
AV_LOG_WARNING,
"Producer Reference Time element option will be ignored as utc_timing_url is not set\n");
1420 av_log(s,
AV_LOG_WARNING,
"Producer Reference Time element option will be ignored as streaming is not enabled\n");
1425 av_log(s,
AV_LOG_WARNING,
"Low Latency mode enabled without Producer Reference Time element option! Resulting manifest may not be complaint\n");
1429 av_log(s,
AV_LOG_WARNING,
"Target latency option will be ignored as Producer Reference Time element will not be written\n");
1434 av_log(s,
AV_LOG_WARNING,
"Minimum playback rate value is higer than the Maximum. Both will be ignored\n");
1439 ptr = strrchr(c->
dirname,
'/');
1441 av_strlcpy(basename, &ptr[1],
sizeof(basename));
1448 ptr = strrchr(basename,
'.');
1468 char filename[1024];
1474 av_log(s, level,
"No bit rate set for stream %d\n",
i);
1504 "One or many segment file names doesn't end with .webm. " 1505 "Override -init_seg_name and/or -media_seg_name and/or " 1506 "-single_file_name to end with the extension .webm\n");
1510 av_log(s,
AV_LOG_WARNING,
"One or more streams in WebM output format. Streaming option will be ignored\n");
1600 av_log(s,
AV_LOG_WARNING,
"frag_type set to P-Frame reordering, but no parser found for stream %d\n",
i);
1650 if (avg_frame_rate.
num > 0) {
1747 if (seg->
time < 0) {
1785 if (
avio_seek(pb, pos, SEEK_SET) != pos) {
1795 *index_length =
AV_RB32(&buf[0]);
1803 int ret, extradata_size;
1809 if (!extradata_size)
1816 memcpy(par->
extradata, extradata, extradata_size);
1827 if (http_base_proto) {
1872 for (
int i = 0;
i < remove_count; ++
i) {
1889 int use_rename = proto && !strcmp(proto,
"file");
1891 int cur_flush_segment_index = 0, next_exp_index = -1;
1919 if (stream >= 0 && i != stream) {
1976 if (remove_count > 0)
1988 int j, start_index, start_number;
2049 int64_t seg_end_duration, elapsed_duration;
2130 &data, &size, pkt->
data, pkt->
size,
2151 "Segment durations differ too much, enable use_timeline " 2152 "and use_template, or keep a stricter keyframe interval\n");
2222 int use_rename = proto && !strcmp(proto,
"file");
2232 use_rename ?
"%s.tmp" :
"%s", os->
full_path);
2286 char filename[1024];
2294 char filename[1024];
2324 #define OFFSET(x) offsetof(DASHContext, x) 2325 #define E AV_OPT_FLAG_ENCODING_PARAM 2327 {
"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 },
2328 {
"window_size",
"number of segments kept in the manifest",
OFFSET(window_size),
AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX,
E },
2329 {
"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 },
2330 #if FF_API_DASH_MIN_SEG_DURATION 2331 {
"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 },
2333 {
"seg_duration",
"segment duration (in seconds, fractional value can be set)",
OFFSET(seg_duration),
AV_OPT_TYPE_DURATION, { .i64 = 5000000 }, 0, INT_MAX, E },
2334 {
"frag_duration",
"fragment duration (in seconds, fractional value can be set)",
OFFSET(frag_duration),
AV_OPT_TYPE_DURATION, { .i64 = 0 }, 0, INT_MAX, E },
2339 {
"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"},
2340 {
"remove_at_exit",
"remove all segments when finished",
OFFSET(remove_at_exit),
AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, E },
2341 {
"use_template",
"Use SegmentTemplate instead of SegmentList",
OFFSET(use_template),
AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1, E },
2342 {
"use_timeline",
"Use SegmentTimeline in SegmentTemplate",
OFFSET(use_timeline),
AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1, E },
2343 {
"single_file",
"Store all segments in one file, accessed using byte ranges",
OFFSET(single_file),
AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, E },
2344 {
"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 },
2345 {
"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 },
2346 {
"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 },
2347 {
"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 },
2350 {
"http_persistent",
"Use persistent HTTP connections",
OFFSET(http_persistent),
AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, E },
2351 {
"hls_playlist",
"Generate HLS playlist files(master.m3u8, media_%d.m3u8)",
OFFSET(hls_playlist),
AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, E },
2352 {
"streaming",
"Enable/Disable streaming mode of output. Each frame will be moof fragment",
OFFSET(streaming),
AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, E },
2353 {
"timeout",
"set timeout for socket I/O operations",
OFFSET(timeout),
AV_OPT_TYPE_DURATION, { .i64 = -1 }, -1, INT_MAX, .flags = E },
2354 {
"index_correction",
"Enable/Disable segment index correction logic",
OFFSET(index_correction),
AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, E },
2355 {
"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},
2356 {
"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 },
2361 {
"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 },
2362 {
"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 },
2363 {
"ldash",
"Enable Low-latency dash. Constrains the value of a few elements",
OFFSET(ldash),
AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, E },
2364 {
"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},
2365 {
"write_prft",
"Write producer reference time element",
OFFSET(write_prft),
AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, E},
2370 {
"target_latency",
"Set desired target latency for Low-latency dash",
OFFSET(target_latency),
AV_OPT_TYPE_DURATION, { .i64 = 0 }, 0, INT_MAX, E },
2371 {
"min_playback_rate",
"Set desired minimum playback rate",
OFFSET(min_playback_rate),
AV_OPT_TYPE_RATIONAL, { .dbl = 1.0 }, 0.5, 1.5, E },
2372 {
"max_playback_rate",
"Set desired maximum playback rate",
OFFSET(max_playback_rate),
AV_OPT_TYPE_RATIONAL, { .dbl = 1.0 }, 0.5, 1.5, E },
2386 .extensions =
"mpd",
2397 .priv_class = &dash_class,
#define FF_COMPLIANCE_EXPERIMENTAL
Allow nonstandardized experimental things.
AVRational min_playback_rate
static void write_packet(OutputFile *of, AVPacket *pkt, OutputStream *ost, int unqueue)
int(* io_open)(struct AVFormatContext *s, AVIOContext **pb, const char *url, int flags, AVDictionary **options)
A callback for opening new IO streams.
enum AVFieldOrder field_order
Video only.
AVBSFContext * bsfc
bitstream filter to run on stream
Producer Reference Time data corresponding to the AVProducerReferenceTime struct, usually exported by...
static int dict_copy_entry(AVDictionary **dst, const AVDictionary *src, const char *key)
void * av_realloc(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory.
static int init_segment_types(AVFormatContext *s)
void av_bprintf(AVBPrint *buf, const char *fmt,...)
AVRational av_div_q(AVRational b, AVRational c)
Divide one rational by another.
AVIOInterruptCB interrupt_callback
Custom interrupt callbacks for the I/O layer.
static void set_http_options(AVDictionary **options, DASHContext *c)
int avio_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer)
Return the written size and a pointer to the buffer.
static int parse_adaptation_sets(AVFormatContext *s)
static const AVOption options[]
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
Write a packet to an output media file.
const char * media_seg_name
#define AV_LOG_WARNING
Something somehow does not look correct.
#define LIBAVUTIL_VERSION_INT
int64_t pos
byte position in stream, -1 if unknown
const char * single_file_name
#define AV_DICT_DONT_OVERWRITE
Don't overwrite existing entries.
int av_parse_time(int64_t *timeval, const char *timestr, int duration)
Parse timestr and return in *time a corresponding number of microseconds.
static av_cold int init(AVCodecContext *avctx)
AVCodecParserContext * parser
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
static void dashenc_io_close(AVFormatContext *s, AVIOContext **pb, char *filename)
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
const char * av_default_item_name(void *ptr)
Return the context name.
#define AVIO_FLAG_READ
read-only
#define AVIO_FLAG_WRITE
write-only
uint8_t transfer_characteristics
Convenience header that includes libavutil's core.
int av_dict_copy(AVDictionary **dst, const AVDictionary *src, int flags)
Copy entries from one AVDictionary struct into another.
static int update_stream_extradata(AVFormatContext *s, OutputStream *os, AVPacket *pkt, AVRational *frame_rate)
int nr_of_streams_to_flush
static void set_codec_str(AVFormatContext *s, AVCodecParameters *par, AVRational *frame_rate, char *str, int size)
int avio_open_dyn_buf(AVIOContext **s)
Open a write only memory stream.
int strict_std_compliance
Allow non-standard and experimental extension.
static int dash_init(AVFormatContext *s)
uint8_t chroma_sample_position
This struct describes the properties of an encoded stream.
int av_bprint_finalize(AVBPrint *buf, char **ret_str)
Finalize a print buffer.
int ffurl_shutdown(URLContext *h, int flags)
Signal the URLContext that we are done reading or writing the stream.
static struct codec_string codecs[]
void ff_hls_write_audio_rendition(AVIOContext *out, const char *agroup, const char *filename, const char *language, int name_id, int is_default)
uint8_t chroma_subsampling_x
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
#define av_assert0(cond)
assert() equivalent, that is always enabled.
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 int64_t start_time
AVRational min_frame_rate
miscellaneous OS support macros and functions.
const AVCodecTag ff_codec_movvideo_tags[]
static int add_adaptation_set(AVFormatContext *s, AdaptationSet **as, enum AVMediaType type)
static av_cold int end(AVCodecContext *avctx)
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
static void get_start_index_number(OutputStream *os, DASHContext *c, int *start_index, int *start_number)
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
AVStream ** streams
A list of all streams in the file.
int avcodec_parameters_to_context(AVCodecContext *codec, const AVCodecParameters *par)
Fill the codec context based on the values from the supplied codec parameters.
AVFormatContext * avformat_alloc_context(void)
Allocate an AVFormatContext.
int64_t wallclock
A UTC timestamp, in microseconds, since Unix epoch (e.g, av_gettime()).
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
int64_t presentation_time_offset
int flags
Flags modifying the (de)muxer behaviour.
static double av_q2d(AVRational a)
Convert an AVRational to a double.
static void dashenc_delete_media_segments(AVFormatContext *s, OutputStream *os, int remove_count)
#define AV_LOG_VERBOSE
Detailed information.
static int dashenc_delete_segment_file(AVFormatContext *s, const char *file)
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)
Reduce a fraction.
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
static av_always_inline void ffio_wfourcc(AVIOContext *pb, const uint8_t *s)
uint64_t availability_start_time
AVDictionary * format_options
#define AV_OPT_FLAG_ENCODING_PARAM
a generic parameter which can be set by the user for muxing or encoding
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
static void get_hls_playlist_name(char *playlist_name, int string_size, const char *base_url, int id)
static void write_time(AVIOContext *out, int64_t time)
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
static int write_manifest(AVFormatContext *s, int final)
#define i(width, name, range_min, range_max)
AVCodecID
Identify the syntax and semantics of the bitstream.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
AVDictionary * metadata
Metadata that applies to the whole file.
#define AV_BPRINT_SIZE_UNLIMITED
const char * init_seg_name
uint8_t * av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type, int *size)
Get side information from packet.
static int dash_write_packet(AVFormatContext *s, AVPacket *pkt)
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
int avio_close(AVIOContext *s)
Close the resource accessed by the AVIOContext s and free it.
void av_bprint_init(AVBPrint *buf, unsigned size_init, unsigned size_max)
char * url
input or output URL.
int video_delay
Video only.
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values. ...
enum AVMediaType codec_type
General type of the encoded data.
simple assert() macros that are a bit more flexible than ISO C assert().
char * av_strireplace(const char *str, const char *from, const char *to)
Locale-independent strings replace.
static int dash_check_bitstream(struct AVFormatContext *s, const AVPacket *avpkt)
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
static int flush_init_segment(AVFormatContext *s, OutputStream *os)
static SegmentType select_segment_type(SegmentType segment_type, enum AVCodecID codec_id)
double availability_time_offset
AVRational avg_frame_rate
Average framerate.
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.
const AVCodecTag ff_mp4_obj_type[]
static void dashenc_delete_file(AVFormatContext *s, char *filename)
int flags
A combination of AV_PKT_FLAG values.
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.
int extradata_size
Size of the extradata content in bytes.
AVOutputFormat ff_dash_muxer
int av_reallocp_array(void *ptr, size_t nmemb, size_t size)
Allocate, reallocate, or free an array through a pointer to a pointer.
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
int ff_rename(const char *url_src, const char *url_dst, void *logctx)
Wrap avpriv_io_move and log if error happens.
AVCodecContext * parser_avctx
const char * media_seg_name
AVProducerReferenceTime producer_reference_time
#define AV_TIME_BASE
Internal time base represented as integer.
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.
AVCodecContext * avcodec_alloc_context3(const AVCodec *codec)
Allocate an AVCodecContext and set its fields to default values.
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.
static int write_trailer(AVFormatContext *s1)
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 master_playlist_created
void av_parser_close(AVCodecParserContext *s)
enum AVMediaType media_type
int avoid_negative_ts
Avoid negative timestamps during muxing.
uint8_t color_description_present_flag
#define AV_DICT_APPEND
If the entry already exists, append to it.
static int av_bprint_is_complete(const AVBPrint *buf)
Test if the print buffer is complete (not truncated).
static void set_vp9_codec_str(AVFormatContext *s, AVCodecParameters *par, AVRational *frame_rate, char *str, int size)
Usually treated as AVMEDIA_TYPE_DATA.
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.
#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...
ff_const59 struct AVOutputFormat * oformat
The output container format.
void ffio_free_dyn_buf(AVIOContext **s)
Free a dynamic buffer.
int64_t av_gettime(void)
Get the current time in microseconds.
static int flush_dynbuf(DASHContext *c, OutputStream *os, int *range_length)
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)
void ff_hls_write_playlist_version(AVIOContext *out, int version)
AVRational max_playback_rate
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)
char * av_strdup(const char *s)
Duplicate a string.
AVStreamInternal * internal
An opaque field for libavformat internal usage.
const AVCodecTag ff_codec_movaudio_tags[]
void avcodec_free_context(AVCodecContext **avctx)
Free the codec context and everything associated with it and write NULL to the provided pointer...
int64_t max_segment_duration
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
AVIOContext * pb
I/O context.
main external API structure.
AVRational max_frame_rate
void(* io_close)(struct AVFormatContext *s, AVIOContext *pb)
A callback for closing the streams opened with AVFormatContext.io_open().
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Describe the class of an AVClass context structure.
const char * init_seg_name
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...
Rational number (pair of numerator and denominator).
static int write_adaptation_set(AVFormatContext *s, AVIOContext *out, int as_index, int final)
void avio_flush(AVIOContext *s)
Force flushing of buffered data.
size_t av_strlcatf(char *dst, size_t size, const char *fmt,...)
static const char * get_format_str(SegmentType segment_type)
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.
#define FF_COMPLIANCE_STRICT
Strictly conform to all the things in the spec no matter what consequences.
void avformat_free_context(AVFormatContext *s)
Free an AVFormatContext and all its streams.
static int adaptation_set_add_stream(AVFormatContext *s, int as_idx, int i)
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)
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...
static void find_index_range(AVFormatContext *s, const char *full_path, int64_t pos, int *index_length)
const char * avio_find_protocol_name(const char *url)
Return the name of the protocol that will handle the passed URL.
static const char * get_extension_str(SegmentType type, int single_file)
static int dashenc_io_open(AVFormatContext *s, AVIOContext **pb, char *filename, AVDictionary **options)
URLContext * ffio_geturlcontext(AVIOContext *s)
Return the URLContext associated with the AVIOContext.
#define flags(name, subs,...)
int ff_http_do_new_request(URLContext *h, const char *uri)
Send a new HTTP request, reusing the old connection.
SegmentType segment_type_option
int av_strerror(int errnum, char *errbuf, size_t errbuf_size)
Put a description of the AVERROR code errnum in errbuf.
int sample_rate
Audio only.
static int av_cmp_q(AVRational a, AVRational b)
Compare two rationals.
int av_strstart(const char *str, const char *pfx, const char **ptr)
Return non-zero if pfx is a prefix of str.
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...
int ff_isom_get_vpcc_features(AVFormatContext *s, AVCodecParameters *par, AVRational *frame_rate, VPCC *vpcc)
Utilties for rational number calculation.
const char * single_file_name
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...
uint8_t chroma_subsampling_y
int ff_av1_parse_seq_header(AV1SequenceParameters *seq, const uint8_t *buf, int size)
Parses a Sequence Header from the the provided buffer.
static int handle_io_open_error(AVFormatContext *s, int err, char *url)
#define PARSER_FLAG_COMPLETE_FRAMES
int64_t max_frag_duration
static void write_styp(AVIOContext *pb)
static int dash_write_header(AVFormatContext *s)
int nr_of_streams_flushed
char producer_reference_time_str[100]
This structure supplies correlation between a packet timestamp and a wall clock production time...
static int check_file_extension(const char *filename, const char *extension)
static int dash_parse_prft(DASHContext *c, AVPacket *pkt)
void * priv_data
Format private data.
static void format_date(char *buf, int size, int64_t time_us)
static int check_bitstream(AVFormatContext *s, AVStream *st, AVPacket *pkt)
const char * utc_timing_url
static int dash_write_trailer(AVFormatContext *s)
static void write_header(FFV1Context *f)
static void dash_free(AVFormatContext *s)
static void write_hls_media_playlist(OutputStream *os, AVFormatContext *s, int representation_id, int final, char *prefetch_url)
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
int64_t total_pkt_duration
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
int avpriv_io_delete(const char *url)
Delete a resource.
void ff_hls_write_end_list(AVIOContext *out)
int av_write_trailer(AVFormatContext *s)
Write the stream trailer to an output media file and free the file private data.
void avio_wb32(AVIOContext *s, unsigned int val)
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)
static void output_segment_list(OutputStream *os, AVIOContext *out, AVFormatContext *s, int representation_id, int final)
const char * extension_name
internal header for VPx codec configuration utilities.
uint8_t matrix_coefficients
unbuffered private I/O API
#define AVERROR_MUXER_NOT_FOUND
Muxer not found.
AVCodecParameters * codecpar
Codec parameters associated with this stream.
static char * xmlescape(const char *str)
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
static int dash_flush(AVFormatContext *s, int final, int stream)
uint8_t * av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type, int size)
Allocate new information of a packet.
void ff_hls_write_init_file(AVIOContext *out, const char *filename, int byterange_mode, int64_t size, int64_t pos)
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
#define MKTAG(a, b, c, d)
unsigned int av_codec_get_tag(const struct AVCodecTag *const *tags, enum AVCodecID id)
Get the codec tag for the given codec id id.
int avcodec_parameters_copy(AVCodecParameters *dst, const AVCodecParameters *src)
Copy the contents of src to dst.
This structure stores compressed data.
char * av_strndup(const char *s, size_t len)
Duplicate a substring of a string.
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
int ff_isom_write_avcc(AVIOContext *pb, const uint8_t *data, int len)
static const AVClass dash_class
#define AV_NOPTS_VALUE
Undefined timestamp value.
int avio_printf(AVIOContext *s, const char *fmt,...) av_printf_format(2
Writes a formatted string to the context.
int avio_get_dyn_buf(AVIOContext *s, uint8_t **pbuffer)
Return the written size and a pointer to the buffer.