FFmpeg
hls.c
Go to the documentation of this file.
1 /*
2  * Apple HTTP Live Streaming demuxer
3  * Copyright (c) 2010 Martin Storsjo
4  * Copyright (c) 2013 Anssi Hannula
5  * Copyright (c) 2021 Nachiket Tarate
6  *
7  * This file is part of FFmpeg.
8  *
9  * FFmpeg is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Lesser General Public
11  * License as published by the Free Software Foundation; either
12  * version 2.1 of the License, or (at your option) any later version.
13  *
14  * FFmpeg is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17  * Lesser General Public License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public
20  * License along with FFmpeg; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22  */
23 
24 /**
25  * @file
26  * Apple HTTP Live Streaming demuxer
27  * https://www.rfc-editor.org/rfc/rfc8216.txt
28  */
29 
30 #include "config_components.h"
31 
32 #include "libavformat/http.h"
33 #include "libavutil/aes.h"
34 #include "libavutil/avstring.h"
35 #include "libavutil/avassert.h"
36 #include "libavutil/intreadwrite.h"
37 #include "libavutil/mathematics.h"
38 #include "libavutil/opt.h"
39 #include "libavutil/dict.h"
40 #include "libavutil/time.h"
41 #include "avformat.h"
42 #include "demux.h"
43 #include "internal.h"
44 #include "avio_internal.h"
45 #include "id3v2.h"
46 #include "url.h"
47 
48 #include "hls_sample_encryption.h"
49 
50 #define INITIAL_BUFFER_SIZE 32768
51 
52 #define MAX_FIELD_LEN 64
53 #define MAX_CHARACTERISTICS_LEN 512
54 
55 #define MPEG_TIME_BASE 90000
56 #define MPEG_TIME_BASE_Q (AVRational){1, MPEG_TIME_BASE}
57 
58 /*
59  * An apple http stream consists of a playlist with media segment files,
60  * played sequentially. There may be several playlists with the same
61  * video content, in different bandwidth variants, that are played in
62  * parallel (preferably only one bandwidth variant at a time). In this case,
63  * the user supplied the url to a main playlist that only lists the variant
64  * playlists.
65  *
66  * If the main playlist doesn't point at any variants, we still create
67  * one anonymous toplevel variant for this, to maintain the structure.
68  */
69 
70 enum KeyType {
74 };
75 
76 struct segment {
77  int64_t duration;
78  int64_t url_offset;
79  int64_t size;
80  char *url;
81  char *key;
83  uint8_t iv[16];
84  /* associated Media Initialization Section, treated as a segment */
86 };
87 
88 struct rendition;
89 
94 };
95 
96 /*
97  * Each playlist has its own demuxer. If it currently is active,
98  * it has an open AVIOContext too, and potentially an AVPacket
99  * containing the next packet from this stream.
100  */
101 struct playlist {
104  uint8_t* read_buffer;
110  int index;
114 
115  /* main demuxer streams associated with this playlist
116  * indexed by the subdemuxer stream indexes */
119 
120  int finished;
123  int64_t start_seq_no;
127  struct segment **segments;
128  int needed;
129  int broken;
130  int64_t cur_seq_no;
131  int64_t last_seq_no;
133  int64_t cur_seg_offset;
134  int64_t last_load_time;
135 
136  /* Currently active Media Initialization Section */
138  uint8_t *init_sec_buf;
139  unsigned int init_sec_buf_size;
140  unsigned int init_sec_data_len;
142 
144  uint8_t key[16];
145 
146  /* ID3 timestamp handling (elementary audio streams have ID3 timestamps
147  * (and possibly other ID3 tags) in the beginning of each segment) */
148  int is_id3_timestamped; /* -1: not yet known */
149  int64_t id3_mpegts_timestamp; /* in mpegts tb */
150  int64_t id3_offset; /* in stream original tb */
151  uint8_t* id3_buf; /* temp buffer for id3 parsing */
152  unsigned int id3_buf_size;
153  AVDictionary *id3_initial; /* data from first id3 tag */
154  int id3_found; /* ID3 tag found at some point */
155  int id3_changed; /* ID3 tag data has changed at some point */
156  ID3v2ExtraMeta *id3_deferred_extra; /* stored here until subdemuxer is opened */
157 
159 
160  int64_t seek_timestamp;
162  int seek_stream_index; /* into subdemuxer stream array */
163 
164  /* Renditions associated with this playlist, if any.
165  * Alternative rendition playlists have a single rendition associated
166  * with them, and variant main Media Playlists may have
167  * multiple (playlist-less) renditions associated with them. */
170 
171  /* Media Initialization Sections (EXT-X-MAP) associated with this
172  * playlist, if any. */
175 };
176 
177 /*
178  * Renditions are e.g. alternative subtitle or audio streams.
179  * The rendition may either be an external playlist or it may be
180  * contained in the main Media Playlist of the variant (in which case
181  * playlist is NULL).
182  */
183 struct rendition {
190 };
191 
192 struct variant {
194 
195  /* every variant contains at least the main Media Playlist in index 0 */
197  struct playlist **playlists;
198 
202 };
203 
204 typedef struct HLSContext {
205  AVClass *class;
208  struct variant **variants;
210  struct playlist **playlists;
213 
214  int64_t cur_seq_no;
220  int64_t cur_timestamp;
232 } HLSContext;
233 
234 static void free_segment_dynarray(struct segment **segments, int n_segments)
235 {
236  int i;
237  for (i = 0; i < n_segments; i++) {
238  av_freep(&segments[i]->key);
239  av_freep(&segments[i]->url);
240  av_freep(&segments[i]);
241  }
242 }
243 
244 static void free_segment_list(struct playlist *pls)
245 {
247  av_freep(&pls->segments);
248  pls->n_segments = 0;
249 }
250 
251 static void free_init_section_list(struct playlist *pls)
252 {
253  int i;
254  for (i = 0; i < pls->n_init_sections; i++) {
255  av_freep(&pls->init_sections[i]->key);
256  av_freep(&pls->init_sections[i]->url);
257  av_freep(&pls->init_sections[i]);
258  }
259  av_freep(&pls->init_sections);
260  pls->n_init_sections = 0;
261 }
262 
264 {
265  int i;
266  for (i = 0; i < c->n_playlists; i++) {
267  struct playlist *pls = c->playlists[i];
268  free_segment_list(pls);
270  av_freep(&pls->main_streams);
271  av_freep(&pls->renditions);
272  av_freep(&pls->id3_buf);
273  av_dict_free(&pls->id3_initial);
275  av_freep(&pls->init_sec_buf);
276  av_packet_free(&pls->pkt);
277  av_freep(&pls->pb.pub.buffer);
278  ff_format_io_close(c->ctx, &pls->input);
279  pls->input_read_done = 0;
280  ff_format_io_close(c->ctx, &pls->input_next);
281  pls->input_next_requested = 0;
282  if (pls->ctx) {
283  pls->ctx->pb = NULL;
284  avformat_close_input(&pls->ctx);
285  }
286  av_free(pls);
287  }
288  av_freep(&c->playlists);
289  c->n_playlists = 0;
290 }
291 
293 {
294  int i;
295  for (i = 0; i < c->n_variants; i++) {
296  struct variant *var = c->variants[i];
297  av_freep(&var->playlists);
298  av_free(var);
299  }
300  av_freep(&c->variants);
301  c->n_variants = 0;
302 }
303 
305 {
306  int i;
307  for (i = 0; i < c->n_renditions; i++)
308  av_freep(&c->renditions[i]);
309  av_freep(&c->renditions);
310  c->n_renditions = 0;
311 }
312 
313 static struct playlist *new_playlist(HLSContext *c, const char *url,
314  const char *base)
315 {
316  struct playlist *pls = av_mallocz(sizeof(struct playlist));
317  if (!pls)
318  return NULL;
319  pls->pkt = av_packet_alloc();
320  if (!pls->pkt) {
321  av_free(pls);
322  return NULL;
323  }
324  ff_make_absolute_url(pls->url, sizeof(pls->url), base, url);
325  if (!pls->url[0]) {
326  av_packet_free(&pls->pkt);
327  av_free(pls);
328  return NULL;
329  }
331 
332  pls->is_id3_timestamped = -1;
334 
335  dynarray_add(&c->playlists, &c->n_playlists, pls);
336  return pls;
337 }
338 
339 struct variant_info {
340  char bandwidth[20];
341  /* variant group ids: */
345 };
346 
347 static struct variant *new_variant(HLSContext *c, struct variant_info *info,
348  const char *url, const char *base)
349 {
350  struct variant *var;
351  struct playlist *pls;
352 
353  pls = new_playlist(c, url, base);
354  if (!pls)
355  return NULL;
356 
357  var = av_mallocz(sizeof(struct variant));
358  if (!var)
359  return NULL;
360 
361  if (info) {
362  var->bandwidth = atoi(info->bandwidth);
363  strcpy(var->audio_group, info->audio);
364  strcpy(var->video_group, info->video);
365  strcpy(var->subtitles_group, info->subtitles);
366  }
367 
368  dynarray_add(&c->variants, &c->n_variants, var);
369  dynarray_add(&var->playlists, &var->n_playlists, pls);
370  return var;
371 }
372 
373 static void handle_variant_args(struct variant_info *info, const char *key,
374  int key_len, char **dest, int *dest_len)
375 {
376  if (!strncmp(key, "BANDWIDTH=", key_len)) {
377  *dest = info->bandwidth;
378  *dest_len = sizeof(info->bandwidth);
379  } else if (!strncmp(key, "AUDIO=", key_len)) {
380  *dest = info->audio;
381  *dest_len = sizeof(info->audio);
382  } else if (!strncmp(key, "VIDEO=", key_len)) {
383  *dest = info->video;
384  *dest_len = sizeof(info->video);
385  } else if (!strncmp(key, "SUBTITLES=", key_len)) {
386  *dest = info->subtitles;
387  *dest_len = sizeof(info->subtitles);
388  }
389 }
390 
391 struct key_info {
393  char method[11];
394  char iv[35];
395 };
396 
397 static void handle_key_args(struct key_info *info, const char *key,
398  int key_len, char **dest, int *dest_len)
399 {
400  if (!strncmp(key, "METHOD=", key_len)) {
401  *dest = info->method;
402  *dest_len = sizeof(info->method);
403  } else if (!strncmp(key, "URI=", key_len)) {
404  *dest = info->uri;
405  *dest_len = sizeof(info->uri);
406  } else if (!strncmp(key, "IV=", key_len)) {
407  *dest = info->iv;
408  *dest_len = sizeof(info->iv);
409  }
410 }
411 
414  char byterange[32];
415 };
416 
417 static struct segment *new_init_section(struct playlist *pls,
418  struct init_section_info *info,
419  const char *url_base)
420 {
421  struct segment *sec;
422  char tmp_str[MAX_URL_SIZE], *ptr = tmp_str;
423 
424  if (!info->uri[0])
425  return NULL;
426 
427  sec = av_mallocz(sizeof(*sec));
428  if (!sec)
429  return NULL;
430 
431  if (!av_strncasecmp(info->uri, "data:", 5)) {
432  ptr = info->uri;
433  } else {
434  ff_make_absolute_url(tmp_str, sizeof(tmp_str), url_base, info->uri);
435  if (!tmp_str[0]) {
436  av_free(sec);
437  return NULL;
438  }
439  }
440  sec->url = av_strdup(ptr);
441  if (!sec->url) {
442  av_free(sec);
443  return NULL;
444  }
445 
446  if (info->byterange[0]) {
447  sec->size = strtoll(info->byterange, NULL, 10);
448  ptr = strchr(info->byterange, '@');
449  if (ptr)
450  sec->url_offset = strtoll(ptr+1, NULL, 10);
451  } else {
452  /* the entire file is the init section */
453  sec->size = -1;
454  }
455 
456  dynarray_add(&pls->init_sections, &pls->n_init_sections, sec);
457 
458  return sec;
459 }
460 
461 static void handle_init_section_args(struct init_section_info *info, const char *key,
462  int key_len, char **dest, int *dest_len)
463 {
464  if (!strncmp(key, "URI=", key_len)) {
465  *dest = info->uri;
466  *dest_len = sizeof(info->uri);
467  } else if (!strncmp(key, "BYTERANGE=", key_len)) {
468  *dest = info->byterange;
469  *dest_len = sizeof(info->byterange);
470  }
471 }
472 
474  char type[16];
480  char defaultr[4];
481  char forced[4];
483 };
484 
486  const char *url_base)
487 {
488  struct rendition *rend;
490  char *characteristic;
491  char *chr_ptr;
492  char *saveptr;
493 
494  if (!strcmp(info->type, "AUDIO"))
496  else if (!strcmp(info->type, "VIDEO"))
498  else if (!strcmp(info->type, "SUBTITLES"))
500  else if (!strcmp(info->type, "CLOSED-CAPTIONS"))
501  /* CLOSED-CAPTIONS is ignored since we do not support CEA-608 CC in
502  * AVC SEI RBSP anyway */
503  return NULL;
504 
505  if (type == AVMEDIA_TYPE_UNKNOWN) {
506  av_log(c->ctx, AV_LOG_WARNING, "Can't support the type: %s\n", info->type);
507  return NULL;
508  }
509 
510  /* URI is mandatory for subtitles as per spec */
511  if (type == AVMEDIA_TYPE_SUBTITLE && !info->uri[0]) {
512  av_log(c->ctx, AV_LOG_ERROR, "The URI tag is REQUIRED for subtitle.\n");
513  return NULL;
514  }
515 
516  /* TODO: handle subtitles (each segment has to parsed separately) */
517  if (c->ctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL)
518  if (type == AVMEDIA_TYPE_SUBTITLE) {
519  av_log(c->ctx, AV_LOG_WARNING, "Can't support the subtitle(uri: %s)\n", info->uri);
520  return NULL;
521  }
522 
523  rend = av_mallocz(sizeof(struct rendition));
524  if (!rend)
525  return NULL;
526 
527  dynarray_add(&c->renditions, &c->n_renditions, rend);
528 
529  rend->type = type;
530  strcpy(rend->group_id, info->group_id);
531  strcpy(rend->language, info->language);
532  strcpy(rend->name, info->name);
533 
534  /* add the playlist if this is an external rendition */
535  if (info->uri[0]) {
536  rend->playlist = new_playlist(c, info->uri, url_base);
537  if (rend->playlist)
539  &rend->playlist->n_renditions, rend);
540  }
541 
542  if (info->assoc_language[0]) {
543  int langlen = strlen(rend->language);
544  if (langlen < sizeof(rend->language) - 3) {
545  rend->language[langlen] = ',';
546  strncpy(rend->language + langlen + 1, info->assoc_language,
547  sizeof(rend->language) - langlen - 2);
548  }
549  }
550 
551  if (!strcmp(info->defaultr, "YES"))
553  if (!strcmp(info->forced, "YES"))
555 
556  chr_ptr = info->characteristics;
557  while ((characteristic = av_strtok(chr_ptr, ",", &saveptr))) {
558  if (!strcmp(characteristic, "public.accessibility.describes-music-and-sound"))
560  else if (!strcmp(characteristic, "public.accessibility.describes-video"))
562 
563  chr_ptr = NULL;
564  }
565 
566  return rend;
567 }
568 
569 static void handle_rendition_args(struct rendition_info *info, const char *key,
570  int key_len, char **dest, int *dest_len)
571 {
572  if (!strncmp(key, "TYPE=", key_len)) {
573  *dest = info->type;
574  *dest_len = sizeof(info->type);
575  } else if (!strncmp(key, "URI=", key_len)) {
576  *dest = info->uri;
577  *dest_len = sizeof(info->uri);
578  } else if (!strncmp(key, "GROUP-ID=", key_len)) {
579  *dest = info->group_id;
580  *dest_len = sizeof(info->group_id);
581  } else if (!strncmp(key, "LANGUAGE=", key_len)) {
582  *dest = info->language;
583  *dest_len = sizeof(info->language);
584  } else if (!strncmp(key, "ASSOC-LANGUAGE=", key_len)) {
585  *dest = info->assoc_language;
586  *dest_len = sizeof(info->assoc_language);
587  } else if (!strncmp(key, "NAME=", key_len)) {
588  *dest = info->name;
589  *dest_len = sizeof(info->name);
590  } else if (!strncmp(key, "DEFAULT=", key_len)) {
591  *dest = info->defaultr;
592  *dest_len = sizeof(info->defaultr);
593  } else if (!strncmp(key, "FORCED=", key_len)) {
594  *dest = info->forced;
595  *dest_len = sizeof(info->forced);
596  } else if (!strncmp(key, "CHARACTERISTICS=", key_len)) {
597  *dest = info->characteristics;
598  *dest_len = sizeof(info->characteristics);
599  }
600  /*
601  * ignored:
602  * - AUTOSELECT: client may autoselect based on e.g. system language
603  * - INSTREAM-ID: EIA-608 closed caption number ("CC1".."CC4")
604  */
605 }
606 
607 /* used by parse_playlist to allocate a new variant+playlist when the
608  * playlist is detected to be a Media Playlist (not Master Playlist)
609  * and we have no parent Master Playlist (parsing of which would have
610  * allocated the variant and playlist already)
611  * *pls == NULL => Master Playlist or parentless Media Playlist
612  * *pls != NULL => parented Media Playlist, playlist+variant allocated */
613 static int ensure_playlist(HLSContext *c, struct playlist **pls, const char *url)
614 {
615  if (*pls)
616  return 0;
617  if (!new_variant(c, NULL, url, NULL))
618  return AVERROR(ENOMEM);
619  *pls = c->playlists[c->n_playlists - 1];
620  return 0;
621 }
622 
624  const char *url, AVDictionary **options)
625 {
626 #if !CONFIG_HTTP_PROTOCOL
628 #else
629  int ret;
630  URLContext *uc = ffio_geturlcontext(*pb);
631  av_assert0(uc);
632  (*pb)->eof_reached = 0;
633  ret = ff_http_do_new_request2(uc, url, options);
634  if (ret < 0) {
635  ff_format_io_close(s, pb);
636  }
637  return ret;
638 #endif
639 }
640 
641 static int open_url(AVFormatContext *s, AVIOContext **pb, const char *url,
642  AVDictionary **opts, AVDictionary *opts2, int *is_http_out)
643 {
644  HLSContext *c = s->priv_data;
645  AVDictionary *tmp = NULL;
646  const char *proto_name = NULL;
647  int ret;
648  int is_http = 0;
649 
650  if (av_strstart(url, "crypto", NULL)) {
651  if (url[6] == '+' || url[6] == ':')
652  proto_name = avio_find_protocol_name(url + 7);
653  } else if (av_strstart(url, "data", NULL)) {
654  if (url[4] == '+' || url[4] == ':')
655  proto_name = avio_find_protocol_name(url + 5);
656  }
657 
658  if (!proto_name)
659  proto_name = avio_find_protocol_name(url);
660 
661  if (!proto_name)
662  return AVERROR_INVALIDDATA;
663 
664  // only http(s) & file are allowed
665  if (av_strstart(proto_name, "file", NULL)) {
666  if (strcmp(c->allowed_extensions, "ALL") && !av_match_ext(url, c->allowed_extensions)) {
668  "Filename extension of \'%s\' is not a common multimedia extension, blocked for security reasons.\n"
669  "If you wish to override this adjust allowed_extensions, you can set it to \'ALL\' to allow all\n",
670  url);
671  return AVERROR_INVALIDDATA;
672  }
673  } else if (av_strstart(proto_name, "http", NULL)) {
674  is_http = 1;
675  } else if (av_strstart(proto_name, "data", NULL)) {
676  ;
677  } else
678  return AVERROR_INVALIDDATA;
679 
680  if (!strncmp(proto_name, url, strlen(proto_name)) && url[strlen(proto_name)] == ':')
681  ;
682  else if (av_strstart(url, "crypto", NULL) && !strncmp(proto_name, url + 7, strlen(proto_name)) && url[7 + strlen(proto_name)] == ':')
683  ;
684  else if (av_strstart(url, "data", NULL) && !strncmp(proto_name, url + 5, strlen(proto_name)) && url[5 + strlen(proto_name)] == ':')
685  ;
686  else if (strcmp(proto_name, "file") || !strncmp(url, "file,", 5))
687  return AVERROR_INVALIDDATA;
688 
689  av_dict_copy(&tmp, *opts, 0);
690  av_dict_copy(&tmp, opts2, 0);
691 
692  if (is_http && c->http_persistent && *pb) {
693  ret = open_url_keepalive(c->ctx, pb, url, &tmp);
694  if (ret == AVERROR_EXIT) {
695  av_dict_free(&tmp);
696  return ret;
697  } else if (ret < 0) {
698  if (ret != AVERROR_EOF)
700  "keepalive request failed for '%s' with error: '%s' when opening url, retrying with new connection\n",
701  url, av_err2str(ret));
702  av_dict_copy(&tmp, *opts, 0);
703  av_dict_copy(&tmp, opts2, 0);
704  ret = s->io_open(s, pb, url, AVIO_FLAG_READ, &tmp);
705  }
706  } else {
707  ret = s->io_open(s, pb, url, AVIO_FLAG_READ, &tmp);
708  }
709  if (ret >= 0) {
710  // update cookies on http response with setcookies.
711  char *new_cookies = NULL;
712 
713  if (!(s->flags & AVFMT_FLAG_CUSTOM_IO))
714  av_opt_get(*pb, "cookies", AV_OPT_SEARCH_CHILDREN, (uint8_t**)&new_cookies);
715 
716  if (new_cookies)
717  av_dict_set(opts, "cookies", new_cookies, AV_DICT_DONT_STRDUP_VAL);
718  }
719 
720  av_dict_free(&tmp);
721 
722  if (is_http_out)
723  *is_http_out = is_http;
724 
725  return ret;
726 }
727 
728 static int parse_playlist(HLSContext *c, const char *url,
729  struct playlist *pls, AVIOContext *in)
730 {
731  int ret = 0, is_segment = 0, is_variant = 0;
732  int64_t duration = 0;
733  enum KeyType key_type = KEY_NONE;
734  uint8_t iv[16] = "";
735  int has_iv = 0;
736  char key[MAX_URL_SIZE] = "";
737  char line[MAX_URL_SIZE];
738  const char *ptr;
739  int close_in = 0;
740  int64_t seg_offset = 0;
741  int64_t seg_size = -1;
742  uint8_t *new_url = NULL;
743  struct variant_info variant_info;
744  char tmp_str[MAX_URL_SIZE];
745  struct segment *cur_init_section = NULL;
746  int is_http = av_strstart(url, "http", NULL);
747  struct segment **prev_segments = NULL;
748  int prev_n_segments = 0;
749  int64_t prev_start_seq_no = -1;
750 
751  if (is_http && !in && c->http_persistent && c->playlist_pb) {
752  in = c->playlist_pb;
753  ret = open_url_keepalive(c->ctx, &c->playlist_pb, url, NULL);
754  if (ret == AVERROR_EXIT) {
755  return ret;
756  } else if (ret < 0) {
757  if (ret != AVERROR_EOF)
758  av_log(c->ctx, AV_LOG_WARNING,
759  "keepalive request failed for '%s' with error: '%s' when parsing playlist\n",
760  url, av_err2str(ret));
761  in = NULL;
762  }
763  }
764 
765  if (!in) {
767  av_dict_copy(&opts, c->avio_opts, 0);
768 
769  if (c->http_persistent)
770  av_dict_set(&opts, "multiple_requests", "1", 0);
771 
772  ret = c->ctx->io_open(c->ctx, &in, url, AVIO_FLAG_READ, &opts);
773  av_dict_free(&opts);
774  if (ret < 0)
775  return ret;
776 
777  if (is_http && c->http_persistent)
778  c->playlist_pb = in;
779  else
780  close_in = 1;
781  }
782 
783  if (av_opt_get(in, "location", AV_OPT_SEARCH_CHILDREN, &new_url) >= 0)
784  url = new_url;
785 
786  ff_get_chomp_line(in, line, sizeof(line));
787  if (strcmp(line, "#EXTM3U")) {
789  goto fail;
790  }
791 
792  if (pls) {
793  prev_start_seq_no = pls->start_seq_no;
794  prev_segments = pls->segments;
795  prev_n_segments = pls->n_segments;
796  pls->segments = NULL;
797  pls->n_segments = 0;
798 
799  pls->finished = 0;
800  pls->type = PLS_TYPE_UNSPECIFIED;
801  }
802  while (!avio_feof(in)) {
803  ff_get_chomp_line(in, line, sizeof(line));
804  if (av_strstart(line, "#EXT-X-STREAM-INF:", &ptr)) {
805  is_variant = 1;
806  memset(&variant_info, 0, sizeof(variant_info));
808  &variant_info);
809  } else if (av_strstart(line, "#EXT-X-KEY:", &ptr)) {
810  struct key_info info = {{0}};
812  &info);
813  key_type = KEY_NONE;
814  has_iv = 0;
815  if (!strcmp(info.method, "AES-128"))
816  key_type = KEY_AES_128;
817  if (!strcmp(info.method, "SAMPLE-AES"))
818  key_type = KEY_SAMPLE_AES;
819  if (!av_strncasecmp(info.iv, "0x", 2)) {
820  ff_hex_to_data(iv, info.iv + 2);
821  has_iv = 1;
822  }
823  av_strlcpy(key, info.uri, sizeof(key));
824  } else if (av_strstart(line, "#EXT-X-MEDIA:", &ptr)) {
825  struct rendition_info info = {{0}};
827  &info);
828  new_rendition(c, &info, url);
829  } else if (av_strstart(line, "#EXT-X-TARGETDURATION:", &ptr)) {
830  int64_t t;
831  ret = ensure_playlist(c, &pls, url);
832  if (ret < 0)
833  goto fail;
834  t = strtoll(ptr, NULL, 10);
835  if (t < 0 || t >= INT64_MAX / AV_TIME_BASE) {
837  goto fail;
838  }
839  pls->target_duration = t * AV_TIME_BASE;
840  } else if (av_strstart(line, "#EXT-X-MEDIA-SEQUENCE:", &ptr)) {
841  uint64_t seq_no;
842  ret = ensure_playlist(c, &pls, url);
843  if (ret < 0)
844  goto fail;
845  seq_no = strtoull(ptr, NULL, 10);
846  if (seq_no > INT64_MAX/2) {
847  av_log(c->ctx, AV_LOG_DEBUG, "MEDIA-SEQUENCE higher than "
848  "INT64_MAX/2, mask out the highest bit\n");
849  seq_no &= INT64_MAX/2;
850  }
851  pls->start_seq_no = seq_no;
852  } else if (av_strstart(line, "#EXT-X-PLAYLIST-TYPE:", &ptr)) {
853  ret = ensure_playlist(c, &pls, url);
854  if (ret < 0)
855  goto fail;
856  if (!strcmp(ptr, "EVENT"))
857  pls->type = PLS_TYPE_EVENT;
858  else if (!strcmp(ptr, "VOD"))
859  pls->type = PLS_TYPE_VOD;
860  } else if (av_strstart(line, "#EXT-X-MAP:", &ptr)) {
861  struct init_section_info info = {{0}};
862  ret = ensure_playlist(c, &pls, url);
863  if (ret < 0)
864  goto fail;
866  &info);
867  cur_init_section = new_init_section(pls, &info, url);
868  if (!cur_init_section) {
869  ret = AVERROR(ENOMEM);
870  goto fail;
871  }
872  cur_init_section->key_type = key_type;
873  if (has_iv) {
874  memcpy(cur_init_section->iv, iv, sizeof(iv));
875  } else {
876  int64_t seq = pls->start_seq_no + pls->n_segments;
877  memset(cur_init_section->iv, 0, sizeof(cur_init_section->iv));
878  AV_WB64(cur_init_section->iv + 8, seq);
879  }
880 
881  if (key_type != KEY_NONE) {
882  ff_make_absolute_url(tmp_str, sizeof(tmp_str), url, key);
883  if (!tmp_str[0]) {
884  av_free(cur_init_section);
886  goto fail;
887  }
888  cur_init_section->key = av_strdup(tmp_str);
889  if (!cur_init_section->key) {
890  av_free(cur_init_section);
891  ret = AVERROR(ENOMEM);
892  goto fail;
893  }
894  } else {
895  cur_init_section->key = NULL;
896  }
897 
898  } else if (av_strstart(line, "#EXT-X-START:", &ptr)) {
899  const char *time_offset_value = NULL;
900  ret = ensure_playlist(c, &pls, url);
901  if (ret < 0) {
902  goto fail;
903  }
904  if (av_strstart(ptr, "TIME-OFFSET=", &time_offset_value)) {
905  float offset = strtof(time_offset_value, NULL);
907  pls->time_offset_flag = 1;
908  } else {
909  av_log(c->ctx, AV_LOG_WARNING, "#EXT-X-START value is"
910  "invalid, it will be ignored");
911  continue;
912  }
913  } else if (av_strstart(line, "#EXT-X-ENDLIST", &ptr)) {
914  if (pls)
915  pls->finished = 1;
916  } else if (av_strstart(line, "#EXTINF:", &ptr)) {
917  is_segment = 1;
918  duration = atof(ptr) * AV_TIME_BASE;
919  } else if (av_strstart(line, "#EXT-X-BYTERANGE:", &ptr)) {
920  seg_size = strtoll(ptr, NULL, 10);
921  ptr = strchr(ptr, '@');
922  if (ptr)
923  seg_offset = strtoll(ptr+1, NULL, 10);
924  } else if (av_strstart(line, "#", NULL)) {
925  av_log(c->ctx, AV_LOG_INFO, "Skip ('%s')\n", line);
926  continue;
927  } else if (line[0]) {
928  if (is_variant) {
929  if (!new_variant(c, &variant_info, line, url)) {
930  ret = AVERROR(ENOMEM);
931  goto fail;
932  }
933  is_variant = 0;
934  }
935  if (is_segment) {
936  struct segment *seg;
937  ret = ensure_playlist(c, &pls, url);
938  if (ret < 0)
939  goto fail;
940  seg = av_malloc(sizeof(struct segment));
941  if (!seg) {
942  ret = AVERROR(ENOMEM);
943  goto fail;
944  }
945  if (has_iv) {
946  memcpy(seg->iv, iv, sizeof(iv));
947  } else {
948  uint64_t seq = pls->start_seq_no + (uint64_t)pls->n_segments;
949  memset(seg->iv, 0, sizeof(seg->iv));
950  AV_WB64(seg->iv + 8, seq);
951  }
952 
953  if (key_type != KEY_NONE) {
954  ff_make_absolute_url(tmp_str, sizeof(tmp_str), url, key);
955  if (!tmp_str[0]) {
957  av_free(seg);
958  goto fail;
959  }
960  seg->key = av_strdup(tmp_str);
961  if (!seg->key) {
962  av_free(seg);
963  ret = AVERROR(ENOMEM);
964  goto fail;
965  }
966  } else {
967  seg->key = NULL;
968  }
969 
970  ff_make_absolute_url(tmp_str, sizeof(tmp_str), url, line);
971  if (!tmp_str[0]) {
973  if (seg->key)
974  av_free(seg->key);
975  av_free(seg);
976  goto fail;
977  }
978  seg->url = av_strdup(tmp_str);
979  if (!seg->url) {
980  av_free(seg->key);
981  av_free(seg);
982  ret = AVERROR(ENOMEM);
983  goto fail;
984  }
985 
986  if (duration < 0.001 * AV_TIME_BASE) {
987  av_log(c->ctx, AV_LOG_WARNING, "Cannot get correct #EXTINF value of segment %s,"
988  " set to default value to 1ms.\n", seg->url);
989  duration = 0.001 * AV_TIME_BASE;
990  }
991  seg->duration = duration;
992  seg->key_type = key_type;
993  dynarray_add(&pls->segments, &pls->n_segments, seg);
994  is_segment = 0;
995 
996  seg->size = seg_size;
997  if (seg_size >= 0) {
998  seg->url_offset = seg_offset;
999  seg_offset += seg_size;
1000  seg_size = -1;
1001  } else {
1002  seg->url_offset = 0;
1003  seg_offset = 0;
1004  }
1005 
1006  seg->init_section = cur_init_section;
1007  }
1008  }
1009  }
1010  if (prev_segments) {
1011  if (pls->start_seq_no > prev_start_seq_no && c->first_timestamp != AV_NOPTS_VALUE) {
1012  int64_t prev_timestamp = c->first_timestamp;
1013  int i;
1014  int64_t diff = pls->start_seq_no - prev_start_seq_no;
1015  for (i = 0; i < prev_n_segments && i < diff; i++) {
1016  c->first_timestamp += prev_segments[i]->duration;
1017  }
1018  av_log(c->ctx, AV_LOG_DEBUG, "Media sequence change (%"PRId64" -> %"PRId64")"
1019  " reflected in first_timestamp: %"PRId64" -> %"PRId64"\n",
1020  prev_start_seq_no, pls->start_seq_no,
1021  prev_timestamp, c->first_timestamp);
1022  } else if (pls->start_seq_no < prev_start_seq_no) {
1023  av_log(c->ctx, AV_LOG_WARNING, "Media sequence changed unexpectedly: %"PRId64" -> %"PRId64"\n",
1024  prev_start_seq_no, pls->start_seq_no);
1025  }
1026  free_segment_dynarray(prev_segments, prev_n_segments);
1027  av_freep(&prev_segments);
1028  }
1029  if (pls)
1031 
1032 fail:
1033  av_free(new_url);
1034  if (close_in)
1035  ff_format_io_close(c->ctx, &in);
1036  c->ctx->ctx_flags = c->ctx->ctx_flags & ~(unsigned)AVFMTCTX_UNSEEKABLE;
1037  if (!c->n_variants || !c->variants[0]->n_playlists ||
1038  !(c->variants[0]->playlists[0]->finished ||
1039  c->variants[0]->playlists[0]->type == PLS_TYPE_EVENT))
1040  c->ctx->ctx_flags |= AVFMTCTX_UNSEEKABLE;
1041  return ret;
1042 }
1043 
1044 static struct segment *current_segment(struct playlist *pls)
1045 {
1046  int64_t n = pls->cur_seq_no - pls->start_seq_no;
1047  if (n >= pls->n_segments)
1048  return NULL;
1049  return pls->segments[n];
1050 }
1051 
1052 static struct segment *next_segment(struct playlist *pls)
1053 {
1054  int64_t n = pls->cur_seq_no - pls->start_seq_no + 1;
1055  if (n >= pls->n_segments)
1056  return NULL;
1057  return pls->segments[n];
1058 }
1059 
1060 static int read_from_url(struct playlist *pls, struct segment *seg,
1061  uint8_t *buf, int buf_size)
1062 {
1063  int ret;
1064 
1065  /* limit read if the segment was only a part of a file */
1066  if (seg->size >= 0)
1067  buf_size = FFMIN(buf_size, seg->size - pls->cur_seg_offset);
1068 
1069  ret = avio_read(pls->input, buf, buf_size);
1070  if (ret > 0)
1071  pls->cur_seg_offset += ret;
1072 
1073  return ret;
1074 }
1075 
1076 /* Parse the raw ID3 data and pass contents to caller */
1078  AVDictionary **metadata, int64_t *dts, HLSAudioSetupInfo *audio_setup_info,
1079  ID3v2ExtraMetaAPIC **apic, ID3v2ExtraMeta **extra_meta)
1080 {
1081  static const char id3_priv_owner_ts[] = "com.apple.streaming.transportStreamTimestamp";
1082  static const char id3_priv_owner_audio_setup[] = "com.apple.streaming.audioDescription";
1083  ID3v2ExtraMeta *meta;
1084 
1085  ff_id3v2_read_dict(pb, metadata, ID3v2_DEFAULT_MAGIC, extra_meta);
1086  for (meta = *extra_meta; meta; meta = meta->next) {
1087  if (!strcmp(meta->tag, "PRIV")) {
1088  ID3v2ExtraMetaPRIV *priv = &meta->data.priv;
1089  if (priv->datasize == 8 && !av_strncasecmp(priv->owner, id3_priv_owner_ts, 44)) {
1090  /* 33-bit MPEG timestamp */
1091  int64_t ts = AV_RB64(priv->data);
1092  av_log(s, AV_LOG_DEBUG, "HLS ID3 audio timestamp %"PRId64"\n", ts);
1093  if ((ts & ~((1ULL << 33) - 1)) == 0)
1094  *dts = ts;
1095  else
1096  av_log(s, AV_LOG_ERROR, "Invalid HLS ID3 audio timestamp %"PRId64"\n", ts);
1097  } else if (priv->datasize >= 8 && !av_strncasecmp(priv->owner, id3_priv_owner_audio_setup, 36)) {
1098  ff_hls_senc_read_audio_setup_info(audio_setup_info, priv->data, priv->datasize);
1099  }
1100  } else if (!strcmp(meta->tag, "APIC") && apic)
1101  *apic = &meta->data.apic;
1102  }
1103 }
1104 
1105 /* Check if the ID3 metadata contents have changed */
1106 static int id3_has_changed_values(struct playlist *pls, AVDictionary *metadata,
1107  ID3v2ExtraMetaAPIC *apic)
1108 {
1109  const AVDictionaryEntry *entry = NULL;
1110  const AVDictionaryEntry *oldentry;
1111  /* check that no keys have changed values */
1112  while ((entry = av_dict_iterate(metadata, entry))) {
1113  oldentry = av_dict_get(pls->id3_initial, entry->key, NULL, AV_DICT_MATCH_CASE);
1114  if (!oldentry || strcmp(oldentry->value, entry->value) != 0)
1115  return 1;
1116  }
1117 
1118  /* check if apic appeared */
1119  if (apic && (pls->ctx->nb_streams != 2 || !pls->ctx->streams[1]->attached_pic.data))
1120  return 1;
1121 
1122  if (apic) {
1123  int size = pls->ctx->streams[1]->attached_pic.size;
1124  if (size != apic->buf->size - AV_INPUT_BUFFER_PADDING_SIZE)
1125  return 1;
1126 
1127  if (memcmp(apic->buf->data, pls->ctx->streams[1]->attached_pic.data, size) != 0)
1128  return 1;
1129  }
1130 
1131  return 0;
1132 }
1133 
1134 /* Parse ID3 data and handle the found data */
1135 static void handle_id3(AVIOContext *pb, struct playlist *pls)
1136 {
1137  AVDictionary *metadata = NULL;
1138  ID3v2ExtraMetaAPIC *apic = NULL;
1139  ID3v2ExtraMeta *extra_meta = NULL;
1140  int64_t timestamp = AV_NOPTS_VALUE;
1141 
1142  parse_id3(pls->ctx, pb, &metadata, &timestamp, &pls->audio_setup_info, &apic, &extra_meta);
1143 
1144  if (timestamp != AV_NOPTS_VALUE) {
1145  pls->id3_mpegts_timestamp = timestamp;
1146  pls->id3_offset = 0;
1147  }
1148 
1149  if (!pls->id3_found) {
1150  /* initial ID3 tags */
1152  pls->id3_found = 1;
1153 
1154  /* get picture attachment and set text metadata */
1155  if (pls->ctx->nb_streams)
1156  ff_id3v2_parse_apic(pls->ctx, extra_meta);
1157  else
1158  /* demuxer not yet opened, defer picture attachment */
1159  pls->id3_deferred_extra = extra_meta;
1160 
1161  ff_id3v2_parse_priv_dict(&metadata, extra_meta);
1162  av_dict_copy(&pls->ctx->metadata, metadata, 0);
1163  pls->id3_initial = metadata;
1164 
1165  } else {
1166  if (!pls->id3_changed && id3_has_changed_values(pls, metadata, apic)) {
1167  avpriv_report_missing_feature(pls->parent, "Changing ID3 metadata in HLS audio elementary stream");
1168  pls->id3_changed = 1;
1169  }
1170  av_dict_free(&metadata);
1171  }
1172 
1173  if (!pls->id3_deferred_extra)
1174  ff_id3v2_free_extra_meta(&extra_meta);
1175 }
1176 
1177 static void intercept_id3(struct playlist *pls, uint8_t *buf,
1178  int buf_size, int *len)
1179 {
1180  /* intercept id3 tags, we do not want to pass them to the raw
1181  * demuxer on all segment switches */
1182  int bytes;
1183  int id3_buf_pos = 0;
1184  int fill_buf = 0;
1185  struct segment *seg = current_segment(pls);
1186 
1187  /* gather all the id3 tags */
1188  while (1) {
1189  /* see if we can retrieve enough data for ID3 header */
1190  if (*len < ID3v2_HEADER_SIZE && buf_size >= ID3v2_HEADER_SIZE) {
1191  bytes = read_from_url(pls, seg, buf + *len, ID3v2_HEADER_SIZE - *len);
1192  if (bytes > 0) {
1193 
1194  if (bytes == ID3v2_HEADER_SIZE - *len)
1195  /* no EOF yet, so fill the caller buffer again after
1196  * we have stripped the ID3 tags */
1197  fill_buf = 1;
1198 
1199  *len += bytes;
1200 
1201  } else if (*len <= 0) {
1202  /* error/EOF */
1203  *len = bytes;
1204  fill_buf = 0;
1205  }
1206  }
1207 
1208  if (*len < ID3v2_HEADER_SIZE)
1209  break;
1210 
1211  if (ff_id3v2_match(buf, ID3v2_DEFAULT_MAGIC)) {
1212  int64_t maxsize = seg->size >= 0 ? seg->size : 1024*1024;
1213  int taglen = ff_id3v2_tag_len(buf);
1214  int tag_got_bytes = FFMIN(taglen, *len);
1215  int remaining = taglen - tag_got_bytes;
1216 
1217  if (taglen > maxsize) {
1218  av_log(pls->parent, AV_LOG_ERROR, "Too large HLS ID3 tag (%d > %"PRId64" bytes)\n",
1219  taglen, maxsize);
1220  break;
1221  }
1222 
1223  /*
1224  * Copy the id3 tag to our temporary id3 buffer.
1225  * We could read a small id3 tag directly without memcpy, but
1226  * we would still need to copy the large tags, and handling
1227  * both of those cases together with the possibility for multiple
1228  * tags would make the handling a bit complex.
1229  */
1230  pls->id3_buf = av_fast_realloc(pls->id3_buf, &pls->id3_buf_size, id3_buf_pos + taglen);
1231  if (!pls->id3_buf)
1232  break;
1233  memcpy(pls->id3_buf + id3_buf_pos, buf, tag_got_bytes);
1234  id3_buf_pos += tag_got_bytes;
1235 
1236  /* strip the intercepted bytes */
1237  *len -= tag_got_bytes;
1238  memmove(buf, buf + tag_got_bytes, *len);
1239  av_log(pls->parent, AV_LOG_DEBUG, "Stripped %d HLS ID3 bytes\n", tag_got_bytes);
1240 
1241  if (remaining > 0) {
1242  /* read the rest of the tag in */
1243  if (read_from_url(pls, seg, pls->id3_buf + id3_buf_pos, remaining) != remaining)
1244  break;
1245  id3_buf_pos += remaining;
1246  av_log(pls->parent, AV_LOG_DEBUG, "Stripped additional %d HLS ID3 bytes\n", remaining);
1247  }
1248 
1249  } else {
1250  /* no more ID3 tags */
1251  break;
1252  }
1253  }
1254 
1255  /* re-fill buffer for the caller unless EOF */
1256  if (*len >= 0 && (fill_buf || *len == 0)) {
1257  bytes = read_from_url(pls, seg, buf + *len, buf_size - *len);
1258 
1259  /* ignore error if we already had some data */
1260  if (bytes >= 0)
1261  *len += bytes;
1262  else if (*len == 0)
1263  *len = bytes;
1264  }
1265 
1266  if (pls->id3_buf) {
1267  /* Now parse all the ID3 tags */
1268  FFIOContext id3ioctx;
1269  ffio_init_read_context(&id3ioctx, pls->id3_buf, id3_buf_pos);
1270  handle_id3(&id3ioctx.pub, pls);
1271  }
1272 
1273  if (pls->is_id3_timestamped == -1)
1275 }
1276 
1277 static int open_input(HLSContext *c, struct playlist *pls, struct segment *seg, AVIOContext **in)
1278 {
1279  AVDictionary *opts = NULL;
1280  int ret;
1281  int is_http = 0;
1282 
1283  if (c->http_persistent)
1284  av_dict_set(&opts, "multiple_requests", "1", 0);
1285 
1286  if (seg->size >= 0) {
1287  /* try to restrict the HTTP request to the part we want
1288  * (if this is in fact a HTTP request) */
1289  av_dict_set_int(&opts, "offset", seg->url_offset, 0);
1290  av_dict_set_int(&opts, "end_offset", seg->url_offset + seg->size, 0);
1291  }
1292 
1293  av_log(pls->parent, AV_LOG_VERBOSE, "HLS request for url '%s', offset %"PRId64", playlist %d\n",
1294  seg->url, seg->url_offset, pls->index);
1295 
1296  if (seg->key_type == KEY_AES_128 || seg->key_type == KEY_SAMPLE_AES) {
1297  if (strcmp(seg->key, pls->key_url)) {
1298  AVIOContext *pb = NULL;
1299  if (open_url(pls->parent, &pb, seg->key, &c->avio_opts, opts, NULL) == 0) {
1300  ret = avio_read(pb, pls->key, sizeof(pls->key));
1301  if (ret != sizeof(pls->key)) {
1302  av_log(pls->parent, AV_LOG_ERROR, "Unable to read key file %s\n",
1303  seg->key);
1304  }
1305  ff_format_io_close(pls->parent, &pb);
1306  } else {
1307  av_log(pls->parent, AV_LOG_ERROR, "Unable to open key file %s\n",
1308  seg->key);
1309  }
1310  av_strlcpy(pls->key_url, seg->key, sizeof(pls->key_url));
1311  }
1312  }
1313 
1314  if (seg->key_type == KEY_AES_128) {
1315  char iv[33], key[33], url[MAX_URL_SIZE];
1316  ff_data_to_hex(iv, seg->iv, sizeof(seg->iv), 0);
1317  ff_data_to_hex(key, pls->key, sizeof(pls->key), 0);
1318  if (strstr(seg->url, "://"))
1319  snprintf(url, sizeof(url), "crypto+%s", seg->url);
1320  else
1321  snprintf(url, sizeof(url), "crypto:%s", seg->url);
1322 
1323  av_dict_set(&opts, "key", key, 0);
1324  av_dict_set(&opts, "iv", iv, 0);
1325 
1326  ret = open_url(pls->parent, in, url, &c->avio_opts, opts, &is_http);
1327  if (ret < 0) {
1328  goto cleanup;
1329  }
1330  ret = 0;
1331  } else {
1332  ret = open_url(pls->parent, in, seg->url, &c->avio_opts, opts, &is_http);
1333  }
1334 
1335  /* Seek to the requested position. If this was a HTTP request, the offset
1336  * should already be where want it to, but this allows e.g. local testing
1337  * without a HTTP server.
1338  *
1339  * This is not done for HTTP at all as avio_seek() does internal bookkeeping
1340  * of file offset which is out-of-sync with the actual offset when "offset"
1341  * AVOption is used with http protocol, causing the seek to not be a no-op
1342  * as would be expected. Wrong offset received from the server will not be
1343  * noticed without the call, though.
1344  */
1345  if (ret == 0 && !is_http && seg->url_offset) {
1346  int64_t seekret = avio_seek(*in, seg->url_offset, SEEK_SET);
1347  if (seekret < 0) {
1348  av_log(pls->parent, AV_LOG_ERROR, "Unable to seek to offset %"PRId64" of HLS segment '%s'\n", seg->url_offset, seg->url);
1349  ret = seekret;
1350  ff_format_io_close(pls->parent, in);
1351  }
1352  }
1353 
1354 cleanup:
1355  av_dict_free(&opts);
1356  pls->cur_seg_offset = 0;
1357  return ret;
1358 }
1359 
1360 static int update_init_section(struct playlist *pls, struct segment *seg)
1361 {
1362  static const int max_init_section_size = 1024*1024;
1363  HLSContext *c = pls->parent->priv_data;
1364  int64_t sec_size;
1365  int64_t urlsize;
1366  int ret;
1367 
1368  if (seg->init_section == pls->cur_init_section)
1369  return 0;
1370 
1371  pls->cur_init_section = NULL;
1372 
1373  if (!seg->init_section)
1374  return 0;
1375 
1376  ret = open_input(c, pls, seg->init_section, &pls->input);
1377  if (ret < 0) {
1379  "Failed to open an initialization section in playlist %d\n",
1380  pls->index);
1381  return ret;
1382  }
1383 
1384  if (seg->init_section->size >= 0)
1385  sec_size = seg->init_section->size;
1386  else if ((urlsize = avio_size(pls->input)) >= 0)
1387  sec_size = urlsize;
1388  else
1389  sec_size = max_init_section_size;
1390 
1391  av_log(pls->parent, AV_LOG_DEBUG,
1392  "Downloading an initialization section of size %"PRId64"\n",
1393  sec_size);
1394 
1395  sec_size = FFMIN(sec_size, max_init_section_size);
1396 
1397  av_fast_malloc(&pls->init_sec_buf, &pls->init_sec_buf_size, sec_size);
1398 
1399  ret = read_from_url(pls, seg->init_section, pls->init_sec_buf,
1400  pls->init_sec_buf_size);
1401  ff_format_io_close(pls->parent, &pls->input);
1402 
1403  if (ret < 0)
1404  return ret;
1405 
1406  pls->cur_init_section = seg->init_section;
1407  pls->init_sec_data_len = ret;
1408  pls->init_sec_buf_read_offset = 0;
1409 
1410  /* spec says audio elementary streams do not have media initialization
1411  * sections, so there should be no ID3 timestamps */
1412  pls->is_id3_timestamped = 0;
1413 
1414  return 0;
1415 }
1416 
1417 static int64_t default_reload_interval(struct playlist *pls)
1418 {
1419  return pls->n_segments > 0 ?
1420  pls->segments[pls->n_segments - 1]->duration :
1421  pls->target_duration;
1422 }
1423 
1424 static int playlist_needed(struct playlist *pls)
1425 {
1426  AVFormatContext *s = pls->parent;
1427  int i, j;
1428  int stream_needed = 0;
1429  int first_st;
1430 
1431  /* If there is no context or streams yet, the playlist is needed */
1432  if (!pls->ctx || !pls->n_main_streams)
1433  return 1;
1434 
1435  /* check if any of the streams in the playlist are needed */
1436  for (i = 0; i < pls->n_main_streams; i++) {
1437  if (pls->main_streams[i]->discard < AVDISCARD_ALL) {
1438  stream_needed = 1;
1439  break;
1440  }
1441  }
1442 
1443  /* If all streams in the playlist were discarded, the playlist is not
1444  * needed (regardless of whether whole programs are discarded or not). */
1445  if (!stream_needed)
1446  return 0;
1447 
1448  /* Otherwise, check if all the programs (variants) this playlist is in are
1449  * discarded. Since all streams in the playlist are part of the same programs
1450  * we can just check the programs of the first stream. */
1451 
1452  first_st = pls->main_streams[0]->index;
1453 
1454  for (i = 0; i < s->nb_programs; i++) {
1455  AVProgram *program = s->programs[i];
1456  if (program->discard < AVDISCARD_ALL) {
1457  for (j = 0; j < program->nb_stream_indexes; j++) {
1458  if (program->stream_index[j] == first_st) {
1459  /* playlist is in an undiscarded program */
1460  return 1;
1461  }
1462  }
1463  }
1464  }
1465 
1466  /* some streams were not discarded but all the programs were */
1467  return 0;
1468 }
1469 
1470 static int read_data(void *opaque, uint8_t *buf, int buf_size)
1471 {
1472  struct playlist *v = opaque;
1473  HLSContext *c = v->parent->priv_data;
1474  int ret;
1475  int just_opened = 0;
1476  int reload_count = 0;
1477  int segment_retries = 0;
1478  struct segment *seg;
1479 
1480 restart:
1481  if (!v->needed)
1482  return AVERROR_EOF;
1483 
1484  if (!v->input || (c->http_persistent && v->input_read_done)) {
1485  int64_t reload_interval;
1486 
1487  /* Check that the playlist is still needed before opening a new
1488  * segment. */
1489  v->needed = playlist_needed(v);
1490 
1491  if (!v->needed) {
1492  av_log(v->parent, AV_LOG_INFO, "No longer receiving playlist %d ('%s')\n",
1493  v->index, v->url);
1494  return AVERROR_EOF;
1495  }
1496 
1497  /* If this is a live stream and the reload interval has elapsed since
1498  * the last playlist reload, reload the playlists now. */
1499  reload_interval = default_reload_interval(v);
1500 
1501 reload:
1502  reload_count++;
1503  if (reload_count > c->max_reload)
1504  return AVERROR_EOF;
1505  if (!v->finished &&
1506  av_gettime_relative() - v->last_load_time >= reload_interval) {
1507  if ((ret = parse_playlist(c, v->url, v, NULL)) < 0) {
1508  if (ret != AVERROR_EXIT)
1509  av_log(v->parent, AV_LOG_WARNING, "Failed to reload playlist %d\n",
1510  v->index);
1511  return ret;
1512  }
1513  /* If we need to reload the playlist again below (if
1514  * there's still no more segments), switch to a reload
1515  * interval of half the target duration. */
1516  reload_interval = v->target_duration / 2;
1517  }
1518  if (v->cur_seq_no < v->start_seq_no) {
1520  "skipping %"PRId64" segments ahead, expired from playlists\n",
1521  v->start_seq_no - v->cur_seq_no);
1522  v->cur_seq_no = v->start_seq_no;
1523  }
1524  if (v->cur_seq_no > v->last_seq_no) {
1525  v->last_seq_no = v->cur_seq_no;
1526  v->m3u8_hold_counters = 0;
1527  } else if (v->last_seq_no == v->cur_seq_no) {
1528  v->m3u8_hold_counters++;
1529  if (v->m3u8_hold_counters >= c->m3u8_hold_counters) {
1530  return AVERROR_EOF;
1531  }
1532  } else {
1533  av_log(v->parent, AV_LOG_WARNING, "The m3u8 list sequence may have been wrapped.\n");
1534  }
1535  if (v->cur_seq_no >= v->start_seq_no + v->n_segments) {
1536  if (v->finished)
1537  return AVERROR_EOF;
1538  while (av_gettime_relative() - v->last_load_time < reload_interval) {
1539  if (ff_check_interrupt(c->interrupt_callback))
1540  return AVERROR_EXIT;
1541  av_usleep(100*1000);
1542  }
1543  /* Enough time has elapsed since the last reload */
1544  goto reload;
1545  }
1546 
1547  v->input_read_done = 0;
1548  seg = current_segment(v);
1549 
1550  /* load/update Media Initialization Section, if any */
1551  ret = update_init_section(v, seg);
1552  if (ret)
1553  return ret;
1554 
1555  if (c->http_multiple == 1 && v->input_next_requested) {
1556  FFSWAP(AVIOContext *, v->input, v->input_next);
1557  v->cur_seg_offset = 0;
1558  v->input_next_requested = 0;
1559  ret = 0;
1560  } else {
1561  ret = open_input(c, v, seg, &v->input);
1562  }
1563  if (ret < 0) {
1564  if (ff_check_interrupt(c->interrupt_callback))
1565  return AVERROR_EXIT;
1566  av_log(v->parent, AV_LOG_WARNING, "Failed to open segment %"PRId64" of playlist %d\n",
1567  v->cur_seq_no,
1568  v->index);
1569  if (segment_retries >= c->seg_max_retry) {
1570  av_log(v->parent, AV_LOG_WARNING, "Segment %"PRId64" of playlist %d failed too many times, skipping\n",
1571  v->cur_seq_no,
1572  v->index);
1573  v->cur_seq_no++;
1574  segment_retries = 0;
1575  } else {
1576  segment_retries++;
1577  }
1578  goto reload;
1579  }
1580  segment_retries = 0;
1581  just_opened = 1;
1582  }
1583 
1584  if (c->http_multiple == -1) {
1585  uint8_t *http_version_opt = NULL;
1586  int r = av_opt_get(v->input, "http_version", AV_OPT_SEARCH_CHILDREN, &http_version_opt);
1587  if (r >= 0) {
1588  c->http_multiple = (!strncmp((const char *)http_version_opt, "1.1", 3) || !strncmp((const char *)http_version_opt, "2.0", 3));
1589  av_freep(&http_version_opt);
1590  }
1591  }
1592 
1593  seg = next_segment(v);
1594  if (c->http_multiple == 1 && !v->input_next_requested &&
1595  seg && seg->key_type == KEY_NONE && av_strstart(seg->url, "http", NULL)) {
1596  ret = open_input(c, v, seg, &v->input_next);
1597  if (ret < 0) {
1598  if (ff_check_interrupt(c->interrupt_callback))
1599  return AVERROR_EXIT;
1600  av_log(v->parent, AV_LOG_WARNING, "Failed to open segment %"PRId64" of playlist %d\n",
1601  v->cur_seq_no + 1,
1602  v->index);
1603  } else {
1604  v->input_next_requested = 1;
1605  }
1606  }
1607 
1609  /* Push init section out first before first actual segment */
1610  int copy_size = FFMIN(v->init_sec_data_len - v->init_sec_buf_read_offset, buf_size);
1611  memcpy(buf, v->init_sec_buf, copy_size);
1612  v->init_sec_buf_read_offset += copy_size;
1613  return copy_size;
1614  }
1615 
1616  seg = current_segment(v);
1617  ret = read_from_url(v, seg, buf, buf_size);
1618  if (ret > 0) {
1619  if (just_opened && v->is_id3_timestamped != 0) {
1620  /* Intercept ID3 tags here, elementary audio streams are required
1621  * to convey timestamps using them in the beginning of each segment. */
1622  intercept_id3(v, buf, buf_size, &ret);
1623  }
1624 
1625  return ret;
1626  }
1627  if (c->http_persistent &&
1628  seg->key_type == KEY_NONE && av_strstart(seg->url, "http", NULL)) {
1629  v->input_read_done = 1;
1630  } else {
1631  ff_format_io_close(v->parent, &v->input);
1632  }
1633  v->cur_seq_no++;
1634 
1635  c->cur_seq_no = v->cur_seq_no;
1636 
1637  goto restart;
1638 }
1639 
1640 static void add_renditions_to_variant(HLSContext *c, struct variant *var,
1641  enum AVMediaType type, const char *group_id)
1642 {
1643  int i;
1644 
1645  for (i = 0; i < c->n_renditions; i++) {
1646  struct rendition *rend = c->renditions[i];
1647 
1648  if (rend->type == type && !strcmp(rend->group_id, group_id)) {
1649 
1650  if (rend->playlist)
1651  /* rendition is an external playlist
1652  * => add the playlist to the variant */
1653  dynarray_add(&var->playlists, &var->n_playlists, rend->playlist);
1654  else
1655  /* rendition is part of the variant main Media Playlist
1656  * => add the rendition to the main Media Playlist */
1657  dynarray_add(&var->playlists[0]->renditions,
1658  &var->playlists[0]->n_renditions,
1659  rend);
1660  }
1661  }
1662 }
1663 
1665  enum AVMediaType type)
1666 {
1667  int rend_idx = 0;
1668  int i;
1669 
1670  for (i = 0; i < pls->n_main_streams; i++) {
1671  AVStream *st = pls->main_streams[i];
1672 
1673  if (st->codecpar->codec_type != type)
1674  continue;
1675 
1676  for (; rend_idx < pls->n_renditions; rend_idx++) {
1677  struct rendition *rend = pls->renditions[rend_idx];
1678 
1679  if (rend->type != type)
1680  continue;
1681 
1682  if (rend->language[0])
1683  av_dict_set(&st->metadata, "language", rend->language, 0);
1684  if (rend->name[0])
1685  av_dict_set(&st->metadata, "comment", rend->name, 0);
1686 
1687  st->disposition |= rend->disposition;
1688  }
1689  if (rend_idx >=pls->n_renditions)
1690  break;
1691  }
1692 }
1693 
1694 /* if timestamp was in valid range: returns 1 and sets seq_no
1695  * if not: returns 0 and sets seq_no to closest segment */
1697  int64_t timestamp, int64_t *seq_no,
1698  int64_t *seg_start_ts)
1699 {
1700  int i;
1701  int64_t pos = c->first_timestamp == AV_NOPTS_VALUE ?
1702  0 : c->first_timestamp;
1703 
1704  if (timestamp < pos) {
1705  *seq_no = pls->start_seq_no;
1706  return 0;
1707  }
1708 
1709  for (i = 0; i < pls->n_segments; i++) {
1710  int64_t diff = pos + pls->segments[i]->duration - timestamp;
1711  if (diff > 0) {
1712  *seq_no = pls->start_seq_no + i;
1713  if (seg_start_ts) {
1714  *seg_start_ts = pos;
1715  }
1716  return 1;
1717  }
1718  pos += pls->segments[i]->duration;
1719  }
1720 
1721  *seq_no = pls->start_seq_no + pls->n_segments - 1;
1722 
1723  return 0;
1724 }
1725 
1726 static int64_t select_cur_seq_no(HLSContext *c, struct playlist *pls)
1727 {
1728  int64_t seq_no;
1729 
1730  if (!pls->finished && !c->first_packet &&
1732  /* reload the playlist since it was suspended */
1733  parse_playlist(c, pls->url, pls, NULL);
1734 
1735  /* If playback is already in progress (we are just selecting a new
1736  * playlist) and this is a complete file, find the matching segment
1737  * by counting durations. */
1738  if (pls->finished && c->cur_timestamp != AV_NOPTS_VALUE) {
1739  find_timestamp_in_playlist(c, pls, c->cur_timestamp, &seq_no, NULL);
1740  return seq_no;
1741  }
1742 
1743  if (!pls->finished) {
1744  if (!c->first_packet && /* we are doing a segment selection during playback */
1745  c->cur_seq_no >= pls->start_seq_no &&
1746  c->cur_seq_no < pls->start_seq_no + pls->n_segments)
1747  /* While spec 3.4.3 says that we cannot assume anything about the
1748  * content at the same sequence number on different playlists,
1749  * in practice this seems to work and doing it otherwise would
1750  * require us to download a segment to inspect its timestamps. */
1751  return c->cur_seq_no;
1752 
1753  /* If this is a live stream, start live_start_index segments from the
1754  * start or end */
1755  if (c->live_start_index < 0)
1756  seq_no = pls->start_seq_no + FFMAX(pls->n_segments +
1757  c->live_start_index, 0);
1758  else
1759  seq_no = pls->start_seq_no + FFMIN(c->live_start_index,
1760  pls->n_segments - 1);
1761 
1762  /* If #EXT-X-START in playlist, need to recalculate */
1763  if (pls->time_offset_flag && c->prefer_x_start) {
1764  int64_t start_timestamp;
1765  int64_t playlist_duration = 0;
1766  int64_t cur_timestamp = c->cur_timestamp == AV_NOPTS_VALUE ? 0 :
1767  c->cur_timestamp;
1768 
1769  for (int i = 0; i < pls->n_segments; i++)
1770  playlist_duration += pls->segments[i]->duration;
1771 
1772  /* If the absolute value of TIME-OFFSET exceeds
1773  * the duration of the playlist, it indicates either the end of the
1774  * playlist (if positive) or the beginning of the playlist (if
1775  * negative). */
1776  if (pls->start_time_offset >=0 &&
1777  pls->start_time_offset > playlist_duration)
1778  start_timestamp = cur_timestamp + playlist_duration;
1779  else if (pls->start_time_offset >= 0 &&
1780  pls->start_time_offset <= playlist_duration)
1781  start_timestamp = cur_timestamp + pls->start_time_offset;
1782  else if (pls->start_time_offset < 0 &&
1783  pls->start_time_offset < -playlist_duration)
1784  start_timestamp = cur_timestamp;
1785  else if (pls->start_time_offset < 0 &&
1786  pls->start_time_offset > -playlist_duration)
1787  start_timestamp = cur_timestamp + playlist_duration +
1788  pls->start_time_offset;
1789  else
1790  start_timestamp = cur_timestamp;
1791 
1792  find_timestamp_in_playlist(c, pls, start_timestamp, &seq_no, NULL);
1793  }
1794  return seq_no;
1795  }
1796 
1797  /* Otherwise just start on the first segment. */
1798  return pls->start_seq_no;
1799 }
1800 
1801 static int nested_io_open(AVFormatContext *s, AVIOContext **pb, const char *url,
1802  int flags, AVDictionary **opts)
1803 {
1805  "A HLS playlist item '%s' referred to an external file '%s'. "
1806  "Opening this file was forbidden for security reasons\n",
1807  s->url, url);
1808  return AVERROR(EPERM);
1809 }
1810 
1811 static void add_stream_to_programs(AVFormatContext *s, struct playlist *pls, AVStream *stream)
1812 {
1813  HLSContext *c = s->priv_data;
1814  int i, j;
1815  int bandwidth = -1;
1816 
1817  for (i = 0; i < c->n_variants; i++) {
1818  struct variant *v = c->variants[i];
1819 
1820  for (j = 0; j < v->n_playlists; j++) {
1821  if (v->playlists[j] != pls)
1822  continue;
1823 
1824  av_program_add_stream_index(s, i, stream->index);
1825 
1826  if (bandwidth < 0)
1827  bandwidth = v->bandwidth;
1828  else if (bandwidth != v->bandwidth)
1829  bandwidth = -1; /* stream in multiple variants with different bandwidths */
1830  }
1831  }
1832 
1833  if (bandwidth >= 0)
1834  av_dict_set_int(&stream->metadata, "variant_bitrate", bandwidth, 0);
1835 }
1836 
1838 {
1839  int err;
1840 
1841  err = avcodec_parameters_copy(st->codecpar, ist->codecpar);
1842  if (err < 0)
1843  return err;
1844 
1845  if (pls->is_id3_timestamped) /* custom timestamps via id3 */
1846  avpriv_set_pts_info(st, 33, 1, MPEG_TIME_BASE);
1847  else
1849 
1850  // copy disposition
1851  st->disposition = ist->disposition;
1852 
1853  av_dict_copy(&st->metadata, ist->metadata, 0);
1854 
1855  ffstream(st)->need_context_update = 1;
1856 
1857  return 0;
1858 }
1859 
1860 /* add new subdemuxer streams to our context, if any */
1862 {
1863  int err;
1864 
1865  while (pls->n_main_streams < pls->ctx->nb_streams) {
1866  int ist_idx = pls->n_main_streams;
1868  AVStream *ist = pls->ctx->streams[ist_idx];
1869 
1870  if (!st)
1871  return AVERROR(ENOMEM);
1872 
1873  st->id = pls->index;
1874  dynarray_add(&pls->main_streams, &pls->n_main_streams, st);
1875 
1876  add_stream_to_programs(s, pls, st);
1877 
1878  err = set_stream_info_from_input_stream(st, pls, ist);
1879  if (err < 0)
1880  return err;
1881  }
1882 
1883  return 0;
1884 }
1885 
1887 {
1888  HLSContext *c = s->priv_data;
1889  int flag_needed = 0;
1890  int i;
1891 
1892  for (i = 0; i < c->n_playlists; i++) {
1893  struct playlist *pls = c->playlists[i];
1894 
1895  if (pls->has_noheader_flag) {
1896  flag_needed = 1;
1897  break;
1898  }
1899  }
1900 
1901  if (flag_needed)
1902  s->ctx_flags |= AVFMTCTX_NOHEADER;
1903  else
1904  s->ctx_flags &= ~AVFMTCTX_NOHEADER;
1905 }
1906 
1908 {
1909  HLSContext *c = s->priv_data;
1910 
1914 
1915  if (c->crypto_ctx.aes_ctx)
1916  av_free(c->crypto_ctx.aes_ctx);
1917 
1918  av_dict_free(&c->avio_opts);
1919  ff_format_io_close(c->ctx, &c->playlist_pb);
1920 
1921  return 0;
1922 }
1923 
1925 {
1926  HLSContext *c = s->priv_data;
1927  int ret = 0, i;
1928  int64_t highest_cur_seq_no = 0;
1929 
1930  c->ctx = s;
1931  c->interrupt_callback = &s->interrupt_callback;
1932 
1933  c->first_packet = 1;
1934  c->first_timestamp = AV_NOPTS_VALUE;
1935  c->cur_timestamp = AV_NOPTS_VALUE;
1936 
1937  if ((ret = ffio_copy_url_options(s->pb, &c->avio_opts)) < 0)
1938  return ret;
1939 
1940  /* XXX: Some HLS servers don't like being sent the range header,
1941  in this case, need to setting http_seekable = 0 to disable
1942  the range header */
1943  av_dict_set_int(&c->avio_opts, "seekable", c->http_seekable, 0);
1944 
1945  if ((ret = parse_playlist(c, s->url, NULL, s->pb)) < 0)
1946  return ret;
1947 
1948  if (c->n_variants == 0) {
1949  av_log(s, AV_LOG_WARNING, "Empty playlist\n");
1950  return AVERROR_EOF;
1951  }
1952  /* If the playlist only contained playlists (Master Playlist),
1953  * parse each individual playlist. */
1954  if (c->n_playlists > 1 || c->playlists[0]->n_segments == 0) {
1955  for (i = 0; i < c->n_playlists; i++) {
1956  struct playlist *pls = c->playlists[i];
1957  pls->m3u8_hold_counters = 0;
1958  if ((ret = parse_playlist(c, pls->url, pls, NULL)) < 0) {
1959  av_log(s, AV_LOG_WARNING, "parse_playlist error %s [%s]\n", av_err2str(ret), pls->url);
1960  pls->broken = 1;
1961  if (c->n_playlists > 1)
1962  continue;
1963  return ret;
1964  }
1965  }
1966  }
1967 
1968  for (i = 0; i < c->n_variants; i++) {
1969  if (c->variants[i]->playlists[0]->n_segments == 0) {
1970  av_log(s, AV_LOG_WARNING, "Empty segment [%s]\n", c->variants[i]->playlists[0]->url);
1971  c->variants[i]->playlists[0]->broken = 1;
1972  }
1973  }
1974 
1975  /* If this isn't a live stream, calculate the total duration of the
1976  * stream. */
1977  if (c->variants[0]->playlists[0]->finished) {
1978  int64_t duration = 0;
1979  for (i = 0; i < c->variants[0]->playlists[0]->n_segments; i++)
1980  duration += c->variants[0]->playlists[0]->segments[i]->duration;
1981  s->duration = duration;
1982  }
1983 
1984  /* Associate renditions with variants */
1985  for (i = 0; i < c->n_variants; i++) {
1986  struct variant *var = c->variants[i];
1987 
1988  if (var->audio_group[0])
1990  if (var->video_group[0])
1992  if (var->subtitles_group[0])
1994  }
1995 
1996  /* Create a program for each variant */
1997  for (i = 0; i < c->n_variants; i++) {
1998  struct variant *v = c->variants[i];
1999  AVProgram *program;
2000 
2001  program = av_new_program(s, i);
2002  if (!program)
2003  return AVERROR(ENOMEM);
2004  av_dict_set_int(&program->metadata, "variant_bitrate", v->bandwidth, 0);
2005  }
2006 
2007  /* Select the starting segments */
2008  for (i = 0; i < c->n_playlists; i++) {
2009  struct playlist *pls = c->playlists[i];
2010 
2011  if (pls->n_segments == 0)
2012  continue;
2013 
2014  pls->cur_seq_no = select_cur_seq_no(c, pls);
2015  highest_cur_seq_no = FFMAX(highest_cur_seq_no, pls->cur_seq_no);
2016  }
2017 
2018  /* Open the demuxer for each playlist */
2019  for (i = 0; i < c->n_playlists; i++) {
2020  struct playlist *pls = c->playlists[i];
2021  const AVInputFormat *in_fmt = NULL;
2022  char *url;
2024  struct segment *seg = NULL;
2025 
2026  if (!(pls->ctx = avformat_alloc_context()))
2027  return AVERROR(ENOMEM);
2028 
2029  if (pls->n_segments == 0)
2030  continue;
2031 
2032  pls->index = i;
2033  pls->needed = 1;
2034  pls->parent = s;
2035 
2036  /*
2037  * If this is a live stream and this playlist looks like it is one segment
2038  * behind, try to sync it up so that every substream starts at the same
2039  * time position (so e.g. avformat_find_stream_info() will see packets from
2040  * all active streams within the first few seconds). This is not very generic,
2041  * though, as the sequence numbers are technically independent.
2042  */
2043  if (!pls->finished && pls->cur_seq_no == highest_cur_seq_no - 1 &&
2044  highest_cur_seq_no < pls->start_seq_no + pls->n_segments) {
2045  pls->cur_seq_no = highest_cur_seq_no;
2046  }
2047 
2049  if (!pls->read_buffer){
2050  avformat_free_context(pls->ctx);
2051  pls->ctx = NULL;
2052  return AVERROR(ENOMEM);
2053  }
2054 
2055  ffio_init_context(&pls->pb, pls->read_buffer, INITIAL_BUFFER_SIZE, 0, pls,
2056  read_data, NULL, NULL);
2057 
2058  /*
2059  * If encryption scheme is SAMPLE-AES, try to read ID3 tags of
2060  * external audio track that contains audio setup information
2061  */
2062  seg = current_segment(pls);
2063  if (seg && seg->key_type == KEY_SAMPLE_AES && pls->n_renditions > 0 &&
2064  pls->renditions[0]->type == AVMEDIA_TYPE_AUDIO) {
2065  uint8_t buf[HLS_MAX_ID3_TAGS_DATA_LEN];
2066  if ((ret = avio_read(&pls->pb.pub, buf, HLS_MAX_ID3_TAGS_DATA_LEN)) < 0) {
2067  /* Fail if error was not end of file */
2068  if (ret != AVERROR_EOF) {
2069  avformat_free_context(pls->ctx);
2070  pls->ctx = NULL;
2071  return ret;
2072  }
2073  }
2074  ret = 0;
2075  /* Reset reading */
2076  ff_format_io_close(pls->parent, &pls->input);
2077  pls->input = NULL;
2078  pls->input_read_done = 0;
2079  ff_format_io_close(pls->parent, &pls->input_next);
2080  pls->input_next = NULL;
2081  pls->input_next_requested = 0;
2082  pls->cur_seg_offset = 0;
2083  pls->cur_init_section = NULL;
2084  /* Reset EOF flag */
2085  pls->pb.pub.eof_reached = 0;
2086  /* Clear any buffered data */
2087  pls->pb.pub.buf_end = pls->pb.pub.buf_ptr = pls->pb.pub.buffer;
2088  /* Reset the position */
2089  pls->pb.pub.pos = 0;
2090  }
2091 
2092  /*
2093  * If encryption scheme is SAMPLE-AES and audio setup information is present in external audio track,
2094  * use that information to find the media format, otherwise probe input data
2095  */
2096  if (seg && seg->key_type == KEY_SAMPLE_AES && pls->is_id3_timestamped &&
2098  void *iter = NULL;
2099  while ((in_fmt = av_demuxer_iterate(&iter)))
2100  if (in_fmt->raw_codec_id == pls->audio_setup_info.codec_id)
2101  break;
2102  } else {
2103  pls->ctx->probesize = s->probesize > 0 ? s->probesize : 1024 * 4;
2104  pls->ctx->max_analyze_duration = s->max_analyze_duration > 0 ? s->max_analyze_duration : 4 * AV_TIME_BASE;
2105  pls->ctx->interrupt_callback = s->interrupt_callback;
2106  url = av_strdup(pls->segments[0]->url);
2107  ret = av_probe_input_buffer(&pls->pb.pub, &in_fmt, url, NULL, 0, 0);
2108  if (ret < 0) {
2109  /* Free the ctx - it isn't initialized properly at this point,
2110  * so avformat_close_input shouldn't be called. If
2111  * avformat_open_input fails below, it frees and zeros the
2112  * context, so it doesn't need any special treatment like this. */
2113  av_log(s, AV_LOG_ERROR, "Error when loading first segment '%s'\n", url);
2114  avformat_free_context(pls->ctx);
2115  pls->ctx = NULL;
2116  av_free(url);
2117  return ret;
2118  }
2119  av_free(url);
2120  }
2121 
2122  if (seg && seg->key_type == KEY_SAMPLE_AES) {
2123  if (strstr(in_fmt->name, "mov")) {
2124  char key[33];
2125  ff_data_to_hex(key, pls->key, sizeof(pls->key), 0);
2126  av_dict_set(&options, "decryption_key", key, 0);
2127  } else if (!c->crypto_ctx.aes_ctx) {
2128  c->crypto_ctx.aes_ctx = av_aes_alloc();
2129  if (!c->crypto_ctx.aes_ctx) {
2130  avformat_free_context(pls->ctx);
2131  pls->ctx = NULL;
2132  return AVERROR(ENOMEM);
2133  }
2134  }
2135  }
2136 
2137  pls->ctx->pb = &pls->pb.pub;
2138  pls->ctx->io_open = nested_io_open;
2139  pls->ctx->flags |= s->flags & ~AVFMT_FLAG_CUSTOM_IO;
2140 
2141  if ((ret = ff_copy_whiteblacklists(pls->ctx, s)) < 0)
2142  return ret;
2143 
2144  av_dict_copy(&options, c->seg_format_opts, 0);
2145 
2146  ret = avformat_open_input(&pls->ctx, pls->segments[0]->url, in_fmt, &options);
2148  if (ret < 0)
2149  return ret;
2150 
2151  if (pls->id3_deferred_extra && pls->ctx->nb_streams == 1) {
2156  }
2157 
2158  if (pls->is_id3_timestamped == -1)
2159  av_log(s, AV_LOG_WARNING, "No expected HTTP requests have been made\n");
2160 
2161  /*
2162  * For ID3 timestamped raw audio streams we need to detect the packet
2163  * durations to calculate timestamps in fill_timing_for_id3_timestamped_stream(),
2164  * but for other streams we can rely on our user calling avformat_find_stream_info()
2165  * on us if they want to.
2166  */
2167  if (pls->is_id3_timestamped || (pls->n_renditions > 0 && pls->renditions[0]->type == AVMEDIA_TYPE_AUDIO)) {
2168  if (seg && seg->key_type == KEY_SAMPLE_AES && pls->audio_setup_info.setup_data_length > 0 &&
2169  pls->ctx->nb_streams == 1)
2171  else
2173 
2174  if (ret < 0)
2175  return ret;
2176  }
2177 
2178  pls->has_noheader_flag = !!(pls->ctx->ctx_flags & AVFMTCTX_NOHEADER);
2179 
2180  /* Create new AVStreams for each stream in this playlist */
2182  if (ret < 0)
2183  return ret;
2184 
2185  /*
2186  * Copy any metadata from playlist to main streams, but do not set
2187  * event flags.
2188  */
2189  if (pls->n_main_streams)
2190  av_dict_copy(&pls->main_streams[0]->metadata, pls->ctx->metadata, 0);
2191 
2195  }
2196 
2198 
2199  return 0;
2200 }
2201 
2203 {
2204  HLSContext *c = s->priv_data;
2205  int i, changed = 0;
2206  int cur_needed;
2207 
2208  /* Check if any new streams are needed */
2209  for (i = 0; i < c->n_playlists; i++) {
2210  struct playlist *pls = c->playlists[i];
2211 
2212  cur_needed = playlist_needed(c->playlists[i]);
2213 
2214  if (pls->broken) {
2215  continue;
2216  }
2217  if (cur_needed && !pls->needed) {
2218  pls->needed = 1;
2219  changed = 1;
2220  pls->cur_seq_no = select_cur_seq_no(c, pls);
2221  pls->pb.pub.eof_reached = 0;
2222  if (c->cur_timestamp != AV_NOPTS_VALUE) {
2223  /* catch up */
2224  pls->seek_timestamp = c->cur_timestamp;
2225  pls->seek_flags = AVSEEK_FLAG_ANY;
2226  pls->seek_stream_index = -1;
2227  }
2228  av_log(s, AV_LOG_INFO, "Now receiving playlist %d, segment %"PRId64"\n", i, pls->cur_seq_no);
2229  } else if (first && !cur_needed && pls->needed) {
2230  ff_format_io_close(pls->parent, &pls->input);
2231  pls->input_read_done = 0;
2232  ff_format_io_close(pls->parent, &pls->input_next);
2233  pls->input_next_requested = 0;
2234  pls->needed = 0;
2235  changed = 1;
2236  av_log(s, AV_LOG_INFO, "No longer receiving playlist %d\n", i);
2237  }
2238  }
2239  return changed;
2240 }
2241 
2243 {
2244  if (pls->id3_offset >= 0) {
2245  pls->pkt->dts = pls->id3_mpegts_timestamp +
2246  av_rescale_q(pls->id3_offset,
2247  pls->ctx->streams[pls->pkt->stream_index]->time_base,
2249  if (pls->pkt->duration)
2250  pls->id3_offset += pls->pkt->duration;
2251  else
2252  pls->id3_offset = -1;
2253  } else {
2254  /* there have been packets with unknown duration
2255  * since the last id3 tag, should not normally happen */
2256  pls->pkt->dts = AV_NOPTS_VALUE;
2257  }
2258 
2259  if (pls->pkt->duration)
2260  pls->pkt->duration = av_rescale_q(pls->pkt->duration,
2261  pls->ctx->streams[pls->pkt->stream_index]->time_base,
2263 
2264  pls->pkt->pts = AV_NOPTS_VALUE;
2265 }
2266 
2267 static AVRational get_timebase(struct playlist *pls)
2268 {
2269  if (pls->is_id3_timestamped)
2270  return MPEG_TIME_BASE_Q;
2271 
2272  return pls->ctx->streams[pls->pkt->stream_index]->time_base;
2273 }
2274 
2275 static int compare_ts_with_wrapdetect(int64_t ts_a, struct playlist *pls_a,
2276  int64_t ts_b, struct playlist *pls_b)
2277 {
2278  int64_t scaled_ts_a = av_rescale_q(ts_a, get_timebase(pls_a), MPEG_TIME_BASE_Q);
2279  int64_t scaled_ts_b = av_rescale_q(ts_b, get_timebase(pls_b), MPEG_TIME_BASE_Q);
2280 
2281  return av_compare_mod(scaled_ts_a, scaled_ts_b, 1LL << 33);
2282 }
2283 
2285 {
2286  HLSContext *c = s->priv_data;
2287  int ret, i, minplaylist = -1;
2288 
2289  recheck_discard_flags(s, c->first_packet);
2290  c->first_packet = 0;
2291 
2292  for (i = 0; i < c->n_playlists; i++) {
2293  struct playlist *pls = c->playlists[i];
2294  /* Make sure we've got one buffered packet from each open playlist
2295  * stream */
2296  if (pls->needed && !pls->pkt->data) {
2297  while (1) {
2298  int64_t ts_diff;
2299  AVRational tb;
2300  struct segment *seg = NULL;
2301  ret = av_read_frame(pls->ctx, pls->pkt);
2302  if (ret < 0) {
2303  if (!avio_feof(&pls->pb.pub) && ret != AVERROR_EOF)
2304  return ret;
2305  break;
2306  } else {
2307  /* stream_index check prevents matching picture attachments etc. */
2308  if (pls->is_id3_timestamped && pls->pkt->stream_index == 0) {
2309  /* audio elementary streams are id3 timestamped */
2311  }
2312 
2313  if (c->first_timestamp == AV_NOPTS_VALUE &&
2314  pls->pkt->dts != AV_NOPTS_VALUE)
2315  c->first_timestamp = av_rescale_q(pls->pkt->dts,
2317  }
2318 
2319  seg = current_segment(pls);
2320  if (seg && seg->key_type == KEY_SAMPLE_AES && !strstr(pls->ctx->iformat->name, "mov")) {
2322  memcpy(c->crypto_ctx.iv, seg->iv, sizeof(seg->iv));
2323  memcpy(c->crypto_ctx.key, pls->key, sizeof(pls->key));
2324  ff_hls_senc_decrypt_frame(codec_id, &c->crypto_ctx, pls->pkt);
2325  }
2326 
2327  if (pls->seek_timestamp == AV_NOPTS_VALUE)
2328  break;
2329 
2330  if (pls->seek_stream_index < 0 ||
2331  pls->seek_stream_index == pls->pkt->stream_index) {
2332 
2333  if (pls->pkt->dts == AV_NOPTS_VALUE) {
2335  break;
2336  }
2337 
2338  tb = get_timebase(pls);
2339  ts_diff = av_rescale_rnd(pls->pkt->dts, AV_TIME_BASE,
2340  tb.den, AV_ROUND_DOWN) -
2341  pls->seek_timestamp;
2342  if (ts_diff >= 0 && (pls->seek_flags & AVSEEK_FLAG_ANY ||
2343  pls->pkt->flags & AV_PKT_FLAG_KEY)) {
2345  break;
2346  }
2347  }
2348  av_packet_unref(pls->pkt);
2349  }
2350  }
2351  /* Check if this stream has the packet with the lowest dts */
2352  if (pls->pkt->data) {
2353  struct playlist *minpls = minplaylist < 0 ?
2354  NULL : c->playlists[minplaylist];
2355  if (minplaylist < 0) {
2356  minplaylist = i;
2357  } else {
2358  int64_t dts = pls->pkt->dts;
2359  int64_t mindts = minpls->pkt->dts;
2360 
2361  if (dts == AV_NOPTS_VALUE ||
2362  (mindts != AV_NOPTS_VALUE && compare_ts_with_wrapdetect(dts, pls, mindts, minpls) < 0))
2363  minplaylist = i;
2364  }
2365  }
2366  }
2367 
2368  /* If we got a packet, return it */
2369  if (minplaylist >= 0) {
2370  struct playlist *pls = c->playlists[minplaylist];
2371  AVStream *ist;
2372  AVStream *st;
2373 
2375  if (ret < 0) {
2376  av_packet_unref(pls->pkt);
2377  return ret;
2378  }
2379 
2380  // If sub-demuxer reports updated metadata, copy it to the first stream
2381  // and set its AVSTREAM_EVENT_FLAG_METADATA_UPDATED flag.
2383  if (pls->n_main_streams) {
2384  st = pls->main_streams[0];
2385  av_dict_copy(&st->metadata, pls->ctx->metadata, 0);
2387  }
2389  }
2390 
2391  /* check if noheader flag has been cleared by the subdemuxer */
2392  if (pls->has_noheader_flag && !(pls->ctx->ctx_flags & AVFMTCTX_NOHEADER)) {
2393  pls->has_noheader_flag = 0;
2395  }
2396 
2397  if (pls->pkt->stream_index >= pls->n_main_streams) {
2398  av_log(s, AV_LOG_ERROR, "stream index inconsistency: index %d, %d main streams, %d subdemuxer streams\n",
2399  pls->pkt->stream_index, pls->n_main_streams, pls->ctx->nb_streams);
2400  av_packet_unref(pls->pkt);
2401  return AVERROR_BUG;
2402  }
2403 
2404  ist = pls->ctx->streams[pls->pkt->stream_index];
2405  st = pls->main_streams[pls->pkt->stream_index];
2406 
2407  av_packet_move_ref(pkt, pls->pkt);
2408  pkt->stream_index = st->index;
2409 
2410  if (pkt->dts != AV_NOPTS_VALUE)
2411  c->cur_timestamp = av_rescale_q(pkt->dts,
2412  ist->time_base,
2413  AV_TIME_BASE_Q);
2414 
2415  /* There may be more situations where this would be useful, but this at least
2416  * handles newly probed codecs properly (i.e. request_probe by mpegts). */
2417  if (ist->codecpar->codec_id != st->codecpar->codec_id) {
2418  ret = set_stream_info_from_input_stream(st, pls, ist);
2419  if (ret < 0) {
2420  return ret;
2421  }
2422  }
2423 
2424  return 0;
2425  }
2426  return AVERROR_EOF;
2427 }
2428 
2429 static int hls_read_seek(AVFormatContext *s, int stream_index,
2430  int64_t timestamp, int flags)
2431 {
2432  HLSContext *c = s->priv_data;
2433  struct playlist *seek_pls = NULL;
2434  int i, j;
2435  int stream_subdemuxer_index;
2436  int64_t first_timestamp, seek_timestamp, duration;
2437  int64_t seq_no, seg_start_ts;
2438 
2439  if ((flags & AVSEEK_FLAG_BYTE) || (c->ctx->ctx_flags & AVFMTCTX_UNSEEKABLE))
2440  return AVERROR(ENOSYS);
2441 
2442  first_timestamp = c->first_timestamp == AV_NOPTS_VALUE ?
2443  0 : c->first_timestamp;
2444 
2446  s->streams[stream_index]->time_base.den,
2447  AV_ROUND_DOWN);
2448 
2449  duration = s->duration == AV_NOPTS_VALUE ?
2450  0 : s->duration;
2451 
2452  if (0 < duration && duration < seek_timestamp - first_timestamp)
2453  return AVERROR(EIO);
2454 
2455  /* find the playlist with the specified stream */
2456  for (i = 0; i < c->n_playlists; i++) {
2457  struct playlist *pls = c->playlists[i];
2458  for (j = 0; j < pls->n_main_streams; j++) {
2459  if (pls->main_streams[j] == s->streams[stream_index]) {
2460  seek_pls = pls;
2461  stream_subdemuxer_index = j;
2462  break;
2463  }
2464  }
2465  }
2466  /* check if the timestamp is valid for the playlist with the
2467  * specified stream index */
2468  if (!seek_pls || !find_timestamp_in_playlist(c, seek_pls, seek_timestamp, &seq_no, &seg_start_ts))
2469  return AVERROR(EIO);
2470 
2471  if (s->streams[stream_index]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
2473  /* Seeking to start of segment ensures we seek to a keyframe located
2474  * before the given timestamp. */
2475  seek_timestamp = seg_start_ts;
2476  }
2477 
2478  /* set segment now so we do not need to search again below */
2479  seek_pls->cur_seq_no = seq_no;
2480  seek_pls->seek_stream_index = stream_subdemuxer_index;
2481 
2482  for (i = 0; i < c->n_playlists; i++) {
2483  /* Reset reading */
2484  struct playlist *pls = c->playlists[i];
2485  AVIOContext *const pb = &pls->pb.pub;
2486  ff_format_io_close(pls->parent, &pls->input);
2487  pls->input_read_done = 0;
2488  ff_format_io_close(pls->parent, &pls->input_next);
2489  pls->input_next_requested = 0;
2490  av_packet_unref(pls->pkt);
2491  pb->eof_reached = 0;
2492  /* Clear any buffered data */
2493  pb->buf_end = pb->buf_ptr = pb->buffer;
2494  /* Reset the pos, to let the mpegts demuxer know we've seeked. */
2495  pb->pos = 0;
2496  /* Flush the packet queue of the subdemuxer. */
2497  ff_read_frame_flush(pls->ctx);
2498 
2499  /* Reset the init segment so it's re-fetched and served appropiately */
2500  pls->cur_init_section = NULL;
2501 
2503  pls->seek_flags = flags;
2504 
2505  if (pls != seek_pls) {
2506  /* set closest segment seq_no for playlists not handled above */
2508  /* seek the playlist to the given position without taking
2509  * keyframes into account since this playlist does not have the
2510  * specified stream where we should look for the keyframes */
2511  pls->seek_stream_index = -1;
2512  pls->seek_flags |= AVSEEK_FLAG_ANY;
2513  }
2514  }
2515 
2516  c->cur_timestamp = seek_timestamp;
2517 
2518  return 0;
2519 }
2520 
2521 static int hls_probe(const AVProbeData *p)
2522 {
2523  /* Require #EXTM3U at the start, and either one of the ones below
2524  * somewhere for a proper match. */
2525  if (strncmp(p->buf, "#EXTM3U", 7))
2526  return 0;
2527 
2528  if (strstr(p->buf, "#EXT-X-STREAM-INF:") ||
2529  strstr(p->buf, "#EXT-X-TARGETDURATION:") ||
2530  strstr(p->buf, "#EXT-X-MEDIA-SEQUENCE:")) {
2531 
2532  int mime_ok = p->mime_type && !(
2533  av_strcasecmp(p->mime_type, "application/vnd.apple.mpegurl") &&
2534  av_strcasecmp(p->mime_type, "audio/mpegurl")
2535  );
2536 
2537  int mime_x = p->mime_type && !(
2538  av_strcasecmp(p->mime_type, "audio/x-mpegurl") &&
2539  av_strcasecmp(p->mime_type, "application/x-mpegurl")
2540  );
2541 
2542  if (!mime_ok &&
2543  !mime_x &&
2544  !av_match_ext (p->filename, "m3u8,m3u") &&
2545  ff_match_url_ext(p->filename, "m3u8,m3u") <= 0) {
2546  av_log(NULL, AV_LOG_ERROR, "Not detecting m3u8/hls with non standard extension and non standard mime type\n");
2547  return 0;
2548  }
2549  if (mime_x)
2550  av_log(NULL, AV_LOG_WARNING, "mime type is not rfc8216 compliant\n");
2551 
2552  return AVPROBE_SCORE_MAX;
2553  }
2554  return 0;
2555 }
2556 
2557 #define OFFSET(x) offsetof(HLSContext, x)
2558 #define FLAGS AV_OPT_FLAG_DECODING_PARAM
2559 static const AVOption hls_options[] = {
2560  {"live_start_index", "segment index to start live streams at (negative values are from the end)",
2561  OFFSET(live_start_index), AV_OPT_TYPE_INT, {.i64 = -3}, INT_MIN, INT_MAX, FLAGS},
2562  {"prefer_x_start", "prefer to use #EXT-X-START if it's in playlist instead of live_start_index",
2563  OFFSET(prefer_x_start), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, FLAGS},
2564  {"allowed_extensions", "List of file extensions that hls is allowed to access",
2565  OFFSET(allowed_extensions), AV_OPT_TYPE_STRING,
2566  {.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"},
2567  INT_MIN, INT_MAX, FLAGS},
2568  {"max_reload", "Maximum number of times a insufficient list is attempted to be reloaded",
2569  OFFSET(max_reload), AV_OPT_TYPE_INT, {.i64 = 3}, 0, INT_MAX, FLAGS},
2570  {"m3u8_hold_counters", "The maximum number of times to load m3u8 when it refreshes without new segments",
2571  OFFSET(m3u8_hold_counters), AV_OPT_TYPE_INT, {.i64 = 1000}, 0, INT_MAX, FLAGS},
2572  {"http_persistent", "Use persistent HTTP connections",
2573  OFFSET(http_persistent), AV_OPT_TYPE_BOOL, {.i64 = 1}, 0, 1, FLAGS },
2574  {"http_multiple", "Use multiple HTTP connections for fetching segments",
2575  OFFSET(http_multiple), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, FLAGS},
2576  {"http_seekable", "Use HTTP partial requests, 0 = disable, 1 = enable, -1 = auto",
2577  OFFSET(http_seekable), AV_OPT_TYPE_BOOL, { .i64 = -1}, -1, 1, FLAGS},
2578  {"seg_format_options", "Set options for segment demuxer",
2579  OFFSET(seg_format_opts), AV_OPT_TYPE_DICT, {.str = NULL}, 0, 0, FLAGS},
2580  {"seg_max_retry", "Maximum number of times to reload a segment on error.",
2581  OFFSET(seg_max_retry), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, FLAGS},
2582  {NULL}
2583 };
2584 
2585 static const AVClass hls_class = {
2586  .class_name = "hls demuxer",
2587  .item_name = av_default_item_name,
2588  .option = hls_options,
2589  .version = LIBAVUTIL_VERSION_INT,
2590 };
2591 
2593  .name = "hls",
2594  .long_name = NULL_IF_CONFIG_SMALL("Apple HTTP Live Streaming"),
2595  .priv_class = &hls_class,
2596  .priv_data_size = sizeof(HLSContext),
2598  .flags_internal = FF_FMT_INIT_CLEANUP,
2599  .read_probe = hls_probe,
2602  .read_close = hls_close,
2604 };
MPEG_TIME_BASE_Q
#define MPEG_TIME_BASE_Q
Definition: hls.c:56
ff_get_chomp_line
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.
Definition: aviobuf.c:833
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:423
playlist::start_seq_no
int64_t start_seq_no
Definition: hls.c:123
AVMEDIA_TYPE_SUBTITLE
@ AVMEDIA_TYPE_SUBTITLE
Definition: avutil.h:204
av_gettime_relative
int64_t av_gettime_relative(void)
Get the current time in microseconds since some unspecified starting point.
Definition: time.c:56
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
MAX_CHARACTERISTICS_LEN
#define MAX_CHARACTERISTICS_LEN
Definition: hls.c:53
AVFMT_NO_BYTE_SEEK
#define AVFMT_NO_BYTE_SEEK
Format does not allow seeking by bytes.
Definition: avformat.h:488
program
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
Definition: undefined.txt:6
ffio_init_context
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, const uint8_t *buf, int buf_size), int64_t(*seek)(void *opaque, int64_t offset, int whence))
Definition: aviobuf.c:81
ffio_copy_url_options
int ffio_copy_url_options(AVIOContext *pb, AVDictionary **avio_opts)
Read url related dictionary options from the AVIOContext and write to the given dictionary.
Definition: aviobuf.c:1039
FF_FMT_INIT_CLEANUP
#define FF_FMT_INIT_CLEANUP
For an AVInputFormat with this flag set read_close() needs to be called by the caller upon read_heade...
Definition: internal.h:46
playlist::input
AVIOContext * input
Definition: hls.c:105
playlist::seek_stream_index
int seek_stream_index
Definition: hls.c:162
free_segment_dynarray
static void free_segment_dynarray(struct segment **segments, int n_segments)
Definition: hls.c:234
r
const char * r
Definition: vf_curves.c:126
AVERROR
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
opt.h
playlist::target_duration
int64_t target_duration
Definition: hls.c:122
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:51
playlist::n_renditions
int n_renditions
Definition: hls.c:168
HLSContext::avio_opts
AVDictionary * avio_opts
Definition: hls.c:222
HLSContext::n_variants
int n_variants
Definition: hls.c:207
ID3v2ExtraMeta::next
struct ID3v2ExtraMeta * next
Definition: id3v2.h:86
AVInputFormat::raw_codec_id
int raw_codec_id
Raw demuxers store their codec ID here.
Definition: avformat.h:598
HLSContext::http_seekable
int http_seekable
Definition: hls.c:228
playlist
Definition: hls.c:101
KEY_AES_128
@ KEY_AES_128
Definition: hls.c:72
avformat_new_stream
AVStream * avformat_new_stream(AVFormatContext *s, const struct AVCodec *c)
Add a new stream to a media file.
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
AVBufferRef::data
uint8_t * data
The data buffer.
Definition: buffer.h:90
playlist::input_next_requested
int input_next_requested
Definition: hls.c:108
AVStream::discard
enum AVDiscard discard
Selects which packets can be discarded at will and do not need to be demuxed.
Definition: avformat.h:912
segment::url_offset
int64_t url_offset
Definition: hls.c:78
variant_info::subtitles
char subtitles[MAX_FIELD_LEN]
Definition: hls.c:344
playlist::id3_mpegts_timestamp
int64_t id3_mpegts_timestamp
Definition: hls.c:149
new_init_section
static struct segment * new_init_section(struct playlist *pls, struct init_section_info *info, const char *url_base)
Definition: hls.c:417
AV_TIME_BASE_Q
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:264
PLS_TYPE_VOD
@ PLS_TYPE_VOD
Definition: hls.c:93
av_strcasecmp
int av_strcasecmp(const char *a, const char *b)
Locale-independent case-insensitive compare.
Definition: avstring.c:207
playlist::input_next
AVIOContext * input_next
Definition: hls.c:107
playlist::id3_offset
int64_t id3_offset
Definition: hls.c:150
AV_DISPOSITION_DEFAULT
#define AV_DISPOSITION_DEFAULT
The stream should be chosen by default among other streams of the same type, unless the user has expl...
Definition: avformat.h:719
id3v2.h
playlist::seek_timestamp
int64_t seek_timestamp
Definition: hls.c:160
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
rendition_info::assoc_language
char assoc_language[MAX_FIELD_LEN]
Definition: hls.c:478
cleanup
static av_cold void cleanup(FlashSV2Context *s)
Definition: flashsv2enc.c:130
AVFormatContext::streams
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1183
AVPacket::data
uint8_t * data
Definition: packet.h:491
segment::size
int64_t size
Definition: hls.c:79
variant::subtitles_group
char subtitles_group[MAX_FIELD_LEN]
Definition: hls.c:201
AVOption
AVOption.
Definition: opt.h:251
compare_ts_with_wrapdetect
static int compare_ts_with_wrapdetect(int64_t ts_a, struct playlist *pls_a, int64_t ts_b, struct playlist *pls_b)
Definition: hls.c:2275
AVFMT_FLAG_CUSTOM_IO
#define AVFMT_FLAG_CUSTOM_IO
The caller has supplied a custom AVIOContext, don't avio_close() it.
Definition: avformat.h:1241
playlist::finished
int finished
Definition: hls.c:120
AVSEEK_FLAG_BYTE
#define AVSEEK_FLAG_BYTE
seeking based on position in bytes
Definition: avformat.h:2225
playlist::segments
struct segment ** segments
Definition: hls.c:127
rendition_info::type
char type[16]
Definition: hls.c:474
nested_io_open
static int nested_io_open(AVFormatContext *s, AVIOContext **pb, const char *url, int flags, AVDictionary **opts)
Definition: hls.c:1801
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:196
base
uint8_t base
Definition: vp3data.h:128
HLSAudioSetupInfo::setup_data_length
uint8_t setup_data_length
Definition: hls_sample_encryption.h:54
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:509
mathematics.h
FF_COMPLIANCE_EXPERIMENTAL
#define FF_COMPLIANCE_EXPERIMENTAL
Allow nonstandardized experimental things.
Definition: defs.h:62
AVDictionary
Definition: dict.c:34
ffio_init_read_context
void ffio_init_read_context(FFIOContext *s, const uint8_t *buffer, int buffer_size)
Wrap a buffer in an AVIOContext for reading.
Definition: aviobuf.c:134
segment::key
char * key
Definition: hls.c:81
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
AVFormatContext::probesize
int64_t probesize
Maximum number of bytes read from input in order to determine stream properties.
Definition: avformat.h:1269
av_read_frame
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
Return the next frame of a stream.
Definition: demux.c:1462
rendition::type
enum AVMediaType type
Definition: hls.c:184
rendition_info::uri
char uri[MAX_URL_SIZE]
Definition: hls.c:475
ff_read_frame_flush
void ff_read_frame_flush(AVFormatContext *s)
Flush the frame reader.
Definition: seek.c:720
OFFSET
#define OFFSET(x)
Definition: hls.c:2557
avio_size
int64_t avio_size(AVIOContext *s)
Get the filesize.
Definition: aviobuf.c:370
FFIOContext
Definition: avio_internal.h:28
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:546
playlist::key_url
char key_url[MAX_URL_SIZE]
Definition: hls.c:143
playlist::start_time_offset
int64_t start_time_offset
Definition: hls.c:125
av_packet_free
void av_packet_free(AVPacket **pkt)
Free the packet, if the packet is reference counted, it will be unreferenced first.
Definition: avpacket.c:74
AV_WB64
#define AV_WB64(p, v)
Definition: intreadwrite.h:431
HLSContext::first_packet
int first_packet
Definition: hls.c:218
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
AVIOInterruptCB
Callback for checking whether to abort blocking functions.
Definition: avio.h:59
avformat_queue_attached_pictures
int avformat_queue_attached_pictures(AVFormatContext *s)
Definition: demux_utils.c:93
hls_close
static int hls_close(AVFormatContext *s)
Definition: hls.c:1907
AVPROBE_SCORE_MAX
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:464
avformat_close_input
void avformat_close_input(AVFormatContext **s)
Close an opened input AVFormatContext.
Definition: demux.c:374
AVFormatContext::interrupt_callback
AVIOInterruptCB interrupt_callback
Custom interrupt callbacks for the I/O layer.
Definition: avformat.h:1381
HLSContext::http_multiple
int http_multiple
Definition: hls.c:227
key_info::iv
char iv[35]
Definition: hls.c:394
variant::audio_group
char audio_group[MAX_FIELD_LEN]
Definition: hls.c:199
avpriv_set_pts_info
void avpriv_set_pts_info(AVStream *st, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)
Set the time base and wrapping info for a given stream.
Definition: avformat.c:761
ffstream
static av_always_inline FFStream * ffstream(AVStream *st)
Definition: internal.h:420
recheck_discard_flags
static int recheck_discard_flags(AVFormatContext *s, int first)
Definition: hls.c:2202
hls_class
static const AVClass hls_class
Definition: hls.c:2585
segment::duration
int64_t duration
Definition: hls.c:77
fail
#define fail()
Definition: checkasm.h:138
AVSEEK_FLAG_ANY
#define AVSEEK_FLAG_ANY
seek to any frame, even non-keyframes
Definition: avformat.h:2226
new_variant
static struct variant * new_variant(HLSContext *c, struct variant_info *info, const char *url, const char *base)
Definition: hls.c:347
read_seek
static int read_seek(AVFormatContext *ctx, int stream_index, int64_t timestamp, int flags)
Definition: libcdio.c:151
playlist::input_read_done
int input_read_done
Definition: hls.c:106
HLSContext::n_renditions
int n_renditions
Definition: hls.c:211
read_close
static av_cold int read_close(AVFormatContext *ctx)
Definition: libcdio.c:143
AVIOContext::pos
int64_t pos
position in the file of the current buffer
Definition: avio.h:247
ff_hls_senc_read_audio_setup_info
void ff_hls_senc_read_audio_setup_info(HLSAudioSetupInfo *info, const uint8_t *buf, size_t size)
Definition: hls_sample_encryption.c:60
variant
Definition: hls.c:192
AV_DISPOSITION_FORCED
#define AV_DISPOSITION_FORCED
Track should be used during playback by default.
Definition: avformat.h:752
type
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
Definition: writing_filters.txt:86
dynarray_add
#define dynarray_add(tab, nb_ptr, elem)
Definition: internal.h:431
av_new_program
AVProgram * av_new_program(AVFormatContext *ac, int id)
Definition: avformat.c:281
ff_check_interrupt
int ff_check_interrupt(AVIOInterruptCB *cb)
Check if the user has requested to interrupt a blocking function associated with cb.
Definition: avio.c:667
ID3v2ExtraMeta::apic
ID3v2ExtraMetaAPIC apic
Definition: id3v2.h:88
HLS_MAX_ID3_TAGS_DATA_LEN
#define HLS_MAX_ID3_TAGS_DATA_LEN
Definition: hls_sample_encryption.h:40
ff_data_to_hex
char * ff_data_to_hex(char *buf, const uint8_t *src, int size, int lowercase)
Write hexadecimal string corresponding to given binary data.
Definition: utils.c:455
AVRational::num
int num
Numerator.
Definition: rational.h:59
handle_rendition_args
static void handle_rendition_args(struct rendition_info *info, const char *key, int key_len, char **dest, int *dest_len)
Definition: hls.c:569
AVFormatContext::event_flags
int event_flags
Flags indicating events happening on the file, a combination of AVFMT_EVENT_FLAG_*.
Definition: avformat.h:1424
AVStream::attached_pic
AVPacket attached_pic
For streams with AV_DISPOSITION_ATTACHED_PIC disposition, this packet will contain the attached pictu...
Definition: avformat.h:939
playlist::cur_seq_no
int64_t cur_seq_no
Definition: hls.c:130
AV_DICT_DONT_STRDUP_VAL
#define AV_DICT_DONT_STRDUP_VAL
Take ownership of a value that's been allocated with av_malloc() or another memory allocation functio...
Definition: dict.h:79
playlist::type
enum PlaylistType type
Definition: hls.c:121
open_url
static int open_url(AVFormatContext *s, AVIOContext **pb, const char *url, AVDictionary **opts, AVDictionary *opts2, int *is_http_out)
Definition: hls.c:641
first
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But first
Definition: rate_distortion.txt:12
avassert.h
pkt
AVPacket * pkt
Definition: movenc.c:59
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
playlist::n_init_sections
int n_init_sections
Definition: hls.c:173
AVFormatContext::metadata
AVDictionary * metadata
Metadata that applies to the whole file.
Definition: avformat.h:1343
AVInputFormat
Definition: avformat.h:549
AVProbeData::mime_type
const char * mime_type
mime_type, when known.
Definition: avformat.h:456
MPEG_TIME_BASE
#define MPEG_TIME_BASE
Definition: hls.c:55
ID3v2ExtraMeta
Definition: id3v2.h:84
AVFormatContext::ctx_flags
int ctx_flags
Flags signalling stream properties.
Definition: avformat.h:1164
duration
int64_t duration
Definition: movenc.c:64
free_rendition_list
static void free_rendition_list(HLSContext *c)
Definition: hls.c:304
avformat_open_input
int avformat_open_input(AVFormatContext **ps, const char *url, const AVInputFormat *fmt, AVDictionary **options)
Open an input stream and read the header.
Definition: demux.c:226
hls_options
static const AVOption hls_options[]
Definition: hls.c:2559
read_packet
static int read_packet(void *opaque, uint8_t *buf, int buf_size)
Definition: avio_read_callback.c:41
av_dict_get
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
Definition: dict.c:62
variant_info
Definition: hls.c:339
fill_timing_for_id3_timestamped_stream
static void fill_timing_for_id3_timestamped_stream(struct playlist *pls)
Definition: hls.c:2242
av_fast_realloc
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.
Definition: mem.c:495
playlist_needed
static int playlist_needed(struct playlist *pls)
Definition: hls.c:1424
intreadwrite.h
key_info::uri
char uri[MAX_URL_SIZE]
Definition: hls.c:392
s
#define s(width, name)
Definition: cbs_vp9.c:198
segment::key_type
enum KeyType key_type
Definition: hls.c:82
KEY_SAMPLE_AES
@ KEY_SAMPLE_AES
Definition: hls.c:73
playlist::n_main_streams
int n_main_streams
Definition: hls.c:118
AVFormatContext::flags
int flags
Flags modifying the (de)muxer behaviour.
Definition: avformat.h:1233
AVInputFormat::name
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:554
AVFormatContext::iformat
const struct AVInputFormat * iformat
The input container format.
Definition: avformat.h:1127
AVProbeData::buf
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:454
AVDictionaryEntry::key
char * key
Definition: dict.h:90
playlist::init_sec_buf_read_offset
unsigned int init_sec_buf_read_offset
Definition: hls.c:141
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
HLSContext::cur_timestamp
int64_t cur_timestamp
Definition: hls.c:220
AVProbeData::filename
const char * filename
Definition: avformat.h:453
info
MIPS optimizations info
Definition: mips.txt:2
variant_info::video
char video[MAX_FIELD_LEN]
Definition: hls.c:343
av_strtok
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().
Definition: avstring.c:178
av_match_ext
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.
Definition: format.c:41
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
playlist::time_offset_flag
int time_offset_flag
Definition: hls.c:124
KEY_NONE
@ KEY_NONE
Definition: hls.c:71
HLSContext::n_playlists
int n_playlists
Definition: hls.c:209
variant_info::audio
char audio[MAX_FIELD_LEN]
Definition: hls.c:342
av_rescale_q
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:142
playlist::init_sections
struct segment ** init_sections
Definition: hls.c:174
ID3v2ExtraMetaAPIC::buf
AVBufferRef * buf
Definition: id3v2.h:66
playlist::init_sec_buf
uint8_t * init_sec_buf
Definition: hls.c:138
add_renditions_to_variant
static void add_renditions_to_variant(HLSContext *c, struct variant *var, enum AVMediaType type, const char *group_id)
Definition: hls.c:1640
HLSContext::allowed_extensions
char * allowed_extensions
Definition: hls.c:224
playlist::id3_buf
uint8_t * id3_buf
Definition: hls.c:151
codec_id
enum AVCodecID codec_id
Definition: vaapi_decode.c:389
FLAGS
#define FLAGS
Definition: hls.c:2558
playlist::read_buffer
uint8_t * read_buffer
Definition: hls.c:104
key
const char * key
Definition: hwcontext_opencl.c:174
HLSContext::crypto_ctx
HLSCryptoContext crypto_ctx
Definition: hls.c:231
av_usleep
int av_usleep(unsigned usec)
Sleep for a period of time.
Definition: time.c:84
playlist::id3_buf_size
unsigned int id3_buf_size
Definition: hls.c:152
HLSContext::seg_format_opts
AVDictionary * seg_format_opts
Definition: hls.c:223
hls_read_header
static int hls_read_header(AVFormatContext *s)
Definition: hls.c:1924
init_section_info
Definition: hls.c:412
ff_hex_to_data
int ff_hex_to_data(uint8_t *data, const char *p)
Parse a string of hexadecimal strings.
Definition: utils.c:476
AVFormatContext::max_analyze_duration
int64_t max_analyze_duration
Maximum duration (in AV_TIME_BASE units) of the data read from input in avformat_find_stream_info().
Definition: avformat.h:1277
handle_id3
static void handle_id3(AVIOContext *pb, struct playlist *pls)
Definition: hls.c:1135
if
if(ret)
Definition: filter_design.txt:179
free_variant_list
static void free_variant_list(HLSContext *c)
Definition: hls.c:292
ID3v2ExtraMeta::tag
const char * tag
Definition: id3v2.h:85
rendition::group_id
char group_id[MAX_FIELD_LEN]
Definition: hls.c:186
AVDISCARD_ALL
@ AVDISCARD_ALL
discard all
Definition: defs.h:219
AVFormatContext
Format I/O context.
Definition: avformat.h:1115
internal.h
HLSContext::interrupt_callback
AVIOInterruptCB * interrupt_callback
Definition: hls.c:221
opts
AVDictionary * opts
Definition: movenc.c:50
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:864
variant::url
char url[MAX_URL_SIZE]
Definition: hlsproto.c:53
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVSEEK_FLAG_BACKWARD
#define AVSEEK_FLAG_BACKWARD
Definition: avformat.h:2224
read_header
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:550
current_segment
static struct segment * current_segment(struct playlist *pls)
Definition: hls.c:1044
aes.h
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
variant::n_playlists
int n_playlists
Definition: hls.c:196
AVStream::time_base
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
Definition: avformat.h:880
NULL
#define NULL
Definition: coverity.c:32
variant::playlists
struct playlist ** playlists
Definition: hls.c:197
ensure_playlist
static int ensure_playlist(HLSContext *c, struct playlist **pls, const char *url)
Definition: hls.c:613
av_program_add_stream_index
void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
Definition: avformat.c:312
AVFMTCTX_NOHEADER
#define AVFMTCTX_NOHEADER
signal that no header is present (streams are added dynamically)
Definition: avformat.h:1066
ID3v2ExtraMetaPRIV::data
uint8_t * data
Definition: id3v2.h:74
fill_buf
static void fill_buf(uint8_t *data, int w, int h, int linesize, uint8_t v)
Definition: vf_fieldmatch.c:188
playlist::renditions
struct rendition ** renditions
Definition: hls.c:169
HLSContext::playlist_pb
AVIOContext * playlist_pb
Definition: hls.c:230
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
AVFMTCTX_UNSEEKABLE
#define AVFMTCTX_UNSEEKABLE
signal that the stream is definitely not seekable, and attempts to call the seek function will fail.
Definition: avformat.h:1068
ff_copy_whiteblacklists
int ff_copy_whiteblacklists(AVFormatContext *dst, const AVFormatContext *src)
Copies the whilelists from one context to the other.
Definition: avformat.c:805
free_init_section_list
static void free_init_section_list(struct playlist *pls)
Definition: hls.c:251
HLSContext::variants
struct variant ** variants
Definition: hls.c:208
update_streams_from_subdemuxer
static int update_streams_from_subdemuxer(AVFormatContext *s, struct playlist *pls)
Definition: hls.c:1861
AV_OPT_TYPE_DICT
@ AV_OPT_TYPE_DICT
Definition: opt.h:232
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
ff_id3v2_parse_apic
int ff_id3v2_parse_apic(AVFormatContext *s, ID3v2ExtraMeta *extra_meta)
Create a stream for each APIC (attached picture) extracted from the ID3v2 header.
Definition: id3v2.c:1161
HLSContext::max_reload
int max_reload
Definition: hls.c:225
AVFormatContext::pb
AVIOContext * pb
I/O context.
Definition: avformat.h:1157
ff_http_do_new_request2
int ff_http_do_new_request2(URLContext *h, const char *uri, AVDictionary **opts)
Send a new HTTP request, reusing the old connection.
Definition: http.c:457
AVProbeData
This structure contains the data a format has to probe a file.
Definition: avformat.h:452
av_aes_alloc
struct AVAES * av_aes_alloc(void)
Allocate an AVAES context.
Definition: aes.c:35
AVStream::metadata
AVDictionary * metadata
Definition: avformat.h:921
rendition_info::defaultr
char defaultr[4]
Definition: hls.c:480
HLSContext::cur_seq_no
int64_t cur_seq_no
Definition: hls.c:214
playlist::broken
int broken
Definition: hls.c:129
time.h
KeyType
KeyType
Definition: hls.c:70
playlist::id3_deferred_extra
ID3v2ExtraMeta * id3_deferred_extra
Definition: hls.c:156
HLSContext::playlists
struct playlist ** playlists
Definition: hls.c:210
playlist::n_segments
int n_segments
Definition: hls.c:126
av_packet_move_ref
void av_packet_move_ref(AVPacket *dst, AVPacket *src)
Move every field in src to dst and reset src.
Definition: avpacket.c:480
handle_init_section_args
static void handle_init_section_args(struct init_section_info *info, const char *key, int key_len, char **dest, int *dest_len)
Definition: hls.c:461
MAX_FIELD_LEN
#define MAX_FIELD_LEN
Definition: hls.c:52
INITIAL_BUFFER_SIZE
#define INITIAL_BUFFER_SIZE
Definition: hls.c:50
ID3v2_HEADER_SIZE
#define ID3v2_HEADER_SIZE
Definition: id3v2.h:30
AVSTREAM_EVENT_FLAG_METADATA_UPDATED
#define AVSTREAM_EVENT_FLAG_METADATA_UPDATED
Definition: avformat.h:991
id3_has_changed_values
static int id3_has_changed_values(struct playlist *pls, AVDictionary *metadata, ID3v2ExtraMetaAPIC *apic)
Definition: hls.c:1106
c
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
Definition: undefined.txt:32
AVCodecID
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:49
AVFormatContext::nb_streams
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1171
av_strncasecmp
int av_strncasecmp(const char *a, const char *b, size_t n)
Locale-independent case-insensitive compare.
Definition: avstring.c:217
playlist::init_sec_buf_size
unsigned int init_sec_buf_size
Definition: hls.c:139
av_rescale_rnd
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.
Definition: mathematics.c:58
options
const OptionDef options[]
avformat_find_stream_info
int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
Read packets of a media file to get stream information.
Definition: demux.c:2436
AVIOContext
Bytestream IO Context.
Definition: avio.h:166
rendition_info::forced
char forced[4]
Definition: hls.c:481
AVMediaType
AVMediaType
Definition: avutil.h:199
AVPacket::size
int size
Definition: packet.h:492
playlist::cur_init_section
struct segment * cur_init_section
Definition: hls.c:137
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:106
avformat_alloc_context
AVFormatContext * avformat_alloc_context(void)
Allocate an AVFormatContext.
Definition: options.c:166
AVIOContext::buf_end
unsigned char * buf_end
End of the data, may be less than buffer+buffer_size if the read function returned less data than req...
Definition: avio.h:234
HLSCryptoContext
Definition: hls_sample_encryption.h:43
new_rendition
static struct rendition * new_rendition(HLSContext *c, struct rendition_info *info, const char *url_base)
Definition: hls.c:485
av_err2str
#define av_err2str(errnum)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: error.h:121
HLSContext::first_timestamp
int64_t first_timestamp
Definition: hls.c:219
FFIOContext::pub
AVIOContext pub
Definition: avio_internal.h:29
playlist::cur_seg_offset
int64_t cur_seg_offset
Definition: hls.c:133
ffio_geturlcontext
struct URLContext * ffio_geturlcontext(AVIOContext *s)
Return the URLContext associated with the AVIOContext.
Definition: aviobuf.c:1028
size
int size
Definition: twinvq_data.h:10344
ID3v2_DEFAULT_MAGIC
#define ID3v2_DEFAULT_MAGIC
Default magic bytes for ID3v2 header: "ID3".
Definition: id3v2.h:35
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
ID3v2ExtraMeta::data
union ID3v2ExtraMeta::@298 data
avpriv_report_missing_feature
void avpriv_report_missing_feature(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
AVStream::event_flags
int event_flags
Flags indicating events happening on the stream, a combination of AVSTREAM_EVENT_FLAG_*.
Definition: avformat.h:984
hls_sample_encryption.h
rendition_info::characteristics
char characteristics[MAX_CHARACTERISTICS_LEN]
Definition: hls.c:482
ff_format_io_close
int ff_format_io_close(AVFormatContext *s, AVIOContext **pb)
Definition: avformat.c:843
av_demuxer_iterate
const AVInputFormat * av_demuxer_iterate(void **opaque)
Iterate over all registered demuxers.
Definition: allformats.c:597
PLS_TYPE_EVENT
@ PLS_TYPE_EVENT
Definition: hls.c:92
AVMEDIA_TYPE_UNKNOWN
@ AVMEDIA_TYPE_UNKNOWN
Usually treated as AVMEDIA_TYPE_DATA.
Definition: avutil.h:200
get_timebase
static AVRational get_timebase(struct playlist *pls)
Definition: hls.c:2267
diff
static av_always_inline int diff(const struct color_info *a, const struct color_info *b, const int trans_thresh)
Definition: vf_paletteuse.c:164
AV_OPT_SEARCH_CHILDREN
#define AV_OPT_SEARCH_CHILDREN
Search in possible children of the given object first.
Definition: opt.h:563
AV_DISPOSITION_HEARING_IMPAIRED
#define AV_DISPOSITION_HEARING_IMPAIRED
The stream is intended for hearing impaired audiences.
Definition: avformat.h:756
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:490
offset
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
Definition: writing_filters.txt:86
update_init_section
static int update_init_section(struct playlist *pls, struct segment *seg)
Definition: hls.c:1360
line
Definition: graph2dot.c:48
playlist::id3_found
int id3_found
Definition: hls.c:154
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:497
av_packet_alloc
AVPacket * av_packet_alloc(void)
Allocate an AVPacket and set its fields to default values.
Definition: avpacket.c:63
av_dict_free
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values.
Definition: dict.c:225
av_strstart
int av_strstart(const char *str, const char *pfx, const char **ptr)
Return non-zero if pfx is a prefix of str.
Definition: avstring.c:36
playlist::seek_flags
int seek_flags
Definition: hls.c:161
av_probe_input_buffer
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.
Definition: format.c:343
read_data
static int read_data(void *opaque, uint8_t *buf, int buf_size)
Definition: hls.c:1470
ID3v2ExtraMetaAPIC
Definition: id3v2.h:65
rendition::playlist
struct playlist * playlist
Definition: hls.c:185
HLSAudioSetupInfo::codec_id
enum AVCodecID codec_id
Definition: hls_sample_encryption.h:50
AVBufferRef::size
size_t size
Size of data in bytes.
Definition: buffer.h:94
playlist::ctx
AVFormatContext * ctx
Definition: hls.c:111
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:191
free_segment_list
static void free_segment_list(struct playlist *pls)
Definition: hls.c:244
init_section_info::uri
char uri[MAX_URL_SIZE]
Definition: hls.c:413
ff_hls_senc_decrypt_frame
int ff_hls_senc_decrypt_frame(enum AVCodecID codec_id, HLSCryptoContext *crypto_ctx, AVPacket *pkt)
Definition: hls_sample_encryption.c:385
playlist::pb
FFIOContext pb
Definition: hls.c:103
HLSContext::seg_max_retry
int seg_max_retry
Definition: hls.c:229
add_metadata_from_renditions
static void add_metadata_from_renditions(AVFormatContext *s, struct playlist *pls, enum AVMediaType type)
Definition: hls.c:1664
key_info::method
char method[11]
Definition: hls.c:393
next_segment
static struct segment * next_segment(struct playlist *pls)
Definition: hls.c:1052
PLS_TYPE_UNSPECIFIED
@ PLS_TYPE_UNSPECIFIED
Definition: hls.c:91
URLContext
Definition: url.h:37
playlist::key
uint8_t key[16]
Definition: hls.c:144
update_noheader_flag
static void update_noheader_flag(AVFormatContext *s)
Definition: hls.c:1886
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: codec_id.h:50
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:255
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:484
avio_internal.h
playlist::needed
int needed
Definition: hls.c:128
rendition::name
char name[MAX_FIELD_LEN]
Definition: hls.c:188
AV_TIME_BASE
#define AV_TIME_BASE
Internal time base represented as integer.
Definition: avutil.h:254
rendition
Definition: hls.c:183
ff_id3v2_read_dict
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.
Definition: id3v2.c:1133
ff_match_url_ext
int ff_match_url_ext(const char *url, const char *extensions)
Return a positive value if the given url has one of the given extensions, negative AVERROR on error,...
Definition: format.c:54
select_cur_seq_no
static int64_t select_cur_seq_no(HLSContext *c, struct playlist *pls)
Definition: hls.c:1726
HLSContext::m3u8_hold_counters
int m3u8_hold_counters
Definition: hls.c:215
variant::video_group
char video_group[MAX_FIELD_LEN]
Definition: hls.c:200
AV_ROUND_DOWN
@ AV_ROUND_DOWN
Round toward -infinity.
Definition: mathematics.h:133
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
HLSContext
Definition: hls.c:204
url.h
default_reload_interval
static int64_t default_reload_interval(struct playlist *pls)
Definition: hls.c:1417
tb
#define tb
Definition: regdef.h:68
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:254
AVProgram
New fields can be added to the end with minor version bumps.
Definition: avformat.h:1039
demux.h
len
int len
Definition: vorbis_enc_data.h:426
HLSContext::ctx
AVFormatContext * ctx
Definition: hls.c:206
ID3v2ExtraMetaPRIV::datasize
uint32_t datasize
Definition: id3v2.h:75
open_url_keepalive
static int open_url_keepalive(AVFormatContext *s, AVIOContext **pb, const char *url, AVDictionary **options)
Definition: hls.c:623
free_playlist_list
static void free_playlist_list(HLSContext *c)
Definition: hls.c:263
ff_hls_senc_parse_audio_setup_info
int ff_hls_senc_parse_audio_setup_info(AVStream *st, HLSAudioSetupInfo *info)
Definition: hls_sample_encryption.c:91
PlaylistType
PlaylistType
Definition: hls.c:90
rendition_info::language
char language[MAX_FIELD_LEN]
Definition: hls.c:477
playlist::parent
AVFormatContext * parent
Definition: hls.c:109
AVStream::disposition
int disposition
Stream disposition - a combination of AV_DISPOSITION_* flags.
Definition: avformat.h:910
AV_DISPOSITION_VISUAL_IMPAIRED
#define AV_DISPOSITION_VISUAL_IMPAIRED
The stream is intended for visually impaired audiences.
Definition: avformat.h:760
HLSContext::http_persistent
int http_persistent
Definition: hls.c:226
ff_id3v2_tag_len
int ff_id3v2_tag_len(const uint8_t *buf)
Get the length of an ID3v2 tag.
Definition: id3v2.c:157
av_compare_mod
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.
Definition: mathematics.c:160
AVStream::id
int id
Format-specific stream ID.
Definition: avformat.h:853
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:841
playlist::index
int index
Definition: hls.c:110
avio_seek
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:278
FFSWAP
#define FFSWAP(type, a, b)
Definition: macros.h:52
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:71
playlist::audio_setup_info
HLSAudioSetupInfo audio_setup_info
Definition: hls.c:158
pos
unsigned int pos
Definition: spdifenc.c:413
avformat.h
dict.h
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: defs.h:40
playlist::m3u8_hold_counters
int m3u8_hold_counters
Definition: hls.c:132
AV_DICT_MATCH_CASE
#define AV_DICT_MATCH_CASE
Only get an entry with exact-case key match.
Definition: dict.h:74
HLSContext::prefer_x_start
int prefer_x_start
Definition: hls.c:217
open_input
static int open_input(HLSContext *c, struct playlist *pls, struct segment *seg, AVIOContext **in)
Definition: hls.c:1277
hls_read_seek
static int hls_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
Definition: hls.c:2429
new_playlist
static struct playlist * new_playlist(HLSContext *c, const char *url, const char *base)
Definition: hls.c:313
HLSContext::live_start_index
int live_start_index
Definition: hls.c:216
set_stream_info_from_input_stream
static int set_stream_info_from_input_stream(AVStream *st, struct playlist *pls, AVStream *ist)
Definition: hls.c:1837
AVStream::index
int index
stream index in AVFormatContext
Definition: avformat.h:847
playlist::main_streams
AVStream ** main_streams
Definition: hls.c:117
MAX_URL_SIZE
#define MAX_URL_SIZE
Definition: internal.h:30
playlist::id3_initial
AVDictionary * id3_initial
Definition: hls.c:153
parse_playlist
static int parse_playlist(HLSContext *c, const char *url, struct playlist *pls, AVIOContext *in)
Definition: hls.c:728
rendition_info
Definition: hls.c:473
AVRational::den
int den
Denominator.
Definition: rational.h:60
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:225
init_section_info::byterange
char byterange[32]
Definition: hls.c:414
avformat_free_context
void avformat_free_context(AVFormatContext *s)
Free an AVFormatContext and all its streams.
Definition: avformat.c:102
AVFMT_NOGENSEARCH
#define AVFMT_NOGENSEARCH
Format does not allow to fall back on generic search.
Definition: avformat.h:487
avio_read
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:659
ff_parse_key_val_cb
void(* ff_parse_key_val_cb)(void *context, const char *key, int key_len, char **dest, int *dest_len)
Callback function type for ff_parse_key_value.
Definition: internal.h:559
AVFormatContext::io_open
int(* io_open)(struct AVFormatContext *s, AVIOContext **pb, const char *url, int flags, AVDictionary **options)
A callback for opening new IO streams.
Definition: avformat.h:1674
AVIOContext::eof_reached
int eof_reached
true if was unable to read due to error or eof
Definition: avio.h:248
playlist::last_seq_no
int64_t last_seq_no
Definition: hls.c:131
variant::bandwidth
int bandwidth
Definition: hls.c:193
AVPacket::stream_index
int stream_index
Definition: packet.h:493
segment
Definition: hls.c:76
av_dict_set_int
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.
Definition: dict.c:169
AVIO_FLAG_READ
#define AVIO_FLAG_READ
read-only
Definition: avio.h:636
add_stream_to_programs
static void add_stream_to_programs(AVFormatContext *s, struct playlist *pls, AVStream *stream)
Definition: hls.c:1811
av_strdup
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:270
hls_probe
static int hls_probe(const AVProbeData *p)
Definition: hls.c:2521
rendition_info::name
char name[MAX_FIELD_LEN]
Definition: hls.c:479
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
read_probe
static int read_probe(const AVProbeData *p)
Definition: cdg.c:29
playlist::is_id3_timestamped
int is_id3_timestamped
Definition: hls.c:148
AVFMT_TS_DISCONT
#define AVFMT_TS_DISCONT
Format allows timestamp discontinuities.
Definition: avformat.h:482
playlist::init_sec_data_len
unsigned int init_sec_data_len
Definition: hls.c:140
hls_read_packet
static int hls_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: hls.c:2284
AVIOContext::buffer
unsigned char * buffer
Start of the buffer.
Definition: avio.h:231
handle_variant_args
static void handle_variant_args(struct variant_info *info, const char *key, int key_len, char **dest, int *dest_len)
Definition: hls.c:373
find_timestamp_in_playlist
static int find_timestamp_in_playlist(HLSContext *c, struct playlist *pls, int64_t timestamp, int64_t *seq_no, int64_t *seg_start_ts)
Definition: hls.c:1696
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
AVDictionaryEntry
Definition: dict.h:89
ff_make_absolute_url
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.
Definition: url.c:321
variant_info::bandwidth
char bandwidth[20]
Definition: hls.c:340
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:55
AVPacket
This structure stores compressed data.
Definition: packet.h:468
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:244
segment::url
char * url
Definition: hls.c:80
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
av_dict_set
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition: dict.c:88
av_fast_malloc
void av_fast_malloc(void *ptr, unsigned int *size, size_t min_size)
Allocate a buffer, reusing the given one if large enough.
Definition: mem.c:555
av_dict_copy
int av_dict_copy(AVDictionary **dst, const AVDictionary *src, int flags)
Copy entries from one AVDictionary struct into another.
Definition: dict.c:239
ff_id3v2_free_extra_meta
void ff_id3v2_free_extra_meta(ID3v2ExtraMeta **extra_meta)
Free memory allocated parsing special (non-text) metadata.
Definition: id3v2.c:1145
segment::init_section
struct segment * init_section
Definition: hls.c:85
avio_find_protocol_name
const char * avio_find_protocol_name(const char *url)
Return the name of the protocol that will handle the passed URL.
Definition: avio.c:468
FFStream::need_context_update
int need_context_update
Whether the internal avctx needs to be updated from codecpar (after a late change to codecpar)
Definition: internal.h:243
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:474
AVERROR_BUG
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
Definition: error.h:52
av_strlcpy
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.
Definition: avstring.c:85
av_opt_get
int av_opt_get(void *obj, const char *name, int search_flags, uint8_t **out_val)
Definition: opt.c:837
playlist::last_load_time
int64_t last_load_time
Definition: hls.c:134
ff_id3v2_parse_priv
int ff_id3v2_parse_priv(AVFormatContext *s, ID3v2ExtraMeta *extra_meta)
Add metadata for all PRIV tags in the ID3v2 header.
Definition: id3v2.c:1257
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
rendition::disposition
int disposition
Definition: hls.c:189
playlist::url
char url[MAX_URL_SIZE]
Definition: hls.c:102
AVERROR_EXIT
#define AVERROR_EXIT
Immediate exit was requested; the called function should not be restarted.
Definition: error.h:58
playlist::id3_changed
int id3_changed
Definition: hls.c:155
AVDictionaryEntry::value
char * value
Definition: dict.h:91
segment::iv
uint8_t iv[16]
Definition: hls.c:83
avstring.h
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Definition: opt.h:229
HLSAudioSetupInfo
Definition: hls_sample_encryption.h:49
handle_key_args
static void handle_key_args(struct key_info *info, const char *key, int key_len, char **dest, int *dest_len)
Definition: hls.c:397
AVStream::pts_wrap_bits
int pts_wrap_bits
Number of bits in timestamps.
Definition: avformat.h:1016
parse_id3
static void parse_id3(AVFormatContext *s, AVIOContext *pb, AVDictionary **metadata, int64_t *dts, HLSAudioSetupInfo *audio_setup_info, ID3v2ExtraMetaAPIC **apic, ID3v2ExtraMeta **extra_meta)
Definition: hls.c:1077
http.h
AVIOContext::buf_ptr
unsigned char * buf_ptr
Current position in the buffer.
Definition: avio.h:233
read_from_url
static int read_from_url(struct playlist *pls, struct segment *seg, uint8_t *buf, int buf_size)
Definition: hls.c:1060
ff_id3v2_parse_priv_dict
int ff_id3v2_parse_priv_dict(AVDictionary **metadata, ID3v2ExtraMeta *extra_meta)
Parse PRIV tags into a dictionary.
Definition: id3v2.c:1217
AVERROR_PROTOCOL_NOT_FOUND
#define AVERROR_PROTOCOL_NOT_FOUND
Protocol not found.
Definition: error.h:65
snprintf
#define snprintf
Definition: snprintf.h:34
AVFormatContext::priv_data
void * priv_data
Format private data.
Definition: avformat.h:1143
intercept_id3
static void intercept_id3(struct playlist *pls, uint8_t *buf, int buf_size, int *len)
Definition: hls.c:1177
rendition::language
char language[MAX_FIELD_LEN]
Definition: hls.c:187
ID3v2ExtraMetaPRIV
Definition: id3v2.h:72
av_dict_iterate
const AVDictionaryEntry * av_dict_iterate(const AVDictionary *m, const AVDictionaryEntry *prev)
Iterate over a dictionary.
Definition: dict.c:44
AV_RB64
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
Definition: bytestream.h:95
ID3v2ExtraMetaPRIV::owner
uint8_t * owner
Definition: id3v2.h:73
HLSContext::renditions
struct rendition ** renditions
Definition: hls.c:212
AVFMT_EVENT_FLAG_METADATA_UPDATED
#define AVFMT_EVENT_FLAG_METADATA_UPDATED
Definition: avformat.h:1431
rendition_info::group_id
char group_id[MAX_FIELD_LEN]
Definition: hls.c:476
ff_id3v2_match
int ff_id3v2_match(const uint8_t *buf, const char *magic)
Detect ID3v2 Header.
Definition: id3v2.c:144
key_info
Definition: hls.c:391
avcodec_parameters_copy
int avcodec_parameters_copy(AVCodecParameters *dst, const AVCodecParameters *src)
Copy the contents of src to dst.
Definition: codec_par.c:106
ff_hls_demuxer
const AVInputFormat ff_hls_demuxer
Definition: hls.c:2592
playlist::pkt
AVPacket * pkt
Definition: hls.c:112
ff_parse_key_value
void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf, void *context)
Parse a string with comma-separated key=value pairs.
Definition: utils.c:504
playlist::has_noheader_flag
int has_noheader_flag
Definition: hls.c:113
avio_feof
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
Definition: aviobuf.c:393
ID3v2ExtraMeta::priv
ID3v2ExtraMetaPRIV priv
Definition: id3v2.h:91