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