avformat/hls: decouple playlists from variants
[ffmpeg.git] / libavformat / hls.c
1 /*
2  * Apple HTTP Live Streaming demuxer
3  * Copyright (c) 2010 Martin Storsjo
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21
22 /**
23  * @file
24  * Apple HTTP Live Streaming demuxer
25  * http://tools.ietf.org/html/draft-pantos-http-live-streaming
26  */
27
28 #include "libavutil/avstring.h"
29 #include "libavutil/intreadwrite.h"
30 #include "libavutil/mathematics.h"
31 #include "libavutil/opt.h"
32 #include "libavutil/dict.h"
33 #include "libavutil/time.h"
34 #include "avformat.h"
35 #include "internal.h"
36 #include "avio_internal.h"
37 #include "url.h"
38
39 #define INITIAL_BUFFER_SIZE 32768
40
41 /*
42  * An apple http stream consists of a playlist with media segment files,
43  * played sequentially. There may be several playlists with the same
44  * video content, in different bandwidth variants, that are played in
45  * parallel (preferably only one bandwidth variant at a time). In this case,
46  * the user supplied the url to a main playlist that only lists the variant
47  * playlists.
48  *
49  * If the main playlist doesn't point at any variants, we still create
50  * one anonymous toplevel variant for this, to maintain the structure.
51  */
52
53 enum KeyType {
54     KEY_NONE,
55     KEY_AES_128,
56 };
57
58 struct segment {
59     int64_t duration;
60     char url[MAX_URL_SIZE];
61     char key[MAX_URL_SIZE];
62     enum KeyType key_type;
63     uint8_t iv[16];
64 };
65
66 /*
67  * Each playlist has its own demuxer. If it currently is active,
68  * it has an open AVIOContext too, and potentially an AVPacket
69  * containing the next packet from this stream.
70  */
71 struct playlist {
72     char url[MAX_URL_SIZE];
73     AVIOContext pb;
74     uint8_t* read_buffer;
75     URLContext *input;
76     AVFormatContext *parent;
77     int index;
78     AVFormatContext *ctx;
79     AVPacket pkt;
80     int stream_offset;
81
82     int finished;
83     int64_t target_duration;
84     int start_seq_no;
85     int n_segments;
86     struct segment **segments;
87     int needed, cur_needed;
88     int cur_seq_no;
89     int64_t last_load_time;
90
91     char key_url[MAX_URL_SIZE];
92     uint8_t key[16];
93 };
94
95 struct variant {
96     int bandwidth;
97     int n_playlists;
98     struct playlist **playlists;
99 };
100
101 typedef struct HLSContext {
102     int n_variants;
103     struct variant **variants;
104     int n_playlists;
105     struct playlist **playlists;
106
107     int cur_seq_no;
108     int end_of_segment;
109     int first_packet;
110     int64_t first_timestamp;
111     int64_t seek_timestamp;
112     int seek_flags;
113     AVIOInterruptCB *interrupt_callback;
114     char *user_agent;                    ///< holds HTTP user agent set as an AVOption to the HTTP protocol context
115     char *cookies;                       ///< holds HTTP cookie values set in either the initial response or as an AVOption to the HTTP protocol context
116     char *headers;                       ///< holds HTTP headers set as an AVOption to the HTTP protocol context
117 } HLSContext;
118
119 static int read_chomp_line(AVIOContext *s, char *buf, int maxlen)
120 {
121     int len = ff_get_line(s, buf, maxlen);
122     while (len > 0 && av_isspace(buf[len - 1]))
123         buf[--len] = '\0';
124     return len;
125 }
126
127 static void free_segment_list(struct playlist *pls)
128 {
129     int i;
130     for (i = 0; i < pls->n_segments; i++)
131         av_free(pls->segments[i]);
132     av_freep(&pls->segments);
133     pls->n_segments = 0;
134 }
135
136 static void free_playlist_list(HLSContext *c)
137 {
138     int i;
139     for (i = 0; i < c->n_playlists; i++) {
140         struct playlist *pls = c->playlists[i];
141         free_segment_list(pls);
142         av_free_packet(&pls->pkt);
143         av_free(pls->pb.buffer);
144         if (pls->input)
145             ffurl_close(pls->input);
146         if (pls->ctx) {
147             pls->ctx->pb = NULL;
148             avformat_close_input(&pls->ctx);
149         }
150         av_free(pls);
151     }
152     av_freep(&c->playlists);
153     av_freep(&c->cookies);
154     av_freep(&c->user_agent);
155     c->n_playlists = 0;
156 }
157
158 static void free_variant_list(HLSContext *c)
159 {
160     int i;
161     for (i = 0; i < c->n_variants; i++) {
162         struct variant *var = c->variants[i];
163         av_freep(&var->playlists);
164         av_free(var);
165     }
166     av_freep(&c->variants);
167     c->n_variants = 0;
168 }
169
170 /*
171  * Used to reset a statically allocated AVPacket to a clean slate,
172  * containing no data.
173  */
174 static void reset_packet(AVPacket *pkt)
175 {
176     av_init_packet(pkt);
177     pkt->data = NULL;
178 }
179
180 static struct playlist *new_playlist(HLSContext *c, const char *url,
181                                      const char *base)
182 {
183     struct playlist *pls = av_mallocz(sizeof(struct playlist));
184     if (!pls)
185         return NULL;
186     reset_packet(&pls->pkt);
187     ff_make_absolute_url(pls->url, sizeof(pls->url), base, url);
188     dynarray_add(&c->playlists, &c->n_playlists, pls);
189     return pls;
190 }
191
192 static struct variant *new_variant(HLSContext *c, int bandwidth,
193                                    const char *url, const char *base)
194 {
195     struct variant *var;
196     struct playlist *pls;
197
198     pls = new_playlist(c, url, base);
199     if (!pls)
200         return NULL;
201
202     var = av_mallocz(sizeof(struct variant));
203     if (!var)
204         return NULL;
205
206     var->bandwidth = bandwidth;
207     dynarray_add(&c->variants, &c->n_variants, var);
208     dynarray_add(&var->playlists, &var->n_playlists, pls);
209     return var;
210 }
211
212 struct variant_info {
213     char bandwidth[20];
214 };
215
216 static void handle_variant_args(struct variant_info *info, const char *key,
217                                 int key_len, char **dest, int *dest_len)
218 {
219     if (!strncmp(key, "BANDWIDTH=", key_len)) {
220         *dest     =        info->bandwidth;
221         *dest_len = sizeof(info->bandwidth);
222     }
223 }
224
225 struct key_info {
226      char uri[MAX_URL_SIZE];
227      char method[10];
228      char iv[35];
229 };
230
231 static void handle_key_args(struct key_info *info, const char *key,
232                             int key_len, char **dest, int *dest_len)
233 {
234     if (!strncmp(key, "METHOD=", key_len)) {
235         *dest     =        info->method;
236         *dest_len = sizeof(info->method);
237     } else if (!strncmp(key, "URI=", key_len)) {
238         *dest     =        info->uri;
239         *dest_len = sizeof(info->uri);
240     } else if (!strncmp(key, "IV=", key_len)) {
241         *dest     =        info->iv;
242         *dest_len = sizeof(info->iv);
243     }
244 }
245
246 static int parse_playlist(HLSContext *c, const char *url,
247                           struct playlist *pls, AVIOContext *in)
248 {
249     int ret = 0, is_segment = 0, is_variant = 0, bandwidth = 0;
250     int64_t duration = 0;
251     enum KeyType key_type = KEY_NONE;
252     uint8_t iv[16] = "";
253     int has_iv = 0;
254     char key[MAX_URL_SIZE] = "";
255     char line[MAX_URL_SIZE];
256     const char *ptr;
257     int close_in = 0;
258     uint8_t *new_url = NULL;
259
260     if (!in) {
261         AVDictionary *opts = NULL;
262         close_in = 1;
263         /* Some HLS servers don't like being sent the range header */
264         av_dict_set(&opts, "seekable", "0", 0);
265
266         // broker prior HTTP options that should be consistent across requests
267         av_dict_set(&opts, "user-agent", c->user_agent, 0);
268         av_dict_set(&opts, "cookies", c->cookies, 0);
269         av_dict_set(&opts, "headers", c->headers, 0);
270
271         ret = avio_open2(&in, url, AVIO_FLAG_READ,
272                          c->interrupt_callback, &opts);
273         av_dict_free(&opts);
274         if (ret < 0)
275             return ret;
276     }
277
278     if (av_opt_get(in, "location", AV_OPT_SEARCH_CHILDREN, &new_url) >= 0)
279         url = new_url;
280
281     read_chomp_line(in, line, sizeof(line));
282     if (strcmp(line, "#EXTM3U")) {
283         ret = AVERROR_INVALIDDATA;
284         goto fail;
285     }
286
287     if (pls) {
288         free_segment_list(pls);
289         pls->finished = 0;
290     }
291     while (!url_feof(in)) {
292         read_chomp_line(in, line, sizeof(line));
293         if (av_strstart(line, "#EXT-X-STREAM-INF:", &ptr)) {
294             struct variant_info info = {{0}};
295             is_variant = 1;
296             ff_parse_key_value(ptr, (ff_parse_key_val_cb) handle_variant_args,
297                                &info);
298             bandwidth = atoi(info.bandwidth);
299         } else if (av_strstart(line, "#EXT-X-KEY:", &ptr)) {
300             struct key_info info = {{0}};
301             ff_parse_key_value(ptr, (ff_parse_key_val_cb) handle_key_args,
302                                &info);
303             key_type = KEY_NONE;
304             has_iv = 0;
305             if (!strcmp(info.method, "AES-128"))
306                 key_type = KEY_AES_128;
307             if (!strncmp(info.iv, "0x", 2) || !strncmp(info.iv, "0X", 2)) {
308                 ff_hex_to_data(iv, info.iv + 2);
309                 has_iv = 1;
310             }
311             av_strlcpy(key, info.uri, sizeof(key));
312         } else if (av_strstart(line, "#EXT-X-TARGETDURATION:", &ptr)) {
313             if (!pls) {
314                 if (!new_variant(c, 0, url, NULL)) {
315                     ret = AVERROR(ENOMEM);
316                     goto fail;
317                 }
318                 pls = c->playlists[c->n_playlists - 1];
319             }
320             pls->target_duration = atoi(ptr) * AV_TIME_BASE;
321         } else if (av_strstart(line, "#EXT-X-MEDIA-SEQUENCE:", &ptr)) {
322             if (!pls) {
323                 if (!new_variant(c, 0, url, NULL)) {
324                     ret = AVERROR(ENOMEM);
325                     goto fail;
326                 }
327                 pls = c->playlists[c->n_playlists - 1];
328             }
329             pls->start_seq_no = atoi(ptr);
330         } else if (av_strstart(line, "#EXT-X-ENDLIST", &ptr)) {
331             if (pls)
332                 pls->finished = 1;
333         } else if (av_strstart(line, "#EXTINF:", &ptr)) {
334             is_segment = 1;
335             duration   = atof(ptr) * AV_TIME_BASE;
336         } else if (av_strstart(line, "#", NULL)) {
337             continue;
338         } else if (line[0]) {
339             if (is_variant) {
340                 if (!new_variant(c, bandwidth, line, url)) {
341                     ret = AVERROR(ENOMEM);
342                     goto fail;
343                 }
344                 is_variant = 0;
345                 bandwidth  = 0;
346             }
347             if (is_segment) {
348                 struct segment *seg;
349                 if (!pls) {
350                     if (!new_variant(c, 0, url, NULL)) {
351                         ret = AVERROR(ENOMEM);
352                         goto fail;
353                     }
354                     pls = c->playlists[c->n_playlists - 1];
355                 }
356                 seg = av_malloc(sizeof(struct segment));
357                 if (!seg) {
358                     ret = AVERROR(ENOMEM);
359                     goto fail;
360                 }
361                 seg->duration = duration;
362                 seg->key_type = key_type;
363                 if (has_iv) {
364                     memcpy(seg->iv, iv, sizeof(iv));
365                 } else {
366                     int seq = pls->start_seq_no + pls->n_segments;
367                     memset(seg->iv, 0, sizeof(seg->iv));
368                     AV_WB32(seg->iv + 12, seq);
369                 }
370                 ff_make_absolute_url(seg->key, sizeof(seg->key), url, key);
371                 ff_make_absolute_url(seg->url, sizeof(seg->url), url, line);
372                 dynarray_add(&pls->segments, &pls->n_segments, seg);
373                 is_segment = 0;
374             }
375         }
376     }
377     if (pls)
378         pls->last_load_time = av_gettime();
379
380 fail:
381     av_free(new_url);
382     if (close_in)
383         avio_close(in);
384     return ret;
385 }
386
387 static int open_input(HLSContext *c, struct playlist *pls)
388 {
389     AVDictionary *opts = NULL;
390     int ret;
391     struct segment *seg = pls->segments[pls->cur_seq_no - pls->start_seq_no];
392
393     // broker prior HTTP options that should be consistent across requests
394     av_dict_set(&opts, "user-agent", c->user_agent, 0);
395     av_dict_set(&opts, "cookies", c->cookies, 0);
396     av_dict_set(&opts, "headers", c->headers, 0);
397     av_dict_set(&opts, "seekable", "0", 0);
398
399     if (seg->key_type == KEY_NONE) {
400         ret = ffurl_open(&pls->input, seg->url, AVIO_FLAG_READ,
401                           &pls->parent->interrupt_callback, &opts);
402         goto cleanup;
403     } else if (seg->key_type == KEY_AES_128) {
404         char iv[33], key[33], url[MAX_URL_SIZE];
405         if (strcmp(seg->key, pls->key_url)) {
406             URLContext *uc;
407             if (ffurl_open(&uc, seg->key, AVIO_FLAG_READ,
408                            &pls->parent->interrupt_callback, &opts) == 0) {
409                 if (ffurl_read_complete(uc, pls->key, sizeof(pls->key))
410                     != sizeof(pls->key)) {
411                     av_log(NULL, AV_LOG_ERROR, "Unable to read key file %s\n",
412                            seg->key);
413                 }
414                 ffurl_close(uc);
415             } else {
416                 av_log(NULL, AV_LOG_ERROR, "Unable to open key file %s\n",
417                        seg->key);
418             }
419             av_strlcpy(pls->key_url, seg->key, sizeof(pls->key_url));
420         }
421         ff_data_to_hex(iv, seg->iv, sizeof(seg->iv), 0);
422         ff_data_to_hex(key, pls->key, sizeof(pls->key), 0);
423         iv[32] = key[32] = '\0';
424         if (strstr(seg->url, "://"))
425             snprintf(url, sizeof(url), "crypto+%s", seg->url);
426         else
427             snprintf(url, sizeof(url), "crypto:%s", seg->url);
428         if ((ret = ffurl_alloc(&pls->input, url, AVIO_FLAG_READ,
429                                &pls->parent->interrupt_callback)) < 0)
430             goto cleanup;
431         av_opt_set(pls->input->priv_data, "key", key, 0);
432         av_opt_set(pls->input->priv_data, "iv", iv, 0);
433         /* Need to repopulate options */
434         av_dict_free(&opts);
435         av_dict_set(&opts, "seekable", "0", 0);
436         if ((ret = ffurl_connect(pls->input, &opts)) < 0) {
437             ffurl_close(pls->input);
438             pls->input = NULL;
439             goto cleanup;
440         }
441         ret = 0;
442     }
443     else
444       ret = AVERROR(ENOSYS);
445
446 cleanup:
447     av_dict_free(&opts);
448     return ret;
449 }
450
451 static int read_data(void *opaque, uint8_t *buf, int buf_size)
452 {
453     struct playlist *v = opaque;
454     HLSContext *c = v->parent->priv_data;
455     int ret, i;
456
457 restart:
458     if (!v->input) {
459         /* If this is a live stream and the reload interval has elapsed since
460          * the last playlist reload, reload the playlists now. */
461         int64_t reload_interval = v->n_segments > 0 ?
462                                   v->segments[v->n_segments - 1]->duration :
463                                   v->target_duration;
464
465 reload:
466         if (!v->finished &&
467             av_gettime() - v->last_load_time >= reload_interval) {
468             if ((ret = parse_playlist(c, v->url, v, NULL)) < 0)
469                 return ret;
470             /* If we need to reload the playlist again below (if
471              * there's still no more segments), switch to a reload
472              * interval of half the target duration. */
473             reload_interval = v->target_duration / 2;
474         }
475         if (v->cur_seq_no < v->start_seq_no) {
476             av_log(NULL, AV_LOG_WARNING,
477                    "skipping %d segments ahead, expired from playlists\n",
478                    v->start_seq_no - v->cur_seq_no);
479             v->cur_seq_no = v->start_seq_no;
480         }
481         if (v->cur_seq_no >= v->start_seq_no + v->n_segments) {
482             if (v->finished)
483                 return AVERROR_EOF;
484             while (av_gettime() - v->last_load_time < reload_interval) {
485                 if (ff_check_interrupt(c->interrupt_callback))
486                     return AVERROR_EXIT;
487                 av_usleep(100*1000);
488             }
489             /* Enough time has elapsed since the last reload */
490             goto reload;
491         }
492
493         ret = open_input(c, v);
494         if (ret < 0)
495             return ret;
496     }
497     ret = ffurl_read(v->input, buf, buf_size);
498     if (ret > 0)
499         return ret;
500     ffurl_close(v->input);
501     v->input = NULL;
502     v->cur_seq_no++;
503
504     c->end_of_segment = 1;
505     c->cur_seq_no = v->cur_seq_no;
506
507     if (v->ctx && v->ctx->nb_streams &&
508         v->parent->nb_streams >= v->stream_offset + v->ctx->nb_streams) {
509         v->needed = 0;
510         for (i = v->stream_offset; i < v->stream_offset + v->ctx->nb_streams;
511              i++) {
512             if (v->parent->streams[i]->discard < AVDISCARD_ALL)
513                 v->needed = 1;
514         }
515     }
516     if (!v->needed) {
517         av_log(v->parent, AV_LOG_INFO, "No longer receiving playlist %d\n",
518                v->index);
519         return AVERROR_EOF;
520     }
521     goto restart;
522 }
523
524 static int playlist_in_multiple_variants(HLSContext *c, struct playlist *pls)
525 {
526     int variant_count = 0;
527     int i, j;
528
529     for (i = 0; i < c->n_variants && variant_count < 2; i++) {
530         struct variant *v = c->variants[i];
531
532         for (j = 0; j < v->n_playlists; j++) {
533             if (v->playlists[j] == pls) {
534                 variant_count++;
535                 break;
536             }
537         }
538     }
539
540     return variant_count >= 2;
541 }
542
543 static int hls_read_header(AVFormatContext *s)
544 {
545     URLContext *u = (s->flags & AVFMT_FLAG_CUSTOM_IO) ? NULL : s->pb->opaque;
546     HLSContext *c = s->priv_data;
547     int ret = 0, i, j, stream_offset = 0;
548
549     c->interrupt_callback = &s->interrupt_callback;
550
551     // if the URL context is good, read important options we must broker later
552     if (u && u->prot->priv_data_class) {
553         // get the previous user agent & set back to null if string size is zero
554         av_freep(&c->user_agent);
555         av_opt_get(u->priv_data, "user-agent", 0, (uint8_t**)&(c->user_agent));
556         if (c->user_agent && !strlen(c->user_agent))
557             av_freep(&c->user_agent);
558
559         // get the previous cookies & set back to null if string size is zero
560         av_freep(&c->cookies);
561         av_opt_get(u->priv_data, "cookies", 0, (uint8_t**)&(c->cookies));
562         if (c->cookies && !strlen(c->cookies))
563             av_freep(&c->cookies);
564
565         // get the previous headers & set back to null if string size is zero
566         av_freep(&c->headers);
567         av_opt_get(u->priv_data, "headers", 0, (uint8_t**)&(c->headers));
568         if (c->headers && !strlen(c->headers))
569             av_freep(&c->headers);
570     }
571
572     if ((ret = parse_playlist(c, s->filename, NULL, s->pb)) < 0)
573         goto fail;
574
575     if (c->n_variants == 0) {
576         av_log(NULL, AV_LOG_WARNING, "Empty playlist\n");
577         ret = AVERROR_EOF;
578         goto fail;
579     }
580     /* If the playlist only contained playlists (Master Playlist),
581      * parse each individual playlist. */
582     if (c->n_playlists > 1 || c->playlists[0]->n_segments == 0) {
583         for (i = 0; i < c->n_playlists; i++) {
584             struct playlist *pls = c->playlists[i];
585             if ((ret = parse_playlist(c, pls->url, pls, NULL)) < 0)
586                 goto fail;
587         }
588     }
589
590     if (c->variants[0]->playlists[0]->n_segments == 0) {
591         av_log(NULL, AV_LOG_WARNING, "Empty playlist\n");
592         ret = AVERROR_EOF;
593         goto fail;
594     }
595
596     /* If this isn't a live stream, calculate the total duration of the
597      * stream. */
598     if (c->variants[0]->playlists[0]->finished) {
599         int64_t duration = 0;
600         for (i = 0; i < c->variants[0]->playlists[0]->n_segments; i++)
601             duration += c->variants[0]->playlists[0]->segments[i]->duration;
602         s->duration = duration;
603     }
604
605     /* Open the demuxer for each playlist */
606     for (i = 0; i < c->n_playlists; i++) {
607         struct playlist *pls = c->playlists[i];
608         AVInputFormat *in_fmt = NULL;
609
610         if (pls->n_segments == 0)
611             continue;
612
613         if (!(pls->ctx = avformat_alloc_context())) {
614             ret = AVERROR(ENOMEM);
615             goto fail;
616         }
617
618         pls->index  = i;
619         pls->needed = 1;
620         pls->parent = s;
621
622         /* If this is a live stream with more than 3 segments, start at the
623          * third last segment. */
624         pls->cur_seq_no = pls->start_seq_no;
625         if (!pls->finished && pls->n_segments > 3)
626             pls->cur_seq_no = pls->start_seq_no + pls->n_segments - 3;
627
628         pls->read_buffer = av_malloc(INITIAL_BUFFER_SIZE);
629         ffio_init_context(&pls->pb, pls->read_buffer, INITIAL_BUFFER_SIZE, 0, pls,
630                           read_data, NULL, NULL);
631         pls->pb.seekable = 0;
632         ret = av_probe_input_buffer(&pls->pb, &in_fmt, pls->segments[0]->url,
633                                     NULL, 0, 0);
634         if (ret < 0) {
635             /* Free the ctx - it isn't initialized properly at this point,
636              * so avformat_close_input shouldn't be called. If
637              * avformat_open_input fails below, it frees and zeros the
638              * context, so it doesn't need any special treatment like this. */
639             av_log(s, AV_LOG_ERROR, "Error when loading first segment '%s'\n", pls->segments[0]->url);
640             avformat_free_context(pls->ctx);
641             pls->ctx = NULL;
642             goto fail;
643         }
644         pls->ctx->pb       = &pls->pb;
645         pls->stream_offset = stream_offset;
646         ret = avformat_open_input(&pls->ctx, pls->segments[0]->url, in_fmt, NULL);
647         if (ret < 0)
648             goto fail;
649
650         pls->ctx->ctx_flags &= ~AVFMTCTX_NOHEADER;
651         ret = avformat_find_stream_info(pls->ctx, NULL);
652         if (ret < 0)
653             goto fail;
654
655         /* Create new AVStreams for each stream in this playlist */
656         for (j = 0; j < pls->ctx->nb_streams; j++) {
657             AVStream *st = avformat_new_stream(s, NULL);
658             AVStream *ist = pls->ctx->streams[j];
659             if (!st) {
660                 ret = AVERROR(ENOMEM);
661                 goto fail;
662             }
663             st->id = i;
664             avpriv_set_pts_info(st, ist->pts_wrap_bits, ist->time_base.num, ist->time_base.den);
665             avcodec_copy_context(st->codec, pls->ctx->streams[j]->codec);
666         }
667
668         stream_offset += pls->ctx->nb_streams;
669     }
670
671     /* Create a program for each variant */
672     for (i = 0; i < c->n_variants; i++) {
673         struct variant *v = c->variants[i];
674         char bitrate_str[20];
675         AVProgram *program;
676
677         snprintf(bitrate_str, sizeof(bitrate_str), "%d", v->bandwidth);
678
679         program = av_new_program(s, i);
680         if (!program)
681             goto fail;
682         av_dict_set(&program->metadata, "variant_bitrate", bitrate_str, 0);
683
684         for (j = 0; j < v->n_playlists; j++) {
685             struct playlist *pls = v->playlists[j];
686             int is_shared = playlist_in_multiple_variants(c, pls);
687             int k;
688
689             for (k = 0; k < pls->ctx->nb_streams; k++) {
690                 struct AVStream *st = s->streams[pls->stream_offset + k];
691
692                 ff_program_add_stream_index(s, i, pls->stream_offset + k);
693
694                 /* Set variant_bitrate for streams unique to this variant */
695                 if (!is_shared && v->bandwidth)
696                     av_dict_set(&st->metadata, "variant_bitrate", bitrate_str, 0);
697             }
698         }
699     }
700
701     c->first_packet = 1;
702     c->first_timestamp = AV_NOPTS_VALUE;
703     c->seek_timestamp  = AV_NOPTS_VALUE;
704
705     return 0;
706 fail:
707     free_playlist_list(c);
708     free_variant_list(c);
709     return ret;
710 }
711
712 static int recheck_discard_flags(AVFormatContext *s, int first)
713 {
714     HLSContext *c = s->priv_data;
715     int i, changed = 0;
716
717     /* Check if any new streams are needed */
718     for (i = 0; i < c->n_playlists; i++)
719         c->playlists[i]->cur_needed = 0;
720
721     for (i = 0; i < s->nb_streams; i++) {
722         AVStream *st = s->streams[i];
723         struct playlist *pls = c->playlists[s->streams[i]->id];
724         if (st->discard < AVDISCARD_ALL)
725             pls->cur_needed = 1;
726     }
727     for (i = 0; i < c->n_playlists; i++) {
728         struct playlist *pls = c->playlists[i];
729         if (pls->cur_needed && !pls->needed) {
730             pls->needed = 1;
731             changed = 1;
732             pls->cur_seq_no = c->cur_seq_no;
733             pls->pb.eof_reached = 0;
734             av_log(s, AV_LOG_INFO, "Now receiving playlist %d\n", i);
735         } else if (first && !pls->cur_needed && pls->needed) {
736             if (pls->input)
737                 ffurl_close(pls->input);
738             pls->input = NULL;
739             pls->needed = 0;
740             changed = 1;
741             av_log(s, AV_LOG_INFO, "No longer receiving playlist %d\n", i);
742         }
743     }
744     return changed;
745 }
746
747 static int hls_read_packet(AVFormatContext *s, AVPacket *pkt)
748 {
749     HLSContext *c = s->priv_data;
750     int ret, i, minplaylist = -1;
751
752     if (c->first_packet) {
753         recheck_discard_flags(s, 1);
754         c->first_packet = 0;
755     }
756
757 start:
758     c->end_of_segment = 0;
759     for (i = 0; i < c->n_playlists; i++) {
760         struct playlist *pls = c->playlists[i];
761         /* Make sure we've got one buffered packet from each open playlist
762          * stream */
763         if (pls->needed && !pls->pkt.data) {
764             while (1) {
765                 int64_t ts_diff;
766                 AVStream *st;
767                 ret = av_read_frame(pls->ctx, &pls->pkt);
768                 if (ret < 0) {
769                     if (!url_feof(&pls->pb) && ret != AVERROR_EOF)
770                         return ret;
771                     reset_packet(&pls->pkt);
772                     break;
773                 } else {
774                     if (c->first_timestamp == AV_NOPTS_VALUE &&
775                         pls->pkt.dts       != AV_NOPTS_VALUE)
776                         c->first_timestamp = av_rescale_q(pls->pkt.dts,
777                             pls->ctx->streams[pls->pkt.stream_index]->time_base,
778                             AV_TIME_BASE_Q);
779                 }
780
781                 if (c->seek_timestamp == AV_NOPTS_VALUE)
782                     break;
783
784                 if (pls->pkt.dts == AV_NOPTS_VALUE) {
785                     c->seek_timestamp = AV_NOPTS_VALUE;
786                     break;
787                 }
788
789                 st = pls->ctx->streams[pls->pkt.stream_index];
790                 ts_diff = av_rescale_rnd(pls->pkt.dts, AV_TIME_BASE,
791                                          st->time_base.den, AV_ROUND_DOWN) -
792                           c->seek_timestamp;
793                 if (ts_diff >= 0 && (c->seek_flags  & AVSEEK_FLAG_ANY ||
794                                      pls->pkt.flags & AV_PKT_FLAG_KEY)) {
795                     c->seek_timestamp = AV_NOPTS_VALUE;
796                     break;
797                 }
798                 av_free_packet(&pls->pkt);
799                 reset_packet(&pls->pkt);
800             }
801         }
802         /* Check if this stream still is on an earlier segment number, or
803          * has the packet with the lowest dts */
804         if (pls->pkt.data) {
805             struct playlist *minpls = minplaylist < 0 ?
806                                      NULL : c->playlists[minplaylist];
807             if (minplaylist < 0 || pls->cur_seq_no < minpls->cur_seq_no) {
808                 minplaylist = i;
809             } else if (pls->cur_seq_no == minpls->cur_seq_no) {
810                 int64_t dts     =    pls->pkt.dts;
811                 int64_t mindts  = minpls->pkt.dts;
812                 AVStream *st    =    pls->ctx->streams[pls->pkt.stream_index];
813                 AVStream *minst = minpls->ctx->streams[minpls->pkt.stream_index];
814
815                 if (dts == AV_NOPTS_VALUE) {
816                     minplaylist = i;
817                 } else if (mindts != AV_NOPTS_VALUE) {
818                     if (st->start_time    != AV_NOPTS_VALUE)
819                         dts    -= st->start_time;
820                     if (minst->start_time != AV_NOPTS_VALUE)
821                         mindts -= minst->start_time;
822
823                     if (av_compare_ts(dts, st->time_base,
824                                       mindts, minst->time_base) < 0)
825                         minplaylist = i;
826                 }
827             }
828         }
829     }
830     if (c->end_of_segment) {
831         if (recheck_discard_flags(s, 0))
832             goto start;
833     }
834     /* If we got a packet, return it */
835     if (minplaylist >= 0) {
836         *pkt = c->playlists[minplaylist]->pkt;
837         pkt->stream_index += c->playlists[minplaylist]->stream_offset;
838         reset_packet(&c->playlists[minplaylist]->pkt);
839         return 0;
840     }
841     return AVERROR_EOF;
842 }
843
844 static int hls_close(AVFormatContext *s)
845 {
846     HLSContext *c = s->priv_data;
847
848     free_playlist_list(c);
849     free_variant_list(c);
850     return 0;
851 }
852
853 static int hls_read_seek(AVFormatContext *s, int stream_index,
854                                int64_t timestamp, int flags)
855 {
856     HLSContext *c = s->priv_data;
857     int i, j, ret;
858
859     if ((flags & AVSEEK_FLAG_BYTE) || !c->variants[0]->playlists[0]->finished)
860         return AVERROR(ENOSYS);
861
862     c->seek_flags     = flags;
863     c->seek_timestamp = stream_index < 0 ? timestamp :
864                         av_rescale_rnd(timestamp, AV_TIME_BASE,
865                                        s->streams[stream_index]->time_base.den,
866                                        flags & AVSEEK_FLAG_BACKWARD ?
867                                        AV_ROUND_DOWN : AV_ROUND_UP);
868     timestamp = av_rescale_rnd(timestamp, AV_TIME_BASE, stream_index >= 0 ?
869                                s->streams[stream_index]->time_base.den :
870                                AV_TIME_BASE, flags & AVSEEK_FLAG_BACKWARD ?
871                                AV_ROUND_DOWN : AV_ROUND_UP);
872     if (s->duration < c->seek_timestamp) {
873         c->seek_timestamp = AV_NOPTS_VALUE;
874         return AVERROR(EIO);
875     }
876
877     ret = AVERROR(EIO);
878     for (i = 0; i < c->n_playlists; i++) {
879         /* Reset reading */
880         struct playlist *pls = c->playlists[i];
881         int64_t pos = c->first_timestamp == AV_NOPTS_VALUE ?
882                       0 : c->first_timestamp;
883         if (pls->input) {
884             ffurl_close(pls->input);
885             pls->input = NULL;
886         }
887         av_free_packet(&pls->pkt);
888         reset_packet(&pls->pkt);
889         pls->pb.eof_reached = 0;
890         /* Clear any buffered data */
891         pls->pb.buf_end = pls->pb.buf_ptr = pls->pb.buffer;
892         /* Reset the pos, to let the mpegts demuxer know we've seeked. */
893         pls->pb.pos = 0;
894
895         /* Locate the segment that contains the target timestamp */
896         for (j = 0; j < pls->n_segments; j++) {
897             if (timestamp >= pos &&
898                 timestamp < pos + pls->segments[j]->duration) {
899                 pls->cur_seq_no = pls->start_seq_no + j;
900                 ret = 0;
901                 break;
902             }
903             pos += pls->segments[j]->duration;
904         }
905         if (ret)
906             c->seek_timestamp = AV_NOPTS_VALUE;
907     }
908     return ret;
909 }
910
911 static int hls_probe(AVProbeData *p)
912 {
913     /* Require #EXTM3U at the start, and either one of the ones below
914      * somewhere for a proper match. */
915     if (strncmp(p->buf, "#EXTM3U", 7))
916         return 0;
917     if (strstr(p->buf, "#EXT-X-STREAM-INF:")     ||
918         strstr(p->buf, "#EXT-X-TARGETDURATION:") ||
919         strstr(p->buf, "#EXT-X-MEDIA-SEQUENCE:"))
920         return AVPROBE_SCORE_MAX;
921     return 0;
922 }
923
924 AVInputFormat ff_hls_demuxer = {
925     .name           = "hls,applehttp",
926     .long_name      = NULL_IF_CONFIG_SMALL("Apple HTTP Live Streaming"),
927     .priv_data_size = sizeof(HLSContext),
928     .read_probe     = hls_probe,
929     .read_header    = hls_read_header,
930     .read_packet    = hls_read_packet,
931     .read_close     = hls_close,
932     .read_seek      = hls_read_seek,
933 };