mpd

type AdaptationSet struct {
	/** @type {?string} */
	Id string

	/**
	 * The language.
	 * @type {?string}
	 * @see IETF RFC 5646
	 * @see ISO 639
	 */
	Lang string

	/**
	 * Should be 'video' or 'audio', not a MIME type.
	 * If not specified, will be inferred from the MIME type.
	 * @type {?string}
	 */
	ContentType mapset.Set

	/** @type {?number} */
	Width int

	/** @type {?number} */
	Height int

	/**
	 * If not specified, will be inferred from the first representation.
	 * @type {?string}
	 */
	MimeType string

	/** @type {?string} */
	Codecs string

	/** @type {!bool}*/
	Main bool

	/** @type {*BaseUrl} */
	BaseUrl *BaseUrl

	/** @type {SegmentBase} */
	SegmentBase *SegmentBase

	/** @type {SegmentList} */
	SegmentList *SegmentList

	/** @type {SegmentTemplate} */
	SegmentTemplate *SegmentTemplate

	/** @type {!Array.<!Representation>} */
	Representations []*Representation
}

type BaseUrl struct {
	/** @type {?string} */
	Url string
}

type CencPssh struct {
	/**
	 * @type {Uint8Array}
	 * @expose
	 */
	PsshBox []uint
}

type Cloneable interface {
	Clone() Node
}

type ContentComponent struct {
	/** @type {?string} */
	Id string

	/**
	 * The language.
	 * @type {?string}
	 * @see IETF RFC 5646
	 * @see ISO 639
	 */
	Lang string

	/**
	 * Should be 'video' or 'audio', not a MIME type.
	 * @type {?string}
	 */
	ContentType string
}

type ContentProtection struct {
	/**
	 * @type {?string}
	 * @expose
	 */
	SchemeIdUri string

	/**
	 * @type {?string}
	 * @expose
	 */
	Value string

	/**
	 * @type {!Array.<!Node>}
	 * @expose
	 */
	Children []Node

	/**
	 * @type {CencPssh}
	 * @expose
	 */
	Pssh CencPssh
}

type FakeNode struct {
	/** @type {*BaseUrl} */
	BaseUrl *BaseUrl
}

type Initialization struct {
	/** @type {String} */
	Url string

	/** @type {Range} */
	Range *Range
}

type ManifestInfo struct {
	Live bool

	MinBufferTime int

	PeriodInfos []PeriodInfo
}

type Mpd struct {
	/** @type {?string} */
	Id string

	/** @type {string} */
	Type string

	/** @type {*BaseUrl} */
	BaseUrl *BaseUrl

	/**
	 * The entire stream's duration, in seconds.
	 * @type {?number}
	 */
	MediaPresentationDuration int

	/**
	 * The quantity of media, in terms of seconds, that should be buffered before
	 * playback begins, to ensure uninterrupted playback.
	 * @type {?number}
	 */
	MinBufferTime int

	/**
	 * The interval, in seconds, to poll the media server for an updated
	 * MPD, or null if updates are not required.
	 * @type {?number}
	 */
	MinUpdatePeriod int

	/**
	 * The wall-clock time, in seconds, that the media content specified within
	 * the MPD started/will start to stream.
	 * @type {?number}
	 */
	AvailabilityStartTime int64

	/**
	 * The duration, in seconds, that the media server retains live media
	 * content, excluding the current segment and the previous segment, which are
	 * always available. For example, if this value is 60 then only media content
	 * up to 60 seconds from the beginning of the previous segment may be
	 * requested from the media server.
	 * @type {?number}
	 */
	TimeShiftBufferDepth int

	//DEFAULT_SUGGESTED_PRESENTATION_DELAY_;
	SuggestedPresentationDelay int

	/** @type {!Array.<!Period>} */
	Periods []*Period
}

type MpdProcessor struct {
	ManifestInfo ManifestInfo
}

type Node interface {
	Parse(parent Node, elem xml.Node)
}

type Pair struct {
	Earliest int
	Current  int
}

