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