Go to the documentation of this file.
30 #include "config_components.h"
49 #define INITIAL_BUFFER_SIZE 32768
51 #define MAX_FIELD_LEN 64
52 #define MAX_CHARACTERISTICS_LEN 512
54 #define MPEG_TIME_BASE 90000
55 #define MPEG_TIME_BASE_Q (AVRational){1, MPEG_TIME_BASE}
235 for (
i = 0;
i < n_segments;
i++) {
264 for (
i = 0;
i <
c->n_playlists;
i++) {
293 for (
i = 0;
i <
c->n_variants;
i++) {
305 for (
i = 0;
i <
c->n_renditions;
i++)
346 const char *
url,
const char *
base)
372 int key_len,
char **dest,
int *dest_len)
374 if (!strncmp(
key,
"BANDWIDTH=", key_len)) {
375 *dest =
info->bandwidth;
376 *dest_len =
sizeof(
info->bandwidth);
377 }
else if (!strncmp(
key,
"AUDIO=", key_len)) {
379 *dest_len =
sizeof(
info->audio);
380 }
else if (!strncmp(
key,
"VIDEO=", key_len)) {
382 *dest_len =
sizeof(
info->video);
383 }
else if (!strncmp(
key,
"SUBTITLES=", key_len)) {
384 *dest =
info->subtitles;
385 *dest_len =
sizeof(
info->subtitles);
396 int key_len,
char **dest,
int *dest_len)
398 if (!strncmp(
key,
"METHOD=", key_len)) {
399 *dest =
info->method;
400 *dest_len =
sizeof(
info->method);
401 }
else if (!strncmp(
key,
"URI=", key_len)) {
403 *dest_len =
sizeof(
info->uri);
404 }
else if (!strncmp(
key,
"IV=", key_len)) {
406 *dest_len =
sizeof(
info->iv);
417 const char *url_base)
444 if (
info->byterange[0]) {
446 ptr = strchr(
info->byterange,
'@');
460 int key_len,
char **dest,
int *dest_len)
462 if (!strncmp(
key,
"URI=", key_len)) {
464 *dest_len =
sizeof(
info->uri);
465 }
else if (!strncmp(
key,
"BYTERANGE=", key_len)) {
466 *dest =
info->byterange;
467 *dest_len =
sizeof(
info->byterange);
484 const char *url_base)
488 char *characteristic;
492 if (!strcmp(
info->type,
"AUDIO"))
494 else if (!strcmp(
info->type,
"VIDEO"))
496 else if (!strcmp(
info->type,
"SUBTITLES"))
498 else if (!strcmp(
info->type,
"CLOSED-CAPTIONS"))
540 if (
info->assoc_language[0]) {
541 int langlen = strlen(rend->
language);
542 if (langlen <
sizeof(rend->
language) - 3) {
544 strncpy(rend->
language + langlen + 1,
info->assoc_language,
545 sizeof(rend->
language) - langlen - 2);
549 if (!strcmp(
info->defaultr,
"YES"))
551 if (!strcmp(
info->forced,
"YES"))
554 chr_ptr =
info->characteristics;
555 while ((characteristic =
av_strtok(chr_ptr,
",", &saveptr))) {
556 if (!strcmp(characteristic,
"public.accessibility.describes-music-and-sound"))
558 else if (!strcmp(characteristic,
"public.accessibility.describes-video"))
568 int key_len,
char **dest,
int *dest_len)
570 if (!strncmp(
key,
"TYPE=", key_len)) {
572 *dest_len =
sizeof(
info->type);
573 }
else if (!strncmp(
key,
"URI=", key_len)) {
575 *dest_len =
sizeof(
info->uri);
576 }
else if (!strncmp(
key,
"GROUP-ID=", key_len)) {
577 *dest =
info->group_id;
578 *dest_len =
sizeof(
info->group_id);
579 }
else if (!strncmp(
key,
"LANGUAGE=", key_len)) {
580 *dest =
info->language;
581 *dest_len =
sizeof(
info->language);
582 }
else if (!strncmp(
key,
"ASSOC-LANGUAGE=", key_len)) {
583 *dest =
info->assoc_language;
584 *dest_len =
sizeof(
info->assoc_language);
585 }
else if (!strncmp(
key,
"NAME=", key_len)) {
587 *dest_len =
sizeof(
info->name);
588 }
else if (!strncmp(
key,
"DEFAULT=", key_len)) {
589 *dest =
info->defaultr;
590 *dest_len =
sizeof(
info->defaultr);
591 }
else if (!strncmp(
key,
"FORCED=", key_len)) {
592 *dest =
info->forced;
593 *dest_len =
sizeof(
info->forced);
594 }
else if (!strncmp(
key,
"CHARACTERISTICS=", key_len)) {
595 *dest =
info->characteristics;
596 *dest_len =
sizeof(
info->characteristics);
617 *pls =
c->playlists[
c->n_playlists - 1];
624 #if !CONFIG_HTTP_PROTOCOL
630 (*pb)->eof_reached = 0;
644 const char *proto_name =
NULL;
649 if (url[6] ==
'+' || url[6] ==
':')
652 if (url[4] ==
'+' || url[4] ==
':')
664 if (strcmp(
c->allowed_extensions,
"ALL") && !
av_match_ext(url,
c->allowed_extensions)) {
666 "Filename extension of \'%s\' is not a common multimedia extension, blocked for security reasons.\n"
667 "If you wish to override this adjust allowed_extensions, you can set it to \'ALL\' to allow all\n",
678 if (!strncmp(proto_name, url, strlen(proto_name)) && url[strlen(proto_name)] ==
':')
680 else if (
av_strstart(url,
"crypto",
NULL) && !strncmp(proto_name, url + 7, strlen(proto_name)) && url[7 + strlen(proto_name)] ==
':')
682 else if (
av_strstart(url,
"data",
NULL) && !strncmp(proto_name, url + 5, strlen(proto_name)) && url[5 + strlen(proto_name)] ==
':')
684 else if (strcmp(proto_name,
"file") || !strncmp(url,
"file,", 5))
690 if (is_http &&
c->http_persistent && *pb) {
695 }
else if (
ret < 0) {
698 "keepalive request failed for '%s' with error: '%s' when opening url, retrying with new connection\n",
709 char *new_cookies =
NULL;
721 *is_http_out = is_http;
729 int ret = 0, is_segment = 0, is_variant = 0;
738 int64_t seg_offset = 0;
739 int64_t seg_size = -1;
740 uint8_t *new_url =
NULL;
746 int prev_n_segments = 0;
747 int64_t prev_start_seq_no = -1;
749 if (is_http && !in &&
c->http_persistent &&
c->playlist_pb) {
754 }
else if (
ret < 0) {
757 "keepalive request failed for '%s' with error: '%s' when parsing playlist\n",
767 if (
c->http_persistent)
775 if (is_http &&
c->http_persistent)
785 if (strcmp(
line,
"#EXTM3U")) {
813 if (!strcmp(
info.method,
"AES-128"))
815 if (!strcmp(
info.method,
"SAMPLE-AES"))
832 t = strtoll(ptr,
NULL, 10);
843 seq_no = strtoull(ptr,
NULL, 10);
844 if (seq_no > INT64_MAX/2) {
846 "INT64_MAX/2, mask out the highest bit\n");
847 seq_no &= INT64_MAX/2;
854 if (!strcmp(ptr,
"EVENT"))
856 else if (!strcmp(ptr,
"VOD"))
866 if (!cur_init_section) {
870 cur_init_section->
key_type = key_type;
872 memcpy(cur_init_section->
iv, iv,
sizeof(iv));
875 memset(cur_init_section->
iv, 0,
sizeof(cur_init_section->
iv));
887 if (!cur_init_section->
key) {
897 const char *time_offset_value =
NULL;
902 if (
av_strstart(ptr,
"TIME-OFFSET=", &time_offset_value)) {
903 float offset = strtof(time_offset_value,
NULL);
908 "invalid, it will be ignored");
918 seg_size = strtoll(ptr,
NULL, 10);
919 ptr = strchr(ptr,
'@');
921 seg_offset = strtoll(ptr+1,
NULL, 10);
925 }
else if (
line[0]) {
944 memcpy(seg->
iv,
iv,
sizeof(
iv));
947 memset(seg->
iv, 0,
sizeof(seg->
iv));
986 " set to default value to 1ms.\n", seg->
url);
994 seg->
size = seg_size;
997 seg_offset += seg_size;
1008 if (prev_segments) {
1010 int64_t prev_timestamp =
c->first_timestamp;
1013 for (
i = 0;
i < prev_n_segments &&
i <
diff;
i++) {
1014 c->first_timestamp += prev_segments[
i]->
duration;
1017 " reflected in first_timestamp: %"PRId64
" -> %"PRId64
"\n",
1019 prev_timestamp,
c->first_timestamp);
1035 if (!
c->n_variants || !
c->variants[0]->n_playlists ||
1036 !(
c->variants[0]->playlists[0]->finished ||
1059 uint8_t *buf,
int buf_size)
1079 static const char id3_priv_owner_ts[] =
"com.apple.streaming.transportStreamTimestamp";
1080 static const char id3_priv_owner_audio_setup[] =
"com.apple.streaming.audioDescription";
1084 for (meta = *extra_meta; meta; meta = meta->
next) {
1085 if (!strcmp(meta->
tag,
"PRIV")) {
1091 if ((ts & ~((1ULL << 33) - 1)) == 0)
1098 }
else if (!strcmp(meta->
tag,
"APIC") && apic)
1112 if (!oldentry || strcmp(oldentry->
value, entry->
value) != 0)
1176 int buf_size,
int *
len)
1181 int id3_buf_pos = 0;
1199 }
else if (*
len <= 0) {
1210 int64_t maxsize = seg->
size >= 0 ? seg->
size : 1024*1024;
1212 int tag_got_bytes =
FFMIN(taglen, *
len);
1213 int remaining = taglen - tag_got_bytes;
1215 if (taglen > maxsize) {
1231 memcpy(pls->
id3_buf + id3_buf_pos, buf, tag_got_bytes);
1232 id3_buf_pos += tag_got_bytes;
1235 *
len -= tag_got_bytes;
1236 memmove(buf, buf + tag_got_bytes, *
len);
1239 if (remaining > 0) {
1243 id3_buf_pos += remaining;
1281 if (
c->http_persistent)
1284 if (seg->
size >= 0) {
1299 if (
ret !=
sizeof(pls->
key)) {
1316 if (strstr(seg->
url,
"://"))
1360 static const int max_init_section_size = 1024*1024;
1377 "Failed to open an initialization section in playlist %d\n",
1387 sec_size = max_init_section_size;
1390 "Downloading an initialization section of size %"PRId64
"\n",
1393 sec_size =
FFMIN(sec_size, max_init_section_size);
1426 int stream_needed = 0;
1452 for (
i = 0;
i <
s->nb_programs;
i++) {
1455 for (j = 0; j <
program->nb_stream_indexes; j++) {
1456 if (
program->stream_index[j] == first_st) {
1468 static int read_data(
void *opaque, uint8_t *buf,
int buf_size)
1473 int just_opened = 0;
1474 int reload_count = 0;
1482 int64_t reload_interval;
1500 if (reload_count >
c->max_reload)
1517 "skipping %"PRId64
" segments ahead, expired from playlists\n",
1572 if (
c->http_multiple == -1) {
1573 uint8_t *http_version_opt =
NULL;
1576 c->http_multiple = (!strncmp((
const char *)http_version_opt,
"1.1", 3) || !strncmp((
const char *)http_version_opt,
"2.0", 3));
1615 if (
c->http_persistent &&
1633 for (
i = 0;
i <
c->n_renditions;
i++) {
1685 int64_t timestamp, int64_t *seq_no,
1686 int64_t *seg_start_ts)
1690 0 :
c->first_timestamp;
1692 if (timestamp <
pos) {
1702 *seg_start_ts =
pos;
1718 if (!pls->
finished && !
c->first_packet &&
1732 if (!
c->first_packet &&
1739 return c->cur_seq_no;
1743 if (
c->live_start_index < 0)
1745 c->live_start_index, 0);
1752 int64_t start_timestamp;
1753 int64_t playlist_duration = 0;
1766 start_timestamp = cur_timestamp + playlist_duration;
1772 start_timestamp = cur_timestamp;
1775 start_timestamp = cur_timestamp + playlist_duration +
1778 start_timestamp = cur_timestamp;
1793 "A HLS playlist item '%s' referred to an external file '%s'. "
1794 "Opening this file was forbidden for security reasons\n",
1805 for (
i = 0;
i <
c->n_variants;
i++) {
1849 memcpy(dst_data, sd_src->
data, sd_src->
size);
1886 int flag_needed = 0;
1889 for (
i = 0;
i <
c->n_playlists;
i++) {
1912 if (
c->crypto_ctx.aes_ctx)
1925 int64_t highest_cur_seq_no = 0;
1928 c->interrupt_callback = &
s->interrupt_callback;
1930 c->first_packet = 1;
1945 if (
c->n_variants == 0) {
1951 if (
c->n_playlists > 1 ||
c->playlists[0]->n_segments == 0) {
1952 for (
i = 0;
i <
c->n_playlists;
i++) {
1958 if (
c->n_playlists > 1)
1965 for (
i = 0;
i <
c->n_variants;
i++) {
1966 if (
c->variants[
i]->playlists[0]->n_segments == 0) {
1968 c->variants[
i]->playlists[0]->broken = 1;
1974 if (
c->variants[0]->playlists[0]->finished) {
1976 for (
i = 0;
i <
c->variants[0]->playlists[0]->n_segments;
i++)
1977 duration +=
c->variants[0]->playlists[0]->segments[
i]->duration;
1982 for (
i = 0;
i <
c->n_variants;
i++) {
1994 for (
i = 0;
i <
c->n_variants;
i++) {
2005 for (
i = 0;
i <
c->n_playlists;
i++) {
2016 for (
i = 0;
i <
c->n_playlists;
i++) {
2041 highest_cur_seq_no < pls->start_seq_no + pls->
n_segments) {
2100 pls->
ctx->
probesize =
s->probesize > 0 ?
s->probesize : 1024 * 4;
2120 if (strstr(in_fmt->
name,
"mov")) {
2124 }
else if (!
c->crypto_ctx.aes_ctx) {
2126 if (!
c->crypto_ctx.aes_ctx) {
2206 for (
i = 0;
i <
c->n_playlists;
i++) {
2214 if (cur_needed && !pls->
needed) {
2273 int64_t ts_b,
struct playlist *pls_b)
2284 int ret,
i, minplaylist = -1;
2287 c->first_packet = 0;
2289 for (
i = 0;
i <
c->n_playlists;
i++) {
2319 memcpy(
c->crypto_ctx.iv, seg->
iv,
sizeof(seg->
iv));
2320 memcpy(
c->crypto_ctx.key, pls->
key,
sizeof(pls->
key));
2350 struct playlist *minpls = minplaylist < 0 ?
2351 NULL :
c->playlists[minplaylist];
2352 if (minplaylist < 0) {
2355 int64_t dts = pls->
pkt->
dts;
2356 int64_t mindts = minpls->
pkt->
dts;
2366 if (minplaylist >= 0) {
2367 struct playlist *pls =
c->playlists[minplaylist];
2395 av_log(
s,
AV_LOG_ERROR,
"stream index inconsistency: index %d, %d main streams, %d subdemuxer streams\n",
2427 int64_t timestamp,
int flags)
2432 int stream_subdemuxer_index;
2434 int64_t seq_no, seg_start_ts;
2440 0 :
c->first_timestamp;
2443 s->streams[stream_index]->time_base.den,
2453 for (
i = 0;
i <
c->n_playlists;
i++) {
2458 stream_subdemuxer_index = j;
2479 for (
i = 0;
i <
c->n_playlists;
i++) {
2488 pb->eof_reached = 0;
2490 pb->buf_end =
pb->buf_ptr =
pb->buffer;
2499 if (pls != seek_pls) {
2519 if (strncmp(p->
buf,
"#EXTM3U", 7))
2522 if (strstr(p->
buf,
"#EXT-X-STREAM-INF:") ||
2523 strstr(p->
buf,
"#EXT-X-TARGETDURATION:") ||
2524 strstr(p->
buf,
"#EXT-X-MEDIA-SEQUENCE:"))
2529 #define OFFSET(x) offsetof(HLSContext, x)
2530 #define FLAGS AV_OPT_FLAG_DECODING_PARAM
2532 {
"live_start_index",
"segment index to start live streams at (negative values are from the end)",
2534 {
"prefer_x_start",
"prefer to use #EXT-X-START if it's in playlist instead of live_start_index",
2536 {
"allowed_extensions",
"List of file extensions that hls is allowed to access",
2538 {.str =
"3gp,aac,avi,ac3,eac3,flac,mkv,m3u8,m4a,m4s,m4v,mpg,mov,mp2,mp3,mp4,mpeg,mpegts,ogg,ogv,oga,ts,vob,wav"},
2539 INT_MIN, INT_MAX,
FLAGS},
2540 {
"max_reload",
"Maximum number of times a insufficient list is attempted to be reloaded",
2542 {
"m3u8_hold_counters",
"The maximum number of times to load m3u8 when it refreshes without new segments",
2544 {
"http_persistent",
"Use persistent HTTP connections",
2546 {
"http_multiple",
"Use multiple HTTP connections for fetching segments",
2548 {
"http_seekable",
"Use HTTP partial requests, 0 = disable, 1 = enable, -1 = auto",
2550 {
"seg_format_options",
"Set options for segment demuxer",
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.
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
int64_t av_gettime_relative(void)
Get the current time in microseconds since some unspecified starting point.
#define AV_LOG_WARNING
Something somehow does not look correct.
#define MAX_CHARACTERISTICS_LEN
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C program
int ffio_copy_url_options(AVIOContext *pb, AVDictionary **avio_opts)
Read url related dictionary options from the AVIOContext and write to the given dictionary.
static void free_segment_dynarray(struct segment **segments, int n_segments)
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
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
enum AVMediaType codec_type
General type of the encoded data.
#define AVERROR_EOF
End of file.
uint8_t * data
The data buffer.
enum AVDiscard discard
Selects which packets can be discarded at will and do not need to be demuxed.
char subtitles[MAX_FIELD_LEN]
int64_t id3_mpegts_timestamp
static struct segment * new_init_section(struct playlist *pls, struct init_section_info *info, const char *url_base)
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
char assoc_language[MAX_FIELD_LEN]
static av_cold void cleanup(FlashSV2Context *s)
AVStream ** streams
A list of all streams in the file.
char subtitles_group[MAX_FIELD_LEN]
static int compare_ts_with_wrapdetect(int64_t ts_a, struct playlist *pls_a, int64_t ts_b, struct playlist *pls_b)
struct segment ** segments
static int nested_io_open(AVFormatContext *s, AVIOContext **pb, const char *url, int flags, AVDictionary **opts)
#define AV_LOG_VERBOSE
Detailed information.
uint8_t setup_data_length
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
#define FF_COMPLIANCE_EXPERIMENTAL
Allow nonstandardized experimental things.
int64_t probesize
Maximum number of bytes read from input in order to determine stream properties.
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
Return the next frame of a stream.
void ff_read_frame_flush(AVFormatContext *s)
Flush the frame reader.
int64_t avio_size(AVIOContext *s)
Get the filesize.
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
char key_url[MAX_URL_SIZE]
int64_t start_time_offset
void av_packet_free(AVPacket **pkt)
Free the packet, if the packet is reference counted, it will be unreferenced first.
Callback for checking whether to abort blocking functions.
int avformat_queue_attached_pictures(AVFormatContext *s)
static int hls_close(AVFormatContext *s)
void avformat_close_input(AVFormatContext **s)
Close an opened input AVFormatContext.
AVIOInterruptCB interrupt_callback
Custom interrupt callbacks for the I/O layer.
char audio_group[MAX_FIELD_LEN]
static int recheck_discard_flags(AVFormatContext *s, int first)
static const AVClass hls_class
static struct variant * new_variant(HLSContext *c, struct variant_info *info, const char *url, const char *base)
static int read_seek(AVFormatContext *ctx, int stream_index, int64_t timestamp, int flags)
static av_cold int read_close(AVFormatContext *ctx)
int64_t pos
position in the file of the current buffer
void ff_hls_senc_read_audio_setup_info(HLSAudioSetupInfo *info, const uint8_t *buf, size_t size)
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 type
AVProgram * av_new_program(AVFormatContext *ac, int id)
int ff_check_interrupt(AVIOInterruptCB *cb)
Check if the user has requested to interrupt a blocking function associated with cb.
#define HLS_MAX_ID3_TAGS_DATA_LEN
static void handle_rendition_args(struct rendition_info *info, const char *key, int key_len, char **dest, int *dest_len)
int event_flags
Flags indicating events happening on the file, a combination of AVFMT_EVENT_FLAG_*.
AVPacket attached_pic
For streams with AV_DISPOSITION_ATTACHED_PIC disposition, this packet will contain the attached pictu...
#define AV_DICT_DONT_STRDUP_VAL
Take ownership of a value that's been allocated with av_malloc() or another memory allocation functio...
static int open_url(AVFormatContext *s, AVIOContext **pb, const char *url, AVDictionary **opts, AVDictionary *opts2, int *is_http_out)
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But first
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
AVDictionary * metadata
Metadata that applies to the whole file.
int ctx_flags
Flags signalling stream properties.
static void free_rendition_list(HLSContext *c)
int avformat_open_input(AVFormatContext **ps, const char *url, const AVInputFormat *fmt, AVDictionary **options)
Open an input stream and read the header.
static const AVOption hls_options[]
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
static void fill_timing_for_id3_timestamped_stream(struct playlist *pls)
void * av_fast_realloc(void *ptr, unsigned int *size, size_t min_size)
Reallocate the given buffer if it is not large enough, otherwise do nothing.
static int playlist_needed(struct playlist *pls)
int flags
Flags modifying the (de)muxer behaviour.
const struct AVInputFormat * iformat
The input container format.
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
unsigned int init_sec_buf_read_offset
char video[MAX_FIELD_LEN]
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().
int av_match_ext(const char *filename, const char *extensions)
Return a positive value if the given filename has one of the given extensions, 0 otherwise.
#define av_assert0(cond)
assert() equivalent, that is always enabled.
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
char audio[MAX_FIELD_LEN]
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
struct segment ** init_sections
static void add_renditions_to_variant(HLSContext *c, struct variant *var, enum AVMediaType type, const char *group_id)
char * allowed_extensions
HLSCryptoContext crypto_ctx
int av_usleep(unsigned usec)
Sleep for a period of time.
unsigned int id3_buf_size
AVDictionary * seg_format_opts
static int hls_read_header(AVFormatContext *s)
int64_t max_analyze_duration
Maximum duration (in AV_TIME_BASE units) of the data read from input in avformat_find_stream_info().
static void handle_id3(AVIOContext *pb, struct playlist *pls)
static void free_variant_list(HLSContext *c)
char group_id[MAX_FIELD_LEN]
@ AVDISCARD_ALL
discard all
AVIOInterruptCB * interrupt_callback
AVCodecParameters * codecpar
Codec parameters associated with this stream.
#define LIBAVUTIL_VERSION_INT
static int read_header(FFV1Context *f)
static struct segment * current_segment(struct playlist *pls)
Describe the class of an AVClass context structure.
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
struct playlist ** playlists
static int ensure_playlist(HLSContext *c, struct playlist **pls, const char *url)
static void fill_buf(uint8_t *data, int w, int h, int linesize, uint8_t v)
struct rendition ** renditions
AVIOContext * playlist_pb
Rational number (pair of numerator and denominator).
enum AVPacketSideDataType type
static void free_init_section_list(struct playlist *pls)
struct variant ** variants
static int update_streams_from_subdemuxer(AVFormatContext *s, struct playlist *pls)
const char * av_default_item_name(void *ptr)
Return the context name.
int ff_id3v2_parse_apic(AVFormatContext *s, ID3v2ExtraMeta *extra_meta)
Create a stream for each APIC (attached picture) extracted from the ID3v2 header.
AVIOContext * pb
I/O context.
int ff_http_do_new_request2(URLContext *h, const char *uri, AVDictionary **opts)
Send a new HTTP request, reusing the old connection.
This structure contains the data a format has to probe a file.
struct AVAES * av_aes_alloc(void)
Allocate an AVAES context.
ID3v2ExtraMeta * id3_deferred_extra
struct playlist ** playlists
void av_packet_move_ref(AVPacket *dst, AVPacket *src)
Move every field in src to dst and reset src.
static void handle_init_section_args(struct init_section_info *info, const char *key, int key_len, char **dest, int *dest_len)
#define INITIAL_BUFFER_SIZE
#define ID3v2_HEADER_SIZE
static int id3_has_changed_values(struct playlist *pls, AVDictionary *metadata, ID3v2ExtraMetaAPIC *apic)
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
AVCodecID
Identify the syntax and semantics of the bitstream.
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
int av_strncasecmp(const char *a, const char *b, size_t n)
Locale-independent case-insensitive compare.
unsigned int init_sec_buf_size
int64_t av_rescale_rnd(int64_t a, int64_t b, int64_t c, enum AVRounding rnd)
Rescale a 64-bit integer with specified rounding.
const OptionDef options[]
int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
Read packets of a media file to get stream information.
struct segment * cur_init_section
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
AVFormatContext * avformat_alloc_context(void)
Allocate an AVFormatContext.
unsigned char * buf_end
End of the data, may be less than buffer+buffer_size if the read function returned less data than req...
static struct rendition * new_rendition(HLSContext *c, struct rendition_info *info, const char *url_base)
#define av_err2str(errnum)
Convenience macro, the return value should be used only directly in function arguments but never stan...
#define ID3v2_DEFAULT_MAGIC
Default magic bytes for ID3v2 header: "ID3".
#define AV_NOPTS_VALUE
Undefined timestamp value.
void avpriv_report_missing_feature(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
int event_flags
Flags indicating events happening on the stream, a combination of AVSTREAM_EVENT_FLAG_*.
char characteristics[MAX_CHARACTERISTICS_LEN]
const AVInputFormat * av_demuxer_iterate(void **opaque)
Iterate over all registered demuxers.
@ AVMEDIA_TYPE_UNKNOWN
Usually treated as AVMEDIA_TYPE_DATA.
static AVRational get_timebase(struct playlist *pls)
static av_always_inline int diff(const struct color_info *a, const struct color_info *b, const int trans_thresh)
#define AV_OPT_SEARCH_CHILDREN
Search in possible children of the given object first.
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
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 offset
static int update_init_section(struct playlist *pls, struct segment *seg)
int flags
A combination of AV_PKT_FLAG values.
AVPacket * av_packet_alloc(void)
Allocate an AVPacket and set its fields to default values.
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values.
int av_strstart(const char *str, const char *pfx, const char **ptr)
Return non-zero if pfx is a prefix of str.
int av_probe_input_buffer(AVIOContext *pb, const AVInputFormat **fmt, const char *url, void *logctx, unsigned int offset, unsigned int max_probe_size)
Like av_probe_input_buffer2() but returns 0 on success.
static int read_data(void *opaque, uint8_t *buf, int buf_size)
struct playlist * playlist
size_t size
Size of data in bytes.
#define AV_LOG_INFO
Standard information.
static void free_segment_list(struct playlist *pls)
AVPacketSideData * side_data
An array of side data that applies to the whole stream (i.e.
int ff_hls_senc_decrypt_frame(enum AVCodecID codec_id, HLSCryptoContext *crypto_ctx, AVPacket *pkt)
static void add_metadata_from_renditions(AVFormatContext *s, struct playlist *pls, enum AVMediaType type)
static struct segment * next_segment(struct playlist *pls)
static void update_noheader_flag(AVFormatContext *s)
#define i(width, name, range_min, range_max)
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
#define AV_TIME_BASE
Internal time base represented as integer.
void ffio_init_context(FFIOContext *s, unsigned char *buffer, int buffer_size, int write_flag, void *opaque, int(*read_packet)(void *opaque, uint8_t *buf, int buf_size), int(*write_packet)(void *opaque, uint8_t *buf, int buf_size), int64_t(*seek)(void *opaque, int64_t offset, int whence))
void ff_id3v2_read_dict(AVIOContext *pb, AVDictionary **metadata, const char *magic, ID3v2ExtraMeta **extra_meta)
Read an ID3v2 tag into specified dictionary and retrieve supported extra metadata.
static int64_t select_cur_seq_no(HLSContext *c, struct playlist *pls)
char video_group[MAX_FIELD_LEN]
@ AV_ROUND_DOWN
Round toward -infinity.
static int64_t default_reload_interval(struct playlist *pls)
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
New fields can be added to the end with minor version bumps.
static int open_url_keepalive(AVFormatContext *s, AVIOContext **pb, const char *url, AVDictionary **options)
static void free_playlist_list(HLSContext *c)
int ff_hls_senc_parse_audio_setup_info(AVStream *st, HLSAudioSetupInfo *info)
char language[MAX_FIELD_LEN]
int disposition
Stream disposition - a combination of AV_DISPOSITION_* flags.
int ff_id3v2_tag_len(const uint8_t *buf)
Get the length of an ID3v2 tag.
int64_t av_compare_mod(uint64_t a, uint64_t b, uint64_t mod)
Compare the remainders of two integer operands divided by a common divisor.
int id
Format-specific stream ID.
static int read_packet(void *opaque, uint8_t *buf, int buf_size)
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
#define FFSWAP(type, a, b)
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 nb_side_data
The number of elements in the AVStream.side_data array.
HLSAudioSetupInfo audio_setup_info
#define AV_INPUT_BUFFER_PADDING_SIZE
#define AV_DICT_MATCH_CASE
Only get an entry with exact-case key match.
static int open_input(HLSContext *c, struct playlist *pls, struct segment *seg, AVIOContext **in)
static int hls_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
static struct playlist * new_playlist(HLSContext *c, const char *url, const char *base)
static int set_stream_info_from_input_stream(AVStream *st, struct playlist *pls, AVStream *ist)
int index
stream index in AVFormatContext
AVDictionary * id3_initial
static int parse_playlist(HLSContext *c, const char *url, struct playlist *pls, AVIOContext *in)
void avformat_free_context(AVFormatContext *s)
Free an AVFormatContext and all its streams.
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
int(* io_open)(struct AVFormatContext *s, AVIOContext **pb, const char *url, int flags, AVDictionary **options)
A callback for opening new IO streams.
int eof_reached
true if was unable to read due to error or eof
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 AVIO_FLAG_READ
read-only
static void add_stream_to_programs(AVFormatContext *s, struct playlist *pls, AVStream *stream)
char * av_strdup(const char *s)
Duplicate a string.
static int hls_probe(const AVProbeData *p)
unsigned int init_sec_data_len
static int hls_read_packet(AVFormatContext *s, AVPacket *pkt)
unsigned char * buffer
Start of the buffer.
static void handle_variant_args(struct variant_info *info, const char *key, int key_len, char **dest, int *dest_len)
static int find_timestamp_in_playlist(HLSContext *c, struct playlist *pls, int64_t timestamp, int64_t *seq_no, int64_t *seg_start_ts)
int ff_make_absolute_url(char *buf, int size, const char *base, const char *rel)
Convert a relative url into an absolute url, given a base url.
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
This structure stores compressed data.
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
void av_fast_malloc(void *ptr, unsigned int *size, size_t min_size)
Allocate a buffer, reusing the given one if large enough.
int av_dict_copy(AVDictionary **dst, const AVDictionary *src, int flags)
Copy entries from one AVDictionary struct into another.
void ff_id3v2_free_extra_meta(ID3v2ExtraMeta **extra_meta)
Free memory allocated parsing special (non-text) metadata.
struct segment * init_section
uint8_t * av_stream_new_side_data(AVStream *st, enum AVPacketSideDataType type, size_t size)
Allocate new information from stream.
const char * avio_find_protocol_name(const char *url)
Return the name of the protocol that will handle the passed URL.
int need_context_update
Whether the internal avctx needs to be updated from codecpar (after a late change to codecpar)
#define flags(name, subs,...)
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
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.
int av_opt_get(void *obj, const char *name, int search_flags, uint8_t **out_val)
int ff_id3v2_parse_priv(AVFormatContext *s, ID3v2ExtraMeta *extra_meta)
Add metadata for all PRIV tags in the ID3v2 header.
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
#define AVERROR_EXIT
Immediate exit was requested; the called function should not be restarted.
static void handle_key_args(struct key_info *info, const char *key, int key_len, char **dest, int *dest_len)
int pts_wrap_bits
Number of bits in timestamps.
static void parse_id3(AVFormatContext *s, AVIOContext *pb, AVDictionary **metadata, int64_t *dts, HLSAudioSetupInfo *audio_setup_info, ID3v2ExtraMetaAPIC **apic, ID3v2ExtraMeta **extra_meta)
unsigned char * buf_ptr
Current position in the buffer.
static int read_from_url(struct playlist *pls, struct segment *seg, uint8_t *buf, int buf_size)
int ff_id3v2_parse_priv_dict(AVDictionary **metadata, ID3v2ExtraMeta *extra_meta)
Parse PRIV tags into a dictionary.
#define AVERROR_PROTOCOL_NOT_FOUND
Protocol not found.
void * priv_data
Format private data.
static void intercept_id3(struct playlist *pls, uint8_t *buf, int buf_size, int *len)
char language[MAX_FIELD_LEN]
URLContext * ffio_geturlcontext(AVIOContext *s)
Return the URLContext associated with the AVIOContext.
const AVDictionaryEntry * av_dict_iterate(const AVDictionary *m, const AVDictionaryEntry *prev)
Iterate over a dictionary.
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_RB64
struct rendition ** renditions
char group_id[MAX_FIELD_LEN]
int ff_id3v2_match(const uint8_t *buf, const char *magic)
Detect ID3v2 Header.
int avcodec_parameters_copy(AVCodecParameters *dst, const AVCodecParameters *src)
Copy the contents of src to dst.
const AVInputFormat ff_hls_demuxer
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.