type Period struct {
	/** @type {?string} */
	Id string

	/**
	 * The start time of the Period, in seconds, with respect to the media
	 * presentation timeline. Note that the Period becomes/became available at
	 * Mpd.availabilityStartTime + Period.start.
	 * @type {?number}
	 */
	Start int

	/**
	 * The duration in seconds.
	 * @type {?number}
	 */
	Duration int

	/** @type {*BaseUrl} */
	BaseUrl *BaseUrl

	/** @type {SegmentBase} */
	SegmentBase *SegmentBase

	/** @type {SegmentList} */
	SegmentList *SegmentList

	/** @type {SegmentTemplate} */
	SegmentTemplate *SegmentTemplate

	/** @type {!Array.<!AdaptationSet>} */
	AdaptationSets []*AdaptationSet
}

type PeriodInfo struct {
	Id string

	Start int

	/**
	 * The period's duration, in seconds.
	 */
	Duration int

	StreamSetInfos []StreamSetInfo
}

type Range struct {
	/** @const {number} */
	Begin int
	/** @const {number} */
	End int
}

type Representation struct {
	/** @type {?string} */
	Id string

	/**
	 * Never seen on the Representation itself, but inherited from AdapationSet
	 * for convenience.
	 * @see AdaptationSet.lang
	 * @type {?string}
	 */
	Lang string

	/**
	 * Bandwidth required, in bits per second, to assure uninterrupted playback,
	 * assuming that |minBufferTime| seconds of video are in buffer before
	 * playback begins.
	 * @type {?number}
	 */
	Bandwidth uint32

	/** @type {?number} */
	Width int

	/** @type {?number} */
	Height int

	/** @type {?string} */
	MimeType string

	/** @type {?string} */
	Codecs string

	/** @type {*BaseUrl} */
	BaseUrl *BaseUrl

	/** @type {SegmentBase} */
	SegmentBase *SegmentBase

	/** @type {SegmentList} */
	SegmentList *SegmentList

	/** @type {SegmentTemplate} */
	SegmentTemplate *SegmentTemplate

	/** @type {!Array.<ContentProtection>} */
	ContentProtections []*ContentProtection

	/** @type {boolean} */
	Main bool
}

type RepresentationIndex struct {
	/** @type {string} */
	Url string

	/**
	 * Inherits the value of SegmentBase.indexRange if not specified.
	 * @type {Range}
	 */
	Range *Range
}

type Role struct {
	/** @type {?string} */
	Value string
}

type SegmentBase struct {
	/**
	 * This not an actual XML attribute of SegmentBase. It is inherited from the
	 * SegmentBase's parent Representation.
	 * @type {*BaseUrl}
	 */
	BaseUrl *BaseUrl

	/** @type {?number} */
	Timescale int

	/** @type {?number} */
	PresentationTimeOffset int

	/** @type {Range} */
	IndexRange *Range

	/** @type {RepresentationIndex} */
	RepresentationIndex *RepresentationIndex

	/** @type {Initialization} */
	Initialization *Initialization
}

type SegmentIndex struct {
	References          []*SegmentReference
	TimestampCorrection int
}

type SegmentList struct {
	/**
	 * This not an actual XML attribute of SegmentList. It is inherited from the
	 * SegmentList's parent Representation.
	 * @type {BaseUrl}
	 */
	BaseUrl *BaseUrl

	/** @type {?number} */
	Timescale uint32 // xs:unsignedInt

	/** @type {?number} */
	PresentationTimeOffset uint64 // xs:unsignedLong

	/**
	 * Each segment's duration. This value is never zero.
	 * @type {?number}
	 */
	SegmentDuration int // xs:duration

	/**
	 * The segment number origin. This value is never zero.
	 * @type {?number}
	 */
	StartNumber uint32 // xs:unsignedInt

	/** @type {Initialization} */
	Initialization *Initialization

	/** @type {!Array.<SegmentUrl>} */
	SegmentUrls []*SegmentUrl
}

type SegmentMetadataInfo struct {
	Url string

	StartByte int

	EndByte int
}

