From patchwork Mon Mar 22 22:25:14 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: zsugabubus X-Patchwork-Id: 26546 Return-Path: X-Original-To: patchwork@ffaux-bg.ffmpeg.org Delivered-To: patchwork@ffaux-bg.ffmpeg.org Received: from ffbox0-bg.mplayerhq.hu (ffbox0-bg.ffmpeg.org [79.124.17.100]) by ffaux.localdomain (Postfix) with ESMTP id DAB0B449583 for ; Tue, 23 Mar 2021 00:25:44 +0200 (EET) Received: from [127.0.1.1] (localhost [127.0.0.1]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTP id A6D5068AA83; Tue, 23 Mar 2021 00:25:44 +0200 (EET) X-Original-To: ffmpeg-devel@ffmpeg.org Delivered-To: ffmpeg-devel@ffmpeg.org Received: from mail.cock.li (unknown [37.120.193.123]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTPS id 16F0B688316 for ; Tue, 23 Mar 2021 00:25:37 +0200 (EET) Date: Mon, 22 Mar 2021 23:25:14 +0100 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=national.shitposting.agency; s=mail; t=1616451934; bh=nPRCDf5DLZOzLe8pAmtgUrGgdM02XmTH2ErjQ6rvID0=; h=Date:From:To:Subject:From; b=j76V1xaMbu/OigHw3A3/n1l++/roWMQEzUzUHM+s3FW1jCE80m1QBxNc85nCpkI1+ oZlaIS7pXd8Rr06KRv8Pl+5qSuUwiLDpx/EI/rXqk98gVr54sm4rqsV7697r3adDci VyCGPwKD4Arl55Bops1VGdbbLttynaOgkZa15+9H4BGOLdXN5AiYEED9C4g1KG1yZh ns4kBdgXqiOZDd1kplmjzqCH+df4/848mGTP07QJOqMRyS69xqaKmzp5PZVX/ER9YG QzJCE+Xf6wuD9fERoj8geH14eUB/CtUcCSdpYspZ2cdtpxgeGwn+Db/sgXlGestCZZ awYDkNgznkX2g== From: zsugabubus To: ffmpeg-devel@ffmpeg.org Message-ID: <20210322222514.rwremenfu5uabtwf@localhost> MIME-Version: 1.0 Content-Disposition: inline Subject: [FFmpeg-devel] [RFC PATCH] avformat/dashdec: Improve implementation X-BeenThere: ffmpeg-devel@ffmpeg.org X-Mailman-Version: 2.1.20 Precedence: list List-Id: FFmpeg development discussions and patches List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Reply-To: FFmpeg development discussions and patches Errors-To: ffmpeg-devel-bounces@ffmpeg.org Sender: "ffmpeg-devel" 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 --- 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 +#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, ×cale); + 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, ×cale); + 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;iinit_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, "buf, "buf, "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;