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