af7c34ce7706c5c7fec5f027e63c9281dcd21915
[ffmpeg.git] / 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/intreadwrite.h"
31 #include "libavutil/mathematics.h"
32 #include "libavutil/opt.h"
33 #include "libavutil/dict.h"
34 #include "libavutil/time.h"
35 #include "avformat.h"
36 #include "internal.h"
37 #include "avio_internal.h"
38 #include "url.h"
39
40 #define INITIAL_BUFFER_SIZE 32768
41
42 #define MAX_FIELD_LEN 64
43 #define MAX_CHARACTERISTICS_LEN 512
44
45 /*
46  * An apple http stream consists of a playlist with media segment files,
47  * played sequentially. There may be several playlists with the same
48  * video content, in different bandwidth variants, that are played in
49  * parallel (preferably only one bandwidth variant at a time). In this case,
50  * the user supplied the url to a main playlist that only lists the variant
51  * playlists.
52  *
53  * If the main playlist doesn't point at any variants, we still create
54  * one anonymous toplevel variant for this, to maintain the structure.
55  */
56
57 enum KeyType {
58     KEY_NONE,
59     KEY_AES_128,
60 };
61
62 struct segment {
63     int64_t duration;
64     char url[MAX_URL_SIZE];
65     char key[MAX_URL_SIZE];
66     enum KeyType key_type;
67     uint8_t iv[16];
68 };
69
70 struct rendition;
71
72 /*
73  * Each playlist has its own demuxer. If it currently is active,
74  * it has an open AVIOContext too, and potentially an AVPacket
75  * containing the next packet from this stream.
76  */
77 struct playlist {
78     char url[MAX_URL_SIZE];
79     AVIOContext pb;
80     uint8_t* read_buffer;
81     URLContext *input;
82     AVFormatContext *parent;
83     int index;
84     AVFormatContext *ctx;
85     AVPacket pkt;
86     int stream_offset;
87
88     int finished;
89     int64_t target_duration;
90     int start_seq_no;
91     int n_segments;
92     struct segment **segments;
93     int needed, cur_needed;
94     int cur_seq_no;
95     int64_t last_load_time;
96
97     char key_url[MAX_URL_SIZE];
98     uint8_t key[16];
99
100     /* Renditions associated with this playlist, if any.
101      * Alternative rendition playlists have a single rendition associated
102      * with them, and variant main Media Playlists may have
103      * multiple (playlist-less) renditions associated with them. */
104     int n_renditions;
105     struct rendition **renditions;
106 };
107
108 /*
109  * Renditions are e.g. alternative subtitle or audio streams.
110  * The rendition may either be an external playlist or it may be
111  * contained in the main Media Playlist of the variant (in which case
112  * playlist is NULL).
113  */
114 struct rendition {
115     enum AVMediaType type;
116     struct playlist *playlist;
117     char group_id[MAX_FIELD_LEN];
118     char language[MAX_FIELD_LEN];
119     char name[MAX_FIELD_LEN];
120     int disposition;
121 };
122
123 struct variant {
124     int bandwidth;
125
126     /* every variant contains at least the main Media Playlist in index 0 */
127     int n_playlists;
128     struct playlist **playlists;
129
130     char audio_group[MAX_FIELD_LEN];
131     char video_group[MAX_FIELD_LEN];
132     char subtitles_group[MAX_FIELD_LEN];
133 };
134
135 typedef struct HLSContext {
136     int n_variants;
137     struct variant **variants;
138     int n_playlists;
139     struct playlist **playlists;
140     int n_renditions;
141     struct rendition **renditions;
142
143     int cur_seq_no;
144     int end_of_segment;
145     int first_packet;
146     int64_t first_timestamp;
147     int64_t seek_timestamp;
148     int seek_flags;
149     AVIOInterruptCB *interrupt_callback;
150     char *user_agent;                    ///< holds HTTP user agent set as an AVOption to the HTTP protocol context
151     char *cookies;                       ///< holds HTTP cookie values set in either the initial response or as an AVOption to the HTTP protocol context
152     char *headers;                       ///< holds HTTP headers set as an AVOption to the HTTP protocol context
153 } HLSContext;
154
155 static int read_chomp_line(AVIOContext *s, char *buf, int maxlen)
156 {
157     int len = ff_get_line(s, buf, maxlen);
158     while (len > 0 && av_isspace(buf[len - 1]))
159         buf[--len] = '\0';
160     return len;
161 }
162
163 static void free_segment_list(struct playlist *pls)
164 {
165     int i;
166     for (i = 0; i < pls->n_segments; i++)
167         av_free(pls->segments[i]);
168     av_freep(&pls->segments);
169     pls->n_segments = 0;
170 }
171
172 static void free_playlist_list(HLSContext *c)
173 {
174     int i;
175     for (i = 0; i < c->n_playlists; i++) {
176         struct playlist *pls = c->playlists[i];
177         free_segment_list(pls);
178         av_freep(&pls->renditions);
179         av_free_packet(&pls->pkt);
180         av_free(pls->pb.buffer);
181         if (pls->input)
182             ffurl_close(pls->input);
183         if (pls->ctx) {
184             pls->ctx->pb = NULL;
185             avformat_close_input(&pls->ctx);
186         }
187         av_free(pls);
188     }
189     av_freep(&c->playlists);
190     av_freep(&c->cookies);
191     av_freep(&c->user_agent);
192     c->n_playlists = 0;
193 }
194
195 static void free_variant_list(HLSContext *c)
196 {
197     int i;
198     for (i = 0; i < c->n_variants; i++) {
199         struct variant *var = c->variants[i];
200         av_freep(&var->playlists);
201         av_free(var);
202     }
203     av_freep(&c->variants);
204     c->n_variants = 0;
205 }
206
207 static void free_rendition_list(HLSContext *c)
208 {
209     int i;
210     for (i = 0; i < c->n_renditions; i++)
211         av_free(c->renditions[i]);
212     av_freep(&c->renditions);
213     c->n_renditions = 0;
214 }
215
216 /*
217  * Used to reset a statically allocated AVPacket to a clean slate,
218  * containing no data.
219  */
220 static void reset_packet(AVPacket *pkt)
221 {
222     av_init_packet(pkt);
223     pkt->data = NULL;
224 }
225
226 static struct playlist *new_playlist(HLSContext *c, const char *url,
227                                      const char *base)
228 {
229     struct playlist *pls = av_mallocz(sizeof(struct playlist));
230     if (!pls)
231         return NULL;
232     reset_packet(&pls->pkt);
233     ff_make_absolute_url(pls->url, sizeof(pls->url), base, url);
234     dynarray_add(&c->playlists, &c->n_playlists, pls);
235     return pls;
236 }
237
238 struct variant_info {
239     char bandwidth[20];
240     /* variant group ids: */
241     char audio[MAX_FIELD_LEN];
242     char video[MAX_FIELD_LEN];
243     char subtitles[MAX_FIELD_LEN];
244 };
245
246 static struct variant *new_variant(HLSContext *c, struct variant_info *info,
247                                    const char *url, const char *base)
248 {
249     struct variant *var;
250     struct playlist *pls;
251
252     pls = new_playlist(c, url, base);
253     if (!pls)
254         return NULL;
255
256     var = av_mallocz(sizeof(struct variant));
257     if (!var)
258         return NULL;
259
260     if (info) {
261         var->bandwidth = atoi(info->bandwidth);
262         strcpy(var->audio_group, info->audio);
263         strcpy(var->video_group, info->video);
264         strcpy(var->subtitles_group, info->subtitles);
265     }
266
267     dynarray_add(&c->variants, &c->n_variants, var);
268     dynarray_add(&var->playlists, &var->n_playlists, pls);
269     return var;
270 }
271
272 static void handle_variant_args(struct variant_info *info, const char *key,
273                                 int key_len, char **dest, int *dest_len)
274 {
275     if (!strncmp(key, "BANDWIDTH=", key_len)) {
276         *dest     =        info->bandwidth;
277         *dest_len = sizeof(info->bandwidth);
278     } else if (!strncmp(key, "AUDIO=", key_len)) {
279         *dest     =        info->audio;
280         *dest_len = sizeof(info->audio);
281     } else if (!strncmp(key, "VIDEO=", key_len)) {
282         *dest     =        info->video;
283         *dest_len = sizeof(info->video);
284     } else if (!strncmp(key, "SUBTITLES=", key_len)) {
285         *dest     =        info->subtitles;
286         *dest_len = sizeof(info->subtitles);
287     }
288 }
289
290 struct key_info {
291      char uri[MAX_URL_SIZE];
292      char method[10];
293      char iv[35];
294 };
295
296 static void handle_key_args(struct key_info *info, const char *key,
297                             int key_len, char **dest, int *dest_len)
298 {
299     if (!strncmp(key, "METHOD=", key_len)) {
300         *dest     =        info->method;
301         *dest_len = sizeof(info->method);
302     } else if (!strncmp(key, "URI=", key_len)) {
303         *dest     =        info->uri;
304         *dest_len = sizeof(info->uri);
305     } else if (!strncmp(key, "IV=", key_len)) {
306         *dest     =        info->iv;
307         *dest_len = sizeof(info->iv);
308     }
309 }
310
311 struct rendition_info {
312     char type[16];
313     char uri[MAX_URL_SIZE];
314     char group_id[MAX_FIELD_LEN];
315     char language[MAX_FIELD_LEN];
316     char assoc_language[MAX_FIELD_LEN];
317     char name[MAX_FIELD_LEN];
318     char defaultr[4];
319     char forced[4];
320     char characteristics[MAX_CHARACTERISTICS_LEN];
321 };
322
323 static struct rendition *new_rendition(HLSContext *c, struct rendition_info *info,
324                                       const char *url_base)
325 {
326     struct rendition *rend;
327     enum AVMediaType type = AVMEDIA_TYPE_UNKNOWN;
328     char *characteristic;
329     char *chr_ptr;
330     char *saveptr;
331
332     if (!strcmp(info->type, "AUDIO"))
333         type = AVMEDIA_TYPE_AUDIO;
334     else if (!strcmp(info->type, "VIDEO"))
335         type = AVMEDIA_TYPE_VIDEO;
336     else if (!strcmp(info->type, "SUBTITLES"))
337         type = AVMEDIA_TYPE_SUBTITLE;
338     else if (!strcmp(info->type, "CLOSED-CAPTIONS"))
339         /* CLOSED-CAPTIONS is ignored since we do not support CEA-608 CC in
340          * AVC SEI RBSP anyway */
341         return NULL;
342
343     if (type == AVMEDIA_TYPE_UNKNOWN)
344         return NULL;
345
346     /* URI is mandatory for subtitles as per spec */
347     if (type == AVMEDIA_TYPE_SUBTITLE && !info->uri[0])
348         return NULL;
349
350     /* TODO: handle subtitles (each segment has to parsed separately) */
351     if (type == AVMEDIA_TYPE_SUBTITLE)
352         return NULL;
353
354     rend = av_mallocz(sizeof(struct rendition));
355     if (!rend)
356         return NULL;
357
358     dynarray_add(&c->renditions, &c->n_renditions, rend);
359
360     rend->type = type;
361     strcpy(rend->group_id, info->group_id);
362     strcpy(rend->language, info->language);
363     strcpy(rend->name, info->name);
364
365     /* add the playlist if this is an external rendition */
366     if (info->uri[0]) {
367         rend->playlist = new_playlist(c, info->uri, url_base);
368         if (rend->playlist)
369             dynarray_add(&rend->playlist->renditions,
370                          &rend->playlist->n_renditions, rend);
371     }
372
373     if (info->assoc_language[0]) {
374         int langlen = strlen(rend->language);
375         if (langlen < sizeof(rend->language) - 3) {
376             rend->language[langlen] = ',';
377             strncpy(rend->language + langlen + 1, info->assoc_language,
378                     sizeof(rend->language) - langlen - 2);
379         }
380     }
381
382     if (!strcmp(info->defaultr, "YES"))
383         rend->disposition |= AV_DISPOSITION_DEFAULT;
384     if (!strcmp(info->forced, "YES"))
385         rend->disposition |= AV_DISPOSITION_FORCED;
386
387     chr_ptr = info->characteristics;
388     while ((characteristic = av_strtok(chr_ptr, ",", &saveptr))) {
389         if (!strcmp(characteristic, "public.accessibility.describes-music-and-sound"))
390             rend->disposition |= AV_DISPOSITION_HEARING_IMPAIRED;
391         else if (!strcmp(characteristic, "public.accessibility.describes-video"))
392             rend->disposition |= AV_DISPOSITION_VISUAL_IMPAIRED;
393
394         chr_ptr = NULL;
395     }
396
397     return rend;
398 }
399
400 static void handle_rendition_args(struct rendition_info *info, const char *key,
401                                   int key_len, char **dest, int *dest_len)
402 {
403     if (!strncmp(key, "TYPE=", key_len)) {
404         *dest     =        info->type;
405         *dest_len = sizeof(info->type);
406     } else if (!strncmp(key, "URI=", key_len)) {
407         *dest     =        info->uri;
408         *dest_len = sizeof(info->uri);
409     } else if (!strncmp(key, "GROUP-ID=", key_len)) {
410         *dest     =        info->group_id;
411         *dest_len = sizeof(info->group_id);
412     } else if (!strncmp(key, "LANGUAGE=", key_len)) {
413         *dest     =        info->language;
414         *dest_len = sizeof(info->language);
415     } else if (!strncmp(key, "ASSOC-LANGUAGE=", key_len)) {
416         *dest     =        info->assoc_language;
417         *dest_len = sizeof(info->assoc_language);
418     } else if (!strncmp(key, "NAME=", key_len)) {
419         *dest     =        info->name;
420         *dest_len = sizeof(info->name);
421     } else if (!strncmp(key, "DEFAULT=", key_len)) {
422         *dest     =        info->defaultr;
423         *dest_len = sizeof(info->defaultr);
424     } else if (!strncmp(key, "FORCED=", key_len)) {
425         *dest     =        info->forced;
426         *dest_len = sizeof(info->forced);
427     } else if (!strncmp(key, "CHARACTERISTICS=", key_len)) {
428         *dest     =        info->characteristics;
429         *dest_len = sizeof(info->characteristics);
430     }
431     /*
432      * ignored:
433      * - AUTOSELECT: client may autoselect based on e.g. system language
434      * - INSTREAM-ID: EIA-608 closed caption number ("CC1".."CC4")
435      */
436 }
437
438 static int parse_playlist(HLSContext *c, const char *url,
439                           struct playlist *pls, AVIOContext *in)
440 {
441     int ret = 0, is_segment = 0, is_variant = 0;
442     int64_t duration = 0;
443     enum KeyType key_type = KEY_NONE;
444     uint8_t iv[16] = "";
445     int has_iv = 0;
446     char key[MAX_URL_SIZE] = "";
447     char line[MAX_URL_SIZE];
448     const char *ptr;
449     int close_in = 0;
450     uint8_t *new_url = NULL;
451     struct variant_info variant_info;
452
453     if (!in) {
454         AVDictionary *opts = NULL;
455         close_in = 1;
456         /* Some HLS servers don't like being sent the range header */
457         av_dict_set(&opts, "seekable", "0", 0);
458
459         // broker prior HTTP options that should be consistent across requests
460         av_dict_set(&opts, "user-agent", c->user_agent, 0);
461         av_dict_set(&opts, "cookies", c->cookies, 0);
462         av_dict_set(&opts, "headers", c->headers, 0);
463
464         ret = avio_open2(&in, url, AVIO_FLAG_READ,
465                          c->interrupt_callback, &opts);
466         av_dict_free(&opts);
467         if (ret < 0)
468             return ret;
469     }
470
471     if (av_opt_get(in, "location", AV_OPT_SEARCH_CHILDREN, &new_url) >= 0)
472         url = new_url;
473
474     read_chomp_line(in, line, sizeof(line));
475     if (strcmp(line, "#EXTM3U")) {
476         ret = AVERROR_INVALIDDATA;
477         goto fail;
478     }
479
480     if (pls) {
481         free_segment_list(pls);
482         pls->finished = 0;
483     }
484     while (!url_feof(in)) {
485         read_chomp_line(in, line, sizeof(line));
486         if (av_strstart(line, "#EXT-X-STREAM-INF:", &ptr)) {
487             is_variant = 1;
488             memset(&variant_info, 0, sizeof(variant_info));
489             ff_parse_key_value(ptr, (ff_parse_key_val_cb) handle_variant_args,
490                                &variant_info);
491         } else if (av_strstart(line, "#EXT-X-KEY:", &ptr)) {
492             struct key_info info = {{0}};
493             ff_parse_key_value(ptr, (ff_parse_key_val_cb) handle_key_args,
494                                &info);
495             key_type = KEY_NONE;
496             has_iv = 0;
497             if (!strcmp(info.method, "AES-128"))
498                 key_type = KEY_AES_128;
499             if (!strncmp(info.iv, "0x", 2) || !strncmp(info.iv, "0X", 2)) {
500                 ff_hex_to_data(iv, info.iv + 2);
501                 has_iv = 1;
502             }
503             av_strlcpy(key, info.uri, sizeof(key));
504         } else if (av_strstart(line, "#EXT-X-MEDIA:", &ptr)) {
505             struct rendition_info info = {{0}};
506             ff_parse_key_value(ptr, (ff_parse_key_val_cb) handle_rendition_args,
507                                &info);
508             new_rendition(c, &info, url);
509         } else if (av_strstart(line, "#EXT-X-TARGETDURATION:", &ptr)) {
510             if (!pls) {
511                 if (!new_variant(c, NULL, url, NULL)) {
512                     ret = AVERROR(ENOMEM);
513                     goto fail;
514                 }
515                 pls = c->playlists[c->n_playlists - 1];
516             }
517             pls->target_duration = atoi(ptr) * AV_TIME_BASE;
518         } else if (av_strstart(line, "#EXT-X-MEDIA-SEQUENCE:", &ptr)) {
519             if (!pls) {
520                 if (!new_variant(c, NULL, url, NULL)) {
521                     ret = AVERROR(ENOMEM);
522                     goto fail;
523                 }
524                 pls = c->playlists[c->n_playlists - 1];
525             }
526             pls->start_seq_no = atoi(ptr);
527         } else if (av_strstart(line, "#EXT-X-ENDLIST", &ptr)) {
528             if (pls)
529                 pls->finished = 1;
530         } else if (av_strstart(line, "#EXTINF:", &ptr)) {
531             is_segment = 1;
532             duration   = atof(ptr) * AV_TIME_BASE;
533         } else if (av_strstart(line, "#", NULL)) {
534             continue;
535         } else if (line[0]) {
536             if (is_variant) {
537                 if (!new_variant(c, &variant_info, line, url)) {
538                     ret = AVERROR(ENOMEM);
539                     goto fail;
540                 }
541                 is_variant = 0;
542             }
543             if (is_segment) {
544                 struct segment *seg;
545                 if (!pls) {
546                     if (!new_variant(c, 0, url, NULL)) {
547                         ret = AVERROR(ENOMEM);
548                         goto fail;
549                     }
550                     pls = c->playlists[c->n_playlists - 1];
551                 }
552                 seg = av_malloc(sizeof(struct segment));
553                 if (!seg) {
554                     ret = AVERROR(ENOMEM);
555                     goto fail;
556                 }
557                 seg->duration = duration;
558                 seg->key_type = key_type;
559                 if (has_iv) {
560                     memcpy(seg->iv, iv, sizeof(iv));
561                 } else {
562                     int seq = pls->start_seq_no + pls->n_segments;
563                     memset(seg->iv, 0, sizeof(seg->iv));
564                     AV_WB32(seg->iv + 12, seq);
565                 }
566                 ff_make_absolute_url(seg->key, sizeof(seg->key), url, key);
567                 ff_make_absolute_url(seg->url, sizeof(seg->url), url, line);
568                 dynarray_add(&pls->segments, &pls->n_segments, seg);
569                 is_segment = 0;
570             }
571         }
572     }
573     if (pls)
574         pls->last_load_time = av_gettime();
575
576 fail:
577     av_free(new_url);
578     if (close_in)
579         avio_close(in);
580     return ret;
581 }
582
583 static int open_input(HLSContext *c, struct playlist *pls)
584 {
585     AVDictionary *opts = NULL;
586     AVDictionary *opts2 = NULL;
587     int ret;
588     struct segment *seg = pls->segments[pls->cur_seq_no - pls->start_seq_no];
589
590     // broker prior HTTP options that should be consistent across requests
591     av_dict_set(&opts, "user-agent", c->user_agent, 0);
592     av_dict_set(&opts, "cookies", c->cookies, 0);
593     av_dict_set(&opts, "headers", c->headers, 0);
594     av_dict_set(&opts, "seekable", "0", 0);
595
596     // Same opts for key request (ffurl_open mutilates the opts so it cannot be used twice)
597     av_dict_copy(&opts2, opts, 0);
598
599     if (seg->key_type == KEY_NONE) {
600         ret = ffurl_open(&pls->input, seg->url, AVIO_FLAG_READ,
601                           &pls->parent->interrupt_callback, &opts);
602         goto cleanup;
603     } else if (seg->key_type == KEY_AES_128) {
604         char iv[33], key[33], url[MAX_URL_SIZE];
605         if (strcmp(seg->key, pls->key_url)) {
606             URLContext *uc;
607             if (ffurl_open(&uc, seg->key, AVIO_FLAG_READ,
608                            &pls->parent->interrupt_callback, &opts2) == 0) {
609                 if (ffurl_read_complete(uc, pls->key, sizeof(pls->key))
610                     != sizeof(pls->key)) {
611                     av_log(NULL, AV_LOG_ERROR, "Unable to read key file %s\n",
612                            seg->key);
613                 }
614                 ffurl_close(uc);
615             } else {
616                 av_log(NULL, AV_LOG_ERROR, "Unable to open key file %s\n",
617                        seg->key);
618             }
619             av_strlcpy(pls->key_url, seg->key, sizeof(pls->key_url));
620         }
621         ff_data_to_hex(iv, seg->iv, sizeof(seg->iv), 0);
622         ff_data_to_hex(key, pls->key, sizeof(pls->key), 0);
623         iv[32] = key[32] = '\0';
624         if (strstr(seg->url, "://"))
625             snprintf(url, sizeof(url), "crypto+%s", seg->url);
626         else
627             snprintf(url, sizeof(url), "crypto:%s", seg->url);
628         if ((ret = ffurl_alloc(&pls->input, url, AVIO_FLAG_READ,
629                                &pls->parent->interrupt_callback)) < 0)
630             goto cleanup;
631         av_opt_set(pls->input->priv_data, "key", key, 0);
632         av_opt_set(pls->input->priv_data, "iv", iv, 0);
633
634         if ((ret = ffurl_connect(pls->input, &opts)) < 0) {
635             ffurl_close(pls->input);
636             pls->input = NULL;
637             goto cleanup;
638         }
639         ret = 0;
640     }
641     else
642       ret = AVERROR(ENOSYS);
643
644 cleanup:
645     av_dict_free(&opts);
646     av_dict_free(&opts2);
647     return ret;
648 }
649
650 static int read_data(void *opaque, uint8_t *buf, int buf_size)
651 {
652     struct playlist *v = opaque;
653     HLSContext *c = v->parent->priv_data;
654     int ret, i;
655
656     if (!v->needed)
657         return AVERROR_EOF;
658
659 restart:
660     if (!v->input) {
661         /* If this is a live stream and the reload interval has elapsed since
662          * the last playlist reload, reload the playlists now. */
663         int64_t reload_interval = v->n_segments > 0 ?
664                                   v->segments[v->n_segments - 1]->duration :
665                                   v->target_duration;
666
667 reload:
668         if (!v->finished &&
669             av_gettime() - v->last_load_time >= reload_interval) {
670             if ((ret = parse_playlist(c, v->url, v, NULL)) < 0)
671                 return ret;
672             /* If we need to reload the playlist again below (if
673              * there's still no more segments), switch to a reload
674              * interval of half the target duration. */
675             reload_interval = v->target_duration / 2;
676         }
677         if (v->cur_seq_no < v->start_seq_no) {
678             av_log(NULL, AV_LOG_WARNING,
679                    "skipping %d segments ahead, expired from playlists\n",
680                    v->start_seq_no - v->cur_seq_no);
681             v->cur_seq_no = v->start_seq_no;
682         }
683         if (v->cur_seq_no >= v->start_seq_no + v->n_segments) {
684             if (v->finished)
685                 return AVERROR_EOF;
686             while (av_gettime() - v->last_load_time < reload_interval) {
687                 if (ff_check_interrupt(c->interrupt_callback))
688                     return AVERROR_EXIT;
689                 av_usleep(100*1000);
690             }
691             /* Enough time has elapsed since the last reload */
692             goto reload;
693         }
694
695         ret = open_input(c, v);
696         if (ret < 0)
697             return ret;
698     }
699     ret = ffurl_read(v->input, buf, buf_size);
700     if (ret > 0)
701         return ret;
702     ffurl_close(v->input);
703     v->input = NULL;
704     v->cur_seq_no++;
705
706     c->end_of_segment = 1;
707     c->cur_seq_no = v->cur_seq_no;
708
709     if (v->ctx && v->ctx->nb_streams &&
710         v->parent->nb_streams >= v->stream_offset + v->ctx->nb_streams) {
711         v->needed = 0;
712         for (i = v->stream_offset; i < v->stream_offset + v->ctx->nb_streams;
713              i++) {
714             if (v->parent->streams[i]->discard < AVDISCARD_ALL)
715                 v->needed = 1;
716         }
717     }
718     if (!v->needed) {
719         av_log(v->parent, AV_LOG_INFO, "No longer receiving playlist %d\n",
720                v->index);
721         return AVERROR_EOF;
722     }
723     goto restart;
724 }
725
726 static int playlist_in_multiple_variants(HLSContext *c, struct playlist *pls)
727 {
728     int variant_count = 0;
729     int i, j;
730
731     for (i = 0; i < c->n_variants && variant_count < 2; i++) {
732         struct variant *v = c->variants[i];
733
734         for (j = 0; j < v->n_playlists; j++) {
735             if (v->playlists[j] == pls) {
736                 variant_count++;
737                 break;
738             }
739         }
740     }
741
742     return variant_count >= 2;
743 }
744
745 static void add_renditions_to_variant(HLSContext *c, struct variant *var,
746                                       enum AVMediaType type, const char *group_id)
747 {
748     int i;
749
750     for (i = 0; i < c->n_renditions; i++) {
751         struct rendition *rend = c->renditions[i];
752
753         if (rend->type == type && !strcmp(rend->group_id, group_id)) {
754
755             if (rend->playlist)
756                 /* rendition is an external playlist
757                  * => add the playlist to the variant */
758                 dynarray_add(&var->playlists, &var->n_playlists, rend->playlist);
759             else
760                 /* rendition is part of the variant main Media Playlist
761                  * => add the rendition to the main Media Playlist */
762                 dynarray_add(&var->playlists[0]->renditions,
763                              &var->playlists[0]->n_renditions,
764                              rend);
765         }
766     }
767 }
768
769 static void add_metadata_from_renditions(AVFormatContext *s, struct playlist *pls,
770                                          enum AVMediaType type)
771 {
772     int rend_idx = 0;
773     int i;
774
775     for (i = 0; i < pls->ctx->nb_streams; i++) {
776         AVStream *st = s->streams[pls->stream_offset + i];
777
778         if (st->codec->codec_type != type)
779             continue;
780
781         for (; rend_idx < pls->n_renditions; rend_idx++) {
782             struct rendition *rend = pls->renditions[rend_idx];
783
784             if (rend->type != type)
785                 continue;
786
787             if (rend->language[0])
788                 av_dict_set(&st->metadata, "language", rend->language, 0);
789             if (rend->name[0])
790                 av_dict_set(&st->metadata, "comment", rend->name, 0);
791
792             st->disposition |= rend->disposition;
793         }
794         if (rend_idx >=pls->n_renditions)
795             break;
796     }
797 }
798
799 static int hls_read_header(AVFormatContext *s)
800 {
801     URLContext *u = (s->flags & AVFMT_FLAG_CUSTOM_IO) ? NULL : s->pb->opaque;
802     HLSContext *c = s->priv_data;
803     int ret = 0, i, j, stream_offset = 0;
804
805     c->interrupt_callback = &s->interrupt_callback;
806
807     // if the URL context is good, read important options we must broker later
808     if (u && u->prot->priv_data_class) {
809         // get the previous user agent & set back to null if string size is zero
810         av_freep(&c->user_agent);
811         av_opt_get(u->priv_data, "user-agent", 0, (uint8_t**)&(c->user_agent));
812         if (c->user_agent && !strlen(c->user_agent))
813             av_freep(&c->user_agent);
814
815         // get the previous cookies & set back to null if string size is zero
816         av_freep(&c->cookies);
817         av_opt_get(u->priv_data, "cookies", 0, (uint8_t**)&(c->cookies));
818         if (c->cookies && !strlen(c->cookies))
819             av_freep(&c->cookies);
820
821         // get the previous headers & set back to null if string size is zero
822         av_freep(&c->headers);
823         av_opt_get(u->priv_data, "headers", 0, (uint8_t**)&(c->headers));
824         if (c->headers && !strlen(c->headers))
825             av_freep(&c->headers);
826     }
827
828     if ((ret = parse_playlist(c, s->filename, NULL, s->pb)) < 0)
829         goto fail;
830
831     if (c->n_variants == 0) {
832         av_log(NULL, AV_LOG_WARNING, "Empty playlist\n");
833         ret = AVERROR_EOF;
834         goto fail;
835     }
836     /* If the playlist only contained playlists (Master Playlist),
837      * parse each individual playlist. */
838     if (c->n_playlists > 1 || c->playlists[0]->n_segments == 0) {
839         for (i = 0; i < c->n_playlists; i++) {
840             struct playlist *pls = c->playlists[i];
841             if ((ret = parse_playlist(c, pls->url, pls, NULL)) < 0)
842                 goto fail;
843         }
844     }
845
846     if (c->variants[0]->playlists[0]->n_segments == 0) {
847         av_log(NULL, AV_LOG_WARNING, "Empty playlist\n");
848         ret = AVERROR_EOF;
849         goto fail;
850     }
851
852     /* If this isn't a live stream, calculate the total duration of the
853      * stream. */
854     if (c->variants[0]->playlists[0]->finished) {
855         int64_t duration = 0;
856         for (i = 0; i < c->variants[0]->playlists[0]->n_segments; i++)
857             duration += c->variants[0]->playlists[0]->segments[i]->duration;
858         s->duration = duration;
859     }
860
861     /* Associate renditions with variants */
862     for (i = 0; i < c->n_variants; i++) {
863         struct variant *var = c->variants[i];
864
865         if (var->audio_group[0])
866             add_renditions_to_variant(c, var, AVMEDIA_TYPE_AUDIO, var->audio_group);
867         if (var->video_group[0])
868             add_renditions_to_variant(c, var, AVMEDIA_TYPE_VIDEO, var->video_group);
869         if (var->subtitles_group[0])
870             add_renditions_to_variant(c, var, AVMEDIA_TYPE_SUBTITLE, var->subtitles_group);
871     }
872
873     /* Open the demuxer for each playlist */
874     for (i = 0; i < c->n_playlists; i++) {
875         struct playlist *pls = c->playlists[i];
876         AVInputFormat *in_fmt = NULL;
877
878         if (pls->n_segments == 0)
879             continue;
880
881         if (!(pls->ctx = avformat_alloc_context())) {
882             ret = AVERROR(ENOMEM);
883             goto fail;
884         }
885
886         pls->index  = i;
887         pls->needed = 1;
888         pls->parent = s;
889
890         /* If this is a live stream with more than 3 segments, start at the
891          * third last segment. */
892         pls->cur_seq_no = pls->start_seq_no;
893         if (!pls->finished && pls->n_segments > 3)
894             pls->cur_seq_no = pls->start_seq_no + pls->n_segments - 3;
895
896         pls->read_buffer = av_malloc(INITIAL_BUFFER_SIZE);
897         ffio_init_context(&pls->pb, pls->read_buffer, INITIAL_BUFFER_SIZE, 0, pls,
898                           read_data, NULL, NULL);
899         pls->pb.seekable = 0;
900         ret = av_probe_input_buffer(&pls->pb, &in_fmt, pls->segments[0]->url,
901                                     NULL, 0, 0);
902         if (ret < 0) {
903             /* Free the ctx - it isn't initialized properly at this point,
904              * so avformat_close_input shouldn't be called. If
905              * avformat_open_input fails below, it frees and zeros the
906              * context, so it doesn't need any special treatment like this. */
907             av_log(s, AV_LOG_ERROR, "Error when loading first segment '%s'\n", pls->segments[0]->url);
908             avformat_free_context(pls->ctx);
909             pls->ctx = NULL;
910             goto fail;
911         }
912         pls->ctx->pb       = &pls->pb;
913         pls->stream_offset = stream_offset;
914         ret = avformat_open_input(&pls->ctx, pls->segments[0]->url, in_fmt, NULL);
915         if (ret < 0)
916             goto fail;
917
918         pls->ctx->ctx_flags &= ~AVFMTCTX_NOHEADER;
919         ret = avformat_find_stream_info(pls->ctx, NULL);
920         if (ret < 0)
921             goto fail;
922
923         /* Create new AVStreams for each stream in this playlist */
924         for (j = 0; j < pls->ctx->nb_streams; j++) {
925             AVStream *st = avformat_new_stream(s, NULL);
926             AVStream *ist = pls->ctx->streams[j];
927             if (!st) {
928                 ret = AVERROR(ENOMEM);
929                 goto fail;
930             }
931             st->id = i;
932             avpriv_set_pts_info(st, ist->pts_wrap_bits, ist->time_base.num, ist->time_base.den);
933             avcodec_copy_context(st->codec, pls->ctx->streams[j]->codec);
934         }
935
936         add_metadata_from_renditions(s, pls, AVMEDIA_TYPE_AUDIO);
937         add_metadata_from_renditions(s, pls, AVMEDIA_TYPE_VIDEO);
938         add_metadata_from_renditions(s, pls, AVMEDIA_TYPE_SUBTITLE);
939
940         stream_offset += pls->ctx->nb_streams;
941     }
942
943     /* Create a program for each variant */
944     for (i = 0; i < c->n_variants; i++) {
945         struct variant *v = c->variants[i];
946         char bitrate_str[20];
947         AVProgram *program;
948
949         snprintf(bitrate_str, sizeof(bitrate_str), "%d", v->bandwidth);
950
951         program = av_new_program(s, i);
952         if (!program)
953             goto fail;
954         av_dict_set(&program->metadata, "variant_bitrate", bitrate_str, 0);
955
956         for (j = 0; j < v->n_playlists; j++) {
957             struct playlist *pls = v->playlists[j];
958             int is_shared = playlist_in_multiple_variants(c, pls);
959             int k;
960
961             for (k = 0; k < pls->ctx->nb_streams; k++) {
962                 struct AVStream *st = s->streams[pls->stream_offset + k];
963
964                 ff_program_add_stream_index(s, i, pls->stream_offset + k);
965
966                 /* Set variant_bitrate for streams unique to this variant */
967                 if (!is_shared && v->bandwidth)
968                     av_dict_set(&st->metadata, "variant_bitrate", bitrate_str, 0);
969             }
970         }
971     }
972
973     c->first_packet = 1;
974     c->first_timestamp = AV_NOPTS_VALUE;
975     c->seek_timestamp  = AV_NOPTS_VALUE;
976
977     return 0;
978 fail:
979     free_playlist_list(c);
980     free_variant_list(c);
981     free_rendition_list(c);
982     return ret;
983 }
984
985 static int recheck_discard_flags(AVFormatContext *s, int first)
986 {
987     HLSContext *c = s->priv_data;
988     int i, changed = 0;
989
990     /* Check if any new streams are needed */
991     for (i = 0; i < c->n_playlists; i++)
992         c->playlists[i]->cur_needed = 0;
993
994     for (i = 0; i < s->nb_streams; i++) {
995         AVStream *st = s->streams[i];
996         struct playlist *pls = c->playlists[s->streams[i]->id];
997         if (st->discard < AVDISCARD_ALL)
998             pls->cur_needed = 1;
999     }
1000     for (i = 0; i < c->n_playlists; i++) {
1001         struct playlist *pls = c->playlists[i];
1002         if (pls->cur_needed && !pls->needed) {
1003             pls->needed = 1;
1004             changed = 1;
1005             pls->cur_seq_no = c->cur_seq_no;
1006             pls->pb.eof_reached = 0;
1007             av_log(s, AV_LOG_INFO, "Now receiving playlist %d\n", i);
1008         } else if (first && !pls->cur_needed && pls->needed) {
1009             if (pls->input)
1010                 ffurl_close(pls->input);
1011             pls->input = NULL;
1012             pls->needed = 0;
1013             changed = 1;
1014             av_log(s, AV_LOG_INFO, "No longer receiving playlist %d\n", i);
1015         }
1016     }
1017     return changed;
1018 }
1019
1020 static int hls_read_packet(AVFormatContext *s, AVPacket *pkt)
1021 {
1022     HLSContext *c = s->priv_data;
1023     int ret, i, minplaylist = -1;
1024
1025     if (c->first_packet) {
1026         recheck_discard_flags(s, 1);
1027         c->first_packet = 0;
1028     }
1029
1030 start:
1031     c->end_of_segment = 0;
1032     for (i = 0; i < c->n_playlists; i++) {
1033         struct playlist *pls = c->playlists[i];
1034         /* Make sure we've got one buffered packet from each open playlist
1035          * stream */
1036         if (pls->needed && !pls->pkt.data) {
1037             while (1) {
1038                 int64_t ts_diff;
1039                 AVStream *st;
1040                 ret = av_read_frame(pls->ctx, &pls->pkt);
1041                 if (ret < 0) {
1042                     if (!url_feof(&pls->pb) && ret != AVERROR_EOF)
1043                         return ret;
1044                     reset_packet(&pls->pkt);
1045                     break;
1046                 } else {
1047                     if (c->first_timestamp == AV_NOPTS_VALUE &&
1048                         pls->pkt.dts       != AV_NOPTS_VALUE)
1049                         c->first_timestamp = av_rescale_q(pls->pkt.dts,
1050                             pls->ctx->streams[pls->pkt.stream_index]->time_base,
1051                             AV_TIME_BASE_Q);
1052                 }
1053
1054                 if (c->seek_timestamp == AV_NOPTS_VALUE)
1055                     break;
1056
1057                 if (pls->pkt.dts == AV_NOPTS_VALUE) {
1058                     c->seek_timestamp = AV_NOPTS_VALUE;
1059                     break;
1060                 }
1061
1062                 st = pls->ctx->streams[pls->pkt.stream_index];
1063                 ts_diff = av_rescale_rnd(pls->pkt.dts, AV_TIME_BASE,
1064                                          st->time_base.den, AV_ROUND_DOWN) -
1065                           c->seek_timestamp;
1066                 if (ts_diff >= 0 && (c->seek_flags  & AVSEEK_FLAG_ANY ||
1067                                      pls->pkt.flags & AV_PKT_FLAG_KEY)) {
1068                     c->seek_timestamp = AV_NOPTS_VALUE;
1069                     break;
1070                 }
1071                 av_free_packet(&pls->pkt);
1072                 reset_packet(&pls->pkt);
1073             }
1074         }
1075         /* Check if this stream still is on an earlier segment number, or
1076          * has the packet with the lowest dts */
1077         if (pls->pkt.data) {
1078             struct playlist *minpls = minplaylist < 0 ?
1079                                      NULL : c->playlists[minplaylist];
1080             if (minplaylist < 0 || pls->cur_seq_no < minpls->cur_seq_no) {
1081                 minplaylist = i;
1082             } else if (pls->cur_seq_no == minpls->cur_seq_no) {
1083                 int64_t dts     =    pls->pkt.dts;
1084                 int64_t mindts  = minpls->pkt.dts;
1085                 AVStream *st    =    pls->ctx->streams[pls->pkt.stream_index];
1086                 AVStream *minst = minpls->ctx->streams[minpls->pkt.stream_index];
1087
1088                 if (dts == AV_NOPTS_VALUE) {
1089                     minplaylist = i;
1090                 } else if (mindts != AV_NOPTS_VALUE) {
1091                     if (st->start_time    != AV_NOPTS_VALUE)
1092                         dts    -= st->start_time;
1093                     if (minst->start_time != AV_NOPTS_VALUE)
1094                         mindts -= minst->start_time;
1095
1096                     if (av_compare_ts(dts, st->time_base,
1097                                       mindts, minst->time_base) < 0)
1098                         minplaylist = i;
1099                 }
1100             }
1101         }
1102     }
1103     if (c->end_of_segment) {
1104         if (recheck_discard_flags(s, 0))
1105             goto start;
1106     }
1107     /* If we got a packet, return it */
1108     if (minplaylist >= 0) {
1109         *pkt = c->playlists[minplaylist]->pkt;
1110         pkt->stream_index += c->playlists[minplaylist]->stream_offset;
1111         reset_packet(&c->playlists[minplaylist]->pkt);
1112         return 0;
1113     }
1114     return AVERROR_EOF;
1115 }
1116
1117 static int hls_close(AVFormatContext *s)
1118 {
1119     HLSContext *c = s->priv_data;
1120
1121     free_playlist_list(c);
1122     free_variant_list(c);
1123     free_rendition_list(c);
1124     return 0;
1125 }
1126
1127 static int hls_read_seek(AVFormatContext *s, int stream_index,
1128                                int64_t timestamp, int flags)
1129 {
1130     HLSContext *c = s->priv_data;
1131     int i, j, ret;
1132
1133     if ((flags & AVSEEK_FLAG_BYTE) || !c->variants[0]->playlists[0]->finished)
1134         return AVERROR(ENOSYS);
1135
1136     c->seek_flags     = flags;
1137     c->seek_timestamp = stream_index < 0 ? timestamp :
1138                         av_rescale_rnd(timestamp, AV_TIME_BASE,
1139                                        s->streams[stream_index]->time_base.den,
1140                                        flags & AVSEEK_FLAG_BACKWARD ?
1141                                        AV_ROUND_DOWN : AV_ROUND_UP);
1142     timestamp = av_rescale_rnd(timestamp, AV_TIME_BASE, stream_index >= 0 ?
1143                                s->streams[stream_index]->time_base.den :
1144                                AV_TIME_BASE, flags & AVSEEK_FLAG_BACKWARD ?
1145                                AV_ROUND_DOWN : AV_ROUND_UP);
1146     if (s->duration < c->seek_timestamp) {
1147         c->seek_timestamp = AV_NOPTS_VALUE;
1148         return AVERROR(EIO);
1149     }
1150
1151     ret = AVERROR(EIO);
1152     for (i = 0; i < c->n_playlists; i++) {
1153         /* Reset reading */
1154         struct playlist *pls = c->playlists[i];
1155         int64_t pos = c->first_timestamp == AV_NOPTS_VALUE ?
1156                       0 : c->first_timestamp;
1157         if (pls->input) {
1158             ffurl_close(pls->input);
1159             pls->input = NULL;
1160         }
1161         av_free_packet(&pls->pkt);
1162         reset_packet(&pls->pkt);
1163         pls->pb.eof_reached = 0;
1164         /* Clear any buffered data */
1165         pls->pb.buf_end = pls->pb.buf_ptr = pls->pb.buffer;
1166         /* Reset the pos, to let the mpegts demuxer know we've seeked. */
1167         pls->pb.pos = 0;
1168
1169         /* Locate the segment that contains the target timestamp */
1170         for (j = 0; j < pls->n_segments; j++) {
1171             if (timestamp >= pos &&
1172                 timestamp < pos + pls->segments[j]->duration) {
1173                 pls->cur_seq_no = pls->start_seq_no + j;
1174                 ret = 0;
1175                 break;
1176             }
1177             pos += pls->segments[j]->duration;
1178         }
1179         if (ret)
1180             c->seek_timestamp = AV_NOPTS_VALUE;
1181     }
1182     return ret;
1183 }
1184
1185 static int hls_probe(AVProbeData *p)
1186 {
1187     /* Require #EXTM3U at the start, and either one of the ones below
1188      * somewhere for a proper match. */
1189     if (strncmp(p->buf, "#EXTM3U", 7))
1190         return 0;
1191     if (strstr(p->buf, "#EXT-X-STREAM-INF:")     ||
1192         strstr(p->buf, "#EXT-X-TARGETDURATION:") ||
1193         strstr(p->buf, "#EXT-X-MEDIA-SEQUENCE:"))
1194         return AVPROBE_SCORE_MAX;
1195     return 0;
1196 }
1197
1198 AVInputFormat ff_hls_demuxer = {
1199     .name           = "hls,applehttp",
1200     .long_name      = NULL_IF_CONFIG_SMALL("Apple HTTP Live Streaming"),
1201     .priv_data_size = sizeof(HLSContext),
1202     .read_probe     = hls_probe,
1203     .read_header    = hls_read_header,
1204     .read_packet    = hls_read_packet,
1205     .read_close     = hls_close,
1206     .read_seek      = hls_read_seek,
1207 };