33 #include <openssl/rand.h> 49 #if CONFIG_HTTP_PROTOCOL 70 #define LINE_BUFFER_SIZE MAX_URL_SIZE 71 #define HLS_MICROSECOND_UNIT 1000000 72 #define POSTFIX_PATTERN "_%d" 171 char codec_attr[128];
266 #if CONFIG_HTTP_PROTOCOL 288 #if CONFIG_HTTP_PROTOCOL 306 }
else if (http_base_proto) {
331 if (data && (data[0] | data[1] | data[2]) == 0 && data[3] == 1 && (data[4] & 0x1F) == 7) {
333 "avc1.%02x%02x%02x", data[5], data[6], data[7]);
338 snprintf(attr,
sizeof(attr),
"mp4a.40.33");
340 snprintf(attr,
sizeof(attr),
"mp4a.40.34");
346 snprintf(attr,
sizeof(attr),
"mp4a.40.2");
348 snprintf(attr,
sizeof(attr),
"ac-3");
350 snprintf(attr,
sizeof(attr),
"ec-3");
358 "%s%s", codec_strlen ?
"," :
"", attr);
384 if (c ==
'%' && *(p+1) ==
'%')
386 else if (c ==
'%' && *(p+1) == placeholder) {
394 if (addchar_count > 0) {
414 int nd, addchar_count;
425 if (c ==
'%' && *(p+1) ==
'%')
427 else if (c ==
'%' && (
av_isdigit(*(p+1)) || *(p+1) == placeholder)) {
431 nd = nd * 10 + *(p + addchar_count) -
'0';
435 if (*(p + addchar_count) == placeholder) {
436 av_bprintf(&buf,
"%0*"PRId64, (number < 0) ? nd : nd++, number);
437 p += (addchar_count + 1);
496 #define SEPARATOR '\\' 498 #define SEPARATOR '/' 502 const char *path,
const char *proto)
514 }
else if (unlink(path) < 0) {
516 path, strerror(errno));
526 float playlist_duration = 0.0f;
530 const char *dirname =
NULL;
531 char *dirname_r =
NULL;
532 char *dirname_repl =
NULL;
533 const char *vtt_dirname =
NULL;
534 char *vtt_dirname_r =
NULL;
535 const char *proto =
NULL;
541 playlist_duration += segment->
duration;
542 segment = segment->
next;
548 playlist_duration -= segment->
duration;
549 previous_segment = segment;
550 segment = previous_segment->
next;
552 if (playlist_duration <= -previous_segment->
duration) {
582 dirname = dirname_repl;
619 previous_segment = segment;
620 segment = previous_segment->
next;
635 gcry_randomize(buf, len, GCRY_VERY_STRONG_RANDOM);
638 if (RAND_bytes(buf, len))
655 len = strlen(key_basename_source) + 4 + 1;
678 memcpy(iv, hls->
iv,
sizeof(iv));
698 if ((ret =
randomize(key,
sizeof(key))) < 0) {
703 memcpy(key, hls->
key,
sizeof(key));
768 if (ret !=
sizeof(key)) {
786 int remaining_options;
844 av_log(s,
AV_LOG_WARNING,
"http persistent mode is currently unsupported for fragment mp4 in the HLS muxer.\n");
847 av_log(s,
AV_LOG_WARNING,
"Multi-file byterange mode is currently unsupported in the HLS muxer.\n");
857 if (byterange_mode) {
876 snprintf(period,
sizeof(period),
"%d", (INT_MAX / 2) - 1);
885 if (remaining_options) {
898 segment = segment->
next;
918 "Invalid second level segment filename template '%s', " 919 "you can try to remove second_level_segment_size flag\n",
931 "Invalid second level segment filename template '%s', " 932 "you can try to remove second_level_segment_time flag\n",
949 "second_level_segment_duration hls_flag requires strftime to be true\n");
954 "second_level_segment_size hls_flag requires strfime to be true\n");
959 "second_level_segment_index hls_flag requires strftime to be true\n");
969 int segment_renaming_ok = proto && !strcmp(proto,
"file");
974 "second_level_segment_duration hls_flag works only with file protocol segment names\n");
979 "second_level_segment_size hls_flag works only with file protocol segment names\n");
1004 "you can try to remove second_level_segment_index flag\n",
1015 char *filename =
NULL;
1018 "you can try to remove second_level_segment_size flag\n",
1026 char *filename =
NULL;
1029 "you can try to remove second_level_segment_time flag\n",
1066 && !byterange_mode) {
1136 int ret = 0, is_segment = 0;
1148 if (strcmp(line,
"#EXTM3U")) {
1156 if (
av_strstart(line,
"#EXT-X-MEDIA-SEQUENCE:", &ptr)) {
1158 if (tmp_sequence < vs->sequence)
1160 "Found playlist sequence number was smaller """ 1161 "than specified start sequence number: %"PRId64
" < %"PRId64
", " 1164 av_log(hls,
AV_LOG_DEBUG,
"Found playlist sequence number: %"PRId64
"\n", tmp_sequence);
1167 }
else if (
av_strstart(line,
"#EXT-X-DISCONTINUITY", &ptr)) {
1176 ptr += strlen(
"URI=\"");
1187 ptr += strlen(
"IV=0x");
1198 }
else if (line[0]) {
1236 size_t len = strlen(oc->
url);
1240 if (!final_filename)
1242 final_filename[len-4] =
'\0';
1244 oc->
url[len-4] =
'\0';
1251 const char *p = strrchr(master_url,
'/');
1252 size_t base_len = 0;
1254 if (!p) p = strrchr(master_url,
'\\');
1257 base_len = p - master_url;
1266 return media_url + base_len + 1;
1294 const char *m3u8_rel_name =
NULL;
1295 const char *vtt_m3u8_rel_name =
NULL;
1296 const char *ccgroup;
1297 const char *sgroup =
NULL;
1300 int is_file_proto = proto && !strcmp(proto,
"file");
1347 if (!m3u8_rel_name) {
1360 if (!m3u8_rel_name) {
1374 if (!vid_st && !aud_st) {
1403 bandwidth += bandwidth / 10;
1420 if (vid_st && vs->
sgroup) {
1423 if (!vtt_m3u8_rel_name) {
1455 int target_duration = 0;
1461 int is_file_proto = proto && !strcmp(proto,
"file");
1463 static unsigned warned_non_file;
1472 if (byterange_mode) {
1486 av_log(s,
AV_LOG_ERROR,
"Cannot use rename on non file protocol, this may lead to races and temporary partial files\n");
1489 snprintf(temp_filename,
sizeof(temp_filename), use_temp_file ?
"%s.tmp" :
"%s", vs->
m3u8_name);
1497 if (target_duration <= en->duration)
1541 snprintf(temp_vtt_filename,
sizeof(temp_vtt_filename), use_temp_file ?
"%s.tmp" :
"%s", vs->
vtt_m3u8_name);
1570 if (use_temp_file) {
1588 const char *proto =
NULL;
1589 int use_temp_file = 0;
1605 char *filename =
NULL;
1620 struct tm *tm, tmpbuf;
1628 if (!strftime(oc->
url, bufsize, vs->
basename, tm)) {
1644 if (
ff_mkdir_p(dir) == -1 && errno != EEXIST) {
1645 av_log(oc,
AV_LOG_ERROR,
"Could not create directory %s with use_localtime_mkdir\n", dir);
1652 char *filename =
NULL;
1666 char *filename =
NULL;
1684 if (use_temp_file) {
1699 " ignoring -hls_enc\n");
1722 memcpy(vs->
iv_string, iv_string,
sizeof(iv_string));
1764 time_t t = time(
NULL);
1765 struct tm *p, tmbuf;
1772 return (
HAVE_LIBC_MSVCRT || !strftime(b,
sizeof(b),
"%s", p) || !strcmp(b,
"%s")) ?
"-%Y%m%d%H%M%S.m4s" :
"-%s.m4s";
1774 return (
HAVE_LIBC_MSVCRT || !strftime(b,
sizeof(b),
"%s", p) || !strcmp(b,
"%s")) ?
"-%Y%m%d%H%M%S.ts" :
"-%s.ts";
1780 char extension[10] = {
'\0'};
1782 p = strrchr(name,
'.');
1790 if (strlen(extension))
1798 const char *
filename, *subdir_name;
1799 char *fn_dup =
NULL;
1813 "either in the filename or in the sub-directory name of file %s\n", fn);
1820 "in the sub-directory name of file %s, but only in one of them\n", fn);
1832 const char *proto, *dir;
1833 char *orig_buf_dup =
NULL, *mod_buf_dup =
NULL;
1861 if (
av_stristr(dir,
"%v") && proto && !strcmp(proto,
"file")) {
1864 if (
ff_mkdir_p(dir) == -1 && errno != EEXIST) {
1880 unsigned int stream_index, cnt;
1881 if (stream_id < 0 || stream_id > s->
nb_streams - 1)
1884 for (stream_index = 0; stream_index < s->
nb_streams; stream_index++) {
1887 if (cnt == stream_id)
1888 return stream_index;
1898 int stream_index,
i, j;
1901 char *p, *q, *saveptr1, *saveptr2, *varstr, *keyval;
1924 while (
av_strtok(q,
" \t", &saveptr1)) {
1937 while (varstr =
av_strtok(p,
" \t", &saveptr1)) {
1940 if (nb_varstreams < hls->nb_varstreams) {
1963 while (keyval =
av_strtok(varstr,
",", &saveptr2)) {
1970 }
else if (
av_strstart(keyval,
"default:", &val)) {
1978 }
else if (
av_strstart(keyval,
"agroup:", &val)) {
1981 }
else if (
av_strstart(keyval,
"sgroup:", &val)) {
1984 }
else if (
av_strstart(keyval,
"ccgroup:", &val)) {
1999 num = strtoll(val, &end, 10);
2006 if (stream_index >= 0 && nb_streams < vs->
nb_streams) {
2007 for (i = 0; nb_streams > 0 && i <
nb_streams; i++) {
2010 "variant definition #%d\n", nb_varstreams - 1);
2014 for (j = 0; nb_varstreams > 1 && j < nb_varstreams - 1; j++) {
2018 "in two different variant definitions #%d and #%d\n",
2019 j, nb_varstreams - 1);
2040 int nb_ccstreams = 0;
2041 char *p, *q, *ccstr, *keyval;
2042 char *saveptr1 =
NULL, *saveptr2 =
NULL;
2051 while (
av_strtok(q,
" \t", &saveptr1)) {
2064 while (ccstr =
av_strtok(p,
" \t", &saveptr1)) {
2067 if (nb_ccstreams < hls->nb_ccstreams)
2072 while (keyval =
av_strtok(ccstr,
",", &saveptr2)) {
2077 }
else if (
av_strstart(keyval,
"instreamid:", &val)) {
2079 }
else if (
av_strstart(keyval,
"language:", &val)) {
2093 if (atoi(val) < 1 || atoi(val) > 4) {
2099 if (atoi(val) < 1 || atoi(val) > 63) {
2177 if (dir && strcmp(dir,
"."))
2215 "(%"PRId64
" > %"PRId64
"), the result maybe not be what you want.",
2273 int ret = 0, can_split = 1,
i, j;
2274 int stream_index = 0;
2275 int range_length = 0;
2276 const char *proto =
NULL;
2277 int use_temp_file = 0;
2279 char *old_filename =
NULL;
2312 end_pts = init_list_dur + after_init_list_dur ;
2331 is_ref_pkt = can_split = 0;
2345 av_log(s,
AV_LOG_WARNING,
"pkt->duration = 0, maybe the hls segment duration will not precise\n");
2364 if (range_length <= 0)
2373 if (!byterange_mode) {
2378 if (!byterange_mode) {
2390 vs->
size = range_length;
2394 use_temp_file = proto && !strcmp(proto,
"file")
2400 char *filename =
NULL;
2415 av_dict_set(&options,
"mpegts_flags",
"resend_headers", 0);
2422 "Failed to open file '%s'\n", filename);
2439 " will retry with a new http session.\n");
2460 if (!old_filename) {
2575 char *old_filename =
NULL;
2576 const char *proto =
NULL;
2577 int use_temp_file = 0;
2582 int range_length, byterange_mode;
2585 char *filename =
NULL;
2592 if (!old_filename) {
2608 int range_length = 0;
2621 if (!byterange_mode) {
2641 vs->
size = range_length;
2674 if (!old_filename) {
2711 const char *pattern;
2735 if (!hls->
method && http_base_proto) {
2773 time_t t = time(
NULL);
2780 struct tm *p, tmbuf;
2783 if (!strftime(b,
sizeof(b),
"%Y%m%d%H%M%S", p))
2796 "'split_by_time' and 'independent_segments' cannot be " 2797 "enabled together. Disabling 'independent_segments' flag\n");
2829 av_log(s,
AV_LOG_WARNING,
"More than a single video stream present, expect issues decoding it.\n");
2867 fmp4_init_filename_len);
2933 " hls_init_time value will have no effect\n");
2947 #define OFFSET(x) offsetof(HLSContext, x) 2948 #define E AV_OPT_FLAG_ENCODING_PARAM 2952 {
"hls_init_time",
"set segment length in seconds at init list",
OFFSET(init_time),
AV_OPT_TYPE_FLOAT, {.dbl = 0}, 0, FLT_MAX, E},
2953 {
"hls_list_size",
"set maximum number of playlist entries",
OFFSET(max_nb_segments),
AV_OPT_TYPE_INT, {.i64 = 5}, 0, INT_MAX, E},
2954 {
"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},
2955 {
"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},
2956 {
"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},
2958 {
"hls_wrap",
"set number after which the index wraps (will be deprecated)",
OFFSET(
wrap),
AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, E},
2960 {
"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},
2963 {
"hls_segment_size",
"maximum size per segment file, (in bytes)",
OFFSET(max_seg_size),
AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, E},
2973 {
"hls_fmp4_init_filename",
"set fragment mp4 file init filename",
OFFSET(fmp4_init_filename),
AV_OPT_TYPE_STRING, {.str =
"init.mp4"}, 0, 0, E},
2974 {
"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 },
2975 {
"hls_flags",
"set flags affecting HLS playlist and media file generation",
OFFSET(
flags),
AV_OPT_TYPE_FLAGS, {.i64 = 0 }, 0, UINT_MAX,
E,
"flags"},
2977 {
"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"},
2989 {
"independent_segments",
"add EXT-X-INDEPENDENT-SEGMENTS, whenever applicable", 0,
AV_OPT_TYPE_CONST, { .i64 =
HLS_INDEPENDENT_SEGMENTS }, 0, UINT_MAX,
E,
"flags"},
2990 {
"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"},
2991 #if FF_API_HLS_USE_LOCALTIME 2992 {
"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 },
2994 {
"strftime",
"set filename expansion with strftime at segment creation",
OFFSET(use_localtime),
AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, E },
2995 #if FF_API_HLS_USE_LOCALTIME 2996 {
"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 },
2998 {
"strftime_mkdir",
"create last directory component in strftime-generated filename",
OFFSET(use_localtime_mkdir),
AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, E },
3012 {
"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},
3013 {
"http_persistent",
"Use persistent HTTP connections",
OFFSET(http_persistent),
AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, E },
3014 {
"timeout",
"set timeout for socket I/O operations",
OFFSET(timeout),
AV_OPT_TYPE_DURATION, { .i64 = -1 }, -1, INT_MAX, .flags = E },
3015 {
"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 },
3016 {
"headers",
"set custom HTTP headers, can override built in default headers",
OFFSET(headers),
AV_OPT_TYPE_STRING, { .str =
NULL }, 0, 0, E },
3031 .extensions =
"m3u8",
3042 .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.
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
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
static av_cold int end(AVCodecContext *avctx)
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
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 i(width, name, range_min, range_max)
#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
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().
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
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)
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.
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]
#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.
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)
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)\", 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...
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)
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
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...
static const AVClass hls_class
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.
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)