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