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"
267 struct tm *tm, tmpbuf;
294 #if CONFIG_HTTP_PROTOCOL
316 #if CONFIG_HTTP_PROTOCOL
334 }
else if (http_base_proto) {
339 if (
c->http_persistent)
389 if (rbsp_size < 13) {
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;
620 if (playlist_duration <= -previous_segment->
duration) {
650 dirname = dirname_repl;
669 if ((
segment->sub_filename[0] !=
'\0')) {
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));
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");
925 if (byterange_mode) {
944 snprintf(period,
sizeof(period),
"%d", (INT_MAX / 2) - 1);
953 if (remaining_options) {
983 char *filename =
NULL;
986 "Invalid second level segment filename template '%s', "
987 "you can try to remove second_level_segment_size flag\n",
995 char *filename =
NULL;
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");
1064 char *filename =
NULL;
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",
1114 const char *filename;
1134 && !byterange_mode) {
1206 int ret = 0, is_segment = 0;
1207 int64_t new_start_pos;
1211 double discont_program_date_time = 0;
1214 &
s->interrupt_callback,
NULL,
1215 s->protocol_whitelist,
s->protocol_blacklist)) < 0)
1219 if (strcmp(
line,
"#EXTM3U")) {
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);
1247 ptr += strlen(
"URI=\"");
1258 ptr += strlen(
"IV=0x");
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';
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;
1554 char *key_uri =
NULL;
1555 char *iv_string =
NULL;
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;
1688 char iv_string[
KEYSIZE*2 + 1];
1702 }
else if (
c->max_seg_size > 0) {
1703 char *filename =
NULL;
1716 if (
c->use_localtime) {
1718 char *expanded =
NULL;
1732 if (
c->use_localtime_mkdir) {
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;
1776 use_temp_file = proto && !strcmp(proto,
"file") && (
c->flags &
HLS_TEMP_FILE);
1778 if (use_temp_file) {
1785 if (
c->key_info_file ||
c->encrypt) {
1791 if (
c->key_info_file &&
c->encrypt) {
1793 " ignoring -hls_enc\n");
1797 if (
c->key_info_file) {
1801 if (!
c->encrypt_started) {
1804 c->encrypt_started = 1;
1816 memcpy(vs->
iv_string, iv_string,
sizeof(iv_string));
1824 if (
c->key_info_file ||
c->encrypt) {
1841 if (
c->ignore_io_errors)
1847 if (
c->ignore_io_errors)
1857 if (
c->ignore_io_errors)
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++) {
2001 if (
s->streams[stream_index]->codecpar->codec_type !=
codec_type)
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)) {
2115 num = strtoll(
val, &end, 10);
2122 if (stream_index >= 0 && nb_streams < vs->
nb_streams) {
2124 if (vs->
streams[
i] ==
s->streams[stream_index]) {
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)) {
2209 if (atoi(
val) < 1 || atoi(
val) > 4) {
2215 if (atoi(
val) < 1 || atoi(
val) > 63) {
2262 for (
i = 0;
i <
s->nb_streams;
i++)
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;
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;
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");
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 },
3182 {
"headers",
"set custom HTTP headers, can override built in default headers",
OFFSET(headers),
AV_OPT_TYPE_STRING, { .str =
NULL }, 0, 0,
E },
3197 .extensions =
"m3u8",
static double val(void *priv, double ch)
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
simple assert() macros that are a bit more flexible than ISO C assert().
#define av_assert0(cond)
assert() equivalent, that is always enabled.
uint8_t * ff_nal_unit_extract_rbsp(const uint8_t *src, uint32_t src_len, uint32_t *dst_len, int header_len)
#define FF_PROFILE_UNKNOWN
int ffurl_shutdown(URLContext *h, int flags)
Signal the URLContext that we are done reading or writing the stream.
const char * avio_find_protocol_name(const char *url)
Return the name of the protocol that will handle the passed URL.
int ff_rename(const char *url_src, const char *url_dst, void *logctx)
Wrap avpriv_io_move and log if error happens.
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
void avio_wb32(AVIOContext *s, unsigned int val)
#define AVIO_FLAG_READ
read-only
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
#define AVIO_FLAG_WRITE
write-only
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
int avio_printf(AVIOContext *s, const char *fmt,...) av_printf_format(2
Writes a formatted string to the context.
int avio_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer)
Return the written size and a pointer to the buffer.
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
int avio_close(AVIOContext *s)
Close the resource accessed by the AVIOContext s and free it.
void avio_flush(AVIOContext *s)
Force flushing of buffered data.
int avio_open_dyn_buf(AVIOContext **s)
Open a write only memory stream.
void ffio_free_dyn_buf(AVIOContext **s)
Free a dynamic buffer.
static av_always_inline void ffio_wfourcc(AVIOContext *pb, const uint8_t *s)
int ffio_open_whitelist(AVIOContext **s, const char *url, int flags, const AVIOInterruptCB *int_cb, AVDictionary **options, const char *whitelist, const char *blacklist)
URLContext * ffio_geturlcontext(AVIOContext *s)
Return the URLContext associated with the AVIOContext.
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 ff_get_line(AVIOContext *s, char *buf, int maxlen)
Read a whole line of text from AVIOContext.
static av_cold int init(AVCodecContext *avctx)
char * av_asprintf(const char *fmt,...)
void av_bprintf(AVBPrint *buf, const char *fmt,...)
void av_bprint_init(AVBPrint *buf, unsigned size_init, unsigned size_max)
int av_bprint_finalize(AVBPrint *buf, char **ret_str)
Finalize a print buffer.
void av_bprint_append_data(AVBPrint *buf, const char *data, unsigned size)
Append data to a print buffer.
void av_bprint_clear(AVBPrint *buf)
Reset the string to "" but keep internal allocated data.
#define AV_BPRINT_SIZE_UNLIMITED
static int av_bprint_is_complete(const AVBPrint *buf)
Test if the print buffer is complete (not truncated).
#define flags(name, subs,...)
int avcodec_parameters_copy(AVCodecParameters *dst, const AVCodecParameters *src)
Copy the contents of src to dst.
#define MKTAG(a, b, c, d)
static void write_packet(OutputFile *of, AVPacket *pkt, OutputStream *ost, int unqueue)
static void write_header(FFV1Context *f)
@ AV_CODEC_ID_MP3
preferred ID for decoding MPEG audio layer 1, 2 or 3
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
@ AV_PKT_DATA_CPB_PROPERTIES
This side data corresponds to the AVCPBProperties struct.
uint8_t * av_stream_get_side_data(const AVStream *stream, enum AVPacketSideDataType type, size_t *size)
Get side information from stream.
void avformat_free_context(AVFormatContext *s)
Free an AVFormatContext and all its streams.
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
av_warn_unused_result int avformat_init_output(AVFormatContext *s, AVDictionary **options)
Allocate the stream private data and initialize the codec, but do not write the header.
av_warn_unused_result int avformat_write_header(AVFormatContext *s, AVDictionary **options)
Allocate the stream private data and write the stream header to an output media file.
ff_const59 AVOutputFormat * av_guess_format(const char *short_name, const char *filename, const char *mime_type)
Return the output format in the list of registered output formats which best matches the provided par...
int av_write_trailer(AVFormatContext *s)
Write the stream trailer to an output media file and free the file private data.
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
Write a packet to an output media file.
unsigned int av_codec_get_tag(const struct AVCodecTag *const *tags, enum AVCodecID id)
Get the codec tag for the given codec id id.
enum AVCodecID av_codec_get_id(const struct AVCodecTag *const *tags, unsigned int tag)
Get the AVCodecID for the given codec tag tag.
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values.
int av_dict_copy(AVDictionary **dst, const AVDictionary *src, int flags)
Copy entries from one AVDictionary struct into another.
#define AV_DICT_APPEND
If the entry already exists, append to it.
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
#define AV_DICT_DONT_OVERWRITE
Don't overwrite existing entries.
int av_dict_count(const AVDictionary *m)
Get number of entries in dictionary.
int av_dict_set_int(AVDictionary **pm, const char *key, int64_t value, int flags)
Convenience wrapper for av_dict_set that converts the value to a string and stores it.
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
#define AVERROR_MUXER_NOT_FOUND
Muxer not found.
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
#define AVERROR_EOF
End of file.
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
#define AV_LOG_WARNING
Something somehow does not look correct.
#define AV_LOG_VERBOSE
Detailed information.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
const char * av_default_item_name(void *ptr)
Return the context name.
int av_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.
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
char * av_strdup(const char *s)
Duplicate a string.
#define av_fourcc2str(fourcc)
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 * av_basename(const char *path)
Thread safe basename.
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().
char * av_stristr(const char *s1, const char *s2)
Locate the first case-independent occurrence in the string haystack of the string needle.
int av_strcasecmp(const char *a, const char *b)
Locale-independent case-insensitive compare.
static av_const int av_isdigit(int c)
Locale-independent conversion of ASCII isdigit.
int av_strstart(const char *str, const char *pfx, const char **ptr)
Return non-zero if pfx is a prefix of str.
size_t av_strlcpy(char *dst, const char *src, size_t size)
Copy the string src to dst, but no more than size - 1 bytes, and null-terminate dst.
char * av_append_path_component(const char *path, const char *component)
Append path component to the existing path.
const char * av_dirname(char *path)
Thread safe dirname.
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.
int av_strncasecmp(const char *a, const char *b, size_t n)
Locale-independent case-insensitive compare.
#define AV_NOPTS_VALUE
Undefined timestamp value.
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
#define LIBAVUTIL_VERSION_INT
int av_opt_set(void *obj, const char *name, const char *val, int search_flags)
static int sls_flag_check_duration_size_index(HLSContext *hls)
static int update_variant_stream_info(AVFormatContext *s)
static int64_t get_stream_bit_rate(AVStream *stream)
static int sls_flags_filename_process(struct AVFormatContext *s, HLSContext *hls, VariantStream *vs, HLSSegment *en, double duration, int64_t pos, int64_t size)
static void set_http_options(AVFormatContext *s, AVDictionary **options, HLSContext *c)
static int hls_init(AVFormatContext *s)
static int create_master_playlist(AVFormatContext *s, VariantStream *const input_vs)
static const AVOption options[]
static int hls_window(AVFormatContext *s, int last, VariantStream *vs)
static HLSSegment * find_segment_by_filename(HLSSegment *segment, const char *filename)
AVOutputFormat ff_hls_muxer
static int validate_name(int nb_vs, const char *fn)
static int get_nth_codec_stream_index(AVFormatContext *s, enum AVMediaType codec_type, int64_t stream_id)
static int hls_rename_temp_file(AVFormatContext *s, AVFormatContext *oc)
static int hls_delete_file(HLSContext *hls, AVFormatContext *avf, const char *path, const char *proto)
static int parse_variant_stream_mapstring(AVFormatContext *s)
static int append_postfix(char *name, int name_buf_len, int i)
static void hls_free_segments(HLSSegment *p)
static int hls_write_header(AVFormatContext *s)
static int hls_append_segment(struct AVFormatContext *s, HLSContext *hls, VariantStream *vs, double duration, int64_t pos, int64_t size)
static int format_name(const char *buf, char **s, int index, const char *varname)
static int replace_int_data_in_filename(char **s, const char *filename, char placeholder, int64_t number)
static int replace_str_data_in_filename(char **s, const char *filename, char placeholder, const char *datastring)
static void reflush_dynbuf(VariantStream *vs, int *range_length)
static int do_encrypt(AVFormatContext *s, VariantStream *vs)
static int sls_flag_use_localtime_filename(AVFormatContext *oc, HLSContext *c, VariantStream *vs)
static int hlsenc_io_close(AVFormatContext *s, AVIOContext **pb, char *filename)
static int hls_init_file_resend(AVFormatContext *s, VariantStream *vs)
static int64_t append_single_file(AVFormatContext *s, VariantStream *vs)
static void sls_flag_file_rename(HLSContext *hls, VariantStream *vs, char *old_filename)
static int strftime_expand(const char *fmt, char **dest)
static int hls_write_trailer(struct AVFormatContext *s)
static void hls_deinit(AVFormatContext *s)
@ HLS_START_SEQUENCE_AS_MICROSECONDS_SINCE_EPOCH
@ HLS_START_SEQUENCE_AS_FORMATTED_DATETIME
@ HLS_START_SEQUENCE_AS_SECONDS_SINCE_EPOCH
@ HLS_START_SEQUENCE_LAST
@ HLS_START_SEQUENCE_AS_START_NUMBER
static int flush_dynbuf(VariantStream *vs, int *range_length)
static const char * get_default_pattern_localtime_fmt(AVFormatContext *s)
static int parse_playlist(AVFormatContext *s, const char *url, VariantStream *vs)
#define HLS_MICROSECOND_UNIT
static int hls_start(AVFormatContext *s, VariantStream *vs)
static int hlsenc_io_open(AVFormatContext *s, AVIOContext **pb, char *filename, AVDictionary **options)
static void write_styp(AVIOContext *pb)
static int hls_encryption_start(AVFormatContext *s, VariantStream *vs)
static int hls_write_packet(AVFormatContext *s, AVPacket *pkt)
static int hls_mux_init(AVFormatContext *s, VariantStream *vs)
static int parse_cc_stream_mapstring(AVFormatContext *s)
static const AVClass hls_class
static int randomize(uint8_t *buf, int len)
@ HLS_SECOND_LEVEL_SEGMENT_INDEX
@ HLS_INDEPENDENT_SEGMENTS
@ HLS_SECOND_LEVEL_SEGMENT_DURATION
@ HLS_SECOND_LEVEL_SEGMENT_SIZE
@ CODEC_ATTRIBUTE_WILL_NOT_BE_WRITTEN
@ CODEC_ATTRIBUTE_WRITTEN
static int hls_delete_old_segments(AVFormatContext *s, HLSContext *hls, VariantStream *vs)
static int sls_flag_check_duration_size(HLSContext *hls, VariantStream *vs)
static const char * get_relative_url(const char *master_url, const char *media_url)
static int update_master_pl_info(AVFormatContext *s)
static void write_codec_attr(AVStream *st, VariantStream *vs)
void ff_hls_write_playlist_version(AVIOContext *out, int version)
void ff_hls_write_playlist_header(AVIOContext *out, int version, int allowcache, int target_duration, int64_t sequence, uint32_t playlist_type, int iframe_mode)
int ff_hls_write_file_entry(AVIOContext *out, int insert_discont, int byterange_mode, double duration, int round_duration, int64_t size, int64_t pos, const char *baseurl, const char *filename, double *prog_date_time, int64_t video_keyframe_size, int64_t video_keyframe_pos, int iframe_mode)
void ff_hls_write_init_file(AVIOContext *out, const char *filename, int byterange_mode, int64_t size, int64_t pos)
void ff_hls_write_subtitle_rendition(AVIOContext *out, const char *sgroup, const char *filename, const char *language, int name_id, int is_default)
void ff_hls_write_audio_rendition(AVIOContext *out, const char *agroup, const char *filename, const char *language, int name_id, int is_default)
void ff_hls_write_stream_info(AVStream *st, AVIOContext *out, int bandwidth, const char *filename, const char *agroup, const char *codecs, const char *ccgroup, const char *sgroup)
void ff_hls_write_end_list(AVIOContext *out)
int ff_http_get_shutdown_status(URLContext *h)
Get the HTTP shutdown response status, be used after http_shutdown.
int ff_http_do_new_request(URLContext *h, const char *uri)
Send a new HTTP request, reusing the old connection.
common internal API header
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
static av_always_inline av_const double round(double x)
miscellaneous OS support macros and functions.
enum AVMediaType codec_type
static const uint8_t start_sequence[]
This structure describes the bitrate properties of an encoded bitstream.
int max_bitrate
Maximum bitrate of the stream, in bits per second.
Describe the class of an AVClass context structure.
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
int extradata_size
Size of the extradata content in bytes.
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
enum AVMediaType codec_type
General type of the encoded data.
int profile
Codec-specific bitstream restrictions that the stream conforms to.
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
AVIOContext * pb
I/O context.
AVDictionary * metadata
Metadata that applies to the whole file.
int strict_std_compliance
Allow non-standard and experimental extension.
AVIOInterruptCB interrupt_callback
Custom interrupt callbacks for the I/O layer.
char * url
input or output URL.
ff_const59 struct AVOutputFormat * oformat
The output container format.
void(* io_close)(struct AVFormatContext *s, AVIOContext *pb)
A callback for closing the streams opened with AVFormatContext.io_open().
void * priv_data
Format private data.
AVStream ** streams
A list of all streams in the file.
int(* io_open)(struct AVFormatContext *s, AVIOContext **pb, const char *url, int flags, AVDictionary **options)
A callback for opening new IO streams.
This structure stores compressed data.
int flags
A combination of AV_PKT_FLAG values.
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
AVCodecParameters * codecpar
Codec parameters associated with this stream.
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
int index
stream index in AVFormatContext
int pts_wrap_bits
number of bits in pts (used for wrapping control)
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
unsigned int nb_ccstreams
ClosedCaptionsStream * cc_streams
AVDictionary * format_options
unsigned int master_publish_rate
VariantStream * var_streams
uint32_t start_sequence_source_type
AVIOContext * sub_m3u8_out
char key_string[KEYSIZE *2+1]
char * fmp4_init_filename
char key_uri[LINE_BUFFER_SIZE+1]
int use_localtime_mkdir
flag to mkdir dirname in timebased filename
char * vtt_format_options_str
int use_localtime
flag to expand filename with localtime
unsigned int nb_varstreams
int resend_init_file
resend init file into disk after refresh m3u8
char iv_string[KEYSIZE *2+1]
AVDictionary * vtt_format_options
char key_file[LINE_BUFFER_SIZE+1]
char filename[MAX_URL_SIZE]
double discont_program_date_time
char key_uri[LINE_BUFFER_SIZE+1]
char sub_filename[MAX_URL_SIZE]
char iv_string[KEYSIZE *2+1]
char key_file[LINE_BUFFER_SIZE+1]
double initial_prog_date_time
HLSSegment * old_segments
int64_t video_keyframe_size
AVIOContext * out_single_file
int reference_stream_index
char * fmp4_init_filename
char key_string[KEYSIZE *2+1]
ff_const59 AVOutputFormat * vtt_oformat
char key_uri[LINE_BUFFER_SIZE+1]
AVFormatContext * vtt_avf
int64_t video_keyframe_pos
char * base_output_dirname
CodecAttributeStatus attr_status
char current_segment_final_filename_fmt[MAX_URL_SIZE]
char iv_string[KEYSIZE *2+1]
HLSSegment * last_segment
ff_const59 AVOutputFormat * oformat
int64_t av_gettime(void)
Get the current time in microseconds.
static int write_trailer(AVFormatContext *s1)