[FFmpeg-devel] [RFC PATCH v2] avformat/dashdec: Improve implementation
zsugabubus
zsugabubus at national.shitposting.agency
Sat Apr 10 03:37:47 EEST 2021
Signed-off-by: zsugabubus <zsugabubus at national.shitposting.agency>
---
Should compile fine now.
libavformat/dashdec.c | 4614 +++++++++++++++++++++++++++++++++++++++++++-------------------------------
libavformat/internal.h | 27 +
libavformat/utils.c | 47 +
3 files changed, 2757 insertions(+), 1931 deletions(-)
diff --git a/libavformat/dashdec.c b/libavformat/dashdec.c
index 6f3f28d..b7a2548 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 at o2.pl based on HLS demux
* Copyright (c) 2017 Steven Liu
+ * Copyright (c) 2020 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 at o2.pl
+ * @author Steven Liu
+ * @author reworked by zsugabubus
+ * @see DASH-IF spec: https://dashif-documents.azurewebsites.net/DASH-IF-IOP/master/DASH-IF-IOP.html
+ * @see another spec: https://dashif-documents.azurewebsites.net/Guidelines-TimingModel/master/Guidelines-TimingModel.html
+ * @see test vectors: https://testassets.dashif.org/
+ * @see MPD scheme: https://standards.iso.org/ittf/PubliclyAvailableStandards/MPEG-DASH_schema_files/DASH-MPD.xsd
+ */
+
#include <libxml/parser.h>
+#include "libavutil/encryption_info.h"
#include "libavutil/intreadwrite.h"
+#include "libavutil/lfg.h"
+#include "libavutil/random_seed.h"
+#include "libavutil/avassert.h"
#include "libavutil/opt.h"
#include "libavutil/time.h"
#include "libavutil/parseutils.h"
#include "internal.h"
#include "avio_internal.h"
-#include "dash.h"
+#include "libavutil/base64.h"
+
+#if CONFIG_HTTP_PROTOCOL
+# include "http.h"
+#endif
+
+#define MICROSEC_PER_SEC 1000000L
+#define MILLISEC_PER_SEC (MICROSEC_PER_SEC / 1000L)
-#define INITIAL_BUFFER_SIZE 32768
-#define MAX_BPRINT_READ_SIZE (UINT_MAX - 1)
-#define DEFAULT_MANIFEST_SIZE 8 * 1024
+static const char CENC_NAMESPACE[] = "urn:mpeg:cenc:2013";
-struct fragment {
- int64_t url_offset;
- int64_t size;
- char *url;
+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 at 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_INITIALIZER (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)
+{
+ 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)
{
- const char *proto_name = avio_find_protocol_name(url);
- return proto_name && av_strstart(proto_name, "http", NULL);
+ 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,2719 @@ 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)
+/**
+ * Parse ISO-8601 duration.
+ * @return duration in AV_TIME_BASE
+ */
+static int64_t dash_parse_duration(const char *s, AVFormatContext *log_ctx)
{
- /* 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++;
+ 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 */
- }
- 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;
+ 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;
- default:
- // handle invalid type
+ 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;
}
- ptr += size;
+
+ if (!unit) {
+ invalid:
+ av_log(log_ctx, AV_LOG_ERROR, "Malformed ISO-8601 duration: '%s'\n", s);
+ return INT64_MIN;
+ }
+
+ ret += unit * base;
}
- return ((days * 24 + hours) * 60 + mins) * 60 + secs;
+
+ return ret;
}
-static int64_t get_segment_start_time_based_on_timeline(struct representation *pls, int64_t cur_seq_no)
+static av_cold void dash_subdemuxer_flush(DASHRepresentation *rep)
{
- int64_t start_time = 0;
- int64_t i = 0;
- int64_t j = 0;
- int64_t num = 0;
+ DASHContext *c = rep->oc->priv_data;
- 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;
+ avio_flush(&rep->ic_pb);
+ for (unsigned i = 0; i < c->nb_connections; ++i)
+ ff_format_io_close(rep->oc, &rep->segments[i].pb);
- start_time += pls->timelines[i]->duration;
- if (pls->timelines[i]->repeat == -1) {
- start_time = pls->timelines[i]->duration * cur_seq_no;
- goto finish;
- }
+ /* for (unsigned i = 0; i < rep->nb_streams; ++i)
+ avcodec_flush_buffers(rep->ostreams[i]->internal->avctx); */
- for (j = 0; j < pls->timelines[i]->repeat; j++) {
- num++;
- if (num == cur_seq_no)
- goto finish;
- start_time += pls->timelines[i]->duration;
- }
- num++;
+ 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;
}
}
-finish:
- return start_time;
}
-static int64_t calc_next_seg_no_from_timelines(struct representation *pls, int64_t cur_time)
+static av_cold void dash_subdemuxer_close(DASHRepresentation *rep)
{
- int64_t i = 0;
- int64_t j = 0;
- int64_t num = 0;
- int64_t start_time = 0;
+ av_log(rep->oc, AV_LOG_DEBUG, "Closing representation '%s'\n", rep->id);
- 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;
+ /* 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;
}
- num++;
}
+}
- return -1;
+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);
+}
-finish:
- return num;
+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 void free_fragment(struct fragment **seg)
+static av_cold xmlNodePtr xml_get_nsnode(xmlNodePtr node, const char *nodename, const char *namespace)
{
- if (!(*seg)) {
- return;
- }
- av_freep(&(*seg)->url);
- av_freep(seg);
+ xml_for_each_child
+ if (!strcmp(child->name, nodename) &&
+ (child->ns && !strcmp(child->ns->href, namespace)))
+ return child;
+ return NULL;
}
-static void free_fragment_list(struct representation *pls)
+static av_cold int dash_parse_contentprotection_pssh(AVFormatContext *s,
+ struct AVEncryptionInitInfo *info,
+ xmlNodePtr node)
{
- int i;
+ 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;
- for (i = 0; i < pls->n_fragments; i++) {
- free_fragment(&pls->fragments[i]);
+ 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;
}
- av_freep(&pls->fragments);
- pls->n_fragments = 0;
-}
-static void free_timelines_list(struct representation *pls)
-{
- int i;
+ if ((decoded_size = av_base64_decode(decoded_pssh, pssh, decoded_size)) < 0) {
+ av_free(decoded_pssh);
- for (i = 0; i < pls->n_timelines; i++) {
- av_freep(&pls->timelines[i]);
+ invalid_content:
+ av_log(s, AV_LOG_ERROR, "Invalid %s/{%s}:pssh content\n",
+ node->name, CENC_NAMESPACE);
+ ret = AVERROR_INVALIDDATA;
+ goto out;
}
- av_freep(&pls->timelines);
- pls->n_timelines = 0;
+
+ info->data = decoded_pssh;
+ info->data_size = decoded_size;
+
+out:
+ xml_free(pssh);
+ return ret;
}
-static void free_representation(struct representation *pls)
+static av_cold void dash_free_scheme(DASHScheme *scheme)
{
- 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);
- }
+ xml_free(scheme->scheme_id);
+ xml_free(scheme->value);
+}
- av_freep(&pls->url_template);
- av_freep(&pls->lang);
- av_freep(&pls->id);
- av_freep(&pls);
+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 void free_video_list(DASHContext *c)
+static av_cold void dash_log_missing_attr(AVFormatContext *log_ctx, xmlNodePtr node, const char *attr)
{
- 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;
+ av_log(log_ctx, AV_LOG_ERROR, "Missing %s/%s@%s\n",
+ node->parent->name,
+ node->name,
+ attr);
}
-static void free_audio_list(DASHContext *c)
+static av_cold void dash_log_unknown_child(AVFormatContext *log_ctx, xmlNodePtr child)
{
- int i;
- for (i = 0; i < c->n_audios; i++) {
- struct representation *pls = c->audios[i];
- free_representation(pls);
- }
- av_freep(&c->audios);
- c->n_audios = 0;
+ av_log(log_ctx, AV_LOG_WARNING, "Unknown %s/%s\n",
+ child->parent->name,
+ child->name);
}
-static void free_subtitle_list(DASHContext *c)
+static av_cold void dash_log_unknown_attr(AVFormatContext *log_ctx, xmlAttrPtr attr, const xmlChar *value)
{
- int i;
- for (i = 0; i < c->n_subtitles; i++) {
- struct representation *pls = c->subtitles[i];
- free_representation(pls);
- }
- av_freep(&c->subtitles);
- c->n_subtitles = 0;
+ 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 int open_url(AVFormatContext *s, AVIOContext **pb, const char *url,
- AVDictionary **opts, AVDictionary *opts2, int *is_http)
+static av_cold void dash_log_unknown_scheme(AVFormatContext *log_ctx, const DASHScheme *scheme)
{
- DASHContext *c = s->priv_data;
- AVDictionary *tmp = NULL;
- const char *proto_name = NULL;
- int ret;
+ 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 (av_strstart(url, "crypto", NULL)) {
- if (url[6] == '+' || url[6] == ':')
- proto_name = avio_find_protocol_name(url + 7);
+ if (!(scheme->scheme_id_attr = xmlHasNsProp(node, "schemeIdUri", NULL))) {
+ dash_log_missing_attr(s, node, "schemeIdUri");
+ return AVERROR_INVALIDDATA;
}
- if (!proto_name)
- proto_name = avio_find_protocol_name(url);
+ if (!(scheme->scheme_id = xmlNodeGetContent(scheme->scheme_id_attr->children)))
+ return AVERROR(ENOMEM);
- if (!proto_name)
+ if (!(scheme->value = xmlGetNoNsProp(node, "value")) && value_required) {
+ dash_log_missing_attr(s, node, "value");
return AVERROR_INVALIDDATA;
+ }
- // 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;
- }
- } else if (av_strstart(proto_name, "http", NULL)) {
- ;
- } else
- return AVERROR_INVALIDDATA;
+ return 0;
+}
- 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;
+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 at cenc:default_KID='%s'\n",
+ scheme.scheme_id);
+ else
+ cp->has_key_id = 1;
- 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;
+ xmlFree(key_id);
+ } else {
+ dash_log_missing_attr(s, node, "default_KID");
+ }
- if (!(s->flags & AVFMT_FLAG_CUSTOM_IO))
- av_opt_get(*pb, "cookies", AV_OPT_SEARCH_CHILDREN, (uint8_t**)&new_cookies);
+ 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);
+ if (!init_info) {
+ ret = AVERROR(ENOMEM);
+ goto out;
+ }
- if (new_cookies) {
- av_dict_set(opts, "cookies", new_cookies, AV_DICT_DONT_STRDUP_VAL);
+ if (ff_uuid_to_data(init_info->system_id, uuid) < 0) {
+ av_log(s, AV_LOG_ERROR, "Malformed UUID in ContentProtection at 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;
- av_dict_free(&tmp);
+ 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;
+ }
- if (is_http)
- *is_http = av_strstart(proto_name, "http", NULL);
+out:
+ if (init_info)
+ av_encryption_init_info_free(init_info);
+ dash_free_scheme(&scheme);
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 av_cold int dash_set_location(AVFormatContext *s, char const *url)
{
- int i;
- char *text;
- char *url = NULL;
- char *tmp_str = av_mallocz(max_url_size);
-
- if (!tmp_str)
- return NULL;
+ DASHContext *c = s->priv_data;
+ URLComponents uc;
+ char const *protocol;
- 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);
- }
- }
- }
+ if (ff_url_decompose(&uc, url, NULL) < 0)
+ return AVERROR_INVALIDDATA;
- if (val)
- ff_make_absolute_url(tmp_str, max_url_size, tmp_str, val);
+ av_free(c->location);
+ if (!(c->location = av_strdup(url)))
+ return AVERROR(ENOMEM);
- if (rep_id_val) {
- url = av_strireplace(tmp_str, "$RepresentationID$", rep_id_val);
- if (!url) {
- goto end;
- }
- 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;
+ 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);
}
}
-end:
- av_free(tmp_str);
- return url;
+
+ return 0;
}
-static char *get_val_from_nodes_tab(xmlNodePtr *nodes, const int n_nodes, const char *attrname)
+static av_cold int dash_parse_location(AVFormatContext *s,
+ xmlNodePtr node)
{
- int i;
- char *val;
+ int ret = 0;
+ char *value;
+ DASHContext *c = s->priv_data;
- for (i = 0; i < n_nodes; ++i) {
- if (nodes[i]) {
- val = xmlGetProp(nodes[i], attrname);
- if (val)
- return val;
- }
+ if (!c->is_live) {
+ av_log(s, AV_LOG_INFO, "MPD at type=\"static\"/Location ignored\n");
+ return 0;
}
- return NULL;
-}
+ if (!(value = xmlNodeGetContent(node)))
+ return AVERROR(ENOMEM);
-static xmlNodePtr find_child_node_by_name(xmlNodePtr rootnode, const char *nodename)
-{
- xmlNodePtr node = rootnode;
- if (!node) {
- return NULL;
- }
+ ret = dash_set_location(s, value);
- node = xmlFirstElementChild(node);
- while (node) {
- if (!av_strcasecmp(node->name, nodename)) {
- return node;
- }
- node = xmlNextElementSibling(node);
- }
- return NULL;
+ xmlFree(value);
+ return ret;
}
-static enum AVMediaType get_content_type(xmlNodePtr node)
-{
- 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);
- }
- }
- }
- return type;
+/**
+ * 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 struct fragment * get_Fragment(char *range)
+static av_cold DASHURLList *dash_new_urllist(unsigned nb_urls)
{
- struct fragment * seg = av_mallocz(sizeof(struct fragment));
+ DASHURLList *urls;
- if (!seg)
+ if (!(urls = av_mallocz(offsetof(DASHURLList, elems[nb_urls]))))
return NULL;
- 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;
- }
+ dash_ref_urllist(urls);
+ urls->nb = nb_urls;
- return seg;
+ return urls;
}
-static int parse_manifest_segmenturlnode(AVFormatContext *s, struct representation *rep,
- xmlNodePtr fragmenturl_node,
- xmlNodePtr *baseurl_nodes,
- char *rep_id_val,
- char *rep_bandwidth_val)
+static av_cold int dash_parse_baseurl(AVFormatContext *s,
+ DASHURLList **urls,
+ xmlNodePtr node)
{
+ int ret = 0;
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);
- return AVERROR(ENOMEM);
- }
- }
- } 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);
- return AVERROR(ENOMEM);
- }
- err = av_dynarray_add_nofree(&rep->fragments, &rep->n_fragments, seg);
- if (err < 0) {
- free_fragment(&seg);
- return err;
- }
- }
- }
+ char *url_chunk = NULL;
+ char *resolved_url = NULL;
+ DASHURLList *new_urls = NULL;
+ int is_absolute;
+ char *base_url;
- return 0;
-}
+ if (!(url_chunk = xmlNodeGetContent(node)))
+ return AVERROR(ENOMEM);
-static int parse_manifest_segmenttimeline(AVFormatContext *s, struct representation *rep,
- xmlNodePtr fragment_timeline_node)
-{
- xmlAttrPtr attr = NULL;
- char *val = NULL;
- int err;
+ base_url = (*urls)->elems[0];
+ if ((ret = ff_make_absolute_urla(&resolved_url, base_url, url_chunk)) < 0)
+ goto out;
- 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 (dash_urllist_has(*urls, resolved_url))
+ goto out;
- if (!val) {
- av_log(s, AV_LOG_WARNING, "parse_manifest_segmenttimeline attr->name = %s val is NULL\n", attr->name);
- continue;
- }
+ is_absolute = !strcmp(resolved_url, url_chunk);
- 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);
+ 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;
}
- attr = attr->next;
- xmlFree(val);
+ } 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;
}
- err = av_dynarray_add_nofree(&rep->timelines, &rep->n_timelines, tml);
- if (err < 0) {
- av_free(tml);
- return err;
+
+ /* 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 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);
-
- 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);
+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;
}
- 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);
+ return 0;
+}
- path = av_mallocz(tmp_max_url_size);
- tmp_str = av_mallocz(tmp_max_url_size);
- if (!tmp_str || !path) {
- updated = AVERROR(ENOMEM);
- goto end;
+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 'a': par->codec_type = AVMEDIA_TYPE_AUDIO; break;
+ case 'v': par->codec_type = AVMEDIA_TYPE_VIDEO; break;
+ default: return 1;
+ }
+
+ } 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;
}
- 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);
- }
+ return 0;
+}
- node = baseurl_nodes[rootId];
- baseurl = xmlNodeGetContent(node);
- root_url = (av_strcasecmp(baseurl, "")) ? baseurl : path;
- if (node) {
- xmlNodeSetContent(node, root_url);
- updated = 1;
+static av_cold int dash_parse_scantype(AVFormatContext *s,
+ DASHParameters *par,
+ const xmlChar *value)
+{
+ if (!strcmp(value, "progressive")) {
+ par->field_order = AV_FIELD_PROGRESSIVE;
+ } else {
+ par->field_order = AV_FIELD_UNKNOWN;
+ return 1;
}
- size = strlen(root_url);
- isRootHttp = ishttp(root_url);
+ return 0;
+}
- if (size > 0 && root_url[size - 1] != token) {
- av_strlcat(root_url, "/", size + 2);
- size += 2;
- }
+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;
- 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;
- }
- 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);
- }
+ return 0;
+}
+
+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);
+ }
+
+out:
+ dash_free_scheme(&scheme);
+ return ret;
+}
+
+static av_cold int dash_parse_assetidentifier(AVFormatContext *s,
+ DASHPeriod *period,
+ xmlNodePtr node)
+{
+ int ret = 0;
+ DASHScheme scheme;
+
+ if ((ret = dash_parse_scheme(s, &scheme, 1, node)) < 0)
+ goto out;
+
+ 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);
+ }
+
+out:
+ dash_free_scheme(&scheme);
+ return ret;
+}
+
+static av_cold int dash_parse_viewpoint(AVFormatContext *s,
+ DASHAdaptationSet *as,
+ xmlNodePtr node)
+{
+ 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);
}
-end:
- if (tmp_max_url_size > *max_url_size) {
- *max_url_size = tmp_max_url_size;
+out:
+ dash_free_scheme(&scheme);
+ return ret;
+}
+
+static av_cold void dash_sync_time(AVFormatContext *s, const xmlChar *value)
+{
+ 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;
}
- av_free(path);
- av_free(tmp_str);
- xmlFree(baseurl);
- return updated;
+ 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));
+ }
}
-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)
+static av_cold int dash_parse_utctiming(AVFormatContext *s,
+ xmlNodePtr node)
{
- int32_t ret = 0;
+ int 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);
+ 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;
+}
+
+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);
+ }
+
+out:
+ dash_free_scheme(&scheme);
+ return ret;
+}
+
+static av_cold int dash_parse_property(AVFormatContext *s,
+ DASHAdaptationSet *as,
+ DASHRepresentationPeriod *rep,
+ xmlNodePtr node)
+{
+ 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);
+ }
+
+out:
+ dash_free_scheme(&scheme);
+ return ret;
+}
+
+static av_cold int dash_check_existing_timeline(AVFormatContext *s, DASHTimeline **out_timeline, xmlNodePtr timeline_node)
+{
+ 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 int dash_parse_segmentlist(AVFormatContext *s,
+ DASHPeriod *period,
+ DASHTimeline **out_timeline,
+ xmlNodePtr node)
+{
+ 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);
}
- // 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);
- }
+ xml_for_each_child {
+ if (!strcmp(child->name, "SegmentURL"))
+ ++nb_segments;
+ else
+ dash_log_unknown_child(s, child);
}
- 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);
+
+ 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);
}
- 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 (!g->url) {
+ dash_log_missing_attr(s, node, "media");
+ ret = AVERROR_INVALIDDATA;
+ goto out;
}
- 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 {
- rep->last_seq_no =(int64_t) strtoll(val, NULL, 10) - 1;
- xmlFree(val);
+
+ ++g;
+ }
+
+ *out_timeline = dash_ref_timeline(timeline);
+
+out:
+ dash_unref_timeline(timeline);
+ return ret;
+}
+
+static av_cold int dash_parse_segmenttimeline(AVFormatContext *s,
+ DASHPeriod *period,
+ uint64_t start_number,
+ DASHTimeline **out_timeline,
+ xmlNodePtr node)
+{
+ 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;
}
- }
- }
- fragment_timeline_node = find_child_node_by_name(representation_segmenttemplate_node, "SegmentTimeline");
-
- 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);
+ 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);
}
}
- } 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);
- }
- 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);
- }
+ start_number = g->number + (g->repeat + 1);
+ start_ts = g->start_ts + g->duration * (g->repeat + 1);
+ ++g;
+ }
+
+ *out_timeline = dash_ref_timeline(timeline);
+
+out:
+ dash_unref_timeline(timeline);
+ return ret;
+}
+
+/* One init URL and list of template arguments. */
+static av_cold int dash_parse_segmenttemplate(AVFormatContext *s,
+ DASHPeriod *period,
+ DASHTimeline **out_timeline,
+ xmlNodePtr node)
+{
+ 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;
- 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);
+ 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);
+ }
+
+ /* value has to be free()'d */
+ if (ret < 0)
+ goto out;
+
+ if (!init_url || !media_url) {
+ ret = AVERROR_INVALIDDATA;
+ dash_log_missing_attr(s, node, !init_url ? "initialization" : "media");
+ goto out;
+ }
+
+ 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 {
- av_log(s, AV_LOG_ERROR, "Unknown format of Representation node id '%s' \n",
- rep->id ? rep->id : "");
- goto free;
- }
-
- 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);
+ 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)
- av_log(s, AV_LOG_VERBOSE, "Ignoring invalid frame rate '%s'\n", rep_framerate_val);
- xmlFree(rep_framerate_val);
+ goto out;
+ }
+
+ /* Either a SegmentTemplate at 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;
}
- }
- 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);
+ timeline->duration = INT64_MAX;
+ timeline->timescale = timescale;
+ timeline->init.range = DASH_RANGE_INITIALIZER;
+ timeline->init.url = init_url;
+ init_url = NULL;
+ timeline->u.templates.master.url = media_url;
+ media_url = NULL;
+
+ timeline->u.templates.master.range = DASH_RANGE_INITIALIZER;
+ *out_timeline = dash_ref_timeline(timeline);
+
+out:
+ xml_free(init_url);
+ xml_free(media_url);
+ dash_unref_timeline(timeline);
return ret;
-enomem:
- ret = AVERROR(ENOMEM);
-free:
- free_representation(rep);
- goto end;
}
-static int parse_manifest_adaptationset_attr(AVFormatContext *s, xmlNodePtr adaptionset_node)
+static DASHRange dash_parse_range(const char *s, AVFormatContext *log_ctx)
{
- DASHContext *c = s->priv_data;
+ DASHRange range = {
+ .start = 0,
+ .end = INT64_MAX
+ };
+ (void)av_sscanf(s, "%"SCNd64"-%"SCNd64, &range.start, &range.end);
+ return range;
+}
- if (!adaptionset_node) {
- av_log(s, AV_LOG_WARNING, "Cannot get AdaptionSet\n");
- return AVERROR(EINVAL);
+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);
}
- c->adaptionset_lang = xmlGetProp(adaptionset_node, "lang");
+ (void)g;
+
+ *out_timeline = dash_ref_timeline(timeline);
+
+out:
+ dash_unref_timeline(timeline);
return 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)
+/**
+ * Make segment URL.
+ * @param base Absolute base path.
+ * @param template Absolute or relative path, potentially containing $ template
+ * arguments that will be substituted. 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$)
{
- 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;
+ enum { MAX_DIGITS = 20 };
- 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;
+ 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 (!(url = av_malloc(max_url_size)))
+ return NULL;
+
+ 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++ = '$';
+ }
+
+#undef IS
+
+ /* Go over $. */
+ if ((template = strchr(template + len, '$')))
+ ++template;
+ } else {
+ /* Copy remaining. */
+ strcpy(u, template);
+ break;
}
- node = xmlNextElementSibling(node);
}
-err:
- xmlFree(c->adaptionset_lang);
- c->adaptionset_lang = NULL;
- return ret;
+ return url;
}
-static int parse_programinformation(AVFormatContext *s, xmlNodePtr node)
+static int64_t dash_subdemuxer_seek(void *opaque, int64_t offset, int whence)
{
- xmlChar *val = NULL;
+ DASHRepresentation *rep = opaque;
+ return avio_seek(rep->segments[0].pb, offset, whence);
+}
- 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);
+static av_cold int dash_copy_stream_props(AVStream *slave, AVStream *master)
+{
+ int ret;
+
+ 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 av_cold DASHRepresentationPeriod *dash_find_representation_period_at(
+ DASHRepresentation *rep, int64_t timestamp)
+{
+ 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 NULL;
+}
+
+/**
+ * Update everything to make outside context of the representation look good.
+ *
+ * Must be called after:
+ * - rep->ic->streams changed,
+ * - rep->cur_period changed.
+ */
+static av_cold int dash_subdemuxer_update(DASHRepresentation *rep)
+{
+ int ret;
+ void *p;
+ AVFormatContext *oc = rep->oc;
+ AVFormatContext *ic = rep->ic;
+
+ 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;
+ }
+
+ rep->ic->event_flags &= ~AVFMT_EVENT_FLAG_METADATA_UPDATED;
+ rep->oc->event_flags |= AVFMT_EVENT_FLAG_METADATA_UPDATED;
+
+ 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;
+ }
+
+ 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;
+ size_t 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;
}
- } else if (!av_strcasecmp(node->name, "Copyright")) {
- val = xmlNodeGetContent(node);
- if (val) {
- av_dict_set(&s->metadata, "Copyright", val, 0);
+
+ 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 from 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;
}
- node = xmlNextElementSibling(node);
- xmlFree(val);
- val = NULL;
+
+ 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(AVFormatContext *s, const char *url, AVIOContext *in)
+static void dash_rotate_urllist(AVFormatContext *s, DASHURLList *urls)
{
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);
- av_dict_free(&opts);
- if (ret < 0)
- return ret;
+
+ 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 (av_opt_get(in, "location", AV_OPT_SEARCH_CHILDREN, (uint8_t**)&c->base_url) < 0)
- c->base_url = av_strdup(url);
+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
- filesize = avio_size(in);
- filesize = filesize > 0 ? filesize : DEFAULT_MANIFEST_SIZE;
+ if (rep->segments[seg].pb &&
+ !rep->segments[seg].pb->eof_reached)
+ continue;
- if (filesize > MAX_BPRINT_READ_SIZE) {
- av_log(s, AV_LOG_ERROR, "Manifest too large: %"PRId64"\n", filesize);
- return AVERROR_INVALIDDATA;
- }
+ for (unsigned i = 0; i < rep->nb_periods; ++i) {
+ int64_t period_ts;
+ DASHTimeline *timeline;
- av_bprint_init(&buf, filesize + 1, AV_BPRINT_SIZE_UNLIMITED);
+ period = rep->periods[i];
+ timeline = period->timeline;
- 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
+ /* Check if we are inside Period boundaries. */
+ if (!(period->period->start_ts <= rep->read_ts &&
+ rep->read_ts < period->period->end_ts))
+ continue;
- doc = xmlReadMemory(buf.str, filesize, c->base_url, NULL, 0);
- root_element = xmlDocGetRootElement(doc);
- node = root_element;
+ /* 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);
+
+ 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);
+
+ if (period_ts < g->start_ts) {
+ /* Gap detected: Missing segments in timeline. */
+ period_ts = g->start_ts;
+ /**
+ * period_ts := 0
+ * Timeline at PTO := S
+ * <S t="S + 1" />
+ */
+ }
- if (!node) {
- ret = AVERROR_INVALIDDATA;
- av_log(s, AV_LOG_ERROR, "Unable to parse '%s' - missing root node\n", url);
- goto cleanup;
- }
+#if 0
+ av_log(rep->oc, AV_LOG_ERROR, "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
+ if (period_ts < end_time) {
+
+ /* If period changed push init section first. */
+ if (rep->cur_period != period) {
+ if (seg != rep->cur_segment)
+ goto read_segment;
+
+ if (!rep->save_init) {
+ rep->save_init = 1;
+
+ /* Send out stored part. */
+ if (0 < period->initbuf_size) {
+ memcpy(buf, period->initbuf, period->initbuf_size);
+ return period->initbuf_size;
+ }
+ }
+
+ rep->cur_period = period;
+ ret = dash_subdemuxer_update(rep);
+ if (ret < 0)
+ return ret;
+
+ range = timeline->init.range;
+ range.start += period->initbuf_size;
+
+ /* 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;
+ }
+
+ $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;
+ }
+ }
+ } 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 {
+ /* One segment timeline. */
+ continue;
+ }
- 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;
- }
+ base = period->base->elems[0];
+ template = g->url; /* HACK: URL is not template. */
+ range = g->range;
- 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);
+ goto found;
+ } else {
+ abort();
}
- attr = attr->next;
- 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;
+
+ /* Periods may be out-of-order so start searching next one from the beginning. */
+ i = 0;
}
- tmp_node = find_child_node_by_name(node, "BaseURL");
- if (tmp_node) {
- mpd_baseurl_node = xmlCopyNode(tmp_node,1);
+ if (seg == rep->cur_segment)
+ return AVERROR_EOF;
+ else
+ goto read_segment;
+
+ found:
+ if (template) {
+ url = dash_make_url(base, template, rep->id, $Number$, $Time$, period->bandwidth);
+ if (!url)
+ return AVERROR(ENOMEM);
} else {
- mpd_baseurl_node = xmlNewNode(NULL, "BaseURL");
+ url = (char *)base;
}
- // 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);
+ opts = NULL;
+
+ if (0 < range.start)
+ av_dict_set_int(&opts, "offset", range.start, 0);
+
+ if (range.end < INT64_MAX)
+ av_dict_set_int(&opts, "end_offset", range.end, 0);
+
+ av_dict_set(&opts, "multiple_requests", "1", 0);
+ av_dict_copy(&opts, c->protocol_opts, 0);
+
+#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);
+ }
+
+ if (template)
+ av_free(url);
+ av_dict_free(&opts);
+
+ if (ret < 0) {
+ 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;
}
- 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);
+
+ return ret;
+ } else {
+ goto read_segment;
}
- 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);
+ if (0 < range.start &&
+ avio_seek(s->pb, range.start, SEEK_SET) != range.start)
+ {
+ ret = AVERROR(EIO);
+ goto fail_segment;
+ }
+
+ 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 ((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;
}
- adaptionset_node = xmlNextElementSibling(adaptionset_node);
}
-cleanup:
- /*free the document */
- xmlFreeDoc(doc);
- xmlCleanupParser();
- xmlFreeNode(mpd_baseurl_node);
+ 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;
+ }
+
+ goto open_segment;
+}
+
+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;
+ av_log(s, AV_LOG_ERROR,
+ "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 av_cold int dash_subdemuxer_alloc(DASHRepresentation *rep)
+{
+ int ret = 0;
+ AVFormatContext *s = rep->oc;
+ DASHContext *c = s->priv_data;
+ uint8_t *buf;
+ int buf_size;
+
+ dash_subdemuxer_close(rep);
+
+ /* 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 (!(buf = av_malloc(buf_size + AV_INPUT_BUFFER_PADDING_SIZE))) {
+ ret = AVERROR(ENOMEM);
+ goto out;
}
- av_bprint_finalize(&buf, NULL);
- if (close_in) {
- avio_close(in);
+ 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;
+
+ /* Padding bytes must be zeroed out. */
+ memset(buf + buf_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
+
+ if (!(rep->ic = avformat_alloc_context())) {
+ ret = AVERROR(ENOMEM);
+ goto out;
}
+
+ 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 int64_t calc_cur_seg_no(AVFormatContext *s, struct representation *pls)
+/**
+ * Open the real context.
+ */
+static av_cold int dash_subdemuxer_open(DASHRepresentation *rep)
{
- DASHContext *c = s->priv_data;
- int64_t num = 0;
- int64_t start_time_offset = 0;
+ int ret = 0;
+ AVFormatContext *s = rep->oc;
+ AVInputFormat *iformat = NULL;
- 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;
+ av_log(s, AV_LOG_DEBUG, "Opening representation '%s'\n", rep->id);
+
+ if ((ret = dash_subdemuxer_alloc(rep)) < 0)
+ goto out;
+
+ 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 num;
+
+ 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 int64_t calc_min_seg_no(AVFormatContext *s, struct representation *pls)
+static av_cold int dash_subdemuxer_init(DASHRepresentation *rep)
{
+ int ret;
+ AVFormatContext *s = rep->oc;
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;
+ 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 num;
+
+ if ((ret = dash_subdemuxer_update(rep)) < 0)
+ goto out;
+
+out:
+ if (ret < 0)
+ dash_subdemuxer_close(rep);
+ return ret;
+}
+
+static void *av_push_array(void *plist, unsigned elem_size)
+{
+ void *p;
+ unsigned *nmemb = (unsigned *)((void **)plist + 1);
+
+ if (!(p = av_realloc(*(void **)plist, (*nmemb + 1) * sizeof(void *))))
+ return NULL;
+ *(void **)plist = p;
+
+ return ((*(void ***)plist)[(*nmemb)++] = av_mallocz(elem_size));
}
-static int64_t calc_max_seg_no(struct representation *pls, DASHContext *c)
+static av_cold void *dash_find_by_id(AVFormatContext *s, void *list, unsigned nmemb, const char *id)
{
- int64_t num = 0;
+ if (!id)
+ return NULL;
- 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;
+ 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 num;
+ return NULL;
}
-static void move_timelines(struct representation *rep_src, struct representation *rep_dest, DASHContext *c)
+static av_cold int dash_push_id_node(AVFormatContext *s, void *elem, void *plist, unsigned elem_size, xmlNodePtr node)
{
- 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;
+ 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 {
+ ret = AVERROR(ENOMEM);
}
+
+ xml_free(id);
+ return ret;
}
-static void move_segments(struct representation *rep_src, struct representation *rep_dest, DASHContext *c)
+static int dash_parse_representation(AVFormatContext *s,
+ DASHPeriod *period,
+ DASHAdaptationSet *as,
+ DASHURLList *base_urls,
+ DASHTimeline *inherited_timeline,
+ const DASHParameters *inherited_par,
+ xmlNodePtr node)
{
- 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;
+ 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);
-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 (ret < 0)
+ goto out;
}
- 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;
+
+ 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_INITIALIZER;
}
- 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;
+ if (!timeline) {
+ ret = AVERROR(ENOMEM);
+ goto out;
}
+ rep_period->base = dash_ref_urllist(urls);
+ rep_period->timeline = dash_ref_timeline(timeline);
- 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);
- }
+ 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;
}
-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;
+out:
+ dash_unref_timeline(timeline);
+ dash_unref_urllist(urls);
return ret;
}
-static struct fragment *get_current_fragment(struct representation *pls)
+static av_cold int dash_parse_label(AVFormatContext *s,
+ DASHAdaptationSet *as,
+ xmlNodePtr node)
{
- 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;
+ xmlChar *lang = NULL;
+ xmlChar *value;
- 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;
- }
+ xml_for_each_attr {
+ if (!strcmp(attr->name, "lang")) {
+ lang = value;
+ value = NULL;
+ } else
+ dash_log_unknown_attr(s, attr, value);
}
- 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;
+ 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);
}
- return seg;
+ xml_free(value);
+ xml_free(lang);
+ return 0;
}
-static int read_from_url(struct representation *pls, struct fragment *seg,
- uint8_t *buf, int buf_size)
+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;
-
- /* 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);
+ 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);
- ret = avio_read(pls->input, buf, buf_size);
- if (ret > 0)
- pls->cur_seg_offset += ret;
+ if (ret < 0)
+ goto out;
+ }
+out:
+ dash_unref_timeline(timeline);
+ dash_unref_urllist(urls);
return ret;
}
-static int open_input(DASHContext *c, struct representation *pls, struct fragment *seg)
+static av_cold int dash_parse_period(AVFormatContext *s,
+ DASHURLList *base_urls,
+ xmlNodePtr node)
{
- AVDictionary *opts = NULL;
- char *url = NULL;
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 (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;
+ }
+
+ 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);
- 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);
+ if (ret < 0)
+ goto out;
}
- 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;
+out:
+ dash_unref_timeline(timeline);
+ dash_unref_urllist(urls);
return ret;
}
-static int update_init_section(struct representation *pls)
+static av_cold int dash_parse_programinformation(AVFormatContext *s, xmlNodePtr node)
{
- 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;
+ xmlChar *lang = NULL;
- 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;
+ xml_for_each_attr {
+ if (!strcmp(attr->name, "lang")) {
+ lang = value;
+ value = NULL;
+ } else
+ dash_log_unknown_attr(s, attr, value);
}
- 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);
+ xml_for_each_child {
+ const char *key = NULL;
+ xmlChar *value;
- sec_size = FFMIN(sec_size, max_init_section_size);
-
- av_fast_malloc(&pls->init_sec_buf, &pls->init_sec_buf_size, sec_size);
+ if (!(value = xmlNodeGetContent(child)))
+ continue;
- 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 (!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 (ret < 0)
- return ret;
+ 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);
+ }
- pls->init_sec_data_len = ret;
- pls->init_sec_buf_read_offset = 0;
+ xmlFree(value);
+ }
+ xml_free(lang);
return 0;
}
-static int64_t seek_data(void *opaque, int64_t offset, int whence)
+static av_cold void dash_reset(AVFormatContext *s)
{
- struct representation *v = opaque;
- if (v->n_fragments && !v->init_sec_data_len) {
- return avio_seek(v->input, offset, whence);
- }
+ 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);
- return AVERROR(ENOSYS);
+ xml_freep(&c->id);
+ xml_freep(&c->chain_next_location);
+ xml_freep(&c->fallback_location);
}
-static int read_data(void *opaque, uint8_t *buf, int buf_size)
+static av_cold int dash_parse_mpd(AVFormatContext *s,
+ DASHURLList *base_urls,
+ xmlNodePtr node)
{
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;
+ DASHContext *c = s->priv_data;
+ DASHURLList *urls = dash_ref_urllist(base_urls);
- ret = open_input(c, v, v->cur_seg);
- if (ret < 0) {
- if (ff_check_interrupt(c->interrupt_callback)) {
- ret = AVERROR_EXIT;
- goto end;
- }
- av_log(v->parent, AV_LOG_WARNING, "Failed to open fragment of playlist\n");
- v->cur_seq_no++;
- goto restart;
- }
+ /* 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;
}
- 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;
+ {
+ xmlChar *id = xmlGetNoNsProp(node, "id");
+ if (!c->id || !id || strcmp(c->id, id)) {
+ dash_reset(s);
+ c->id = id;
+ } else {
+ xmlFree(id);
+ }
}
- /* 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;
+ 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);
+ }
+
+ 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 (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 (ret < 0)
+ goto out;
}
-end:
+out:
+ dash_unref_urllist(urls);
return ret;
}
-static int save_avio_options(AVFormatContext *s)
+/**
+ * Remove filename component from an URL.
+ */
+static int ff_make_absolute_head_urla(char **out_url, const char *url)
{
- 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;
+ int ret;
- 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++;
+ 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 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);
- 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_parse_root(AVFormatContext *s, xmlNodePtr node)
{
+ int ret = 0;
+ DASHURLList *urls = NULL;
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;
-
- if (pls->ctx) {
- close_demux_for_component(pls);
- }
- if (ff_check_interrupt(&s->interrupt_callback)) {
- ret = AVERROR_EXIT;
- goto fail;
+ 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 (!(pls->ctx = avformat_alloc_context())) {
+ if (!(urls = dash_new_urllist(1))) {
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;
- }
-
- pls->ctx->pb = &pls->pb;
- pls->ctx->io_open = nested_io_open;
-
- // 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 ((ret = ff_make_absolute_head_urla(&urls->elems[0], c->location)) < 0)
+ goto out;
-fail:
+ if ((ret = dash_parse_mpd(s, urls, node)) < 0)
+ goto out;
+
+out:
+ dash_unref_urllist(urls);
return ret;
}
-static int open_demux_for_component(AVFormatContext *s, struct representation *pls)
+static av_cold void dash_libxml_error_handler(void *opaque, const char *fmt, ...)
+{
+ 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;
- int i;
+ DASHContext *c = s->priv_data;
+ xmlParserCtxtPtr xml;
+ AVIOContext *pb;
+ AVDictionary *opts = NULL;
+ uint8_t *location;
- pls->parent = s;
- pls->cur_seq_no = calc_cur_seg_no(s, pls);
+ 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;
- if (!pls->last_seq_no) {
- pls->last_seq_no = calc_max_seg_no(pls, s->priv_data);
- }
+ xmlSetGenericErrorFunc(s, dash_libxml_error_handler);
- 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);
+ /* Why not SAX? DASH-IF may standardize patching that obviously requires us
+ * to maintain DOM. */
+ for (xml = NULL;;) {
+ char buf[1 << 14];
- // copy disposition
- st->disposition = ist->disposition;
+ /* 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;
- // 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;
+ parse_error:
+ av_log(s, AV_LOG_ERROR, "Failed to parse manifest file\n");
+ ret = AVERROR_INVALIDDATA;
+ goto out;
+ }
+ } else if (ret == AVERROR_EOF) {
+ if (!xmlParseChunk(xml, NULL, 0, 1 /* Terminate? */))
+ break;
- 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);
+ goto parse_error;
}
- }
-
- return 0;
-fail:
- return ret;
-}
-static int is_common_init_section_exist(struct representation **pls, int n_pls)
-{
- struct fragment *first_init_section = pls[0]->init_section;
- char *url =NULL;
- int64_t url_offset = -1;
- int64_t size = -1;
- int i = 0;
+ av_log(s, AV_LOG_ERROR, "Failed to read manifest file\n");
+ goto out;
+ }
- if (first_init_section == NULL || n_pls == 0)
- return 0;
+ /* 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);
+ }
- url = first_init_section->url;
- url_offset = first_init_section->url_offset;
- size = pls[0]->init_section->size;
- for (i=0;i<n_pls;i++) {
- if (!pls[i]->init_section)
- continue;
+ ret = dash_parse_root(s, xmlDocGetRootElement(xml->myDoc));
- 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;
- }
+ 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;
}
- return 1;
-}
-static int copy_init_section(struct representation *rep_dest, struct representation *rep_src)
-{
- 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);
+out:
+ if (xml) {
+ if (xml->myDoc)
+ xmlFreeDoc(xml->myDoc);
+ xmlFreeParserCtxt(xml);
}
- 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;
-
- return 0;
-}
-static int dash_close(AVFormatContext *s);
+ /* Reset handlers so passed references to AVFormatContext will not survive. */
+ xmlSetGenericErrorFunc(NULL, NULL);
-static void move_metadata(AVStream *st, const char *key, char **value)
-{
- if (*value) {
- av_dict_set(&st->metadata, key, *value, AV_DICT_DONT_STRDUP_VAL);
- *value = NULL;
- }
+ ff_format_io_close(s, &pb);
+ return ret;
}
-static int dash_read_header(AVFormatContext *s)
+static av_cold int dash_close(AVFormatContext *s)
{
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;
+ dash_reset(s);
- if ((ret = save_avio_options(s)) < 0)
- goto fail;
+ av_dict_free(&c->protocol_opts);
- if ((ret = parse_manifest(s, s->url, s->pb)) < 0)
- goto fail;
+ return 0;
+}
- /* 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;
- } else {
- av_dict_set(&c->avio_opts, "seekable", "0", 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;
- if(c->n_videos)
- c->is_init_section_common_video = is_common_init_section_exist(c->videos, c->n_videos);
+ for (const char *opt = OPTIONS; *opt; opt += strlen(opt) + 1 /* NUL */) {
+ uint8_t *buf;
- /* 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 (0 <= av_opt_get(s->pb, opt, AV_OPT_SEARCH_CHILDREN | AV_OPT_ALLOW_NULL, &buf) && buf) {
+ int ret = av_dict_set(&c->protocol_opts, opt, buf,
+ AV_DICT_DONT_OVERWRITE | AV_DICT_DONT_STRDUP_VAL);
if (ret < 0)
- goto fail;
+ return ret;
}
- ret = open_demux_for_component(s, rep);
-
- if (ret)
- goto fail;
- rep->stream_index = stream_index;
- ++stream_index;
}
- if(c->n_audios)
- c->is_init_section_common_audio = is_common_init_section_exist(c->audios, c->n_audios);
-
- 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;
- }
- ret = open_demux_for_component(s, rep);
+ return 0;
+}
- if (ret)
- goto fail;
- rep->stream_index = stream_index;
- ++stream_index;
- }
+static av_cold int dash_read_header(AVFormatContext *s)
+{
+ int ret = 0;
+ DASHContext *c = s->priv_data;
- if (c->n_subtitles)
- c->is_init_section_common_subtitle = is_common_init_section_exist(c->subtitles, c->n_subtitles);
+ if ((ret = dash_set_location(s, s->url)) < 0)
+ goto out;
- 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;
- }
- ret = open_demux_for_component(s, rep);
+ /* Signal that we may create additional streams as time pasts. */
+ s->ctx_flags |= AVFMTCTX_NOHEADER;
- if (ret)
- goto fail;
- rep->stream_index = stream_index;
- ++stream_index;
- }
+ if ((ret = dash_save_protocol_options(s)) < 0)
+ goto out;
- if (!stream_index) {
- ret = AVERROR_INVALIDDATA;
- goto fail;
- }
+ av_lfg_init(&c->rnd, av_get_random_seed());
- /* Create a program */
- program = av_new_program(s, 0);
- if (!program) {
- 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);
- }
+ if ((ret = dash_open_manifest(s)) < 0)
+ goto out;
- return 0;
-fail:
- dash_close(s);
+out:
+ if (ret < 0)
+ dash_close(s);
return ret;
}
-static void recheck_discard_flags(AVFormatContext *s, struct representation **p, int n)
+static DASHRepresentation *dash_get_read_next_representation(AVFormatContext *s)
{
- int i, j;
+ DASHContext *c = s->priv_data;
+ DASHRepresentation *best_rep = NULL;
- for (i = 0; i < n; i++) {
- struct representation *pls = p[i];
- int needed = !pls->assoc_stream || pls->assoc_stream->discard < AVDISCARD_ALL;
+ for (unsigned i = 0; i < c->nb_reps; ++i) {
+ DASHRepresentation *rep = c->reps[i];
+ int needed = 0;
- 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);
- }
- 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);
+ /* 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;
- }
- 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;
- }
+ break;
}
- 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);
- return 0;
-}
+ ist = rep->ic->streams[pkt->stream_index];
-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;
+ 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;
- 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++;
- }
+ /* Make packet timestamps comparable to each other. */
+ rep->last_pts = av_rescale_q(pkt->pts + pkt->duration, ist->time_base, AV_TIME_BASE_Q);
-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);
+ 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;
- return ret;
+ /* Translate stream_index from inner to outer context. */
+ pkt->stream_index = ost->index;
+
+ return 0;
}
static int dash_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
{
- int ret = 0, i;
+ int ret = 0;
DASHContext *c = s->priv_data;
- int64_t seek_pos_msec = av_rescale_rnd(timestamp, 1000,
- s->streams[stream_index]->time_base.den,
- flags & AVSEEK_FLAG_BACKWARD ?
- AV_ROUND_DOWN : AV_ROUND_UP);
- if ((flags & AVSEEK_FLAG_BYTE) || c->is_live)
+ AVStream *st;
+ int64_t now_ts;
+
+ if (flags & AVSEEK_FLAG_BYTE)
return AVERROR(ENOSYS);
- /* Seek in discarded streams with dry_run=1 to avoid reopening them */
- for (i = 0; i < c->n_videos; i++) {
- if (!ret)
- ret = dash_seek(s, c->videos[i], seek_pos_msec, flags, !c->videos[i]->ctx);
- }
- for (i = 0; i < c->n_audios; i++) {
- if (!ret)
- ret = dash_seek(s, c->audios[i], seek_pos_msec, flags, !c->audios[i]->ctx);
- }
- for (i = 0; i < c->n_subtitles; i++) {
- if (!ret)
- ret = dash_seek(s, c->subtitles[i], seek_pos_msec, flags, !c->subtitles[i]->ctx);
+ st = s->streams[stream_index];
+ now_ts = av_rescale_q_rnd(timestamp, st->time_base, AV_TIME_BASE_Q,
+ (flags & AVSEEK_FLAG_BACKWARD)
+ ? AV_ROUND_DOWN : AV_ROUND_UP);
+
+ for (unsigned i = 0; i < c->nb_reps; ++i) {
+ DASHRepresentation *rep = c->reps[i];
+
+ if (!rep->ic)
+ continue;
+
+ rep->last_pts = AV_NOPTS_VALUE;
+
+ rep->read_ts = c->start_ts + now_ts;
+
+ if ((ret = av_seek_frame(rep->ic, -1, now_ts, flags)) < 0) {
+ av_log(s, AV_LOG_ERROR, "Failed to seek subdemuxer\n");
+ /* abort(); */
+ }
+
+ dash_subdemuxer_flush(rep);
}
return ret;
}
-static int dash_probe(const AVProbeData *p)
+static av_cold int dash_probe(const AVProbeData *p)
{
- if (!av_stristr(p->buf, "<MPD"))
- return 0;
-
- if (av_stristr(p->buf, "dash:profile:isoff-on-demand:2011") ||
- av_stristr(p->buf, "dash:profile:isoff-live:2011") ||
- av_stristr(p->buf, "dash:profile:isoff-live:2012") ||
- av_stristr(p->buf, "dash:profile:isoff-main:2011") ||
- av_stristr(p->buf, "3GPP:PSS:profile:DASH1")) {
+ if (strstr(p->buf, "<?xml") &&
+ strstr(p->buf, "<MPD"))
return AVPROBE_SCORE_MAX;
- }
- if (av_stristr(p->buf, "dash:profile")) {
+
+ if (p->mime_type && !strncmp(p->mime_type, "application/dash+xml", 20))
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 +3157,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 a698761..4cccaf7 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
@@ -390,6 +392,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);
/**
@@ -927,6 +941,19 @@ int ff_unlock_avformat(void);
*/
void ff_format_set_url(AVFormatContext *s, char *url);
+/*
+ * Set parent for subdemuxer opened s context. Also inherit some basic
+ * properties.
+ */
+void ff_format_set_parent(AVFormatContext *s, AVFormatContext *parent);
+
+/**
+ * Get the AVFormatContext that this context originates from. This context
+ * usually the one that was explicitly created by the user so it is useful for
+ * callbacks that would like to refer that specific context.
+ */
+AVFormatContext *ff_format_get_origin(AVFormatContext *s);
+
void avpriv_register_devices(const AVOutputFormat * const o[], const AVInputFormat * const i[]);
#endif /* AVFORMAT_INTERNAL_H */
diff --git a/libavformat/utils.c b/libavformat/utils.c
index d9971d7..d43f277 100644
--- a/libavformat/utils.c
+++ b/libavformat/utils.c
@@ -4947,6 +4947,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;
More information about the ffmpeg-devel
mailing list