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