git.sesse.net Git - ffmpeg/blob - libavformat/hls.c

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