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