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