type SegmentReference struct {

	/**
	 * The segment's ID.
	 * @const {number}
	 */
	Id uint64

	/**
	 * The time, in seconds, that the segment begins.
	 * @const {number}
	 */
	StartTime uint64

	/**
	 * The time, in seconds, that the segment ends. The segment ends immediately
	 * before this time. A null value indicates that the segment continues to the
	 * end of the stream.
	 * @const {?number}
	 */
	EndTime uint64

	/**
	 * The position of the segment's first byte.
	 * @const {number}
	 */
	StartByte int

	/**
	 * The position of the segment's last byte, inclusive. A null value indicates
	 * that the segment continues to the end of the file located at |url|.
	 * @const {?number}
	 */
	EndByte int

	/**
	 * The segment's location.
	 * @const {!string}
	 */
	Url string
}

type SegmentTemplate struct {
	/** @type {?number} */
	Timescale uint32 // xs:unsignedInt

	/** @type {?number} */
	PresentationTimeOffset int // xs:unsignedLong

	/**
	 * Each segment's duration. This value is never zero.
	 * @type {?number}
	 */
	SegmentDuration int // xs:duration

	/**
	 * The segment number origin. This value is never zero.
	 * @type {?number}
	 */
	StartNumber int // xs:unsignedInt

	/** @type {?string} */
	MediaUrlTemplate string

	/** @type {?string} */
	IndexUrlTemplate string

	/** @type {?string} */
	InitializationUrlTemplate string

	/** @type {SegmentTimeline} */
	Timeline *SegmentTimeline
}

type SegmentTimePoint struct {
	/**
	 * The start time of the media segment, in seconds, relative to the beginning
	 * of the Period.
	 * @type {?number}
	 */
	StartTime uint64

	/** @type {?number} */
	Duration uint64

	/** @type {?number} */
	Repeat int
}

type SegmentTimeline struct {
	/** @type {!Array.<!SegmentTimePoint>} */
	TimePoints []*SegmentTimePoint
}

type SegmentUrl struct {
	/** @type {string} */
	MediaUrl string

	/** @type {Range} */
	MediaRange *Range
}

type StreamInfo struct {
	UniqueId int

	Id string

	/**
	 * An offset, in seconds, to apply to each timestamp within each media
	 * segment that's put in buffer.
	 */
	TimestampOffset int

	/**
	 * Indicates the stream's current segment's start time, i.e., its live-edge.
	 * This value is non-null if the stream is both live and available;
	 * otherwise, this value is null.
	 */
	CurrentSegmentStartTime uint64

	/**
	 * Bandwidth required, in bits per second, to assure uninterrupted playback,
	 * assuming that |minBufferTime| seconds of video are in buffer before
	 * playback begins.
	 */
	Bandwidth uint32

	Width int

	Height int

	MimeType string

	Codecs string

	MediaUrl string

	Enabled bool

	/**
	 * The stream's SegmentIndex metadata.
	 * @see {StreamInfo.isAvailable}
	 */
	SegmentIndexInfo *SegmentMetadataInfo

	/**
	 * The stream's segment initialization metadata.
	 * @type {SegmentMetadataInfo}
	 */
	SegmentInitializationInfo *SegmentMetadataInfo

	/**
	 * The stream's SegmentIndex.
	 * @see {StreamInfo.isAvailable}
	 * @type {SegmentIndex}
	 */
	SegmentIndex *SegmentIndex

	/** @type {ArrayBuffer} */
	SegmentInitializationData []byte

	/** @private {ArrayBuffer} */
	SegmentIndexData []byte
}

type StreamSetInfo struct {
	/** @type {number} */
	UniqueId int

	/** @type {?string} */
	Id string

	/** @type {string} */
	ContentType mapset.Set

	/** @type {!Array.<!StreamInfo>} */
	StreamInfos []*StreamInfo

	/** @type {string} */
	Lang string

	/** @type {boolean} */
	Main bool
}

type TimeLine struct {
	Start uint64
	End   uint64
}