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