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