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