Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

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