33 #include <openssl/rand.h> 50 #if CONFIG_HTTP_PROTOCOL 71 #define LINE_BUFFER_SIZE MAX_URL_SIZE 72 #define HLS_MICROSECOND_UNIT 1000000 73 #define BUFSIZE (16 * 1024) 74 #define POSTFIX_PATTERN "_%d" 176 char codec_attr[128];
267 struct tm *tm, tmpbuf;
294 #if CONFIG_HTTP_PROTOCOL 316 #if CONFIG_HTTP_PROTOCOL 334 }
else if (http_base_proto) {
359 if (data && (data[0] | data[1] | data[2]) == 0 && data[3] == 1 && (data[4] & 0x1F) == 7) {
361 "avc1.%02x%02x%02x", data[5], data[6], data[7]);
378 if (!(data[0] | data[1] | data[2]) && data[3] == 1 && ((data[4] & 0x7E) == 0x42)) {
389 if (rbsp_size < 13) {
396 profile = rbsp_buf[1] & 0x1f;
398 level = rbsp_buf[12];
411 snprintf(attr,
sizeof(attr),
"mp4a.40.33");
413 snprintf(attr,
sizeof(attr),
"mp4a.40.34");
416 snprintf(attr,
sizeof(attr),
"mp4a.40.2");
418 snprintf(attr,
sizeof(attr),
"ac-3");
420 snprintf(attr,
sizeof(attr),
"ec-3");
428 "%s%s", codec_strlen ?
"," :
"", attr);
454 if (c ==
'%' && *(p+1) ==
'%')
456 else if (c ==
'%' && *(p+1) == placeholder) {
464 if (addchar_count > 0) {
482 int nd, addchar_count;
494 if (c ==
'%' && *(p+1) ==
'%')
496 else if (c ==
'%' && (
av_isdigit(*(p+1)) || *(p+1) == placeholder)) {
500 nd = nd * 10 + *(p + addchar_count) -
'0';
504 if (*(p + addchar_count) == placeholder) {
505 av_bprintf(&buf,
"%0*"PRId64, (number < 0) ? nd : nd++, number);
506 p += (addchar_count + 1);
564 #define SEPARATOR '\\' 566 #define SEPARATOR '/' 570 const char *path,
const char *proto)
582 }
else if (unlink(path) < 0) {
584 path, strerror(errno));
594 float playlist_duration = 0.0f;
598 const char *dirname =
NULL;
599 char *dirname_r =
NULL;
600 char *dirname_repl =
NULL;
601 const char *vtt_dirname =
NULL;
602 char *vtt_dirname_r =
NULL;
603 const char *proto =
NULL;
609 playlist_duration += segment->
duration;
610 segment = segment->
next;
616 playlist_duration -= segment->
duration;
617 previous_segment = segment;
618 segment = previous_segment->
next;
620 if (playlist_duration <= -previous_segment->
duration) {
650 dirname = dirname_repl;
687 previous_segment = segment;
688 segment = previous_segment->
next;
703 gcry_randomize(buf, len, GCRY_VERY_STRONG_RANDOM);
706 if (RAND_bytes(buf, len))
723 len = strlen(key_basename_source) + 4 + 1;
746 memcpy(iv, hls->
iv,
sizeof(iv));
766 if ((ret =
randomize(key,
sizeof(key))) < 0) {
771 memcpy(key, hls->
key,
sizeof(key));
836 if (ret !=
sizeof(key)) {
854 int remaining_options;
912 av_log(s,
AV_LOG_WARNING,
"http persistent mode is currently unsupported for fragment mp4 in the HLS muxer.\n");
915 av_log(s,
AV_LOG_WARNING,
"Multi-file byterange mode is currently unsupported in the HLS muxer.\n");
925 if (byterange_mode) {
944 snprintf(period,
sizeof(period),
"%d", (INT_MAX / 2) - 1);
953 if (remaining_options) {
966 segment = segment->
next;
986 "Invalid second level segment filename template '%s', " 987 "you can try to remove second_level_segment_size flag\n",
999 "Invalid second level segment filename template '%s', " 1000 "you can try to remove second_level_segment_time flag\n",
1017 "second_level_segment_duration hls_flag requires strftime to be true\n");
1022 "second_level_segment_size hls_flag requires strfime to be true\n");
1027 "second_level_segment_index hls_flag requires strftime to be true\n");
1037 int segment_renaming_ok = proto && !strcmp(proto,
"file");
1042 "second_level_segment_duration hls_flag works only with file protocol segment names\n");
1047 "second_level_segment_size hls_flag works only with file protocol segment names\n");
1072 "you can try to remove second_level_segment_index flag\n",
1083 char *filename =
NULL;
1086 "you can try to remove second_level_segment_size flag\n",
1094 char *filename =
NULL;
1097 "you can try to remove second_level_segment_time flag\n",
1134 && !byterange_mode) {
1206 int ret = 0, is_segment = 0;
1207 int64_t new_start_pos;
1219 if (strcmp(line,
"#EXTM3U")) {
1227 if (
av_strstart(line,
"#EXT-X-MEDIA-SEQUENCE:", &ptr)) {
1228 int64_t tmp_sequence = strtoll(ptr,
NULL, 10);
1229 if (tmp_sequence < vs->sequence)
1231 "Found playlist sequence number was smaller """ 1232 "than specified start sequence number: %"PRId64
" < %"PRId64
", " 1235 av_log(hls,
AV_LOG_DEBUG,
"Found playlist sequence number: %"PRId64
"\n", tmp_sequence);
1238 }
else if (
av_strstart(line,
"#EXT-X-DISCONTINUITY", &ptr)) {
1247 ptr += strlen(
"URI=\"");
1258 ptr += strlen(
"IV=0x");
1266 }
else if (
av_strstart(line,
"#EXT-X-PROGRAM-DATE-TIME:", &ptr)) {
1267 struct tm program_date_time;
1270 if (sscanf(ptr,
"%d-%d-%dT%d:%d:%d.%lf", &y, &M, &d, &h, &m, &s, &ms) != 7) {
1275 program_date_time.tm_year = y - 1900;
1276 program_date_time.tm_mon = M - 1;
1277 program_date_time.tm_mday = d;
1278 program_date_time.tm_hour =
h;
1279 program_date_time.tm_min = m;
1280 program_date_time.tm_sec =
s;
1281 program_date_time.tm_isdst = -1;
1283 discont_program_date_time = mktime(&program_date_time);
1284 discont_program_date_time += (double)(ms / 1000);
1287 }
else if (line[0]) {
1300 discont_program_date_time += vs->
duration;
1326 size_t len = strlen(oc->
url);
1330 if (!final_filename)
1332 final_filename[len-4] =
'\0';
1334 oc->
url[len-4] =
'\0';
1341 const char *p = strrchr(master_url,
'/');
1342 size_t base_len = 0;
1344 if (!p) p = strrchr(master_url,
'\\');
1347 base_len = p - master_url;
1356 return media_url + base_len + 1;
1384 const char *m3u8_rel_name =
NULL;
1385 const char *vtt_m3u8_rel_name =
NULL;
1386 const char *ccgroup;
1387 const char *sgroup =
NULL;
1390 int is_file_proto = proto && !strcmp(proto,
"file");
1437 if (!m3u8_rel_name) {
1450 if (!m3u8_rel_name) {
1464 if (!vid_st && !aud_st) {
1493 bandwidth += bandwidth / 10;
1510 if (vid_st && vs->
sgroup) {
1513 if (!vtt_m3u8_rel_name) {
1545 int target_duration = 0;
1551 int is_file_proto = proto && !strcmp(proto,
"file");
1553 static unsigned warned_non_file;
1562 if (byterange_mode) {
1580 av_log(s,
AV_LOG_ERROR,
"Cannot use rename on non file protocol, this may lead to races and temporary partial files\n");
1583 snprintf(temp_filename,
sizeof(temp_filename), use_temp_file ?
"%s.tmp" :
"%s", vs->
m3u8_name);
1591 if (target_duration <= en->duration)
1639 snprintf(temp_vtt_filename,
sizeof(temp_vtt_filename), use_temp_file ?
"%s.tmp" :
"%s", vs->
vtt_m3u8_name);
1668 if (use_temp_file) {
1686 const char *proto =
NULL;
1687 int use_temp_file = 0;
1703 char *filename =
NULL;
1718 char *expanded =
NULL;
1738 if (
ff_mkdir_p(dir) == -1 && errno != EEXIST) {
1739 av_log(oc,
AV_LOG_ERROR,
"Could not create directory %s with use_localtime_mkdir\n", dir);
1746 char *filename =
NULL;
1760 char *filename =
NULL;
1778 if (use_temp_file) {
1793 " ignoring -hls_enc\n");
1816 memcpy(vs->
iv_string, iv_string,
sizeof(iv_string));
1880 time_t t = time(
NULL);
1881 struct tm *p, tmbuf;
1888 return (HAVE_LIBC_MSVCRT || !strftime(b,
sizeof(b),
"%s", p) || !strcmp(b,
"%s")) ?
"-%Y%m%d%H%M%S.m4s" :
"-%s.m4s";
1890 return (HAVE_LIBC_MSVCRT || !strftime(b,
sizeof(b),
"%s", p) || !strcmp(b,
"%s")) ?
"-%Y%m%d%H%M%S.ts" :
"-%s.ts";
1896 char extension[10] = {
'\0'};
1898 p = strrchr(name,
'.');
1906 if (strlen(extension))
1914 const char *
filename, *subdir_name;
1915 char *fn_dup =
NULL;
1929 "either in the filename or in the sub-directory name of file %s\n", fn);
1936 "in the sub-directory name of file %s, but only in one of them\n", fn);
1948 const char *proto, *dir;
1949 char *orig_buf_dup =
NULL, *mod_buf_dup =
NULL;
1977 if (
av_stristr(dir,
"%v") && proto && !strcmp(proto,
"file")) {
1980 if (
ff_mkdir_p(dir) == -1 && errno != EEXIST) {
1996 unsigned int stream_index, cnt;
1997 if (stream_id < 0 || stream_id > s->
nb_streams - 1)
2000 for (stream_index = 0; stream_index < s->
nb_streams; stream_index++) {
2003 if (cnt == stream_id)
2004 return stream_index;
2014 int stream_index,
i, j;
2017 char *p, *q, *saveptr1, *saveptr2, *varstr, *keyval;
2040 while (
av_strtok(q,
" \t", &saveptr1)) {
2053 while (varstr =
av_strtok(p,
" \t", &saveptr1)) {
2056 if (nb_varstreams < hls->nb_varstreams) {
2079 while (keyval =
av_strtok(varstr,
",", &saveptr2)) {
2086 }
else if (
av_strstart(keyval,
"default:", &val)) {
2094 }
else if (
av_strstart(keyval,
"agroup:", &val)) {
2097 }
else if (
av_strstart(keyval,
"sgroup:", &val)) {
2100 }
else if (
av_strstart(keyval,
"ccgroup:", &val)) {
2115 num = strtoll(val, &end, 10);
2122 if (stream_index >= 0 && nb_streams < vs->
nb_streams) {
2123 for (i = 0; nb_streams > 0 && i <
nb_streams; i++) {
2126 "variant definition #%d\n", nb_varstreams - 1);
2130 for (j = 0; nb_varstreams > 1 && j < nb_varstreams - 1; j++) {
2134 "in two different variant definitions #%d and #%d\n",
2135 j, nb_varstreams - 1);
2156 int nb_ccstreams = 0;
2157 char *p, *q, *ccstr, *keyval;
2158 char *saveptr1 =
NULL, *saveptr2 =
NULL;
2167 while (
av_strtok(q,
" \t", &saveptr1)) {
2180 while (ccstr =
av_strtok(p,
" \t", &saveptr1)) {
2183 if (nb_ccstreams < hls->nb_ccstreams)
2188 while (keyval =
av_strtok(ccstr,
",", &saveptr2)) {
2193 }
else if (
av_strstart(keyval,
"instreamid:", &val)) {
2195 }
else if (
av_strstart(keyval,
"language:", &val)) {
2209 if (atoi(val) < 1 || atoi(val) > 4) {
2215 if (atoi(val) < 1 || atoi(val) > 63) {
2293 if (dir && strcmp(dir,
"."))
2331 "(%"PRId64
" > %"PRId64
"), the result maybe not be what you want.",
2389 int64_t read_byte = 0;
2390 int64_t total_size = 0;
2391 char *filename =
NULL;
2404 memset(buf, 0,
sizeof(
BUFSIZE));
2407 if (read_byte > 0) {
2408 total_size += read_byte;
2411 }
while (read_byte > 0);
2423 int64_t end_pts = 0;
2425 int ret = 0, can_split = 1,
i, j;
2426 int stream_index = 0;
2427 int range_length = 0;
2428 const char *proto =
NULL;
2429 int use_temp_file = 0;
2431 char *old_filename =
NULL;
2464 end_pts = init_list_dur + after_init_list_dur ;
2483 is_ref_pkt = can_split = 0;
2497 av_log(s,
AV_LOG_WARNING,
"pkt->duration = 0, maybe the hls segment duration will not precise\n");
2503 can_split = can_split && (pkt->
pts - vs->
end_pts > 0);
2506 int64_t new_start_pos;
2516 if (range_length <= 0)
2525 if (!byterange_mode) {
2530 if (!byterange_mode) {
2542 vs->
size = range_length;
2548 use_temp_file = proto && !strcmp(proto,
"file")
2554 char *filename =
NULL;
2569 av_dict_set(&options,
"mpegts_flags",
"resend_headers", 0);
2576 "Failed to open file '%s'\n", filename);
2593 " will retry with a new http session.\n");
2609 if (!old_filename) {
2728 char *old_filename =
NULL;
2729 const char *proto =
NULL;
2730 int use_temp_file = 0;
2735 int range_length, byterange_mode;
2738 char *filename =
NULL;
2745 if (!old_filename) {
2761 int range_length = 0;
2774 if (!byterange_mode) {
2794 vs->
size = range_length;
2831 if (!old_filename) {
2868 const char *pattern;
2874 double initial_program_date_time =
av_gettime() / 1000000.0;
2893 if (!hls->
method && http_base_proto) {
2931 time_t t = time(
NULL);
2938 struct tm *p, tmbuf;
2941 if (!strftime(b,
sizeof(b),
"%Y%m%d%H%M%S", p))
2954 "'split_by_time' and 'independent_segments' cannot be " 2955 "enabled together. Disabling 'independent_segments' flag\n");
2982 av_log(s,
AV_LOG_WARNING,
"More than a single video stream present, expect issues decoding it.\n");
3020 fmp4_init_filename_len);
3035 char *expanded =
NULL;
3099 " hls_init_time value will have no effect\n");
3113 #define OFFSET(x) offsetof(HLSContext, x) 3114 #define E AV_OPT_FLAG_ENCODING_PARAM 3119 {
"hls_list_size",
"set maximum number of playlist entries",
OFFSET(max_nb_segments),
AV_OPT_TYPE_INT, {.i64 = 5}, 0, INT_MAX, E},
3120 {
"hls_delete_threshold",
"set number of unreferenced segments to keep before deleting",
OFFSET(hls_delete_threshold),
AV_OPT_TYPE_INT, {.i64 = 1}, 1, INT_MAX, E},
3121 {
"hls_ts_options",
"set hls mpegts list of options for the container format used for hls",
OFFSET(format_options),
AV_OPT_TYPE_DICT, {.str =
NULL}, 0, 0, E},
3122 {
"hls_vtt_options",
"set hls vtt list of options for the container format used for hls",
OFFSET(vtt_format_options_str),
AV_OPT_TYPE_STRING, {.str =
NULL}, 0, 0, E},
3124 {
"hls_wrap",
"set number after which the index wraps (will be deprecated)",
OFFSET(
wrap),
AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, E},
3126 {
"hls_allow_cache",
"explicitly set whether the client MAY (1) or MUST NOT (0) cache media segments",
OFFSET(allowcache),
AV_OPT_TYPE_INT, {.i64 = -1}, INT_MIN, INT_MAX, E},
3129 {
"hls_segment_size",
"maximum size per segment file, (in bytes)",
OFFSET(max_seg_size),
AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, E},
3139 {
"hls_fmp4_init_filename",
"set fragment mp4 file init filename",
OFFSET(fmp4_init_filename),
AV_OPT_TYPE_STRING, {.str =
"init.mp4"}, 0, 0, E},
3140 {
"hls_fmp4_init_resend",
"resend fragment mp4 init file after refresh m3u8 every time",
OFFSET(resend_init_file),
AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, E },
3141 {
"hls_flags",
"set flags affecting HLS playlist and media file generation",
OFFSET(
flags),
AV_OPT_TYPE_FLAGS, {.i64 = 0 }, 0, UINT_MAX,
E,
"flags"},
3143 {
"temp_file",
"write segment and playlist to temporary file and rename when complete", 0,
AV_OPT_TYPE_CONST, {.i64 =
HLS_TEMP_FILE }, 0, UINT_MAX,
E,
"flags"},
3155 {
"independent_segments",
"add EXT-X-INDEPENDENT-SEGMENTS, whenever applicable", 0,
AV_OPT_TYPE_CONST, { .i64 =
HLS_INDEPENDENT_SEGMENTS }, 0, UINT_MAX,
E,
"flags"},
3156 {
"iframes_only",
"add EXT-X-I-FRAMES-ONLY, whenever applicable", 0,
AV_OPT_TYPE_CONST, { .i64 =
HLS_I_FRAMES_ONLY }, 0, UINT_MAX,
E,
"flags"},
3157 #if FF_API_HLS_USE_LOCALTIME 3158 {
"use_localtime",
"set filename expansion with strftime at segment creation(will be deprecated)",
OFFSET(use_localtime),
AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, E },
3160 {
"strftime",
"set filename expansion with strftime at segment creation",
OFFSET(use_localtime),
AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, E },
3161 #if FF_API_HLS_USE_LOCALTIME 3162 {
"use_localtime_mkdir",
"create last directory component in strftime-generated filename(will be deprecated)",
OFFSET(use_localtime_mkdir),
AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, E },
3164 {
"strftime_mkdir",
"create last directory component in strftime-generated filename",
OFFSET(use_localtime_mkdir),
AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, E },
3178 {
"master_pl_publish_rate",
"Publish master play list every after this many segment intervals",
OFFSET(master_publish_rate),
AV_OPT_TYPE_INT, {.i64 = 0}, 0, UINT_MAX, E},
3179 {
"http_persistent",
"Use persistent HTTP connections",
OFFSET(http_persistent),
AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, E },
3180 {
"timeout",
"set timeout for socket I/O operations",
OFFSET(timeout),
AV_OPT_TYPE_DURATION, { .i64 = -1 }, -1, INT_MAX, .flags = E },
3181 {
"ignore_io_errors",
"Ignore IO errors for stable long-duration runs with network output",
OFFSET(ignore_io_errors),
AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, E },
3197 .extensions =
"m3u8",
3208 .priv_class = &hls_class,
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.
char key_string[KEYSIZE *2+1]
char key_uri[LINE_BUFFER_SIZE+1]
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
void av_bprintf(AVBPrint *buf, const char *fmt,...)
static av_const int av_isdigit(int c)
Locale-independent conversion of ASCII isdigit.
AVIOInterruptCB interrupt_callback
Custom interrupt callbacks for the I/O layer.
int avio_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer)
Return the written size and a pointer to the buffer.
ptrdiff_t const GLvoid * data
static int hls_write_trailer(struct AVFormatContext *s)
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
Write a packet to an output media file.
static int hlsenc_io_close(AVFormatContext *s, AVIOContext **pb, char *filename)
static int update_variant_stream_info(AVFormatContext *s)
#define AV_LOG_WARNING
Something somehow does not look correct.
#define LIBAVUTIL_VERSION_INT
#define AV_DICT_DONT_OVERWRITE
Don't overwrite existing entries.
char * av_stristr(const char *s1, const char *s2)
Locate the first case-independent occurrence in the string haystack of the string needle...
static av_cold int init(AVCodecContext *avctx)
int max_bitrate
Maximum bitrate of the stream, in bits per second.
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
char * vtt_format_options_str
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
int use_localtime_mkdir
flag to mkdir dirname in timebased filename
int index
stream index in AVFormatContext
int av_dict_count(const AVDictionary *m)
Get number of entries in dictionary.
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
static int hls_start(AVFormatContext *s, VariantStream *vs)
#define AVIO_FLAG_WRITE
write-only
enum AVMediaType codec_type
int av_strncasecmp(const char *a, const char *b, size_t n)
Locale-independent case-insensitive compare.
static int replace_int_data_in_filename(char **s, const char *filename, char placeholder, int64_t number)
int av_dict_copy(AVDictionary **dst, const AVDictionary *src, int flags)
Copy entries from one AVDictionary struct into another.
HLSSegment * old_segments
CodecAttributeStatus attr_status
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
AVIOContext * out_single_file
int avio_open_dyn_buf(AVIOContext **s)
Open a write only memory stream.
static int hls_window(AVFormatContext *s, int last, VariantStream *vs)
int strict_std_compliance
Allow non-standard and experimental extension.
static int hls_init_file_resend(AVFormatContext *s, VariantStream *vs)
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 int update_master_pl_info(AVFormatContext *s)
VariantStream * var_streams
static int do_encrypt(AVFormatContext *s, VariantStream *vs)
void ff_hls_write_audio_rendition(AVIOContext *out, const char *agroup, const char *filename, const char *language, int name_id, int is_default)
char current_segment_final_filename_fmt[MAX_URL_SIZE]
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.
int av_stristart(const char *str, const char *pfx, const char **ptr)
Return non-zero if pfx is a prefix of str independent of case.
char filename[MAX_URL_SIZE]
const char * av_basename(const char *path)
Thread safe basename.
static int hls_delete_file(HLSContext *hls, AVFormatContext *avf, const char *path, const char *proto)
enum AVCodecID av_codec_get_id(const struct AVCodecTag *const *tags, unsigned int tag)
Get the AVCodecID for the given codec tag tag.
miscellaneous OS support macros and functions.
char * fmp4_init_filename
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
static void hls_free_segments(HLSSegment *p)
static int append_postfix(char *name, int name_buf_len, int i)
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
uint8_t * av_stream_get_side_data(const AVStream *stream, enum AVPacketSideDataType type, int *size)
Get side information from stream.
AVStream ** streams
A list of all streams in the file.
void av_bprint_append_data(AVBPrint *buf, const char *data, unsigned size)
Append data to a print buffer.
char * protocol_whitelist
',' separated list of allowed protocols.
#define AVERROR_EOF
End of file.
#define AV_LOG_VERBOSE
Detailed information.
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
static av_always_inline void ffio_wfourcc(AVIOContext *pb, const uint8_t *s)
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 hls_deinit(AVFormatContext *s)
static const AVOption options[]
int ff_http_get_shutdown_status(URLContext *h)
Get the HTTP shutdown response status, be used after http_shutdown.
static int hls_write_header(AVFormatContext *s)
#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
#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.
#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. ...
preferred ID for decoding MPEG audio layer 1, 2 or 3
#define av_fourcc2str(fourcc)
enum AVMediaType codec_type
General type of the encoded data.
AVDictionary * vtt_format_options
static int hls_delete_old_segments(AVFormatContext *s, HLSContext *hls, VariantStream *vs)
simple assert() macros that are a bit more flexible than ISO C assert().
static int hls_append_segment(struct AVFormatContext *s, HLSContext *hls, VariantStream *vs, double duration, int64_t pos, int64_t size)
static av_always_inline av_const double round(double x)
char key_uri[LINE_BUFFER_SIZE+1]
static int hls_rename_temp_file(AVFormatContext *s, AVFormatContext *oc)
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option keep it simple and lowercase description are in without period
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.
static void write_styp(AVIOContext *pb)
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.
static void set_http_options(AVFormatContext *s, AVDictionary **options, HLSContext *c)
char * av_asprintf(const char *fmt,...)
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.
static int sls_flag_check_duration_size_index(HLSContext *hls)
char key_string[KEYSIZE *2+1]
AVFormatContext * vtt_avf
#define HLS_MICROSECOND_UNIT
static int randomize(uint8_t *buf, int len)
void ff_hls_write_subtitle_rendition(AVIOContext *out, const char *sgroup, const char *filename, const char *language, int name_id, int is_default)
HLSSegment * last_segment
char key_uri[LINE_BUFFER_SIZE+1]
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.
int av_strcasecmp(const char *a, const char *b)
Locale-independent case-insensitive compare.
AVIOContext * sub_m3u8_out
char sub_filename[MAX_URL_SIZE]
#define FF_PROFILE_UNKNOWN
static int write_trailer(AVFormatContext *s1)
static int hls_write_packet(AVFormatContext *s, AVPacket *pkt)
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 resend_init_file
resend init file into disk after refresh m3u8
static int get_nth_codec_stream_index(AVFormatContext *s, enum AVMediaType codec_type, int64_t stream_id)
static int create_master_playlist(AVFormatContext *s, VariantStream *const input_vs)
static int hls_mux_init(AVFormatContext *s, VariantStream *vs)
#define AV_DICT_APPEND
If the entry already exists, append to it.
ClosedCaptionsStream * cc_streams
static int av_bprint_is_complete(const AVBPrint *buf)
Test if the print buffer is complete (not truncated).
static void reflush_dynbuf(VariantStream *vs, int *range_length)
AVDictionary * format_options
int ff_get_line(AVIOContext *s, char *buf, int maxlen)
Read a whole line of text from AVIOContext.
static void sls_flag_file_rename(HLSContext *hls, VariantStream *vs, char *old_filename)
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.
static int hls_encryption_start(AVFormatContext *s, VariantStream *vs)
uint8_t * ff_nal_unit_extract_rbsp(const uint8_t *src, uint32_t src_len, uint32_t *dst_len, int header_len)
int reference_stream_index
char * base_output_dirname
ff_const59 struct AVOutputFormat * oformat
The output container format.
void ffio_free_dyn_buf(AVIOContext **s)
Free a dynamic buffer.
int use_localtime
flag to expand filename with localtime
int64_t av_gettime(void)
Get the current time in microseconds.
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
void ff_hls_write_playlist_version(AVIOContext *out, int version)
This structure describes the bitrate properties of an encoded bitstream.
char iv_string[KEYSIZE *2+1]
char * av_strdup(const char *s)
Duplicate a string.
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
AVIOContext * pb
I/O context.
unsigned int nb_ccstreams
char * fmp4_init_filename
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.
static int64_t get_stream_bit_rate(AVStream *stream)
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(const int16_t *) pi >> 8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(const int32_t *) pi >> 24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31))))#define SET_CONV_FUNC_GROUP(ofmt, ifmt) static void set_generic_function(AudioConvert *ac){}void ff_audio_convert_free(AudioConvert **ac){if(!*ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, int sample_rate, int apply_map){AudioConvert *ac;int in_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) return NULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method!=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt) > 2){ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc){av_free(ac);return NULL;}return ac;}in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar){ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar?ac->channels:1;}else if(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;else ac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);return ac;}int ff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){int use_generic=1;int len=in->nb_samples;int p;if(ac->dc){av_log(ac->avr, AV_LOG_TRACE,"%d samples - audio_convert: %s to %s (dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));return ff_convert_dither(ac-> in
char key_file[LINE_BUFFER_SIZE+1]
static int validate_name(int nb_vs, const char *fn)
Describe the class of an AVClass context structure.
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...
static int hlsenc_io_open(AVFormatContext *s, AVIOContext **pb, char *filename, AVDictionary **options)
char iv_string[KEYSIZE *2+1]
void avio_flush(AVIOContext *s)
Force flushing of buffered data.
static int flush_dynbuf(VariantStream *vs, int *range_length)
void avformat_free_context(AVFormatContext *s)
Free an AVFormatContext and all its streams.
static int hls_init(AVFormatContext *s)
int ffio_open_whitelist(AVIOContext **s, const char *url, int flags, const AVIOInterruptCB *int_cb, AVDictionary **options, const char *whitelist, const char *blacklist)
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...
double discont_program_date_time
const char * avio_find_protocol_name(const char *url)
Return the name of the protocol that will handle the passed URL.
URLContext * ffio_geturlcontext(AVIOContext *s)
Return the URLContext associated with the AVIOContext.
#define flags(name, subs,...)
char key_file[LINE_BUFFER_SIZE+1]
static HLSSegment * find_segment_by_filename(HLSSegment *segment, const char *filename)
static int format_name(const char *buf, char **s, int index, const char *varname)
static const char * get_default_pattern_localtime_fmt(AVFormatContext *s)
int ff_http_do_new_request(URLContext *h, const char *uri)
Send a new HTTP request, reusing the old connection.
void av_bprint_clear(AVBPrint *buf)
Reset the string to "" but keep internal allocated data.
char * av_strtok(char *s, const char *delim, char **saveptr)
Split the string into several tokens which can be accessed by successive calls to av_strtok()...
static void write_codec_attr(AVStream *st, VariantStream *vs)
static int replace_str_data_in_filename(char **s, const char *filename, char placeholder, const char *datastring)
int av_strstart(const char *str, const char *pfx, const char **ptr)
Return non-zero if pfx is a prefix of str.
static int parse_playlist(AVFormatContext *s, const char *url, VariantStream *vs)
char * av_append_path_component(const char *path, const char *component)
Append path component to the existing path.
unsigned int nb_varstreams
int profile
Codec-specific bitstream restrictions that the stream conforms to.
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...
const char * av_dirname(char *path)
Thread safe dirname.
int pts_wrap_bits
number of bits in pts (used for wrapping control)
int64_t video_keyframe_pos
static int sls_flag_check_duration_size(HLSContext *hls, VariantStream *vs)
uint32_t start_sequence_source_type
void * priv_data
Format private data.
This side data corresponds to the AVCPBProperties struct.
ff_const59 AVOutputFormat * vtt_oformat
static const uint8_t start_sequence[]
static void write_header(FFV1Context *f)
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
static int sls_flags_filename_process(struct AVFormatContext *s, HLSContext *hls, VariantStream *vs, HLSSegment *en, double duration, int64_t pos, int64_t size)
AVOutputFormat ff_hls_muxer
void ff_hls_write_end_list(AVIOContext *out)
static int strftime_expand(const char *fmt, char **dest)
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)
char * protocol_blacklist
',' separated list of disallowed protocols.
ff_const59 AVOutputFormat * oformat
unsigned int master_publish_rate
static int64_t append_single_file(AVFormatContext *s, VariantStream *vs)
int64_t video_keyframe_size
#define AVERROR_MUXER_NOT_FOUND
Muxer not found.
AVCodecParameters * codecpar
Codec parameters associated with this stream.
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
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...
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
static const AVClass hls_class
#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.
double initial_prog_date_time
int ff_get_chomp_line(AVIOContext *s, char *buf, int maxlen)
Same as ff_get_line but strip the white-space characters in the text tail.
int avcodec_parameters_copy(AVCodecParameters *dst, const AVCodecParameters *src)
Copy the contents of src to dst.
char iv_string[KEYSIZE *2+1]
static double val(void *priv, double ch)
This structure stores compressed data.
int av_opt_set(void *obj, const char *name, const char *val, int search_flags)
static int parse_variant_stream_mapstring(AVFormatContext *s)
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
#define AV_NOPTS_VALUE
Undefined timestamp value.
FFmpeg currently uses a custom build this text attempts to document some of its obscure features and options Makefile the full command issued by make and its output will be shown on the screen DBG Preprocess x86 external assembler files to a dbg asm file in the object which then gets compiled Helps in developing those assembler files DESTDIR Destination directory for the install useful to prepare packages or install FFmpeg in cross environments GEN Set to ‘1’ to generate the missing or mismatched references Makefile builds all the libraries and the executables fate Run the fate test note that you must have installed it fate list List all fate regression test targets install Install headers
static const char * get_relative_url(const char *master_url, const char *media_url)
int avio_printf(AVIOContext *s, const char *fmt,...) av_printf_format(2
Writes a formatted string to the context.
static int sls_flag_use_localtime_filename(AVFormatContext *oc, HLSContext *c, VariantStream *vs)
static int parse_cc_stream_mapstring(AVFormatContext *s)