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