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