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