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