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