[FFmpeg-devel,RFC] avformat/dashdec: Improve implementation

Compared to previous implementation, this rework tries to:

- Improve code quality,
- Provide better error handling (also: reduce numerous (potential)
  memory leaks),
- Broader coverage of the standard:
  * multiple periods,
  * multiple base URLs (fallback on CDN failure),
  * handle ContentProtection/Role/etc... nodes,
  * manifest chaining,
  * drop ridiculous limits of @id's.
- Fast startup, thanks to reading/probing streams only when needed.
- Open multiple connections (HLS can open one more connection in
  advance; DASH can do up to UINT_MAX, configurable via option);
  similarly to HLS, currently it only opens them so only sequential
  reading is possible, however this behavior can be changed in the
  future,
- Ability to seek live streams.
- Bonus: Tests show that there are some kind of live streams that old
  implementation was unable to cope with, now it is possible to play
  them.

I mark this patch as RFC since I think:
- Seeking needs some improvement (I currently lack the necessary
  knowledge to finish it (...I hope a little community help)),
- Stuff around codec reinitialization (mentioned late opening +
  multiperiod) may require some fine tuning, dunno.

Signed-off-by: zsugabubus <zsugabubus@national.shitposting.agency>
---
 libavformat/dashdec.c  | 4871 +++++++++++++++++++++++-----------------
 libavformat/internal.h |   14 +
 libavformat/utils.c    |   47 +
 3 files changed, 2868 insertions(+), 2064 deletions(-)

zsugabubus <zsugabubus@national.shitposting.agency> 于2021年3月23日周二 上午6:25写道：
>
> Compared to previous implementation, this rework tries to:
>
> - Improve code quality,
> - Provide better error handling (also: reduce numerous (potential)
>   memory leaks),
> - Broader coverage of the standard:
>   * multiple periods,
>   * multiple base URLs (fallback on CDN failure),
>   * handle ContentProtection/Role/etc... nodes,
>   * manifest chaining,
>   * drop ridiculous limits of @id's.
> - Fast startup, thanks to reading/probing streams only when needed.
> - Open multiple connections (HLS can open one more connection in
>   advance; DASH can do up to UINT_MAX, configurable via option);
>   similarly to HLS, currently it only opens them so only sequential
>   reading is possible, however this behavior can be changed in the
>   future,
> - Ability to seek live streams.
> - Bonus: Tests show that there are some kind of live streams that old
>   implementation was unable to cope with, now it is possible to play
>   them.
>
> I mark this patch as RFC since I think:
> - Seeking needs some improvement (I currently lack the necessary
>   knowledge to finish it (...I hope a little community help)),
> - Stuff around codec reinitialization (mentioned late opening +
>   multiperiod) may require some fine tuning, dunno.
>
> Signed-off-by: zsugabubus <zsugabubus@national.shitposting.agency>
> ---
>  libavformat/dashdec.c  | 4871 +++++++++++++++++++++++-----------------
>  libavformat/internal.h |   14 +
>  libavformat/utils.c    |   47 +
>  3 files changed, 2868 insertions(+), 2064 deletions(-)
>
> diff --git a/libavformat/dashdec.c b/libavformat/dashdec.c
> index 6f3f28d..0ee7dd8 100644
> --- a/libavformat/dashdec.c
> +++ b/libavformat/dashdec.c
> @@ -1,7 +1,8 @@
>  /*
> - * Dynamic Adaptive Streaming over HTTP demux
> + * Dynamic Adaptive Streaming over HTTP demuxer
>   * Copyright (c) 2017 samsamsam@o2.pl based on HLS demux
>   * Copyright (c) 2017 Steven Liu
> + * Copyright (c) 2021 reworked by zsugabubus
>   *
>   * This file is part of FFmpeg.
>   *
> @@ -19,182 +20,401 @@
>   * License along with FFmpeg; if not, write to the Free Software
>   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
>   */
> +
> +/**
> + * @file
> + * Dynamic Adaptive Streaming over HTTP demuxer
> + * @author samsamsam@o2.pl
> + * @author Steven Liu
> + * @author reworked by zsugabubus
> + * @see DASH-IF spec: https://dashif-documents.azurewebsites.net/DASH-IF-IOP/master/DASH-IF-IOP.html
> + * @see another spec: https://dashif-documents.azurewebsites.net/Guidelines-TimingModel/master/Guidelines-TimingModel.html
> + * @see test vectors: https://testassets.dashif.org/
> + * @see MPD scheme: https://standards.iso.org/ittf/PubliclyAvailableStandards/MPEG-DASH_schema_files/DASH-MPD.xsd
> + */
> +
>  #include <libxml/parser.h>
> +#include "libavutil/encryption_info.h"
>  #include "libavutil/intreadwrite.h"
> +#include "libavutil/lfg.h"
> +#include "libavutil/random_seed.h"
> +#include "libavutil/avassert.h"
>  #include "libavutil/opt.h"
>  #include "libavutil/time.h"
>  #include "libavutil/parseutils.h"
>  #include "internal.h"
>  #include "avio_internal.h"
> -#include "dash.h"
> +#include "libavutil/base64.h"
>
> -#define INITIAL_BUFFER_SIZE 32768
> -#define MAX_BPRINT_READ_SIZE (UINT_MAX - 1)
> -#define DEFAULT_MANIFEST_SIZE 8 * 1024
> +#if CONFIG_HTTP_PROTOCOL
> +# include "http.h"
> +#endif
>
> -struct fragment {
> -    int64_t url_offset;
> -    int64_t size;
> -    char *url;
> +#define MICROSEC_PER_SEC 1000000L
> +#define MILLISEC_PER_SEC (MICROSEC_PER_SEC / 1000L)
> +
> +static const char CENC_NAMESPACE[] = "urn:mpeg:cenc:2013";
> +
> +enum {
> +    /* Most init section <1K, but some DRM systems can use 600 or so bytes for
> +     * PSSH data. */
> +    INITBUF_MAX = 4 * 1024
>  };
>
> -/*
> - * reference to : ISO_IEC_23009-1-DASH-2012
> - * Section: 5.3.9.6.2
> - * Table: Table 17 — Semantics of SegmentTimeline element
> - * */
> -struct timeline {
> -    /* starttime: Element or Attribute Name
> -     * specifies the MPD start time, in @timescale units,
> -     * the first Segment in the series starts relative to the beginning of the Period.
> -     * The value of this attribute must be equal to or greater than the sum of the previous S
> -     * element earliest presentation time and the sum of the contiguous Segment durations.
> -     * If the value of the attribute is greater than what is expressed by the previous S element,
> -     * it expresses discontinuities in the timeline.
> -     * If not present then the value shall be assumed to be zero for the first S element
> -     * and for the subsequent S elements, the value shall be assumed to be the sum of
> -     * the previous S element's earliest presentation time and contiguous duration
> -     * (i.e. previous S@starttime + @duration * (@repeat + 1)).
> -     * */
> -    int64_t starttime;
> -    /* repeat: Element or Attribute Name
> -     * specifies the repeat count of the number of following contiguous Segments with
> -     * the same duration expressed by the value of @duration. This value is zero-based
> -     * (e.g. a value of three means four Segments in the contiguous series).
> -     * */
> -    int64_t repeat;
> -    /* duration: Element or Attribute Name
> -     * specifies the Segment duration, in units of the value of the @timescale.
> -     * */
> +#define xml_for_each_attr /* { ... } */ \
> +    for (xmlAttrPtr attr = node->properties; \
> +         attr; \
> +         attr = attr->next) \
> +        for (xmlChar *value = xmlNodeGetContent(attr->children); \
> +             value; \
> +             xml_freep(&value))
> +
> +#define xml_for_each_child /* { ... } */ \
> +    for (xmlNodePtr child = xmlFirstElementChild(node); \
> +         child; \
> +         child = xmlNextElementSibling(child))
> +
> +#define ARRAY_SIZE(x) (sizeof(x) / sizeof(*x))
> +
> +#define DASH_RANGE_INITALIZER (DASHRange){ .start = 0, .end = INT64_MAX }
> +
> +typedef struct {
> +    int64_t start;
> +    int64_t end;
> +} DASHRange;
> +
> +typedef struct {
> +    xmlChar *url;
> +    DASHRange range;
> +} DASHSegment;
> +
> +typedef struct {
> +    xmlChar *id;
> +    int64_t start_ts;
> +    int64_t end_ts;
> +    AVDictionary *metadata;
> +} DASHPeriod;
> +
> +typedef struct {
> +    int64_t start_ts; /* Relative to timeline. */
> +    uint64_t number; /**< $Number$ */
> +    int64_t repeat; /**< number..=(number + repeat) */
>      int64_t duration;
> +} DASHSegmentTemplate;
> +
> +typedef struct {
> +    unsigned refcount;
> +    unsigned nb;
> +    char *elems[];
> +} DASHURLList;
> +
> +typedef struct {
> +    AVIOContext *pb; /**< IO context for reading segment. */
> +    uint64_t segment_size; /**< Size of segment to read. */
> +} DASHSegmentContext;
> +
> +typedef struct {
> +    xmlChar *id;
> +
> +    unsigned refcount;
> +    AVDictionary *metadata;
> +    AVEncryptionInitInfo *init_info; /**< Chain of initialization infos
> +                                       extracted from the manifest. */
> +} DASHAdaptationSet;
> +
> +enum DASHTimelineType {
> +    TIMELINE_TEMPLATES, /**< DASHTimeline.u.templates */
> +    TIMELINE_SEGMENTS, /**< DASHTimeline.u.segments */
>  };
>
> -/*
> - * Each playlist has its own demuxer. If it is currently active,
> - * it has an opened AVIOContext too, and potentially an AVPacket
> - * containing the next packet from this stream.
> - */
> -struct representation {
> -    char *url_template;
> -    AVIOContext pb;
> -    AVIOContext *input;
> -    AVFormatContext *parent;
> -    AVFormatContext *ctx;
> -    int stream_index;
> -
> -    char *id;
> -    char *lang;
> -    int bandwidth;
> -    AVRational framerate;
> -    AVStream *assoc_stream; /* demuxer stream associated with this representation */
> -
> -    int n_fragments;
> -    struct fragment **fragments; /* VOD list of fragment for profile */
> -
> -    int n_timelines;
> -    struct timeline **timelines;
> -
> -    int64_t first_seq_no;
> -    int64_t last_seq_no;
> -    int64_t start_number; /* used in case when we have dynamic list of segment to know which segments are new one*/
> -
> -    int64_t fragment_duration;
> -    int64_t fragment_timescale;
> -
> -    int64_t presentation_timeoffset;
> -
> -    int64_t cur_seq_no;
> -    int64_t cur_seg_offset;
> -    int64_t cur_seg_size;
> -    struct fragment *cur_seg;
> -
> -    /* Currently active Media Initialization Section */
> -    struct fragment *init_section;
> -    uint8_t *init_sec_buf;
> -    uint32_t init_sec_buf_size;
> -    uint32_t init_sec_data_len;
> -    uint32_t init_sec_buf_read_offset;
> -    int64_t cur_timestamp;
> -    int is_restart_needed;
> +typedef struct {
> +    unsigned refcount;
> +    enum DASHTimelineType type;
> +    int64_t duration;
> +    int64_t timescale;
> +    DASHSegment init;
> +    union {
> +        struct {
> +            unsigned nb;
> +            DASHSegment elems[];
> +        } segments;
> +        struct {
> +            unsigned nb;
> +            DASHSegment master;
> +            DASHSegmentTemplate elems[];
> +        } templates;
> +    } u;
> +} DASHTimeline;
> +
> +#define DASH_PARAMETERS_INITIALIZER { \
> +    .sample_aspect_ratio = { 0, 1 }, \
> +    .field_order = AV_FIELD_PROGRESSIVE, \
> +}
> +
> +typedef struct {
> +    enum AVMediaType codec_type;
> +    enum AVCodecID codec_id;
> +    int profile;
> +    int level;
> +    int disposition;
> +
> +    /* Audio only. */
> +    int sample_rate;
> +    int channels;
> +    uint64_t channel_layout;
> +    enum AVMatrixEncoding matrix_encoding;
> +
> +    /* Video only. */
> +    int width;
> +    int height;
> +    AVRational frame_rate;
> +    AVRational sample_aspect_ratio;
> +    enum AVFieldOrder field_order;
> +} DASHParameters;
> +
> +typedef struct {
> +    DASHPeriod *period;
> +    DASHAdaptationSet *as;
> +    DASHTimeline *timeline;
> +    DASHURLList *base;
> +    uint32_t bandwidth;
> +
> +    char *initbuf;
> +    int initbuf_size; /* Limited by INITBUF_MAX. */
> +
> +    DASHParameters par;
> +} DASHRepresentationPeriod;
> +
> +typedef struct {
> +    xmlChar *id;
> +
> +    AVFormatContext *oc; /* := DASHContext.ctx */
> +    AVStream **ostreams; /**< Corresponding output streams. */
> +    AVFormatContext *ic;
> +    unsigned nb_streams; /**< Should be := ic->nb_streams. If less, subdemuxer
> +                           created new streams. */
> +
> +    AVIOContext ic_pb; /**< Custom IO context for ic subdemuxer. */
> +
> +    int save_init; /**< Whether to store what we have read from the current segment. */
> +    DASHRepresentationPeriod **periods;
> +    unsigned nb_periods;
> +    DASHRepresentationPeriod *cur_period;
> +
> +    int64_t last_pts;
> +    int64_t read_ts;
> +
> +    unsigned cur_segment;
> +    DASHSegmentContext segments[];
> +} DASHRepresentation;
> +
> +enum DASHUTCTiming {
> +    DASH_UTC_TIMING_LOCAL,
> +    DASH_UTC_TIMING_HTTP_XSDATE,
> +    DASH_UTC_TIMING_HTTP_ISO,
> +    DASH_UTC_TIMING_HTTP_NTP,
> +    DASH_UTC_TIMING_NTP,
> +    DASH_UTC_TIMING_HTTP_HEAD,
> +    DASH_UTC_TIMING_DIRECT,
>  };
>
> -typedef struct DASHContext {
> +typedef struct {
>      const AVClass *class;
> -    char *base_url;
> -
> -    int n_videos;
> -    struct representation **videos;
> -    int n_audios;
> -    struct representation **audios;
> -    int n_subtitles;
> -    struct representation **subtitles;
> -
> -    /* MediaPresentationDescription Attribute */
> -    uint64_t media_presentation_duration;
> -    uint64_t suggested_presentation_delay;
> -    uint64_t availability_start_time;
> -    uint64_t availability_end_time;
> -    uint64_t publish_time;
> -    uint64_t minimum_update_period;
> -    uint64_t time_shift_buffer_depth;
> -    uint64_t min_buffer_time;
> -
> -    /* Period Attribute */
> -    uint64_t period_duration;
> -    uint64_t period_start;
> -
> -    /* AdaptationSet Attribute */
> -    char *adaptionset_lang;
> -
> -    int is_live;
> -    AVIOInterruptCB *interrupt_callback;
> -    char *allowed_extensions;
> -    AVDictionary *avio_opts;
> -    int max_url_size;
> -
> -    /* Flags for init section*/
> -    int is_init_section_common_video;
> -    int is_init_section_common_audio;
> -    int is_init_section_common_subtitle;
>
> +    xmlChar *id;
> +
> +    char *location;
> +    xmlChar *chain_next_location;
> +    xmlChar *fallback_location;
> +
> +    unsigned nb_connections;
> +
> +    DASHPeriod **periods;
> +    unsigned nb_periods;
> +
> +    DASHAdaptationSet **ass;
> +    unsigned nb_ass;
> +
> +    DASHRepresentation **reps;
> +    unsigned nb_reps;
> +
> +    int is_live; /**< Segments may get available over time. */
> +    int64_t start_ts;
> +
> +    int64_t media_presentation_duration;
> +    int64_t suggested_presentation_delay;
> +    int64_t availability_start_time;
> +    int64_t availability_end_time;
> +    int64_t publish_time;
> +    int64_t min_update_period;
> +    int64_t time_shift_buffer_depth;
> +    int64_t min_buffer_time;
> +    int64_t max_segment_duration;
> +
> +    int64_t next_update;
> +
> +    int64_t time_diff;
> +    int utc_timing; /* DASH_UTC_TIMING_*; < 0 if updated */
> +
> +    AVLFG rnd;
> +
> +    AVDictionary *protocol_opts;
>  } DASHContext;
>
> -static int ishttp(char *url)
> +typedef struct {
> +    xmlChar *scheme_id;
> +    xmlChar *value;
> +    xmlAttrPtr scheme_id_attr;
> +} DASHScheme;
> +
> +#define DASH_CONTENTPROTECTION_INITIALIZER { .has_key_id = 0 }
> +
> +typedef struct {
> +    int has_key_id;
> +    uint8_t default_kid[16];
> +} DASHContentProtection;
> +
> +#pragma GCC diagnostic push
> +#pragma GCC diagnostic ignored "-Wstrict-prototypes"
> +static av_cold void av_freep_arrayp(void *ptr, void (*free)())
> +{
> +    unsigned *nmemb = (unsigned *)((void **)ptr + 1);
> +
> +    for (unsigned i = 0; i < *nmemb; ++i)
> +        ((void(*)(void *))free)((*(void ***)ptr)[i]);
> +
> +    *nmemb = 0;
> +    av_freep(ptr);
> +}
> +#pragma GCC diagnostic pop
> +
> +static void xml_free(xmlChar *p)
> +{
> +    if (p)
> +        xmlFree(p);
> +}
> +
> +static void xml_freep(xmlChar **pp)
> +{
> +    if (*pp) {
> +        xmlFree(*pp);
> +        *pp = NULL;
> +    }
> +}
> +
> +static av_cold DASHURLList *dash_ref_urllist(DASHURLList *urls)
> +{
> +    ++urls->refcount;
> +    return urls;
> +}
> +
> +static av_cold void dash_unref_urllist(DASHURLList *urls)
> +{
> +    if (!urls || --urls->refcount)
> +        return;
> +
> +    for (unsigned i = 0; i < urls->nb; ++i)
> +        av_free(urls->elems[i]);
> +    av_free(urls);
> +}
> +
> +static int dash_urllist_has(const DASHURLList *urls, const char *url)
>  {
> -    const char *proto_name = avio_find_protocol_name(url);
> -    return proto_name && av_strstart(proto_name, "http", NULL);
> +    for (unsigned i = 0; i < urls->nb; ++i)
> +        if (!strcmp(urls->elems[i], url))
> +            return 1;
> +
> +    return 0;
> +}
> +
> +static av_cold void dash_free_period(DASHPeriod *period)
> +{
> +    if (!period)
> +        return;
> +
> +    xml_free(period->id);
> +    av_dict_free(&period->metadata);
> +    av_free(period);
> +}
> +
> +static av_cold void dash_free_adaptationset(DASHAdaptationSet *as)
> +{
> +    if (!as)
> +        return;
> +
> +    xml_free(as->id);
> +    av_encryption_init_info_free(as->init_info);
> +    av_dict_free(&as->metadata);
> +    av_free(as);
> +}
> +
> +static av_cold DASHTimeline *dash_ref_timeline(DASHTimeline *timeline)
> +{
> +    ++timeline->refcount;
> +    return timeline;
> +}
> +
> +static void dash_free_segment(DASHSegment *g)
> +{
> +    xml_free(g->url);
> +}
> +
> +static void dash_unref_timeline(DASHTimeline *timeline)
> +{
> +    if (!timeline || --timeline->refcount)
> +        return;
> +
> +    dash_free_segment(&timeline->init);
> +
> +    if (TIMELINE_SEGMENTS == timeline->type) {
> +        for (unsigned i = 0; i < timeline->u.segments.nb; ++i)
> +            dash_free_segment(&timeline->u.segments.elems[i]);
> +    } else if (TIMELINE_TEMPLATES == timeline->type) {
> +        dash_free_segment(&timeline->u.templates.master);
> +    } else {
> +        abort();
> +    }
> +
> +    av_free(timeline);
>  }
>
> -static int aligned(int val)
> +/**
> + * @return |wall_time| / MICROSEC_PER_SEC * AV_TIME_BASE
> + */
> +static int64_t av_wall2timebase(int64_t wall_time)
>  {
> -    return ((val + 0x3F) >> 6) << 6;
> +    if (MICROSEC_PER_SEC < AV_TIME_BASE)
> +        return wall_time * (AV_TIME_BASE / MICROSEC_PER_SEC);
> +    else
> +        return wall_time / (MICROSEC_PER_SEC / AV_TIME_BASE);
>  }
>
> -static uint64_t get_current_time_in_sec(void)
> +/**
> + * @return wall clock time in AV_TIME_BASE
> + */
> +static int64_t dash_gettime(AVFormatContext *s)
>  {
> -    return  av_gettime() / 1000000;
> +    DASHContext *c = s->priv_data;
> +    return av_wall2timebase(av_gettime()) + c->time_diff;
>  }
>
> -static uint64_t get_utc_date_time_insec(AVFormatContext *s, const char *datetime)
> +/**
> + * Parse ISO-8601 date.
> + * @return time in AV_TIME_BASE
> + */
> +static uint64_t dash_parse_date(const char *s, AVFormatContext *log_ctx)
>  {
>      struct tm timeinfo;
> -    int year = 0;
> -    int month = 0;
> -    int day = 0;
> -    int hour = 0;
> -    int minute = 0;
> -    int ret = 0;
> +    unsigned year = 0, month = 0, day = 0;
> +    unsigned hour = 0, minute = 0;
>      float second = 0.0;
>
> -    /* ISO-8601 date parser */
> -    if (!datetime)
> -        return 0;
> +    if (6 != av_sscanf(s, "%u-%u-%uT%u:%u:%fZ",
> +                       &year, &month, &day,
> +                       &hour, &minute, &second))
> +        av_log(log_ctx, AV_LOG_WARNING, "Malformed ISO-8601 date: '%s'\n", s);
> +        /* Fall-through. */
>
> -    ret = sscanf(datetime, "%d-%d-%dT%d:%d:%fZ", &year, &month, &day, &hour, &minute, &second);
> -    /* year, month, day, hour, minute, second  6 arguments */
> -    if (ret != 6) {
> -        av_log(s, AV_LOG_WARNING, "get_utc_date_time_insec get a wrong time format\n");
> -    }
>      timeinfo.tm_year = year - 1900;
>      timeinfo.tm_mon  = month - 1;
>      timeinfo.tm_mday = day;
> @@ -205,2189 +425,2711 @@ static uint64_t get_utc_date_time_insec(AVFormatContext *s, const char *datetime
>      return av_timegm(&timeinfo);
>  }
>
> -static uint32_t get_duration_insec(AVFormatContext *s, const char *duration)
> -{
> -    /* ISO-8601 duration parser */
> -    uint32_t days = 0;
> -    uint32_t hours = 0;
> -    uint32_t mins = 0;
> -    uint32_t secs = 0;
> -    int size = 0;
> -    float value = 0;
> -    char type = '\0';
> -    const char *ptr = duration;
> -
> -    while (*ptr) {
> -        if (*ptr == 'P' || *ptr == 'T') {
> -            ptr++;
> +/**
> + * Parse ISO-8601 duration.
> + * @return duration in AV_TIME_BASE
> + */
> +static int64_t dash_parse_duration(const char *s, AVFormatContext *log_ctx)
> +{
> +    enum {
> +        STATE_GROUND,
> +        STATE_DATE,
> +        STATE_TIME,
> +    } state = STATE_GROUND;
> +    int64_t ret = 0;
> +
> +    for (const char *p = s; *p; ++p) {
> +        int len;
> +        int64_t unit = 0;
> +        /* We require double precision since it is absolutely valid to pass a
> +         * huge integer solely in seconds. */
> +        double base;
> +
> +        switch (*p) {
> +        case 'P':
> +            if (state != STATE_GROUND)
> +                goto invalid;
> +            state = STATE_DATE;
> +            continue;
> +        case 'T':
> +            if (state != STATE_DATE)
> +                goto invalid;
> +            state = STATE_TIME;
>              continue;
>          }
>
> -        if (sscanf(ptr, "%f%c%n", &value, &type, &size) != 2) {
> -            av_log(s, AV_LOG_WARNING, "get_duration_insec get a wrong time format\n");
> -            return 0; /* parser error */
> +        av_sscanf(p, "%lf%n", &base, &len);
> +        p += len;
> +
> +        switch (state) {
> +        case STATE_DATE:
> +            switch (*p) {
> +            case 'Y':
> +                unit = (int64_t)AV_TIME_BASE * 60 * 60 * 24 * 365;
> +                break;
> +            case 'M':
> +                unit = (int64_t)AV_TIME_BASE * 60 * 60 * 24 * 30;
> +                break;
> +            case 'D':
> +                unit = (int64_t)AV_TIME_BASE * 60 * 60 * 24;
> +                break;
> +            }
> +            break;
> +        case STATE_TIME:
> +            switch (*p) {
> +            case 'H':
> +                unit = (int64_t)AV_TIME_BASE * 60 * 60;
> +                break;
> +            case 'M':
> +                unit = (int64_t)AV_TIME_BASE * 60;
> +                break;
> +            case 'S':
> +                unit = (int64_t)AV_TIME_BASE;
> +                break;
> +            }
> +            break;
> +        }
> +
> +        if (!unit) {
> +        invalid:
> +            av_log(log_ctx, AV_LOG_ERROR, "Malformed ISO-8601 duration: '%s'\n", s);
> +            return INT64_MIN;
>          }
> +
> +        ret += unit * base;
> +    }
> +
> +    return ret;
> +}
> +
> +static av_cold void dash_subdemuxer_flush(DASHRepresentation *rep)
> +{
> +    DASHContext *c = rep->oc->priv_data;
> +
> +    avio_flush(&rep->ic_pb);
> +    for (unsigned i = 0; i < c->nb_connections; ++i)
> +        ff_format_io_close(rep->oc, &rep->segments[i].pb);
> +
> +
> +    /* for (unsigned i = 0; i < rep->nb_streams; ++i)
> +            avcodec_flush_buffers(rep->ostreams[i]->internal->avctx); */
> +
> +    if (rep->ic) {
> +        /* for (unsigned i = 0; i < rep->ic->nb_streams; ++i)
> +                avcodec_flush_buffers(rep->ic->streams[i]->internal->avctx); */
> +        avformat_flush(rep->ic);
> +    }
> +
> +    /* If receiving init section just has been aborted, we have to forget all
> +     * received bytes otherwise at subdemuxer restart on the first read it will
> +     * be falsely detected that we have received the complete section because
> +     * stored init section size is less than maximum storable. */
> +    if (rep->save_init) {
> +        rep->save_init = 0;
> +        if (rep->cur_period) {
> +            rep->cur_period->initbuf_size = 0;
> +            rep->cur_period = NULL;
> +        }
> +    }
> +}
> +
> +static av_cold void dash_subdemuxer_close(DASHRepresentation *rep)
> +{
> +    av_log(rep->oc, AV_LOG_DEBUG, "Closing representation '%s'\n", rep->id);
> +
> +    /* Only need to deallocate the used array. */
> +    av_freep(&rep->ic_pb.buffer);
> +
> +    dash_subdemuxer_flush(rep);
> +
> +    if (rep->ic) {
> +        /* IO context is part of our context so avoid freeing it. */
> +        rep->ic->pb = NULL;
> +        rep->cur_period = NULL;
> +
> +        if (rep->ic->iformat) {
> +            avformat_close_input(&rep->ic);
> +        } else {
> +            avformat_free_context(rep->ic);
> +            rep->ic = NULL;
> +        }
> +    }
> +}
> +
> +static av_cold void dash_free_representationperiod(DASHRepresentationPeriod *period)
> +{
> +    dash_unref_timeline(period->timeline);
> +    dash_unref_urllist(period->base);
> +    av_free(period->initbuf);
> +    av_free(period);
> +}
> +
> +static av_cold void dash_free_representation(DASHRepresentation *rep)
> +{
> +    dash_subdemuxer_close(rep);
> +    av_free(rep->ostreams);
> +    av_freep_arrayp(&rep->periods, dash_free_representationperiod);
> +    xml_free(rep->id);
> +    av_free(rep);
> +}
> +
> +static av_cold xmlNodePtr xml_get_nsnode(xmlNodePtr node, const char *nodename, const char *namespace)
> +{
> +    xml_for_each_child
> +        if (!strcmp(child->name, nodename) &&
> +            (child->ns && !strcmp(child->ns->href, namespace)))
> +            return child;
> +    return NULL;
> +}
> +
> +static av_cold int dash_parse_contentprotection_pssh(AVFormatContext *s,
> +                                                     struct AVEncryptionInitInfo *info,
> +                                                     xmlNodePtr node)
> +{
> +    int ret = 0;
> +    xmlNodePtr pssh_node;
> +    int size;
> +    char *pssh = NULL;
> +    int decoded_size;
> +    uint8_t *decoded_pssh;
> +
> +    av_free(info->data);
> +    info->data = NULL;
> +    info->data_size = 0;
> +
> +    if (!(pssh_node = xml_get_nsnode(node, "pssh", CENC_NAMESPACE)))
> +        goto out;
> +
> +    if (!(pssh = xmlNodeGetContent(pssh_node)))
> +        goto invalid_content;
> +
> +    size = strlen(pssh);
> +    decoded_size = AV_BASE64_DECODE_SIZE(size);
> +
> +    if (!(decoded_pssh = av_malloc(decoded_size))) {
> +        ret = AVERROR(ENOMEM);
> +        goto out;
> +    }
> +
> +    if ((decoded_size = av_base64_decode(decoded_pssh, pssh, decoded_size)) < 0) {
> +        av_free(decoded_pssh);
> +
> +    invalid_content:
> +        av_log(s, AV_LOG_ERROR, "Invalid %s/{%s}:pssh content\n",
> +               node->name, CENC_NAMESPACE);
> +        ret = AVERROR_INVALIDDATA;
> +        goto out;
> +    }
> +
> +    info->data = decoded_pssh;
> +    info->data_size = decoded_size;
> +
> +out:
> +    xml_free(pssh);
> +    return ret;
> +}
> +
> +static av_cold void dash_free_scheme(DASHScheme *scheme)
> +{
> +    xml_free(scheme->scheme_id);
> +    xml_free(scheme->value);
> +}
> +
> +static av_cold void dash_log_invalid_attr_value(AVFormatContext *log_ctx, xmlAttrPtr attr, const char *value)
> +{
> +    av_log(log_ctx, AV_LOG_ERROR, "Invalid %s/%s@%s%s%s%s='%s'\n",
> +           attr->parent->parent->name,
> +           attr->parent->ns ? "{" : "",
> +           attr->parent->ns ? (const char *)attr->parent->ns->href : "",
> +           attr->parent->ns ? "}" : "",
> +           attr->parent->name,
> +           attr->name,
> +           value);
> +}
> +
> +static av_cold void dash_log_missing_attr(AVFormatContext *log_ctx, xmlNodePtr node, const char *attr)
> +{
> +    av_log(log_ctx, AV_LOG_ERROR, "Missing %s/%s@%s\n",
> +           node->parent->name,
> +           node->name,
> +           attr);
> +}
> +
> +static av_cold void dash_log_unknown_child(AVFormatContext *log_ctx, xmlNodePtr child)
> +{
> +    av_log(log_ctx, AV_LOG_WARNING, "Unknown %s/%s\n",
> +           child->parent->name,
> +           child->name);
> +}
> +
> +static av_cold void dash_log_unknown_attr(AVFormatContext *log_ctx, xmlAttrPtr attr, const xmlChar *value)
> +{
> +    av_log(log_ctx, AV_LOG_WARNING, "Unknown %s%s%s@%s%s%s%s='%s'\n",
> +           attr->parent->parent->name ? (const char *)attr->parent->parent->name : "",
> +           attr->parent->parent->name ? "/"                                      : "",
> +           attr->parent->name,
> +           attr->ns ? "{" : "",
> +           attr->ns ? (const char *)attr->ns->href : "",
> +           attr->ns ? "}:" : "",
> +           attr->name,
> +           value);
> +}
> +
> +static av_cold void dash_log_unknown_scheme(AVFormatContext *log_ctx, const DASHScheme *scheme)
> +{
> +    av_log(log_ctx, AV_LOG_WARNING,
> +           "Unknown %s/%s@%s='%s' (@value=%c%s%c)\n",
> +           scheme->scheme_id_attr->parent->parent->name,
> +           scheme->scheme_id_attr->parent->name,
> +           scheme->scheme_id_attr->name,
> +           scheme->scheme_id,
> +           scheme->value ? '\''                        : '(',
> +           scheme->value ? (const char *)scheme->value : "not present",
> +           scheme->value ? '\''                        : ')');
> +}
> +
> +static av_cold int dash_parse_scheme(AVFormatContext *s, DASHScheme *scheme, int value_required, xmlNodePtr node)
> +{
> +    scheme->value = NULL;
> +
> +    if (!(scheme->scheme_id_attr = xmlHasNsProp(node, "schemeIdUri", NULL))) {
> +        dash_log_missing_attr(s, node, "schemeIdUri");
> +        return AVERROR_INVALIDDATA;
> +    }
> +
> +    if (!(scheme->scheme_id = xmlNodeGetContent(scheme->scheme_id_attr->children)))
> +        return AVERROR(ENOMEM);
> +
> +    if (!(scheme->value = xmlGetNoNsProp(node, "value")) && value_required) {
> +        dash_log_missing_attr(s, node, "value");
> +        return AVERROR_INVALIDDATA;
> +    }
> +
> +    return 0;
> +}
> +
> +static av_cold int dash_parse_contentprotection(AVFormatContext *s,
> +                                                DASHAdaptationSet *as,
> +                                                DASHContentProtection *cp,
> +                                                xmlNodePtr node)
> +{
> +    int ret = 0;
> +    AVEncryptionInitInfo *init_info = NULL;
> +    const char *uuid;
> +    DASHScheme scheme;
> +
> +    if ((ret = dash_parse_scheme(s, &scheme, 0, node)) < 0)
> +        goto out;
> +
> +    /* Parse Common Encryption element. */
> +    if (!cp->has_key_id &&
> +        !strcmp(scheme.scheme_id, "urn:mpeg:dash:mp4protection:2011") &&
> +        (scheme.value && !strcmp(scheme.value, "cenc")))
> +    {
> +        char *key_id;
> +
> +        if ((key_id = xmlGetNsProp(node, "default_KID", CENC_NAMESPACE))) {
> +            if (ff_uuid_to_data(cp->default_kid, key_id) < 0)
> +                av_log(s, AV_LOG_ERROR, "Malformed UUID in ContentProtection@cenc:default_KID='%s'\n",
> +                       scheme.scheme_id);
> +            else
> +                cp->has_key_id = 1;
> +
> +            xmlFree(key_id);
> +        } else {
> +            dash_log_missing_attr(s, node, "default_KID");
> +        }
> +
> +        goto out;
> +    } else if (cp->has_key_id && av_strstart(scheme.scheme_id, "urn:uuid:", &uuid)) {
> +        /* Parse an UUID schema. */
> +        init_info = av_encryption_init_info_alloc(/* system_id_size */ 16, 1,
> +                                                  /* key_id_size */ 16, /* data_size */ 0,
> +                                                  /* extra_data_size */ 0);
> +        if (!init_info) {
> +            ret = AVERROR(ENOMEM);
> +            goto out;
> +        }
> +
> +        if (ff_uuid_to_data(init_info->system_id, uuid) < 0) {
> +            av_log(s, AV_LOG_ERROR, "Malformed UUID in ContentProtection@schemeIdUri='%s'\n",
> +                   scheme.scheme_id);
> +            goto out;
> +        }
> +
> +        if (0 <= ret)
> +            ret = dash_parse_contentprotection_pssh(s, init_info, node);
> +        if (ret < 0)
> +            goto out;
> +
> +        memcpy(init_info->key_ids[0], cp->default_kid, init_info->key_id_size);
> +
> +        init_info->next = as->init_info;
> +        as->init_info = init_info;
> +        init_info = NULL;
> +    } else {
> +        dash_log_unknown_scheme(s, &scheme);
> +        goto out;
> +    }
> +
> +out:
> +    if (init_info)
> +        av_encryption_init_info_free(init_info);
> +    dash_free_scheme(&scheme);
> +
> +    return ret;
> +}
> +
> +static av_cold int dash_set_location(AVFormatContext *s, char const *url)
> +{
> +    DASHContext *c = s->priv_data;
> +    URLComponents uc;
> +    char const *protocol;
> +
> +    if (ff_url_decompose(&uc, url, NULL) < 0)
> +        return AVERROR_INVALIDDATA;
> +
> +    av_free(c->location);
> +    if (!(c->location = av_strdup(url)))
> +        return AVERROR(ENOMEM);
> +
> +    protocol = avio_find_protocol_name(c->location);
> +    if (strstr(protocol, "http")) {
> +        char *p = strstr(uc.query, "t=");
> +        if (p) {
> +            int64_t seconds;
> +
> +            p += 2;
> +            if (1 == av_sscanf(p, "posix:%"SCNd64, &seconds))
> +                c->start_ts = AV_TIME_BASE * seconds;
> +            else if (!strncmp(p, "now", 4))
> +                c->start_ts = dash_gettime(s);
> +            else
> +                c->start_ts = dash_parse_date(p, s);
> +        }
> +    }
> +
> +    return 0;
> +}
> +
> +static av_cold int dash_parse_location(AVFormatContext *s,
> +                                       xmlNodePtr node)
> +{
> +    int ret = 0;
> +    char *value;
> +    DASHContext *c = s->priv_data;
> +
> +    if (!c->is_live) {
> +        av_log(s, AV_LOG_INFO, "MPD@type=\"static\"/Location ignored\n");
> +        return 0;
> +    }
> +
> +    if (!(value = xmlNodeGetContent(node)))
> +        return AVERROR(ENOMEM);
> +
> +    ret = dash_set_location(s, value);
> +
> +    xmlFree(value);
> +    return ret;
> +}
> +
> +/**
> + * Like ff_make_absolute_urla() but allocates a big enough memory.
> + * *out_url shall always be av_free()d regard of error.
> + * */
> +static int ff_make_absolute_urla(char **out_url, const char *base, const char *rel)
> +{
> +    int out_url_max_size = strlen(base) + strlen(rel) + 1/* NUL */;
> +    if (!(*out_url = av_malloc(out_url_max_size)))
> +        return AVERROR(ENOMEM);
> +
> +    return ff_make_absolute_url(*out_url, out_url_max_size, base, rel);
> +}
> +
> +static av_cold DASHURLList *dash_new_urllist(unsigned nb_urls)
> +{
> +    DASHURLList *urls;
> +
> +    if (!(urls = av_mallocz(offsetof(DASHURLList, elems[nb_urls]))))
> +        return NULL;
> +
> +    dash_ref_urllist(urls);
> +    urls->nb = nb_urls;
> +
> +    return urls;
> +}
> +
> +static av_cold int dash_parse_baseurl(AVFormatContext *s,
> +                                      DASHURLList **urls,
> +                                      xmlNodePtr node)
> +{
> +    int ret = 0;
> +    DASHContext *c = s->priv_data;
> +    char *url_chunk = NULL;
> +    char *resolved_url = NULL;
> +    DASHURLList *new_urls = NULL;
> +    int is_absolute;
> +    char *base_url;
> +
> +    if (!(url_chunk = xmlNodeGetContent(node)))
> +        return AVERROR(ENOMEM);
> +
> +    base_url = (*urls)->elems[0];
> +    if ((ret = ff_make_absolute_urla(&resolved_url, base_url, url_chunk)) < 0)
> +        goto out;
> +
> +    if (dash_urllist_has(*urls, resolved_url))
> +        goto out;
> +
> +    is_absolute = !strcmp(resolved_url, url_chunk);
> +
> +    if (1 == (*urls)->refcount) {
> +        /* If we own the instance, it means that this node is an alternative
> +         * BaseURL. */
> +        if (is_absolute) {
> +            void *p;
> +
> +            if ((p = av_realloc(*urls, offsetof(DASHURLList, elems[(*urls)->nb + 1])))) {
> +                /* Put the new URL at a random place. Absolute addresses most
> +                 * commonly mean different servers/CDNs, so we can help a
> +                 * little bit on load-balancing. */
> +                unsigned to_index;
> +
> +                *urls = p;
> +                to_index = av_lfg_get(&c->rnd) % ((*urls)->nb + 1);
> +                (*urls)->elems[(*urls)->nb++] = (*urls)->elems[to_index];
> +                (*urls)->elems[to_index] = resolved_url, resolved_url = NULL;
> +            }
> +        } else {
> +            /* We do not want to explode URL list so we ignore relative
> +             * alternative URLs. Also, using different paths on the same
> +             * server does not really makes sense. */
> +        }
> +    } else {
> +        /* Either add a single absolute URL to the list or in case of a
> +         * relative BaseURL combine it with every parent URL. */
> +        if (!(new_urls = dash_new_urllist(is_absolute ? 1 : (*urls)->nb))) {
> +            ret = AVERROR(ENOMEM);
> +            goto out;
> +        }
> +
> +        /* We have already done the first one at the top. */
> +        new_urls->elems[0] = resolved_url, resolved_url = NULL;
> +        if (!is_absolute) {
> +            for (unsigned i = 1; i < (*urls)->nb; ++i)
> +                if (!(ret = ff_make_absolute_urla(&new_urls->elems[i], (*urls)->elems[i], url_chunk)))
> +                    goto out;
> +        }
> +
> +        /* Replace URL list of current level with the modified one. */
> +        dash_unref_urllist(*urls);
> +        *urls = new_urls;
> +        new_urls = NULL;
> +    }
> +
> +out:
> +    xmlFree(url_chunk);
> +    av_free(resolved_url);
> +    dash_unref_urllist(new_urls);
> +    return ret;
> +}
> +
> +static av_cold int dash_parse_mimetype(DASHParameters *par, const char *value)
> +{
> +    if (!strncmp(value, "video/", 6))
> +        par->codec_type = AVMEDIA_TYPE_VIDEO;
> +    else if (!strncmp(value, "audio/", 6))
> +        par->codec_type = AVMEDIA_TYPE_AUDIO;
> +    else if (!strncmp(value, "text/", 5))
> +        par->codec_type = AVMEDIA_TYPE_SUBTITLE;
> +    else
> +        return 1;
> +
> +    return 0;
> +}
> +
> +static av_cold int dash_parse_contenttype(AVFormatContext *s,
> +                                          DASHParameters *par,
> +                                          const xmlChar *value)
> +{
> +    if (!strcmp(value, "video"))
> +        par->codec_type = AVMEDIA_TYPE_VIDEO;
> +    else if (!strcmp(value, "audio"))
> +        par->codec_type = AVMEDIA_TYPE_AUDIO;
> +    else {
> +        par->codec_type = AVMEDIA_TYPE_UNKNOWN;
> +        return 1;
> +    }
> +
> +    return 0;
> +}
> +
> +static av_cold int dash_parse_codecs(AVFormatContext *s,
> +                                     DASHParameters *par,
> +                                     const xmlChar *value)
> +{
> +    int n;
> +    char type;
> +    int flags;
> +
> +    /* https://developer.mozilla.org/en-US/docs/Web/Media/Formats/codecs_parameter */
> +    /* https://tools.ietf.org/html/rfc6381 */
> +    if (3 == av_sscanf(value, "mp4%c.%d.%d%n", &type, &par->level, &par->profile, &n) &&
> +        !value[n])
> +    {
>          switch (type) {
> -        case 'D':
> -            days = (uint32_t)value;
> -            break;
> -        case 'H':
> -            hours = (uint32_t)value;
> -            break;
> -        case 'M':
> -            mins = (uint32_t)value;
> -            break;
> -        case 'S':
> -            secs = (uint32_t)value;
> -            break;
> -        default:
> -            // handle invalid type
> -            break;
> +        case 'a': par->codec_type = AVMEDIA_TYPE_AUDIO; break;
> +        case 'v': par->codec_type = AVMEDIA_TYPE_VIDEO; break;
> +        default: return 1;
>          }
> -        ptr += size;
> +
> +    } else if (3 == av_sscanf(value, "avc1"/* avcoti */".%02x%02x%02x%n",
> +                              &par->profile, &flags, &par->level, &n) &&
> +               !value[n])
> +    {
> +        par->codec_type = AVMEDIA_TYPE_VIDEO;
> +        par->codec_id = AV_CODEC_ID_H264;
> +        par->profile |= (unsigned)flags << 7;
> +    } else if (av_sscanf(value, "hev1.%n", &n), n == 5)
> +    {
> +        par->codec_id = AV_CODEC_ID_HEVC;
> +    } else {
> +        par->codec_id = AV_CODEC_ID_NONE;
> +        return 1;
>      }
> -    return  ((days * 24 + hours) * 60 + mins) * 60 + secs;
> +
> +    return 0;
>  }
>
> -static int64_t get_segment_start_time_based_on_timeline(struct representation *pls, int64_t cur_seq_no)
> +static av_cold int dash_parse_scantype(AVFormatContext *s,
> +                                       DASHParameters *par,
> +                                       const xmlChar *value)
>  {
> -    int64_t start_time = 0;
> -    int64_t i = 0;
> -    int64_t j = 0;
> -    int64_t num = 0;
> -
> -    if (pls->n_timelines) {
> -        for (i = 0; i < pls->n_timelines; i++) {
> -            if (pls->timelines[i]->starttime > 0) {
> -                start_time = pls->timelines[i]->starttime;
> -            }
> -            if (num == cur_seq_no)
> -                goto finish;
> +    if (!strcmp(value, "progressive")) {
> +        par->field_order = AV_FIELD_PROGRESSIVE;
> +    } else {
> +        par->field_order = AV_FIELD_UNKNOWN;
> +        return 1;
> +    }
>
> -            start_time += pls->timelines[i]->duration;
> +    return 0;
> +}
>
> -            if (pls->timelines[i]->repeat == -1) {
> -                start_time = pls->timelines[i]->duration * cur_seq_no;
> -                goto finish;
> -            }
> +static av_cold int dash_parse_parameters(AVFormatContext *s,
> +                                         DASHParameters *par,
> +                                         xmlAttrPtr attr,
> +                                         const xmlChar *value)
> +{
> +    if (!strcmp(attr->name, "height"))
> +        (void)av_sscanf(value, "%d", &par->height);
> +    else if (!strcmp(attr->name, "width"))
> +        (void)av_sscanf(value, "%d", &par->width);
> +    else if (!strcmp(attr->name, "mimeType"))
> +        return dash_parse_mimetype(par, value);
> +    else if (!strcmp(attr->name, "audioSamplingRate"))
> +        (void)av_sscanf(value, "%d", &par->sample_rate);
> +    else if (!strcmp(attr->name, "par"))
> +        /* Ignore. */;
> +    else if (!strcmp(attr->name, "sar"))
> +        (void)av_parse_ratio(&par->sample_aspect_ratio, value, INT_MAX, AV_LOG_ERROR, s);
> +    else if (!strcmp(attr->name, "frameRate"))
> +        (void)av_sscanf(value, "%d", &par->frame_rate);
> +    else if (!strcmp(attr->name, "codecs"))
> +        return dash_parse_codecs(s, par, value);
> +    else if (!strcmp(attr->name, "scanType"))
> +        return dash_parse_scantype(s, par, value);
> +    else if (!strcmp(attr->name, "contentType"))
> +        return dash_parse_contenttype(s, par, value);
> +    else
> +        return 1;
> +
> +    return 0;
> +}
>
> -            for (j = 0; j < pls->timelines[i]->repeat; j++) {
> -                num++;
> -                if (num == cur_seq_no)
> -                    goto finish;
> -                start_time += pls->timelines[i]->duration;
> -            }
> -            num++;
> -        }
> +static av_cold int dash_parse_audiochannelconfiguration(AVFormatContext *s,
> +                                                        DASHParameters *par,
> +                                                        xmlNodePtr node)
> +{
> +    int ret = 0;
> +    DASHScheme scheme;
> +
> +    if ((ret = dash_parse_scheme(s, &scheme, 1, node)) < 0)
> +        goto out;
> +
> +    par->channels = 0;
> +    par->channel_layout = 0;
> +    par->matrix_encoding = AV_MATRIX_ENCODING_NONE;
> +
> +    /* https://testassets.dashif.org/#testvector/details/586fb3879ae9045678eacd10 */
> +    if (!strcmp(scheme.scheme_id, "urn:dolby:dash:audio_channel_configuration:2011") ||
> +        !strcmp(scheme.scheme_id, "tag:dolby.com,2014:dash:audio_channel_configuration:2011"))
> +    {
> +        par->matrix_encoding = AV_MATRIX_ENCODING_DOLBY;
> +        (void)av_get_extended_channel_layout(scheme.value, &par->channel_layout, &par->channels);
> +    } else if (!strcmp(scheme.scheme_id, "urn:mpeg:dash:23003:3:audio_channel_configuration:2011")) {
> +        (void)av_sscanf(scheme.value, "%d", &par->channels);
> +        par->channel_layout = av_get_default_channel_layout(par->channels);
> +    } else {
> +        (void)av_get_extended_channel_layout(scheme.value, &par->channel_layout, &par->channels);
> +        dash_log_unknown_scheme(s, &scheme);
>      }
> -finish:
> -    return start_time;
> +
> +out:
> +    dash_free_scheme(&scheme);
> +    return ret;
>  }
>
> -static int64_t calc_next_seg_no_from_timelines(struct representation *pls, int64_t cur_time)
> +static av_cold int dash_parse_assetidentifier(AVFormatContext *s,
> +                                              DASHPeriod *period,
> +                                              xmlNodePtr node)
>  {
> -    int64_t i = 0;
> -    int64_t j = 0;
> -    int64_t num = 0;
> -    int64_t start_time = 0;
> +    int ret = 0;
> +    DASHScheme scheme;
>
> -    for (i = 0; i < pls->n_timelines; i++) {
> -        if (pls->timelines[i]->starttime > 0) {
> -            start_time = pls->timelines[i]->starttime;
> -        }
> -        if (start_time > cur_time)
> -            goto finish;
> -
> -        start_time += pls->timelines[i]->duration;
> -        for (j = 0; j < pls->timelines[i]->repeat; j++) {
> -            num++;
> -            if (start_time > cur_time)
> -                goto finish;
> -            start_time += pls->timelines[i]->duration;
> -        }
> -        num++;
> -    }
> +    if ((ret = dash_parse_scheme(s, &scheme, 1, node)) < 0)
> +        goto out;
>
> -    return -1;
> +    if (!strcmp(scheme.scheme_id, "urn:org:dashif:asset-id:2013")) {
> +        av_dict_set(&period->metadata, "asset_identifier", scheme.value, 0);
> +    } else {
> +        dash_log_unknown_scheme(s, &scheme);
> +    }
>
> -finish:
> -    return num;
> +out:
> +    dash_free_scheme(&scheme);
> +    return ret;
>  }
>
> -static void free_fragment(struct fragment **seg)
> +static av_cold int dash_parse_viewpoint(AVFormatContext *s,
> +                                        DASHAdaptationSet *as,
> +                                        xmlNodePtr node)
>  {
> -    if (!(*seg)) {
> -        return;
> +    int ret = 0;
> +    DASHScheme scheme;
> +
> +    if ((ret = dash_parse_scheme(s, &scheme, 1, node)) < 0)
> +        goto out;
> +
> +    /* https://testassets.dashif.org/#testvector/details/5cde78e4a5eeda55aa663101 */
> +    if (!strcmp(scheme.scheme_id, "urn:mpeg:dash:viewpoint:2011")) {
> +        av_dict_set(&as->metadata, "viewpoint", scheme.value, 0);
> +    } else {
> +        dash_log_unknown_scheme(s, &scheme);
>      }
> -    av_freep(&(*seg)->url);
> -    av_freep(seg);
> +
> +out:
> +    dash_free_scheme(&scheme);
> +    return ret;
>  }
>
> -static void free_fragment_list(struct representation *pls)
> +static av_cold void dash_sync_time(AVFormatContext *s, const xmlChar *value)
>  {
> -    int i;
> +    DASHContext *c = s->priv_data;
> +    int ret = 0;
> +
> +    switch (c->utc_timing) {
> +    case DASH_UTC_TIMING_LOCAL:
> +    default:
> +        ret = 1;
> +        break;
> +    case DASH_UTC_TIMING_HTTP_XSDATE:
> +    case DASH_UTC_TIMING_HTTP_ISO:
> +    case DASH_UTC_TIMING_HTTP_NTP:
> +    case DASH_UTC_TIMING_NTP:
> +    case DASH_UTC_TIMING_HTTP_HEAD:
> +    case DASH_UTC_TIMING_DIRECT:
> +        ret = AVERROR_PATCHWELCOME;
> +        break;
> +    }
>
> -    for (i = 0; i < pls->n_fragments; i++) {
> -        free_fragment(&pls->fragments[i]);
> +    if (!ret) {
> +        av_log(s, AV_LOG_DEBUG, "Time synchronized: %lf s\n",
> +               (double)c->time_diff / AV_TIME_BASE);
> +        c->utc_timing = -c->utc_timing;
> +    } else if (ret < 0) {
> +        av_log(s, AV_LOG_ERROR, "Failed to synchronized time: %s\n",
> +               av_err2str(ret));
>      }
> -    av_freep(&pls->fragments);
> -    pls->n_fragments = 0;
>  }
>
> -static void free_timelines_list(struct representation *pls)
> +static av_cold int dash_parse_utctiming(AVFormatContext *s,
> +                                        xmlNodePtr node)
>  {
> -    int i;
> +    int ret = 0;
> +    DASHContext *c = s->priv_data;
> +    DASHScheme scheme;
> +    int utc_timing = c->utc_timing;
> +
> +    if ((ret = dash_parse_scheme(s, &scheme, 0, node)) < 0)
> +        goto out;
> +
> +    c->utc_timing = DASH_UTC_TIMING_LOCAL;
> +
> +    if (0);
> +#define PARSE(name, scheme_name) \
> +    else if (!strcmp(scheme.scheme_id, "urn:mpeg:dash:utc:"scheme_name":2014")) \
> +        c->utc_timing = DASH_UTC_TIMING_##name
> +    PARSE(HTTP_XSDATE, "http-xsdate");
> +    PARSE(HTTP_ISO,    "http-iso");
> +    PARSE(HTTP_NTP,    "http-ntp");
> +    PARSE(NTP,         "ntp");
> +    PARSE(HTTP_HEAD,   "http-head");
> +    PARSE(DIRECT,      "direct");
> +#undef PARSE
> +    else
> +        dash_log_unknown_scheme(s, &scheme);
> +
> +    if (c->utc_timing == -utc_timing)
> +        c->utc_timing = utc_timing;
> +
> +    dash_sync_time(s, scheme.value);
> +
> +out:
> +    dash_free_scheme(&scheme);
> +    return ret;
> +}
>
> -    for (i = 0; i < pls->n_timelines; i++) {
> -        av_freep(&pls->timelines[i]);
> +static av_cold int dash_parse_role(AVFormatContext *s,
> +                                   DASHParameters *par,
> +                                   xmlNodePtr node)
> +{
> +    int ret = 0;
> +    DASHScheme scheme;
> +
> +    if ((ret = dash_parse_scheme(s, &scheme, 1, node)) < 0)
> +        goto out;
> +
> +    /* https://testassets.dashif.org/#feature/details/588a48c27459f8cb201b881b */
> +    if (!strcmp(scheme.scheme_id, "urn:mpeg:dash:role:2011")) {
> +        if (!strcmp(scheme.value, "main"))
> +            par->disposition |= AV_DISPOSITION_DEFAULT;
> +        else if (!strcmp(scheme.value, "alternate"))
> +            par->disposition &= ~AV_DISPOSITION_DEFAULT;
> +        else if (!strcmp(scheme.value, "original"))
> +            par->disposition |= AV_DISPOSITION_ORIGINAL;
> +        else if (!strcmp(scheme.value, "dub"))
> +            par->disposition |= AV_DISPOSITION_DUB;
> +        else if (!strcmp(scheme.value, "subtitle"))
> +            par->codec_type = AVMEDIA_TYPE_SUBTITLE;
> +    } else {
> +        dash_log_unknown_scheme(s, &scheme);
>      }
> -    av_freep(&pls->timelines);
> -    pls->n_timelines = 0;
> +
> +out:
> +    dash_free_scheme(&scheme);
> +    return ret;
>  }
>
> -static void free_representation(struct representation *pls)
> +static av_cold int dash_parse_property(AVFormatContext *s,
> +                                       DASHAdaptationSet *as,
> +                                       DASHRepresentationPeriod *rep,
> +                                       xmlNodePtr node)
>  {
> -    free_fragment_list(pls);
> -    free_timelines_list(pls);
> -    free_fragment(&pls->cur_seg);
> -    free_fragment(&pls->init_section);
> -    av_freep(&pls->init_sec_buf);
> -    av_freep(&pls->pb.buffer);
> -    ff_format_io_close(pls->parent, &pls->input);
> -    if (pls->ctx) {
> -        pls->ctx->pb = NULL;
> -        avformat_close_input(&pls->ctx);
> +    int ret = 0;
> +    DASHContext *c = s->priv_data;
> +    DASHScheme scheme;
> +
> +    if ((ret = dash_parse_scheme(s, &scheme, 1, node)) < 0)
> +        goto out;
> +
> +    /* https://testassets.dashif.org/#feature/details/588a48c27459f8cb201b881b */
> +    if ((!as && !rep) && !strcmp(scheme.scheme_id, "urn:mpeg:dash:chaining:2016")) {
> +        xml_free(c->chain_next_location);
> +        c->chain_next_location = scheme.value;
> +        scheme.value = NULL;
> +    } else if ((!as && !rep) && !strcmp(scheme.scheme_id, "urn:mpeg:dash:fallback:2016")) {
> +        xml_free(c->fallback_location);
> +        c->fallback_location = scheme.value;
> +        scheme.value = NULL;
> +    } else {
> +        dash_log_unknown_scheme(s, &scheme);
>      }
>
> -    av_freep(&pls->url_template);
> -    av_freep(&pls->lang);
> -    av_freep(&pls->id);
> -    av_freep(&pls);
> +out:
> +    dash_free_scheme(&scheme);
> +    return ret;
>  }
>
> -static void free_video_list(DASHContext *c)
> +static av_cold int dash_check_existing_timeline(AVFormatContext *s, DASHTimeline **out_timeline, xmlNodePtr timeline_node)
>  {
> -    int i;
> -    for (i = 0; i < c->n_videos; i++) {
> -        struct representation *pls = c->videos[i];
> -        free_representation(pls);
> -    }
> -    av_freep(&c->videos);
> -    c->n_videos = 0;
> +    if (!*out_timeline)
> +        return 0;
> +
> +    av_log(s, AV_LOG_ERROR, "Multiple timelines specified\n");
> +    dash_log_unknown_child(s, timeline_node);
> +
> +    return AVERROR_INVALIDDATA;
>  }
>
> -static void free_audio_list(DASHContext *c)
> +static int dash_parse_segmentlist(AVFormatContext *s,
> +                                  DASHPeriod *period,
> +                                  DASHTimeline **out_timeline,
> +                                  xmlNodePtr node)
>  {
> -    int i;
> -    for (i = 0; i < c->n_audios; i++) {
> -        struct representation *pls = c->audios[i];
> -        free_representation(pls);
> +    int nb_segments = 0;
> +    int64_t duration = 0;
> +    int64_t timescale = 1;
> +    DASHTimeline *timeline = NULL;
> +    DASHSegment *g;
> +    int ret = 0;
> +
> +    if ((ret = dash_check_existing_timeline(s, out_timeline, node) < 0))
> +        return ret;
> +
> +    xml_for_each_attr {
> +        if (!strcmp(attr->name, "duration"))
> +            (void)av_sscanf(value, "%"SCNd64, &duration);
> +        else if (!strcmp(attr->name, "timescale"))
> +            (void)av_sscanf(value, "%"SCNd64, &timescale);
> +        else
> +            dash_log_unknown_attr(s, attr, value);
> +    }
> +
> +    xml_for_each_child {
> +        if (!strcmp(child->name, "SegmentURL"))
> +            ++nb_segments;
> +        else
> +            dash_log_unknown_child(s, child);
> +    }
> +
> +    if (!(timeline = av_mallocz(offsetof(DASHTimeline, u.segments.elems[nb_segments])))) {
> +        ret = AVERROR(ENOMEM);
> +        goto out;
> +    }
> +    dash_ref_timeline(timeline);
> +    timeline->type = TIMELINE_SEGMENTS;
> +    timeline->u.segments.nb = nb_segments;
> +    g = &timeline->u.segments.elems[0];
> +
> +    xml_for_each_child {
> +        xmlNodePtr node = child;
> +
> +        if (strcmp(node->name, "SegmentURL"))
> +            continue;
> +
> +        xml_for_each_attr {
> +            if (!strcmp(attr->name, "media")) {
> +                g->url = value;
> +                value = NULL;
> +            } else
> +                dash_log_unknown_attr(s, attr, value);
> +        }
> +        if (!g->url) {
> +            dash_log_missing_attr(s, node, "media");
> +            ret = AVERROR_INVALIDDATA;
> +            goto out;
> +        }
> +
> +        ++g;
>      }
> -    av_freep(&c->audios);
> -    c->n_audios = 0;
> +
> +    *out_timeline = dash_ref_timeline(timeline);
> +
> +out:
> +    dash_unref_timeline(timeline);
> +    return ret;
>  }
>
> -static void free_subtitle_list(DASHContext *c)
> +static av_cold int dash_parse_segmenttimeline(AVFormatContext *s,
> +                                              DASHPeriod *period,
> +                                              uint64_t start_number,
> +                                              DASHTimeline **out_timeline,
> +                                              xmlNodePtr node)
>  {
> -    int i;
> -    for (i = 0; i < c->n_subtitles; i++) {
> -        struct representation *pls = c->subtitles[i];
> -        free_representation(pls);
> +    int ret = 0;
> +    unsigned nb_selems = 0;
> +    DASHSegmentTemplate *g;
> +    DASHTimeline *timeline;
> +    int64_t start_ts = 0;
> +
> +    if ((ret = dash_check_existing_timeline(s, out_timeline, node) < 0))
> +        return ret;
> +
> +    xml_for_each_attr {
> +        dash_log_unknown_attr(s, attr, value);
> +    }
> +
> +    xml_for_each_child {
> +        if (!strcmp(child->name, "S"))
> +            ++nb_selems;
> +        else
> +            dash_log_unknown_child(s, child);
> +    }
> +
> +    if (!(timeline = av_malloc(offsetof(DASHTimeline, u.templates.elems[nb_selems])))) {
> +        ret = AVERROR(ENOMEM);
> +        goto out;
> +    }
> +    memset(timeline, 0, offsetof(DASHTimeline, u.templates.elems[0]));
> +    dash_ref_timeline(timeline);
> +    timeline->type = TIMELINE_TEMPLATES;
> +    timeline->u.templates.nb = nb_selems;
> +    g = &timeline->u.templates.elems[0];
> +
> +    xml_for_each_child {
> +        xmlNodePtr node = child;
> +
> +        if (strcmp(node->name, "S"))
> +            continue;
> +
> +        *g = (DASHSegmentTemplate){
> +            .start_ts = start_ts,
> +            .number = start_number
> +        };
> +
> +        xml_for_each_attr {
> +            int64_t num = 0;
> +
> +            (void)av_sscanf(value, "%"SCNd64, &num);
> +
> +            if (!strcmp(attr->name, "t")) {
> +                /* Muste be increasing. */
> +                if (num < start_ts) {
> +                    dash_log_invalid_attr_value(s, attr, value);
> +                    ret = AVERROR_INVALIDDATA;
> +                    goto out;
> +                }
> +
> +                g->start_ts = num;
> +            } else if (!strcmp(attr->name, "n"))
> +                g->number = num;
> +            else if (!strcmp(attr->name, "r"))
> +                g->repeat = num;
> +            else if (!strcmp(attr->name, "d")) {
> +                g->duration = num;
> +
> +                if (g->duration <= 0) {
> +                    dash_log_invalid_attr_value(s, attr, value);
> +                    ret = AVERROR_INVALIDDATA;
> +                    goto out;
> +                }
> +            } else {
> +                dash_log_unknown_attr(s, attr, value);
> +            }
> +        }
> +
> +        start_number = g->number + (g->repeat + 1);
> +        start_ts = g->start_ts + g->duration * (g->repeat + 1);
> +        ++g;
>      }
> -    av_freep(&c->subtitles);
> -    c->n_subtitles = 0;
> +
> +    *out_timeline = dash_ref_timeline(timeline);
> +
> +out:
> +    dash_unref_timeline(timeline);
> +    return ret;
>  }
>
> -static int open_url(AVFormatContext *s, AVIOContext **pb, const char *url,
> -                    AVDictionary **opts, AVDictionary *opts2, int *is_http)
> +/* One init URL and list of template arguments. */
> +static av_cold int dash_parse_segmenttemplate(AVFormatContext *s,
> +                                              DASHPeriod *period,
> +                                              DASHTimeline **out_timeline,
> +                                              xmlNodePtr node)
>  {
> -    DASHContext *c = s->priv_data;
> -    AVDictionary *tmp = NULL;
> -    const char *proto_name = NULL;
> -    int ret;
> -
> -    if (av_strstart(url, "crypto", NULL)) {
> -        if (url[6] == '+' || url[6] == ':')
> -            proto_name = avio_find_protocol_name(url + 7);
> +    int ret = 0;
> +    DASHTimeline *timeline = NULL;
> +    int64_t duration = -1;
> +    uint64_t start_number = 1;
> +    int64_t presentation_time_offset = 0;
> +    int64_t timescale = 1;
> +    xmlChar *init_url = NULL;
> +    xmlChar *media_url = NULL;
> +
> +    if ((ret = dash_check_existing_timeline(s, out_timeline, node) < 0))
> +        return ret;
> +
> +    xml_for_each_attr {
> +        if (!strcmp(attr->name, "startNumber"))
> +            (void)av_sscanf(value, "%"SCNu64, &start_number);
> +        else if (!strcmp(attr->name, "duration")) {
> +            (void)av_sscanf(value, "%"SCNd64, &duration);
> +            if (duration < 0) {
> +                dash_log_invalid_attr_value(s, attr, value);
> +                ret = AVERROR_INVALIDDATA;
> +            }
> +        } else if (!strcmp(attr->name, "presentationTimeOffset"))
> +            (void)av_sscanf(value, "%"SCNu64, &presentation_time_offset);
> +        else if (!strcmp(attr->name, "timescale")) {
> +            (void)av_sscanf(value, "%"SCNd64, &timescale);
> +            if (timescale <= 0) {
> +                dash_log_invalid_attr_value(s, attr, value);
> +                ret = AVERROR_INVALIDDATA;
> +            }
> +        } else if (!strcmp(attr->name, "initialization")) {
> +            init_url = value;
> +            value = NULL;
> +        } else if (!strcmp(attr->name, "media")) {
> +            media_url = value;
> +            value = NULL;
> +        } else
> +            dash_log_unknown_attr(s, attr, value);
>      }
>
> -    if (!proto_name)
> -        proto_name = avio_find_protocol_name(url);
> +    /* value has to be free()'d */
> +    if (ret < 0)
> +        goto out;
>
> -    if (!proto_name)
> -        return AVERROR_INVALIDDATA;
> +    if (!init_url || !media_url) {
> +        ret = AVERROR_INVALIDDATA;
> +        dash_log_missing_attr(s, node, !init_url ? "initialization" : "media");
> +        goto out;
> +    }
>
> -    // only http(s) & file are allowed
> -    if (av_strstart(proto_name, "file", NULL)) {
> -        if (strcmp(c->allowed_extensions, "ALL") && !av_match_ext(url, c->allowed_extensions)) {
> -            av_log(s, AV_LOG_ERROR,
> -                   "Filename extension of \'%s\' is not a common multimedia extension, blocked for security reasons.\n"
> -                   "If you wish to override this adjust allowed_extensions, you can set it to \'ALL\' to allow all\n",
> -                   url);
> -            return AVERROR_INVALIDDATA;
> +    if (0 <= duration) {
> +        DASHSegmentTemplate *g;
> +
> +        if (!(timeline = av_mallocz(offsetof(DASHTimeline, u.templates.elems[1])))) {
> +            ret = AVERROR(ENOMEM);
> +            goto out;
> +        }
> +        dash_ref_timeline(timeline);
> +        timeline->type = TIMELINE_TEMPLATES;
> +        timeline->u.templates.nb = 1;
> +        g = &timeline->u.templates.elems[0];
> +        g->start_ts = 0;
> +        g->number = start_number;
> +        g->repeat = INT64_MAX;
> +        /* We round down in order to fetch segments more instead before than after. */
> +        g->duration =  duration; /* av_rescale_rnd(duration, AV_TIME_BASE, timescale, AV_ROUND_DOWN); */
> +    } else {
> +        xml_for_each_child {
> +            if (!strcmp(child->name, "SegmentTimeline"))
> +                ret = dash_parse_segmenttimeline(s, period, start_number, &timeline, child);
> +            else
> +                dash_log_unknown_child(s, child);
> +
> +            if (ret < 0)
> +                goto out;
>          }
> -    } else if (av_strstart(proto_name, "http", NULL)) {
> -        ;
> -    } else
> -        return AVERROR_INVALIDDATA;
> -
> -    if (!strncmp(proto_name, url, strlen(proto_name)) && url[strlen(proto_name)] == ':')
> -        ;
> -    else if (av_strstart(url, "crypto", NULL) && !strncmp(proto_name, url + 7, strlen(proto_name)) && url[7 + strlen(proto_name)] == ':')
> -        ;
> -    else if (strcmp(proto_name, "file") || !strncmp(url, "file,", 5))
> -        return AVERROR_INVALIDDATA;
> -
> -    av_freep(pb);
> -    av_dict_copy(&tmp, *opts, 0);
> -    av_dict_copy(&tmp, opts2, 0);
> -    ret = avio_open2(pb, url, AVIO_FLAG_READ, c->interrupt_callback, &tmp);
> -    if (ret >= 0) {
> -        // update cookies on http response with setcookies.
> -        char *new_cookies = NULL;
> -
> -        if (!(s->flags & AVFMT_FLAG_CUSTOM_IO))
> -            av_opt_get(*pb, "cookies", AV_OPT_SEARCH_CHILDREN, (uint8_t**)&new_cookies);
> -
> -        if (new_cookies) {
> -            av_dict_set(opts, "cookies", new_cookies, AV_DICT_DONT_STRDUP_VAL);
> +
> +        /* Either a SegmentTemplate@duration or a SegmentTimeline must be
> +         * given. */
> +        if (!timeline) {
> +            av_log(s, AV_LOG_ERROR, "Missing %s/%s",
> +                   node->name, "SegmentTimeline");
> +            ret = AVERROR_INVALIDDATA;
> +            goto out;
>          }
>
>      }
>
> -    av_dict_free(&tmp);
> +    timeline->duration = INT64_MAX;
> +    timeline->timescale = timescale;
> +    timeline->init.range = DASH_RANGE_INITALIZER;
> +    timeline->init.url = init_url;
> +    init_url = NULL;
> +    timeline->u.templates.master.url = media_url;
> +    media_url = NULL;
>
> -    if (is_http)
> -        *is_http = av_strstart(proto_name, "http", NULL);
> +    timeline->u.templates.master.range = DASH_RANGE_INITALIZER;
>
> +    *out_timeline = dash_ref_timeline(timeline);
> +
> +out:
> +    xml_free(init_url);
> +    xml_free(media_url);
> +    dash_unref_timeline(timeline);
>      return ret;
>  }
>
> -static char *get_content_url(xmlNodePtr *baseurl_nodes,
> -                             int n_baseurl_nodes,
> -                             int max_url_size,
> -                             char *rep_id_val,
> -                             char *rep_bandwidth_val,
> -                             char *val)
> +static DASHRange dash_parse_range(const char *s, AVFormatContext *log_ctx)
>  {
> -    int i;
> -    char *text;
> -    char *url = NULL;
> -    char *tmp_str = av_mallocz(max_url_size);
> +    DASHRange range = {
> +        .start = 0,
> +        .end = INT64_MAX
> +    };
> +    (void)av_sscanf(s, "%"SCNd64"-%"SCNd64, &range.start, &range.end);
> +    return range;
> +}
> +
> +static int dash_parse_segmentbase(AVFormatContext *s,
> +                                  DASHPeriod *period,
> +                                  DASHTimeline **out_timeline,
> +                                  xmlNodePtr node)
> +{
> +    int ret = 0;
> +    DASHSegment *g;
> +    DASHTimeline *timeline;
> +
> +    if ((ret = dash_check_existing_timeline(s, out_timeline, node) < 0))
> +        return ret;
> +
> +    if (!(timeline = av_mallocz(offsetof(DASHTimeline, u.segments.elems[1])))) {
> +        ret = AVERROR(ENOMEM);
> +        goto out;
> +    }
> +    dash_ref_timeline(timeline);
> +    timeline->type = TIMELINE_SEGMENTS;
> +    timeline->duration = INT64_MAX;
> +    timeline->u.segments.nb = 1;
> +    g = &timeline->u.segments.elems[0];
> +
> +    abort();
> +    xml_for_each_child {
> +        if (!strcmp(child->name, "Initalization")) {
> +            xmlNodePtr node = child;
> +            xml_for_each_attr {
> +                if (!strcmp(attr->name, "range"))
> +                    timeline->init.range = dash_parse_range(value, s);
> +                else
> +                    dash_log_unknown_attr(s, attr, value);
> +            }
> +        } else
> +            dash_log_unknown_child(s, child);
> +    }
> +
> +    (void)g;
> +
> +    *out_timeline = dash_ref_timeline(timeline);
> +
> +out:
> +    dash_unref_timeline(timeline);
> +    return 0;
> +}
> +
> +/**
> + * Substitute template arguments in |template| if not NULL and make an URL by
> + * joining it to the absolute |base| part.
> + * @param base Absolute base path.
> + * @param template Absolute or relative path, potentially containing $ template
> + *                 arguments. May be NULL.
> + * @return The allocated URL that shall be av_free()d by the caller.
> + */
> +static char *dash_make_url(const char *base, const char *template,
> +                           /* Template arguments. */
> +                           const char *$RepresentationID$,
> +                           uint64_t $Number$,
> +                           int64_t $Time$,
> +                           uint32_t $Bandwidth$)
> +{
> +    enum { MAX_DIGITS = 20 };
> +
> +    size_t base_size;
> +    size_t $RepresentationID$_size = strlen($RepresentationID$);
> +    size_t max_url_size;
> +    char *url, *u;
> +    URLComponents uc;
> +
> +    ff_url_decompose(&uc, template, NULL);
> +    base_size = URL_COMPONENT_HAVE(uc, scheme) ? 0 : strlen(base);
> +
> +    max_url_size = base_size +
> +                   (template ? strlen(template) : 0) +
> +                   $RepresentationID$_size +
> +                   (MAX_DIGITS * 3) + 1 /* NUL */;
>
> -    if (!tmp_str)
> +    if (!(url = av_malloc(max_url_size)))
>          return NULL;
>
> -    for (i = 0; i < n_baseurl_nodes; ++i) {
> -        if (baseurl_nodes[i] &&
> -            baseurl_nodes[i]->children &&
> -            baseurl_nodes[i]->children->type == XML_TEXT_NODE) {
> -            text = xmlNodeGetContent(baseurl_nodes[i]->children);
> -            if (text) {
> -                memset(tmp_str, 0, max_url_size);
> -                ff_make_absolute_url(tmp_str, max_url_size, "", text);
> -                xmlFree(text);
> +    memcpy(url, base, base_size);
> +    u = url + base_size;
> +
> +    while (template && *template) {
> +        char *t;
> +
> +        if ((t = strchr(template, '$'))) {
> +            size_t len;
> +            unsigned digits;
> +
> +            /* Append everything before $. */
> +            len = t - template;
> +            memcpy(u, template, len);
> +            u += len;
> +            template = t + 1;
> +
> +            /* Get length of template name. */
> +            len = strcspn(template, "$%");
> +
> +            /* Parse formatting. It's easy because we have only one
> +             * possibility. */
> +            digits = 0;
> +            (void)av_sscanf(template + len, "%%0%ud$", &digits);
> +            if (MAX_DIGITS < digits)
> +                digits = MAX_DIGITS;
> +
> +#define IS(name) (len == sizeof(name) - 1 && !memcmp(template, name, sizeof(name) - 1))
> +
> +            /* Substitute template argument. */
> +            if (IS("RepresentationID")) {
> +                memcpy(u, $RepresentationID$, $RepresentationID$_size);
> +                u += $RepresentationID$_size;
> +            } else if (IS("Time")) {
> +                u += sprintf(u, "%0*"PRId64, digits, $Time$);
> +            } else if (IS("Bandwidth")) {
> +                u += sprintf(u, "%0*"PRIu32, digits, $Bandwidth$);
> +            } else if (IS("Number")) {
> +                u += sprintf(u, "%0*"PRIu64, digits, $Number$);
> +            } else if (IS("")) {
> +                *u++ = '$';
>              }
> -        }
> -    }
>
> -    if (val)
> -        ff_make_absolute_url(tmp_str, max_url_size, tmp_str, val);
> +#undef IS
>
> -    if (rep_id_val) {
> -        url = av_strireplace(tmp_str, "$RepresentationID$", rep_id_val);
> -        if (!url) {
> -            goto end;
> +            /* Go over $. */
> +            if ((template = strchr(template + len, '$')))
> +                ++template;
> +        } else {
> +            /* Copy remaining. */
> +            strcpy(u, template);
> +            break;
>          }
> -        av_strlcpy(tmp_str, url, max_url_size);
>      }
> -    if (rep_bandwidth_val && tmp_str[0] != '\0') {
> -        // free any previously assigned url before reassigning
> -        av_free(url);
> -        url = av_strireplace(tmp_str, "$Bandwidth$", rep_bandwidth_val);
> -        if (!url) {
> -            goto end;
> -        }
> -    }
> -end:
> -    av_free(tmp_str);
> +
>      return url;
>  }
>
> -static char *get_val_from_nodes_tab(xmlNodePtr *nodes, const int n_nodes, const char *attrname)
> +static int64_t dash_subdemuxer_seek(void *opaque, int64_t offset, int whence)
>  {
> -    int i;
> -    char *val;
> -
> -    for (i = 0; i < n_nodes; ++i) {
> -        if (nodes[i]) {
> -            val = xmlGetProp(nodes[i], attrname);
> -            if (val)
> -                return val;
> -        }
> -    }
> -
> -    return NULL;
> +    DASHRepresentation *rep = opaque;
> +    return avio_seek(rep->segments[0].pb, offset, whence);
>  }
>
> -static xmlNodePtr find_child_node_by_name(xmlNodePtr rootnode, const char *nodename)
> +static av_cold int dash_copy_stream_props(AVStream *slave, AVStream *master)
>  {
> -    xmlNodePtr node = rootnode;
> -    if (!node) {
> -        return NULL;
> -    }
> +    int ret;
>
> -    node = xmlFirstElementChild(node);
> -    while (node) {
> -        if (!av_strcasecmp(node->name, nodename)) {
> -            return node;
> -        }
> -        node = xmlNextElementSibling(node);
> -    }
> -    return NULL;
> +    master->event_flags &= ~AVSTREAM_EVENT_FLAG_METADATA_UPDATED;
> +    slave->event_flags |= AVSTREAM_EVENT_FLAG_METADATA_UPDATED;
> +
> +    slave->internal->need_context_update = 1;
> +
> +    if ((ret = ff_stream_encode_params_copy(slave, master)) < 0)
> +        return ret;
> +
> +    /* Only for probed context (oc->iformat != NULL). */
> +    if (master->time_base.den)
> +        avpriv_set_pts_info(slave, master->pts_wrap_bits,
> +                            master->time_base.num, master->time_base.den);
> +
> +    return 0;
>  }
>
> -static enum AVMediaType get_content_type(xmlNodePtr node)
> +static av_cold DASHRepresentationPeriod *dash_find_representation_period_at(
> +        DASHRepresentation *rep, int64_t timestamp)
>  {
> -    enum AVMediaType type = AVMEDIA_TYPE_UNKNOWN;
> -    int i = 0;
> -    const char *attr;
> -    char *val = NULL;
> -
> -    if (node) {
> -        for (i = 0; i < 2; i++) {
> -            attr = i ? "mimeType" : "contentType";
> -            val = xmlGetProp(node, attr);
> -            if (val) {
> -                if (av_stristr(val, "video")) {
> -                    type = AVMEDIA_TYPE_VIDEO;
> -                } else if (av_stristr(val, "audio")) {
> -                    type = AVMEDIA_TYPE_AUDIO;
> -                } else if (av_stristr(val, "text")) {
> -                    type = AVMEDIA_TYPE_SUBTITLE;
> -                }
> -                xmlFree(val);
> -            }
> -        }
> +    for (unsigned i = 0; i < rep->nb_periods; ++i) {
> +        DASHRepresentationPeriod *period = rep->periods[i];
> +        if (period->period->start_ts <= timestamp &&
> +                                        timestamp < period->period->end_ts)
> +            return period;
>      }
> -    return type;
> +
> +    return NULL;
>  }
>
> -static struct fragment * get_Fragment(char *range)
> +/**
> + * Update everything to make outside context of representation.
> + *
> + * Must be called after:
> + * - rep->ic->streams changed,
> + * - rep->cur_period changed.
> + */
> +static av_cold int dash_subdemuxer_update(DASHRepresentation *rep)
>  {
> -    struct fragment * seg =  av_mallocz(sizeof(struct fragment));
> -
> -    if (!seg)
> -        return NULL;
> +    int ret;
> +    void *p;
> +    AVFormatContext *oc = rep->oc;
> +    AVFormatContext *ic = rep->ic;
>
> -    seg->size = -1;
> -    if (range) {
> -        char *str_end_offset;
> -        char *str_offset = av_strtok(range, "-", &str_end_offset);
> -        seg->url_offset = strtoll(str_offset, NULL, 10);
> -        seg->size = strtoll(str_end_offset, NULL, 10) - seg->url_offset + 1;
> +    if (rep->nb_streams < ic->nb_streams) {
> +        if (!(p = av_realloc(rep->ostreams, ic->nb_streams * sizeof(*rep->ostreams))))
> +            return AVERROR(ENOMEM);
> +        rep->ostreams = p;
>      }
>
> -    return seg;
> -}
> +    rep->ic->event_flags &= ~AVFMT_EVENT_FLAG_METADATA_UPDATED;
> +    rep->oc->event_flags |= AVFMT_EVENT_FLAG_METADATA_UPDATED;
>
> -static int parse_manifest_segmenturlnode(AVFormatContext *s, struct representation *rep,
> -                                         xmlNodePtr fragmenturl_node,
> -                                         xmlNodePtr *baseurl_nodes,
> -                                         char *rep_id_val,
> -                                         char *rep_bandwidth_val)
> -{
> -    DASHContext *c = s->priv_data;
> -    char *initialization_val = NULL;
> -    char *media_val = NULL;
> -    char *range_val = NULL;
> -    int max_url_size = c ? c->max_url_size: MAX_URL_SIZE;
> -    int err;
> -
> -    if (!av_strcasecmp(fragmenturl_node->name, "Initialization")) {
> -        initialization_val = xmlGetProp(fragmenturl_node, "sourceURL");
> -        range_val = xmlGetProp(fragmenturl_node, "range");
> -        if (initialization_val || range_val) {
> -            free_fragment(&rep->init_section);
> -            rep->init_section = get_Fragment(range_val);
> -            xmlFree(range_val);
> -            if (!rep->init_section) {
> -                xmlFree(initialization_val);
> -                return AVERROR(ENOMEM);
> -            }
> -            rep->init_section->url = get_content_url(baseurl_nodes, 4,
> -                                                     max_url_size,
> -                                                     rep_id_val,
> -                                                     rep_bandwidth_val,
> -                                                     initialization_val);
> -            xmlFree(initialization_val);
> -            if (!rep->init_section->url) {
> -                av_freep(&rep->init_section);
> +    for (unsigned stream_index = 0;
> +         stream_index < ic->nb_streams;
> +         stream_index++)
> +    {
> +        AVStream *ist, *ost;
> +        DASHRepresentationPeriod *period;
> +        AVDictionary *metadata = NULL;
> +
> +        ist = ic->streams[stream_index];
> +
> +        if (stream_index < rep->nb_streams) {
> +            ost = rep->ostreams[stream_index];
> +        } else {
> +            ost = avformat_new_stream(oc, NULL);
> +            if (!ost)
>                  return AVERROR(ENOMEM);
> -            }
> +
> +            rep->ostreams[stream_index] = ost;
>          }
> -    } else if (!av_strcasecmp(fragmenturl_node->name, "SegmentURL")) {
> -        media_val = xmlGetProp(fragmenturl_node, "media");
> -        range_val = xmlGetProp(fragmenturl_node, "mediaRange");
> -        if (media_val || range_val) {
> -            struct fragment *seg = get_Fragment(range_val);
> -            xmlFree(range_val);
> -            if (!seg) {
> -                xmlFree(media_val);
> -                return AVERROR(ENOMEM);
> -            }
> -            seg->url = get_content_url(baseurl_nodes, 4,
> -                                       max_url_size,
> -                                       rep_id_val,
> -                                       rep_bandwidth_val,
> -                                       media_val);
> -            xmlFree(media_val);
> -            if (!seg->url) {
> -                av_free(seg);
> +
> +        av_log(oc, AV_LOG_VERBOSE,
> +               "Match '%s', stream #%u -> DASH stream #%u\n",
> +               rep->id, stream_index, ost->index);
> +
> +        /* Period specific metadata. */
> +        period = rep->cur_period;
> +        /* For inactive representations compute where we would be. */
> +        if (!period)
> +            period = dash_find_representation_period_at(rep, rep->read_ts);
> +        if (period) {
> +            const DASHParameters *par = &period->par;
> +            uint8_t *side_data;
> +            int side_data_size;
> +
> +            side_data = av_encryption_init_info_add_side_data(period->as->init_info, &side_data_size);
> +            if (!side_data)
>                  return AVERROR(ENOMEM);
> +
> +            ret = av_stream_add_side_data(ist, AV_PKT_DATA_ENCRYPTION_INIT_INFO,
> +                                          side_data, side_data_size);
> +            if (ret < 0) {
> +                av_free(side_data);
> +                return ret;
>              }
> -            err = av_dynarray_add_nofree(&rep->fragments, &rep->n_fragments, seg);
> -            if (err < 0) {
> -                free_fragment(&seg);
> -                return err;
> +
> +            av_dict_set_int(&metadata, "variant_bitrate", period->bandwidth, AV_DICT_MULTIKEY);
> +
> +            /* AdaptationSet specific metadata. */
> +            av_dict_copy(&metadata, period->as->metadata, AV_DICT_MULTIKEY);
> +
> +            /* Most parameters are only relevant for elementary streams. */
> +            if (rep->ic->nb_streams == 1) {
> +                AVCodecParameters *codecpar = ist->codecpar;
> +
> +                /* Set unknown parameters for manifest. */
> +
> +                if (codecpar->codec_type == AVMEDIA_TYPE_UNKNOWN)
> +                    codecpar->codec_type = par->codec_type;
> +
> +                if (codecpar->codec_id == AV_CODEC_ID_NONE)
> +                    codecpar->codec_id = par->codec_id;
> +
> +                if (!codecpar->sample_rate)
> +                    codecpar->sample_rate = par->sample_rate;
> +
> +                if (!codecpar->channels && !codecpar->channel_layout)
> +                    codecpar->channels = par->channels,
> +                    codecpar->channel_layout = par->channel_layout;
> +
> +                if (!codecpar->width && !codecpar->height)
> +                    codecpar->width = par->width,
> +                    codecpar->height = par->height;
> +
> +                if (!ist->avg_frame_rate.num)
> +                    ist->avg_frame_rate = par->frame_rate;
> +                if (!ist->r_frame_rate.num)
> +                    ist->r_frame_rate = par->frame_rate;
> +
> +                if (!codecpar->sample_aspect_ratio.num)
> +                    codecpar->sample_aspect_ratio = par->sample_aspect_ratio;
> +
> +                if (codecpar->field_order == AV_FIELD_UNKNOWN)
> +                    codecpar->field_order = par->field_order;
>              }
> +
> +            ist->disposition = par->disposition;
> +        }
> +
> +        /* Representation specific metadata. */
> +        av_dict_set(&metadata, "id", rep->id, AV_DICT_MULTIKEY);
> +
> +        /* RepresentationPeriod (stream) specific metadata. */
> +        if ((ret = dash_copy_stream_props(ost, ist)) < 0) {
> +            av_dict_free(&metadata);
> +            return ret;
>          }
> +
> +        av_dict_copy(&ost->metadata, metadata, AV_DICT_MULTIKEY);
> +        av_dict_free(&metadata);
> +    }
> +
> +    for (unsigned stream_index = ic->nb_streams;
> +         stream_index < rep->nb_streams;
> +         stream_index++)
> +    {
> +        AVStream *ist, *ost;
> +
> +        /* Dummy format with no streams. */
> +        if (!ic->streams)
> +            break;
> +
> +        ist = ic->streams[stream_index];
> +        ost = rep->ostreams[stream_index];
> +
> +        /* Reset codec parameters. */
> +        avcodec_parameters_free(&ist->codecpar);
> +        ist->codecpar = avcodec_parameters_alloc();
> +        if (!ist->codecpar)
> +            return AVERROR(ENOMEM);
> +
> +        if ((ret = dash_copy_stream_props(ost, ist)) < 0)
> +            return ret;
>      }
>
> +    rep->nb_streams = FFMAX(rep->nb_streams, ic->nb_streams);
> +
>      return 0;
>  }
>
> -static int parse_manifest_segmenttimeline(AVFormatContext *s, struct representation *rep,
> -                                          xmlNodePtr fragment_timeline_node)
> +static void dash_rotate_urllist(AVFormatContext *s, DASHURLList *urls)
>  {
> -    xmlAttrPtr attr = NULL;
> -    char *val  = NULL;
> -    int err;
> +    DASHContext *c = s->priv_data;
>
> -    if (!av_strcasecmp(fragment_timeline_node->name, "S")) {
> -        struct timeline *tml = av_mallocz(sizeof(struct timeline));
> -        if (!tml) {
> -            return AVERROR(ENOMEM);
> -        }
> -        attr = fragment_timeline_node->properties;
> -        while (attr) {
> -            val = xmlGetProp(fragment_timeline_node, attr->name);
> +    if (1 < urls->nb) {
> +        unsigned const i = 1 + av_lfg_get(&c->rnd) % (urls->nb - 1);
> +        char *tmp     = urls->elems[i];
> +        urls->elems[i] = urls->elems[0];
> +        urls->elems[0] = tmp;
> +    }
> +}
>
> -            if (!val) {
> -                av_log(s, AV_LOG_WARNING, "parse_manifest_segmenttimeline attr->name = %s val is NULL\n", attr->name);
> +static int dash_subdemuxer_read(void *opaque, uint8_t *buf, int buf_size)
> +{
> +    int ret;
> +    DASHRepresentation *rep = opaque;
> +    AVFormatContext *s = rep->oc;
> +    DASHContext *c = s->priv_data;
> +    int size;
> +    unsigned seg = rep->cur_segment;
> +
> +open_segment:;
> +    do {
> +        DASHRepresentationPeriod *period;
> +        char *url;
> +        const char *base;
> +        const char *template;
> +        uint64_t $Number$;
> +        int64_t $Time$;
> +        DASHRange range;
> +        AVDictionary *opts;
> +#if CONFIG_HTTP_PROTOCOL
> +        URLContext *uc;
> +#endif
> +
> +        if (rep->segments[seg].pb &&
> +            !rep->segments[seg].pb->eof_reached)
> +            continue;
> +
> +        for (unsigned i = 0; i < rep->nb_periods; ++i) {
> +            int64_t period_ts;
> +            DASHTimeline *timeline;
> +
> +            period = rep->periods[i];
> +            timeline = period->timeline;
> +
> +            /* Check if we are inside Period boundaries. */
> +            if (!(period->period->start_ts <= rep->read_ts &&
> +                                              rep->read_ts < period->period->end_ts))
>                  continue;
> -            }
>
> -            if (!av_strcasecmp(attr->name, "t")) {
> -                tml->starttime = (int64_t)strtoll(val, NULL, 10);
> -            } else if (!av_strcasecmp(attr->name, "r")) {
> -                tml->repeat =(int64_t) strtoll(val, NULL, 10);
> -            } else if (!av_strcasecmp(attr->name, "d")) {
> -                tml->duration = (int64_t)strtoll(val, NULL, 10);
> -            }
> -            attr = attr->next;
> -            xmlFree(val);
> -        }
> -        err = av_dynarray_add_nofree(&rep->timelines, &rep->n_timelines, tml);
> -        if (err < 0) {
> -            av_free(tml);
> -            return err;
> -        }
> -    }
> +            /* period_ts := read_ts relative to Period start. */
> +            period_ts = av_rescale_q_rnd(rep->read_ts - period->period->start_ts,
> +                                         AV_TIME_BASE_Q,
> +                                         (AVRational){ 1, timeline->timescale },
> +                                         AV_ROUND_UP);
>
> -    return 0;
> -}
> +            if (timeline->type == TIMELINE_TEMPLATES) {
> +                for (unsigned j = 0; j < timeline->u.templates.nb; ++j) {
> +                    DASHSegmentTemplate *g = &timeline->u.templates.elems[j];
> +                    int64_t end_time = g->repeat < 0 || INT64_MAX / (g->repeat + 1) < g->duration
> +                        ? INT64_MAX
> +                        : g->start_ts + g->duration * (g->repeat + 1);
> +                    end_time = FFMIN(end_time, timeline->duration);
>
> -static int resolve_content_path(AVFormatContext *s, const char *url, int *max_url_size, xmlNodePtr *baseurl_nodes, int n_baseurl_nodes)
> -{
> -    char *tmp_str = NULL;
> -    char *path = NULL;
> -    char *mpdName = NULL;
> -    xmlNodePtr node = NULL;
> -    char *baseurl = NULL;
> -    char *root_url = NULL;
> -    char *text = NULL;
> -    char *tmp = NULL;
> -    int isRootHttp = 0;
> -    char token ='/';
> -    int start =  0;
> -    int rootId = 0;
> -    int updated = 0;
> -    int size = 0;
> -    int i;
> -    int tmp_max_url_size = strlen(url);
> +                    if (period_ts < g->start_ts) {
> +                        /* Gap detected: Missing segments in timeline. */
> +                    }
>
> -    for (i = n_baseurl_nodes-1; i >= 0 ; i--) {
> -        text = xmlNodeGetContent(baseurl_nodes[i]);
> -        if (!text)
> -            continue;
> -        tmp_max_url_size += strlen(text);
> -        if (ishttp(text)) {
> -            xmlFree(text);
> -            break;
> -        }
> -        xmlFree(text);
> -    }
> +                    if (period_ts < end_time) {
> +#if 0
> +                        av_log(rep->oc, AV_LOG_TRACE, "S@[n=%"PRId64" d*r=%"PRId64"*%"PRId64"]: %"PRId64" <= %"PRId64" <= %"PRId64"?\n",
> +                               g->number, g->duration, g->repeat, g->start_ts, period_ts, end_time);
> +#endif
>
> -    tmp_max_url_size = aligned(tmp_max_url_size);
> -    text = av_mallocz(tmp_max_url_size);
> -    if (!text) {
> -        updated = AVERROR(ENOMEM);
> -        goto end;
> -    }
> -    av_strlcpy(text, url, strlen(url)+1);
> -    tmp = text;
> -    while (mpdName = av_strtok(tmp, "/", &tmp))  {
> -        size = strlen(mpdName);
> -    }
> -    av_free(text);
> +                        /* If period changed push init section first. */
> +                        if (rep->cur_period != period) {
> +                            if (seg != rep->cur_segment)
> +                                goto read_segment;
>
> -    path = av_mallocz(tmp_max_url_size);
> -    tmp_str = av_mallocz(tmp_max_url_size);
> -    if (!tmp_str || !path) {
> -        updated = AVERROR(ENOMEM);
> -        goto end;
> -    }
> +                            if (!rep->save_init) {
> +                                rep->save_init = 1;
>
> -    av_strlcpy (path, url, strlen(url) - size + 1);
> -    for (rootId = n_baseurl_nodes - 1; rootId > 0; rootId --) {
> -        if (!(node = baseurl_nodes[rootId])) {
> -            continue;
> -        }
> -        text = xmlNodeGetContent(node);
> -        if (ishttp(text)) {
> -            xmlFree(text);
> -            break;
> -        }
> -        xmlFree(text);
> -    }
> +                                /* Send out stored part. */
> +                                if (0 < period->initbuf_size) {
> +                                    memcpy(buf, period->initbuf, period->initbuf_size);
> +                                    return period->initbuf_size;
> +                                }
> +                            }
>
> -    node = baseurl_nodes[rootId];
> -    baseurl = xmlNodeGetContent(node);
> -    root_url = (av_strcasecmp(baseurl, "")) ? baseurl : path;
> -    if (node) {
> -        xmlNodeSetContent(node, root_url);
> -        updated = 1;
> -    }
> +                            rep->cur_period = period;
> +                            ret = dash_subdemuxer_update(rep);
> +                            if (ret < 0)
> +                                return ret;
>
> -    size = strlen(root_url);
> -    isRootHttp = ishttp(root_url);
> +                            range = timeline->init.range;
> +                            range.start += period->initbuf_size;
>
> -    if (size > 0 && root_url[size - 1] != token) {
> -        av_strlcat(root_url, "/", size + 2);
> -        size += 2;
> -    }
> +                            /* Test whether full segment is stored and thus
> +                             * previously has been sent out. */
> +                            if (0 < period->initbuf_size &&
> +                                (period->initbuf_size < INITBUF_MAX ||
> +                                 range.end <= range.start))
> +                            {
> +                                rep->save_init = 0;
> +                                continue;
> +                            }
>
> -    for (i = 0; i < n_baseurl_nodes; ++i) {
> -        if (i == rootId) {
> -            continue;
> -        }
> -        text = xmlNodeGetContent(baseurl_nodes[i]);
> -        if (text && !av_strstart(text, "/", NULL)) {
> -            memset(tmp_str, 0, strlen(tmp_str));
> -            if (!ishttp(text) && isRootHttp) {
> -                av_strlcpy(tmp_str, root_url, size + 1);
> -            }
> -            start = (text[0] == token);
> -            if (start && av_stristr(tmp_str, text)) {
> -                char *p = tmp_str;
> -                if (!av_strncasecmp(tmp_str, "http://", 7)) {
> -                    p += 7;
> -                } else if (!av_strncasecmp(tmp_str, "https://", 8)) {
> -                    p += 8;
> +                            $Time$ = 0, $Number$ = 0; /* They should not be used in template URL. */
> +                            template = timeline->init.url;
> +                        } else {
> +                            uint64_t r = (period_ts - g->start_ts) / g->duration;
> +                            $Time$ = g->start_ts + g->duration * r;
> +                            $Number$ = g->number + r;
> +                            template = timeline->u.templates.master.url;
> +                            range = timeline->u.templates.master.range;
> +
> +                            rep->read_ts = av_rescale_q_rnd($Time$ + g->duration,
> +                                                            (AVRational){ 1, timeline->timescale },
> +                                                            AV_TIME_BASE_Q,
> +                                                            AV_ROUND_UP);
> +
> +                            /* Wait until segment becomes available. */
> +                            if (c->is_live) {
> +                                int64_t time_shift = rep->read_ts - c->availability_start_time;
> +                                if (time_shift < 0) {
> +                                    /* Allow suspending thread only when it is really neccessary, i.e. we have no other segments to serve. */
> +                                    if (seg == rep->cur_segment)
> +                                        av_usleep(-time_shift);
> +                                    else
> +                                        goto read_segment;
> +                                }
> +                            }
> +                        }
> +                        base = period->base->elems[0];
> +
> +                        goto found;
> +                    }
>                  }
> -                p = strchr(p, '/');
> -                memset(p + 1, 0, strlen(p));
> -            }
> -            av_strlcat(tmp_str, text + start, tmp_max_url_size);
> -            xmlNodeSetContent(baseurl_nodes[i], tmp_str);
> -            updated = 1;
> -            xmlFree(text);
> -        }
> -    }
> -
> -end:
> -    if (tmp_max_url_size > *max_url_size) {
> -        *max_url_size = tmp_max_url_size;
> -    }
> -    av_free(path);
> -    av_free(tmp_str);
> -    xmlFree(baseurl);
> -    return updated;
> -
> -}
> -
> -static int parse_manifest_representation(AVFormatContext *s, const char *url,
> -                                         xmlNodePtr node,
> -                                         xmlNodePtr adaptionset_node,
> -                                         xmlNodePtr mpd_baseurl_node,
> -                                         xmlNodePtr period_baseurl_node,
> -                                         xmlNodePtr period_segmenttemplate_node,
> -                                         xmlNodePtr period_segmentlist_node,
> -                                         xmlNodePtr fragment_template_node,
> -                                         xmlNodePtr content_component_node,
> -                                         xmlNodePtr adaptionset_baseurl_node,
> -                                         xmlNodePtr adaptionset_segmentlist_node,
> -                                         xmlNodePtr adaptionset_supplementalproperty_node)
> -{
> -    int32_t ret = 0;
> -    DASHContext *c = s->priv_data;
> -    struct representation *rep = NULL;
> -    struct fragment *seg = NULL;
> -    xmlNodePtr representation_segmenttemplate_node = NULL;
> -    xmlNodePtr representation_baseurl_node = NULL;
> -    xmlNodePtr representation_segmentlist_node = NULL;
> -    xmlNodePtr segmentlists_tab[3];
> -    xmlNodePtr fragment_timeline_node = NULL;
> -    xmlNodePtr fragment_templates_tab[5];
> -    char *val = NULL;
> -    xmlNodePtr baseurl_nodes[4];
> -    xmlNodePtr representation_node = node;
> -    char *rep_bandwidth_val;
> -    enum AVMediaType type = AVMEDIA_TYPE_UNKNOWN;
> -
> -    // try get information from representation
> -    if (type == AVMEDIA_TYPE_UNKNOWN)
> -        type = get_content_type(representation_node);
> -    // try get information from contentComponen
> -    if (type == AVMEDIA_TYPE_UNKNOWN)
> -        type = get_content_type(content_component_node);
> -    // try get information from adaption set
> -    if (type == AVMEDIA_TYPE_UNKNOWN)
> -        type = get_content_type(adaptionset_node);
> -    if (type != AVMEDIA_TYPE_VIDEO && type != AVMEDIA_TYPE_AUDIO &&
> -        type != AVMEDIA_TYPE_SUBTITLE) {
> -        av_log(s, AV_LOG_VERBOSE, "Parsing '%s' - skipp not supported representation type\n", url);
> -        return 0;
> -    }
> -
> -    // convert selected representation to our internal struct
> -    rep = av_mallocz(sizeof(struct representation));
> -    if (!rep)
> -        return AVERROR(ENOMEM);
> -    if (c->adaptionset_lang) {
> -        rep->lang = av_strdup(c->adaptionset_lang);
> -        if (!rep->lang) {
> -            av_log(s, AV_LOG_ERROR, "alloc language memory failure\n");
> -            av_freep(&rep);
> -            return AVERROR(ENOMEM);
> -        }
> -    }
> -    rep->parent = s;
> -    representation_segmenttemplate_node = find_child_node_by_name(representation_node, "SegmentTemplate");
> -    representation_baseurl_node = find_child_node_by_name(representation_node, "BaseURL");
> -    representation_segmentlist_node = find_child_node_by_name(representation_node, "SegmentList");
> -    rep_bandwidth_val = xmlGetProp(representation_node, "bandwidth");
> -    val               = xmlGetProp(representation_node, "id");
> -    if (val) {
> -        rep->id = av_strdup(val);
> -        xmlFree(val);
> -        if (!rep->id)
> -            goto enomem;
> -    }
> -
> -    baseurl_nodes[0] = mpd_baseurl_node;
> -    baseurl_nodes[1] = period_baseurl_node;
> -    baseurl_nodes[2] = adaptionset_baseurl_node;
> -    baseurl_nodes[3] = representation_baseurl_node;
> -
> -    ret = resolve_content_path(s, url, &c->max_url_size, baseurl_nodes, 4);
> -    c->max_url_size = aligned(c->max_url_size
> -                              + (rep->id ? strlen(rep->id) : 0)
> -                              + (rep_bandwidth_val ? strlen(rep_bandwidth_val) : 0));
> -    if (ret == AVERROR(ENOMEM) || ret == 0)
> -        goto free;
> -    if (representation_segmenttemplate_node || fragment_template_node || period_segmenttemplate_node) {
> -        fragment_timeline_node = NULL;
> -        fragment_templates_tab[0] = representation_segmenttemplate_node;
> -        fragment_templates_tab[1] = adaptionset_segmentlist_node;
> -        fragment_templates_tab[2] = fragment_template_node;
> -        fragment_templates_tab[3] = period_segmenttemplate_node;
> -        fragment_templates_tab[4] = period_segmentlist_node;
> -
> -        val = get_val_from_nodes_tab(fragment_templates_tab, 4, "initialization");
> -        if (val) {
> -            rep->init_section = av_mallocz(sizeof(struct fragment));
> -            if (!rep->init_section) {
> -                xmlFree(val);
> -                goto enomem;
> -            }
> -            c->max_url_size = aligned(c->max_url_size  + strlen(val));
> -            rep->init_section->url = get_content_url(baseurl_nodes, 4,
> -                                                     c->max_url_size, rep->id,
> -                                                     rep_bandwidth_val, val);
> -            xmlFree(val);
> -            if (!rep->init_section->url)
> -                goto enomem;
> -            rep->init_section->size = -1;
> -        }
> -        val = get_val_from_nodes_tab(fragment_templates_tab, 4, "media");
> -        if (val) {
> -            c->max_url_size = aligned(c->max_url_size  + strlen(val));
> -            rep->url_template = get_content_url(baseurl_nodes, 4,
> -                                                c->max_url_size, rep->id,
> -                                                rep_bandwidth_val, val);
> -            xmlFree(val);
> -        }
> -        val = get_val_from_nodes_tab(fragment_templates_tab, 4, "presentationTimeOffset");
> -        if (val) {
> -            rep->presentation_timeoffset = (int64_t) strtoll(val, NULL, 10);
> -            av_log(s, AV_LOG_TRACE, "rep->presentation_timeoffset = [%"PRId64"]\n", rep->presentation_timeoffset);
> -            xmlFree(val);
> -        }
> -        val = get_val_from_nodes_tab(fragment_templates_tab, 4, "duration");
> -        if (val) {
> -            rep->fragment_duration = (int64_t) strtoll(val, NULL, 10);
> -            av_log(s, AV_LOG_TRACE, "rep->fragment_duration = [%"PRId64"]\n", rep->fragment_duration);
> -            xmlFree(val);
> -        }
> -        val = get_val_from_nodes_tab(fragment_templates_tab, 4, "timescale");
> -        if (val) {
> -            rep->fragment_timescale = (int64_t) strtoll(val, NULL, 10);
> -            av_log(s, AV_LOG_TRACE, "rep->fragment_timescale = [%"PRId64"]\n", rep->fragment_timescale);
> -            xmlFree(val);
> -        }
> -        val = get_val_from_nodes_tab(fragment_templates_tab, 4, "startNumber");
> -        if (val) {
> -            rep->start_number = rep->first_seq_no = (int64_t) strtoll(val, NULL, 10);
> -            av_log(s, AV_LOG_TRACE, "rep->first_seq_no = [%"PRId64"]\n", rep->first_seq_no);
> -            xmlFree(val);
> -        }
> -        if (adaptionset_supplementalproperty_node) {
> -            if (!av_strcasecmp(xmlGetProp(adaptionset_supplementalproperty_node,"schemeIdUri"), "http://dashif.org/guidelines/last-segment-number")) {
> -                val = xmlGetProp(adaptionset_supplementalproperty_node,"value");
> -                if (!val) {
> -                    av_log(s, AV_LOG_ERROR, "Missing value attribute in adaptionset_supplementalproperty_node\n");
> +            } else if (timeline->type == TIMELINE_SEGMENTS) {
> +                DASHSegment *g;
> +
> +                if (rep->cur_period != period) {
> +                    if (seg != rep->cur_segment)
> +                        goto read_segment;
> +
> +                    rep->cur_period = period;
> +                    ret = dash_subdemuxer_update(rep);
> +                    if (ret < 0)
> +                        return ret;
> +
> +                    g = &timeline->init;
> +                } else if (0 < timeline->u.segments.nb) {
> +                    int64_t segment_ts = timeline->duration / timeline->u.segments.nb;
> +                    g = &timeline->u.segments.elems[period_ts / segment_ts];
>                  } else {
> -                    rep->last_seq_no =(int64_t) strtoll(val, NULL, 10) - 1;
> -                    xmlFree(val);
> +                    /* One segment timeline. */
> +                    continue;
>                  }
> -            }
> -        }
>
> -        fragment_timeline_node = find_child_node_by_name(representation_segmenttemplate_node, "SegmentTimeline");
> +                base = period->base->elems[0];
> +                template = g->url; /* HACK: URL is not template. */
> +                range = g->range;
>
> -        if (!fragment_timeline_node)
> -            fragment_timeline_node = find_child_node_by_name(fragment_template_node, "SegmentTimeline");
> -        if (!fragment_timeline_node)
> -            fragment_timeline_node = find_child_node_by_name(adaptionset_segmentlist_node, "SegmentTimeline");
> -        if (!fragment_timeline_node)
> -            fragment_timeline_node = find_child_node_by_name(period_segmentlist_node, "SegmentTimeline");
> -        if (fragment_timeline_node) {
> -            fragment_timeline_node = xmlFirstElementChild(fragment_timeline_node);
> -            while (fragment_timeline_node) {
> -                ret = parse_manifest_segmenttimeline(s, rep, fragment_timeline_node);
> -                if (ret < 0)
> -                    goto free;
> -                fragment_timeline_node = xmlNextElementSibling(fragment_timeline_node);
> +                goto found;
> +            } else {
> +                abort();
>              }
> -        }
> -    } else if (representation_baseurl_node && !representation_segmentlist_node) {
> -        seg = av_mallocz(sizeof(struct fragment));
> -        if (!seg)
> -            goto enomem;
> -        ret = av_dynarray_add_nofree(&rep->fragments, &rep->n_fragments, seg);
> -        if (ret < 0) {
> -            av_free(seg);
> -            goto free;
> -        }
> -        seg->url = get_content_url(baseurl_nodes, 4, c->max_url_size,
> -                                   rep->id, rep_bandwidth_val, NULL);
> -        if (!seg->url)
> -            goto enomem;
> -        seg->size = -1;
> -    } else if (representation_segmentlist_node) {
> -        // TODO: https://www.brendanlong.com/the-structure-of-an-mpeg-dash-mpd.html
> -        // http://www-itec.uni-klu.ac.at/dash/ddash/mpdGenerator.php?fragmentlength=15&type=full
> -        xmlNodePtr fragmenturl_node = NULL;
> -        segmentlists_tab[0] = representation_segmentlist_node;
> -        segmentlists_tab[1] = adaptionset_segmentlist_node;
> -        segmentlists_tab[2] = period_segmentlist_node;
>
> -        val = get_val_from_nodes_tab(segmentlists_tab, 3, "duration");
> -        if (val) {
> -            rep->fragment_duration = (int64_t) strtoll(val, NULL, 10);
> -            av_log(s, AV_LOG_TRACE, "rep->fragment_duration = [%"PRId64"]\n", rep->fragment_duration);
> -            xmlFree(val);
> -        }
> -        val = get_val_from_nodes_tab(segmentlists_tab, 3, "timescale");
> -        if (val) {
> -            rep->fragment_timescale = (int64_t) strtoll(val, NULL, 10);
> -            av_log(s, AV_LOG_TRACE, "rep->fragment_timescale = [%"PRId64"]\n", rep->fragment_timescale);
> -            xmlFree(val);
> -        }
> -        val = get_val_from_nodes_tab(segmentlists_tab, 3, "startNumber");
> -        if (val) {
> -            rep->start_number = rep->first_seq_no = (int64_t) strtoll(val, NULL, 10);
> -            av_log(s, AV_LOG_TRACE, "rep->first_seq_no = [%"PRId64"]\n", rep->first_seq_no);
> -            xmlFree(val);
> -        }
> +            /* Gap detected: No more segments till end of the period. Jump to
> +             * the end of the period. */
> +            rep->read_ts = period->period->end_ts;
>
> -        fragmenturl_node = xmlFirstElementChild(representation_segmentlist_node);
> -        while (fragmenturl_node) {
> -            ret = parse_manifest_segmenturlnode(s, rep, fragmenturl_node,
> -                                                baseurl_nodes, rep->id,
> -                                                rep_bandwidth_val);
> -            if (ret < 0)
> -                goto free;
> -            fragmenturl_node = xmlNextElementSibling(fragmenturl_node);
> +            /* Periods may be out-of-order so start searching next one from the beginning. */
> +            i = 0;
>          }
>
> -        fragment_timeline_node = find_child_node_by_name(adaptionset_segmentlist_node, "SegmentTimeline");
> -        if (!fragment_timeline_node)
> -            fragment_timeline_node = find_child_node_by_name(period_segmentlist_node, "SegmentTimeline");
> -        if (fragment_timeline_node) {
> -            fragment_timeline_node = xmlFirstElementChild(fragment_timeline_node);
> -            while (fragment_timeline_node) {
> -                ret = parse_manifest_segmenttimeline(s, rep, fragment_timeline_node);
> -                if (ret < 0)
> -                    goto free;
> -                fragment_timeline_node = xmlNextElementSibling(fragment_timeline_node);
> -            }
> -        }
> -    } else {
> -        av_log(s, AV_LOG_ERROR, "Unknown format of Representation node id '%s' \n",
> -               rep->id ? rep->id : "");
> -        goto free;
> -    }
> +        if (seg == rep->cur_segment)
> +            return AVERROR_EOF;
> +        else
> +            goto read_segment;
>
> -    if (rep->fragment_duration > 0 && !rep->fragment_timescale)
> -        rep->fragment_timescale = 1;
> -    rep->bandwidth = rep_bandwidth_val ? atoi(rep_bandwidth_val) : 0;
> -    rep->framerate = av_make_q(0, 0);
> -    if (type == AVMEDIA_TYPE_VIDEO) {
> -        char *rep_framerate_val = xmlGetProp(representation_node, "frameRate");
> -        if (rep_framerate_val) {
> -            ret = av_parse_video_rate(&rep->framerate, rep_framerate_val);
> -            if (ret < 0)
> -                av_log(s, AV_LOG_VERBOSE, "Ignoring invalid frame rate '%s'\n", rep_framerate_val);
> -            xmlFree(rep_framerate_val);
> +    found:
> +        if (template) {
> +            url = dash_make_url(base, template, rep->id, $Number$, $Time$, period->bandwidth);
> +            if (!url)
> +                return AVERROR(ENOMEM);
> +        } else {
> +            url = (char *)base;
>          }
> -    }
> -
> -    switch (type) {
> -    case AVMEDIA_TYPE_VIDEO:
> -        ret = av_dynarray_add_nofree(&c->videos, &c->n_videos, rep);
> -        break;
> -    case AVMEDIA_TYPE_AUDIO:
> -        ret = av_dynarray_add_nofree(&c->audios, &c->n_audios, rep);
> -        break;
> -    case AVMEDIA_TYPE_SUBTITLE:
> -        ret = av_dynarray_add_nofree(&c->subtitles, &c->n_subtitles, rep);
> -        break;
> -    }
> -    if (ret < 0)
> -        goto free;
> -
> -end:
> -    if (rep_bandwidth_val)
> -        xmlFree(rep_bandwidth_val);
>
> -    return ret;
> -enomem:
> -    ret = AVERROR(ENOMEM);
> -free:
> -    free_representation(rep);
> -    goto end;
> -}
> +        opts = NULL;
>
> -static int parse_manifest_adaptationset_attr(AVFormatContext *s, xmlNodePtr adaptionset_node)
> -{
> -    DASHContext *c = s->priv_data;
> +        if (0 < range.start)
> +            av_dict_set_int(&opts, "offset", range.start, 0);
>
> -    if (!adaptionset_node) {
> -        av_log(s, AV_LOG_WARNING, "Cannot get AdaptionSet\n");
> -        return AVERROR(EINVAL);
> -    }
> -    c->adaptionset_lang = xmlGetProp(adaptionset_node, "lang");
> +        if (range.end < INT64_MAX)
> +            av_dict_set_int(&opts, "end_offset", range.end, 0);
>
> -    return 0;
> -}
> +        av_dict_set(&opts, "multiple_requests", "1", 0);
> +        av_dict_copy(&opts, c->protocol_opts, 0);
>
> -static int parse_manifest_adaptationset(AVFormatContext *s, const char *url,
> -                                        xmlNodePtr adaptionset_node,
> -                                        xmlNodePtr mpd_baseurl_node,
> -                                        xmlNodePtr period_baseurl_node,
> -                                        xmlNodePtr period_segmenttemplate_node,
> -                                        xmlNodePtr period_segmentlist_node)
> -{
> -    int ret = 0;
> -    DASHContext *c = s->priv_data;
> -    xmlNodePtr fragment_template_node = NULL;
> -    xmlNodePtr content_component_node = NULL;
> -    xmlNodePtr adaptionset_baseurl_node = NULL;
> -    xmlNodePtr adaptionset_segmentlist_node = NULL;
> -    xmlNodePtr adaptionset_supplementalproperty_node = NULL;
> -    xmlNodePtr node = NULL;
> -
> -    ret = parse_manifest_adaptationset_attr(s, adaptionset_node);
> -    if (ret < 0)
> -        return ret;
> -
> -    node = xmlFirstElementChild(adaptionset_node);
> -    while (node) {
> -        if (!av_strcasecmp(node->name, "SegmentTemplate")) {
> -            fragment_template_node = node;
> -        } else if (!av_strcasecmp(node->name, "ContentComponent")) {
> -            content_component_node = node;
> -        } else if (!av_strcasecmp(node->name, "BaseURL")) {
> -            adaptionset_baseurl_node = node;
> -        } else if (!av_strcasecmp(node->name, "SegmentList")) {
> -            adaptionset_segmentlist_node = node;
> -        } else if (!av_strcasecmp(node->name, "SupplementalProperty")) {
> -            adaptionset_supplementalproperty_node = node;
> -        } else if (!av_strcasecmp(node->name, "Representation")) {
> -            ret = parse_manifest_representation(s, url, node,
> -                                                adaptionset_node,
> -                                                mpd_baseurl_node,
> -                                                period_baseurl_node,
> -                                                period_segmenttemplate_node,
> -                                                period_segmentlist_node,
> -                                                fragment_template_node,
> -                                                content_component_node,
> -                                                adaptionset_baseurl_node,
> -                                                adaptionset_segmentlist_node,
> -                                                adaptionset_supplementalproperty_node);
> -            if (ret < 0)
> -                goto err;
> +#if CONFIG_HTTP_PROTOCOL
> +        if (!(uc = ffio_geturlcontext(rep->segments[seg].pb)) ||
> +             (rep->segments[seg].pb->eof_reached = 0,
> +              rep->segments[seg].pb->pos = 0,
> +              (ret = ff_http_do_new_request2(uc, url, &opts)) < 0))
> +#endif
> +        {
> +            ff_format_io_close(s, &rep->segments[seg].pb);
> +            ret = s->io_open(s, &rep->segments[seg].pb, url, AVIO_FLAG_READ, &opts);
>          }
> -        node = xmlNextElementSibling(node);
> -    }
> -
> -err:
> -    xmlFree(c->adaptionset_lang);
> -    c->adaptionset_lang = NULL;
> -    return ret;
> -}
> -
> -static int parse_programinformation(AVFormatContext *s, xmlNodePtr node)
> -{
> -    xmlChar *val = NULL;
> -
> -    node = xmlFirstElementChild(node);
> -    while (node) {
> -        if (!av_strcasecmp(node->name, "Title")) {
> -            val = xmlNodeGetContent(node);
> -            if (val) {
> -                av_dict_set(&s->metadata, "Title", val, 0);
> -            }
> -        } else if (!av_strcasecmp(node->name, "Source")) {
> -            val = xmlNodeGetContent(node);
> -            if (val) {
> -                av_dict_set(&s->metadata, "Source", val, 0);
> -            }
> -        } else if (!av_strcasecmp(node->name, "Copyright")) {
> -            val = xmlNodeGetContent(node);
> -            if (val) {
> -                av_dict_set(&s->metadata, "Copyright", val, 0);
> -            }
> -        }
> -        node = xmlNextElementSibling(node);
> -        xmlFree(val);
> -        val = NULL;
> -    }
> -    return 0;
> -}
> -
> -static int parse_manifest(AVFormatContext *s, const char *url, AVIOContext *in)
> -{
> -    DASHContext *c = s->priv_data;
> -    int ret = 0;
> -    int close_in = 0;
> -    int64_t filesize = 0;
> -    AVBPrint buf;
> -    AVDictionary *opts = NULL;
> -    xmlDoc *doc = NULL;
> -    xmlNodePtr root_element = NULL;
> -    xmlNodePtr node = NULL;
> -    xmlNodePtr period_node = NULL;
> -    xmlNodePtr tmp_node = NULL;
> -    xmlNodePtr mpd_baseurl_node = NULL;
> -    xmlNodePtr period_baseurl_node = NULL;
> -    xmlNodePtr period_segmenttemplate_node = NULL;
> -    xmlNodePtr period_segmentlist_node = NULL;
> -    xmlNodePtr adaptionset_node = NULL;
> -    xmlAttrPtr attr = NULL;
> -    char *val  = NULL;
> -    uint32_t period_duration_sec = 0;
> -    uint32_t period_start_sec = 0;
> -
> -    if (!in) {
> -        close_in = 1;
>
> -        av_dict_copy(&opts, c->avio_opts, 0);
> -        ret = avio_open2(&in, url, AVIO_FLAG_READ, c->interrupt_callback, &opts);
> +        if (template)
> +            av_free(url);
>          av_dict_free(&opts);
> -        if (ret < 0)
> -            return ret;
> -    }
>
> -    if (av_opt_get(in, "location", AV_OPT_SEARCH_CHILDREN, (uint8_t**)&c->base_url) < 0)
> -        c->base_url = av_strdup(url);
> -
> -    filesize = avio_size(in);
> -    filesize = filesize > 0 ? filesize : DEFAULT_MANIFEST_SIZE;
> -
> -    if (filesize > MAX_BPRINT_READ_SIZE) {
> -        av_log(s, AV_LOG_ERROR, "Manifest too large: %"PRId64"\n", filesize);
> -        return AVERROR_INVALIDDATA;
> -    }
> -
> -    av_bprint_init(&buf, filesize + 1, AV_BPRINT_SIZE_UNLIMITED);
> -
> -    if ((ret = avio_read_to_bprint(in, &buf, MAX_BPRINT_READ_SIZE)) < 0 ||
> -        !avio_feof(in) ||
> -        (filesize = buf.len) == 0) {
> -        av_log(s, AV_LOG_ERROR, "Unable to read to manifest '%s'\n", url);
> -        if (ret == 0)
> -            ret = AVERROR_INVALIDDATA;
> -    } else {
> -        LIBXML_TEST_VERSION
> -
> -        doc = xmlReadMemory(buf.str, filesize, c->base_url, NULL, 0);
> -        root_element = xmlDocGetRootElement(doc);
> -        node = root_element;
> -
> -        if (!node) {
> -            ret = AVERROR_INVALIDDATA;
> -            av_log(s, AV_LOG_ERROR, "Unable to parse '%s' - missing root node\n", url);
> -            goto cleanup;
> -        }
> -
> -        if (node->type != XML_ELEMENT_NODE ||
> -            av_strcasecmp(node->name, "MPD")) {
> -            ret = AVERROR_INVALIDDATA;
> -            av_log(s, AV_LOG_ERROR, "Unable to parse '%s' - wrong root node name[%s] type[%d]\n", url, node->name, (int)node->type);
> -            goto cleanup;
> -        }
> -
> -        val = xmlGetProp(node, "type");
> -        if (!val) {
> -            av_log(s, AV_LOG_ERROR, "Unable to parse '%s' - missing type attrib\n", url);
> -            ret = AVERROR_INVALIDDATA;
> -            goto cleanup;
> -        }
> -        if (!av_strcasecmp(val, "dynamic"))
> -            c->is_live = 1;
> -        xmlFree(val);
> -
> -        attr = node->properties;
> -        while (attr) {
> -            val = xmlGetProp(node, attr->name);
> -
> -            if (!av_strcasecmp(attr->name, "availabilityStartTime")) {
> -                c->availability_start_time = get_utc_date_time_insec(s, val);
> -                av_log(s, AV_LOG_TRACE, "c->availability_start_time = [%"PRId64"]\n", c->availability_start_time);
> -            } else if (!av_strcasecmp(attr->name, "availabilityEndTime")) {
> -                c->availability_end_time = get_utc_date_time_insec(s, val);
> -                av_log(s, AV_LOG_TRACE, "c->availability_end_time = [%"PRId64"]\n", c->availability_end_time);
> -            } else if (!av_strcasecmp(attr->name, "publishTime")) {
> -                c->publish_time = get_utc_date_time_insec(s, val);
> -                av_log(s, AV_LOG_TRACE, "c->publish_time = [%"PRId64"]\n", c->publish_time);
> -            } else if (!av_strcasecmp(attr->name, "minimumUpdatePeriod")) {
> -                c->minimum_update_period = get_duration_insec(s, val);
> -                av_log(s, AV_LOG_TRACE, "c->minimum_update_period = [%"PRId64"]\n", c->minimum_update_period);
> -            } else if (!av_strcasecmp(attr->name, "timeShiftBufferDepth")) {
> -                c->time_shift_buffer_depth = get_duration_insec(s, val);
> -                av_log(s, AV_LOG_TRACE, "c->time_shift_buffer_depth = [%"PRId64"]\n", c->time_shift_buffer_depth);
> -            } else if (!av_strcasecmp(attr->name, "minBufferTime")) {
> -                c->min_buffer_time = get_duration_insec(s, val);
> -                av_log(s, AV_LOG_TRACE, "c->min_buffer_time = [%"PRId64"]\n", c->min_buffer_time);
> -            } else if (!av_strcasecmp(attr->name, "suggestedPresentationDelay")) {
> -                c->suggested_presentation_delay = get_duration_insec(s, val);
> -                av_log(s, AV_LOG_TRACE, "c->suggested_presentation_delay = [%"PRId64"]\n", c->suggested_presentation_delay);
> -            } else if (!av_strcasecmp(attr->name, "mediaPresentationDuration")) {
> -                c->media_presentation_duration = get_duration_insec(s, val);
> -                av_log(s, AV_LOG_TRACE, "c->media_presentation_duration = [%"PRId64"]\n", c->media_presentation_duration);
> -            }
> -            attr = attr->next;
> -            xmlFree(val);
> -        }
> -
> -        tmp_node = find_child_node_by_name(node, "BaseURL");
> -        if (tmp_node) {
> -            mpd_baseurl_node = xmlCopyNode(tmp_node,1);
> -        } else {
> -            mpd_baseurl_node = xmlNewNode(NULL, "BaseURL");
> -        }
> -
> -        // at now we can handle only one period, with the longest duration
> -        node = xmlFirstElementChild(node);
> -        while (node) {
> -            if (!av_strcasecmp(node->name, "Period")) {
> -                period_duration_sec = 0;
> -                period_start_sec = 0;
> -                attr = node->properties;
> -                while (attr) {
> -                    val = xmlGetProp(node, attr->name);
> -                    if (!av_strcasecmp(attr->name, "duration")) {
> -                        period_duration_sec = get_duration_insec(s, val);
> -                    } else if (!av_strcasecmp(attr->name, "start")) {
> -                        period_start_sec    = get_duration_insec(s, val);
> -                    }
> -                    attr = attr->next;
> -                    xmlFree(val);
> -                }
> -                if ((period_duration_sec) >= (c->period_duration)) {
> -                    period_node = node;
> -                    c->period_duration = period_duration_sec;
> -                    c->period_start = period_start_sec;
> -                    if (c->period_start > 0)
> -                        c->media_presentation_duration = c->period_duration;
> -                }
> -            } else if (!av_strcasecmp(node->name, "ProgramInformation")) {
> -                parse_programinformation(s, node);
> -            }
> -            node = xmlNextElementSibling(node);
> -        }
> -        if (!period_node) {
> -            av_log(s, AV_LOG_ERROR, "Unable to parse '%s' - missing Period node\n", url);
> -            ret = AVERROR_INVALIDDATA;
> -            goto cleanup;
> -        }
> -
> -        adaptionset_node = xmlFirstElementChild(period_node);
> -        while (adaptionset_node) {
> -            if (!av_strcasecmp(adaptionset_node->name, "BaseURL")) {
> -                period_baseurl_node = adaptionset_node;
> -            } else if (!av_strcasecmp(adaptionset_node->name, "SegmentTemplate")) {
> -                period_segmenttemplate_node = adaptionset_node;
> -            } else if (!av_strcasecmp(adaptionset_node->name, "SegmentList")) {
> -                period_segmentlist_node = adaptionset_node;
> -            } else if (!av_strcasecmp(adaptionset_node->name, "AdaptationSet")) {
> -                parse_manifest_adaptationset(s, url, adaptionset_node, mpd_baseurl_node, period_baseurl_node, period_segmenttemplate_node, period_segmentlist_node);
> -            }
> -            adaptionset_node = xmlNextElementSibling(adaptionset_node);
> -        }
> -cleanup:
> -        /*free the document */
> -        xmlFreeDoc(doc);
> -        xmlCleanupParser();
> -        xmlFreeNode(mpd_baseurl_node);
> -    }
> -
> -    av_bprint_finalize(&buf, NULL);
> -    if (close_in) {
> -        avio_close(in);
> -    }
> -    return ret;
> -}
> -
> -static int64_t calc_cur_seg_no(AVFormatContext *s, struct representation *pls)
> -{
> -    DASHContext *c = s->priv_data;
> -    int64_t num = 0;
> -    int64_t start_time_offset = 0;
> -
> -    if (c->is_live) {
> -        if (pls->n_fragments) {
> -            av_log(s, AV_LOG_TRACE, "in n_fragments mode\n");
> -            num = pls->first_seq_no;
> -        } else if (pls->n_timelines) {
> -            av_log(s, AV_LOG_TRACE, "in n_timelines mode\n");
> -            start_time_offset = get_segment_start_time_based_on_timeline(pls, 0xFFFFFFFF) - 60 * pls->fragment_timescale; // 60 seconds before end
> -            num = calc_next_seg_no_from_timelines(pls, start_time_offset);
> -            if (num == -1)
> -                num = pls->first_seq_no;
> -            else
> -                num += pls->first_seq_no;
> -        } else if (pls->fragment_duration){
> -            av_log(s, AV_LOG_TRACE, "in fragment_duration mode fragment_timescale = %"PRId64", presentation_timeoffset = %"PRId64"\n", pls->fragment_timescale, pls->presentation_timeoffset);
> -            if (pls->presentation_timeoffset) {
> -                num = pls->first_seq_no + (((get_current_time_in_sec() - c->availability_start_time) * pls->fragment_timescale)-pls->presentation_timeoffset) / pls->fragment_duration - c->min_buffer_time;
> -            } else if (c->publish_time > 0 && !c->availability_start_time) {
> -                if (c->min_buffer_time) {
> -                    num = pls->first_seq_no + (((c->publish_time + pls->fragment_duration) - c->suggested_presentation_delay) * pls->fragment_timescale) / pls->fragment_duration - c->min_buffer_time;
> -                } else {
> -                    num = pls->first_seq_no + (((c->publish_time - c->time_shift_buffer_depth + pls->fragment_duration) - c->suggested_presentation_delay) * pls->fragment_timescale) / pls->fragment_duration;
> -                }
> -            } else {
> -                num = pls->first_seq_no + (((get_current_time_in_sec() - c->availability_start_time) - c->suggested_presentation_delay) * pls->fragment_timescale) / pls->fragment_duration;
> -            }
> -        }
> -    } else {
> -        num = pls->first_seq_no;
> -    }
> -    return num;
> -}
> -
> -static int64_t calc_min_seg_no(AVFormatContext *s, struct representation *pls)
> -{
> -    DASHContext *c = s->priv_data;
> -    int64_t num = 0;
> -
> -    if (c->is_live && pls->fragment_duration) {
> -        av_log(s, AV_LOG_TRACE, "in live mode\n");
> -        num = pls->first_seq_no + (((get_current_time_in_sec() - c->availability_start_time) - c->time_shift_buffer_depth) * pls->fragment_timescale) / pls->fragment_duration;
> -    } else {
> -        num = pls->first_seq_no;
> -    }
> -    return num;
> -}
> -
> -static int64_t calc_max_seg_no(struct representation *pls, DASHContext *c)
> -{
> -    int64_t num = 0;
> -
> -    if (pls->n_fragments) {
> -        num = pls->first_seq_no + pls->n_fragments - 1;
> -    } else if (pls->n_timelines) {
> -        int i = 0;
> -        num = pls->first_seq_no + pls->n_timelines - 1;
> -        for (i = 0; i < pls->n_timelines; i++) {
> -            if (pls->timelines[i]->repeat == -1) {
> -                int length_of_each_segment = pls->timelines[i]->duration / pls->fragment_timescale;
> -                num =  c->period_duration / length_of_each_segment;
> -            } else {
> -                num += pls->timelines[i]->repeat;
> -            }
> -        }
> -    } else if (c->is_live && pls->fragment_duration) {
> -        num = pls->first_seq_no + (((get_current_time_in_sec() - c->availability_start_time)) * pls->fragment_timescale)  / pls->fragment_duration;
> -    } else if (pls->fragment_duration) {
> -        num = pls->first_seq_no + (c->media_presentation_duration * pls->fragment_timescale) / pls->fragment_duration;
> -    }
> -
> -    return num;
> -}
> -
> -static void move_timelines(struct representation *rep_src, struct representation *rep_dest, DASHContext *c)
> -{
> -    if (rep_dest && rep_src ) {
> -        free_timelines_list(rep_dest);
> -        rep_dest->timelines    = rep_src->timelines;
> -        rep_dest->n_timelines  = rep_src->n_timelines;
> -        rep_dest->first_seq_no = rep_src->first_seq_no;
> -        rep_dest->last_seq_no = calc_max_seg_no(rep_dest, c);
> -        rep_src->timelines = NULL;
> -        rep_src->n_timelines = 0;
> -        rep_dest->cur_seq_no = rep_src->cur_seq_no;
> -    }
> -}
> -
> -static void move_segments(struct representation *rep_src, struct representation *rep_dest, DASHContext *c)
> -{
> -    if (rep_dest && rep_src ) {
> -        free_fragment_list(rep_dest);
> -        if (rep_src->start_number > (rep_dest->start_number + rep_dest->n_fragments))
> -            rep_dest->cur_seq_no = 0;
> -        else
> -            rep_dest->cur_seq_no += rep_src->start_number - rep_dest->start_number;
> -        rep_dest->fragments    = rep_src->fragments;
> -        rep_dest->n_fragments  = rep_src->n_fragments;
> -        rep_dest->parent  = rep_src->parent;
> -        rep_dest->last_seq_no = calc_max_seg_no(rep_dest, c);
> -        rep_src->fragments = NULL;
> -        rep_src->n_fragments = 0;
> -    }
> -}
> -
> -
> -static int refresh_manifest(AVFormatContext *s)
> -{
> -    int ret = 0, i;
> -    DASHContext *c = s->priv_data;
> -    // save current context
> -    int n_videos = c->n_videos;
> -    struct representation **videos = c->videos;
> -    int n_audios = c->n_audios;
> -    struct representation **audios = c->audios;
> -    int n_subtitles = c->n_subtitles;
> -    struct representation **subtitles = c->subtitles;
> -    char *base_url = c->base_url;
> -
> -    c->base_url = NULL;
> -    c->n_videos = 0;
> -    c->videos = NULL;
> -    c->n_audios = 0;
> -    c->audios = NULL;
> -    c->n_subtitles = 0;
> -    c->subtitles = NULL;
> -    ret = parse_manifest(s, s->url, NULL);
> -    if (ret)
> -        goto finish;
> -
> -    if (c->n_videos != n_videos) {
> -        av_log(c, AV_LOG_ERROR,
> -               "new manifest has mismatched no. of video representations, %d -> %d\n",
> -               n_videos, c->n_videos);
> -        return AVERROR_INVALIDDATA;
> -    }
> -    if (c->n_audios != n_audios) {
> -        av_log(c, AV_LOG_ERROR,
> -               "new manifest has mismatched no. of audio representations, %d -> %d\n",
> -               n_audios, c->n_audios);
> -        return AVERROR_INVALIDDATA;
> -    }
> -    if (c->n_subtitles != n_subtitles) {
> -        av_log(c, AV_LOG_ERROR,
> -               "new manifest has mismatched no. of subtitles representations, %d -> %d\n",
> -               n_subtitles, c->n_subtitles);
> -        return AVERROR_INVALIDDATA;
> -    }
> -
> -    for (i = 0; i < n_videos; i++) {
> -        struct representation *cur_video = videos[i];
> -        struct representation *ccur_video = c->videos[i];
> -        if (cur_video->timelines) {
> -            // calc current time
> -            int64_t currentTime = get_segment_start_time_based_on_timeline(cur_video, cur_video->cur_seq_no) / cur_video->fragment_timescale;
> -            // update segments
> -            ccur_video->cur_seq_no = calc_next_seg_no_from_timelines(ccur_video, currentTime * cur_video->fragment_timescale - 1);
> -            if (ccur_video->cur_seq_no >= 0) {
> -                move_timelines(ccur_video, cur_video, c);
> -            }
> -        }
> -        if (cur_video->fragments) {
> -            move_segments(ccur_video, cur_video, c);
> -        }
> -    }
> -    for (i = 0; i < n_audios; i++) {
> -        struct representation *cur_audio = audios[i];
> -        struct representation *ccur_audio = c->audios[i];
> -        if (cur_audio->timelines) {
> -            // calc current time
> -            int64_t currentTime = get_segment_start_time_based_on_timeline(cur_audio, cur_audio->cur_seq_no) / cur_audio->fragment_timescale;
> -            // update segments
> -            ccur_audio->cur_seq_no = calc_next_seg_no_from_timelines(ccur_audio, currentTime * cur_audio->fragment_timescale - 1);
> -            if (ccur_audio->cur_seq_no >= 0) {
> -                move_timelines(ccur_audio, cur_audio, c);
> -            }
> -        }
> -        if (cur_audio->fragments) {
> -            move_segments(ccur_audio, cur_audio, c);
> -        }
> -    }
> -
> -finish:
> -    // restore context
> -    if (c->base_url)
> -        av_free(base_url);
> -    else
> -        c->base_url  = base_url;
> -
> -    if (c->subtitles)
> -        free_subtitle_list(c);
> -    if (c->audios)
> -        free_audio_list(c);
> -    if (c->videos)
> -        free_video_list(c);
> -
> -    c->n_subtitles = n_subtitles;
> -    c->subtitles = subtitles;
> -    c->n_audios = n_audios;
> -    c->audios = audios;
> -    c->n_videos = n_videos;
> -    c->videos = videos;
> -    return ret;
> -}
> -
> -static struct fragment *get_current_fragment(struct representation *pls)
> -{
> -    int64_t min_seq_no = 0;
> -    int64_t max_seq_no = 0;
> -    struct fragment *seg = NULL;
> -    struct fragment *seg_ptr = NULL;
> -    DASHContext *c = pls->parent->priv_data;
> -
> -    while (( !ff_check_interrupt(c->interrupt_callback)&& pls->n_fragments > 0)) {
> -        if (pls->cur_seq_no < pls->n_fragments) {
> -            seg_ptr = pls->fragments[pls->cur_seq_no];
> -            seg = av_mallocz(sizeof(struct fragment));
> -            if (!seg) {
> -                return NULL;
> -            }
> -            seg->url = av_strdup(seg_ptr->url);
> -            if (!seg->url) {
> -                av_free(seg);
> -                return NULL;
> -            }
> -            seg->size = seg_ptr->size;
> -            seg->url_offset = seg_ptr->url_offset;
> -            return seg;
> -        } else if (c->is_live) {
> -            refresh_manifest(pls->parent);
> -        } else {
> -            break;
> -        }
> -    }
> -    if (c->is_live) {
> -        min_seq_no = calc_min_seg_no(pls->parent, pls);
> -        max_seq_no = calc_max_seg_no(pls, c);
> -
> -        if (pls->timelines || pls->fragments) {
> -            refresh_manifest(pls->parent);
> -        }
> -        if (pls->cur_seq_no <= min_seq_no) {
> -            av_log(pls->parent, AV_LOG_VERBOSE, "old fragment: cur[%"PRId64"] min[%"PRId64"] max[%"PRId64"]\n", (int64_t)pls->cur_seq_no, min_seq_no, max_seq_no);
> -            pls->cur_seq_no = calc_cur_seg_no(pls->parent, pls);
> -        } else if (pls->cur_seq_no > max_seq_no) {
> -            av_log(pls->parent, AV_LOG_VERBOSE, "new fragment: min[%"PRId64"] max[%"PRId64"]\n", min_seq_no, max_seq_no);
> -        }
> -        seg = av_mallocz(sizeof(struct fragment));
> -        if (!seg) {
> -            return NULL;
> -        }
> -    } else if (pls->cur_seq_no <= pls->last_seq_no) {
> -        seg = av_mallocz(sizeof(struct fragment));
> -        if (!seg) {
> -            return NULL;
> -        }
> -    }
> -    if (seg) {
> -        char *tmpfilename;
> -        if (!pls->url_template) {
> -            av_log(pls->parent, AV_LOG_ERROR, "Cannot get fragment, missing template URL\n");
> -            av_free(seg);
> -            return NULL;
> -        }
> -        tmpfilename = av_mallocz(c->max_url_size);
> -        if (!tmpfilename) {
> -            av_free(seg);
> -            return NULL;
> -        }
> -        ff_dash_fill_tmpl_params(tmpfilename, c->max_url_size, pls->url_template, 0, pls->cur_seq_no, 0, get_segment_start_time_based_on_timeline(pls, pls->cur_seq_no));
> -        seg->url = av_strireplace(pls->url_template, pls->url_template, tmpfilename);
> -        if (!seg->url) {
> -            av_log(pls->parent, AV_LOG_WARNING, "Unable to resolve template url '%s', try to use origin template\n", pls->url_template);
> -            seg->url = av_strdup(pls->url_template);
> -            if (!seg->url) {
> -                av_log(pls->parent, AV_LOG_ERROR, "Cannot resolve template url '%s'\n", pls->url_template);
> -                av_free(tmpfilename);
> -                av_free(seg);
> -                return NULL;
> -            }
> -        }
> -        av_free(tmpfilename);
> -        seg->size = -1;
> -    }
> -
> -    return seg;
> -}
> -
> -static int read_from_url(struct representation *pls, struct fragment *seg,
> -                         uint8_t *buf, int buf_size)
> -{
> -    int ret;
> -
> -    /* limit read if the fragment was only a part of a file */
> -    if (seg->size >= 0)
> -        buf_size = FFMIN(buf_size, pls->cur_seg_size - pls->cur_seg_offset);
> -
> -    ret = avio_read(pls->input, buf, buf_size);
> -    if (ret > 0)
> -        pls->cur_seg_offset += ret;
> -
> -    return ret;
> -}
> -
> -static int open_input(DASHContext *c, struct representation *pls, struct fragment *seg)
> -{
> -    AVDictionary *opts = NULL;
> -    char *url = NULL;
> -    int ret = 0;
> -
> -    url = av_mallocz(c->max_url_size);
> -    if (!url) {
> -        ret = AVERROR(ENOMEM);
> -        goto cleanup;
> -    }
> -
> -    if (seg->size >= 0) {
> -        /* try to restrict the HTTP request to the part we want
> -         * (if this is in fact a HTTP request) */
> -        av_dict_set_int(&opts, "offset", seg->url_offset, 0);
> -        av_dict_set_int(&opts, "end_offset", seg->url_offset + seg->size, 0);
> -    }
> -
> -    ff_make_absolute_url(url, c->max_url_size, c->base_url, seg->url);
> -    av_log(pls->parent, AV_LOG_VERBOSE, "DASH request for url '%s', offset %"PRId64"\n",
> -           url, seg->url_offset);
> -    ret = open_url(pls->parent, &pls->input, url, &c->avio_opts, opts, NULL);
> -
> -cleanup:
> -    av_free(url);
> -    av_dict_free(&opts);
> -    pls->cur_seg_offset = 0;
> -    pls->cur_seg_size = seg->size;
> -    return ret;
> -}
> -
> -static int update_init_section(struct representation *pls)
> -{
> -    static const int max_init_section_size = 1024 * 1024;
> -    DASHContext *c = pls->parent->priv_data;
> -    int64_t sec_size;
> -    int64_t urlsize;
> -    int ret;
> -
> -    if (!pls->init_section || pls->init_sec_buf)
> -        return 0;
> -
> -    ret = open_input(c, pls, pls->init_section);
> -    if (ret < 0) {
> -        av_log(pls->parent, AV_LOG_WARNING,
> -               "Failed to open an initialization section\n");
> -        return ret;
> -    }
> -
> -    if (pls->init_section->size >= 0)
> -        sec_size = pls->init_section->size;
> -    else if ((urlsize = avio_size(pls->input)) >= 0)
> -        sec_size = urlsize;
> -    else
> -        sec_size = max_init_section_size;
> -
> -    av_log(pls->parent, AV_LOG_DEBUG,
> -           "Downloading an initialization section of size %"PRId64"\n",
> -           sec_size);
> -
> -    sec_size = FFMIN(sec_size, max_init_section_size);
> -
> -    av_fast_malloc(&pls->init_sec_buf, &pls->init_sec_buf_size, sec_size);
> -
> -    ret = read_from_url(pls, pls->init_section, pls->init_sec_buf,
> -                        pls->init_sec_buf_size);
> -    ff_format_io_close(pls->parent, &pls->input);
> -
> -    if (ret < 0)
> -        return ret;
> -
> -    pls->init_sec_data_len = ret;
> -    pls->init_sec_buf_read_offset = 0;
> -
> -    return 0;
> -}
> -
> -static int64_t seek_data(void *opaque, int64_t offset, int whence)
> -{
> -    struct representation *v = opaque;
> -    if (v->n_fragments && !v->init_sec_data_len) {
> -        return avio_seek(v->input, offset, whence);
> -    }
> -
> -    return AVERROR(ENOSYS);
> -}
> -
> -static int read_data(void *opaque, uint8_t *buf, int buf_size)
> -{
> -    int ret = 0;
> -    struct representation *v = opaque;
> -    DASHContext *c = v->parent->priv_data;
> -
> -restart:
> -    if (!v->input) {
> -        free_fragment(&v->cur_seg);
> -        v->cur_seg = get_current_fragment(v);
> -        if (!v->cur_seg) {
> -            ret = AVERROR_EOF;
> -            goto end;
> -        }
> -
> -        /* load/update Media Initialization Section, if any */
> -        ret = update_init_section(v);
> -        if (ret)
> -            goto end;
> -
> -        ret = open_input(c, v, v->cur_seg);
>          if (ret < 0) {
> -            if (ff_check_interrupt(c->interrupt_callback)) {
> -                ret = AVERROR_EXIT;
> -                goto end;
> +        fail_segment:
> +            if (seg == rep->cur_segment) {
> +                /* We know that we have not reached the end. */
> +                if (rep->read_ts < period->period->end_ts) {
> +                    if (0) {
> +                        /* TODO: Implement some failure resistance in case of
> +                         * specific HTTP response codes. */
> +                        goto open_segment;
> +                    } else if (!c->is_live && (ret == AVERROR(ETIMEDOUT) || ret == AVERROR(EIO))) {
> +                        /* Allow dropping some segments only for live streams. */
> +                        goto open_segment;
> +                    }
> +                }
> +
> +                return ret;
> +            } else {
> +                goto read_segment;
>              }
> -            av_log(v->parent, AV_LOG_WARNING, "Failed to open fragment of playlist\n");
> -            v->cur_seq_no++;
> -            goto restart;
>          }
> -    }
>
> -    if (v->init_sec_buf_read_offset < v->init_sec_data_len) {
> -        /* Push init section out first before first actual fragment */
> -        int copy_size = FFMIN(v->init_sec_data_len - v->init_sec_buf_read_offset, buf_size);
> -        memcpy(buf, v->init_sec_buf, copy_size);
> -        v->init_sec_buf_read_offset += copy_size;
> -        ret = copy_size;
> -        goto end;
> -    }
> +        if (0 < range.start &&
> +            avio_seek(s->pb, range.start, SEEK_SET) != range.start)
> +        {
> +            ret = AVERROR(EIO);
> +            goto fail_segment;
> +        }
>
> -    /* check the v->cur_seg, if it is null, get current and double check if the new v->cur_seg*/
> -    if (!v->cur_seg) {
> -        v->cur_seg = get_current_fragment(v);
> -    }
> -    if (!v->cur_seg) {
> -        ret = AVERROR_EOF;
> -        goto end;
> -    }
> -    ret = read_from_url(v, v->cur_seg, buf, buf_size);
> -    if (ret > 0)
> -        goto end;
> +        rep->segments[seg].segment_size = range.end - range.start;
> +    } while (rep->cur_segment != (seg = (seg + 1) % c->nb_connections) &&
> +             /* Use only a single IO context on startup. */
> +             rep->ic->iformat);
> +
> +read_segment:;
> +    /* Only the current segment can be read. */
> +    size = FFMIN(buf_size, (int)FFMIN(rep->segments[rep->cur_segment].segment_size, (uint64_t)INT_MAX));
> +    av_assert1(0 < size);
> +    ret = avio_read_partial(rep->segments[rep->cur_segment].pb, buf, size);
> +    if (0 < ret) {
> +        rep->segments[rep->cur_segment].segment_size -= ret;
> +        if (rep->save_init) {
> +            uint8_t *p;
> +            /* How much bytes can we store? */
> +            int append_size = FFMIN(rep->cur_period->initbuf_size + ret, INITBUF_MAX) -
> +                              rep->cur_period->initbuf_size;
>
> -    if (c->is_live || v->cur_seq_no < v->last_seq_no) {
> -        if (!v->is_restart_needed)
> -            v->cur_seq_no++;
> -        v->is_restart_needed = 1;
> +            if ((p = av_realloc(rep->cur_period->initbuf, rep->cur_period->initbuf_size + append_size))) {
> +                memcpy((rep->cur_period->initbuf = p) + rep->cur_period->initbuf_size, buf, append_size);
> +                rep->cur_period->initbuf_size += append_size;
> +            } else {
> +                /* Do not save anything furthermore otherwise cached init data
> +                 * would may be restored with a missing intermediate chunk. */
> +                rep->save_init = 0;
> +                /* Heck. Reset stored stuff. We can only handle correctly
> +                 * received init buffer. */
> +                rep->cur_period->initbuf_size = 0;
> +            }
> +        }
> +        return ret;
> +    } else if (ret == AVERROR_EOF) {
> +        /* Go to next segment. */
> +        rep->cur_segment = (rep->cur_segment + 1) % c->nb_connections;
> +        rep->save_init = 0;
> +    } else if (ret == AVERROR(ETIMEDOUT)) {
> +        dash_rotate_urllist(s, rep->cur_period->base);
> +    } else if (ret == 0) {
> +        if (s->flags & AVFMT_FLAG_NONBLOCK) {
> +            return AVERROR(EAGAIN);
> +        } else {
> +            av_usleep(150 * MILLISEC_PER_SEC);
> +            goto read_segment;
> +        }
> +    } else {
> +        return ret;
>      }
>
> -end:
> -    return ret;
> +    goto open_segment;
>  }
>
> -static int save_avio_options(AVFormatContext *s)
> +static av_cold int dash_subdemuxer_block_io_open(AVFormatContext *s, AVIOContext **pb, const char *url,
> +                                                 int flags, AVDictionary **opts)
>  {
>      DASHContext *c = s->priv_data;
> -    const char *opts[] = {
> -        "headers", "user_agent", "cookies", "http_proxy", "referer", "rw_timeout", "icy", NULL };
> -    const char **opt = opts;
> -    uint8_t *buf = NULL;
> -    int ret = 0;
> -
> -    while (*opt) {
> -        if (av_opt_get(s->pb, *opt, AV_OPT_SEARCH_CHILDREN, &buf) >= 0) {
> -            if (buf[0] != '\0') {
> -                ret = av_dict_set(&c->avio_opts, *opt, buf, AV_DICT_DONT_STRDUP_VAL);
> -                if (ret < 0)
> -                    return ret;
> -            } else {
> -                av_freep(&buf);
> -            }
> -        }
> -        opt++;
> -    }
> -
> -    return ret;
> -}
> -
> -static int nested_io_open(AVFormatContext *s, AVIOContext **pb, const char *url,
> -                          int flags, AVDictionary **opts)
> -{
>      av_log(s, AV_LOG_ERROR,
> -           "A DASH playlist item '%s' referred to an external file '%s'. "
> -           "Opening this file was forbidden for security reasons\n",
> -           s->url, url);
> +           "Opening external resource '%s' from DASH segment '%s' has been blocked for security reasons",
> +           url, c->location);
> +    av_log(s, AV_LOG_VERBOSE,
> +           "To avoid this security guard open MPD manifest using file: protocol");
>      return AVERROR(EPERM);
>  }
>
> -static void close_demux_for_component(struct representation *pls)
> -{
> -    /* note: the internal buffer could have changed */
> -    av_freep(&pls->pb.buffer);
> -    memset(&pls->pb, 0x00, sizeof(AVIOContext));
> -    pls->ctx->pb = NULL;
> -    avformat_close_input(&pls->ctx);
> -}
> -
> -static int reopen_demux_for_component(AVFormatContext *s, struct representation *pls)
> +static av_cold int dash_subdemuxer_alloc(DASHRepresentation *rep)
>  {
> +    int ret = 0;
> +    AVFormatContext *s = rep->oc;
>      DASHContext *c = s->priv_data;
> -    ff_const59 AVInputFormat *in_fmt = NULL;
> -    AVDictionary  *in_fmt_opts = NULL;
> -    uint8_t *avio_ctx_buffer  = NULL;
> -    int ret = 0, i;
> +    uint8_t *buf;
> +    int buf_size;
>
> -    if (pls->ctx) {
> -        close_demux_for_component(pls);
> -    }
> +    dash_subdemuxer_close(rep);
>
> -    if (ff_check_interrupt(&s->interrupt_callback)) {
> -        ret = AVERROR_EXIT;
> -        goto fail;
> -    }
> +    /* Allocate space that is enough for the theoretically largest segment. */
> +    buf_size = rep->periods[0]->bandwidth * c->max_segment_duration / AV_TIME_BASE;
> +    /* When maximum is not enough. */
> +    buf_size += buf_size / 16 /* +~5% */;
> +    buf_size = FFMIN(FFMAX(buf_size, 4 * 1024), 256 * 1024);
>
> -    if (!(pls->ctx = avformat_alloc_context())) {
> +    if (!(buf = av_malloc(buf_size + AV_INPUT_BUFFER_PADDING_SIZE))) {
>          ret = AVERROR(ENOMEM);
> -        goto fail;
> +        goto out;
>      }
>
> -    avio_ctx_buffer  = av_malloc(INITIAL_BUFFER_SIZE);
> -    if (!avio_ctx_buffer ) {
> -        ret = AVERROR(ENOMEM);
> -        avformat_free_context(pls->ctx);
> -        pls->ctx = NULL;
> -        goto fail;
> -    }
> -    ffio_init_context(&pls->pb, avio_ctx_buffer, INITIAL_BUFFER_SIZE, 0,
> -                      pls, read_data, NULL, c->is_live ? NULL : seek_data);
> -    pls->pb.seekable = 0;
> -
> -    if ((ret = ff_copy_whiteblacklists(pls->ctx, s)) < 0)
> -        goto fail;
> -
> -    pls->ctx->flags = AVFMT_FLAG_CUSTOM_IO;
> -    pls->ctx->probesize = s->probesize > 0 ? s->probesize : 1024 * 4;
> -    pls->ctx->max_analyze_duration = s->max_analyze_duration > 0 ? s->max_analyze_duration : 4 * AV_TIME_BASE;
> -    pls->ctx->interrupt_callback = s->interrupt_callback;
> -    ret = av_probe_input_buffer(&pls->pb, &in_fmt, "", NULL, 0, 0);
> -    if (ret < 0) {
> -        av_log(s, AV_LOG_ERROR, "Error when loading first fragment of playlist\n");
> -        avformat_free_context(pls->ctx);
> -        pls->ctx = NULL;
> -        goto fail;
> +    if ((ret = ffio_init_context(&rep->ic_pb, buf, buf_size, 0, rep,
> +                                 dash_subdemuxer_read, NULL, dash_subdemuxer_seek) < 0))
> +    {
> +        /* Note: We purposely do not free I/O buffer since documentation says
> +         * nothing about it. We presume inputs are freed on error. Just like in
> +         * case av_dict_set() and avformat_alloc_context()... */
> +        goto out;
>      }
> +    rep->ic_pb.seekable = 0;
>
> -    pls->ctx->pb = &pls->pb;
> -    pls->ctx->io_open  = nested_io_open;
> +    /* Padding bytes must be zeroed out. */
> +    memset(buf + buf_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
>
> -    // provide additional information from mpd if available
> -    ret = avformat_open_input(&pls->ctx, "", in_fmt, &in_fmt_opts); //pls->init_section->url
> -    av_dict_free(&in_fmt_opts);
> -    if (ret < 0)
> -        goto fail;
> -    if (pls->n_fragments) {
> -#if FF_API_R_FRAME_RATE
> -        if (pls->framerate.den) {
> -            for (i = 0; i < pls->ctx->nb_streams; i++)
> -                pls->ctx->streams[i]->r_frame_rate = pls->framerate;
> -        }
> -#endif
> -        ret = avformat_find_stream_info(pls->ctx, NULL);
> -        if (ret < 0)
> -            goto fail;
> +    if (!(rep->ic = avformat_alloc_context())) {
> +        ret = AVERROR(ENOMEM);
> +        goto out;
>      }
>
> -fail:
> +    rep->ic->pb = &rep->ic_pb;
> +    rep->ic->interrupt_callback = s->interrupt_callback;
> +
> +    rep->ic->probesize = 0 < s->probesize
> +        ? s->probesize
> +        : 4 * 1024;
> +    rep->ic->max_analyze_duration = 0 < s->max_analyze_duration
> +        ? s->max_analyze_duration
> +        : 4 * AV_TIME_BASE;
> +
> +    /* We supply everything for the demuxer so normall it should not need to
> +     * open anything. Apply this restriction unless we use "file" protocol. */
> +    if (strcmp(avio_find_protocol_name(s->url), "file"))
> +        rep->ic->io_open = dash_subdemuxer_block_io_open;
> +
> +    if ((ret = ff_copy_whiteblacklists(rep->ic, s)) < 0)
> +        goto out;
> +
> +out:
> +    if (ret < 0)
> +        dash_subdemuxer_close(rep);
>      return ret;
>  }
>
> -static int open_demux_for_component(AVFormatContext *s, struct representation *pls)
> +/**
> + * Open the real context.
> + */
> +static av_cold int dash_subdemuxer_open(DASHRepresentation *rep)
>  {
>      int ret = 0;
> -    int i;
> +    AVFormatContext *s = rep->oc;
> +    AVInputFormat *iformat = NULL;
>
> -    pls->parent = s;
> -    pls->cur_seq_no  = calc_cur_seg_no(s, pls);
> +    av_log(s, AV_LOG_DEBUG, "Opening representation '%s'\n", rep->id);
>
> -    if (!pls->last_seq_no) {
> -        pls->last_seq_no = calc_max_seg_no(pls, s->priv_data);
> -    }
> +    if ((ret = dash_subdemuxer_alloc(rep)) < 0)
> +        goto out;
>
> -    ret = reopen_demux_for_component(s, pls);
> -    if (ret < 0) {
> -        goto fail;
> -    }
> -    for (i = 0; i < pls->ctx->nb_streams; i++) {
> -        AVStream *st = avformat_new_stream(s, NULL);
> -        AVStream *ist = pls->ctx->streams[i];
> -        if (!st) {
> -            ret = AVERROR(ENOMEM);
> -            goto fail;
> -        }
> -        st->id = i;
> -        avcodec_parameters_copy(st->codecpar, ist->codecpar);
> -        avpriv_set_pts_info(st, ist->pts_wrap_bits, ist->time_base.num, ist->time_base.den);
> -
> -        // copy disposition
> -        st->disposition = ist->disposition;
> -
> -        // copy side data
> -        for (int i = 0; i < ist->nb_side_data; i++) {
> -            const AVPacketSideData *sd_src = &ist->side_data[i];
> -            uint8_t *dst_data;
> -
> -            dst_data = av_stream_new_side_data(st, sd_src->type, sd_src->size);
> -            if (!dst_data)
> -                return AVERROR(ENOMEM);
> -            memcpy(dst_data, sd_src->data, sd_src->size);
> -        }
> +    if ((ret = av_probe_input_buffer(&rep->ic_pb, &iformat, NULL, NULL, 0, 0)) < 0) {
> +        av_log(s, AV_LOG_ERROR, "Probe failed for representation '%s'\n", rep->id);
> +        goto out;
>      }
>
> -    return 0;
> -fail:
> +    if ((ret = avformat_open_input(&rep->ic, NULL, iformat, NULL)) < 0)
> +        goto out;
> +
> +    /* Finding stream information may need some essential information, like
> +     * encryption init info so stream metadata must be updated before. */
> +    if ((ret = dash_subdemuxer_update(rep)))
> +        goto out;
> +
> +    if ((ret = avformat_find_stream_info(rep->ic, NULL)) < 0)
> +        goto out;
> +
> +    /* Though new streams may have been created we do not care about them now.
> +     * If this is the case or stream information otherwise changed it will get
> +     * updated after reading frames. */
> +
> +out:
> +    if (ret < 0)
> +        dash_subdemuxer_close(rep);
>      return ret;
>  }
>
> -static int is_common_init_section_exist(struct representation **pls, int n_pls)
> +static av_cold int dash_subdemuxer_init(DASHRepresentation *rep)
>  {
> -    struct fragment *first_init_section = pls[0]->init_section;
> -    char *url =NULL;
> -    int64_t url_offset = -1;
> -    int64_t size = -1;
> -    int i = 0;
> -
> -    if (first_init_section == NULL || n_pls == 0)
> -        return 0;
> -
> -    url = first_init_section->url;
> -    url_offset = first_init_section->url_offset;
> -    size = pls[0]->init_section->size;
> -    for (i=0;i<n_pls;i++) {
> -        if (!pls[i]->init_section)
> -            continue;
> -
> -        if (av_strcasecmp(pls[i]->init_section->url, url) ||
> -            pls[i]->init_section->url_offset != url_offset ||
> -            pls[i]->init_section->size != size) {
> -            return 0;
> -        }
> +    int ret;
> +    AVFormatContext *s = rep->oc;
> +    DASHContext *c = s->priv_data;
> +
> +    if (c->is_live)
> +        rep->read_ts = av_gettime() - FFMIN(10, c->time_shift_buffer_depth) * MICROSEC_PER_SEC;
> +    else
> +        rep->read_ts = c->start_ts;
> +
> +    /* Create an inital stream for this representation though we do not what is
> +     * really inside. We expect it to be an elementary stream however it do not
> +     * have to be always true. In such cases the new streams will appear in
> +     * dash_subdemuxer_open(). */
> +    if (!avformat_new_stream(rep->ic, NULL)) {
> +        ret = AVERROR(ENOMEM);
> +        goto out;
>      }
> -    return 1;
> +
> +    if ((ret = dash_subdemuxer_update(rep)) < 0)
> +        goto out;
> +
> +out:
> +    if (ret < 0)
> +        dash_subdemuxer_close(rep);
> +    return ret;
>  }
>
> -static int copy_init_section(struct representation *rep_dest, struct representation *rep_src)
> +static void *av_push_array(void *plist, unsigned elem_size)
>  {
> -    rep_dest->init_sec_buf = av_mallocz(rep_src->init_sec_buf_size);
> -    if (!rep_dest->init_sec_buf) {
> -        av_log(rep_dest->ctx, AV_LOG_WARNING, "Cannot alloc memory for init_sec_buf\n");
> -        return AVERROR(ENOMEM);
> -    }
> -    memcpy(rep_dest->init_sec_buf, rep_src->init_sec_buf, rep_src->init_sec_data_len);
> -    rep_dest->init_sec_buf_size = rep_src->init_sec_buf_size;
> -    rep_dest->init_sec_data_len = rep_src->init_sec_data_len;
> -    rep_dest->cur_timestamp = rep_src->cur_timestamp;
> +    void *p;
> +    unsigned *nmemb = (unsigned *)((void **)plist + 1);
>
> -    return 0;
> -}
> +    if (!(p = av_realloc(*(void **)plist, (*nmemb + 1) * sizeof(void *))))
> +        return NULL;
> +    *(void **)plist = p;
>
> -static int dash_close(AVFormatContext *s);
> +    return ((*(void ***)plist)[(*nmemb)++] = av_mallocz(elem_size));
> +}
>
> -static void move_metadata(AVStream *st, const char *key, char **value)
> +static av_cold void *dash_find_by_id(AVFormatContext *s, void *list, unsigned nmemb, const char *id)
>  {
> -    if (*value) {
> -        av_dict_set(&st->metadata, key, *value, AV_DICT_DONT_STRDUP_VAL);
> -        *value = NULL;
> +    if (!id)
> +        return NULL;
> +
> +    for (unsigned i = 0; i < nmemb; ++i) {
> +        void *elem = ((void **)list)[i];
> +        xmlChar *elem_id = *(xmlChar **)elem;
> +        if (elem_id && !strcmp(elem_id, id))
> +            return elem;
>      }
> +
> +    return NULL;
>  }
>
> -static int dash_read_header(AVFormatContext *s)
> +static av_cold int dash_push_id_node(AVFormatContext *s, void *elem, void *plist, unsigned elem_size, xmlNodePtr node)
>  {
> -    DASHContext *c = s->priv_data;
> -    struct representation *rep;
> -    AVProgram *program;
> -    int ret = 0;
> -    int stream_index = 0;
> -    int i;
> -
> -    c->interrupt_callback = &s->interrupt_callback;
> -
> -    if ((ret = save_avio_options(s)) < 0)
> -        goto fail;
> -
> -    if ((ret = parse_manifest(s, s->url, s->pb)) < 0)
> -        goto fail;
> -
> -    /* If this isn't a live stream, fill the total duration of the
> -     * stream. */
> -    if (!c->is_live) {
> -        s->duration = (int64_t) c->media_presentation_duration * AV_TIME_BASE;
> +    int ret;
> +    xmlChar *id = xmlGetNoNsProp(node, "id");
> +    unsigned *nmemb = (unsigned *)((void **)plist + 1);
> +
> +    if ((*(void **)elem = dash_find_by_id(s, *(void ***)plist, *nmemb, id))) {
> +        ret = 1;
> +    } else if ((*(void **)elem = av_push_array(plist, elem_size))) {
> +        *(xmlChar **)(*(void **)elem) = id;
> +        id = NULL;
> +        ret = 0;
>      } else {
> -        av_dict_set(&c->avio_opts, "seekable", "0", 0);
> +        ret = AVERROR(ENOMEM);
>      }
>
> -    if(c->n_videos)
> -        c->is_init_section_common_video = is_common_init_section_exist(c->videos, c->n_videos);
> +    xml_free(id);
> +    return ret;
> +}
>
> -    /* Open the demuxer for video and audio components if available */
> -    for (i = 0; i < c->n_videos; i++) {
> -        rep = c->videos[i];
> -        if (i > 0 && c->is_init_section_common_video) {
> -            ret = copy_init_section(rep, c->videos[0]);
> -            if (ret < 0)
> -                goto fail;
> -        }
> -        ret = open_demux_for_component(s, rep);
> +static int dash_parse_representation(AVFormatContext *s,
> +                                     DASHPeriod *period,
> +                                     DASHAdaptationSet *as,
> +                                     DASHURLList *base_urls,
> +                                     DASHTimeline *inherited_timeline,
> +                                     const DASHParameters *inherited_par,
> +                                     xmlNodePtr node)
> +{
> +    int ret = 0;
> +    DASHContext *c = s->priv_data;
> +    DASHURLList *urls = dash_ref_urllist(base_urls);
> +    DASHRepresentation *rep;
> +    DASHRepresentationPeriod *rep_period;
> +    DASHTimeline *timeline = NULL;
> +    int64_t availability_time_offset = 0;
> +
> +    if ((ret = dash_push_id_node(s, &rep, &c->reps, offsetof(DASHRepresentation, segments[c->nb_connections]), node)) < 0)
> +        goto out;
> +    else if (!ret) {
> +        rep->oc = s;
> +    }
> +
> +    if (!(rep_period = av_push_array(&rep->periods, sizeof(DASHRepresentationPeriod)))) {
> +        ret = AVERROR(ENOMEM);
> +        goto out;
> +    }
> +
> +    rep_period->period = period;
> +    rep_period->par = *inherited_par;
> +
> +    xml_for_each_attr {
> +        if (!strcmp(attr->name, "availabilityTimeOffset"))
> +            (void)av_sscanf(value, "%"SCNd64, &availability_time_offset);
> +        else if (!strcmp(attr->name, "bandwidth"))
> +            (void)av_sscanf(value, "%"SCNu32, &rep_period->bandwidth);
> +        else if (!dash_parse_parameters(s, &rep_period->par, attr, value))
> +            /* Already done. */;
> +        else if (!strcmp(attr->name, "startWithSAP") && !strcmp(value, "1"))
> +            /* Just check. */;
> +        else if (strcmp(attr->name, "id"))
> +            dash_log_unknown_attr(s, attr, value);
> +    }
> +
> +    xml_for_each_child {
> +        if (!strcmp(child->name, "BaseURL"))
> +            ret = dash_parse_baseurl(s, &urls, child);
> +        else if (!strcmp(child->name, "SegmentTemplate"))
> +            ret = dash_parse_segmenttemplate(s, period, &timeline, child);
> +        else if (!strcmp(child->name, "SegmentList"))
> +            ret = dash_parse_segmentlist(s, period, &timeline, child);
> +        else if (!strcmp(child->name, "SegmentBase"))
> +            ret = dash_parse_segmentbase(s, period, &timeline, child);
> +        else if (!strcmp(child->name, "AudioChannelConfiguration"))
> +            ret = dash_parse_audiochannelconfiguration(s, &rep_period->par, child);
> +        else if (!strcmp(child->name, "UTCTiming"))
> +            ret = dash_parse_utctiming(s, child);
> +        else
> +            dash_log_unknown_child(s, child);
> +
> +        if (ret < 0)
> +            goto out;
> +    }
> +
> +    rep_period->as = as;
> +    if (!timeline && inherited_timeline)
> +        timeline = dash_ref_timeline(inherited_timeline);
> +    /* Default timeline with one big segment. URL is obtained from BaseURLs. */
> +    if (!timeline && (timeline = av_mallocz(sizeof(DASHTimeline)))) {
> +        dash_ref_timeline(timeline);
> +        timeline->type = TIMELINE_SEGMENTS;
> +        timeline->duration = INT64_MAX;
> +        timeline->init.range = DASH_RANGE_INITALIZER;
> +    }
> +    if (!timeline) {
> +        ret = AVERROR(ENOMEM);
> +        goto out;
> +    }
> +    rep_period->base = dash_ref_urllist(urls);
> +    rep_period->timeline = dash_ref_timeline(timeline);
> +
> +    if ((ret = dash_subdemuxer_alloc(rep)) < 0 ||
> +        (ret = dash_subdemuxer_init(rep)) < 0)
> +    {
> +        av_log(s, AV_LOG_DEBUG, "Failed to initalize subdemuxer for representation '%s': %s\n",
> +               rep->id, av_err2str(ret));
> +        goto out;
> +    }
> +
> +out:
> +    dash_unref_timeline(timeline);
> +    dash_unref_urllist(urls);
> +    return ret;
> +}
> +
> +static av_cold int dash_parse_label(AVFormatContext *s,
> +                                    DASHAdaptationSet *as,
> +                                    xmlNodePtr node)
> +{
> +    xmlChar *lang = NULL;
> +    xmlChar *value;
> +
> +    xml_for_each_attr {
> +        if (!strcmp(attr->name, "lang")) {
> +            lang = value;
> +            value = NULL;
> +        } else
> +            dash_log_unknown_attr(s, attr, value);
> +    }
> +
> +    if ((value = xmlNodeGetContent(node)) && *value) {
> +        char key_lang[100];
> +        if (lang)
> +            sprintf(key_lang, "label-%s", lang);
> +        av_dict_set(&s->metadata, lang ? key_lang : "label", value, 0);
> +    }
> +
> +    xml_free(value);
> +    xml_free(lang);
> +    return 0;
> +}
> +
> +static av_cold int dash_parse_adaptationset(AVFormatContext *s,
> +                                            DASHPeriod *period,
> +                                            DASHURLList *base_urls,
> +                                            DASHTimeline *inherited_timeline,
> +                                            const DASHParameters *inherited_par,
> +                                            xmlNodePtr node)
> +{
> +    int ret = 0;
> +    DASHContext *c = s->priv_data;
> +    DASHContentProtection cp = DASH_CONTENTPROTECTION_INITIALIZER;
> +    DASHURLList *urls = dash_ref_urllist(base_urls);
> +    DASHAdaptationSet *as;
> +    DASHTimeline *timeline = NULL;
> +    DASHParameters par = *inherited_par;
> +
> +    if ((ret = dash_push_id_node(s, &as, &c->ass, sizeof(DASHAdaptationSet), node)) < 0)
> +        goto out;
> +
> +    xml_for_each_attr {
> +        if (!strcmp(attr->name, "lang"))
> +            av_dict_set(&as->metadata, "language", value, 0);
> +        else if (!strcmp(attr->name, "selectionPriority"))
> +            av_dict_set(&as->metadata, "priority", value, 0);
> +        else if (!strcmp(attr->name, "group"))
> +            av_dict_set(&as->metadata, "group", value, 0);
> +        else if (!dash_parse_parameters(s, &par, attr, value))
> +            /* Already done. */;
> +        else if (!strcmp(attr->name, "segmentAlignment") && !strcmp(value, "true"))
> +            /* Just check. */;
> +        else if (!strcmp(attr->name, "startWithSAP") && !strcmp(value, "1"))
> +            /* Just check. */;
> +        else if (strcmp(attr->name, "id") &&
> +                 strncmp(attr->name, "max", 3) &&
> +                 strncmp(attr->name, "min", 3))
> +            dash_log_unknown_attr(s, attr, value);
> +    }
> +
> +    xml_for_each_child {
> +        if (!strcmp(child->name, "SegmentTemplate"))
> +            ret = dash_parse_segmenttemplate(s, period, &timeline, child);
> +        else if (!strcmp(child->name, "SegmentList"))
> +            ret = dash_parse_segmentlist(s, period, &timeline, child);
> +        else if (!strcmp(child->name, "SegmentBase"))
> +            ret = dash_parse_segmentbase(s, period, &timeline, child);
> +        else if (!strcmp(child->name, "ContentProtection"))
> +            ret = dash_parse_contentprotection(s, as, &cp, child);
> +        else if (!strcmp(child->name, "BaseURL"))
> +            ret = dash_parse_baseurl(s, &urls, child);
> +        else if (!strcmp(child->name, "Role"))
> +            ret = dash_parse_role(s, &par, child);
> +        else if (!strcmp(child->name, "Viewpoint"))
> +            ret = dash_parse_viewpoint(s, as, child);
> +        else if (!strcmp(child->name, "SupplementalProperty") ||
> +                 !strcmp(child->name, "EssentialProperty"))
> +            ret = dash_parse_property(s, as, NULL, child);
> +        else if (!strcmp(child->name, "Representation"))
> +            ret = dash_parse_representation(s, period, as, urls, (timeline ? timeline : inherited_timeline), &par, child);
> +        else if (!strcmp(child->name, "AudioChannelConfiguration"))
> +            ret = dash_parse_audiochannelconfiguration(s, &par, child);
> +        else if (!strcmp(child->name, "Label"))
> +            ret = dash_parse_label(s, as, child);
> +        else
> +            dash_log_unknown_child(s, child);
> +
> +        if (ret < 0)
> +            goto out;
> +    }
> +
> +out:
> +    dash_unref_timeline(timeline);
> +    dash_unref_urllist(urls);
> +    return ret;
> +}
> +
> +static av_cold int dash_parse_period(AVFormatContext *s,
> +                                     DASHURLList *base_urls,
> +                                     xmlNodePtr node)
> +{
> +    int ret = 0;
> +    DASHContext *c = s->priv_data;
> +    DASHURLList *urls = dash_ref_urllist(base_urls);
> +    DASHTimeline *timeline = NULL;
> +    DASHPeriod *period;
> +    int64_t duration = INT64_MAX;
> +    DASHParameters par = DASH_PARAMETERS_INITIALIZER;
> +
> +    if ((ret = dash_push_id_node(s, &period, &c->periods, sizeof(DASHPeriod), node)) < 0)
> +        goto out;
> +
> +    period->start_ts = 0;
> +
> +    xml_for_each_attr {
> +        if (!strcmp(attr->name, "start"))
> +            period->start_ts = dash_parse_duration(value, s);
> +        else if (!strcmp(attr->name, "duration"))
> +            duration = dash_parse_duration(value, s);
> +        else if (!dash_parse_parameters(s, &par, attr, value))
> +            /* Already done. */;
> +        else if (strcmp(attr->name, "id"))
> +            dash_log_unknown_attr(s, attr, value);
> +    }
> +
> +    period->start_ts += c->availability_start_time;
> +    period->end_ts = period->start_ts < INT64_MAX - duration
> +        ? period->start_ts + duration
> +        : INT64_MAX;
> +    if (c->media_presentation_duration < 0)
> +        s->duration = FFMAX(s->duration != AV_NOPTS_VALUE ? s->duration : 0, period->end_ts);
> +    period->end_ts = FFMIN(period->end_ts, s->duration != AV_NOPTS_VALUE ? s->duration : 0);
> +
> +    /* INT64_MAX means infinity, ergo unknown duration. It has to be stored
> +     * differently for format. */
> +    if (INT64_MAX == s->duration)
> +        s->duration = AV_NOPTS_VALUE;
> +
> +    /* Restrict duration of previous periods. */
> +    for (unsigned i = 0; i < c->nb_periods; ++i) {
> +        DASHPeriod *per = c->periods[i];
> +        if (per->start_ts < period->start_ts)
> +            per->end_ts = FFMIN(per->end_ts, period->start_ts);
> +    }
>
> -        if (ret)
> -            goto fail;
> -        rep->stream_index = stream_index;
> -        ++stream_index;
> +    if (period->end_ts <= period->start_ts) {
> +        av_log(s, AV_LOG_DEBUG, "Ignoring empty Period %"PRId64" >= %"PRId64"\n",
> +               period->start_ts, period->end_ts);
> +        goto out;
>      }
>
> -    if(c->n_audios)
> -        c->is_init_section_common_audio = is_common_init_section_exist(c->audios, c->n_audios);
> +    xml_for_each_child {
> +        if (!strcmp(child->name, "BaseURL"))
> +            ret = dash_parse_baseurl(s, &urls, child);
> +        else if (!strcmp(child->name, "SegmentTemplate"))
> +            ret = dash_parse_segmenttemplate(s, period, &timeline, child);
> +        else if (!strcmp(child->name, "SegmentList"))
> +            ret = dash_parse_segmentlist(s, period, &timeline, child);
> +        else if (!strcmp(child->name, "SegmentBase"))
> +            ret = dash_parse_segmentbase(s, period, &timeline, child);
> +        else if (!strcmp(child->name, "AdaptationSet"))
> +            ret = dash_parse_adaptationset(s, period, urls, timeline, &par, child);
> +        else if (!strcmp(child->name, "AssetIdentifier"))
> +            ret = dash_parse_assetidentifier(s, period, child);
> +        else
> +            dash_log_unknown_child(s, child);
>
> -    for (i = 0; i < c->n_audios; i++) {
> -        rep = c->audios[i];
> -        if (i > 0 && c->is_init_section_common_audio) {
> -            ret = copy_init_section(rep, c->audios[0]);
> -            if (ret < 0)
> -                goto fail;
> +        if (ret < 0)
> +            goto out;
> +    }
> +
> +out:
> +    dash_unref_timeline(timeline);
> +    dash_unref_urllist(urls);
> +    return ret;
> +}
> +
> +static av_cold int dash_parse_programinformation(AVFormatContext *s, xmlNodePtr node)
> +{
> +    xmlChar *lang = NULL;
> +
> +    xml_for_each_attr {
> +        if (!strcmp(attr->name, "lang")) {
> +            lang = value;
> +            value = NULL;
> +        } else
> +            dash_log_unknown_attr(s, attr, value);
> +    }
> +
> +    xml_for_each_child {
> +        const char *key = NULL;
> +        xmlChar *value;
> +
> +        if (!(value = xmlNodeGetContent(child)))
> +            continue;
> +
> +        if (!strcmp(child->name, "Title"))
> +            key = "title";
> +        else if (!strcmp(child->name, "Source"))
> +            key = "source";
> +        else if (!strcmp(child->name, "Copyright"))
> +            key = "copyright";
> +        else
> +            dash_log_unknown_child(s, child);
> +
> +        if (key) {
> +            char key_lang[100];
> +            if (lang)
> +                sprintf(key_lang, "%s-%s", key, lang);
> +            av_dict_set(&s->metadata, lang ? key_lang : key, value, 0);
>          }
> -        ret = open_demux_for_component(s, rep);
>
> -        if (ret)
> -            goto fail;
> -        rep->stream_index = stream_index;
> -        ++stream_index;
> +        xmlFree(value);
>      }
>
> -    if (c->n_subtitles)
> -        c->is_init_section_common_subtitle = is_common_init_section_exist(c->subtitles, c->n_subtitles);
> +    xml_free(lang);
> +    return 0;
> +}
> +
> +static av_cold void dash_reset(AVFormatContext *s)
> +{
> +    DASHContext *c = s->priv_data;
> +
> +    /* Gets updated as we parse Periods. */
> +    s->duration = AV_NOPTS_VALUE;
> +    c->is_live = 0;
> +    c->media_presentation_duration = INT64_MIN;
> +
> +    av_freep_arrayp(&c->reps, dash_free_representation);
> +    av_freep_arrayp(&c->ass, dash_free_adaptationset);
> +    av_freep_arrayp(&c->periods, dash_free_period);
> +
> +    av_freep(&c->location);
> +
> +    xml_freep(&c->id);
> +    xml_freep(&c->chain_next_location);
> +    xml_freep(&c->fallback_location);
> +
> +    av_dict_free(&c->protocol_opts);
> +}
> +
> +static av_cold int dash_parse_mpd(AVFormatContext *s,
> +                                  DASHURLList *base_urls,
> +                                  xmlNodePtr node)
> +{
> +    int ret = 0;
> +    DASHContext *c = s->priv_data;
> +    DASHURLList *urls = dash_ref_urllist(base_urls);
>
> -    for (i = 0; i < c->n_subtitles; i++) {
> -        rep = c->subtitles[i];
> -        if (i > 0 && c->is_init_section_common_subtitle) {
> -            ret = copy_init_section(rep, c->subtitles[0]);
> -            if (ret < 0)
> -                goto fail;
> +    /* Nullify periods.
> +     * TODO: Maybe they sould be cleaned up after parsing. */
> +    for (unsigned i = 0; i < c->nb_periods; ++i) {
> +        DASHPeriod *period = c->periods[i];
> +        period->start_ts = period->end_ts = 0;
> +    }
> +
> +    {
> +        xmlChar *id = xmlGetNoNsProp(node, "id");
> +        if (!c->id || !id || strcmp(c->id, id)) {
> +            dash_reset(s);
> +            c->id = id;
> +        } else {
> +            xmlFree(id);
>          }
> -        ret = open_demux_for_component(s, rep);
> +    }
>
> -        if (ret)
> -            goto fail;
> -        rep->stream_index = stream_index;
> -        ++stream_index;
> +    xml_for_each_attr {
> +        if (!strcmp(attr->name, "type")) {
> +            /* https://livesim.dashif.org/livesim/scte35_2/testpic_2s/Manifest.mpd */
> +            if (!strcmp(value, "dynamic"))
> +                c->is_live = 1;
> +            else if (!strcmp(value, "static"))
> +                c->is_live = 0;
> +            else
> +                dash_log_invalid_attr_value(s, attr, value);
> +        } else if (!strcmp(attr->name, "availabilityStartTime"))
> +            c->availability_start_time = dash_parse_date(value, s);
> +        else if (!strcmp(attr->name, "availabilityEndTime"))
> +            c->availability_end_time  = dash_parse_date(value, s);
> +        else if (!strcmp(attr->name, "publishTime")) {
> +            c->publish_time = dash_parse_date(value, s);
> +            /* Take the easy way. */
> +            av_dict_set(&s->metadata, "creation_time", value, 0);
> +        } else if (!strcmp(attr->name, "minimumUpdatePeriod"))
> +            c->min_update_period = dash_parse_duration(value, s);
> +        else if (!strcmp(attr->name, "maxSegmentDuration"))
> +            c->max_segment_duration = dash_parse_duration(value, s);
> +        else if (!strcmp(attr->name, "minBufferTime"))
> +            c->min_buffer_time = dash_parse_duration(value, s);
> +        else if (!strcmp(attr->name, "timeShiftBufferDepth"))
> +            c->time_shift_buffer_depth = dash_parse_duration(value, s);
> +        else if (!strcmp(attr->name, "mediaPresentationDuration"))
> +            s->duration = c->media_presentation_duration = dash_parse_duration(value, s);
> +        else if (strcmp(attr->name, "id") &&
> +                 strcmp(attr->name, "profiles") &&
> +                 strcmp(attr->name, "schemaLocation"))
> +            dash_log_unknown_attr(s, attr, value);
>      }
>
> -    if (!stream_index) {
> -        ret = AVERROR_INVALIDDATA;
> -        goto fail;
> +    xml_for_each_child {
> +        if (!strcmp(child->name, "ProgramInformation"))
> +            ret = dash_parse_programinformation(s, child);
> +        else if (!strcmp(child->name, "Location"))
> +            ret = dash_parse_location(s, child);
> +        else if (!strcmp(child->name, "BaseURL"))
> +            ret = dash_parse_baseurl(s, &urls, child);
> +        else if (!strcmp(child->name, "Period"))
> +            ret = dash_parse_period(s, urls, child);
> +        else if (!strcmp(child->name, "UTCTiming"))
> +            ret = dash_parse_utctiming(s, child);
> +        else if (!strcmp(child->name, "SupplementalProperty") ||
> +                 !strcmp(child->name, "EssentialProperty"))
> +            ret = dash_parse_property(s, NULL, NULL, child);
> +        else
> +            dash_log_unknown_child(s, child);
> +
> +        if (ret < 0)
> +            goto out;
>      }
>
> -    /* Create a program */
> -    program = av_new_program(s, 0);
> -    if (!program) {
> +out:
> +    dash_unref_urllist(urls);
> +    return ret;
> +}
> +
> +/**
> + * Remove filename component from an URL.
> + */
> +static int ff_make_absolute_head_urla(char **out_url, const char *url)
> +{
> +    int ret;
> +
> +    if (0 <= (ret = ff_make_absolute_urla(out_url, url, "./"))) {
> +        char *p = *out_url;
> +        size_t len = strlen(p);
> +
> +        if (3 <= len && !memcmp(p + len - 3, "/./", 4))
> +            p[len - 2] = '\0';
> +    }
> +
> +    return ret;
> +}
> +
> +static av_cold int dash_parse_root(AVFormatContext *s, xmlNodePtr node)
> +{
> +    int ret = 0;
> +    DASHURLList *urls = NULL;
> +    DASHContext *c = s->priv_data;
> +
> +    if (!node ||
> +        strcmp(node->name, "MPD") ||
> +        !node->ns ||
> +        strcmp(node->ns->href, "urn:mpeg:dash:schema:mpd:2011"))
> +    {
> +        av_log(s, AV_LOG_ERROR, "Not an MPD\n");
> +        return AVERROR_INVALIDDATA;
> +    }
> +
> +    if (!(urls = dash_new_urllist(1))) {
>          ret = AVERROR(ENOMEM);
> -        goto fail;
> -    }
> -
> -    for (i = 0; i < c->n_videos; i++) {
> -        rep = c->videos[i];
> -        av_program_add_stream_index(s, 0, rep->stream_index);
> -        rep->assoc_stream = s->streams[rep->stream_index];
> -        if (rep->bandwidth > 0)
> -            av_dict_set_int(&rep->assoc_stream->metadata, "variant_bitrate", rep->bandwidth, 0);
> -        move_metadata(rep->assoc_stream, "id", &rep->id);
> -    }
> -    for (i = 0; i < c->n_audios; i++) {
> -        rep = c->audios[i];
> -        av_program_add_stream_index(s, 0, rep->stream_index);
> -        rep->assoc_stream = s->streams[rep->stream_index];
> -        if (rep->bandwidth > 0)
> -            av_dict_set_int(&rep->assoc_stream->metadata, "variant_bitrate", rep->bandwidth, 0);
> -        move_metadata(rep->assoc_stream, "id", &rep->id);
> -        move_metadata(rep->assoc_stream, "language", &rep->lang);
> -    }
> -    for (i = 0; i < c->n_subtitles; i++) {
> -        rep = c->subtitles[i];
> -        av_program_add_stream_index(s, 0, rep->stream_index);
> -        rep->assoc_stream = s->streams[rep->stream_index];
> -        move_metadata(rep->assoc_stream, "id", &rep->id);
> -        move_metadata(rep->assoc_stream, "language", &rep->lang);
> +        goto out;
>      }
>
> -    return 0;
> -fail:
> -    dash_close(s);
> +    if ((ret = ff_make_absolute_head_urla(&urls->elems[0], c->location)) < 0)
> +        goto out;
> +
> +    if ((ret = dash_parse_mpd(s, urls, node)) < 0)
> +        goto out;
> +
> +out:
> +    dash_unref_urllist(urls);
>      return ret;
>  }
>
> -static void recheck_discard_flags(AVFormatContext *s, struct representation **p, int n)
> +static av_cold void dash_libxml_error_handler(void *opaque, const char *fmt, ...)
>  {
> -    int i, j;
> -
> -    for (i = 0; i < n; i++) {
> -        struct representation *pls = p[i];
> -        int needed = !pls->assoc_stream || pls->assoc_stream->discard < AVDISCARD_ALL;
> -
> -        if (needed && !pls->ctx) {
> -            pls->cur_seg_offset = 0;
> -            pls->init_sec_buf_read_offset = 0;
> -            /* Catch up */
> -            for (j = 0; j < n; j++) {
> -                pls->cur_seq_no = FFMAX(pls->cur_seq_no, p[j]->cur_seq_no);
> +    AVFormatContext *s = opaque;
> +    va_list ap;
> +
> +    va_start(ap, fmt);
> +    av_vlog(s, AV_LOG_ERROR, fmt, ap);
> +    va_end(ap);
> +}
> +
> +static av_cold int dash_open_manifest(AVFormatContext *s)
> +{
> +    int ret = 0;
> +    DASHContext *c = s->priv_data;
> +    xmlParserCtxtPtr xml;
> +    AVIOContext *pb;
> +    AVDictionary *opts = NULL;
> +    uint8_t *location;
> +
> +    av_dict_set(&opts, "icy", "0", 0);
> +    ret = s->io_open(s, &pb, c->location, AVIO_FLAG_READ, &opts);
> +    av_dict_free(&opts);
> +    if (ret < 0)
> +        return ret;
> +
> +    xmlSetGenericErrorFunc(s, dash_libxml_error_handler);
> +
> +    /* Why not SAX? DASH-IF may standardize patching that obviously requires us
> +     * to maintain DOM. */
> +    for (xml = NULL;;) {
> +        char buf[1 << 14];
> +
> +        /* libXML2 needs at least 4 bytes at the beginnig to being able to
> +         * initialize its parsing context. */
> +        if (0 < (ret = (xml ? avio_read_partial : avio_read)(pb, buf, (xml ? sizeof(buf) : sizeof("BOM"))))) {
> +            /* Context is initialized by the first read call. */
> +            if (!xml) {
> +                if ((xml = xmlCreatePushParserCtxt(NULL, NULL, buf, ret, NULL)))
> +                    continue;
> +            } else {
> +                if (!xmlParseChunk(xml, buf, ret, 0 /* Terminate? */))
> +                    continue;
> +
> +            parse_error:
> +                av_log(s, AV_LOG_ERROR, "Failed to parse manifest file\n");
> +                ret = AVERROR_INVALIDDATA;
> +                goto out;
>              }
> -            reopen_demux_for_component(s, pls);
> -            av_log(s, AV_LOG_INFO, "Now receiving stream_index %d\n", pls->stream_index);
> -        } else if (!needed && pls->ctx) {
> -            close_demux_for_component(pls);
> -            ff_format_io_close(pls->parent, &pls->input);
> -            av_log(s, AV_LOG_INFO, "No longer receiving stream_index %d\n", pls->stream_index);
> +        } else if (ret == AVERROR_EOF) {
> +            if (!xmlParseChunk(xml, NULL, 0, 1 /* Terminate? */))
> +                break;
> +
> +            goto parse_error;
>          }
> +
> +        av_log(s, AV_LOG_ERROR, "Failed to read manifest file\n");
> +        goto out;
>      }
> +
> +    /* For HTTP 3XX redirects standard states that the redirected location
> +     * should be used for updates. We are lazy and just check for "location". */
> +    if (0 <= av_opt_get(pb, "location", AV_OPT_SEARCH_CHILDREN, &location)) {
> +        (void)dash_set_location(s, location);
> +        av_free(location);
> +    }
> +
> +    ret = dash_parse_root(s, xmlDocGetRootElement(xml->myDoc));
> +
> +    if (c->is_live) {
> +        int64_t accuracy = c->min_update_period / 20; /* 5% */
> +        c->next_update = av_gettime() +
> +                         (av_lfg_get(&c->rnd) % accuracy + 1) +
> +                         (c->min_update_period - accuracy);
> +    } else {
> +        c->next_update = 0;
> +    }
> +
> +out:
> +    if (xml) {
> +        if (xml->myDoc)
> +            xmlFreeDoc(xml->myDoc);
> +        xmlFreeParserCtxt(xml);
> +    }
> +
> +    /* Reset handlers so passed references to AVFormatContext will not survive. */
> +    xmlSetGenericErrorFunc(NULL, NULL);
> +
> +    ff_format_io_close(s, &pb);
> +    return ret;
> +}
> +
> +static av_cold int dash_close(AVFormatContext *s)
> +{
> +    return dash_reset(s), 0;
> +}
> +
> +static av_cold int dash_save_protocol_options(AVFormatContext *s)
> +{
> +    static const char OPTIONS[] =
> +        "headers\0" "http_proxy\0" "user_agent\0" "cookies\0" "referer\0"
> +        "rw_timeout\0" "icy\0";
> +
> +    DASHContext *c = s->priv_data;
> +
> +    for (const char *opt = OPTIONS; *opt; opt += strlen(opt) + 1 /* NUL */) {
> +        uint8_t *buf;
> +
> +        if (0 <= av_opt_get(s->pb, opt, AV_OPT_SEARCH_CHILDREN, &buf)) {
> +            int ret = av_dict_set(&c->protocol_opts, opt, buf,
> +                                  AV_DICT_DONT_OVERWRITE | AV_DICT_DONT_STRDUP_VAL);
> +            if (ret < 0)
> +                return ret;
> +        }
> +    }
> +
> +    return 0;
> +}
> +
> +static av_cold int dash_read_header(AVFormatContext *s)
> +{
> +    int ret = 0;
> +    DASHContext *c = s->priv_data;
> +
> +    if ((ret = dash_set_location(s, s->url)) < 0)
> +        goto out;
> +
> +    /* Signal that we may create additional streams as time pasts. */
> +    s->ctx_flags |= AVFMTCTX_NOHEADER;
> +
> +    if ((ret = dash_save_protocol_options(s)) < 0)
> +        goto out;
> +
> +    av_lfg_init(&c->rnd, av_get_random_seed());
> +
> +    if ((ret = dash_open_manifest(s)) < 0)
> +        goto out;
> +
> +out:
> +    if (ret < 0)
> +        dash_close(s);
> +    return ret;
> +}
> +
> +static DASHRepresentation *dash_get_read_next_representation(AVFormatContext *s)
> +{
> +    DASHContext *c = s->priv_data;
> +    DASHRepresentation *best_rep = NULL;
> +
> +    for (unsigned i = 0; i < c->nb_reps; ++i) {
> +        DASHRepresentation *rep = c->reps[i];
> +        int needed = 0;
> +
> +        /* Subdemuxer not opened for this representation, so we are not
> +         * interested in receiving segments for this. */
> +        if (!rep->ic)
> +            continue;
> +
> +        /* Check if any of the streams is needed. */
> +        for (unsigned k = 0; k < rep->nb_streams; ++k) {
> +            AVStream *ost = rep->ostreams[k];
> +            if ((needed = ost->discard < AVDISCARD_ALL))
> +                break;
> +        }
> +
> +        if (!needed)
> +            continue;
> +
> +        /* A toy scheduler. */
> +        if (!best_rep || rep->last_pts < best_rep->last_pts)
> +            best_rep = rep;
> +    }
> +
> +    return best_rep;
>  }
>
>  static int dash_read_packet(AVFormatContext *s, AVPacket *pkt)
>  {
> +    int ret;
> +    DASHRepresentation *rep;
> +    AVStream *ist, /* --packet--> */ *ost;
>      DASHContext *c = s->priv_data;
> -    int ret = 0, i;
> -    int64_t mints = 0;
> -    struct representation *cur = NULL;
> -    struct representation *rep = NULL;
>
> -    recheck_discard_flags(s, c->videos, c->n_videos);
> -    recheck_discard_flags(s, c->audios, c->n_audios);
> -    recheck_discard_flags(s, c->subtitles, c->n_subtitles);
> -
> -    for (i = 0; i < c->n_videos; i++) {
> -        rep = c->videos[i];
> -        if (!rep->ctx)
> -            continue;
> -        if (!cur || rep->cur_timestamp < mints) {
> -            cur = rep;
> -            mints = rep->cur_timestamp;
> +    if (c->next_update && c->next_update <= av_gettime())
> +        if ((ret = dash_open_manifest(s)) < 0) {
> +            c->next_update = av_gettime() * (60 * MICROSEC_PER_SEC) /* 1 min */;
> +            av_log(s, AV_LOG_ERROR, "Failed to update manifest\n");
>          }
> -    }
> -    for (i = 0; i < c->n_audios; i++) {
> -        rep = c->audios[i];
> -        if (!rep->ctx)
> -            continue;
> -        if (!cur || rep->cur_timestamp < mints) {
> -            cur = rep;
> -            mints = rep->cur_timestamp;
> +
> +    /* Find a representation where we can read from. */
> +    for (;;) {
> +        if (!(rep = dash_get_read_next_representation(s))) {
> +            /* Load next manifest, if any. */
> +            if (c->chain_next_location) {
> +                if ((ret = dash_set_location(s, c->chain_next_location)) < 0)
> +                    return ret;
> +                xml_freep(&c->chain_next_location);
> +
> +                if ((ret = dash_open_manifest(s)) < 0)
> +                    return ret;
> +
> +                continue;
> +            }
> +
> +            return AVERROR_EOF;
>          }
> -    }
>
> -    for (i = 0; i < c->n_subtitles; i++) {
> -        rep = c->subtitles[i];
> -        if (!rep->ctx)
> +        if ((!rep->ic->iformat &&
> +             (ret = dash_subdemuxer_open(rep)) < 0) ||
> +            (ret = av_read_frame(rep->ic, pkt)) < 0)
> +        {
> +            av_log(s, AVERROR_EOF != ret ? AV_LOG_ERROR : AV_LOG_DEBUG,
> +                   "Failed to read representation '%s': %s\n",
> +                   rep->id, av_err2str(ret));
> +            dash_subdemuxer_close(rep);
>              continue;
> -        if (!cur || rep->cur_timestamp < mints) {
> -            cur = rep;
> -            mints = rep->cur_timestamp;
>          }
> -    }
>
> -    if (!cur) {
> -        return AVERROR_INVALIDDATA;
> +        break;
>      }
> -    while (!ff_check_interrupt(c->interrupt_callback) && !ret) {
> -        ret = av_read_frame(cur->ctx, pkt);
> -        if (ret >= 0) {
> -            /* If we got a packet, return it */
> -            cur->cur_timestamp = av_rescale(pkt->pts, (int64_t)cur->ctx->streams[0]->time_base.num * 90000, cur->ctx->streams[0]->time_base.den);
> -            pkt->stream_index = cur->stream_index;
> -            return 0;
> -        }
> -        if (cur->is_restart_needed) {
> -            cur->cur_seg_offset = 0;
> -            cur->init_sec_buf_read_offset = 0;
> -            ff_format_io_close(cur->parent, &cur->input);
> -            ret = reopen_demux_for_component(s, cur);
> -            cur->is_restart_needed = 0;
> -        }
> -    }
> -    return AVERROR_EOF;
> -}
>
> -static int dash_close(AVFormatContext *s)
> -{
> -    DASHContext *c = s->priv_data;
> -    free_audio_list(c);
> -    free_video_list(c);
> -    free_subtitle_list(c);
> -    av_dict_free(&c->avio_opts);
> -    av_freep(&c->base_url);
> +    ist = rep->ic->streams[pkt->stream_index];
> +
> +    if (/* New stream had been created by the underlying subdemuxer. */
> +        rep->nb_streams <= pkt->stream_index ||
> +        /* Something changed. */
> +        (ist->event_flags & AVSTREAM_EVENT_FLAG_METADATA_UPDATED))
> +        if ((ret = dash_subdemuxer_update(rep)) < 0)
> +            return ret;
> +
> +    /* Make packet timestamps comparable to each other. */
> +    rep->last_pts = av_rescale_q(pkt->pts + pkt->duration, ist->time_base, AV_TIME_BASE_Q);
> +
> +    ost = rep->ostreams[pkt->stream_index];
> +    if (ost->codecpar->codec_type != ist->codecpar->codec_type ||
> +        ost->codecpar->codec_id   != ist->codecpar->codec_id   ||
> +        ost->codecpar->codec_tag  != ist->codecpar->codec_tag)
> +        if ((ret = dash_subdemuxer_update(rep)) < 0)
> +            return ret;
> +
> +    /* Translate stream_index from inner to outer context. */
> +    pkt->stream_index = ost->index;
> +
>      return 0;
>  }
>
> -static int dash_seek(AVFormatContext *s, struct representation *pls, int64_t seek_pos_msec, int flags, int dry_run)
> -{
> -    int ret = 0;
> -    int i = 0;
> -    int j = 0;
> -    int64_t duration = 0;
> -
> -    av_log(pls->parent, AV_LOG_VERBOSE, "DASH seek pos[%"PRId64"ms] %s\n",
> -           seek_pos_msec, dry_run ? " (dry)" : "");
> -
> -    // single fragment mode
> -    if (pls->n_fragments == 1) {
> -        pls->cur_timestamp = 0;
> -        pls->cur_seg_offset = 0;
> -        if (dry_run)
> -            return 0;
> -        ff_read_frame_flush(pls->ctx);
> -        return av_seek_frame(pls->ctx, -1, seek_pos_msec * 1000, flags);
> -    }
> -
> -    ff_format_io_close(pls->parent, &pls->input);
> -
> -    // find the nearest fragment
> -    if (pls->n_timelines > 0 && pls->fragment_timescale > 0) {
> -        int64_t num = pls->first_seq_no;
> -        av_log(pls->parent, AV_LOG_VERBOSE, "dash_seek with SegmentTimeline start n_timelines[%d] "
> -               "last_seq_no[%"PRId64"].\n",
> -               (int)pls->n_timelines, (int64_t)pls->last_seq_no);
> -        for (i = 0; i < pls->n_timelines; i++) {
> -            if (pls->timelines[i]->starttime > 0) {
> -                duration = pls->timelines[i]->starttime;
> -            }
> -            duration += pls->timelines[i]->duration;
> -            if (seek_pos_msec < ((duration * 1000) /  pls->fragment_timescale)) {
> -                goto set_seq_num;
> -            }
> -            for (j = 0; j < pls->timelines[i]->repeat; j++) {
> -                duration += pls->timelines[i]->duration;
> -                num++;
> -                if (seek_pos_msec < ((duration * 1000) /  pls->fragment_timescale)) {
> -                    goto set_seq_num;
> -                }
> -            }
> -            num++;
> -        }
> -
> -set_seq_num:
> -        pls->cur_seq_no = num > pls->last_seq_no ? pls->last_seq_no : num;
> -        av_log(pls->parent, AV_LOG_VERBOSE, "dash_seek with SegmentTimeline end cur_seq_no[%"PRId64"].\n",
> -               (int64_t)pls->cur_seq_no);
> -    } else if (pls->fragment_duration > 0) {
> -        pls->cur_seq_no = pls->first_seq_no + ((seek_pos_msec * pls->fragment_timescale) / pls->fragment_duration) / 1000;
> -    } else {
> -        av_log(pls->parent, AV_LOG_ERROR, "dash_seek missing timeline or fragment_duration\n");
> -        pls->cur_seq_no = pls->first_seq_no;
> -    }
> -    pls->cur_timestamp = 0;
> -    pls->cur_seg_offset = 0;
> -    pls->init_sec_buf_read_offset = 0;
> -    ret = dry_run ? 0 : reopen_demux_for_component(s, pls);
> -
> -    return ret;
> -}
> -
>  static int dash_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
>  {
> -    int ret = 0, i;
> +    int ret = 0;
>      DASHContext *c = s->priv_data;
> -    int64_t seek_pos_msec = av_rescale_rnd(timestamp, 1000,
> -                                           s->streams[stream_index]->time_base.den,
> -                                           flags & AVSEEK_FLAG_BACKWARD ?
> -                                           AV_ROUND_DOWN : AV_ROUND_UP);
> -    if ((flags & AVSEEK_FLAG_BYTE) || c->is_live)
> +    AVStream *st;
> +    int64_t now_ts;
> +
> +    if (flags & AVSEEK_FLAG_BYTE)
>          return AVERROR(ENOSYS);
>
> -    /* Seek in discarded streams with dry_run=1 to avoid reopening them */
> -    for (i = 0; i < c->n_videos; i++) {
> -        if (!ret)
> -            ret = dash_seek(s, c->videos[i], seek_pos_msec, flags, !c->videos[i]->ctx);
> -    }
> -    for (i = 0; i < c->n_audios; i++) {
> -        if (!ret)
> -            ret = dash_seek(s, c->audios[i], seek_pos_msec, flags, !c->audios[i]->ctx);
> -    }
> -    for (i = 0; i < c->n_subtitles; i++) {
> -        if (!ret)
> -            ret = dash_seek(s, c->subtitles[i], seek_pos_msec, flags, !c->subtitles[i]->ctx);
> +    st = s->streams[stream_index];
> +    now_ts = av_rescale_q_rnd(timestamp, st->time_base, AV_TIME_BASE_Q,
> +                              (flags & AVSEEK_FLAG_BACKWARD)
> +                                  ? AV_ROUND_DOWN : AV_ROUND_UP);
> +
> +    for (unsigned i = 0; i < c->nb_reps; ++i) {
> +        DASHRepresentation *rep = c->reps[i];
> +
> +        if (!rep->ic)
> +            continue;
> +
> +        rep->last_pts = AV_NOPTS_VALUE;
> +
> +        rep->read_ts = c->start_ts + now_ts;
> +
> +        if ((ret = av_seek_frame(rep->ic, -1, now_ts, flags)) < 0) {
> +            av_log(s, AV_LOG_ERROR, "Failed to seek subdemuxer\n");
> +            /* abort(); */
> +        }
> +
> +        dash_subdemuxer_flush(rep);
>      }
>
>      return ret;
>  }
>
> -static int dash_probe(const AVProbeData *p)
> +static av_cold int dash_probe(const AVProbeData *p)
>  {
> -    if (!av_stristr(p->buf, "<MPD"))
> -        return 0;
> +    if (strstr(p->buf, "<?xml") &&
> +        strstr(p->buf, "<MPD"))
> +        return AVPROBE_SCORE_MAX;
>
> -    if (av_stristr(p->buf, "dash:profile:isoff-on-demand:2011") ||
> -        av_stristr(p->buf, "dash:profile:isoff-live:2011") ||
> -        av_stristr(p->buf, "dash:profile:isoff-live:2012") ||
> -        av_stristr(p->buf, "dash:profile:isoff-main:2011") ||
> -        av_stristr(p->buf, "3GPP:PSS:profile:DASH1")) {
> +    if (p->mime_type && !strncmp(p->mime_type, "application/dash+xml", 20))
>          return AVPROBE_SCORE_MAX;
> -    }
> -    if (av_stristr(p->buf, "dash:profile")) {
> -        return AVPROBE_SCORE_MAX;
> -    }
>
>      return 0;
>  }
>
>  #define OFFSET(x) offsetof(DASHContext, x)
> -#define FLAGS AV_OPT_FLAG_DECODING_PARAM
>  static const AVOption dash_options[] = {
> -    {"allowed_extensions", "List of file extensions that dash is allowed to access",
> -        OFFSET(allowed_extensions), AV_OPT_TYPE_STRING,
> -        {.str = "aac,m4a,m4s,m4v,mov,mp4,webm,ts"},
> -        INT_MIN, INT_MAX, FLAGS},
> -    {NULL}
> +    { "connections", "Number of segment requests on the fly (per representation)",
> +        OFFSET(nb_connections), AV_OPT_TYPE_INT,
> +        { .i64 = 1 }, .min = 1, .max = UINT_MAX, .flags = AV_OPT_FLAG_DECODING_PARAM },
> +    { "protocol_opts", "Specify protocol options for opened segments",
> +        OFFSET(protocol_opts), AV_OPT_TYPE_DICT,
> +        .flags = AV_OPT_FLAG_DECODING_PARAM },
> +    { NULL }
>  };
>
>  static const AVClass dash_class = {
> @@ -2407,5 +3149,6 @@ AVInputFormat ff_dash_demuxer = {
>      .read_packet    = dash_read_packet,
>      .read_close     = dash_close,
>      .read_seek      = dash_read_seek,
> +    .extensions     = "mpd",
>      .flags          = AVFMT_NO_BYTE_SEEK,
>  };
> diff --git a/libavformat/internal.h b/libavformat/internal.h
> index 3c6b292..ee547e0 100644
> --- a/libavformat/internal.h
> +++ b/libavformat/internal.h
> @@ -33,6 +33,8 @@
>  #define PROBE_BUF_MIN 2048
>  #define PROBE_BUF_MAX (1 << 20)
>
> +#define UUID_BUF_SIZE 36
> +
>  #ifdef DEBUG
>  #    define hex_dump_debug(class, buf, size) av_hex_dump_log(class, AV_LOG_DEBUG, buf, size)
>  #else
> @@ -379,6 +381,18 @@ do {\
>   */
>  int ff_mkdir_p(const char *path);
>
> +char *ff_uuid_to_hex(char *buff, const uint8_t *src, int lowercase);
> +
> +/**
> + * Parse an UUID string.
> + *
> + * @param data the parsed data is written to this pointer
> + * @param p the string to parse
> + * @return the number of bytes written that is always 16 or negative number on
> + * error
> + */
> +int ff_uuid_to_data(uint8_t *data, const char *p);
> +
>  char *ff_data_to_hex(char *buf, const uint8_t *src, int size, int lowercase);
>
>  /**
> diff --git a/libavformat/utils.c b/libavformat/utils.c
> index ee947c1..d6b8418 100644
> --- a/libavformat/utils.c
> +++ b/libavformat/utils.c
> @@ -4878,6 +4878,53 @@ int ff_mkdir_p(const char *path)
>      return ret;
>  }
>
> +char *ff_uuid_to_hex(char *buff, const uint8_t *src, int lowercase)
> +{
> +    ff_data_to_hex(buff + 0, src + 0, 4, lowercase);
> +    buff[8] = '-';
> +    ff_data_to_hex(buff + 9, src + 4, 2, lowercase);
> +    buff[13] = '-';
> +    ff_data_to_hex(buff + 14, src + 6, 2, lowercase);
> +    buff[18] = '-';
> +    ff_data_to_hex(buff + 19, src + 8, 2, lowercase);
> +    buff[23] = '-';
> +    ff_data_to_hex(buff + 24, src + 10, 6, lowercase);
> +
> +    return buff;
> +}
> +
> +int ff_uuid_to_data(uint8_t *data, const char *p)
> +{
> +    uint8_t len;
> +
> +    for (len = 0; len < 16; ) {
> +        uint8_t h, l;
> +
> +#define PARSE_XDIGIT(ch, res) \
> +        if ('0' <= ch && ch <= '9') \
> +            res = ch - '0'; \
> +        else if ('A' <= ch && ch <= 'F') \
> +            res = ch - 'A' + 10; \
> +        else if ('a' <= ch && ch <= 'f') \
> +            res = ch - 'a' + 10; \
> +        else \
> +            return -1;
> +
> +        PARSE_XDIGIT(p[0], h);
> +        PARSE_XDIGIT(p[1], l);
> +        p += 2;
> +
> +#undef PARSE_XDIGIT
> +
> +        data[len++] = (h << 4) | l;
> +
> +        if ((4 == len || 6 == len || 8 == len || 10 == len) && *p++ != '-')
> +            return -1;
> +    }
> +
> +    return *p == '\0' ? 16 : -1;
> +}
> +
>  char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
>  {
>      int i;
> --
> 2.30.1
>
> _______________________________________________
> ffmpeg-devel mailing list
> ffmpeg-devel@ffmpeg.org
> https://ffmpeg.org/mailman/listinfo/ffmpeg-devel
>
> To unsubscribe, visit link above, or email
> ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".


I have been receviced this patch, will test and review soon.



Thanks
Steven

zsugabubus <zsugabubus@national.shitposting.agency> 于2021年3月23日周二 上午6:25写道：
>
> Compared to previous implementation, this rework tries to:
>
> - Improve code quality,
> - Provide better error handling (also: reduce numerous (potential)
>   memory leaks),
> - Broader coverage of the standard:
>   * multiple periods,
>   * multiple base URLs (fallback on CDN failure),
>   * handle ContentProtection/Role/etc... nodes,
>   * manifest chaining,
>   * drop ridiculous limits of @id's.
> - Fast startup, thanks to reading/probing streams only when needed.
> - Open multiple connections (HLS can open one more connection in
>   advance; DASH can do up to UINT_MAX, configurable via option);
>   similarly to HLS, currently it only opens them so only sequential
>   reading is possible, however this behavior can be changed in the
>   future,
> - Ability to seek live streams.
> - Bonus: Tests show that there are some kind of live streams that old
>   implementation was unable to cope with, now it is possible to play
>   them.
>
> I mark this patch as RFC since I think:
> - Seeking needs some improvement (I currently lack the necessary
>   knowledge to finish it (...I hope a little community help)),
> - Stuff around codec reinitialization (mentioned late opening +
>   multiperiod) may require some fine tuning, dunno.
>
> Signed-off-by: zsugabubus <zsugabubus@national.shitposting.agency>
> ---
>  libavformat/dashdec.c  | 4871 +++++++++++++++++++++++-----------------
>  libavformat/internal.h |   14 +
>  libavformat/utils.c    |   47 +
>  3 files changed, 2868 insertions(+), 2064 deletions(-)
>
> diff --git a/libavformat/dashdec.c b/libavformat/dashdec.c
> index 6f3f28d..0ee7dd8 100644
> --- a/libavformat/dashdec.c
> +++ b/libavformat/dashdec.c
> @@ -1,7 +1,8 @@
>  /*
> - * Dynamic Adaptive Streaming over HTTP demux
> + * Dynamic Adaptive Streaming over HTTP demuxer
>   * Copyright (c) 2017 samsamsam@o2.pl based on HLS demux
>   * Copyright (c) 2017 Steven Liu
> + * Copyright (c) 2021 reworked by zsugabubus
>   *
>   * This file is part of FFmpeg.
>   *
> @@ -19,182 +20,401 @@
>   * License along with FFmpeg; if not, write to the Free Software
>   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
>   */
> +
> +/**
> + * @file
> + * Dynamic Adaptive Streaming over HTTP demuxer
> + * @author samsamsam@o2.pl
> + * @author Steven Liu
> + * @author reworked by zsugabubus
> + * @see DASH-IF spec: https://dashif-documents.azurewebsites.net/DASH-IF-IOP/master/DASH-IF-IOP.html
> + * @see another spec: https://dashif-documents.azurewebsites.net/Guidelines-TimingModel/master/Guidelines-TimingModel.html
> + * @see test vectors: https://testassets.dashif.org/
> + * @see MPD scheme: https://standards.iso.org/ittf/PubliclyAvailableStandards/MPEG-DASH_schema_files/DASH-MPD.xsd
> + */
> +
>  #include <libxml/parser.h>
> +#include "libavutil/encryption_info.h"
>  #include "libavutil/intreadwrite.h"
> +#include "libavutil/lfg.h"
> +#include "libavutil/random_seed.h"
> +#include "libavutil/avassert.h"
>  #include "libavutil/opt.h"
>  #include "libavutil/time.h"
>  #include "libavutil/parseutils.h"
>  #include "internal.h"
>  #include "avio_internal.h"
> -#include "dash.h"
> +#include "libavutil/base64.h"
>
> -#define INITIAL_BUFFER_SIZE 32768
> -#define MAX_BPRINT_READ_SIZE (UINT_MAX - 1)
> -#define DEFAULT_MANIFEST_SIZE 8 * 1024
> +#if CONFIG_HTTP_PROTOCOL
> +# include "http.h"
> +#endif
>
> -struct fragment {
> -    int64_t url_offset;
> -    int64_t size;
> -    char *url;
> +#define MICROSEC_PER_SEC 1000000L
> +#define MILLISEC_PER_SEC (MICROSEC_PER_SEC / 1000L)
> +
> +static const char CENC_NAMESPACE[] = "urn:mpeg:cenc:2013";
> +
> +enum {
> +    /* Most init section <1K, but some DRM systems can use 600 or so bytes for
> +     * PSSH data. */
> +    INITBUF_MAX = 4 * 1024
>  };
>
> -/*
> - * reference to : ISO_IEC_23009-1-DASH-2012
> - * Section: 5.3.9.6.2
> - * Table: Table 17 — Semantics of SegmentTimeline element
> - * */
> -struct timeline {
> -    /* starttime: Element or Attribute Name
> -     * specifies the MPD start time, in @timescale units,
> -     * the first Segment in the series starts relative to the beginning of the Period.
> -     * The value of this attribute must be equal to or greater than the sum of the previous S
> -     * element earliest presentation time and the sum of the contiguous Segment durations.
> -     * If the value of the attribute is greater than what is expressed by the previous S element,
> -     * it expresses discontinuities in the timeline.
> -     * If not present then the value shall be assumed to be zero for the first S element
> -     * and for the subsequent S elements, the value shall be assumed to be the sum of
> -     * the previous S element's earliest presentation time and contiguous duration
> -     * (i.e. previous S@starttime + @duration * (@repeat + 1)).
> -     * */
> -    int64_t starttime;
> -    /* repeat: Element or Attribute Name
> -     * specifies the repeat count of the number of following contiguous Segments with
> -     * the same duration expressed by the value of @duration. This value is zero-based
> -     * (e.g. a value of three means four Segments in the contiguous series).
> -     * */
> -    int64_t repeat;
> -    /* duration: Element or Attribute Name
> -     * specifies the Segment duration, in units of the value of the @timescale.
> -     * */
> +#define xml_for_each_attr /* { ... } */ \
> +    for (xmlAttrPtr attr = node->properties; \
> +         attr; \
> +         attr = attr->next) \
> +        for (xmlChar *value = xmlNodeGetContent(attr->children); \
> +             value; \
> +             xml_freep(&value))
> +
> +#define xml_for_each_child /* { ... } */ \
> +    for (xmlNodePtr child = xmlFirstElementChild(node); \
> +         child; \
> +         child = xmlNextElementSibling(child))
> +
> +#define ARRAY_SIZE(x) (sizeof(x) / sizeof(*x))
> +
> +#define DASH_RANGE_INITALIZER (DASHRange){ .start = 0, .end = INT64_MAX }
> +
> +typedef struct {
> +    int64_t start;
> +    int64_t end;
> +} DASHRange;
> +
> +typedef struct {
> +    xmlChar *url;
> +    DASHRange range;
> +} DASHSegment;
> +
> +typedef struct {
> +    xmlChar *id;
> +    int64_t start_ts;
> +    int64_t end_ts;
> +    AVDictionary *metadata;
> +} DASHPeriod;
> +
> +typedef struct {
> +    int64_t start_ts; /* Relative to timeline. */
> +    uint64_t number; /**< $Number$ */
> +    int64_t repeat; /**< number..=(number + repeat) */
>      int64_t duration;
> +} DASHSegmentTemplate;
> +
> +typedef struct {
> +    unsigned refcount;
> +    unsigned nb;
> +    char *elems[];
> +} DASHURLList;
> +
> +typedef struct {
> +    AVIOContext *pb; /**< IO context for reading segment. */
> +    uint64_t segment_size; /**< Size of segment to read. */
> +} DASHSegmentContext;
> +
> +typedef struct {
> +    xmlChar *id;
> +
> +    unsigned refcount;
> +    AVDictionary *metadata;
> +    AVEncryptionInitInfo *init_info; /**< Chain of initialization infos
> +                                       extracted from the manifest. */
> +} DASHAdaptationSet;
> +
> +enum DASHTimelineType {
> +    TIMELINE_TEMPLATES, /**< DASHTimeline.u.templates */
> +    TIMELINE_SEGMENTS, /**< DASHTimeline.u.segments */
>  };
>
> -/*
> - * Each playlist has its own demuxer. If it is currently active,
> - * it has an opened AVIOContext too, and potentially an AVPacket
> - * containing the next packet from this stream.
> - */
> -struct representation {
> -    char *url_template;
> -    AVIOContext pb;
> -    AVIOContext *input;
> -    AVFormatContext *parent;
> -    AVFormatContext *ctx;
> -    int stream_index;
> -
> -    char *id;
> -    char *lang;
> -    int bandwidth;
> -    AVRational framerate;
> -    AVStream *assoc_stream; /* demuxer stream associated with this representation */
> -
> -    int n_fragments;
> -    struct fragment **fragments; /* VOD list of fragment for profile */
> -
> -    int n_timelines;
> -    struct timeline **timelines;
> -
> -    int64_t first_seq_no;
> -    int64_t last_seq_no;
> -    int64_t start_number; /* used in case when we have dynamic list of segment to know which segments are new one*/
> -
> -    int64_t fragment_duration;
> -    int64_t fragment_timescale;
> -
> -    int64_t presentation_timeoffset;
> -
> -    int64_t cur_seq_no;
> -    int64_t cur_seg_offset;
> -    int64_t cur_seg_size;
> -    struct fragment *cur_seg;
> -
> -    /* Currently active Media Initialization Section */
> -    struct fragment *init_section;
> -    uint8_t *init_sec_buf;
> -    uint32_t init_sec_buf_size;
> -    uint32_t init_sec_data_len;
> -    uint32_t init_sec_buf_read_offset;
> -    int64_t cur_timestamp;
> -    int is_restart_needed;
> +typedef struct {
> +    unsigned refcount;
> +    enum DASHTimelineType type;
> +    int64_t duration;
> +    int64_t timescale;
> +    DASHSegment init;
> +    union {
> +        struct {
> +            unsigned nb;
> +            DASHSegment elems[];
> +        } segments;
> +        struct {
> +            unsigned nb;
> +            DASHSegment master;
> +            DASHSegmentTemplate elems[];
> +        } templates;
> +    } u;
> +} DASHTimeline;
> +
> +#define DASH_PARAMETERS_INITIALIZER { \
> +    .sample_aspect_ratio = { 0, 1 }, \
> +    .field_order = AV_FIELD_PROGRESSIVE, \
> +}
> +
> +typedef struct {
> +    enum AVMediaType codec_type;
> +    enum AVCodecID codec_id;
> +    int profile;
> +    int level;
> +    int disposition;
> +
> +    /* Audio only. */
> +    int sample_rate;
> +    int channels;
> +    uint64_t channel_layout;
> +    enum AVMatrixEncoding matrix_encoding;
> +
> +    /* Video only. */
> +    int width;
> +    int height;
> +    AVRational frame_rate;
> +    AVRational sample_aspect_ratio;
> +    enum AVFieldOrder field_order;
> +} DASHParameters;
> +
> +typedef struct {
> +    DASHPeriod *period;
> +    DASHAdaptationSet *as;
> +    DASHTimeline *timeline;
> +    DASHURLList *base;
> +    uint32_t bandwidth;
> +
> +    char *initbuf;
> +    int initbuf_size; /* Limited by INITBUF_MAX. */
> +
> +    DASHParameters par;
> +} DASHRepresentationPeriod;
> +
> +typedef struct {
> +    xmlChar *id;
> +
> +    AVFormatContext *oc; /* := DASHContext.ctx */
> +    AVStream **ostreams; /**< Corresponding output streams. */
> +    AVFormatContext *ic;
> +    unsigned nb_streams; /**< Should be := ic->nb_streams. If less, subdemuxer
> +                           created new streams. */
> +
> +    AVIOContext ic_pb; /**< Custom IO context for ic subdemuxer. */
> +
> +    int save_init; /**< Whether to store what we have read from the current segment. */
> +    DASHRepresentationPeriod **periods;
> +    unsigned nb_periods;
> +    DASHRepresentationPeriod *cur_period;
> +
> +    int64_t last_pts;
> +    int64_t read_ts;
> +
> +    unsigned cur_segment;
> +    DASHSegmentContext segments[];
> +} DASHRepresentation;
> +
> +enum DASHUTCTiming {
> +    DASH_UTC_TIMING_LOCAL,
> +    DASH_UTC_TIMING_HTTP_XSDATE,
> +    DASH_UTC_TIMING_HTTP_ISO,
> +    DASH_UTC_TIMING_HTTP_NTP,
> +    DASH_UTC_TIMING_NTP,
> +    DASH_UTC_TIMING_HTTP_HEAD,
> +    DASH_UTC_TIMING_DIRECT,
>  };
>
> -typedef struct DASHContext {
> +typedef struct {
>      const AVClass *class;
> -    char *base_url;
> -
> -    int n_videos;
> -    struct representation **videos;
> -    int n_audios;
> -    struct representation **audios;
> -    int n_subtitles;
> -    struct representation **subtitles;
> -
> -    /* MediaPresentationDescription Attribute */
> -    uint64_t media_presentation_duration;
> -    uint64_t suggested_presentation_delay;
> -    uint64_t availability_start_time;
> -    uint64_t availability_end_time;
> -    uint64_t publish_time;
> -    uint64_t minimum_update_period;
> -    uint64_t time_shift_buffer_depth;
> -    uint64_t min_buffer_time;
> -
> -    /* Period Attribute */
> -    uint64_t period_duration;
> -    uint64_t period_start;
> -
> -    /* AdaptationSet Attribute */
> -    char *adaptionset_lang;
> -
> -    int is_live;
> -    AVIOInterruptCB *interrupt_callback;
> -    char *allowed_extensions;
> -    AVDictionary *avio_opts;
> -    int max_url_size;
> -
> -    /* Flags for init section*/
> -    int is_init_section_common_video;
> -    int is_init_section_common_audio;
> -    int is_init_section_common_subtitle;
>
> +    xmlChar *id;
> +
> +    char *location;
> +    xmlChar *chain_next_location;
> +    xmlChar *fallback_location;
> +
> +    unsigned nb_connections;
> +
> +    DASHPeriod **periods;
> +    unsigned nb_periods;
> +
> +    DASHAdaptationSet **ass;
> +    unsigned nb_ass;
> +
> +    DASHRepresentation **reps;
> +    unsigned nb_reps;
> +
> +    int is_live; /**< Segments may get available over time. */
> +    int64_t start_ts;
> +
> +    int64_t media_presentation_duration;
> +    int64_t suggested_presentation_delay;
> +    int64_t availability_start_time;
> +    int64_t availability_end_time;
> +    int64_t publish_time;
> +    int64_t min_update_period;
> +    int64_t time_shift_buffer_depth;
> +    int64_t min_buffer_time;
> +    int64_t max_segment_duration;
> +
> +    int64_t next_update;
> +
> +    int64_t time_diff;
> +    int utc_timing; /* DASH_UTC_TIMING_*; < 0 if updated */
> +
> +    AVLFG rnd;
> +
> +    AVDictionary *protocol_opts;
>  } DASHContext;
>
> -static int ishttp(char *url)
> +typedef struct {
> +    xmlChar *scheme_id;
> +    xmlChar *value;
> +    xmlAttrPtr scheme_id_attr;
> +} DASHScheme;
> +
> +#define DASH_CONTENTPROTECTION_INITIALIZER { .has_key_id = 0 }
> +
> +typedef struct {
> +    int has_key_id;
> +    uint8_t default_kid[16];
> +} DASHContentProtection;
> +
> +#pragma GCC diagnostic push
> +#pragma GCC diagnostic ignored "-Wstrict-prototypes"
> +static av_cold void av_freep_arrayp(void *ptr, void (*free)())
> +{
> +    unsigned *nmemb = (unsigned *)((void **)ptr + 1);
> +
> +    for (unsigned i = 0; i < *nmemb; ++i)
> +        ((void(*)(void *))free)((*(void ***)ptr)[i]);
> +
> +    *nmemb = 0;
> +    av_freep(ptr);
> +}
> +#pragma GCC diagnostic pop
> +
> +static void xml_free(xmlChar *p)
> +{
> +    if (p)
> +        xmlFree(p);
> +}
> +
> +static void xml_freep(xmlChar **pp)
> +{
> +    if (*pp) {
> +        xmlFree(*pp);
> +        *pp = NULL;
> +    }
> +}
> +
> +static av_cold DASHURLList *dash_ref_urllist(DASHURLList *urls)
> +{
> +    ++urls->refcount;
> +    return urls;
> +}
> +
> +static av_cold void dash_unref_urllist(DASHURLList *urls)
> +{
> +    if (!urls || --urls->refcount)
> +        return;
> +
> +    for (unsigned i = 0; i < urls->nb; ++i)
> +        av_free(urls->elems[i]);
> +    av_free(urls);
> +}
> +
> +static int dash_urllist_has(const DASHURLList *urls, const char *url)
>  {
> -    const char *proto_name = avio_find_protocol_name(url);
> -    return proto_name && av_strstart(proto_name, "http", NULL);
> +    for (unsigned i = 0; i < urls->nb; ++i)
> +        if (!strcmp(urls->elems[i], url))
> +            return 1;
> +
> +    return 0;
> +}
> +
> +static av_cold void dash_free_period(DASHPeriod *period)
> +{
> +    if (!period)
> +        return;
> +
> +    xml_free(period->id);
> +    av_dict_free(&period->metadata);
> +    av_free(period);
> +}
> +
> +static av_cold void dash_free_adaptationset(DASHAdaptationSet *as)
> +{
> +    if (!as)
> +        return;
> +
> +    xml_free(as->id);
> +    av_encryption_init_info_free(as->init_info);
> +    av_dict_free(&as->metadata);
> +    av_free(as);
> +}
> +
> +static av_cold DASHTimeline *dash_ref_timeline(DASHTimeline *timeline)
> +{
> +    ++timeline->refcount;
> +    return timeline;
> +}
> +
> +static void dash_free_segment(DASHSegment *g)
> +{
> +    xml_free(g->url);
> +}
> +
> +static void dash_unref_timeline(DASHTimeline *timeline)
> +{
> +    if (!timeline || --timeline->refcount)
> +        return;
> +
> +    dash_free_segment(&timeline->init);
> +
> +    if (TIMELINE_SEGMENTS == timeline->type) {
> +        for (unsigned i = 0; i < timeline->u.segments.nb; ++i)
> +            dash_free_segment(&timeline->u.segments.elems[i]);
> +    } else if (TIMELINE_TEMPLATES == timeline->type) {
> +        dash_free_segment(&timeline->u.templates.master);
> +    } else {
> +        abort();
> +    }
> +
> +    av_free(timeline);
>  }
>
> -static int aligned(int val)
> +/**
> + * @return |wall_time| / MICROSEC_PER_SEC * AV_TIME_BASE
> + */
> +static int64_t av_wall2timebase(int64_t wall_time)
>  {
> -    return ((val + 0x3F) >> 6) << 6;
> +    if (MICROSEC_PER_SEC < AV_TIME_BASE)
> +        return wall_time * (AV_TIME_BASE / MICROSEC_PER_SEC);
> +    else
> +        return wall_time / (MICROSEC_PER_SEC / AV_TIME_BASE);
>  }
>
> -static uint64_t get_current_time_in_sec(void)
> +/**
> + * @return wall clock time in AV_TIME_BASE
> + */
> +static int64_t dash_gettime(AVFormatContext *s)
>  {
> -    return  av_gettime() / 1000000;
> +    DASHContext *c = s->priv_data;
> +    return av_wall2timebase(av_gettime()) + c->time_diff;
>  }
>
> -static uint64_t get_utc_date_time_insec(AVFormatContext *s, const char *datetime)
> +/**
> + * Parse ISO-8601 date.
> + * @return time in AV_TIME_BASE
> + */
> +static uint64_t dash_parse_date(const char *s, AVFormatContext *log_ctx)
>  {
>      struct tm timeinfo;
> -    int year = 0;
> -    int month = 0;
> -    int day = 0;
> -    int hour = 0;
> -    int minute = 0;
> -    int ret = 0;
> +    unsigned year = 0, month = 0, day = 0;
> +    unsigned hour = 0, minute = 0;
>      float second = 0.0;
>
> -    /* ISO-8601 date parser */
> -    if (!datetime)
> -        return 0;
> +    if (6 != av_sscanf(s, "%u-%u-%uT%u:%u:%fZ",
> +                       &year, &month, &day,
> +                       &hour, &minute, &second))
> +        av_log(log_ctx, AV_LOG_WARNING, "Malformed ISO-8601 date: '%s'\n", s);
> +        /* Fall-through. */
>
> -    ret = sscanf(datetime, "%d-%d-%dT%d:%d:%fZ", &year, &month, &day, &hour, &minute, &second);
> -    /* year, month, day, hour, minute, second  6 arguments */
> -    if (ret != 6) {
> -        av_log(s, AV_LOG_WARNING, "get_utc_date_time_insec get a wrong time format\n");
> -    }
>      timeinfo.tm_year = year - 1900;
>      timeinfo.tm_mon  = month - 1;
>      timeinfo.tm_mday = day;
> @@ -205,2189 +425,2711 @@ static uint64_t get_utc_date_time_insec(AVFormatContext *s, const char *datetime
>      return av_timegm(&timeinfo);
>  }
>
> -static uint32_t get_duration_insec(AVFormatContext *s, const char *duration)
> -{
> -    /* ISO-8601 duration parser */
> -    uint32_t days = 0;
> -    uint32_t hours = 0;
> -    uint32_t mins = 0;
> -    uint32_t secs = 0;
> -    int size = 0;
> -    float value = 0;
> -    char type = '\0';
> -    const char *ptr = duration;
> -
> -    while (*ptr) {
> -        if (*ptr == 'P' || *ptr == 'T') {
> -            ptr++;
> +/**
> + * Parse ISO-8601 duration.
> + * @return duration in AV_TIME_BASE
> + */
> +static int64_t dash_parse_duration(const char *s, AVFormatContext *log_ctx)
> +{
> +    enum {
> +        STATE_GROUND,
> +        STATE_DATE,
> +        STATE_TIME,
> +    } state = STATE_GROUND;
> +    int64_t ret = 0;
> +
> +    for (const char *p = s; *p; ++p) {
> +        int len;
> +        int64_t unit = 0;
> +        /* We require double precision since it is absolutely valid to pass a
> +         * huge integer solely in seconds. */
> +        double base;
> +
> +        switch (*p) {
> +        case 'P':
> +            if (state != STATE_GROUND)
> +                goto invalid;
> +            state = STATE_DATE;
> +            continue;
> +        case 'T':
> +            if (state != STATE_DATE)
> +                goto invalid;
> +            state = STATE_TIME;
>              continue;
>          }
>
> -        if (sscanf(ptr, "%f%c%n", &value, &type, &size) != 2) {
> -            av_log(s, AV_LOG_WARNING, "get_duration_insec get a wrong time format\n");
> -            return 0; /* parser error */
> +        av_sscanf(p, "%lf%n", &base, &len);
> +        p += len;
> +
> +        switch (state) {
> +        case STATE_DATE:
> +            switch (*p) {
> +            case 'Y':
> +                unit = (int64_t)AV_TIME_BASE * 60 * 60 * 24 * 365;
> +                break;
> +            case 'M':
> +                unit = (int64_t)AV_TIME_BASE * 60 * 60 * 24 * 30;
> +                break;
> +            case 'D':
> +                unit = (int64_t)AV_TIME_BASE * 60 * 60 * 24;
> +                break;
> +            }
> +            break;
> +        case STATE_TIME:
> +            switch (*p) {
> +            case 'H':
> +                unit = (int64_t)AV_TIME_BASE * 60 * 60;
> +                break;
> +            case 'M':
> +                unit = (int64_t)AV_TIME_BASE * 60;
> +                break;
> +            case 'S':
> +                unit = (int64_t)AV_TIME_BASE;
> +                break;
> +            }
> +            break;
> +        }
> +
> +        if (!unit) {
> +        invalid:
> +            av_log(log_ctx, AV_LOG_ERROR, "Malformed ISO-8601 duration: '%s'\n", s);
> +            return INT64_MIN;
>          }
> +
> +        ret += unit * base;
> +    }
> +
> +    return ret;
> +}
> +
> +static av_cold void dash_subdemuxer_flush(DASHRepresentation *rep)
> +{
> +    DASHContext *c = rep->oc->priv_data;
> +
> +    avio_flush(&rep->ic_pb);
> +    for (unsigned i = 0; i < c->nb_connections; ++i)
> +        ff_format_io_close(rep->oc, &rep->segments[i].pb);
> +
> +
> +    /* for (unsigned i = 0; i < rep->nb_streams; ++i)
> +            avcodec_flush_buffers(rep->ostreams[i]->internal->avctx); */
> +
> +    if (rep->ic) {
> +        /* for (unsigned i = 0; i < rep->ic->nb_streams; ++i)
> +                avcodec_flush_buffers(rep->ic->streams[i]->internal->avctx); */
> +        avformat_flush(rep->ic);
> +    }
> +
> +    /* If receiving init section just has been aborted, we have to forget all
> +     * received bytes otherwise at subdemuxer restart on the first read it will
> +     * be falsely detected that we have received the complete section because
> +     * stored init section size is less than maximum storable. */
> +    if (rep->save_init) {
> +        rep->save_init = 0;
> +        if (rep->cur_period) {
> +            rep->cur_period->initbuf_size = 0;
> +            rep->cur_period = NULL;
> +        }
> +    }
> +}
> +
> +static av_cold void dash_subdemuxer_close(DASHRepresentation *rep)
> +{
> +    av_log(rep->oc, AV_LOG_DEBUG, "Closing representation '%s'\n", rep->id);
> +
> +    /* Only need to deallocate the used array. */
> +    av_freep(&rep->ic_pb.buffer);
> +
> +    dash_subdemuxer_flush(rep);
> +
> +    if (rep->ic) {
> +        /* IO context is part of our context so avoid freeing it. */
> +        rep->ic->pb = NULL;
> +        rep->cur_period = NULL;
> +
> +        if (rep->ic->iformat) {
> +            avformat_close_input(&rep->ic);
> +        } else {
> +            avformat_free_context(rep->ic);
> +            rep->ic = NULL;
> +        }
> +    }
> +}
> +
> +static av_cold void dash_free_representationperiod(DASHRepresentationPeriod *period)
> +{
> +    dash_unref_timeline(period->timeline);
> +    dash_unref_urllist(period->base);
> +    av_free(period->initbuf);
> +    av_free(period);
> +}
> +
> +static av_cold void dash_free_representation(DASHRepresentation *rep)
> +{
> +    dash_subdemuxer_close(rep);
> +    av_free(rep->ostreams);
> +    av_freep_arrayp(&rep->periods, dash_free_representationperiod);
> +    xml_free(rep->id);
> +    av_free(rep);
> +}
> +
> +static av_cold xmlNodePtr xml_get_nsnode(xmlNodePtr node, const char *nodename, const char *namespace)
> +{
> +    xml_for_each_child
> +        if (!strcmp(child->name, nodename) &&
> +            (child->ns && !strcmp(child->ns->href, namespace)))
> +            return child;
> +    return NULL;
> +}
> +
> +static av_cold int dash_parse_contentprotection_pssh(AVFormatContext *s,
> +                                                     struct AVEncryptionInitInfo *info,
> +                                                     xmlNodePtr node)
> +{
> +    int ret = 0;
> +    xmlNodePtr pssh_node;
> +    int size;
> +    char *pssh = NULL;
> +    int decoded_size;
> +    uint8_t *decoded_pssh;
> +
> +    av_free(info->data);
> +    info->data = NULL;
> +    info->data_size = 0;
> +
> +    if (!(pssh_node = xml_get_nsnode(node, "pssh", CENC_NAMESPACE)))
> +        goto out;
> +
> +    if (!(pssh = xmlNodeGetContent(pssh_node)))
> +        goto invalid_content;
> +
> +    size = strlen(pssh);
> +    decoded_size = AV_BASE64_DECODE_SIZE(size);
> +
> +    if (!(decoded_pssh = av_malloc(decoded_size))) {
> +        ret = AVERROR(ENOMEM);
> +        goto out;
> +    }
> +
> +    if ((decoded_size = av_base64_decode(decoded_pssh, pssh, decoded_size)) < 0) {
> +        av_free(decoded_pssh);
> +
> +    invalid_content:
> +        av_log(s, AV_LOG_ERROR, "Invalid %s/{%s}:pssh content\n",
> +               node->name, CENC_NAMESPACE);
> +        ret = AVERROR_INVALIDDATA;
> +        goto out;
> +    }
> +
> +    info->data = decoded_pssh;
> +    info->data_size = decoded_size;
> +
> +out:
> +    xml_free(pssh);
> +    return ret;
> +}
> +
> +static av_cold void dash_free_scheme(DASHScheme *scheme)
> +{
> +    xml_free(scheme->scheme_id);
> +    xml_free(scheme->value);
> +}
> +
> +static av_cold void dash_log_invalid_attr_value(AVFormatContext *log_ctx, xmlAttrPtr attr, const char *value)
> +{
> +    av_log(log_ctx, AV_LOG_ERROR, "Invalid %s/%s@%s%s%s%s='%s'\n",
> +           attr->parent->parent->name,
> +           attr->parent->ns ? "{" : "",
> +           attr->parent->ns ? (const char *)attr->parent->ns->href : "",
> +           attr->parent->ns ? "}" : "",
> +           attr->parent->name,
> +           attr->name,
> +           value);
> +}
> +
> +static av_cold void dash_log_missing_attr(AVFormatContext *log_ctx, xmlNodePtr node, const char *attr)
> +{
> +    av_log(log_ctx, AV_LOG_ERROR, "Missing %s/%s@%s\n",
> +           node->parent->name,
> +           node->name,
> +           attr);
> +}
> +
> +static av_cold void dash_log_unknown_child(AVFormatContext *log_ctx, xmlNodePtr child)
> +{
> +    av_log(log_ctx, AV_LOG_WARNING, "Unknown %s/%s\n",
> +           child->parent->name,
> +           child->name);
> +}
> +
> +static av_cold void dash_log_unknown_attr(AVFormatContext *log_ctx, xmlAttrPtr attr, const xmlChar *value)
> +{
> +    av_log(log_ctx, AV_LOG_WARNING, "Unknown %s%s%s@%s%s%s%s='%s'\n",
> +           attr->parent->parent->name ? (const char *)attr->parent->parent->name : "",
> +           attr->parent->parent->name ? "/"                                      : "",
> +           attr->parent->name,
> +           attr->ns ? "{" : "",
> +           attr->ns ? (const char *)attr->ns->href : "",
> +           attr->ns ? "}:" : "",
> +           attr->name,
> +           value);
> +}
> +
> +static av_cold void dash_log_unknown_scheme(AVFormatContext *log_ctx, const DASHScheme *scheme)
> +{
> +    av_log(log_ctx, AV_LOG_WARNING,
> +           "Unknown %s/%s@%s='%s' (@value=%c%s%c)\n",
> +           scheme->scheme_id_attr->parent->parent->name,
> +           scheme->scheme_id_attr->parent->name,
> +           scheme->scheme_id_attr->name,
> +           scheme->scheme_id,
> +           scheme->value ? '\''                        : '(',
> +           scheme->value ? (const char *)scheme->value : "not present",
> +           scheme->value ? '\''                        : ')');
> +}
> +
> +static av_cold int dash_parse_scheme(AVFormatContext *s, DASHScheme *scheme, int value_required, xmlNodePtr node)
> +{
> +    scheme->value = NULL;
> +
> +    if (!(scheme->scheme_id_attr = xmlHasNsProp(node, "schemeIdUri", NULL))) {
> +        dash_log_missing_attr(s, node, "schemeIdUri");
> +        return AVERROR_INVALIDDATA;
> +    }
> +
> +    if (!(scheme->scheme_id = xmlNodeGetContent(scheme->scheme_id_attr->children)))
> +        return AVERROR(ENOMEM);
> +
> +    if (!(scheme->value = xmlGetNoNsProp(node, "value")) && value_required) {
> +        dash_log_missing_attr(s, node, "value");
> +        return AVERROR_INVALIDDATA;
> +    }
> +
> +    return 0;
> +}
> +
> +static av_cold int dash_parse_contentprotection(AVFormatContext *s,
> +                                                DASHAdaptationSet *as,
> +                                                DASHContentProtection *cp,
> +                                                xmlNodePtr node)
> +{
> +    int ret = 0;
> +    AVEncryptionInitInfo *init_info = NULL;
> +    const char *uuid;
> +    DASHScheme scheme;
> +
> +    if ((ret = dash_parse_scheme(s, &scheme, 0, node)) < 0)
> +        goto out;
> +
> +    /* Parse Common Encryption element. */
> +    if (!cp->has_key_id &&
> +        !strcmp(scheme.scheme_id, "urn:mpeg:dash:mp4protection:2011") &&
> +        (scheme.value && !strcmp(scheme.value, "cenc")))
> +    {
> +        char *key_id;
> +
> +        if ((key_id = xmlGetNsProp(node, "default_KID", CENC_NAMESPACE))) {
> +            if (ff_uuid_to_data(cp->default_kid, key_id) < 0)
> +                av_log(s, AV_LOG_ERROR, "Malformed UUID in ContentProtection@cenc:default_KID='%s'\n",
> +                       scheme.scheme_id);
> +            else
> +                cp->has_key_id = 1;
> +
> +            xmlFree(key_id);
> +        } else {
> +            dash_log_missing_attr(s, node, "default_KID");
> +        }
> +
> +        goto out;
> +    } else if (cp->has_key_id && av_strstart(scheme.scheme_id, "urn:uuid:", &uuid)) {
> +        /* Parse an UUID schema. */
> +        init_info = av_encryption_init_info_alloc(/* system_id_size */ 16, 1,
> +                                                  /* key_id_size */ 16, /* data_size */ 0,
> +                                                  /* extra_data_size */ 0);
Hi zsugabubus,

This line will break the compling work.

CC libavformat/dashdec.o
src/libavformat/dashdec.c:748:73: error: too many arguments to
function call, expected 4, have 5
                                                  /* extra_data_size */ 0);
                                                                        ^
src/libavutil/encryption_info.h:176:1: note:
'av_encryption_init_info_alloc' declared here
AVEncryptionInitInfo *av_encryption_init_info_alloc(
^
src/libavformat/dashdec.c:1777:86: warning: incompatible pointer types
passing 'int *' to parameter of type 'size_t *'
      (aka 'unsigned long *') [-Wincompatible-pointer-types]
            side_data =
av_encryption_init_info_add_side_data(period->as->init_info,
&side_data_size);

              ^~~~~~~~~~~~~~~
src/libavutil/encryption_info.h:203:47: note: passing argument to
parameter 'side_data_size' here
    const AVEncryptionInitInfo *info, size_t *side_data_size);
                                              ^
1 warning and 1 error generated.
make: *** [libavformat/dashdec.o] Error 1




> +        if (!init_info) {
> +            ret = AVERROR(ENOMEM);
> +            goto out;
> +        }
> +
> +        if (ff_uuid_to_data(init_info->system_id, uuid) < 0) {
> +            av_log(s, AV_LOG_ERROR, "Malformed UUID in ContentProtection@schemeIdUri='%s'\n",
> +                   scheme.scheme_id);
> +            goto out;
> +        }
> +
> +        if (0 <= ret)
> +            ret = dash_parse_contentprotection_pssh(s, init_info, node);
> +        if (ret < 0)
> +            goto out;
> +
> +        memcpy(init_info->key_ids[0], cp->default_kid, init_info->key_id_size);
> +
> +        init_info->next = as->init_info;
> +        as->init_info = init_info;
> +        init_info = NULL;
> +    } else {
> +        dash_log_unknown_scheme(s, &scheme);
> +        goto out;
> +    }
> +
> +out:
> +    if (init_info)
> +        av_encryption_init_info_free(init_info);
> +    dash_free_scheme(&scheme);
> +
> +    return ret;
> +}
> +
> +static av_cold int dash_set_location(AVFormatContext *s, char const *url)
> +{
> +    DASHContext *c = s->priv_data;
> +    URLComponents uc;
> +    char const *protocol;
> +
> +    if (ff_url_decompose(&uc, url, NULL) < 0)
> +        return AVERROR_INVALIDDATA;
> +
> +    av_free(c->location);
> +    if (!(c->location = av_strdup(url)))
> +        return AVERROR(ENOMEM);
> +
> +    protocol = avio_find_protocol_name(c->location);
> +    if (strstr(protocol, "http")) {
> +        char *p = strstr(uc.query, "t=");
> +        if (p) {
> +            int64_t seconds;
> +
> +            p += 2;
> +            if (1 == av_sscanf(p, "posix:%"SCNd64, &seconds))
> +                c->start_ts = AV_TIME_BASE * seconds;
> +            else if (!strncmp(p, "now", 4))
> +                c->start_ts = dash_gettime(s);
> +            else
> +                c->start_ts = dash_parse_date(p, s);
> +        }
> +    }
> +
> +    return 0;
> +}
> +
> +static av_cold int dash_parse_location(AVFormatContext *s,
> +                                       xmlNodePtr node)
> +{
> +    int ret = 0;
> +    char *value;
> +    DASHContext *c = s->priv_data;
> +
> +    if (!c->is_live) {
> +        av_log(s, AV_LOG_INFO, "MPD@type=\"static\"/Location ignored\n");
> +        return 0;
> +    }
> +
> +    if (!(value = xmlNodeGetContent(node)))
> +        return AVERROR(ENOMEM);
> +
> +    ret = dash_set_location(s, value);
> +
> +    xmlFree(value);
> +    return ret;
> +}
> +
> +/**
> + * Like ff_make_absolute_urla() but allocates a big enough memory.
> + * *out_url shall always be av_free()d regard of error.
> + * */
> +static int ff_make_absolute_urla(char **out_url, const char *base, const char *rel)
> +{
> +    int out_url_max_size = strlen(base) + strlen(rel) + 1/* NUL */;
> +    if (!(*out_url = av_malloc(out_url_max_size)))
> +        return AVERROR(ENOMEM);
> +
> +    return ff_make_absolute_url(*out_url, out_url_max_size, base, rel);
> +}
> +
> +static av_cold DASHURLList *dash_new_urllist(unsigned nb_urls)
> +{
> +    DASHURLList *urls;
> +
> +    if (!(urls = av_mallocz(offsetof(DASHURLList, elems[nb_urls]))))
> +        return NULL;
> +
> +    dash_ref_urllist(urls);
> +    urls->nb = nb_urls;
> +
> +    return urls;
> +}
> +
> +static av_cold int dash_parse_baseurl(AVFormatContext *s,
> +                                      DASHURLList **urls,
> +                                      xmlNodePtr node)
> +{
> +    int ret = 0;
> +    DASHContext *c = s->priv_data;
> +    char *url_chunk = NULL;
> +    char *resolved_url = NULL;
> +    DASHURLList *new_urls = NULL;
> +    int is_absolute;
> +    char *base_url;
> +
> +    if (!(url_chunk = xmlNodeGetContent(node)))
> +        return AVERROR(ENOMEM);
> +
> +    base_url = (*urls)->elems[0];
> +    if ((ret = ff_make_absolute_urla(&resolved_url, base_url, url_chunk)) < 0)
> +        goto out;
> +
> +    if (dash_urllist_has(*urls, resolved_url))
> +        goto out;
> +
> +    is_absolute = !strcmp(resolved_url, url_chunk);
> +
> +    if (1 == (*urls)->refcount) {
> +        /* If we own the instance, it means that this node is an alternative
> +         * BaseURL. */
> +        if (is_absolute) {
> +            void *p;
> +
> +            if ((p = av_realloc(*urls, offsetof(DASHURLList, elems[(*urls)->nb + 1])))) {
> +                /* Put the new URL at a random place. Absolute addresses most
> +                 * commonly mean different servers/CDNs, so we can help a
> +                 * little bit on load-balancing. */
> +                unsigned to_index;
> +
> +                *urls = p;
> +                to_index = av_lfg_get(&c->rnd) % ((*urls)->nb + 1);
> +                (*urls)->elems[(*urls)->nb++] = (*urls)->elems[to_index];
> +                (*urls)->elems[to_index] = resolved_url, resolved_url = NULL;
> +            }
> +        } else {
> +            /* We do not want to explode URL list so we ignore relative
> +             * alternative URLs. Also, using different paths on the same
> +             * server does not really makes sense. */
> +        }
> +    } else {
> +        /* Either add a single absolute URL to the list or in case of a
> +         * relative BaseURL combine it with every parent URL. */
> +        if (!(new_urls = dash_new_urllist(is_absolute ? 1 : (*urls)->nb))) {
> +            ret = AVERROR(ENOMEM);
> +            goto out;
> +        }
> +
> +        /* We have already done the first one at the top. */
> +        new_urls->elems[0] = resolved_url, resolved_url = NULL;
> +        if (!is_absolute) {
> +            for (unsigned i = 1; i < (*urls)->nb; ++i)
> +                if (!(ret = ff_make_absolute_urla(&new_urls->elems[i], (*urls)->elems[i], url_chunk)))
> +                    goto out;
> +        }
> +
> +        /* Replace URL list of current level with the modified one. */
> +        dash_unref_urllist(*urls);
> +        *urls = new_urls;
> +        new_urls = NULL;
> +    }
> +
> +out:
> +    xmlFree(url_chunk);
> +    av_free(resolved_url);
> +    dash_unref_urllist(new_urls);
> +    return ret;
> +}
> +
> +static av_cold int dash_parse_mimetype(DASHParameters *par, const char *value)
> +{
> +    if (!strncmp(value, "video/", 6))
> +        par->codec_type = AVMEDIA_TYPE_VIDEO;
> +    else if (!strncmp(value, "audio/", 6))
> +        par->codec_type = AVMEDIA_TYPE_AUDIO;
> +    else if (!strncmp(value, "text/", 5))
> +        par->codec_type = AVMEDIA_TYPE_SUBTITLE;
> +    else
> +        return 1;
> +
> +    return 0;
> +}
> +
> +static av_cold int dash_parse_contenttype(AVFormatContext *s,
> +                                          DASHParameters *par,
> +                                          const xmlChar *value)
> +{
> +    if (!strcmp(value, "video"))
> +        par->codec_type = AVMEDIA_TYPE_VIDEO;
> +    else if (!strcmp(value, "audio"))
> +        par->codec_type = AVMEDIA_TYPE_AUDIO;
> +    else {
> +        par->codec_type = AVMEDIA_TYPE_UNKNOWN;
> +        return 1;
> +    }
> +
> +    return 0;
> +}
> +
> +static av_cold int dash_parse_codecs(AVFormatContext *s,
> +                                     DASHParameters *par,
> +                                     const xmlChar *value)
> +{
> +    int n;
> +    char type;
> +    int flags;
> +
> +    /* https://developer.mozilla.org/en-US/docs/Web/Media/Formats/codecs_parameter */
> +    /* https://tools.ietf.org/html/rfc6381 */
> +    if (3 == av_sscanf(value, "mp4%c.%d.%d%n", &type, &par->level, &par->profile, &n) &&
> +        !value[n])
> +    {
>          switch (type) {
> -        case 'D':
> -            days = (uint32_t)value;
> -            break;
> -        case 'H':
> -            hours = (uint32_t)value;
> -            break;
> -        case 'M':
> -            mins = (uint32_t)value;
> -            break;
> -        case 'S':
> -            secs = (uint32_t)value;
> -            break;
> -        default:
> -            // handle invalid type
> -            break;
> +        case 'a': par->codec_type = AVMEDIA_TYPE_AUDIO; break;
> +        case 'v': par->codec_type = AVMEDIA_TYPE_VIDEO; break;
> +        default: return 1;
>          }
> -        ptr += size;
> +
> +    } else if (3 == av_sscanf(value, "avc1"/* avcoti */".%02x%02x%02x%n",
> +                              &par->profile, &flags, &par->level, &n) &&
> +               !value[n])
> +    {
> +        par->codec_type = AVMEDIA_TYPE_VIDEO;
> +        par->codec_id = AV_CODEC_ID_H264;
> +        par->profile |= (unsigned)flags << 7;
> +    } else if (av_sscanf(value, "hev1.%n", &n), n == 5)
> +    {
> +        par->codec_id = AV_CODEC_ID_HEVC;
> +    } else {
> +        par->codec_id = AV_CODEC_ID_NONE;
> +        return 1;
>      }
> -    return  ((days * 24 + hours) * 60 + mins) * 60 + secs;
> +
> +    return 0;
>  }
>
> -static int64_t get_segment_start_time_based_on_timeline(struct representation *pls, int64_t cur_seq_no)
> +static av_cold int dash_parse_scantype(AVFormatContext *s,
> +                                       DASHParameters *par,
> +                                       const xmlChar *value)
>  {
> -    int64_t start_time = 0;
> -    int64_t i = 0;
> -    int64_t j = 0;
> -    int64_t num = 0;
> -
> -    if (pls->n_timelines) {
> -        for (i = 0; i < pls->n_timelines; i++) {
> -            if (pls->timelines[i]->starttime > 0) {
> -                start_time = pls->timelines[i]->starttime;
> -            }
> -            if (num == cur_seq_no)
> -                goto finish;
> +    if (!strcmp(value, "progressive")) {
> +        par->field_order = AV_FIELD_PROGRESSIVE;
> +    } else {
> +        par->field_order = AV_FIELD_UNKNOWN;
> +        return 1;
> +    }
>
> -            start_time += pls->timelines[i]->duration;
> +    return 0;
> +}
>
> -            if (pls->timelines[i]->repeat == -1) {
> -                start_time = pls->timelines[i]->duration * cur_seq_no;
> -                goto finish;
> -            }
> +static av_cold int dash_parse_parameters(AVFormatContext *s,
> +                                         DASHParameters *par,
> +                                         xmlAttrPtr attr,
> +                                         const xmlChar *value)
> +{
> +    if (!strcmp(attr->name, "height"))
> +        (void)av_sscanf(value, "%d", &par->height);
> +    else if (!strcmp(attr->name, "width"))
> +        (void)av_sscanf(value, "%d", &par->width);
> +    else if (!strcmp(attr->name, "mimeType"))
> +        return dash_parse_mimetype(par, value);
> +    else if (!strcmp(attr->name, "audioSamplingRate"))
> +        (void)av_sscanf(value, "%d", &par->sample_rate);
> +    else if (!strcmp(attr->name, "par"))
> +        /* Ignore. */;
> +    else if (!strcmp(attr->name, "sar"))
> +        (void)av_parse_ratio(&par->sample_aspect_ratio, value, INT_MAX, AV_LOG_ERROR, s);
> +    else if (!strcmp(attr->name, "frameRate"))
> +        (void)av_sscanf(value, "%d", &par->frame_rate);
> +    else if (!strcmp(attr->name, "codecs"))
> +        return dash_parse_codecs(s, par, value);
> +    else if (!strcmp(attr->name, "scanType"))
> +        return dash_parse_scantype(s, par, value);
> +    else if (!strcmp(attr->name, "contentType"))
> +        return dash_parse_contenttype(s, par, value);
> +    else
> +        return 1;
> +
> +    return 0;
> +}
>
> -            for (j = 0; j < pls->timelines[i]->repeat; j++) {
> -                num++;
> -                if (num == cur_seq_no)
> -                    goto finish;
> -                start_time += pls->timelines[i]->duration;
> -            }
> -            num++;
> -        }
> +static av_cold int dash_parse_audiochannelconfiguration(AVFormatContext *s,
> +                                                        DASHParameters *par,
> +                                                        xmlNodePtr node)
> +{
> +    int ret = 0;
> +    DASHScheme scheme;
> +
> +    if ((ret = dash_parse_scheme(s, &scheme, 1, node)) < 0)
> +        goto out;
> +
> +    par->channels = 0;
> +    par->channel_layout = 0;
> +    par->matrix_encoding = AV_MATRIX_ENCODING_NONE;
> +
> +    /* https://testassets.dashif.org/#testvector/details/586fb3879ae9045678eacd10 */
> +    if (!strcmp(scheme.scheme_id, "urn:dolby:dash:audio_channel_configuration:2011") ||
> +        !strcmp(scheme.scheme_id, "tag:dolby.com,2014:dash:audio_channel_configuration:2011"))
> +    {
> +        par->matrix_encoding = AV_MATRIX_ENCODING_DOLBY;
> +        (void)av_get_extended_channel_layout(scheme.value, &par->channel_layout, &par->channels);
> +    } else if (!strcmp(scheme.scheme_id, "urn:mpeg:dash:23003:3:audio_channel_configuration:2011")) {
> +        (void)av_sscanf(scheme.value, "%d", &par->channels);
> +        par->channel_layout = av_get_default_channel_layout(par->channels);
> +    } else {
> +        (void)av_get_extended_channel_layout(scheme.value, &par->channel_layout, &par->channels);
> +        dash_log_unknown_scheme(s, &scheme);
>      }
> -finish:
> -    return start_time;
> +
> +out:
> +    dash_free_scheme(&scheme);
> +    return ret;
>  }
>
> -static int64_t calc_next_seg_no_from_timelines(struct representation *pls, int64_t cur_time)
> +static av_cold int dash_parse_assetidentifier(AVFormatContext *s,
> +                                              DASHPeriod *period,
> +                                              xmlNodePtr node)
>  {
> -    int64_t i = 0;
> -    int64_t j = 0;
> -    int64_t num = 0;
> -    int64_t start_time = 0;
> +    int ret = 0;
> +    DASHScheme scheme;
>
> -    for (i = 0; i < pls->n_timelines; i++) {
> -        if (pls->timelines[i]->starttime > 0) {
> -            start_time = pls->timelines[i]->starttime;
> -        }
> -        if (start_time > cur_time)
> -            goto finish;
> -
> -        start_time += pls->timelines[i]->duration;
> -        for (j = 0; j < pls->timelines[i]->repeat; j++) {
> -            num++;
> -            if (start_time > cur_time)
> -                goto finish;
> -            start_time += pls->timelines[i]->duration;
> -        }
> -        num++;
> -    }
> +    if ((ret = dash_parse_scheme(s, &scheme, 1, node)) < 0)
> +        goto out;
>
> -    return -1;
> +    if (!strcmp(scheme.scheme_id, "urn:org:dashif:asset-id:2013")) {
> +        av_dict_set(&period->metadata, "asset_identifier", scheme.value, 0);
> +    } else {
> +        dash_log_unknown_scheme(s, &scheme);
> +    }
>
> -finish:
> -    return num;
> +out:
> +    dash_free_scheme(&scheme);
> +    return ret;
>  }
>
> -static void free_fragment(struct fragment **seg)
> +static av_cold int dash_parse_viewpoint(AVFormatContext *s,
> +                                        DASHAdaptationSet *as,
> +                                        xmlNodePtr node)
>  {
> -    if (!(*seg)) {
> -        return;
> +    int ret = 0;
> +    DASHScheme scheme;
> +
> +    if ((ret = dash_parse_scheme(s, &scheme, 1, node)) < 0)
> +        goto out;
> +
> +    /* https://testassets.dashif.org/#testvector/details/5cde78e4a5eeda55aa663101 */
> +    if (!strcmp(scheme.scheme_id, "urn:mpeg:dash:viewpoint:2011")) {
> +        av_dict_set(&as->metadata, "viewpoint", scheme.value, 0);
> +    } else {
> +        dash_log_unknown_scheme(s, &scheme);
>      }
> -    av_freep(&(*seg)->url);
> -    av_freep(seg);
> +
> +out:
> +    dash_free_scheme(&scheme);
> +    return ret;
>  }
>
> -static void free_fragment_list(struct representation *pls)
> +static av_cold void dash_sync_time(AVFormatContext *s, const xmlChar *value)
>  {
> -    int i;
> +    DASHContext *c = s->priv_data;
> +    int ret = 0;
> +
> +    switch (c->utc_timing) {
> +    case DASH_UTC_TIMING_LOCAL:
> +    default:
> +        ret = 1;
> +        break;
> +    case DASH_UTC_TIMING_HTTP_XSDATE:
> +    case DASH_UTC_TIMING_HTTP_ISO:
> +    case DASH_UTC_TIMING_HTTP_NTP:
> +    case DASH_UTC_TIMING_NTP:
> +    case DASH_UTC_TIMING_HTTP_HEAD:
> +    case DASH_UTC_TIMING_DIRECT:
> +        ret = AVERROR_PATCHWELCOME;
> +        break;
> +    }
>
> -    for (i = 0; i < pls->n_fragments; i++) {
> -        free_fragment(&pls->fragments[i]);
> +    if (!ret) {
> +        av_log(s, AV_LOG_DEBUG, "Time synchronized: %lf s\n",
> +               (double)c->time_diff / AV_TIME_BASE);
> +        c->utc_timing = -c->utc_timing;
> +    } else if (ret < 0) {
> +        av_log(s, AV_LOG_ERROR, "Failed to synchronized time: %s\n",
> +               av_err2str(ret));
>      }
> -    av_freep(&pls->fragments);
> -    pls->n_fragments = 0;
>  }
>
> -static void free_timelines_list(struct representation *pls)
> +static av_cold int dash_parse_utctiming(AVFormatContext *s,
> +                                        xmlNodePtr node)
>  {
> -    int i;
> +    int ret = 0;
> +    DASHContext *c = s->priv_data;
> +    DASHScheme scheme;
> +    int utc_timing = c->utc_timing;
> +
> +    if ((ret = dash_parse_scheme(s, &scheme, 0, node)) < 0)
> +        goto out;
> +
> +    c->utc_timing = DASH_UTC_TIMING_LOCAL;
> +
> +    if (0);
> +#define PARSE(name, scheme_name) \
> +    else if (!strcmp(scheme.scheme_id, "urn:mpeg:dash:utc:"scheme_name":2014")) \
> +        c->utc_timing = DASH_UTC_TIMING_##name
> +    PARSE(HTTP_XSDATE, "http-xsdate");
> +    PARSE(HTTP_ISO,    "http-iso");
> +    PARSE(HTTP_NTP,    "http-ntp");
> +    PARSE(NTP,         "ntp");
> +    PARSE(HTTP_HEAD,   "http-head");
> +    PARSE(DIRECT,      "direct");
> +#undef PARSE
> +    else
> +        dash_log_unknown_scheme(s, &scheme);
> +
> +    if (c->utc_timing == -utc_timing)
> +        c->utc_timing = utc_timing;
> +
> +    dash_sync_time(s, scheme.value);
> +
> +out:
> +    dash_free_scheme(&scheme);
> +    return ret;
> +}
>
> -    for (i = 0; i < pls->n_timelines; i++) {
> -        av_freep(&pls->timelines[i]);
> +static av_cold int dash_parse_role(AVFormatContext *s,
> +                                   DASHParameters *par,
> +                                   xmlNodePtr node)
> +{
> +    int ret = 0;
> +    DASHScheme scheme;
> +
> +    if ((ret = dash_parse_scheme(s, &scheme, 1, node)) < 0)
> +        goto out;
> +
> +    /* https://testassets.dashif.org/#feature/details/588a48c27459f8cb201b881b */
> +    if (!strcmp(scheme.scheme_id, "urn:mpeg:dash:role:2011")) {
> +        if (!strcmp(scheme.value, "main"))
> +            par->disposition |= AV_DISPOSITION_DEFAULT;
> +        else if (!strcmp(scheme.value, "alternate"))
> +            par->disposition &= ~AV_DISPOSITION_DEFAULT;
> +        else if (!strcmp(scheme.value, "original"))
> +            par->disposition |= AV_DISPOSITION_ORIGINAL;
> +        else if (!strcmp(scheme.value, "dub"))
> +            par->disposition |= AV_DISPOSITION_DUB;
> +        else if (!strcmp(scheme.value, "subtitle"))
> +            par->codec_type = AVMEDIA_TYPE_SUBTITLE;
> +    } else {
> +        dash_log_unknown_scheme(s, &scheme);
>      }
> -    av_freep(&pls->timelines);
> -    pls->n_timelines = 0;
> +
> +out:
> +    dash_free_scheme(&scheme);
> +    return ret;
>  }
>
> -static void free_representation(struct representation *pls)
> +static av_cold int dash_parse_property(AVFormatContext *s,
> +                                       DASHAdaptationSet *as,
> +                                       DASHRepresentationPeriod *rep,
> +                                       xmlNodePtr node)
>  {
> -    free_fragment_list(pls);
> -    free_timelines_list(pls);
> -    free_fragment(&pls->cur_seg);
> -    free_fragment(&pls->init_section);
> -    av_freep(&pls->init_sec_buf);
> -    av_freep(&pls->pb.buffer);
> -    ff_format_io_close(pls->parent, &pls->input);
> -    if (pls->ctx) {
> -        pls->ctx->pb = NULL;
> -        avformat_close_input(&pls->ctx);
> +    int ret = 0;
> +    DASHContext *c = s->priv_data;
> +    DASHScheme scheme;
> +
> +    if ((ret = dash_parse_scheme(s, &scheme, 1, node)) < 0)
> +        goto out;
> +
> +    /* https://testassets.dashif.org/#feature/details/588a48c27459f8cb201b881b */
> +    if ((!as && !rep) && !strcmp(scheme.scheme_id, "urn:mpeg:dash:chaining:2016")) {
> +        xml_free(c->chain_next_location);
> +        c->chain_next_location = scheme.value;
> +        scheme.value = NULL;
> +    } else if ((!as && !rep) && !strcmp(scheme.scheme_id, "urn:mpeg:dash:fallback:2016")) {
> +        xml_free(c->fallback_location);
> +        c->fallback_location = scheme.value;
> +        scheme.value = NULL;
> +    } else {
> +        dash_log_unknown_scheme(s, &scheme);
>      }
>
> -    av_freep(&pls->url_template);
> -    av_freep(&pls->lang);
> -    av_freep(&pls->id);
> -    av_freep(&pls);
> +out:
> +    dash_free_scheme(&scheme);
> +    return ret;
>  }
>
> -static void free_video_list(DASHContext *c)
> +static av_cold int dash_check_existing_timeline(AVFormatContext *s, DASHTimeline **out_timeline, xmlNodePtr timeline_node)
>  {
> -    int i;
> -    for (i = 0; i < c->n_videos; i++) {
> -        struct representation *pls = c->videos[i];
> -        free_representation(pls);
> -    }
> -    av_freep(&c->videos);
> -    c->n_videos = 0;
> +    if (!*out_timeline)
> +        return 0;
> +
> +    av_log(s, AV_LOG_ERROR, "Multiple timelines specified\n");
> +    dash_log_unknown_child(s, timeline_node);
> +
> +    return AVERROR_INVALIDDATA;
>  }
>
> -static void free_audio_list(DASHContext *c)
> +static int dash_parse_segmentlist(AVFormatContext *s,
> +                                  DASHPeriod *period,
> +                                  DASHTimeline **out_timeline,
> +                                  xmlNodePtr node)
>  {
> -    int i;
> -    for (i = 0; i < c->n_audios; i++) {
> -        struct representation *pls = c->audios[i];
> -        free_representation(pls);
> +    int nb_segments = 0;
> +    int64_t duration = 0;
> +    int64_t timescale = 1;
> +    DASHTimeline *timeline = NULL;
> +    DASHSegment *g;
> +    int ret = 0;
> +
> +    if ((ret = dash_check_existing_timeline(s, out_timeline, node) < 0))
> +        return ret;
> +
> +    xml_for_each_attr {
> +        if (!strcmp(attr->name, "duration"))
> +            (void)av_sscanf(value, "%"SCNd64, &duration);
> +        else if (!strcmp(attr->name, "timescale"))
> +            (void)av_sscanf(value, "%"SCNd64, &timescale);
> +        else
> +            dash_log_unknown_attr(s, attr, value);
> +    }
> +
> +    xml_for_each_child {
> +        if (!strcmp(child->name, "SegmentURL"))
> +            ++nb_segments;
> +        else
> +            dash_log_unknown_child(s, child);
> +    }
> +
> +    if (!(timeline = av_mallocz(offsetof(DASHTimeline, u.segments.elems[nb_segments])))) {
> +        ret = AVERROR(ENOMEM);
> +        goto out;
> +    }
> +    dash_ref_timeline(timeline);
> +    timeline->type = TIMELINE_SEGMENTS;
> +    timeline->u.segments.nb = nb_segments;
> +    g = &timeline->u.segments.elems[0];
> +
> +    xml_for_each_child {
> +        xmlNodePtr node = child;
> +
> +        if (strcmp(node->name, "SegmentURL"))
> +            continue;
> +
> +        xml_for_each_attr {
> +            if (!strcmp(attr->name, "media")) {
> +                g->url = value;
> +                value = NULL;
> +            } else
> +                dash_log_unknown_attr(s, attr, value);
> +        }
> +        if (!g->url) {
> +            dash_log_missing_attr(s, node, "media");
> +            ret = AVERROR_INVALIDDATA;
> +            goto out;
> +        }
> +
> +        ++g;
>      }
> -    av_freep(&c->audios);
> -    c->n_audios = 0;
> +
> +    *out_timeline = dash_ref_timeline(timeline);
> +
> +out:
> +    dash_unref_timeline(timeline);
> +    return ret;
>  }
>
> -static void free_subtitle_list(DASHContext *c)
> +static av_cold int dash_parse_segmenttimeline(AVFormatContext *s,
> +                                              DASHPeriod *period,
> +                                              uint64_t start_number,
> +                                              DASHTimeline **out_timeline,
> +                                              xmlNodePtr node)
>  {
> -    int i;
> -    for (i = 0; i < c->n_subtitles; i++) {
> -        struct representation *pls = c->subtitles[i];
> -        free_representation(pls);
> +    int ret = 0;
> +    unsigned nb_selems = 0;
> +    DASHSegmentTemplate *g;
> +    DASHTimeline *timeline;
> +    int64_t start_ts = 0;
> +
> +    if ((ret = dash_check_existing_timeline(s, out_timeline, node) < 0))
> +        return ret;
> +
> +    xml_for_each_attr {
> +        dash_log_unknown_attr(s, attr, value);
> +    }
> +
> +    xml_for_each_child {
> +        if (!strcmp(child->name, "S"))
> +            ++nb_selems;
> +        else
> +            dash_log_unknown_child(s, child);
> +    }
> +
> +    if (!(timeline = av_malloc(offsetof(DASHTimeline, u.templates.elems[nb_selems])))) {
> +        ret = AVERROR(ENOMEM);
> +        goto out;
> +    }
> +    memset(timeline, 0, offsetof(DASHTimeline, u.templates.elems[0]));
> +    dash_ref_timeline(timeline);
> +    timeline->type = TIMELINE_TEMPLATES;
> +    timeline->u.templates.nb = nb_selems;
> +    g = &timeline->u.templates.elems[0];
> +
> +    xml_for_each_child {
> +        xmlNodePtr node = child;
> +
> +        if (strcmp(node->name, "S"))
> +            continue;
> +
> +        *g = (DASHSegmentTemplate){
> +            .start_ts = start_ts,
> +            .number = start_number
> +        };
> +
> +        xml_for_each_attr {
> +            int64_t num = 0;
> +
> +            (void)av_sscanf(value, "%"SCNd64, &num);
> +
> +            if (!strcmp(attr->name, "t")) {
> +                /* Muste be increasing. */
> +                if (num < start_ts) {
> +                    dash_log_invalid_attr_value(s, attr, value);
> +                    ret = AVERROR_INVALIDDATA;
> +                    goto out;
> +                }
> +
> +                g->start_ts = num;
> +            } else if (!strcmp(attr->name, "n"))
> +                g->number = num;
> +            else if (!strcmp(attr->name, "r"))
> +                g->repeat = num;
> +            else if (!strcmp(attr->name, "d")) {
> +                g->duration = num;
> +
> +                if (g->duration <= 0) {
> +                    dash_log_invalid_attr_value(s, attr, value);
> +                    ret = AVERROR_INVALIDDATA;
> +                    goto out;
> +                }
> +            } else {
> +                dash_log_unknown_attr(s, attr, value);
> +            }
> +        }
> +
> +        start_number = g->number + (g->repeat + 1);
> +        start_ts = g->start_ts + g->duration * (g->repeat + 1);
> +        ++g;
>      }
> -    av_freep(&c->subtitles);
> -    c->n_subtitles = 0;
> +
> +    *out_timeline = dash_ref_timeline(timeline);
> +
> +out:
> +    dash_unref_timeline(timeline);
> +    return ret;
>  }
>
> -static int open_url(AVFormatContext *s, AVIOContext **pb, const char *url,
> -                    AVDictionary **opts, AVDictionary *opts2, int *is_http)
> +/* One init URL and list of template arguments. */
> +static av_cold int dash_parse_segmenttemplate(AVFormatContext *s,
> +                                              DASHPeriod *period,
> +                                              DASHTimeline **out_timeline,
> +                                              xmlNodePtr node)
>  {
> -    DASHContext *c = s->priv_data;
> -    AVDictionary *tmp = NULL;
> -    const char *proto_name = NULL;
> -    int ret;
> -
> -    if (av_strstart(url, "crypto", NULL)) {
> -        if (url[6] == '+' || url[6] == ':')
> -            proto_name = avio_find_protocol_name(url + 7);
> +    int ret = 0;
> +    DASHTimeline *timeline = NULL;
> +    int64_t duration = -1;
> +    uint64_t start_number = 1;
> +    int64_t presentation_time_offset = 0;
> +    int64_t timescale = 1;
> +    xmlChar *init_url = NULL;
> +    xmlChar *media_url = NULL;
> +
> +    if ((ret = dash_check_existing_timeline(s, out_timeline, node) < 0))
> +        return ret;
> +
> +    xml_for_each_attr {
> +        if (!strcmp(attr->name, "startNumber"))
> +            (void)av_sscanf(value, "%"SCNu64, &start_number);
> +        else if (!strcmp(attr->name, "duration")) {
> +            (void)av_sscanf(value, "%"SCNd64, &duration);
> +            if (duration < 0) {
> +                dash_log_invalid_attr_value(s, attr, value);
> +                ret = AVERROR_INVALIDDATA;
> +            }
> +        } else if (!strcmp(attr->name, "presentationTimeOffset"))
> +            (void)av_sscanf(value, "%"SCNu64, &presentation_time_offset);
> +        else if (!strcmp(attr->name, "timescale")) {
> +            (void)av_sscanf(value, "%"SCNd64, &timescale);
> +            if (timescale <= 0) {
> +                dash_log_invalid_attr_value(s, attr, value);
> +                ret = AVERROR_INVALIDDATA;
> +            }
> +        } else if (!strcmp(attr->name, "initialization")) {
> +            init_url = value;
> +            value = NULL;
> +        } else if (!strcmp(attr->name, "media")) {
> +            media_url = value;
> +            value = NULL;
> +        } else
> +            dash_log_unknown_attr(s, attr, value);
>      }
>
> -    if (!proto_name)
> -        proto_name = avio_find_protocol_name(url);
> +    /* value has to be free()'d */
> +    if (ret < 0)
> +        goto out;
>
> -    if (!proto_name)
> -        return AVERROR_INVALIDDATA;
> +    if (!init_url || !media_url) {
> +        ret = AVERROR_INVALIDDATA;
> +        dash_log_missing_attr(s, node, !init_url ? "initialization" : "media");
> +        goto out;
> +    }
>
> -    // only http(s) & file are allowed
> -    if (av_strstart(proto_name, "file", NULL)) {
> -        if (strcmp(c->allowed_extensions, "ALL") && !av_match_ext(url, c->allowed_extensions)) {
> -            av_log(s, AV_LOG_ERROR,
> -                   "Filename extension of \'%s\' is not a common multimedia extension, blocked for security reasons.\n"
> -                   "If you wish to override this adjust allowed_extensions, you can set it to \'ALL\' to allow all\n",
> -                   url);
> -            return AVERROR_INVALIDDATA;
> +    if (0 <= duration) {
> +        DASHSegmentTemplate *g;
> +
> +        if (!(timeline = av_mallocz(offsetof(DASHTimeline, u.templates.elems[1])))) {
> +            ret = AVERROR(ENOMEM);
> +            goto out;
> +        }
> +        dash_ref_timeline(timeline);
> +        timeline->type = TIMELINE_TEMPLATES;
> +        timeline->u.templates.nb = 1;
> +        g = &timeline->u.templates.elems[0];
> +        g->start_ts = 0;
> +        g->number = start_number;
> +        g->repeat = INT64_MAX;
> +        /* We round down in order to fetch segments more instead before than after. */
> +        g->duration =  duration; /* av_rescale_rnd(duration, AV_TIME_BASE, timescale, AV_ROUND_DOWN); */
> +    } else {
> +        xml_for_each_child {
> +            if (!strcmp(child->name, "SegmentTimeline"))
> +                ret = dash_parse_segmenttimeline(s, period, start_number, &timeline, child);
> +            else
> +                dash_log_unknown_child(s, child);
> +
> +            if (ret < 0)
> +                goto out;
>          }
> -    } else if (av_strstart(proto_name, "http", NULL)) {
> -        ;
> -    } else
> -        return AVERROR_INVALIDDATA;
> -
> -    if (!strncmp(proto_name, url, strlen(proto_name)) && url[strlen(proto_name)] == ':')
> -        ;
> -    else if (av_strstart(url, "crypto", NULL) && !strncmp(proto_name, url + 7, strlen(proto_name)) && url[7 + strlen(proto_name)] == ':')
> -        ;
> -    else if (strcmp(proto_name, "file") || !strncmp(url, "file,", 5))
> -        return AVERROR_INVALIDDATA;
> -
> -    av_freep(pb);
> -    av_dict_copy(&tmp, *opts, 0);
> -    av_dict_copy(&tmp, opts2, 0);
> -    ret = avio_open2(pb, url, AVIO_FLAG_READ, c->interrupt_callback, &tmp);
> -    if (ret >= 0) {
> -        // update cookies on http response with setcookies.
> -        char *new_cookies = NULL;
> -
> -        if (!(s->flags & AVFMT_FLAG_CUSTOM_IO))
> -            av_opt_get(*pb, "cookies", AV_OPT_SEARCH_CHILDREN, (uint8_t**)&new_cookies);
> -
> -        if (new_cookies) {
> -            av_dict_set(opts, "cookies", new_cookies, AV_DICT_DONT_STRDUP_VAL);
> +
> +        /* Either a SegmentTemplate@duration or a SegmentTimeline must be
> +         * given. */
> +        if (!timeline) {
> +            av_log(s, AV_LOG_ERROR, "Missing %s/%s",
> +                   node->name, "SegmentTimeline");
> +            ret = AVERROR_INVALIDDATA;
> +            goto out;
>          }
>
>      }
>
> -    av_dict_free(&tmp);
> +    timeline->duration = INT64_MAX;
> +    timeline->timescale = timescale;
> +    timeline->init.range = DASH_RANGE_INITALIZER;
> +    timeline->init.url = init_url;
> +    init_url = NULL;
> +    timeline->u.templates.master.url = media_url;
> +    media_url = NULL;
>
> -    if (is_http)
> -        *is_http = av_strstart(proto_name, "http", NULL);
> +    timeline->u.templates.master.range = DASH_RANGE_INITALIZER;
>
> +    *out_timeline = dash_ref_timeline(timeline);
> +
> +out:
> +    xml_free(init_url);
> +    xml_free(media_url);
> +    dash_unref_timeline(timeline);
>      return ret;
>  }
>
> -static char *get_content_url(xmlNodePtr *baseurl_nodes,
> -                             int n_baseurl_nodes,
> -                             int max_url_size,
> -                             char *rep_id_val,
> -                             char *rep_bandwidth_val,
> -                             char *val)
> +static DASHRange dash_parse_range(const char *s, AVFormatContext *log_ctx)
>  {
> -    int i;
> -    char *text;
> -    char *url = NULL;
> -    char *tmp_str = av_mallocz(max_url_size);
> +    DASHRange range = {
> +        .start = 0,
> +        .end = INT64_MAX
> +    };
> +    (void)av_sscanf(s, "%"SCNd64"-%"SCNd64, &range.start, &range.end);
> +    return range;
> +}
> +
> +static int dash_parse_segmentbase(AVFormatContext *s,
> +                                  DASHPeriod *period,
> +                                  DASHTimeline **out_timeline,
> +                                  xmlNodePtr node)
> +{
> +    int ret = 0;
> +    DASHSegment *g;
> +    DASHTimeline *timeline;
> +
> +    if ((ret = dash_check_existing_timeline(s, out_timeline, node) < 0))
> +        return ret;
> +
> +    if (!(timeline = av_mallocz(offsetof(DASHTimeline, u.segments.elems[1])))) {
> +        ret = AVERROR(ENOMEM);
> +        goto out;
> +    }
> +    dash_ref_timeline(timeline);
> +    timeline->type = TIMELINE_SEGMENTS;
> +    timeline->duration = INT64_MAX;
> +    timeline->u.segments.nb = 1;
> +    g = &timeline->u.segments.elems[0];
> +
> +    abort();
> +    xml_for_each_child {
> +        if (!strcmp(child->name, "Initalization")) {
> +            xmlNodePtr node = child;
> +            xml_for_each_attr {
> +                if (!strcmp(attr->name, "range"))
> +                    timeline->init.range = dash_parse_range(value, s);
> +                else
> +                    dash_log_unknown_attr(s, attr, value);
> +            }
> +        } else
> +            dash_log_unknown_child(s, child);
> +    }
> +
> +    (void)g;
> +
> +    *out_timeline = dash_ref_timeline(timeline);
> +
> +out:
> +    dash_unref_timeline(timeline);
> +    return 0;
> +}
> +
> +/**
> + * Substitute template arguments in |template| if not NULL and make an URL by
> + * joining it to the absolute |base| part.
> + * @param base Absolute base path.
> + * @param template Absolute or relative path, potentially containing $ template
> + *                 arguments. May be NULL.
> + * @return The allocated URL that shall be av_free()d by the caller.
> + */
> +static char *dash_make_url(const char *base, const char *template,
> +                           /* Template arguments. */
> +                           const char *$RepresentationID$,
> +                           uint64_t $Number$,
> +                           int64_t $Time$,
> +                           uint32_t $Bandwidth$)
> +{
> +    enum { MAX_DIGITS = 20 };
> +
> +    size_t base_size;
> +    size_t $RepresentationID$_size = strlen($RepresentationID$);
> +    size_t max_url_size;
> +    char *url, *u;
> +    URLComponents uc;
> +
> +    ff_url_decompose(&uc, template, NULL);
> +    base_size = URL_COMPONENT_HAVE(uc, scheme) ? 0 : strlen(base);
> +
> +    max_url_size = base_size +
> +                   (template ? strlen(template) : 0) +
> +                   $RepresentationID$_size +
> +                   (MAX_DIGITS * 3) + 1 /* NUL */;
>
> -    if (!tmp_str)
> +    if (!(url = av_malloc(max_url_size)))
>          return NULL;
>
> -    for (i = 0; i < n_baseurl_nodes; ++i) {
> -        if (baseurl_nodes[i] &&
> -            baseurl_nodes[i]->children &&
> -            baseurl_nodes[i]->children->type == XML_TEXT_NODE) {
> -            text = xmlNodeGetContent(baseurl_nodes[i]->children);
> -            if (text) {
> -                memset(tmp_str, 0, max_url_size);
> -                ff_make_absolute_url(tmp_str, max_url_size, "", text);
> -                xmlFree(text);
> +    memcpy(url, base, base_size);
> +    u = url + base_size;
> +
> +    while (template && *template) {
> +        char *t;
> +
> +        if ((t = strchr(template, '$'))) {
> +            size_t len;
> +            unsigned digits;
> +
> +            /* Append everything before $. */
> +            len = t - template;
> +            memcpy(u, template, len);
> +            u += len;
> +            template = t + 1;
> +
> +            /* Get length of template name. */
> +            len = strcspn(template, "$%");
> +
> +            /* Parse formatting. It's easy because we have only one
> +             * possibility. */
> +            digits = 0;
> +            (void)av_sscanf(template + len, "%%0%ud$", &digits);
> +            if (MAX_DIGITS < digits)
> +                digits = MAX_DIGITS;
> +
> +#define IS(name) (len == sizeof(name) - 1 && !memcmp(template, name, sizeof(name) - 1))
> +
> +            /* Substitute template argument. */
> +            if (IS("RepresentationID")) {
> +                memcpy(u, $RepresentationID$, $RepresentationID$_size);
> +                u += $RepresentationID$_size;
> +            } else if (IS("Time")) {
> +                u += sprintf(u, "%0*"PRId64, digits, $Time$);
> +            } else if (IS("Bandwidth")) {
> +                u += sprintf(u, "%0*"PRIu32, digits, $Bandwidth$);
> +            } else if (IS("Number")) {
> +                u += sprintf(u, "%0*"PRIu64, digits, $Number$);
> +            } else if (IS("")) {
> +                *u++ = '$';
>              }
> -        }
> -    }
>
> -    if (val)
> -        ff_make_absolute_url(tmp_str, max_url_size, tmp_str, val);
> +#undef IS
>
> -    if (rep_id_val) {
> -        url = av_strireplace(tmp_str, "$RepresentationID$", rep_id_val);
> -        if (!url) {
> -            goto end;
> +            /* Go over $. */
> +            if ((template = strchr(template + len, '$')))
> +                ++template;
> +        } else {
> +            /* Copy remaining. */
> +            strcpy(u, template);
> +            break;
>          }
> -        av_strlcpy(tmp_str, url, max_url_size);
>      }
> -    if (rep_bandwidth_val && tmp_str[0] != '\0') {
> -        // free any previously assigned url before reassigning
> -        av_free(url);
> -        url = av_strireplace(tmp_str, "$Bandwidth$", rep_bandwidth_val);
> -        if (!url) {
> -            goto end;
> -        }
> -    }
> -end:
> -    av_free(tmp_str);
> +
>      return url;
>  }
>
> -static char *get_val_from_nodes_tab(xmlNodePtr *nodes, const int n_nodes, const char *attrname)
> +static int64_t dash_subdemuxer_seek(void *opaque, int64_t offset, int whence)
>  {
> -    int i;
> -    char *val;
> -
> -    for (i = 0; i < n_nodes; ++i) {
> -        if (nodes[i]) {
> -            val = xmlGetProp(nodes[i], attrname);
> -            if (val)
> -                return val;
> -        }
> -    }
> -
> -    return NULL;
> +    DASHRepresentation *rep = opaque;
> +    return avio_seek(rep->segments[0].pb, offset, whence);
>  }
>
> -static xmlNodePtr find_child_node_by_name(xmlNodePtr rootnode, const char *nodename)
> +static av_cold int dash_copy_stream_props(AVStream *slave, AVStream *master)
>  {
> -    xmlNodePtr node = rootnode;
> -    if (!node) {
> -        return NULL;
> -    }
> +    int ret;
>
> -    node = xmlFirstElementChild(node);
> -    while (node) {
> -        if (!av_strcasecmp(node->name, nodename)) {
> -            return node;
> -        }
> -        node = xmlNextElementSibling(node);
> -    }
> -    return NULL;
> +    master->event_flags &= ~AVSTREAM_EVENT_FLAG_METADATA_UPDATED;
> +    slave->event_flags |= AVSTREAM_EVENT_FLAG_METADATA_UPDATED;
> +
> +    slave->internal->need_context_update = 1;
> +
> +    if ((ret = ff_stream_encode_params_copy(slave, master)) < 0)
> +        return ret;
> +
> +    /* Only for probed context (oc->iformat != NULL). */
> +    if (master->time_base.den)
> +        avpriv_set_pts_info(slave, master->pts_wrap_bits,
> +                            master->time_base.num, master->time_base.den);
> +
> +    return 0;
>  }
>
> -static enum AVMediaType get_content_type(xmlNodePtr node)
> +static av_cold DASHRepresentationPeriod *dash_find_representation_period_at(
> +        DASHRepresentation *rep, int64_t timestamp)
>  {
> -    enum AVMediaType type = AVMEDIA_TYPE_UNKNOWN;
> -    int i = 0;
> -    const char *attr;
> -    char *val = NULL;
> -
> -    if (node) {
> -        for (i = 0; i < 2; i++) {
> -            attr = i ? "mimeType" : "contentType";
> -            val = xmlGetProp(node, attr);
> -            if (val) {
> -                if (av_stristr(val, "video")) {
> -                    type = AVMEDIA_TYPE_VIDEO;
> -                } else if (av_stristr(val, "audio")) {
> -                    type = AVMEDIA_TYPE_AUDIO;
> -                } else if (av_stristr(val, "text")) {
> -                    type = AVMEDIA_TYPE_SUBTITLE;
> -                }
> -                xmlFree(val);
> -            }
> -        }
> +    for (unsigned i = 0; i < rep->nb_periods; ++i) {
> +        DASHRepresentationPeriod *period = rep->periods[i];
> +        if (period->period->start_ts <= timestamp &&
> +                                        timestamp < period->period->end_ts)
> +            return period;
>      }
> -    return type;
> +
> +    return NULL;
>  }
>
> -static struct fragment * get_Fragment(char *range)
> +/**
> + * Update everything to make outside context of representation.
> + *
> + * Must be called after:
> + * - rep->ic->streams changed,
> + * - rep->cur_period changed.
> + */
> +static av_cold int dash_subdemuxer_update(DASHRepresentation *rep)
>  {
> -    struct fragment * seg =  av_mallocz(sizeof(struct fragment));
> -
> -    if (!seg)
> -        return NULL;
> +    int ret;
> +    void *p;
> +    AVFormatContext *oc = rep->oc;
> +    AVFormatContext *ic = rep->ic;
>
> -    seg->size = -1;
> -    if (range) {
> -        char *str_end_offset;
> -        char *str_offset = av_strtok(range, "-", &str_end_offset);
> -        seg->url_offset = strtoll(str_offset, NULL, 10);
> -        seg->size = strtoll(str_end_offset, NULL, 10) - seg->url_offset + 1;
> +    if (rep->nb_streams < ic->nb_streams) {
> +        if (!(p = av_realloc(rep->ostreams, ic->nb_streams * sizeof(*rep->ostreams))))
> +            return AVERROR(ENOMEM);
> +        rep->ostreams = p;
>      }
>
> -    return seg;
> -}
> +    rep->ic->event_flags &= ~AVFMT_EVENT_FLAG_METADATA_UPDATED;
> +    rep->oc->event_flags |= AVFMT_EVENT_FLAG_METADATA_UPDATED;
>
> -static int parse_manifest_segmenturlnode(AVFormatContext *s, struct representation *rep,
> -                                         xmlNodePtr fragmenturl_node,
> -                                         xmlNodePtr *baseurl_nodes,
> -                                         char *rep_id_val,
> -                                         char *rep_bandwidth_val)
> -{
> -    DASHContext *c = s->priv_data;
> -    char *initialization_val = NULL;
> -    char *media_val = NULL;
> -    char *range_val = NULL;
> -    int max_url_size = c ? c->max_url_size: MAX_URL_SIZE;
> -    int err;
> -
> -    if (!av_strcasecmp(fragmenturl_node->name, "Initialization")) {
> -        initialization_val = xmlGetProp(fragmenturl_node, "sourceURL");
> -        range_val = xmlGetProp(fragmenturl_node, "range");
> -        if (initialization_val || range_val) {
> -            free_fragment(&rep->init_section);
> -            rep->init_section = get_Fragment(range_val);
> -            xmlFree(range_val);
> -            if (!rep->init_section) {
> -                xmlFree(initialization_val);
> -                return AVERROR(ENOMEM);
> -            }
> -            rep->init_section->url = get_content_url(baseurl_nodes, 4,
> -                                                     max_url_size,
> -                                                     rep_id_val,
> -                                                     rep_bandwidth_val,
> -                                                     initialization_val);
> -            xmlFree(initialization_val);
> -            if (!rep->init_section->url) {
> -                av_freep(&rep->init_section);
> +    for (unsigned stream_index = 0;
> +         stream_index < ic->nb_streams;
> +         stream_index++)
> +    {
> +        AVStream *ist, *ost;
> +        DASHRepresentationPeriod *period;
> +        AVDictionary *metadata = NULL;
> +
> +        ist = ic->streams[stream_index];
> +
> +        if (stream_index < rep->nb_streams) {
> +            ost = rep->ostreams[stream_index];
> +        } else {
> +            ost = avformat_new_stream(oc, NULL);
> +            if (!ost)
>                  return AVERROR(ENOMEM);
> -            }
> +
> +            rep->ostreams[stream_index] = ost;
>          }
> -    } else if (!av_strcasecmp(fragmenturl_node->name, "SegmentURL")) {
> -        media_val = xmlGetProp(fragmenturl_node, "media");
> -        range_val = xmlGetProp(fragmenturl_node, "mediaRange");
> -        if (media_val || range_val) {
> -            struct fragment *seg = get_Fragment(range_val);
> -            xmlFree(range_val);
> -            if (!seg) {
> -                xmlFree(media_val);
> -                return AVERROR(ENOMEM);
> -            }
> -            seg->url = get_content_url(baseurl_nodes, 4,
> -                                       max_url_size,
> -                                       rep_id_val,
> -                                       rep_bandwidth_val,
> -                                       media_val);
> -            xmlFree(media_val);
> -            if (!seg->url) {
> -                av_free(seg);
> +
> +        av_log(oc, AV_LOG_VERBOSE,
> +               "Match '%s', stream #%u -> DASH stream #%u\n",
> +               rep->id, stream_index, ost->index);
> +
> +        /* Period specific metadata. */
> +        period = rep->cur_period;
> +        /* For inactive representations compute where we would be. */
> +        if (!period)
> +            period = dash_find_representation_period_at(rep, rep->read_ts);
> +        if (period) {
> +            const DASHParameters *par = &period->par;
> +            uint8_t *side_data;
> +            int side_data_size;
> +
> +            side_data = av_encryption_init_info_add_side_data(period->as->init_info, &side_data_size);
> +            if (!side_data)
>                  return AVERROR(ENOMEM);
> +
> +            ret = av_stream_add_side_data(ist, AV_PKT_DATA_ENCRYPTION_INIT_INFO,
> +                                          side_data, side_data_size);
> +            if (ret < 0) {
> +                av_free(side_data);
> +                return ret;
>              }
> -            err = av_dynarray_add_nofree(&rep->fragments, &rep->n_fragments, seg);
> -            if (err < 0) {
> -                free_fragment(&seg);
> -                return err;
> +
> +            av_dict_set_int(&metadata, "variant_bitrate", period->bandwidth, AV_DICT_MULTIKEY);
> +
> +            /* AdaptationSet specific metadata. */
> +            av_dict_copy(&metadata, period->as->metadata, AV_DICT_MULTIKEY);
> +
> +            /* Most parameters are only relevant for elementary streams. */
> +            if (rep->ic->nb_streams == 1) {
> +                AVCodecParameters *codecpar = ist->codecpar;
> +
> +                /* Set unknown parameters for manifest. */
> +
> +                if (codecpar->codec_type == AVMEDIA_TYPE_UNKNOWN)
> +                    codecpar->codec_type = par->codec_type;
> +
> +                if (codecpar->codec_id == AV_CODEC_ID_NONE)
> +                    codecpar->codec_id = par->codec_id;
> +
> +                if (!codecpar->sample_rate)
> +                    codecpar->sample_rate = par->sample_rate;
> +
> +                if (!codecpar->channels && !codecpar->channel_layout)
> +                    codecpar->channels = par->channels,
> +                    codecpar->channel_layout = par->channel_layout;
> +
> +                if (!codecpar->width && !codecpar->height)
> +                    codecpar->width = par->width,
> +                    codecpar->height = par->height;
> +
> +                if (!ist->avg_frame_rate.num)
> +                    ist->avg_frame_rate = par->frame_rate;
> +                if (!ist->r_frame_rate.num)
> +                    ist->r_frame_rate = par->frame_rate;
> +
> +                if (!codecpar->sample_aspect_ratio.num)
> +                    codecpar->sample_aspect_ratio = par->sample_aspect_ratio;
> +
> +                if (codecpar->field_order == AV_FIELD_UNKNOWN)
> +                    codecpar->field_order = par->field_order;
>              }
> +
> +            ist->disposition = par->disposition;
> +        }
> +
> +        /* Representation specific metadata. */
> +        av_dict_set(&metadata, "id", rep->id, AV_DICT_MULTIKEY);
> +
> +        /* RepresentationPeriod (stream) specific metadata. */
> +        if ((ret = dash_copy_stream_props(ost, ist)) < 0) {
> +            av_dict_free(&metadata);
> +            return ret;
>          }
> +
> +        av_dict_copy(&ost->metadata, metadata, AV_DICT_MULTIKEY);
> +        av_dict_free(&metadata);
> +    }
> +
> +    for (unsigned stream_index = ic->nb_streams;
> +         stream_index < rep->nb_streams;
> +         stream_index++)
> +    {
> +        AVStream *ist, *ost;
> +
> +        /* Dummy format with no streams. */
> +        if (!ic->streams)
> +            break;
> +
> +        ist = ic->streams[stream_index];
> +        ost = rep->ostreams[stream_index];
> +
> +        /* Reset codec parameters. */
> +        avcodec_parameters_free(&ist->codecpar);
> +        ist->codecpar = avcodec_parameters_alloc();
> +        if (!ist->codecpar)
> +            return AVERROR(ENOMEM);
> +
> +        if ((ret = dash_copy_stream_props(ost, ist)) < 0)
> +            return ret;
>      }
>
> +    rep->nb_streams = FFMAX(rep->nb_streams, ic->nb_streams);
> +
>      return 0;
>  }
>
> -static int parse_manifest_segmenttimeline(AVFormatContext *s, struct representation *rep,
> -                                          xmlNodePtr fragment_timeline_node)
> +static void dash_rotate_urllist(AVFormatContext *s, DASHURLList *urls)
>  {
> -    xmlAttrPtr attr = NULL;
> -    char *val  = NULL;
> -    int err;
> +    DASHContext *c = s->priv_data;
>
> -    if (!av_strcasecmp(fragment_timeline_node->name, "S")) {
> -        struct timeline *tml = av_mallocz(sizeof(struct timeline));
> -        if (!tml) {
> -            return AVERROR(ENOMEM);
> -        }
> -        attr = fragment_timeline_node->properties;
> -        while (attr) {
> -            val = xmlGetProp(fragment_timeline_node, attr->name);
> +    if (1 < urls->nb) {
> +        unsigned const i = 1 + av_lfg_get(&c->rnd) % (urls->nb - 1);
> +        char *tmp     = urls->elems[i];
> +        urls->elems[i] = urls->elems[0];
> +        urls->elems[0] = tmp;
> +    }
> +}
>
> -            if (!val) {
> -                av_log(s, AV_LOG_WARNING, "parse_manifest_segmenttimeline attr->name = %s val is NULL\n", attr->name);
> +static int dash_subdemuxer_read(void *opaque, uint8_t *buf, int buf_size)
> +{
> +    int ret;
> +    DASHRepresentation *rep = opaque;
> +    AVFormatContext *s = rep->oc;
> +    DASHContext *c = s->priv_data;
> +    int size;
> +    unsigned seg = rep->cur_segment;
> +
> +open_segment:;
> +    do {
> +        DASHRepresentationPeriod *period;
> +        char *url;
> +        const char *base;
> +        const char *template;
> +        uint64_t $Number$;
> +        int64_t $Time$;
> +        DASHRange range;
> +        AVDictionary *opts;
> +#if CONFIG_HTTP_PROTOCOL
> +        URLContext *uc;
> +#endif
> +
> +        if (rep->segments[seg].pb &&
> +            !rep->segments[seg].pb->eof_reached)
> +            continue;
> +
> +        for (unsigned i = 0; i < rep->nb_periods; ++i) {
> +            int64_t period_ts;
> +            DASHTimeline *timeline;
> +
> +            period = rep->periods[i];
> +            timeline = period->timeline;
> +
> +            /* Check if we are inside Period boundaries. */
> +            if (!(period->period->start_ts <= rep->read_ts &&
> +                                              rep->read_ts < period->period->end_ts))
>                  continue;
> -            }
>
> -            if (!av_strcasecmp(attr->name, "t")) {
> -                tml->starttime = (int64_t)strtoll(val, NULL, 10);
> -            } else if (!av_strcasecmp(attr->name, "r")) {
> -                tml->repeat =(int64_t) strtoll(val, NULL, 10);
> -            } else if (!av_strcasecmp(attr->name, "d")) {
> -                tml->duration = (int64_t)strtoll(val, NULL, 10);
> -            }
> -            attr = attr->next;
> -            xmlFree(val);
> -        }
> -        err = av_dynarray_add_nofree(&rep->timelines, &rep->n_timelines, tml);
> -        if (err < 0) {
> -            av_free(tml);
> -            return err;
> -        }
> -    }
> +            /* period_ts := read_ts relative to Period start. */
> +            period_ts = av_rescale_q_rnd(rep->read_ts - period->period->start_ts,
> +                                         AV_TIME_BASE_Q,
> +                                         (AVRational){ 1, timeline->timescale },
> +                                         AV_ROUND_UP);
>
> -    return 0;
> -}
> +            if (timeline->type == TIMELINE_TEMPLATES) {
> +                for (unsigned j = 0; j < timeline->u.templates.nb; ++j) {
> +                    DASHSegmentTemplate *g = &timeline->u.templates.elems[j];
> +                    int64_t end_time = g->repeat < 0 || INT64_MAX / (g->repeat + 1) < g->duration
> +                        ? INT64_MAX
> +                        : g->start_ts + g->duration * (g->repeat + 1);
> +                    end_time = FFMIN(end_time, timeline->duration);
>
> -static int resolve_content_path(AVFormatContext *s, const char *url, int *max_url_size, xmlNodePtr *baseurl_nodes, int n_baseurl_nodes)
> -{
> -    char *tmp_str = NULL;
> -    char *path = NULL;
> -    char *mpdName = NULL;
> -    xmlNodePtr node = NULL;
> -    char *baseurl = NULL;
> -    char *root_url = NULL;
> -    char *text = NULL;
> -    char *tmp = NULL;
> -    int isRootHttp = 0;
> -    char token ='/';
> -    int start =  0;
> -    int rootId = 0;
> -    int updated = 0;
> -    int size = 0;
> -    int i;
> -    int tmp_max_url_size = strlen(url);
> +                    if (period_ts < g->start_ts) {
> +                        /* Gap detected: Missing segments in timeline. */
> +                    }
>
> -    for (i = n_baseurl_nodes-1; i >= 0 ; i--) {
> -        text = xmlNodeGetContent(baseurl_nodes[i]);
> -        if (!text)
> -            continue;
> -        tmp_max_url_size += strlen(text);
> -        if (ishttp(text)) {
> -            xmlFree(text);
> -            break;
> -        }
> -        xmlFree(text);
> -    }
> +                    if (period_ts < end_time) {
> +#if 0
> +                        av_log(rep->oc, AV_LOG_TRACE, "S@[n=%"PRId64" d*r=%"PRId64"*%"PRId64"]: %"PRId64" <= %"PRId64" <= %"PRId64"?\n",
> +                               g->number, g->duration, g->repeat, g->start_ts, period_ts, end_time);
> +#endif
>
> -    tmp_max_url_size = aligned(tmp_max_url_size);
> -    text = av_mallocz(tmp_max_url_size);
> -    if (!text) {
> -        updated = AVERROR(ENOMEM);
> -        goto end;
> -    }
> -    av_strlcpy(text, url, strlen(url)+1);
> -    tmp = text;
> -    while (mpdName = av_strtok(tmp, "/", &tmp))  {
> -        size = strlen(mpdName);
> -    }
> -    av_free(text);
> +                        /* If period changed push init section first. */
> +                        if (rep->cur_period != period) {
> +                            if (seg != rep->cur_segment)
> +                                goto read_segment;
>
> -    path = av_mallocz(tmp_max_url_size);
> -    tmp_str = av_mallocz(tmp_max_url_size);
> -    if (!tmp_str || !path) {
> -        updated = AVERROR(ENOMEM);
> -        goto end;
> -    }
> +                            if (!rep->save_init) {
> +                                rep->save_init = 1;
>
> -    av_strlcpy (path, url, strlen(url) - size + 1);
> -    for (rootId = n_baseurl_nodes - 1; rootId > 0; rootId --) {
> -        if (!(node = baseurl_nodes[rootId])) {
> -            continue;
> -        }
> -        text = xmlNodeGetContent(node);
> -        if (ishttp(text)) {
> -            xmlFree(text);
> -            break;
> -        }
> -        xmlFree(text);
> -    }
> +                                /* Send out stored part. */
> +                                if (0 < period->initbuf_size) {
> +                                    memcpy(buf, period->initbuf, period->initbuf_size);
> +                                    return period->initbuf_size;
> +                                }
> +                            }
>
> -    node = baseurl_nodes[rootId];
> -    baseurl = xmlNodeGetContent(node);
> -    root_url = (av_strcasecmp(baseurl, "")) ? baseurl : path;
> -    if (node) {
> -        xmlNodeSetContent(node, root_url);
> -        updated = 1;
> -    }
> +                            rep->cur_period = period;
> +                            ret = dash_subdemuxer_update(rep);
> +                            if (ret < 0)
> +                                return ret;
>
> -    size = strlen(root_url);
> -    isRootHttp = ishttp(root_url);
> +                            range = timeline->init.range;
> +                            range.start += period->initbuf_size;
>
> -    if (size > 0 && root_url[size - 1] != token) {
> -        av_strlcat(root_url, "/", size + 2);
> -        size += 2;
> -    }
> +                            /* Test whether full segment is stored and thus
> +                             * previously has been sent out. */
> +                            if (0 < period->initbuf_size &&
> +                                (period->initbuf_size < INITBUF_MAX ||
> +                                 range.end <= range.start))
> +                            {
> +                                rep->save_init = 0;
> +                                continue;
> +                            }
>
> -    for (i = 0; i < n_baseurl_nodes; ++i) {
> -        if (i == rootId) {
> -            continue;
> -        }
> -        text = xmlNodeGetContent(baseurl_nodes[i]);
> -        if (text && !av_strstart(text, "/", NULL)) {
> -            memset(tmp_str, 0, strlen(tmp_str));
> -            if (!ishttp(text) && isRootHttp) {
> -                av_strlcpy(tmp_str, root_url, size + 1);
> -            }
> -            start = (text[0] == token);
> -            if (start && av_stristr(tmp_str, text)) {
> -                char *p = tmp_str;
> -                if (!av_strncasecmp(tmp_str, "http://", 7)) {
> -                    p += 7;
> -                } else if (!av_strncasecmp(tmp_str, "https://", 8)) {
> -                    p += 8;
> +                            $Time$ = 0, $Number$ = 0; /* They should not be used in template URL. */
> +                            template = timeline->init.url;
> +                        } else {
> +                            uint64_t r = (period_ts - g->start_ts) / g->duration;
> +                            $Time$ = g->start_ts + g->duration * r;
> +                            $Number$ = g->number + r;
> +                            template = timeline->u.templates.master.url;
> +                            range = timeline->u.templates.master.range;
> +
> +                            rep->read_ts = av_rescale_q_rnd($Time$ + g->duration,
> +                                                            (AVRational){ 1, timeline->timescale },
> +                                                            AV_TIME_BASE_Q,
> +                                                            AV_ROUND_UP);
> +
> +                            /* Wait until segment becomes available. */
> +                            if (c->is_live) {
> +                                int64_t time_shift = rep->read_ts - c->availability_start_time;
> +                                if (time_shift < 0) {
> +                                    /* Allow suspending thread only when it is really neccessary, i.e. we have no other segments to serve. */
> +                                    if (seg == rep->cur_segment)
> +                                        av_usleep(-time_shift);
> +                                    else
> +                                        goto read_segment;
> +                                }
> +                            }
> +                        }
> +                        base = period->base->elems[0];
> +
> +                        goto found;
> +                    }
>                  }
> -                p = strchr(p, '/');
> -                memset(p + 1, 0, strlen(p));
> -            }
> -            av_strlcat(tmp_str, text + start, tmp_max_url_size);
> -            xmlNodeSetContent(baseurl_nodes[i], tmp_str);
> -            updated = 1;
> -            xmlFree(text);
> -        }
> -    }
> -
> -end:
> -    if (tmp_max_url_size > *max_url_size) {
> -        *max_url_size = tmp_max_url_size;
> -    }
> -    av_free(path);
> -    av_free(tmp_str);
> -    xmlFree(baseurl);
> -    return updated;
> -
> -}
> -
> -static int parse_manifest_representation(AVFormatContext *s, const char *url,
> -                                         xmlNodePtr node,
> -                                         xmlNodePtr adaptionset_node,
> -                                         xmlNodePtr mpd_baseurl_node,
> -                                         xmlNodePtr period_baseurl_node,
> -                                         xmlNodePtr period_segmenttemplate_node,
> -                                         xmlNodePtr period_segmentlist_node,
> -                                         xmlNodePtr fragment_template_node,
> -                                         xmlNodePtr content_component_node,
> -                                         xmlNodePtr adaptionset_baseurl_node,
> -                                         xmlNodePtr adaptionset_segmentlist_node,
> -                                         xmlNodePtr adaptionset_supplementalproperty_node)
> -{
> -    int32_t ret = 0;
> -    DASHContext *c = s->priv_data;
> -    struct representation *rep = NULL;
> -    struct fragment *seg = NULL;
> -    xmlNodePtr representation_segmenttemplate_node = NULL;
> -    xmlNodePtr representation_baseurl_node = NULL;
> -    xmlNodePtr representation_segmentlist_node = NULL;
> -    xmlNodePtr segmentlists_tab[3];
> -    xmlNodePtr fragment_timeline_node = NULL;
> -    xmlNodePtr fragment_templates_tab[5];
> -    char *val = NULL;
> -    xmlNodePtr baseurl_nodes[4];
> -    xmlNodePtr representation_node = node;
> -    char *rep_bandwidth_val;
> -    enum AVMediaType type = AVMEDIA_TYPE_UNKNOWN;
> -
> -    // try get information from representation
> -    if (type == AVMEDIA_TYPE_UNKNOWN)
> -        type = get_content_type(representation_node);
> -    // try get information from contentComponen
> -    if (type == AVMEDIA_TYPE_UNKNOWN)
> -        type = get_content_type(content_component_node);
> -    // try get information from adaption set
> -    if (type == AVMEDIA_TYPE_UNKNOWN)
> -        type = get_content_type(adaptionset_node);
> -    if (type != AVMEDIA_TYPE_VIDEO && type != AVMEDIA_TYPE_AUDIO &&
> -        type != AVMEDIA_TYPE_SUBTITLE) {
> -        av_log(s, AV_LOG_VERBOSE, "Parsing '%s' - skipp not supported representation type\n", url);
> -        return 0;
> -    }
> -
> -    // convert selected representation to our internal struct
> -    rep = av_mallocz(sizeof(struct representation));
> -    if (!rep)
> -        return AVERROR(ENOMEM);
> -    if (c->adaptionset_lang) {
> -        rep->lang = av_strdup(c->adaptionset_lang);
> -        if (!rep->lang) {
> -            av_log(s, AV_LOG_ERROR, "alloc language memory failure\n");
> -            av_freep(&rep);
> -            return AVERROR(ENOMEM);
> -        }
> -    }
> -    rep->parent = s;
> -    representation_segmenttemplate_node = find_child_node_by_name(representation_node, "SegmentTemplate");
> -    representation_baseurl_node = find_child_node_by_name(representation_node, "BaseURL");
> -    representation_segmentlist_node = find_child_node_by_name(representation_node, "SegmentList");
> -    rep_bandwidth_val = xmlGetProp(representation_node, "bandwidth");
> -    val               = xmlGetProp(representation_node, "id");
> -    if (val) {
> -        rep->id = av_strdup(val);
> -        xmlFree(val);
> -        if (!rep->id)
> -            goto enomem;
> -    }
> -
> -    baseurl_nodes[0] = mpd_baseurl_node;
> -    baseurl_nodes[1] = period_baseurl_node;
> -    baseurl_nodes[2] = adaptionset_baseurl_node;
> -    baseurl_nodes[3] = representation_baseurl_node;
> -
> -    ret = resolve_content_path(s, url, &c->max_url_size, baseurl_nodes, 4);
> -    c->max_url_size = aligned(c->max_url_size
> -                              + (rep->id ? strlen(rep->id) : 0)
> -                              + (rep_bandwidth_val ? strlen(rep_bandwidth_val) : 0));
> -    if (ret == AVERROR(ENOMEM) || ret == 0)
> -        goto free;
> -    if (representation_segmenttemplate_node || fragment_template_node || period_segmenttemplate_node) {
> -        fragment_timeline_node = NULL;
> -        fragment_templates_tab[0] = representation_segmenttemplate_node;
> -        fragment_templates_tab[1] = adaptionset_segmentlist_node;
> -        fragment_templates_tab[2] = fragment_template_node;
> -        fragment_templates_tab[3] = period_segmenttemplate_node;
> -        fragment_templates_tab[4] = period_segmentlist_node;
> -
> -        val = get_val_from_nodes_tab(fragment_templates_tab, 4, "initialization");
> -        if (val) {
> -            rep->init_section = av_mallocz(sizeof(struct fragment));
> -            if (!rep->init_section) {
> -                xmlFree(val);
> -                goto enomem;
> -            }
> -            c->max_url_size = aligned(c->max_url_size  + strlen(val));
> -            rep->init_section->url = get_content_url(baseurl_nodes, 4,
> -                                                     c->max_url_size, rep->id,
> -                                                     rep_bandwidth_val, val);
> -            xmlFree(val);
> -            if (!rep->init_section->url)
> -                goto enomem;
> -            rep->init_section->size = -1;
> -        }
> -        val = get_val_from_nodes_tab(fragment_templates_tab, 4, "media");
> -        if (val) {
> -            c->max_url_size = aligned(c->max_url_size  + strlen(val));
> -            rep->url_template = get_content_url(baseurl_nodes, 4,
> -                                                c->max_url_size, rep->id,
> -                                                rep_bandwidth_val, val);
> -            xmlFree(val);
> -        }
> -        val = get_val_from_nodes_tab(fragment_templates_tab, 4, "presentationTimeOffset");
> -        if (val) {
> -            rep->presentation_timeoffset = (int64_t) strtoll(val, NULL, 10);
> -            av_log(s, AV_LOG_TRACE, "rep->presentation_timeoffset = [%"PRId64"]\n", rep->presentation_timeoffset);
> -            xmlFree(val);
> -        }
> -        val = get_val_from_nodes_tab(fragment_templates_tab, 4, "duration");
> -        if (val) {
> -            rep->fragment_duration = (int64_t) strtoll(val, NULL, 10);
> -            av_log(s, AV_LOG_TRACE, "rep->fragment_duration = [%"PRId64"]\n", rep->fragment_duration);
> -            xmlFree(val);
> -        }
> -        val = get_val_from_nodes_tab(fragment_templates_tab, 4, "timescale");
> -        if (val) {
> -            rep->fragment_timescale = (int64_t) strtoll(val, NULL, 10);
> -            av_log(s, AV_LOG_TRACE, "rep->fragment_timescale = [%"PRId64"]\n", rep->fragment_timescale);
> -            xmlFree(val);
> -        }
> -        val = get_val_from_nodes_tab(fragment_templates_tab, 4, "startNumber");
> -        if (val) {
> -            rep->start_number = rep->first_seq_no = (int64_t) strtoll(val, NULL, 10);
> -            av_log(s, AV_LOG_TRACE, "rep->first_seq_no = [%"PRId64"]\n", rep->first_seq_no);
> -            xmlFree(val);
> -        }
> -        if (adaptionset_supplementalproperty_node) {
> -            if (!av_strcasecmp(xmlGetProp(adaptionset_supplementalproperty_node,"schemeIdUri"), "http://dashif.org/guidelines/last-segment-number")) {
> -                val = xmlGetProp(adaptionset_supplementalproperty_node,"value");
> -                if (!val) {
> -                    av_log(s, AV_LOG_ERROR, "Missing value attribute in adaptionset_supplementalproperty_node\n");
> +            } else if (timeline->type == TIMELINE_SEGMENTS) {
> +                DASHSegment *g;
> +
> +                if (rep->cur_period != period) {
> +                    if (seg != rep->cur_segment)
> +                        goto read_segment;
> +
> +                    rep->cur_period = period;
> +                    ret = dash_subdemuxer_update(rep);
> +                    if (ret < 0)
> +                        return ret;
> +
> +                    g = &timeline->init;
> +                } else if (0 < timeline->u.segments.nb) {
> +                    int64_t segment_ts = timeline->duration / timeline->u.segments.nb;
> +                    g = &timeline->u.segments.elems[period_ts / segment_ts];
>                  } else {
> -                    rep->last_seq_no =(int64_t) strtoll(val, NULL, 10) - 1;
> -                    xmlFree(val);
> +                    /* One segment timeline. */
> +                    continue;
>                  }
> -            }
> -        }
>
> -        fragment_timeline_node = find_child_node_by_name(representation_segmenttemplate_node, "SegmentTimeline");
> +                base = period->base->elems[0];
> +                template = g->url; /* HACK: URL is not template. */
> +                range = g->range;
>
> -        if (!fragment_timeline_node)
> -            fragment_timeline_node = find_child_node_by_name(fragment_template_node, "SegmentTimeline");
> -        if (!fragment_timeline_node)
> -            fragment_timeline_node = find_child_node_by_name(adaptionset_segmentlist_node, "SegmentTimeline");
> -        if (!fragment_timeline_node)
> -            fragment_timeline_node = find_child_node_by_name(period_segmentlist_node, "SegmentTimeline");
> -        if (fragment_timeline_node) {
> -            fragment_timeline_node = xmlFirstElementChild(fragment_timeline_node);
> -            while (fragment_timeline_node) {
> -                ret = parse_manifest_segmenttimeline(s, rep, fragment_timeline_node);
> -                if (ret < 0)
> -                    goto free;
> -                fragment_timeline_node = xmlNextElementSibling(fragment_timeline_node);
> +                goto found;
> +            } else {
> +                abort();
>              }
> -        }
> -    } else if (representation_baseurl_node && !representation_segmentlist_node) {
> -        seg = av_mallocz(sizeof(struct fragment));
> -        if (!seg)
> -            goto enomem;
> -        ret = av_dynarray_add_nofree(&rep->fragments, &rep->n_fragments, seg);
> -        if (ret < 0) {
> -            av_free(seg);
> -            goto free;
> -        }
> -        seg->url = get_content_url(baseurl_nodes, 4, c->max_url_size,
> -                                   rep->id, rep_bandwidth_val, NULL);
> -        if (!seg->url)
> -            goto enomem;
> -        seg->size = -1;
> -    } else if (representation_segmentlist_node) {
> -        // TODO: https://www.brendanlong.com/the-structure-of-an-mpeg-dash-mpd.html
> -        // http://www-itec.uni-klu.ac.at/dash/ddash/mpdGenerator.php?fragmentlength=15&type=full
> -        xmlNodePtr fragmenturl_node = NULL;
> -        segmentlists_tab[0] = representation_segmentlist_node;
> -        segmentlists_tab[1] = adaptionset_segmentlist_node;
> -        segmentlists_tab[2] = period_segmentlist_node;
>
> -        val = get_val_from_nodes_tab(segmentlists_tab, 3, "duration");
> -        if (val) {
> -            rep->fragment_duration = (int64_t) strtoll(val, NULL, 10);
> -            av_log(s, AV_LOG_TRACE, "rep->fragment_duration = [%"PRId64"]\n", rep->fragment_duration);
> -            xmlFree(val);
> -        }
> -        val = get_val_from_nodes_tab(segmentlists_tab, 3, "timescale");
> -        if (val) {
> -            rep->fragment_timescale = (int64_t) strtoll(val, NULL, 10);
> -            av_log(s, AV_LOG_TRACE, "rep->fragment_timescale = [%"PRId64"]\n", rep->fragment_timescale);
> -            xmlFree(val);
> -        }
> -        val = get_val_from_nodes_tab(segmentlists_tab, 3, "startNumber");
> -        if (val) {
> -            rep->start_number = rep->first_seq_no = (int64_t) strtoll(val, NULL, 10);
> -            av_log(s, AV_LOG_TRACE, "rep->first_seq_no = [%"PRId64"]\n", rep->first_seq_no);
> -            xmlFree(val);
> -        }
> +            /* Gap detected: No more segments till end of the period. Jump to
> +             * the end of the period. */
> +            rep->read_ts = period->period->end_ts;
>
> -        fragmenturl_node = xmlFirstElementChild(representation_segmentlist_node);
> -        while (fragmenturl_node) {
> -            ret = parse_manifest_segmenturlnode(s, rep, fragmenturl_node,
> -                                                baseurl_nodes, rep->id,
> -                                                rep_bandwidth_val);
> -            if (ret < 0)
> -                goto free;
> -            fragmenturl_node = xmlNextElementSibling(fragmenturl_node);
> +            /* Periods may be out-of-order so start searching next one from the beginning. */
> +            i = 0;
>          }
>
> -        fragment_timeline_node = find_child_node_by_name(adaptionset_segmentlist_node, "SegmentTimeline");
> -        if (!fragment_timeline_node)
> -            fragment_timeline_node = find_child_node_by_name(period_segmentlist_node, "SegmentTimeline");
> -        if (fragment_timeline_node) {
> -            fragment_timeline_node = xmlFirstElementChild(fragment_timeline_node);
> -            while (fragment_timeline_node) {
> -                ret = parse_manifest_segmenttimeline(s, rep, fragment_timeline_node);
> -                if (ret < 0)
> -                    goto free;
> -                fragment_timeline_node = xmlNextElementSibling(fragment_timeline_node);
> -            }
> -        }
> -    } else {
> -        av_log(s, AV_LOG_ERROR, "Unknown format of Representation node id '%s' \n",
> -               rep->id ? rep->id : "");
> -        goto free;
> -    }
> +        if (seg == rep->cur_segment)
> +            return AVERROR_EOF;
> +        else
> +            goto read_segment;
>
> -    if (rep->fragment_duration > 0 && !rep->fragment_timescale)
> -        rep->fragment_timescale = 1;
> -    rep->bandwidth = rep_bandwidth_val ? atoi(rep_bandwidth_val) : 0;
> -    rep->framerate = av_make_q(0, 0);
> -    if (type == AVMEDIA_TYPE_VIDEO) {
> -        char *rep_framerate_val = xmlGetProp(representation_node, "frameRate");
> -        if (rep_framerate_val) {
> -            ret = av_parse_video_rate(&rep->framerate, rep_framerate_val);
> -            if (ret < 0)
> -                av_log(s, AV_LOG_VERBOSE, "Ignoring invalid frame rate '%s'\n", rep_framerate_val);
> -            xmlFree(rep_framerate_val);
> +    found:
> +        if (template) {
> +            url = dash_make_url(base, template, rep->id, $Number$, $Time$, period->bandwidth);
> +            if (!url)
> +                return AVERROR(ENOMEM);
> +        } else {
> +            url = (char *)base;
>          }
> -    }
> -
> -    switch (type) {
> -    case AVMEDIA_TYPE_VIDEO:
> -        ret = av_dynarray_add_nofree(&c->videos, &c->n_videos, rep);
> -        break;
> -    case AVMEDIA_TYPE_AUDIO:
> -        ret = av_dynarray_add_nofree(&c->audios, &c->n_audios, rep);
> -        break;
> -    case AVMEDIA_TYPE_SUBTITLE:
> -        ret = av_dynarray_add_nofree(&c->subtitles, &c->n_subtitles, rep);
> -        break;
> -    }
> -    if (ret < 0)
> -        goto free;
> -
> -end:
> -    if (rep_bandwidth_val)
> -        xmlFree(rep_bandwidth_val);
>
> -    return ret;
> -enomem:
> -    ret = AVERROR(ENOMEM);
> -free:
> -    free_representation(rep);
> -    goto end;
> -}
> +        opts = NULL;
>
> -static int parse_manifest_adaptationset_attr(AVFormatContext *s, xmlNodePtr adaptionset_node)
> -{
> -    DASHContext *c = s->priv_data;
> +        if (0 < range.start)
> +            av_dict_set_int(&opts, "offset", range.start, 0);
>
> -    if (!adaptionset_node) {
> -        av_log(s, AV_LOG_WARNING, "Cannot get AdaptionSet\n");
> -        return AVERROR(EINVAL);
> -    }
> -    c->adaptionset_lang = xmlGetProp(adaptionset_node, "lang");
> +        if (range.end < INT64_MAX)
> +            av_dict_set_int(&opts, "end_offset", range.end, 0);
>
> -    return 0;
> -}
> +        av_dict_set(&opts, "multiple_requests", "1", 0);
> +        av_dict_copy(&opts, c->protocol_opts, 0);
>
> -static int parse_manifest_adaptationset(AVFormatContext *s, const char *url,
> -                                        xmlNodePtr adaptionset_node,
> -                                        xmlNodePtr mpd_baseurl_node,
> -                                        xmlNodePtr period_baseurl_node,
> -                                        xmlNodePtr period_segmenttemplate_node,
> -                                        xmlNodePtr period_segmentlist_node)
> -{
> -    int ret = 0;
> -    DASHContext *c = s->priv_data;
> -    xmlNodePtr fragment_template_node = NULL;
> -    xmlNodePtr content_component_node = NULL;
> -    xmlNodePtr adaptionset_baseurl_node = NULL;
> -    xmlNodePtr adaptionset_segmentlist_node = NULL;
> -    xmlNodePtr adaptionset_supplementalproperty_node = NULL;
> -    xmlNodePtr node = NULL;
> -
> -    ret = parse_manifest_adaptationset_attr(s, adaptionset_node);
> -    if (ret < 0)
> -        return ret;
> -
> -    node = xmlFirstElementChild(adaptionset_node);
> -    while (node) {
> -        if (!av_strcasecmp(node->name, "SegmentTemplate")) {
> -            fragment_template_node = node;
> -        } else if (!av_strcasecmp(node->name, "ContentComponent")) {
> -            content_component_node = node;
> -        } else if (!av_strcasecmp(node->name, "BaseURL")) {
> -            adaptionset_baseurl_node = node;
> -        } else if (!av_strcasecmp(node->name, "SegmentList")) {
> -            adaptionset_segmentlist_node = node;
> -        } else if (!av_strcasecmp(node->name, "SupplementalProperty")) {
> -            adaptionset_supplementalproperty_node = node;
> -        } else if (!av_strcasecmp(node->name, "Representation")) {
> -            ret = parse_manifest_representation(s, url, node,
> -                                                adaptionset_node,
> -                                                mpd_baseurl_node,
> -                                                period_baseurl_node,
> -                                                period_segmenttemplate_node,
> -                                                period_segmentlist_node,
> -                                                fragment_template_node,
> -                                                content_component_node,
> -                                                adaptionset_baseurl_node,
> -                                                adaptionset_segmentlist_node,
> -                                                adaptionset_supplementalproperty_node);
> -            if (ret < 0)
> -                goto err;
> +#if CONFIG_HTTP_PROTOCOL
> +        if (!(uc = ffio_geturlcontext(rep->segments[seg].pb)) ||
> +             (rep->segments[seg].pb->eof_reached = 0,
> +              rep->segments[seg].pb->pos = 0,
> +              (ret = ff_http_do_new_request2(uc, url, &opts)) < 0))
> +#endif
> +        {
> +            ff_format_io_close(s, &rep->segments[seg].pb);
> +            ret = s->io_open(s, &rep->segments[seg].pb, url, AVIO_FLAG_READ, &opts);
>          }
> -        node = xmlNextElementSibling(node);
> -    }
> -
> -err:
> -    xmlFree(c->adaptionset_lang);
> -    c->adaptionset_lang = NULL;
> -    return ret;
> -}
> -
> -static int parse_programinformation(AVFormatContext *s, xmlNodePtr node)
> -{
> -    xmlChar *val = NULL;
> -
> -    node = xmlFirstElementChild(node);
> -    while (node) {
> -        if (!av_strcasecmp(node->name, "Title")) {
> -            val = xmlNodeGetContent(node);
> -            if (val) {
> -                av_dict_set(&s->metadata, "Title", val, 0);
> -            }
> -        } else if (!av_strcasecmp(node->name, "Source")) {
> -            val = xmlNodeGetContent(node);
> -            if (val) {
> -                av_dict_set(&s->metadata, "Source", val, 0);
> -            }
> -        } else if (!av_strcasecmp(node->name, "Copyright")) {
> -            val = xmlNodeGetContent(node);
> -            if (val) {
> -                av_dict_set(&s->metadata, "Copyright", val, 0);
> -            }
> -        }
> -        node = xmlNextElementSibling(node);
> -        xmlFree(val);
> -        val = NULL;
> -    }
> -    return 0;
> -}
> -
> -static int parse_manifest(AVFormatContext *s, const char *url, AVIOContext *in)
> -{
> -    DASHContext *c = s->priv_data;
> -    int ret = 0;
> -    int close_in = 0;
> -    int64_t filesize = 0;
> -    AVBPrint buf;
> -    AVDictionary *opts = NULL;
> -    xmlDoc *doc = NULL;
> -    xmlNodePtr root_element = NULL;
> -    xmlNodePtr node = NULL;
> -    xmlNodePtr period_node = NULL;
> -    xmlNodePtr tmp_node = NULL;
> -    xmlNodePtr mpd_baseurl_node = NULL;
> -    xmlNodePtr period_baseurl_node = NULL;
> -    xmlNodePtr period_segmenttemplate_node = NULL;
> -    xmlNodePtr period_segmentlist_node = NULL;
> -    xmlNodePtr adaptionset_node = NULL;
> -    xmlAttrPtr attr = NULL;
> -    char *val  = NULL;
> -    uint32_t period_duration_sec = 0;
> -    uint32_t period_start_sec = 0;
> -
> -    if (!in) {
> -        close_in = 1;
>
> -        av_dict_copy(&opts, c->avio_opts, 0);
> -        ret = avio_open2(&in, url, AVIO_FLAG_READ, c->interrupt_callback, &opts);
> +        if (template)
> +            av_free(url);
>          av_dict_free(&opts);
> -        if (ret < 0)
> -            return ret;
> -    }
>
> -    if (av_opt_get(in, "location", AV_OPT_SEARCH_CHILDREN, (uint8_t**)&c->base_url) < 0)
> -        c->base_url = av_strdup(url);
> -
> -    filesize = avio_size(in);
> -    filesize = filesize > 0 ? filesize : DEFAULT_MANIFEST_SIZE;
> -
> -    if (filesize > MAX_BPRINT_READ_SIZE) {
> -        av_log(s, AV_LOG_ERROR, "Manifest too large: %"PRId64"\n", filesize);
> -        return AVERROR_INVALIDDATA;
> -    }
> -
> -    av_bprint_init(&buf, filesize + 1, AV_BPRINT_SIZE_UNLIMITED);
> -
> -    if ((ret = avio_read_to_bprint(in, &buf, MAX_BPRINT_READ_SIZE)) < 0 ||
> -        !avio_feof(in) ||
> -        (filesize = buf.len) == 0) {
> -        av_log(s, AV_LOG_ERROR, "Unable to read to manifest '%s'\n", url);
> -        if (ret == 0)
> -            ret = AVERROR_INVALIDDATA;
> -    } else {
> -        LIBXML_TEST_VERSION
> -
> -        doc = xmlReadMemory(buf.str, filesize, c->base_url, NULL, 0);
> -        root_element = xmlDocGetRootElement(doc);
> -        node = root_element;
> -
> -        if (!node) {
> -            ret = AVERROR_INVALIDDATA;
> -            av_log(s, AV_LOG_ERROR, "Unable to parse '%s' - missing root node\n", url);
> -            goto cleanup;
> -        }
> -
> -        if (node->type != XML_ELEMENT_NODE ||
> -            av_strcasecmp(node->name, "MPD")) {
> -            ret = AVERROR_INVALIDDATA;
> -            av_log(s, AV_LOG_ERROR, "Unable to parse '%s' - wrong root node name[%s] type[%d]\n", url, node->name, (int)node->type);
> -            goto cleanup;
> -        }
> -
> -        val = xmlGetProp(node, "type");
> -        if (!val) {
> -            av_log(s, AV_LOG_ERROR, "Unable to parse '%s' - missing type attrib\n", url);
> -            ret = AVERROR_INVALIDDATA;
> -            goto cleanup;
> -        }
> -        if (!av_strcasecmp(val, "dynamic"))
> -            c->is_live = 1;
> -        xmlFree(val);
> -
> -        attr = node->properties;
> -        while (attr) {
> -            val = xmlGetProp(node, attr->name);
> -
> -            if (!av_strcasecmp(attr->name, "availabilityStartTime")) {
> -                c->availability_start_time = get_utc_date_time_insec(s, val);
> -                av_log(s, AV_LOG_TRACE, "c->availability_start_time = [%"PRId64"]\n", c->availability_start_time);
> -            } else if (!av_strcasecmp(attr->name, "availabilityEndTime")) {
> -                c->availability_end_time = get_utc_date_time_insec(s, val);
> -                av_log(s, AV_LOG_TRACE, "c->availability_end_time = [%"PRId64"]\n", c->availability_end_time);
> -            } else if (!av_strcasecmp(attr->name, "publishTime")) {
> -                c->publish_time = get_utc_date_time_insec(s, val);
> -                av_log(s, AV_LOG_TRACE, "c->publish_time = [%"PRId64"]\n", c->publish_time);
> -            } else if (!av_strcasecmp(attr->name, "minimumUpdatePeriod")) {
> -                c->minimum_update_period = get_duration_insec(s, val);
> -                av_log(s, AV_LOG_TRACE, "c->minimum_update_period = [%"PRId64"]\n", c->minimum_update_period);
> -            } else if (!av_strcasecmp(attr->name, "timeShiftBufferDepth")) {
> -                c->time_shift_buffer_depth = get_duration_insec(s, val);
> -                av_log(s, AV_LOG_TRACE, "c->time_shift_buffer_depth = [%"PRId64"]\n", c->time_shift_buffer_depth);
> -            } else if (!av_strcasecmp(attr->name, "minBufferTime")) {
> -                c->min_buffer_time = get_duration_insec(s, val);
> -                av_log(s, AV_LOG_TRACE, "c->min_buffer_time = [%"PRId64"]\n", c->min_buffer_time);
> -            } else if (!av_strcasecmp(attr->name, "suggestedPresentationDelay")) {
> -                c->suggested_presentation_delay = get_duration_insec(s, val);
> -                av_log(s, AV_LOG_TRACE, "c->suggested_presentation_delay = [%"PRId64"]\n", c->suggested_presentation_delay);
> -            } else if (!av_strcasecmp(attr->name, "mediaPresentationDuration")) {
> -                c->media_presentation_duration = get_duration_insec(s, val);
> -                av_log(s, AV_LOG_TRACE, "c->media_presentation_duration = [%"PRId64"]\n", c->media_presentation_duration);
> -            }
> -            attr = attr->next;
> -            xmlFree(val);
> -        }
> -
> -        tmp_node = find_child_node_by_name(node, "BaseURL");
> -        if (tmp_node) {
> -            mpd_baseurl_node = xmlCopyNode(tmp_node,1);
> -        } else {
> -            mpd_baseurl_node = xmlNewNode(NULL, "BaseURL");
> -        }
> -
> -        // at now we can handle only one period, with the longest duration
> -        node = xmlFirstElementChild(node);
> -        while (node) {
> -            if (!av_strcasecmp(node->name, "Period")) {
> -                period_duration_sec = 0;
> -                period_start_sec = 0;
> -                attr = node->properties;
> -                while (attr) {
> -                    val = xmlGetProp(node, attr->name);
> -                    if (!av_strcasecmp(attr->name, "duration")) {
> -                        period_duration_sec = get_duration_insec(s, val);
> -                    } else if (!av_strcasecmp(attr->name, "start")) {
> -                        period_start_sec    = get_duration_insec(s, val);
> -                    }
> -                    attr = attr->next;
> -                    xmlFree(val);
> -                }
> -                if ((period_duration_sec) >= (c->period_duration)) {
> -                    period_node = node;
> -                    c->period_duration = period_duration_sec;
> -                    c->period_start = period_start_sec;
> -                    if (c->period_start > 0)
> -                        c->media_presentation_duration = c->period_duration;
> -                }
> -            } else if (!av_strcasecmp(node->name, "ProgramInformation")) {
> -                parse_programinformation(s, node);
> -            }
> -            node = xmlNextElementSibling(node);
> -        }
> -        if (!period_node) {
> -            av_log(s, AV_LOG_ERROR, "Unable to parse '%s' - missing Period node\n", url);
> -            ret = AVERROR_INVALIDDATA;
> -            goto cleanup;
> -        }
> -
> -        adaptionset_node = xmlFirstElementChild(period_node);
> -        while (adaptionset_node) {
> -            if (!av_strcasecmp(adaptionset_node->name, "BaseURL")) {
> -                period_baseurl_node = adaptionset_node;
> -            } else if (!av_strcasecmp(adaptionset_node->name, "SegmentTemplate")) {
> -                period_segmenttemplate_node = adaptionset_node;
> -            } else if (!av_strcasecmp(adaptionset_node->name, "SegmentList")) {
> -                period_segmentlist_node = adaptionset_node;
> -            } else if (!av_strcasecmp(adaptionset_node->name, "AdaptationSet")) {
> -                parse_manifest_adaptationset(s, url, adaptionset_node, mpd_baseurl_node, period_baseurl_node, period_segmenttemplate_node, period_segmentlist_node);
> -            }
> -            adaptionset_node = xmlNextElementSibling(adaptionset_node);
> -        }
> -cleanup:
> -        /*free the document */
> -        xmlFreeDoc(doc);
> -        xmlCleanupParser();
> -        xmlFreeNode(mpd_baseurl_node);
> -    }
> -
> -    av_bprint_finalize(&buf, NULL);
> -    if (close_in) {
> -        avio_close(in);
> -    }
> -    return ret;
> -}
> -
> -static int64_t calc_cur_seg_no(AVFormatContext *s, struct representation *pls)
> -{
> -    DASHContext *c = s->priv_data;
> -    int64_t num = 0;
> -    int64_t start_time_offset = 0;
> -
> -    if (c->is_live) {
> -        if (pls->n_fragments) {
> -            av_log(s, AV_LOG_TRACE, "in n_fragments mode\n");
> -            num = pls->first_seq_no;
> -        } else if (pls->n_timelines) {
> -            av_log(s, AV_LOG_TRACE, "in n_timelines mode\n");
> -            start_time_offset = get_segment_start_time_based_on_timeline(pls, 0xFFFFFFFF) - 60 * pls->fragment_timescale; // 60 seconds before end
> -            num = calc_next_seg_no_from_timelines(pls, start_time_offset);
> -            if (num == -1)
> -                num = pls->first_seq_no;
> -            else
> -                num += pls->first_seq_no;
> -        } else if (pls->fragment_duration){
> -            av_log(s, AV_LOG_TRACE, "in fragment_duration mode fragment_timescale = %"PRId64", presentation_timeoffset = %"PRId64"\n", pls->fragment_timescale, pls->presentation_timeoffset);
> -            if (pls->presentation_timeoffset) {
> -                num = pls->first_seq_no + (((get_current_time_in_sec() - c->availability_start_time) * pls->fragment_timescale)-pls->presentation_timeoffset) / pls->fragment_duration - c->min_buffer_time;
> -            } else if (c->publish_time > 0 && !c->availability_start_time) {
> -                if (c->min_buffer_time) {
> -                    num = pls->first_seq_no + (((c->publish_time + pls->fragment_duration) - c->suggested_presentation_delay) * pls->fragment_timescale) / pls->fragment_duration - c->min_buffer_time;
> -                } else {
> -                    num = pls->first_seq_no + (((c->publish_time - c->time_shift_buffer_depth + pls->fragment_duration) - c->suggested_presentation_delay) * pls->fragment_timescale) / pls->fragment_duration;
> -                }
> -            } else {
> -                num = pls->first_seq_no + (((get_current_time_in_sec() - c->availability_start_time) - c->suggested_presentation_delay) * pls->fragment_timescale) / pls->fragment_duration;
> -            }
> -        }
> -    } else {
> -        num = pls->first_seq_no;
> -    }
> -    return num;
> -}
> -
> -static int64_t calc_min_seg_no(AVFormatContext *s, struct representation *pls)
> -{
> -    DASHContext *c = s->priv_data;
> -    int64_t num = 0;
> -
> -    if (c->is_live && pls->fragment_duration) {
> -        av_log(s, AV_LOG_TRACE, "in live mode\n");
> -        num = pls->first_seq_no + (((get_current_time_in_sec() - c->availability_start_time) - c->time_shift_buffer_depth) * pls->fragment_timescale) / pls->fragment_duration;
> -    } else {
> -        num = pls->first_seq_no;
> -    }
> -    return num;
> -}
> -
> -static int64_t calc_max_seg_no(struct representation *pls, DASHContext *c)
> -{
> -    int64_t num = 0;
> -
> -    if (pls->n_fragments) {
> -        num = pls->first_seq_no + pls->n_fragments - 1;
> -    } else if (pls->n_timelines) {
> -        int i = 0;
> -        num = pls->first_seq_no + pls->n_timelines - 1;
> -        for (i = 0; i < pls->n_timelines; i++) {
> -            if (pls->timelines[i]->repeat == -1) {
> -                int length_of_each_segment = pls->timelines[i]->duration / pls->fragment_timescale;
> -                num =  c->period_duration / length_of_each_segment;
> -            } else {
> -                num += pls->timelines[i]->repeat;
> -            }
> -        }
> -    } else if (c->is_live && pls->fragment_duration) {
> -        num = pls->first_seq_no + (((get_current_time_in_sec() - c->availability_start_time)) * pls->fragment_timescale)  / pls->fragment_duration;
> -    } else if (pls->fragment_duration) {
> -        num = pls->first_seq_no + (c->media_presentation_duration * pls->fragment_timescale) / pls->fragment_duration;
> -    }
> -
> -    return num;
> -}
> -
> -static void move_timelines(struct representation *rep_src, struct representation *rep_dest, DASHContext *c)
> -{
> -    if (rep_dest && rep_src ) {
> -        free_timelines_list(rep_dest);
> -        rep_dest->timelines    = rep_src->timelines;
> -        rep_dest->n_timelines  = rep_src->n_timelines;
> -        rep_dest->first_seq_no = rep_src->first_seq_no;
> -        rep_dest->last_seq_no = calc_max_seg_no(rep_dest, c);
> -        rep_src->timelines = NULL;
> -        rep_src->n_timelines = 0;
> -        rep_dest->cur_seq_no = rep_src->cur_seq_no;
> -    }
> -}
> -
> -static void move_segments(struct representation *rep_src, struct representation *rep_dest, DASHContext *c)
> -{
> -    if (rep_dest && rep_src ) {
> -        free_fragment_list(rep_dest);
> -        if (rep_src->start_number > (rep_dest->start_number + rep_dest->n_fragments))
> -            rep_dest->cur_seq_no = 0;
> -        else
> -            rep_dest->cur_seq_no += rep_src->start_number - rep_dest->start_number;
> -        rep_dest->fragments    = rep_src->fragments;
> -        rep_dest->n_fragments  = rep_src->n_fragments;
> -        rep_dest->parent  = rep_src->parent;
> -        rep_dest->last_seq_no = calc_max_seg_no(rep_dest, c);
> -        rep_src->fragments = NULL;
> -        rep_src->n_fragments = 0;
> -    }
> -}
> -
> -
> -static int refresh_manifest(AVFormatContext *s)
> -{
> -    int ret = 0, i;
> -    DASHContext *c = s->priv_data;
> -    // save current context
> -    int n_videos = c->n_videos;
> -    struct representation **videos = c->videos;
> -    int n_audios = c->n_audios;
> -    struct representation **audios = c->audios;
> -    int n_subtitles = c->n_subtitles;
> -    struct representation **subtitles = c->subtitles;
> -    char *base_url = c->base_url;
> -
> -    c->base_url = NULL;
> -    c->n_videos = 0;
> -    c->videos = NULL;
> -    c->n_audios = 0;
> -    c->audios = NULL;
> -    c->n_subtitles = 0;
> -    c->subtitles = NULL;
> -    ret = parse_manifest(s, s->url, NULL);
> -    if (ret)
> -        goto finish;
> -
> -    if (c->n_videos != n_videos) {
> -        av_log(c, AV_LOG_ERROR,
> -               "new manifest has mismatched no. of video representations, %d -> %d\n",
> -               n_videos, c->n_videos);
> -        return AVERROR_INVALIDDATA;
> -    }
> -    if (c->n_audios != n_audios) {
> -        av_log(c, AV_LOG_ERROR,
> -               "new manifest has mismatched no. of audio representations, %d -> %d\n",
> -               n_audios, c->n_audios);
> -        return AVERROR_INVALIDDATA;
> -    }
> -    if (c->n_subtitles != n_subtitles) {
> -        av_log(c, AV_LOG_ERROR,
> -               "new manifest has mismatched no. of subtitles representations, %d -> %d\n",
> -               n_subtitles, c->n_subtitles);
> -        return AVERROR_INVALIDDATA;
> -    }
> -
> -    for (i = 0; i < n_videos; i++) {
> -        struct representation *cur_video = videos[i];
> -        struct representation *ccur_video = c->videos[i];
> -        if (cur_video->timelines) {
> -            // calc current time
> -            int64_t currentTime = get_segment_start_time_based_on_timeline(cur_video, cur_video->cur_seq_no) / cur_video->fragment_timescale;
> -            // update segments
> -            ccur_video->cur_seq_no = calc_next_seg_no_from_timelines(ccur_video, currentTime * cur_video->fragment_timescale - 1);
> -            if (ccur_video->cur_seq_no >= 0) {
> -                move_timelines(ccur_video, cur_video, c);
> -            }
> -        }
> -        if (cur_video->fragments) {
> -            move_segments(ccur_video, cur_video, c);
> -        }
> -    }
> -    for (i = 0; i < n_audios; i++) {
> -        struct representation *cur_audio = audios[i];
> -        struct representation *ccur_audio = c->audios[i];
> -        if (cur_audio->timelines) {
> -            // calc current time
> -            int64_t currentTime = get_segment_start_time_based_on_timeline(cur_audio, cur_audio->cur_seq_no) / cur_audio->fragment_timescale;
> -            // update segments
> -            ccur_audio->cur_seq_no = calc_next_seg_no_from_timelines(ccur_audio, currentTime * cur_audio->fragment_timescale - 1);
> -            if (ccur_audio->cur_seq_no >= 0) {
> -                move_timelines(ccur_audio, cur_audio, c);
> -            }
> -        }
> -        if (cur_audio->fragments) {
> -            move_segments(ccur_audio, cur_audio, c);
> -        }
> -    }
> -
> -finish:
> -    // restore context
> -    if (c->base_url)
> -        av_free(base_url);
> -    else
> -        c->base_url  = base_url;
> -
> -    if (c->subtitles)
> -        free_subtitle_list(c);
> -    if (c->audios)
> -        free_audio_list(c);
> -    if (c->videos)
> -        free_video_list(c);
> -
> -    c->n_subtitles = n_subtitles;
> -    c->subtitles = subtitles;
> -    c->n_audios = n_audios;
> -    c->audios = audios;
> -    c->n_videos = n_videos;
> -    c->videos = videos;
> -    return ret;
> -}
> -
> -static struct fragment *get_current_fragment(struct representation *pls)
> -{
> -    int64_t min_seq_no = 0;
> -    int64_t max_seq_no = 0;
> -    struct fragment *seg = NULL;
> -    struct fragment *seg_ptr = NULL;
> -    DASHContext *c = pls->parent->priv_data;
> -
> -    while (( !ff_check_interrupt(c->interrupt_callback)&& pls->n_fragments > 0)) {
> -        if (pls->cur_seq_no < pls->n_fragments) {
> -            seg_ptr = pls->fragments[pls->cur_seq_no];
> -            seg = av_mallocz(sizeof(struct fragment));
> -            if (!seg) {
> -                return NULL;
> -            }
> -            seg->url = av_strdup(seg_ptr->url);
> -            if (!seg->url) {
> -                av_free(seg);
> -                return NULL;
> -            }
> -            seg->size = seg_ptr->size;
> -            seg->url_offset = seg_ptr->url_offset;
> -            return seg;
> -        } else if (c->is_live) {
> -            refresh_manifest(pls->parent);
> -        } else {
> -            break;
> -        }
> -    }
> -    if (c->is_live) {
> -        min_seq_no = calc_min_seg_no(pls->parent, pls);
> -        max_seq_no = calc_max_seg_no(pls, c);
> -
> -        if (pls->timelines || pls->fragments) {
> -            refresh_manifest(pls->parent);
> -        }
> -        if (pls->cur_seq_no <= min_seq_no) {
> -            av_log(pls->parent, AV_LOG_VERBOSE, "old fragment: cur[%"PRId64"] min[%"PRId64"] max[%"PRId64"]\n", (int64_t)pls->cur_seq_no, min_seq_no, max_seq_no);
> -            pls->cur_seq_no = calc_cur_seg_no(pls->parent, pls);
> -        } else if (pls->cur_seq_no > max_seq_no) {
> -            av_log(pls->parent, AV_LOG_VERBOSE, "new fragment: min[%"PRId64"] max[%"PRId64"]\n", min_seq_no, max_seq_no);
> -        }
> -        seg = av_mallocz(sizeof(struct fragment));
> -        if (!seg) {
> -            return NULL;
> -        }
> -    } else if (pls->cur_seq_no <= pls->last_seq_no) {
> -        seg = av_mallocz(sizeof(struct fragment));
> -        if (!seg) {
> -            return NULL;
> -        }
> -    }
> -    if (seg) {
> -        char *tmpfilename;
> -        if (!pls->url_template) {
> -            av_log(pls->parent, AV_LOG_ERROR, "Cannot get fragment, missing template URL\n");
> -            av_free(seg);
> -            return NULL;
> -        }
> -        tmpfilename = av_mallocz(c->max_url_size);
> -        if (!tmpfilename) {
> -            av_free(seg);
> -            return NULL;
> -        }
> -        ff_dash_fill_tmpl_params(tmpfilename, c->max_url_size, pls->url_template, 0, pls->cur_seq_no, 0, get_segment_start_time_based_on_timeline(pls, pls->cur_seq_no));
> -        seg->url = av_strireplace(pls->url_template, pls->url_template, tmpfilename);
> -        if (!seg->url) {
> -            av_log(pls->parent, AV_LOG_WARNING, "Unable to resolve template url '%s', try to use origin template\n", pls->url_template);
> -            seg->url = av_strdup(pls->url_template);
> -            if (!seg->url) {
> -                av_log(pls->parent, AV_LOG_ERROR, "Cannot resolve template url '%s'\n", pls->url_template);
> -                av_free(tmpfilename);
> -                av_free(seg);
> -                return NULL;
> -            }
> -        }
> -        av_free(tmpfilename);
> -        seg->size = -1;
> -    }
> -
> -    return seg;
> -}
> -
> -static int read_from_url(struct representation *pls, struct fragment *seg,
> -                         uint8_t *buf, int buf_size)
> -{
> -    int ret;
> -
> -    /* limit read if the fragment was only a part of a file */
> -    if (seg->size >= 0)
> -        buf_size = FFMIN(buf_size, pls->cur_seg_size - pls->cur_seg_offset);
> -
> -    ret = avio_read(pls->input, buf, buf_size);
> -    if (ret > 0)
> -        pls->cur_seg_offset += ret;
> -
> -    return ret;
> -}
> -
> -static int open_input(DASHContext *c, struct representation *pls, struct fragment *seg)
> -{
> -    AVDictionary *opts = NULL;
> -    char *url = NULL;
> -    int ret = 0;
> -
> -    url = av_mallocz(c->max_url_size);
> -    if (!url) {
> -        ret = AVERROR(ENOMEM);
> -        goto cleanup;
> -    }
> -
> -    if (seg->size >= 0) {
> -        /* try to restrict the HTTP request to the part we want
> -         * (if this is in fact a HTTP request) */
> -        av_dict_set_int(&opts, "offset", seg->url_offset, 0);
> -        av_dict_set_int(&opts, "end_offset", seg->url_offset + seg->size, 0);
> -    }
> -
> -    ff_make_absolute_url(url, c->max_url_size, c->base_url, seg->url);
> -    av_log(pls->parent, AV_LOG_VERBOSE, "DASH request for url '%s', offset %"PRId64"\n",
> -           url, seg->url_offset);
> -    ret = open_url(pls->parent, &pls->input, url, &c->avio_opts, opts, NULL);
> -
> -cleanup:
> -    av_free(url);
> -    av_dict_free(&opts);
> -    pls->cur_seg_offset = 0;
> -    pls->cur_seg_size = seg->size;
> -    return ret;
> -}
> -
> -static int update_init_section(struct representation *pls)
> -{
> -    static const int max_init_section_size = 1024 * 1024;
> -    DASHContext *c = pls->parent->priv_data;
> -    int64_t sec_size;
> -    int64_t urlsize;
> -    int ret;
> -
> -    if (!pls->init_section || pls->init_sec_buf)
> -        return 0;
> -
> -    ret = open_input(c, pls, pls->init_section);
> -    if (ret < 0) {
> -        av_log(pls->parent, AV_LOG_WARNING,
> -               "Failed to open an initialization section\n");
> -        return ret;
> -    }
> -
> -    if (pls->init_section->size >= 0)
> -        sec_size = pls->init_section->size;
> -    else if ((urlsize = avio_size(pls->input)) >= 0)
> -        sec_size = urlsize;
> -    else
> -        sec_size = max_init_section_size;
> -
> -    av_log(pls->parent, AV_LOG_DEBUG,
> -           "Downloading an initialization section of size %"PRId64"\n",
> -           sec_size);
> -
> -    sec_size = FFMIN(sec_size, max_init_section_size);
> -
> -    av_fast_malloc(&pls->init_sec_buf, &pls->init_sec_buf_size, sec_size);
> -
> -    ret = read_from_url(pls, pls->init_section, pls->init_sec_buf,
> -                        pls->init_sec_buf_size);
> -    ff_format_io_close(pls->parent, &pls->input);
> -
> -    if (ret < 0)
> -        return ret;
> -
> -    pls->init_sec_data_len = ret;
> -    pls->init_sec_buf_read_offset = 0;
> -
> -    return 0;
> -}
> -
> -static int64_t seek_data(void *opaque, int64_t offset, int whence)
> -{
> -    struct representation *v = opaque;
> -    if (v->n_fragments && !v->init_sec_data_len) {
> -        return avio_seek(v->input, offset, whence);
> -    }
> -
> -    return AVERROR(ENOSYS);
> -}
> -
> -static int read_data(void *opaque, uint8_t *buf, int buf_size)
> -{
> -    int ret = 0;
> -    struct representation *v = opaque;
> -    DASHContext *c = v->parent->priv_data;
> -
> -restart:
> -    if (!v->input) {
> -        free_fragment(&v->cur_seg);
> -        v->cur_seg = get_current_fragment(v);
> -        if (!v->cur_seg) {
> -            ret = AVERROR_EOF;
> -            goto end;
> -        }
> -
> -        /* load/update Media Initialization Section, if any */
> -        ret = update_init_section(v);
> -        if (ret)
> -            goto end;
> -
> -        ret = open_input(c, v, v->cur_seg);
>          if (ret < 0) {
> -            if (ff_check_interrupt(c->interrupt_callback)) {
> -                ret = AVERROR_EXIT;
> -                goto end;
> +        fail_segment:
> +            if (seg == rep->cur_segment) {
> +                /* We know that we have not reached the end. */
> +                if (rep->read_ts < period->period->end_ts) {
> +                    if (0) {
> +                        /* TODO: Implement some failure resistance in case of
> +                         * specific HTTP response codes. */
> +                        goto open_segment;
> +                    } else if (!c->is_live && (ret == AVERROR(ETIMEDOUT) || ret == AVERROR(EIO))) {
> +                        /* Allow dropping some segments only for live streams. */
> +                        goto open_segment;
> +                    }
> +                }
> +
> +                return ret;
> +            } else {
> +                goto read_segment;
>              }
> -            av_log(v->parent, AV_LOG_WARNING, "Failed to open fragment of playlist\n");
> -            v->cur_seq_no++;
> -            goto restart;
>          }
> -    }
>
> -    if (v->init_sec_buf_read_offset < v->init_sec_data_len) {
> -        /* Push init section out first before first actual fragment */
> -        int copy_size = FFMIN(v->init_sec_data_len - v->init_sec_buf_read_offset, buf_size);
> -        memcpy(buf, v->init_sec_buf, copy_size);
> -        v->init_sec_buf_read_offset += copy_size;
> -        ret = copy_size;
> -        goto end;
> -    }
> +        if (0 < range.start &&
> +            avio_seek(s->pb, range.start, SEEK_SET) != range.start)
> +        {
> +            ret = AVERROR(EIO);
> +            goto fail_segment;
> +        }
>
> -    /* check the v->cur_seg, if it is null, get current and double check if the new v->cur_seg*/
> -    if (!v->cur_seg) {
> -        v->cur_seg = get_current_fragment(v);
> -    }
> -    if (!v->cur_seg) {
> -        ret = AVERROR_EOF;
> -        goto end;
> -    }
> -    ret = read_from_url(v, v->cur_seg, buf, buf_size);
> -    if (ret > 0)
> -        goto end;
> +        rep->segments[seg].segment_size = range.end - range.start;
> +    } while (rep->cur_segment != (seg = (seg + 1) % c->nb_connections) &&
> +             /* Use only a single IO context on startup. */
> +             rep->ic->iformat);
> +
> +read_segment:;
> +    /* Only the current segment can be read. */
> +    size = FFMIN(buf_size, (int)FFMIN(rep->segments[rep->cur_segment].segment_size, (uint64_t)INT_MAX));
> +    av_assert1(0 < size);
> +    ret = avio_read_partial(rep->segments[rep->cur_segment].pb, buf, size);
> +    if (0 < ret) {
> +        rep->segments[rep->cur_segment].segment_size -= ret;
> +        if (rep->save_init) {
> +            uint8_t *p;
> +            /* How much bytes can we store? */
> +            int append_size = FFMIN(rep->cur_period->initbuf_size + ret, INITBUF_MAX) -
> +                              rep->cur_period->initbuf_size;
>
> -    if (c->is_live || v->cur_seq_no < v->last_seq_no) {
> -        if (!v->is_restart_needed)
> -            v->cur_seq_no++;
> -        v->is_restart_needed = 1;
> +            if ((p = av_realloc(rep->cur_period->initbuf, rep->cur_period->initbuf_size + append_size))) {
> +                memcpy((rep->cur_period->initbuf = p) + rep->cur_period->initbuf_size, buf, append_size);
> +                rep->cur_period->initbuf_size += append_size;
> +            } else {
> +                /* Do not save anything furthermore otherwise cached init data
> +                 * would may be restored with a missing intermediate chunk. */
> +                rep->save_init = 0;
> +                /* Heck. Reset stored stuff. We can only handle correctly
> +                 * received init buffer. */
> +                rep->cur_period->initbuf_size = 0;
> +            }
> +        }
> +        return ret;
> +    } else if (ret == AVERROR_EOF) {
> +        /* Go to next segment. */
> +        rep->cur_segment = (rep->cur_segment + 1) % c->nb_connections;
> +        rep->save_init = 0;
> +    } else if (ret == AVERROR(ETIMEDOUT)) {
> +        dash_rotate_urllist(s, rep->cur_period->base);
> +    } else if (ret == 0) {
> +        if (s->flags & AVFMT_FLAG_NONBLOCK) {
> +            return AVERROR(EAGAIN);
> +        } else {
> +            av_usleep(150 * MILLISEC_PER_SEC);
> +            goto read_segment;
> +        }
> +    } else {
> +        return ret;
>      }
>
> -end:
> -    return ret;
> +    goto open_segment;
>  }
>
> -static int save_avio_options(AVFormatContext *s)
> +static av_cold int dash_subdemuxer_block_io_open(AVFormatContext *s, AVIOContext **pb, const char *url,
> +                                                 int flags, AVDictionary **opts)
>  {
>      DASHContext *c = s->priv_data;
> -    const char *opts[] = {
> -        "headers", "user_agent", "cookies", "http_proxy", "referer", "rw_timeout", "icy", NULL };
> -    const char **opt = opts;
> -    uint8_t *buf = NULL;
> -    int ret = 0;
> -
> -    while (*opt) {
> -        if (av_opt_get(s->pb, *opt, AV_OPT_SEARCH_CHILDREN, &buf) >= 0) {
> -            if (buf[0] != '\0') {
> -                ret = av_dict_set(&c->avio_opts, *opt, buf, AV_DICT_DONT_STRDUP_VAL);
> -                if (ret < 0)
> -                    return ret;
> -            } else {
> -                av_freep(&buf);
> -            }
> -        }
> -        opt++;
> -    }
> -
> -    return ret;
> -}
> -
> -static int nested_io_open(AVFormatContext *s, AVIOContext **pb, const char *url,
> -                          int flags, AVDictionary **opts)
> -{
>      av_log(s, AV_LOG_ERROR,
> -           "A DASH playlist item '%s' referred to an external file '%s'. "
> -           "Opening this file was forbidden for security reasons\n",
> -           s->url, url);
> +           "Opening external resource '%s' from DASH segment '%s' has been blocked for security reasons",
> +           url, c->location);
> +    av_log(s, AV_LOG_VERBOSE,
> +           "To avoid this security guard open MPD manifest using file: protocol");
>      return AVERROR(EPERM);
>  }
>
> -static void close_demux_for_component(struct representation *pls)
> -{
> -    /* note: the internal buffer could have changed */
> -    av_freep(&pls->pb.buffer);
> -    memset(&pls->pb, 0x00, sizeof(AVIOContext));
> -    pls->ctx->pb = NULL;
> -    avformat_close_input(&pls->ctx);
> -}
> -
> -static int reopen_demux_for_component(AVFormatContext *s, struct representation *pls)
> +static av_cold int dash_subdemuxer_alloc(DASHRepresentation *rep)
>  {
> +    int ret = 0;
> +    AVFormatContext *s = rep->oc;
>      DASHContext *c = s->priv_data;
> -    ff_const59 AVInputFormat *in_fmt = NULL;
> -    AVDictionary  *in_fmt_opts = NULL;
> -    uint8_t *avio_ctx_buffer  = NULL;
> -    int ret = 0, i;
> +    uint8_t *buf;
> +    int buf_size;
>
> -    if (pls->ctx) {
> -        close_demux_for_component(pls);
> -    }
> +    dash_subdemuxer_close(rep);
>
> -    if (ff_check_interrupt(&s->interrupt_callback)) {
> -        ret = AVERROR_EXIT;
> -        goto fail;
> -    }
> +    /* Allocate space that is enough for the theoretically largest segment. */
> +    buf_size = rep->periods[0]->bandwidth * c->max_segment_duration / AV_TIME_BASE;
> +    /* When maximum is not enough. */
> +    buf_size += buf_size / 16 /* +~5% */;
> +    buf_size = FFMIN(FFMAX(buf_size, 4 * 1024), 256 * 1024);
>
> -    if (!(pls->ctx = avformat_alloc_context())) {
> +    if (!(buf = av_malloc(buf_size + AV_INPUT_BUFFER_PADDING_SIZE))) {
>          ret = AVERROR(ENOMEM);
> -        goto fail;
> +        goto out;
>      }
>
> -    avio_ctx_buffer  = av_malloc(INITIAL_BUFFER_SIZE);
> -    if (!avio_ctx_buffer ) {
> -        ret = AVERROR(ENOMEM);
> -        avformat_free_context(pls->ctx);
> -        pls->ctx = NULL;
> -        goto fail;
> -    }
> -    ffio_init_context(&pls->pb, avio_ctx_buffer, INITIAL_BUFFER_SIZE, 0,
> -                      pls, read_data, NULL, c->is_live ? NULL : seek_data);
> -    pls->pb.seekable = 0;
> -
> -    if ((ret = ff_copy_whiteblacklists(pls->ctx, s)) < 0)
> -        goto fail;
> -
> -    pls->ctx->flags = AVFMT_FLAG_CUSTOM_IO;
> -    pls->ctx->probesize = s->probesize > 0 ? s->probesize : 1024 * 4;
> -    pls->ctx->max_analyze_duration = s->max_analyze_duration > 0 ? s->max_analyze_duration : 4 * AV_TIME_BASE;
> -    pls->ctx->interrupt_callback = s->interrupt_callback;
> -    ret = av_probe_input_buffer(&pls->pb, &in_fmt, "", NULL, 0, 0);
> -    if (ret < 0) {
> -        av_log(s, AV_LOG_ERROR, "Error when loading first fragment of playlist\n");
> -        avformat_free_context(pls->ctx);
> -        pls->ctx = NULL;
> -        goto fail;
> +    if ((ret = ffio_init_context(&rep->ic_pb, buf, buf_size, 0, rep,
> +                                 dash_subdemuxer_read, NULL, dash_subdemuxer_seek) < 0))
> +    {
> +        /* Note: We purposely do not free I/O buffer since documentation says
> +         * nothing about it. We presume inputs are freed on error. Just like in
> +         * case av_dict_set() and avformat_alloc_context()... */
> +        goto out;
>      }
> +    rep->ic_pb.seekable = 0;
>
> -    pls->ctx->pb = &pls->pb;
> -    pls->ctx->io_open  = nested_io_open;
> +    /* Padding bytes must be zeroed out. */
> +    memset(buf + buf_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
>
> -    // provide additional information from mpd if available
> -    ret = avformat_open_input(&pls->ctx, "", in_fmt, &in_fmt_opts); //pls->init_section->url
> -    av_dict_free(&in_fmt_opts);
> -    if (ret < 0)
> -        goto fail;
> -    if (pls->n_fragments) {
> -#if FF_API_R_FRAME_RATE
> -        if (pls->framerate.den) {
> -            for (i = 0; i < pls->ctx->nb_streams; i++)
> -                pls->ctx->streams[i]->r_frame_rate = pls->framerate;
> -        }
> -#endif
> -        ret = avformat_find_stream_info(pls->ctx, NULL);
> -        if (ret < 0)
> -            goto fail;
> +    if (!(rep->ic = avformat_alloc_context())) {
> +        ret = AVERROR(ENOMEM);
> +        goto out;
>      }
>
> -fail:
> +    rep->ic->pb = &rep->ic_pb;
> +    rep->ic->interrupt_callback = s->interrupt_callback;
> +
> +    rep->ic->probesize = 0 < s->probesize
> +        ? s->probesize
> +        : 4 * 1024;
> +    rep->ic->max_analyze_duration = 0 < s->max_analyze_duration
> +        ? s->max_analyze_duration
> +        : 4 * AV_TIME_BASE;
> +
> +    /* We supply everything for the demuxer so normall it should not need to
> +     * open anything. Apply this restriction unless we use "file" protocol. */
> +    if (strcmp(avio_find_protocol_name(s->url), "file"))
> +        rep->ic->io_open = dash_subdemuxer_block_io_open;
> +
> +    if ((ret = ff_copy_whiteblacklists(rep->ic, s)) < 0)
> +        goto out;
> +
> +out:
> +    if (ret < 0)
> +        dash_subdemuxer_close(rep);
>      return ret;
>  }
>
> -static int open_demux_for_component(AVFormatContext *s, struct representation *pls)
> +/**
> + * Open the real context.
> + */
> +static av_cold int dash_subdemuxer_open(DASHRepresentation *rep)
>  {
>      int ret = 0;
> -    int i;
> +    AVFormatContext *s = rep->oc;
> +    AVInputFormat *iformat = NULL;
>
> -    pls->parent = s;
> -    pls->cur_seq_no  = calc_cur_seg_no(s, pls);
> +    av_log(s, AV_LOG_DEBUG, "Opening representation '%s'\n", rep->id);
>
> -    if (!pls->last_seq_no) {
> -        pls->last_seq_no = calc_max_seg_no(pls, s->priv_data);
> -    }
> +    if ((ret = dash_subdemuxer_alloc(rep)) < 0)
> +        goto out;
>
> -    ret = reopen_demux_for_component(s, pls);
> -    if (ret < 0) {
> -        goto fail;
> -    }
> -    for (i = 0; i < pls->ctx->nb_streams; i++) {
> -        AVStream *st = avformat_new_stream(s, NULL);
> -        AVStream *ist = pls->ctx->streams[i];
> -        if (!st) {
> -            ret = AVERROR(ENOMEM);
> -            goto fail;
> -        }
> -        st->id = i;
> -        avcodec_parameters_copy(st->codecpar, ist->codecpar);
> -        avpriv_set_pts_info(st, ist->pts_wrap_bits, ist->time_base.num, ist->time_base.den);
> -
> -        // copy disposition
> -        st->disposition = ist->disposition;
> -
> -        // copy side data
> -        for (int i = 0; i < ist->nb_side_data; i++) {
> -            const AVPacketSideData *sd_src = &ist->side_data[i];
> -            uint8_t *dst_data;
> -
> -            dst_data = av_stream_new_side_data(st, sd_src->type, sd_src->size);
> -            if (!dst_data)
> -                return AVERROR(ENOMEM);
> -            memcpy(dst_data, sd_src->data, sd_src->size);
> -        }
> +    if ((ret = av_probe_input_buffer(&rep->ic_pb, &iformat, NULL, NULL, 0, 0)) < 0) {
> +        av_log(s, AV_LOG_ERROR, "Probe failed for representation '%s'\n", rep->id);
> +        goto out;
>      }
>
> -    return 0;
> -fail:
> +    if ((ret = avformat_open_input(&rep->ic, NULL, iformat, NULL)) < 0)
> +        goto out;
> +
> +    /* Finding stream information may need some essential information, like
> +     * encryption init info so stream metadata must be updated before. */
> +    if ((ret = dash_subdemuxer_update(rep)))
> +        goto out;
> +
> +    if ((ret = avformat_find_stream_info(rep->ic, NULL)) < 0)
> +        goto out;
> +
> +    /* Though new streams may have been created we do not care about them now.
> +     * If this is the case or stream information otherwise changed it will get
> +     * updated after reading frames. */
> +
> +out:
> +    if (ret < 0)
> +        dash_subdemuxer_close(rep);
>      return ret;
>  }
>
> -static int is_common_init_section_exist(struct representation **pls, int n_pls)
> +static av_cold int dash_subdemuxer_init(DASHRepresentation *rep)
>  {
> -    struct fragment *first_init_section = pls[0]->init_section;
> -    char *url =NULL;
> -    int64_t url_offset = -1;
> -    int64_t size = -1;
> -    int i = 0;
> -
> -    if (first_init_section == NULL || n_pls == 0)
> -        return 0;
> -
> -    url = first_init_section->url;
> -    url_offset = first_init_section->url_offset;
> -    size = pls[0]->init_section->size;
> -    for (i=0;i<n_pls;i++) {
> -        if (!pls[i]->init_section)
> -            continue;
> -
> -        if (av_strcasecmp(pls[i]->init_section->url, url) ||
> -            pls[i]->init_section->url_offset != url_offset ||
> -            pls[i]->init_section->size != size) {
> -            return 0;
> -        }
> +    int ret;
> +    AVFormatContext *s = rep->oc;
> +    DASHContext *c = s->priv_data;
> +
> +    if (c->is_live)
> +        rep->read_ts = av_gettime() - FFMIN(10, c->time_shift_buffer_depth) * MICROSEC_PER_SEC;
> +    else
> +        rep->read_ts = c->start_ts;
> +
> +    /* Create an inital stream for this representation though we do not what is
> +     * really inside. We expect it to be an elementary stream however it do not
> +     * have to be always true. In such cases the new streams will appear in
> +     * dash_subdemuxer_open(). */
> +    if (!avformat_new_stream(rep->ic, NULL)) {
> +        ret = AVERROR(ENOMEM);
> +        goto out;
>      }
> -    return 1;
> +
> +    if ((ret = dash_subdemuxer_update(rep)) < 0)
> +        goto out;
> +
> +out:
> +    if (ret < 0)
> +        dash_subdemuxer_close(rep);
> +    return ret;
>  }
>
> -static int copy_init_section(struct representation *rep_dest, struct representation *rep_src)
> +static void *av_push_array(void *plist, unsigned elem_size)
>  {
> -    rep_dest->init_sec_buf = av_mallocz(rep_src->init_sec_buf_size);
> -    if (!rep_dest->init_sec_buf) {
> -        av_log(rep_dest->ctx, AV_LOG_WARNING, "Cannot alloc memory for init_sec_buf\n");
> -        return AVERROR(ENOMEM);
> -    }
> -    memcpy(rep_dest->init_sec_buf, rep_src->init_sec_buf, rep_src->init_sec_data_len);
> -    rep_dest->init_sec_buf_size = rep_src->init_sec_buf_size;
> -    rep_dest->init_sec_data_len = rep_src->init_sec_data_len;
> -    rep_dest->cur_timestamp = rep_src->cur_timestamp;
> +    void *p;
> +    unsigned *nmemb = (unsigned *)((void **)plist + 1);
>
> -    return 0;
> -}
> +    if (!(p = av_realloc(*(void **)plist, (*nmemb + 1) * sizeof(void *))))
> +        return NULL;
> +    *(void **)plist = p;
>
> -static int dash_close(AVFormatContext *s);
> +    return ((*(void ***)plist)[(*nmemb)++] = av_mallocz(elem_size));
> +}
>
> -static void move_metadata(AVStream *st, const char *key, char **value)
> +static av_cold void *dash_find_by_id(AVFormatContext *s, void *list, unsigned nmemb, const char *id)
>  {
> -    if (*value) {
> -        av_dict_set(&st->metadata, key, *value, AV_DICT_DONT_STRDUP_VAL);
> -        *value = NULL;
> +    if (!id)
> +        return NULL;
> +
> +    for (unsigned i = 0; i < nmemb; ++i) {
> +        void *elem = ((void **)list)[i];
> +        xmlChar *elem_id = *(xmlChar **)elem;
> +        if (elem_id && !strcmp(elem_id, id))
> +            return elem;
>      }
> +
> +    return NULL;
>  }
>
> -static int dash_read_header(AVFormatContext *s)
> +static av_cold int dash_push_id_node(AVFormatContext *s, void *elem, void *plist, unsigned elem_size, xmlNodePtr node)
>  {
> -    DASHContext *c = s->priv_data;
> -    struct representation *rep;
> -    AVProgram *program;
> -    int ret = 0;
> -    int stream_index = 0;
> -    int i;
> -
> -    c->interrupt_callback = &s->interrupt_callback;
> -
> -    if ((ret = save_avio_options(s)) < 0)
> -        goto fail;
> -
> -    if ((ret = parse_manifest(s, s->url, s->pb)) < 0)
> -        goto fail;
> -
> -    /* If this isn't a live stream, fill the total duration of the
> -     * stream. */
> -    if (!c->is_live) {
> -        s->duration = (int64_t) c->media_presentation_duration * AV_TIME_BASE;
> +    int ret;
> +    xmlChar *id = xmlGetNoNsProp(node, "id");
> +    unsigned *nmemb = (unsigned *)((void **)plist + 1);
> +
> +    if ((*(void **)elem = dash_find_by_id(s, *(void ***)plist, *nmemb, id))) {
> +        ret = 1;
> +    } else if ((*(void **)elem = av_push_array(plist, elem_size))) {
> +        *(xmlChar **)(*(void **)elem) = id;
> +        id = NULL;
> +        ret = 0;
>      } else {
> -        av_dict_set(&c->avio_opts, "seekable", "0", 0);
> +        ret = AVERROR(ENOMEM);
>      }
>
> -    if(c->n_videos)
> -        c->is_init_section_common_video = is_common_init_section_exist(c->videos, c->n_videos);
> +    xml_free(id);
> +    return ret;
> +}
>
> -    /* Open the demuxer for video and audio components if available */
> -    for (i = 0; i < c->n_videos; i++) {
> -        rep = c->videos[i];
> -        if (i > 0 && c->is_init_section_common_video) {
> -            ret = copy_init_section(rep, c->videos[0]);
> -            if (ret < 0)
> -                goto fail;
> -        }
> -        ret = open_demux_for_component(s, rep);
> +static int dash_parse_representation(AVFormatContext *s,
> +                                     DASHPeriod *period,
> +                                     DASHAdaptationSet *as,
> +                                     DASHURLList *base_urls,
> +                                     DASHTimeline *inherited_timeline,
> +                                     const DASHParameters *inherited_par,
> +                                     xmlNodePtr node)
> +{
> +    int ret = 0;
> +    DASHContext *c = s->priv_data;
> +    DASHURLList *urls = dash_ref_urllist(base_urls);
> +    DASHRepresentation *rep;
> +    DASHRepresentationPeriod *rep_period;
> +    DASHTimeline *timeline = NULL;
> +    int64_t availability_time_offset = 0;
> +
> +    if ((ret = dash_push_id_node(s, &rep, &c->reps, offsetof(DASHRepresentation, segments[c->nb_connections]), node)) < 0)
> +        goto out;
> +    else if (!ret) {
> +        rep->oc = s;
> +    }
> +
> +    if (!(rep_period = av_push_array(&rep->periods, sizeof(DASHRepresentationPeriod)))) {
> +        ret = AVERROR(ENOMEM);
> +        goto out;
> +    }
> +
> +    rep_period->period = period;
> +    rep_period->par = *inherited_par;
> +
> +    xml_for_each_attr {
> +        if (!strcmp(attr->name, "availabilityTimeOffset"))
> +            (void)av_sscanf(value, "%"SCNd64, &availability_time_offset);
> +        else if (!strcmp(attr->name, "bandwidth"))
> +            (void)av_sscanf(value, "%"SCNu32, &rep_period->bandwidth);
> +        else if (!dash_parse_parameters(s, &rep_period->par, attr, value))
> +            /* Already done. */;
> +        else if (!strcmp(attr->name, "startWithSAP") && !strcmp(value, "1"))
> +            /* Just check. */;
> +        else if (strcmp(attr->name, "id"))
> +            dash_log_unknown_attr(s, attr, value);
> +    }
> +
> +    xml_for_each_child {
> +        if (!strcmp(child->name, "BaseURL"))
> +            ret = dash_parse_baseurl(s, &urls, child);
> +        else if (!strcmp(child->name, "SegmentTemplate"))
> +            ret = dash_parse_segmenttemplate(s, period, &timeline, child);
> +        else if (!strcmp(child->name, "SegmentList"))
> +            ret = dash_parse_segmentlist(s, period, &timeline, child);
> +        else if (!strcmp(child->name, "SegmentBase"))
> +            ret = dash_parse_segmentbase(s, period, &timeline, child);
> +        else if (!strcmp(child->name, "AudioChannelConfiguration"))
> +            ret = dash_parse_audiochannelconfiguration(s, &rep_period->par, child);
> +        else if (!strcmp(child->name, "UTCTiming"))
> +            ret = dash_parse_utctiming(s, child);
> +        else
> +            dash_log_unknown_child(s, child);
> +
> +        if (ret < 0)
> +            goto out;
> +    }
> +
> +    rep_period->as = as;
> +    if (!timeline && inherited_timeline)
> +        timeline = dash_ref_timeline(inherited_timeline);
> +    /* Default timeline with one big segment. URL is obtained from BaseURLs. */
> +    if (!timeline && (timeline = av_mallocz(sizeof(DASHTimeline)))) {
> +        dash_ref_timeline(timeline);
> +        timeline->type = TIMELINE_SEGMENTS;
> +        timeline->duration = INT64_MAX;
> +        timeline->init.range = DASH_RANGE_INITALIZER;
> +    }
> +    if (!timeline) {
> +        ret = AVERROR(ENOMEM);
> +        goto out;
> +    }
> +    rep_period->base = dash_ref_urllist(urls);
> +    rep_period->timeline = dash_ref_timeline(timeline);
> +
> +    if ((ret = dash_subdemuxer_alloc(rep)) < 0 ||
> +        (ret = dash_subdemuxer_init(rep)) < 0)
> +    {
> +        av_log(s, AV_LOG_DEBUG, "Failed to initalize subdemuxer for representation '%s': %s\n",
> +               rep->id, av_err2str(ret));
> +        goto out;
> +    }
> +
> +out:
> +    dash_unref_timeline(timeline);
> +    dash_unref_urllist(urls);
> +    return ret;
> +}
> +
> +static av_cold int dash_parse_label(AVFormatContext *s,
> +                                    DASHAdaptationSet *as,
> +                                    xmlNodePtr node)
> +{
> +    xmlChar *lang = NULL;
> +    xmlChar *value;
> +
> +    xml_for_each_attr {
> +        if (!strcmp(attr->name, "lang")) {
> +            lang = value;
> +            value = NULL;
> +        } else
> +            dash_log_unknown_attr(s, attr, value);
> +    }
> +
> +    if ((value = xmlNodeGetContent(node)) && *value) {
> +        char key_lang[100];
> +        if (lang)
> +            sprintf(key_lang, "label-%s", lang);
> +        av_dict_set(&s->metadata, lang ? key_lang : "label", value, 0);
> +    }
> +
> +    xml_free(value);
> +    xml_free(lang);
> +    return 0;
> +}
> +
> +static av_cold int dash_parse_adaptationset(AVFormatContext *s,
> +                                            DASHPeriod *period,
> +                                            DASHURLList *base_urls,
> +                                            DASHTimeline *inherited_timeline,
> +                                            const DASHParameters *inherited_par,
> +                                            xmlNodePtr node)
> +{
> +    int ret = 0;
> +    DASHContext *c = s->priv_data;
> +    DASHContentProtection cp = DASH_CONTENTPROTECTION_INITIALIZER;
> +    DASHURLList *urls = dash_ref_urllist(base_urls);
> +    DASHAdaptationSet *as;
> +    DASHTimeline *timeline = NULL;
> +    DASHParameters par = *inherited_par;
> +
> +    if ((ret = dash_push_id_node(s, &as, &c->ass, sizeof(DASHAdaptationSet), node)) < 0)
> +        goto out;
> +
> +    xml_for_each_attr {
> +        if (!strcmp(attr->name, "lang"))
> +            av_dict_set(&as->metadata, "language", value, 0);
> +        else if (!strcmp(attr->name, "selectionPriority"))
> +            av_dict_set(&as->metadata, "priority", value, 0);
> +        else if (!strcmp(attr->name, "group"))
> +            av_dict_set(&as->metadata, "group", value, 0);
> +        else if (!dash_parse_parameters(s, &par, attr, value))
> +            /* Already done. */;
> +        else if (!strcmp(attr->name, "segmentAlignment") && !strcmp(value, "true"))
> +            /* Just check. */;
> +        else if (!strcmp(attr->name, "startWithSAP") && !strcmp(value, "1"))
> +            /* Just check. */;
> +        else if (strcmp(attr->name, "id") &&
> +                 strncmp(attr->name, "max", 3) &&
> +                 strncmp(attr->name, "min", 3))
> +            dash_log_unknown_attr(s, attr, value);
> +    }
> +
> +    xml_for_each_child {
> +        if (!strcmp(child->name, "SegmentTemplate"))
> +            ret = dash_parse_segmenttemplate(s, period, &timeline, child);
> +        else if (!strcmp(child->name, "SegmentList"))
> +            ret = dash_parse_segmentlist(s, period, &timeline, child);
> +        else if (!strcmp(child->name, "SegmentBase"))
> +            ret = dash_parse_segmentbase(s, period, &timeline, child);
> +        else if (!strcmp(child->name, "ContentProtection"))
> +            ret = dash_parse_contentprotection(s, as, &cp, child);
> +        else if (!strcmp(child->name, "BaseURL"))
> +            ret = dash_parse_baseurl(s, &urls, child);
> +        else if (!strcmp(child->name, "Role"))
> +            ret = dash_parse_role(s, &par, child);
> +        else if (!strcmp(child->name, "Viewpoint"))
> +            ret = dash_parse_viewpoint(s, as, child);
> +        else if (!strcmp(child->name, "SupplementalProperty") ||
> +                 !strcmp(child->name, "EssentialProperty"))
> +            ret = dash_parse_property(s, as, NULL, child);
> +        else if (!strcmp(child->name, "Representation"))
> +            ret = dash_parse_representation(s, period, as, urls, (timeline ? timeline : inherited_timeline), &par, child);
> +        else if (!strcmp(child->name, "AudioChannelConfiguration"))
> +            ret = dash_parse_audiochannelconfiguration(s, &par, child);
> +        else if (!strcmp(child->name, "Label"))
> +            ret = dash_parse_label(s, as, child);
> +        else
> +            dash_log_unknown_child(s, child);
> +
> +        if (ret < 0)
> +            goto out;
> +    }
> +
> +out:
> +    dash_unref_timeline(timeline);
> +    dash_unref_urllist(urls);
> +    return ret;
> +}
> +
> +static av_cold int dash_parse_period(AVFormatContext *s,
> +                                     DASHURLList *base_urls,
> +                                     xmlNodePtr node)
> +{
> +    int ret = 0;
> +    DASHContext *c = s->priv_data;
> +    DASHURLList *urls = dash_ref_urllist(base_urls);
> +    DASHTimeline *timeline = NULL;
> +    DASHPeriod *period;
> +    int64_t duration = INT64_MAX;
> +    DASHParameters par = DASH_PARAMETERS_INITIALIZER;
> +
> +    if ((ret = dash_push_id_node(s, &period, &c->periods, sizeof(DASHPeriod), node)) < 0)
> +        goto out;
> +
> +    period->start_ts = 0;
> +
> +    xml_for_each_attr {
> +        if (!strcmp(attr->name, "start"))
> +            period->start_ts = dash_parse_duration(value, s);
> +        else if (!strcmp(attr->name, "duration"))
> +            duration = dash_parse_duration(value, s);
> +        else if (!dash_parse_parameters(s, &par, attr, value))
> +            /* Already done. */;
> +        else if (strcmp(attr->name, "id"))
> +            dash_log_unknown_attr(s, attr, value);
> +    }
> +
> +    period->start_ts += c->availability_start_time;
> +    period->end_ts = period->start_ts < INT64_MAX - duration
> +        ? period->start_ts + duration
> +        : INT64_MAX;
> +    if (c->media_presentation_duration < 0)
> +        s->duration = FFMAX(s->duration != AV_NOPTS_VALUE ? s->duration : 0, period->end_ts);
> +    period->end_ts = FFMIN(period->end_ts, s->duration != AV_NOPTS_VALUE ? s->duration : 0);
> +
> +    /* INT64_MAX means infinity, ergo unknown duration. It has to be stored
> +     * differently for format. */
> +    if (INT64_MAX == s->duration)
> +        s->duration = AV_NOPTS_VALUE;
> +
> +    /* Restrict duration of previous periods. */
> +    for (unsigned i = 0; i < c->nb_periods; ++i) {
> +        DASHPeriod *per = c->periods[i];
> +        if (per->start_ts < period->start_ts)
> +            per->end_ts = FFMIN(per->end_ts, period->start_ts);
> +    }
>
> -        if (ret)
> -            goto fail;
> -        rep->stream_index = stream_index;
> -        ++stream_index;
> +    if (period->end_ts <= period->start_ts) {
> +        av_log(s, AV_LOG_DEBUG, "Ignoring empty Period %"PRId64" >= %"PRId64"\n",
> +               period->start_ts, period->end_ts);
> +        goto out;
>      }
>
> -    if(c->n_audios)
> -        c->is_init_section_common_audio = is_common_init_section_exist(c->audios, c->n_audios);
> +    xml_for_each_child {
> +        if (!strcmp(child->name, "BaseURL"))
> +            ret = dash_parse_baseurl(s, &urls, child);
> +        else if (!strcmp(child->name, "SegmentTemplate"))
> +            ret = dash_parse_segmenttemplate(s, period, &timeline, child);
> +        else if (!strcmp(child->name, "SegmentList"))
> +            ret = dash_parse_segmentlist(s, period, &timeline, child);
> +        else if (!strcmp(child->name, "SegmentBase"))
> +            ret = dash_parse_segmentbase(s, period, &timeline, child);
> +        else if (!strcmp(child->name, "AdaptationSet"))
> +            ret = dash_parse_adaptationset(s, period, urls, timeline, &par, child);
> +        else if (!strcmp(child->name, "AssetIdentifier"))
> +            ret = dash_parse_assetidentifier(s, period, child);
> +        else
> +            dash_log_unknown_child(s, child);
>
> -    for (i = 0; i < c->n_audios; i++) {
> -        rep = c->audios[i];
> -        if (i > 0 && c->is_init_section_common_audio) {
> -            ret = copy_init_section(rep, c->audios[0]);
> -            if (ret < 0)
> -                goto fail;
> +        if (ret < 0)
> +            goto out;
> +    }
> +
> +out:
> +    dash_unref_timeline(timeline);
> +    dash_unref_urllist(urls);
> +    return ret;
> +}
> +
> +static av_cold int dash_parse_programinformation(AVFormatContext *s, xmlNodePtr node)
> +{
> +    xmlChar *lang = NULL;
> +
> +    xml_for_each_attr {
> +        if (!strcmp(attr->name, "lang")) {
> +            lang = value;
> +            value = NULL;
> +        } else
> +            dash_log_unknown_attr(s, attr, value);
> +    }
> +
> +    xml_for_each_child {
> +        const char *key = NULL;
> +        xmlChar *value;
> +
> +        if (!(value = xmlNodeGetContent(child)))
> +            continue;
> +
> +        if (!strcmp(child->name, "Title"))
> +            key = "title";
> +        else if (!strcmp(child->name, "Source"))
> +            key = "source";
> +        else if (!strcmp(child->name, "Copyright"))
> +            key = "copyright";
> +        else
> +            dash_log_unknown_child(s, child);
> +
> +        if (key) {
> +            char key_lang[100];
> +            if (lang)
> +                sprintf(key_lang, "%s-%s", key, lang);
> +            av_dict_set(&s->metadata, lang ? key_lang : key, value, 0);
>          }
> -        ret = open_demux_for_component(s, rep);
>
> -        if (ret)
> -            goto fail;
> -        rep->stream_index = stream_index;
> -        ++stream_index;
> +        xmlFree(value);
>      }
>
> -    if (c->n_subtitles)
> -        c->is_init_section_common_subtitle = is_common_init_section_exist(c->subtitles, c->n_subtitles);
> +    xml_free(lang);
> +    return 0;
> +}
> +
> +static av_cold void dash_reset(AVFormatContext *s)
> +{
> +    DASHContext *c = s->priv_data;
> +
> +    /* Gets updated as we parse Periods. */
> +    s->duration = AV_NOPTS_VALUE;
> +    c->is_live = 0;
> +    c->media_presentation_duration = INT64_MIN;
> +
> +    av_freep_arrayp(&c->reps, dash_free_representation);
> +    av_freep_arrayp(&c->ass, dash_free_adaptationset);
> +    av_freep_arrayp(&c->periods, dash_free_period);
> +
> +    av_freep(&c->location);
> +
> +    xml_freep(&c->id);
> +    xml_freep(&c->chain_next_location);
> +    xml_freep(&c->fallback_location);
> +
> +    av_dict_free(&c->protocol_opts);
> +}
> +
> +static av_cold int dash_parse_mpd(AVFormatContext *s,
> +                                  DASHURLList *base_urls,
> +                                  xmlNodePtr node)
> +{
> +    int ret = 0;
> +    DASHContext *c = s->priv_data;
> +    DASHURLList *urls = dash_ref_urllist(base_urls);
>
> -    for (i = 0; i < c->n_subtitles; i++) {
> -        rep = c->subtitles[i];
> -        if (i > 0 && c->is_init_section_common_subtitle) {
> -            ret = copy_init_section(rep, c->subtitles[0]);
> -            if (ret < 0)
> -                goto fail;
> +    /* Nullify periods.
> +     * TODO: Maybe they sould be cleaned up after parsing. */
> +    for (unsigned i = 0; i < c->nb_periods; ++i) {
> +        DASHPeriod *period = c->periods[i];
> +        period->start_ts = period->end_ts = 0;
> +    }
> +
> +    {
> +        xmlChar *id = xmlGetNoNsProp(node, "id");
> +        if (!c->id || !id || strcmp(c->id, id)) {
> +            dash_reset(s);
> +            c->id = id;
> +        } else {
> +            xmlFree(id);
>          }
> -        ret = open_demux_for_component(s, rep);
> +    }
>
> -        if (ret)
> -            goto fail;
> -        rep->stream_index = stream_index;
> -        ++stream_index;
> +    xml_for_each_attr {
> +        if (!strcmp(attr->name, "type")) {
> +            /* https://livesim.dashif.org/livesim/scte35_2/testpic_2s/Manifest.mpd */
> +            if (!strcmp(value, "dynamic"))
> +                c->is_live = 1;
> +            else if (!strcmp(value, "static"))
> +                c->is_live = 0;
> +            else
> +                dash_log_invalid_attr_value(s, attr, value);
> +        } else if (!strcmp(attr->name, "availabilityStartTime"))
> +            c->availability_start_time = dash_parse_date(value, s);
> +        else if (!strcmp(attr->name, "availabilityEndTime"))
> +            c->availability_end_time  = dash_parse_date(value, s);
> +        else if (!strcmp(attr->name, "publishTime")) {
> +            c->publish_time = dash_parse_date(value, s);
> +            /* Take the easy way. */
> +            av_dict_set(&s->metadata, "creation_time", value, 0);
> +        } else if (!strcmp(attr->name, "minimumUpdatePeriod"))
> +            c->min_update_period = dash_parse_duration(value, s);
> +        else if (!strcmp(attr->name, "maxSegmentDuration"))
> +            c->max_segment_duration = dash_parse_duration(value, s);
> +        else if (!strcmp(attr->name, "minBufferTime"))
> +            c->min_buffer_time = dash_parse_duration(value, s);
> +        else if (!strcmp(attr->name, "timeShiftBufferDepth"))
> +            c->time_shift_buffer_depth = dash_parse_duration(value, s);
> +        else if (!strcmp(attr->name, "mediaPresentationDuration"))
> +            s->duration = c->media_presentation_duration = dash_parse_duration(value, s);
> +        else if (strcmp(attr->name, "id") &&
> +                 strcmp(attr->name, "profiles") &&
> +                 strcmp(attr->name, "schemaLocation"))
> +            dash_log_unknown_attr(s, attr, value);
>      }
>
> -    if (!stream_index) {
> -        ret = AVERROR_INVALIDDATA;
> -        goto fail;
> +    xml_for_each_child {
> +        if (!strcmp(child->name, "ProgramInformation"))
> +            ret = dash_parse_programinformation(s, child);
> +        else if (!strcmp(child->name, "Location"))
> +            ret = dash_parse_location(s, child);
> +        else if (!strcmp(child->name, "BaseURL"))
> +            ret = dash_parse_baseurl(s, &urls, child);
> +        else if (!strcmp(child->name, "Period"))
> +            ret = dash_parse_period(s, urls, child);
> +        else if (!strcmp(child->name, "UTCTiming"))
> +            ret = dash_parse_utctiming(s, child);
> +        else if (!strcmp(child->name, "SupplementalProperty") ||
> +                 !strcmp(child->name, "EssentialProperty"))
> +            ret = dash_parse_property(s, NULL, NULL, child);
> +        else
> +            dash_log_unknown_child(s, child);
> +
> +        if (ret < 0)
> +            goto out;
>      }
>
> -    /* Create a program */
> -    program = av_new_program(s, 0);
> -    if (!program) {
> +out:
> +    dash_unref_urllist(urls);
> +    return ret;
> +}
> +
> +/**
> + * Remove filename component from an URL.
> + */
> +static int ff_make_absolute_head_urla(char **out_url, const char *url)
> +{
> +    int ret;
> +
> +    if (0 <= (ret = ff_make_absolute_urla(out_url, url, "./"))) {
> +        char *p = *out_url;
> +        size_t len = strlen(p);
> +
> +        if (3 <= len && !memcmp(p + len - 3, "/./", 4))
> +            p[len - 2] = '\0';
> +    }
> +
> +    return ret;
> +}
> +
> +static av_cold int dash_parse_root(AVFormatContext *s, xmlNodePtr node)
> +{
> +    int ret = 0;
> +    DASHURLList *urls = NULL;
> +    DASHContext *c = s->priv_data;
> +
> +    if (!node ||
> +        strcmp(node->name, "MPD") ||
> +        !node->ns ||
> +        strcmp(node->ns->href, "urn:mpeg:dash:schema:mpd:2011"))
> +    {
> +        av_log(s, AV_LOG_ERROR, "Not an MPD\n");
> +        return AVERROR_INVALIDDATA;
> +    }
> +
> +    if (!(urls = dash_new_urllist(1))) {
>          ret = AVERROR(ENOMEM);
> -        goto fail;
> -    }
> -
> -    for (i = 0; i < c->n_videos; i++) {
> -        rep = c->videos[i];
> -        av_program_add_stream_index(s, 0, rep->stream_index);
> -        rep->assoc_stream = s->streams[rep->stream_index];
> -        if (rep->bandwidth > 0)
> -            av_dict_set_int(&rep->assoc_stream->metadata, "variant_bitrate", rep->bandwidth, 0);
> -        move_metadata(rep->assoc_stream, "id", &rep->id);
> -    }
> -    for (i = 0; i < c->n_audios; i++) {
> -        rep = c->audios[i];
> -        av_program_add_stream_index(s, 0, rep->stream_index);
> -        rep->assoc_stream = s->streams[rep->stream_index];
> -        if (rep->bandwidth > 0)
> -            av_dict_set_int(&rep->assoc_stream->metadata, "variant_bitrate", rep->bandwidth, 0);
> -        move_metadata(rep->assoc_stream, "id", &rep->id);
> -        move_metadata(rep->assoc_stream, "language", &rep->lang);
> -    }
> -    for (i = 0; i < c->n_subtitles; i++) {
> -        rep = c->subtitles[i];
> -        av_program_add_stream_index(s, 0, rep->stream_index);
> -        rep->assoc_stream = s->streams[rep->stream_index];
> -        move_metadata(rep->assoc_stream, "id", &rep->id);
> -        move_metadata(rep->assoc_stream, "language", &rep->lang);
> +        goto out;
>      }
>
> -    return 0;
> -fail:
> -    dash_close(s);
> +    if ((ret = ff_make_absolute_head_urla(&urls->elems[0], c->location)) < 0)
> +        goto out;
> +
> +    if ((ret = dash_parse_mpd(s, urls, node)) < 0)
> +        goto out;
> +
> +out:
> +    dash_unref_urllist(urls);
>      return ret;
>  }
>
> -static void recheck_discard_flags(AVFormatContext *s, struct representation **p, int n)
> +static av_cold void dash_libxml_error_handler(void *opaque, const char *fmt, ...)
>  {
> -    int i, j;
> -
> -    for (i = 0; i < n; i++) {
> -        struct representation *pls = p[i];
> -        int needed = !pls->assoc_stream || pls->assoc_stream->discard < AVDISCARD_ALL;
> -
> -        if (needed && !pls->ctx) {
> -            pls->cur_seg_offset = 0;
> -            pls->init_sec_buf_read_offset = 0;
> -            /* Catch up */
> -            for (j = 0; j < n; j++) {
> -                pls->cur_seq_no = FFMAX(pls->cur_seq_no, p[j]->cur_seq_no);
> +    AVFormatContext *s = opaque;
> +    va_list ap;
> +
> +    va_start(ap, fmt);
> +    av_vlog(s, AV_LOG_ERROR, fmt, ap);
> +    va_end(ap);
> +}
> +
> +static av_cold int dash_open_manifest(AVFormatContext *s)
> +{
> +    int ret = 0;
> +    DASHContext *c = s->priv_data;
> +    xmlParserCtxtPtr xml;
> +    AVIOContext *pb;
> +    AVDictionary *opts = NULL;
> +    uint8_t *location;
> +
> +    av_dict_set(&opts, "icy", "0", 0);
> +    ret = s->io_open(s, &pb, c->location, AVIO_FLAG_READ, &opts);
> +    av_dict_free(&opts);
> +    if (ret < 0)
> +        return ret;
> +
> +    xmlSetGenericErrorFunc(s, dash_libxml_error_handler);
> +
> +    /* Why not SAX? DASH-IF may standardize patching that obviously requires us
> +     * to maintain DOM. */
> +    for (xml = NULL;;) {
> +        char buf[1 << 14];
> +
> +        /* libXML2 needs at least 4 bytes at the beginnig to being able to
> +         * initialize its parsing context. */
> +        if (0 < (ret = (xml ? avio_read_partial : avio_read)(pb, buf, (xml ? sizeof(buf) : sizeof("BOM"))))) {
> +            /* Context is initialized by the first read call. */
> +            if (!xml) {
> +                if ((xml = xmlCreatePushParserCtxt(NULL, NULL, buf, ret, NULL)))
> +                    continue;
> +            } else {
> +                if (!xmlParseChunk(xml, buf, ret, 0 /* Terminate? */))
> +                    continue;
> +
> +            parse_error:
> +                av_log(s, AV_LOG_ERROR, "Failed to parse manifest file\n");
> +                ret = AVERROR_INVALIDDATA;
> +                goto out;
>              }
> -            reopen_demux_for_component(s, pls);
> -            av_log(s, AV_LOG_INFO, "Now receiving stream_index %d\n", pls->stream_index);
> -        } else if (!needed && pls->ctx) {
> -            close_demux_for_component(pls);
> -            ff_format_io_close(pls->parent, &pls->input);
> -            av_log(s, AV_LOG_INFO, "No longer receiving stream_index %d\n", pls->stream_index);
> +        } else if (ret == AVERROR_EOF) {
> +            if (!xmlParseChunk(xml, NULL, 0, 1 /* Terminate? */))
> +                break;
> +
> +            goto parse_error;
>          }
> +
> +        av_log(s, AV_LOG_ERROR, "Failed to read manifest file\n");
> +        goto out;
>      }
> +
> +    /* For HTTP 3XX redirects standard states that the redirected location
> +     * should be used for updates. We are lazy and just check for "location". */
> +    if (0 <= av_opt_get(pb, "location", AV_OPT_SEARCH_CHILDREN, &location)) {
> +        (void)dash_set_location(s, location);
> +        av_free(location);
> +    }
> +
> +    ret = dash_parse_root(s, xmlDocGetRootElement(xml->myDoc));
> +
> +    if (c->is_live) {
> +        int64_t accuracy = c->min_update_period / 20; /* 5% */
> +        c->next_update = av_gettime() +
> +                         (av_lfg_get(&c->rnd) % accuracy + 1) +
> +                         (c->min_update_period - accuracy);
> +    } else {
> +        c->next_update = 0;
> +    }
> +
> +out:
> +    if (xml) {
> +        if (xml->myDoc)
> +            xmlFreeDoc(xml->myDoc);
> +        xmlFreeParserCtxt(xml);
> +    }
> +
> +    /* Reset handlers so passed references to AVFormatContext will not survive. */
> +    xmlSetGenericErrorFunc(NULL, NULL);
> +
> +    ff_format_io_close(s, &pb);
> +    return ret;
> +}
> +
> +static av_cold int dash_close(AVFormatContext *s)
> +{
> +    return dash_reset(s), 0;
> +}
> +
> +static av_cold int dash_save_protocol_options(AVFormatContext *s)
> +{
> +    static const char OPTIONS[] =
> +        "headers\0" "http_proxy\0" "user_agent\0" "cookies\0" "referer\0"
> +        "rw_timeout\0" "icy\0";
> +
> +    DASHContext *c = s->priv_data;
> +
> +    for (const char *opt = OPTIONS; *opt; opt += strlen(opt) + 1 /* NUL */) {
> +        uint8_t *buf;
> +
> +        if (0 <= av_opt_get(s->pb, opt, AV_OPT_SEARCH_CHILDREN, &buf)) {
> +            int ret = av_dict_set(&c->protocol_opts, opt, buf,
> +                                  AV_DICT_DONT_OVERWRITE | AV_DICT_DONT_STRDUP_VAL);
> +            if (ret < 0)
> +                return ret;
> +        }
> +    }
> +
> +    return 0;
> +}
> +
> +static av_cold int dash_read_header(AVFormatContext *s)
> +{
> +    int ret = 0;
> +    DASHContext *c = s->priv_data;
> +
> +    if ((ret = dash_set_location(s, s->url)) < 0)
> +        goto out;
> +
> +    /* Signal that we may create additional streams as time pasts. */
> +    s->ctx_flags |= AVFMTCTX_NOHEADER;
> +
> +    if ((ret = dash_save_protocol_options(s)) < 0)
> +        goto out;
> +
> +    av_lfg_init(&c->rnd, av_get_random_seed());
> +
> +    if ((ret = dash_open_manifest(s)) < 0)
> +        goto out;
> +
> +out:
> +    if (ret < 0)
> +        dash_close(s);
> +    return ret;
> +}
> +
> +static DASHRepresentation *dash_get_read_next_representation(AVFormatContext *s)
> +{
> +    DASHContext *c = s->priv_data;
> +    DASHRepresentation *best_rep = NULL;
> +
> +    for (unsigned i = 0; i < c->nb_reps; ++i) {
> +        DASHRepresentation *rep = c->reps[i];
> +        int needed = 0;
> +
> +        /* Subdemuxer not opened for this representation, so we are not
> +         * interested in receiving segments for this. */
> +        if (!rep->ic)
> +            continue;
> +
> +        /* Check if any of the streams is needed. */
> +        for (unsigned k = 0; k < rep->nb_streams; ++k) {
> +            AVStream *ost = rep->ostreams[k];
> +            if ((needed = ost->discard < AVDISCARD_ALL))
> +                break;
> +        }
> +
> +        if (!needed)
> +            continue;
> +
> +        /* A toy scheduler. */
> +        if (!best_rep || rep->last_pts < best_rep->last_pts)
> +            best_rep = rep;
> +    }
> +
> +    return best_rep;
>  }
>
>  static int dash_read_packet(AVFormatContext *s, AVPacket *pkt)
>  {
> +    int ret;
> +    DASHRepresentation *rep;
> +    AVStream *ist, /* --packet--> */ *ost;
>      DASHContext *c = s->priv_data;
> -    int ret = 0, i;
> -    int64_t mints = 0;
> -    struct representation *cur = NULL;
> -    struct representation *rep = NULL;
>
> -    recheck_discard_flags(s, c->videos, c->n_videos);
> -    recheck_discard_flags(s, c->audios, c->n_audios);
> -    recheck_discard_flags(s, c->subtitles, c->n_subtitles);
> -
> -    for (i = 0; i < c->n_videos; i++) {
> -        rep = c->videos[i];
> -        if (!rep->ctx)
> -            continue;
> -        if (!cur || rep->cur_timestamp < mints) {
> -            cur = rep;
> -            mints = rep->cur_timestamp;
> +    if (c->next_update && c->next_update <= av_gettime())
> +        if ((ret = dash_open_manifest(s)) < 0) {
> +            c->next_update = av_gettime() * (60 * MICROSEC_PER_SEC) /* 1 min */;
> +            av_log(s, AV_LOG_ERROR, "Failed to update manifest\n");
>          }
> -    }
> -    for (i = 0; i < c->n_audios; i++) {
> -        rep = c->audios[i];
> -        if (!rep->ctx)
> -            continue;
> -        if (!cur || rep->cur_timestamp < mints) {
> -            cur = rep;
> -            mints = rep->cur_timestamp;
> +
> +    /* Find a representation where we can read from. */
> +    for (;;) {
> +        if (!(rep = dash_get_read_next_representation(s))) {
> +            /* Load next manifest, if any. */
> +            if (c->chain_next_location) {
> +                if ((ret = dash_set_location(s, c->chain_next_location)) < 0)
> +                    return ret;
> +                xml_freep(&c->chain_next_location);
> +
> +                if ((ret = dash_open_manifest(s)) < 0)
> +                    return ret;
> +
> +                continue;
> +            }
> +
> +            return AVERROR_EOF;
>          }
> -    }
>
> -    for (i = 0; i < c->n_subtitles; i++) {
> -        rep = c->subtitles[i];
> -        if (!rep->ctx)
> +        if ((!rep->ic->iformat &&
> +             (ret = dash_subdemuxer_open(rep)) < 0) ||
> +            (ret = av_read_frame(rep->ic, pkt)) < 0)
> +        {
> +            av_log(s, AVERROR_EOF != ret ? AV_LOG_ERROR : AV_LOG_DEBUG,
> +                   "Failed to read representation '%s': %s\n",
> +                   rep->id, av_err2str(ret));
> +            dash_subdemuxer_close(rep);
>              continue;
> -        if (!cur || rep->cur_timestamp < mints) {
> -            cur = rep;
> -            mints = rep->cur_timestamp;
>          }
> -    }
>
> -    if (!cur) {
> -        return AVERROR_INVALIDDATA;
> +        break;
>      }
> -    while (!ff_check_interrupt(c->interrupt_callback) && !ret) {
> -        ret = av_read_frame(cur->ctx, pkt);
> -        if (ret >= 0) {
> -            /* If we got a packet, return it */
> -            cur->cur_timestamp = av_rescale(pkt->pts, (int64_t)cur->ctx->streams[0]->time_base.num * 90000, cur->ctx->streams[0]->time_base.den);
> -            pkt->stream_index = cur->stream_index;
> -            return 0;
> -        }
> -        if (cur->is_restart_needed) {
> -            cur->cur_seg_offset = 0;
> -            cur->init_sec_buf_read_offset = 0;
> -            ff_format_io_close(cur->parent, &cur->input);
> -            ret = reopen_demux_for_component(s, cur);
> -            cur->is_restart_needed = 0;
> -        }
> -    }
> -    return AVERROR_EOF;
> -}
>
> -static int dash_close(AVFormatContext *s)
> -{
> -    DASHContext *c = s->priv_data;
> -    free_audio_list(c);
> -    free_video_list(c);
> -    free_subtitle_list(c);
> -    av_dict_free(&c->avio_opts);
> -    av_freep(&c->base_url);
> +    ist = rep->ic->streams[pkt->stream_index];
> +
> +    if (/* New stream had been created by the underlying subdemuxer. */
> +        rep->nb_streams <= pkt->stream_index ||
> +        /* Something changed. */
> +        (ist->event_flags & AVSTREAM_EVENT_FLAG_METADATA_UPDATED))
> +        if ((ret = dash_subdemuxer_update(rep)) < 0)
> +            return ret;
> +
> +    /* Make packet timestamps comparable to each other. */
> +    rep->last_pts = av_rescale_q(pkt->pts + pkt->duration, ist->time_base, AV_TIME_BASE_Q);
> +
> +    ost = rep->ostreams[pkt->stream_index];
> +    if (ost->codecpar->codec_type != ist->codecpar->codec_type ||
> +        ost->codecpar->codec_id   != ist->codecpar->codec_id   ||
> +        ost->codecpar->codec_tag  != ist->codecpar->codec_tag)
> +        if ((ret = dash_subdemuxer_update(rep)) < 0)
> +            return ret;
> +
> +    /* Translate stream_index from inner to outer context. */
> +    pkt->stream_index = ost->index;
> +
>      return 0;
>  }
>
> -static int dash_seek(AVFormatContext *s, struct representation *pls, int64_t seek_pos_msec, int flags, int dry_run)
> -{
> -    int ret = 0;
> -    int i = 0;
> -    int j = 0;
> -    int64_t duration = 0;
> -
> -    av_log(pls->parent, AV_LOG_VERBOSE, "DASH seek pos[%"PRId64"ms] %s\n",
> -           seek_pos_msec, dry_run ? " (dry)" : "");
> -
> -    // single fragment mode
> -    if (pls->n_fragments == 1) {
> -        pls->cur_timestamp = 0;
> -        pls->cur_seg_offset = 0;
> -        if (dry_run)
> -            return 0;
> -        ff_read_frame_flush(pls->ctx);
> -        return av_seek_frame(pls->ctx, -1, seek_pos_msec * 1000, flags);
> -    }
> -
> -    ff_format_io_close(pls->parent, &pls->input);
> -
> -    // find the nearest fragment
> -    if (pls->n_timelines > 0 && pls->fragment_timescale > 0) {
> -        int64_t num = pls->first_seq_no;
> -        av_log(pls->parent, AV_LOG_VERBOSE, "dash_seek with SegmentTimeline start n_timelines[%d] "
> -               "last_seq_no[%"PRId64"].\n",
> -               (int)pls->n_timelines, (int64_t)pls->last_seq_no);
> -        for (i = 0; i < pls->n_timelines; i++) {
> -            if (pls->timelines[i]->starttime > 0) {
> -                duration = pls->timelines[i]->starttime;
> -            }
> -            duration += pls->timelines[i]->duration;
> -            if (seek_pos_msec < ((duration * 1000) /  pls->fragment_timescale)) {
> -                goto set_seq_num;
> -            }
> -            for (j = 0; j < pls->timelines[i]->repeat; j++) {
> -                duration += pls->timelines[i]->duration;
> -                num++;
> -                if (seek_pos_msec < ((duration * 1000) /  pls->fragment_timescale)) {
> -                    goto set_seq_num;
> -                }
> -            }
> -            num++;
> -        }
> -
> -set_seq_num:
> -        pls->cur_seq_no = num > pls->last_seq_no ? pls->last_seq_no : num;
> -        av_log(pls->parent, AV_LOG_VERBOSE, "dash_seek with SegmentTimeline end cur_seq_no[%"PRId64"].\n",
> -               (int64_t)pls->cur_seq_no);
> -    } else if (pls->fragment_duration > 0) {
> -        pls->cur_seq_no = pls->first_seq_no + ((seek_pos_msec * pls->fragment_timescale) / pls->fragment_duration) / 1000;
> -    } else {
> -        av_log(pls->parent, AV_LOG_ERROR, "dash_seek missing timeline or fragment_duration\n");
> -        pls->cur_seq_no = pls->first_seq_no;
> -    }
> -    pls->cur_timestamp = 0;
> -    pls->cur_seg_offset = 0;
> -    pls->init_sec_buf_read_offset = 0;
> -    ret = dry_run ? 0 : reopen_demux_for_component(s, pls);
> -
> -    return ret;
> -}
> -
>  static int dash_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
>  {
> -    int ret = 0, i;
> +    int ret = 0;
>      DASHContext *c = s->priv_data;
> -    int64_t seek_pos_msec = av_rescale_rnd(timestamp, 1000,
> -                                           s->streams[stream_index]->time_base.den,
> -                                           flags & AVSEEK_FLAG_BACKWARD ?
> -                                           AV_ROUND_DOWN : AV_ROUND_UP);
> -    if ((flags & AVSEEK_FLAG_BYTE) || c->is_live)
> +    AVStream *st;
> +    int64_t now_ts;
> +
> +    if (flags & AVSEEK_FLAG_BYTE)
>          return AVERROR(ENOSYS);
>
> -    /* Seek in discarded streams with dry_run=1 to avoid reopening them */
> -    for (i = 0; i < c->n_videos; i++) {
> -        if (!ret)
> -            ret = dash_seek(s, c->videos[i], seek_pos_msec, flags, !c->videos[i]->ctx);
> -    }
> -    for (i = 0; i < c->n_audios; i++) {
> -        if (!ret)
> -            ret = dash_seek(s, c->audios[i], seek_pos_msec, flags, !c->audios[i]->ctx);
> -    }
> -    for (i = 0; i < c->n_subtitles; i++) {
> -        if (!ret)
> -            ret = dash_seek(s, c->subtitles[i], seek_pos_msec, flags, !c->subtitles[i]->ctx);
> +    st = s->streams[stream_index];
> +    now_ts = av_rescale_q_rnd(timestamp, st->time_base, AV_TIME_BASE_Q,
> +                              (flags & AVSEEK_FLAG_BACKWARD)
> +                                  ? AV_ROUND_DOWN : AV_ROUND_UP);
> +
> +    for (unsigned i = 0; i < c->nb_reps; ++i) {
> +        DASHRepresentation *rep = c->reps[i];
> +
> +        if (!rep->ic)
> +            continue;
> +
> +        rep->last_pts = AV_NOPTS_VALUE;
> +
> +        rep->read_ts = c->start_ts + now_ts;
> +
> +        if ((ret = av_seek_frame(rep->ic, -1, now_ts, flags)) < 0) {
> +            av_log(s, AV_LOG_ERROR, "Failed to seek subdemuxer\n");
> +            /* abort(); */
> +        }
> +
> +        dash_subdemuxer_flush(rep);
>      }
>
>      return ret;
>  }
>
> -static int dash_probe(const AVProbeData *p)
> +static av_cold int dash_probe(const AVProbeData *p)
>  {
> -    if (!av_stristr(p->buf, "<MPD"))
> -        return 0;
> +    if (strstr(p->buf, "<?xml") &&
> +        strstr(p->buf, "<MPD"))
> +        return AVPROBE_SCORE_MAX;
>
> -    if (av_stristr(p->buf, "dash:profile:isoff-on-demand:2011") ||
> -        av_stristr(p->buf, "dash:profile:isoff-live:2011") ||
> -        av_stristr(p->buf, "dash:profile:isoff-live:2012") ||
> -        av_stristr(p->buf, "dash:profile:isoff-main:2011") ||
> -        av_stristr(p->buf, "3GPP:PSS:profile:DASH1")) {
> +    if (p->mime_type && !strncmp(p->mime_type, "application/dash+xml", 20))
>          return AVPROBE_SCORE_MAX;
> -    }
> -    if (av_stristr(p->buf, "dash:profile")) {
> -        return AVPROBE_SCORE_MAX;
> -    }
>
>      return 0;
>  }
>
>  #define OFFSET(x) offsetof(DASHContext, x)
> -#define FLAGS AV_OPT_FLAG_DECODING_PARAM
>  static const AVOption dash_options[] = {
> -    {"allowed_extensions", "List of file extensions that dash is allowed to access",
> -        OFFSET(allowed_extensions), AV_OPT_TYPE_STRING,
> -        {.str = "aac,m4a,m4s,m4v,mov,mp4,webm,ts"},
> -        INT_MIN, INT_MAX, FLAGS},
> -    {NULL}
> +    { "connections", "Number of segment requests on the fly (per representation)",
> +        OFFSET(nb_connections), AV_OPT_TYPE_INT,
> +        { .i64 = 1 }, .min = 1, .max = UINT_MAX, .flags = AV_OPT_FLAG_DECODING_PARAM },
> +    { "protocol_opts", "Specify protocol options for opened segments",
> +        OFFSET(protocol_opts), AV_OPT_TYPE_DICT,
> +        .flags = AV_OPT_FLAG_DECODING_PARAM },
> +    { NULL }
>  };
>
>  static const AVClass dash_class = {
> @@ -2407,5 +3149,6 @@ AVInputFormat ff_dash_demuxer = {
>      .read_packet    = dash_read_packet,
>      .read_close     = dash_close,
>      .read_seek      = dash_read_seek,
> +    .extensions     = "mpd",
>      .flags          = AVFMT_NO_BYTE_SEEK,
>  };
> diff --git a/libavformat/internal.h b/libavformat/internal.h
> index 3c6b292..ee547e0 100644
> --- a/libavformat/internal.h
> +++ b/libavformat/internal.h
> @@ -33,6 +33,8 @@
>  #define PROBE_BUF_MIN 2048
>  #define PROBE_BUF_MAX (1 << 20)
>
> +#define UUID_BUF_SIZE 36
> +
>  #ifdef DEBUG
>  #    define hex_dump_debug(class, buf, size) av_hex_dump_log(class, AV_LOG_DEBUG, buf, size)
>  #else
> @@ -379,6 +381,18 @@ do {\
>   */
>  int ff_mkdir_p(const char *path);
>
> +char *ff_uuid_to_hex(char *buff, const uint8_t *src, int lowercase);
> +
> +/**
> + * Parse an UUID string.
> + *
> + * @param data the parsed data is written to this pointer
> + * @param p the string to parse
> + * @return the number of bytes written that is always 16 or negative number on
> + * error
> + */
> +int ff_uuid_to_data(uint8_t *data, const char *p);
> +
>  char *ff_data_to_hex(char *buf, const uint8_t *src, int size, int lowercase);
>
>  /**
> diff --git a/libavformat/utils.c b/libavformat/utils.c
> index ee947c1..d6b8418 100644
> --- a/libavformat/utils.c
> +++ b/libavformat/utils.c
> @@ -4878,6 +4878,53 @@ int ff_mkdir_p(const char *path)
>      return ret;
>  }
>
> +char *ff_uuid_to_hex(char *buff, const uint8_t *src, int lowercase)
> +{
> +    ff_data_to_hex(buff + 0, src + 0, 4, lowercase);
> +    buff[8] = '-';
> +    ff_data_to_hex(buff + 9, src + 4, 2, lowercase);
> +    buff[13] = '-';
> +    ff_data_to_hex(buff + 14, src + 6, 2, lowercase);
> +    buff[18] = '-';
> +    ff_data_to_hex(buff + 19, src + 8, 2, lowercase);
> +    buff[23] = '-';
> +    ff_data_to_hex(buff + 24, src + 10, 6, lowercase);
> +
> +    return buff;
> +}
> +
> +int ff_uuid_to_data(uint8_t *data, const char *p)
> +{
> +    uint8_t len;
> +
> +    for (len = 0; len < 16; ) {
> +        uint8_t h, l;
> +
> +#define PARSE_XDIGIT(ch, res) \
> +        if ('0' <= ch && ch <= '9') \
> +            res = ch - '0'; \
> +        else if ('A' <= ch && ch <= 'F') \
> +            res = ch - 'A' + 10; \
> +        else if ('a' <= ch && ch <= 'f') \
> +            res = ch - 'a' + 10; \
> +        else \
> +            return -1;
> +
> +        PARSE_XDIGIT(p[0], h);
> +        PARSE_XDIGIT(p[1], l);
> +        p += 2;
> +
> +#undef PARSE_XDIGIT
> +
> +        data[len++] = (h << 4) | l;
> +
> +        if ((4 == len || 6 == len || 8 == len || 10 == len) && *p++ != '-')
> +            return -1;
> +    }
> +
> +    return *p == '\0' ? 16 : -1;
> +}
> +
>  char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
>  {
>      int i;
> --
> 2.30.1
>
> _______________________________________________
> ffmpeg-devel mailing list
> ffmpeg-devel@ffmpeg.org
> https://ffmpeg.org/mailman/listinfo/ffmpeg-devel
>
> To unsubscribe, visit link above, or email
> ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".