mirror of
https://github.com/shaka-project/shaka-player.git
synced 2026-06-14 15:56:38 +03:00
Álvaro Velad Galván
1543 lines
58 KiB
JavaScript
1543 lines
58 KiB
JavaScript
/*! @license
|
|
* Shaka Player
|
|
* Copyright 2016 Google LLC
|
|
* SPDX-License-Identifier: Apache-2.0
|
|
*/
|
|
|
|
describe('DashParser Live', () => {
|
|
const Util = shaka.test.Util;
|
|
const ManifestParser = shaka.test.ManifestParser;
|
|
|
|
const oldNow = Date.now;
|
|
const updateTime = 5;
|
|
const originalUri = 'http://example.com/';
|
|
|
|
|
|
/** @type {!shaka.test.FakeNetworkingEngine} */
|
|
let fakeNetEngine;
|
|
/** @type {!shaka.dash.DashParser} */
|
|
let parser;
|
|
/** @type {shaka.extern.ManifestParser.PlayerInterface} */
|
|
let playerInterface;
|
|
|
|
beforeEach(() => {
|
|
fakeNetEngine = new shaka.test.FakeNetworkingEngine();
|
|
parser = new shaka.dash.DashParser();
|
|
parser.configure(shaka.util.PlayerConfiguration.createDefault().manifest);
|
|
playerInterface = {
|
|
networkingEngine: fakeNetEngine,
|
|
filter: (manifest) => Promise.resolve(),
|
|
makeTextStreamsForClosedCaptions: (manifest) => {},
|
|
onTimelineRegionAdded: fail, // Should not have any EventStream elements.
|
|
onEvent: fail,
|
|
onError: fail,
|
|
isLowLatencyMode: () => false,
|
|
isAutoLowLatencyMode: () => false,
|
|
enableLowLatencyMode: () => {},
|
|
updateDuration: () => {},
|
|
newDrmInfo: (stream) => {},
|
|
onManifestUpdated: () => {},
|
|
getBandwidthEstimate: () => 1e6,
|
|
};
|
|
});
|
|
|
|
afterEach(() => {
|
|
// Dash parser stop is synchronous.
|
|
parser.stop();
|
|
Date.now = oldNow;
|
|
});
|
|
|
|
/**
|
|
* Trigger a manifest update.
|
|
* @suppress {accessControls}
|
|
*/
|
|
async function updateManifest() {
|
|
if (parser.updateTimer_) {
|
|
parser.updateTimer_.tickNow();
|
|
}
|
|
await Util.shortDelay(); // Allow update to complete.
|
|
}
|
|
|
|
/**
|
|
* Gets a spy on the function that sets the update period.
|
|
* @return {!jasmine.Spy}
|
|
* @suppress {accessControls}
|
|
*/
|
|
function updateTickSpy() {
|
|
return spyOn(parser.updateTimer_, 'tickAfter');
|
|
}
|
|
|
|
/**
|
|
* Makes a simple live manifest with the given representation contents.
|
|
*
|
|
* @param {!Array.<string>} lines
|
|
* @param {number?} updateTime
|
|
* @param {number=} duration
|
|
* @return {string}
|
|
*/
|
|
function makeSimpleLiveManifestText(lines, updateTime, duration) {
|
|
const updateAttr = updateTime != null ?
|
|
'minimumUpdatePeriod="PT' + updateTime + 'S"' : '';
|
|
const durationAttr = duration != undefined ?
|
|
'duration="PT' + duration + 'S"' : '';
|
|
const template = [
|
|
'<MPD type="dynamic" %(updateAttr)s',
|
|
' availabilityStartTime="1970-01-01T00:00:00Z">',
|
|
' <Period id="1" %(durationAttr)s>',
|
|
' <AdaptationSet mimeType="video/mp4">',
|
|
' <Representation id="3" bandwidth="500">',
|
|
' <BaseURL>http://example.com</BaseURL>',
|
|
'%(contents)s',
|
|
' </Representation>',
|
|
' </AdaptationSet>',
|
|
' </Period>',
|
|
'</MPD>',
|
|
].join('\n');
|
|
const text = sprintf(template, {
|
|
updateAttr: updateAttr,
|
|
durationAttr: durationAttr,
|
|
contents: lines.join('\n'),
|
|
updateTime: updateTime,
|
|
});
|
|
return text;
|
|
}
|
|
|
|
/**
|
|
* Make clones of a list of references so that they can be modified without
|
|
* affecting the originals.
|
|
*
|
|
* @param {!Array.<!shaka.media.SegmentReference>} references
|
|
* @return {!Array.<!shaka.media.SegmentReference>}
|
|
*/
|
|
function cloneRefs(references) {
|
|
return references.map((ref) => {
|
|
return new shaka.media.SegmentReference(
|
|
ref.startTime,
|
|
ref.endTime,
|
|
ref.getUrisInner,
|
|
ref.startByte,
|
|
ref.endByte,
|
|
ref.initSegmentReference,
|
|
ref.timestampOffset,
|
|
ref.appendWindowStart,
|
|
ref.appendWindowEnd);
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Creates tests that test the behavior common between SegmentList and
|
|
* SegmentTemplate.
|
|
*
|
|
* @param {!Array.<string>} basicLines
|
|
* @param {!Array.<!shaka.media.SegmentReference>} basicRefs
|
|
* @param {!Array.<string>} updateLines
|
|
* @param {!Array.<!shaka.media.SegmentReference>} updateRefs
|
|
* @param {!Array.<string>} partialUpdateLines
|
|
*/
|
|
function testCommonBehaviors(
|
|
basicLines, basicRefs, updateLines, updateRefs, partialUpdateLines) {
|
|
/**
|
|
* Tests that an update will show the given references.
|
|
*
|
|
* @param {!Array.<string>} firstLines The Representation contents for the
|
|
* first manifest.
|
|
* @param {!Array.<!shaka.media.SegmentReference>} firstReferences The media
|
|
* references for the first parse.
|
|
* @param {!Array.<string>} secondLines The Representation contents for the
|
|
* updated manifest.
|
|
* @param {!Array.<!shaka.media.SegmentReference>} secondReferences The
|
|
* media references for the updated manifest.
|
|
*/
|
|
async function testBasicUpdate(
|
|
firstLines, firstReferences, secondLines, secondReferences) {
|
|
const firstManifest = makeSimpleLiveManifestText(firstLines, updateTime);
|
|
const secondManifest =
|
|
makeSimpleLiveManifestText(secondLines, updateTime);
|
|
|
|
fakeNetEngine.setResponseText('dummy://foo', firstManifest);
|
|
const manifest = await parser.start('dummy://foo', playerInterface);
|
|
const stream = manifest.variants[0].video;
|
|
await stream.createSegmentIndex();
|
|
ManifestParser.verifySegmentIndex(stream, firstReferences);
|
|
|
|
fakeNetEngine.setResponseText('dummy://foo', secondManifest);
|
|
await updateManifest();
|
|
ManifestParser.verifySegmentIndex(stream, secondReferences);
|
|
}
|
|
|
|
it('basic support', async () => {
|
|
await testBasicUpdate(basicLines, basicRefs, updateLines, updateRefs);
|
|
});
|
|
|
|
it('new manifests don\'t need to include old references', async () => {
|
|
await testBasicUpdate(
|
|
basicLines, basicRefs, partialUpdateLines, updateRefs);
|
|
});
|
|
|
|
it('evicts old references for single-period live stream', async () => {
|
|
const template = [
|
|
'<MPD type="dynamic" minimumUpdatePeriod="PT%(updateTime)dS"',
|
|
' timeShiftBufferDepth="PT30S"',
|
|
' suggestedPresentationDelay="PT5S"',
|
|
' availabilityStartTime="1970-01-01T00:00:00Z">',
|
|
' <Period id="1">',
|
|
' <AdaptationSet mimeType="video/mp4">',
|
|
' <Representation id="3" bandwidth="500">',
|
|
' <BaseURL>http://example.com</BaseURL>',
|
|
'%(contents)s',
|
|
' </Representation>',
|
|
' </AdaptationSet>',
|
|
' </Period>',
|
|
'</MPD>',
|
|
].join('\n');
|
|
const text = sprintf(
|
|
template, {updateTime: updateTime, contents: basicLines.join('\n')});
|
|
|
|
fakeNetEngine.setResponseText('dummy://foo', text);
|
|
const baseTime = new Date(2015, 11, 30);
|
|
Date.now = () => baseTime.getTime();
|
|
const manifest = await parser.start('dummy://foo', playerInterface);
|
|
|
|
expect(manifest).toBeTruthy();
|
|
const stream = manifest.variants[0].video;
|
|
expect(stream).toBeTruthy();
|
|
|
|
await stream.createSegmentIndex();
|
|
expect(stream.segmentIndex).toBeTruthy();
|
|
const firstPosition = stream.segmentIndex.find(0);
|
|
ManifestParser.verifySegmentIndex(stream, basicRefs);
|
|
|
|
// The 30 second availability window is initially full in all cases
|
|
// (SegmentTemplate+Timeline, etc.) The first segment is always 10
|
|
// seconds long in all of these cases. So 11 seconds after the
|
|
// manifest was parsed, the first segment should have fallen out of
|
|
// the availability window.
|
|
Date.now = () => baseTime.getTime() + (11 * 1000);
|
|
await updateManifest();
|
|
// The first reference should have been evicted.
|
|
expect(stream.segmentIndex.find(0)).toBe(firstPosition + 1);
|
|
ManifestParser.verifySegmentIndex(stream, basicRefs.slice(1));
|
|
});
|
|
|
|
it('evicts old references for multi-period live stream', async () => {
|
|
const template = [
|
|
'<MPD type="dynamic" minimumUpdatePeriod="PT%(updateTime)dS"',
|
|
' timeShiftBufferDepth="PT60S"',
|
|
' suggestedPresentationDelay="PT5S"',
|
|
' availabilityStartTime="1970-01-01T00:00:00Z">',
|
|
' <Period id="1">',
|
|
' <AdaptationSet mimeType="video/mp4">',
|
|
' <Representation id="3" bandwidth="500">',
|
|
' <BaseURL>http://example.com</BaseURL>',
|
|
'%(contents)s',
|
|
' </Representation>',
|
|
' </AdaptationSet>',
|
|
' </Period>',
|
|
' <Period id="2" start="PT%(pStart)dS">',
|
|
' <AdaptationSet mimeType="video/mp4">',
|
|
' <Representation id="4" bandwidth="500">',
|
|
' <BaseURL>http://example.com</BaseURL>',
|
|
'%(contents)s',
|
|
' </Representation>',
|
|
' </AdaptationSet>',
|
|
' </Period>',
|
|
'</MPD>',
|
|
].join('\n');
|
|
// Set the period start to the sum of the durations of the references
|
|
// in the previous period.
|
|
const durs = basicRefs.map((r) => {
|
|
return r.endTime - r.startTime;
|
|
});
|
|
const pStart = durs.reduce((p, d) => p + d, 0);
|
|
const args = {
|
|
updateTime: updateTime,
|
|
pStart: pStart,
|
|
contents: basicLines.join('\n'),
|
|
};
|
|
const text = sprintf(template, args);
|
|
|
|
fakeNetEngine.setResponseText('dummy://foo', text);
|
|
Date.now = () => 0;
|
|
const manifest = await parser.start('dummy://foo', playerInterface);
|
|
|
|
/** @const {!Array.<!shaka.media.SegmentReference>} */
|
|
const period1Refs = cloneRefs(basicRefs);
|
|
/** @const {!Array.<!shaka.media.SegmentReference>} */
|
|
const period2Refs = cloneRefs(basicRefs);
|
|
for (const ref of period2Refs) {
|
|
ref.timestampOffset = pStart;
|
|
ref.startTime += pStart;
|
|
ref.endTime += pStart;
|
|
ref.trueEndTime += pStart;
|
|
}
|
|
/** @const {!Array.<!shaka.media.SegmentReference>} */
|
|
const allRefs = period1Refs.concat(period2Refs);
|
|
|
|
const stream1 = manifest.variants[0].video;
|
|
await stream1.createSegmentIndex();
|
|
ManifestParser.verifySegmentIndex(stream1, allRefs);
|
|
|
|
// The 60 second availability window is initially full in all cases
|
|
// (SegmentTemplate+Timeline, etc.) The first segment is always 10
|
|
// seconds long in all of these cases. So 11 seconds after the
|
|
// manifest was parsed, the first segment should have fallen out of
|
|
// the availability window.
|
|
Date.now = () => 11 * 1000;
|
|
await updateManifest();
|
|
// The first reference should have been evicted.
|
|
ManifestParser.verifySegmentIndex(stream1, allRefs.slice(1));
|
|
|
|
// Same as above, but 1 period length later
|
|
Date.now = () => (11 + pStart) * 1000;
|
|
await updateManifest();
|
|
ManifestParser.verifySegmentIndex(stream1, period2Refs.slice(1));
|
|
});
|
|
|
|
it('sets infinite duration for single-period live streams', async () => {
|
|
const template = [
|
|
'<MPD type="dynamic" minimumUpdatePeriod="PT%(updateTime)dS"',
|
|
' timeShiftBufferDepth="PT1S"',
|
|
' suggestedPresentationDelay="PT5S"',
|
|
' availabilityStartTime="1970-01-01T00:00:00Z">',
|
|
' <Period id="1">',
|
|
' <AdaptationSet mimeType="video/mp4">',
|
|
' <Representation id="3" bandwidth="500">',
|
|
' <BaseURL>http://example.com</BaseURL>',
|
|
'%(contents)s',
|
|
' </Representation>',
|
|
' </AdaptationSet>',
|
|
' </Period>',
|
|
'</MPD>',
|
|
].join('\n');
|
|
const text = sprintf(
|
|
template, {updateTime: updateTime, contents: basicLines.join('\n')});
|
|
|
|
fakeNetEngine.setResponseText('dummy://foo', text);
|
|
Date.now = () => 0;
|
|
const manifest = await parser.start('dummy://foo', playerInterface);
|
|
|
|
const timeline = manifest.presentationTimeline;
|
|
expect(timeline.getDuration()).toBe(Infinity);
|
|
});
|
|
|
|
it('sets infinite duration for multi-period live streams', async () => {
|
|
const template = [
|
|
'<MPD type="dynamic" minimumUpdatePeriod="PT%(updateTime)dS"',
|
|
' timeShiftBufferDepth="PT1S"',
|
|
' suggestedPresentationDelay="PT5S"',
|
|
' availabilityStartTime="1970-01-01T00:00:00Z">',
|
|
' <Period id="1">',
|
|
' <AdaptationSet mimeType="video/mp4">',
|
|
' <Representation id="3" bandwidth="500">',
|
|
' <BaseURL>http://example.com</BaseURL>',
|
|
'%(contents)s',
|
|
' </Representation>',
|
|
' </AdaptationSet>',
|
|
' </Period>',
|
|
' <Period id="2" start="PT60S">',
|
|
' <AdaptationSet mimeType="video/mp4">',
|
|
' <Representation id="4" bandwidth="500">',
|
|
' <BaseURL>http://example.com</BaseURL>',
|
|
'%(contents)s',
|
|
' </Representation>',
|
|
' </AdaptationSet>',
|
|
' </Period>',
|
|
'</MPD>',
|
|
].join('\n');
|
|
const text = sprintf(
|
|
template, {updateTime: updateTime, contents: basicLines.join('\n')});
|
|
|
|
fakeNetEngine.setResponseText('dummy://foo', text);
|
|
Date.now = () => 0;
|
|
const manifest = await parser.start('dummy://foo', playerInterface);
|
|
|
|
const timeline = manifest.presentationTimeline;
|
|
expect(timeline.getDuration()).toBe(Infinity);
|
|
});
|
|
}
|
|
|
|
it('can add Periods with SegmentTemplate', async () => {
|
|
const template1 = [
|
|
'<MPD type="dynamic" availabilityStartTime="1970-01-01T00:00:00Z"',
|
|
' suggestedPresentationDelay="PT5S"',
|
|
' minimumUpdatePeriod="PT%(updateTime)dS">',
|
|
' <Period id="1">',
|
|
' <AdaptationSet mimeType="video/mp4">',
|
|
' <Representation id="1" bandwidth="500">',
|
|
' <BaseURL>http://example.com</BaseURL>',
|
|
' <SegmentTemplate media="s$Number$.mp4">',
|
|
' <SegmentTimeline>',
|
|
' <S t="0" d="2" r="1" />',
|
|
' </SegmentTimeline>',
|
|
' </SegmentTemplate>',
|
|
' </Representation>',
|
|
' </AdaptationSet>',
|
|
' </Period>',
|
|
'</MPD>',
|
|
].join('\n');
|
|
const template2 = [
|
|
'<MPD type="dynamic" availabilityStartTime="1970-01-01T00:00:00Z"',
|
|
' suggestedPresentationDelay="PT5S"',
|
|
' minimumUpdatePeriod="PT%(updateTime)dS">',
|
|
' <Period id="1" duration="PT10S">',
|
|
' <AdaptationSet mimeType="video/mp4">',
|
|
' <Representation id="1" bandwidth="500">',
|
|
' <BaseURL>http://example.com</BaseURL>',
|
|
' <SegmentTemplate media="s$Number$.mp4">',
|
|
' <SegmentTimeline>',
|
|
' <S t="0" d="2" r="4" />',
|
|
' </SegmentTimeline>',
|
|
' </SegmentTemplate>',
|
|
' </Representation>',
|
|
' </AdaptationSet>',
|
|
' </Period>',
|
|
' <Period id="2">',
|
|
' <AdaptationSet mimeType="video/mp4">',
|
|
' <Representation id="2" bandwidth="500">',
|
|
' <BaseURL>http://example.com</BaseURL>',
|
|
' <SegmentTemplate media="s$Number$.mp4">',
|
|
' <SegmentTimeline>',
|
|
' <S t="0" d="2" r="1" />',
|
|
' </SegmentTimeline>',
|
|
' </SegmentTemplate>',
|
|
' </Representation>',
|
|
' </AdaptationSet>',
|
|
' </Period>',
|
|
'</MPD>',
|
|
].join('\n');
|
|
const firstManifest = sprintf(template1, {updateTime: updateTime});
|
|
const secondManifest = sprintf(template2, {updateTime: updateTime});
|
|
|
|
fakeNetEngine.setResponseText('dummy://foo', firstManifest);
|
|
// First two segments should exist
|
|
Date.now = () => 5;
|
|
|
|
const manifest = await parser.start('dummy://foo', playerInterface);
|
|
const variant = manifest.variants[0];
|
|
const stream = variant.video;
|
|
await stream.createSegmentIndex();
|
|
|
|
// First two segments exist, but not the third.
|
|
expect(stream.segmentIndex.find(3)).not.toBe(null);
|
|
expect(stream.segmentIndex.find(5)).toBe(null);
|
|
|
|
fakeNetEngine.setResponseText('dummy://foo', secondManifest);
|
|
// First period (10s) is complete, plus first two segments of next period
|
|
Date.now = () => 15;
|
|
|
|
await updateManifest();
|
|
|
|
// The update should have affected the same variant object we captured
|
|
// before. Now the entire first period should exist (0-10s), plus the next
|
|
// two segments (10-14s).
|
|
expect(stream.segmentIndex.find(9)).not.toBe(null);
|
|
expect(stream.segmentIndex.find(13)).not.toBe(null);
|
|
|
|
stream.closeSegmentIndex();
|
|
await stream.createSegmentIndex();
|
|
|
|
expect(stream.segmentIndex.find(9)).not.toBe(null);
|
|
expect(stream.segmentIndex.find(13)).not.toBe(null);
|
|
});
|
|
|
|
it('can add Periods with SegmentList', async () => {
|
|
const list1 = [
|
|
'<MPD type="dynamic" availabilityStartTime="1970-01-01T00:00:00Z"',
|
|
' suggestedPresentationDelay="PT5S"',
|
|
' minimumUpdatePeriod="PT%(updateTime)dS">',
|
|
' <Period id="1">',
|
|
' <AdaptationSet mimeType="video/mp4">',
|
|
' <Representation id="1" bandwidth="500">',
|
|
' <BaseURL>http://example.com</BaseURL>',
|
|
' <SegmentList>',
|
|
' <SegmentURL media="s1.mp4" />',
|
|
' <SegmentURL media="s2.mp4" />',
|
|
' <SegmentURL media="s3.mp4" />',
|
|
' <SegmentTimeline>',
|
|
' <S d="10" t="0" r="2"/>',
|
|
' </SegmentTimeline>',
|
|
' </SegmentList>',
|
|
' </Representation>',
|
|
' </AdaptationSet>',
|
|
' </Period>',
|
|
'</MPD>',
|
|
].join('\n');
|
|
const list2 = [
|
|
'<MPD type="dynamic" availabilityStartTime="1970-01-01T00:00:00Z"',
|
|
' suggestedPresentationDelay="PT5S"',
|
|
' minimumUpdatePeriod="PT%(updateTime)dS">',
|
|
' <Period id="1" duration="PT40S">',
|
|
' <AdaptationSet mimeType="video/mp4">',
|
|
' <Representation id="1" bandwidth="500">',
|
|
' <BaseURL>http://example.com</BaseURL>',
|
|
' <SegmentList>',
|
|
' <SegmentURL media="s1.mp4" />',
|
|
' <SegmentURL media="s2.mp4" />',
|
|
' <SegmentURL media="s3.mp4" />',
|
|
' <SegmentURL media="s4.mp4" />',
|
|
' <SegmentTimeline>',
|
|
' <S d="10" t="0" r="3"/>',
|
|
' </SegmentTimeline>',
|
|
' </SegmentList>',
|
|
' </Representation>',
|
|
' </AdaptationSet>',
|
|
' </Period>',
|
|
' <Period id="2">',
|
|
' <AdaptationSet mimeType="video/mp4">',
|
|
' <Representation id="2" bandwidth="500">',
|
|
' <BaseURL>http://example.com</BaseURL>',
|
|
' <SegmentList>',
|
|
' <SegmentURL media="s1.mp4" />',
|
|
' <SegmentURL media="s2.mp4" />',
|
|
' <SegmentTimeline>',
|
|
' <S d="10" t="0" r="1"/>',
|
|
' </SegmentTimeline>',
|
|
' </SegmentList>',
|
|
' </Representation>',
|
|
' </AdaptationSet>',
|
|
' </Period>',
|
|
'</MPD>',
|
|
].join('\n');
|
|
const firstManifest = sprintf(list1, {updateTime: updateTime});
|
|
const secondManifest = sprintf(list2, {updateTime: updateTime});
|
|
|
|
fakeNetEngine.setResponseText('dummy://foo', firstManifest);
|
|
// First three segments should exist.
|
|
Date.now = () => 5;
|
|
|
|
const manifest = await parser.start('dummy://foo', playerInterface);
|
|
const variant = manifest.variants[0];
|
|
const stream = variant.video;
|
|
await stream.createSegmentIndex();
|
|
|
|
// First three segments exist, but not the fourth.
|
|
expect(stream.segmentIndex.find(25)).not.toBe(null);
|
|
expect(stream.segmentIndex.find(45)).toBe(null);
|
|
|
|
fakeNetEngine.setResponseText('dummy://foo', secondManifest);
|
|
Date.now = () => 25;
|
|
|
|
await updateManifest();
|
|
|
|
// The update should have affected the same variant object we captured
|
|
// before. Now the entire first period should exist (0-40s), plus the next
|
|
// two segments of the second period(40-60s).
|
|
expect(stream.segmentIndex.find(25)).not.toBe(null);
|
|
expect(stream.segmentIndex.find(45)).not.toBe(null);
|
|
|
|
stream.closeSegmentIndex();
|
|
await stream.createSegmentIndex();
|
|
|
|
expect(stream.segmentIndex.find(25)).not.toBe(null);
|
|
expect(stream.segmentIndex.find(45)).not.toBe(null);
|
|
});
|
|
|
|
it('uses redirect URL for manifest BaseURL and updates', async () => {
|
|
const template = [
|
|
'<MPD type="dynamic" availabilityStartTime="1970-01-01T00:00:00Z"',
|
|
' suggestedPresentationDelay="PT5S"',
|
|
' minimumUpdatePeriod="PT%(updateTime)dS">',
|
|
' <Period id="1" duration="PT30S">',
|
|
' <AdaptationSet mimeType="video/mp4">',
|
|
' <Representation id="3" bandwidth="500">',
|
|
' <SegmentTemplate startNumber="1" media="s$Number$.mp4">',
|
|
' <SegmentTimeline>',
|
|
' <S d="10" t="0" />',
|
|
' <S d="5" />',
|
|
' <S d="15" />',
|
|
' </SegmentTimeline>',
|
|
' </SegmentTemplate>',
|
|
' </Representation>',
|
|
' </AdaptationSet>',
|
|
' </Period>',
|
|
'</MPD>',
|
|
].join('\n');
|
|
const manifestText = sprintf(template, {updateTime: updateTime});
|
|
const manifestData = shaka.util.StringUtils.toUTF8(manifestText);
|
|
const redirectedUri = 'http://redirected.com/';
|
|
|
|
// The initial manifest request will be redirected.
|
|
fakeNetEngine.request.and.returnValue(
|
|
shaka.util.AbortableOperation.completed({
|
|
uri: redirectedUri,
|
|
data: manifestData,
|
|
}));
|
|
|
|
const manifest = await parser.start(originalUri, playerInterface);
|
|
|
|
// The manifest request was made to the original URL.
|
|
// But includes a redirect
|
|
expect(fakeNetEngine.request).toHaveBeenCalledTimes(1);
|
|
const netRequest = fakeNetEngine.request.calls.argsFor(0)[1];
|
|
expect(netRequest.uris).toEqual([redirectedUri, originalUri]);
|
|
|
|
// Since the manifest request was redirected, the segment refers to
|
|
// the redirected base.
|
|
const stream = manifest.variants[0].video;
|
|
await stream.createSegmentIndex();
|
|
goog.asserts.assert(stream.segmentIndex != null, 'Null segmentIndex!');
|
|
|
|
const ref = Array.from(stream.segmentIndex)[0];
|
|
const segmentUri = ref.getUris()[0];
|
|
expect(segmentUri).toBe(redirectedUri + 's1.mp4');
|
|
});
|
|
|
|
it('calls the error callback if an update fails', async () => {
|
|
const lines = [
|
|
'<SegmentTemplate startNumber="1" media="s$Number$.mp4" duration="2" />',
|
|
];
|
|
const manifestText = makeSimpleLiveManifestText(lines, updateTime);
|
|
/** @type {!jasmine.Spy} */
|
|
const onError = jasmine.createSpy('onError');
|
|
playerInterface.onError = Util.spyFunc(onError);
|
|
|
|
const updateTick = updateTickSpy();
|
|
|
|
fakeNetEngine.setResponseText('dummy://foo', manifestText);
|
|
await parser.start('dummy://foo', playerInterface);
|
|
|
|
expect(fakeNetEngine.request).toHaveBeenCalledTimes(1);
|
|
|
|
const error = new shaka.util.Error(
|
|
shaka.util.Error.Severity.CRITICAL,
|
|
shaka.util.Error.Category.NETWORK,
|
|
shaka.util.Error.Code.BAD_HTTP_STATUS);
|
|
const operation = shaka.util.AbortableOperation.failed(error);
|
|
fakeNetEngine.request.and.returnValue(operation);
|
|
|
|
await updateManifest();
|
|
expect(onError).toHaveBeenCalledTimes(1);
|
|
expect(updateTick).toHaveBeenCalledTimes(2);
|
|
});
|
|
|
|
it('fatal error on manifest update request failure when ' +
|
|
'raiseFatalErrorOnManifestUpdateRequestFailure is true', async () => {
|
|
const manifestConfig =
|
|
shaka.util.PlayerConfiguration.createDefault().manifest;
|
|
manifestConfig.raiseFatalErrorOnManifestUpdateRequestFailure = true;
|
|
parser.configure(manifestConfig);
|
|
|
|
const updateTick = updateTickSpy();
|
|
|
|
const lines = [
|
|
'<SegmentTemplate startNumber="1" media="s$Number$.mp4" duration="2"/>',
|
|
];
|
|
const manifestText = makeSimpleLiveManifestText(lines, updateTime);
|
|
/** @type {!jasmine.Spy} */
|
|
const onError = jasmine.createSpy('onError');
|
|
playerInterface.onError = Util.spyFunc(onError);
|
|
|
|
fakeNetEngine.setResponseText('dummy://foo', manifestText);
|
|
await parser.start('dummy://foo', playerInterface);
|
|
|
|
const error = new shaka.util.Error(
|
|
shaka.util.Error.Severity.CRITICAL,
|
|
shaka.util.Error.Category.NETWORK,
|
|
shaka.util.Error.Code.BAD_HTTP_STATUS);
|
|
const operation = shaka.util.AbortableOperation.failed(error);
|
|
fakeNetEngine.request.and.returnValue(operation);
|
|
|
|
await updateManifest();
|
|
expect(onError).toHaveBeenCalledWith(error);
|
|
expect(updateTick).toHaveBeenCalledTimes(1);
|
|
});
|
|
|
|
it('uses @minimumUpdatePeriod', async () => {
|
|
const lines = [
|
|
'<SegmentTemplate startNumber="1" media="s$Number$.mp4" duration="2" />',
|
|
];
|
|
// updateTime parameter sets @minimumUpdatePeriod in the manifest.
|
|
const manifestText = makeSimpleLiveManifestText(lines, updateTime);
|
|
|
|
/** @type {!jasmine.Spy} */
|
|
const tickAfter = updateTickSpy();
|
|
Date.now = () => 0;
|
|
|
|
fakeNetEngine.setResponseText('dummy://foo', manifestText);
|
|
await parser.start('dummy://foo', playerInterface);
|
|
|
|
expect(tickAfter).toHaveBeenCalledTimes(1);
|
|
const delay = tickAfter.calls.mostRecent().args[0];
|
|
expect(delay).toBe(updateTime);
|
|
});
|
|
|
|
it('does not update when @minimumUpdatePeriod is missing', async () => {
|
|
const lines = [
|
|
'<SegmentTemplate startNumber="1" media="s$Number$.mp4" duration="2" />',
|
|
];
|
|
// updateTime parameter sets @minimumUpdatePeriod in the manifest.
|
|
const manifestText =
|
|
makeSimpleLiveManifestText(lines, /* updateTime= */ null);
|
|
|
|
/** @type {!jasmine.Spy} */
|
|
const tickAfter = updateTickSpy();
|
|
|
|
fakeNetEngine.setResponseText('dummy://foo', manifestText);
|
|
await parser.start('dummy://foo', playerInterface);
|
|
|
|
expect(tickAfter).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('delays subsequent updates when an update is slow', async () => {
|
|
const lines = [
|
|
'<SegmentTemplate startNumber="1" media="s$Number$.mp4" duration="2" />',
|
|
];
|
|
const extraWaitTime = 15.0;
|
|
const manifestText = makeSimpleLiveManifestText(lines, 3);
|
|
|
|
let now = 0;
|
|
Date.now = () => now;
|
|
/** @type {!jasmine.Spy} */
|
|
const tickAfter = updateTickSpy();
|
|
|
|
fakeNetEngine.setResponseText('dummy://foo', manifestText);
|
|
/** @type {!shaka.util.PublicPromise} */
|
|
const delay = fakeNetEngine.delayNextRequest();
|
|
const p = parser.start('dummy://foo', playerInterface);
|
|
now += extraWaitTime * 1000; // Make the update appear to take longer.
|
|
delay.resolve();
|
|
await p;
|
|
|
|
// Check the last update was scheduled close to how long the update took.
|
|
const realDelay = tickAfter.calls.mostRecent().args[0];
|
|
expect(realDelay).toBeCloseTo(extraWaitTime, 0);
|
|
});
|
|
|
|
it('uses Mpd.Location', async () => {
|
|
const manifestText = [
|
|
'<MPD type="dynamic" availabilityStartTime="1970-01-01T00:00:00Z"',
|
|
' suggestedPresentationDelay="PT5S"',
|
|
' minimumUpdatePeriod="PT' + updateTime + 'S">',
|
|
' <Location>http://foobar</Location>',
|
|
' <Location>http://foobar2</Location>',
|
|
' <Location>foobar3</Location>',
|
|
' <Period id="1" duration="PT10S">',
|
|
' <AdaptationSet mimeType="video/mp4">',
|
|
' <Representation id="3" bandwidth="500">',
|
|
'<SegmentTemplate startNumber="1" media="s$Number$.mp4" duration="2" />',
|
|
' </Representation>',
|
|
' </AdaptationSet>',
|
|
' </Period>',
|
|
'</MPD>',
|
|
].join('\n');
|
|
fakeNetEngine.setResponseText('dummy://foo', manifestText);
|
|
|
|
const manifestRequest = shaka.net.NetworkingEngine.RequestType.MANIFEST;
|
|
const manifestContext = {
|
|
type: shaka.net.NetworkingEngine.AdvancedRequestType.MPD,
|
|
};
|
|
await parser.start('dummy://foo', playerInterface);
|
|
|
|
expect(fakeNetEngine.request).toHaveBeenCalledTimes(1);
|
|
fakeNetEngine.expectRequest('dummy://foo', manifestRequest, manifestContext);
|
|
fakeNetEngine.request.calls.reset();
|
|
|
|
// Create a mock so we can verify it gives two URIs.
|
|
// The third location is a relative url, and should be resolved as an
|
|
// absolute url.
|
|
fakeNetEngine.request.and.callFake((type, request, context) => {
|
|
expect(type).toBe(manifestRequest);
|
|
expect(context).toEqual(manifestContext);
|
|
expect(request.uris).toEqual(
|
|
['http://foobar', 'http://foobar2', 'dummy://foo/foobar3']);
|
|
const data = shaka.util.StringUtils.toUTF8(manifestText);
|
|
return shaka.util.AbortableOperation.completed(
|
|
{uri: request.uris[0], data: data, headers: {}});
|
|
});
|
|
|
|
await updateManifest();
|
|
expect(fakeNetEngine.request).toHaveBeenCalledTimes(1);
|
|
});
|
|
|
|
it('uses @suggestedPresentationDelay', async () => {
|
|
const manifestText = [
|
|
'<MPD type="dynamic" suggestedPresentationDelay="PT60S"',
|
|
' minimumUpdatePeriod="PT5S"',
|
|
' timeShiftBufferDepth="PT2M"',
|
|
' maxSegmentDuration="PT10S"',
|
|
' availabilityStartTime="1970-01-01T00:05:00Z">',
|
|
' <Period id="1">',
|
|
' <AdaptationSet mimeType="video/mp4">',
|
|
' <Representation id="3" bandwidth="500">',
|
|
' <BaseURL>http://example.com</BaseURL>',
|
|
'<SegmentTemplate startNumber="1" media="s$Number$.mp4" duration="2" />',
|
|
' </Representation>',
|
|
' </AdaptationSet>',
|
|
' </Period>',
|
|
'</MPD>',
|
|
].join('\n');
|
|
fakeNetEngine.setResponseText('dummy://foo', manifestText);
|
|
|
|
Date.now = () => 600000; /* 10 minutes */
|
|
const manifest = await parser.start('dummy://foo', playerInterface);
|
|
|
|
expect(manifest).toBeTruthy();
|
|
const timeline = manifest.presentationTimeline;
|
|
expect(timeline).toBeTruthy();
|
|
|
|
// We are 5 minutes into the presentation, with a
|
|
// @timeShiftBufferDepth of 120 seconds and a @maxSegmentDuration of
|
|
// 10 seconds, the start will be 2:50.
|
|
expect(timeline.getSegmentAvailabilityStart()).toBe(170);
|
|
// Normally the end should be 4:50; but with a 60 second
|
|
// @suggestedPresentationDelay it will be 3:50 minutes.
|
|
expect(timeline.getSegmentAvailabilityEnd()).toBe(290);
|
|
expect(timeline.getSeekRangeEnd()).toBe(230);
|
|
});
|
|
|
|
it('parses availabilityTimeOffset', async () => {
|
|
const manifestText = [
|
|
'<MPD type="dynamic" suggestedPresentationDelay="PT0S"',
|
|
' minimumUpdatePeriod="PT5S"',
|
|
' timeShiftBufferDepth="PT2M"',
|
|
' maxSegmentDuration="PT10S"',
|
|
' availabilityStartTime="1970-01-01T00:05:00Z">',
|
|
' <Period id="1">',
|
|
' <AdaptationSet mimeType="video/mp4">',
|
|
' <Representation id="3" bandwidth="500">',
|
|
' <BaseURL availabilityTimeOffset="6">http://example.com',
|
|
' </BaseURL>',
|
|
' <SegmentTemplate availabilityTimeOffset="6.00" ',
|
|
' startNumber="1" media="s$Number$.mp4" duration="2" />',
|
|
' </Representation>',
|
|
' </AdaptationSet>',
|
|
' </Period>',
|
|
'</MPD>',
|
|
].join('\n');
|
|
fakeNetEngine.setResponseText('dummy://foo', manifestText);
|
|
playerInterface.isLowLatencyMode = () => true;
|
|
|
|
Date.now = () => 600000; /* 10 minutes */
|
|
const manifest = await parser.start('dummy://foo', playerInterface);
|
|
|
|
expect(manifest).toBeTruthy();
|
|
const timeline = manifest.presentationTimeline;
|
|
expect(timeline).toBeTruthy();
|
|
|
|
// We are 5 minutes into the presentation, with a @timeShiftBufferDepth of
|
|
// 120 seconds and a @maxSegmentDuration of 10 seconds, the start will be
|
|
// 2:50. With the availabilityTimeOffset of 6+6 seconds, it will be 3:02.
|
|
expect(timeline.getSegmentAvailabilityStart()).toBe(182);
|
|
// Normally the end should be 4:50; with the availabilityTimeOffset of
|
|
// 12 seconds, it will be 5:02.
|
|
expect(timeline.getSegmentAvailabilityEnd()).toBe(302);
|
|
expect(timeline.getSeekRangeEnd()).toBe(302);
|
|
});
|
|
|
|
describe('availabilityWindowOverride', () => {
|
|
it('overrides @timeShiftBufferDepth', async () => {
|
|
const manifestText = [
|
|
'<MPD type="dynamic" suggestedPresentationDelay="PT60S"',
|
|
' minimumUpdatePeriod="PT5S"',
|
|
' timeShiftBufferDepth="PT2M"',
|
|
' maxSegmentDuration="PT10S"',
|
|
' availabilityStartTime="1970-01-01T00:05:00Z">',
|
|
' <Period id="1">',
|
|
' <AdaptationSet mimeType="video/mp4">',
|
|
' <Representation id="3" bandwidth="500">',
|
|
' <BaseURL>http://example.com</BaseURL>',
|
|
' <SegmentTemplate media="s$Number$.mp4" duration="2" />',
|
|
' </Representation>',
|
|
' </AdaptationSet>',
|
|
' </Period>',
|
|
'</MPD>',
|
|
].join('\n');
|
|
fakeNetEngine.setResponseText('dummy://foo', manifestText);
|
|
|
|
const config = shaka.util.PlayerConfiguration.createDefault().manifest;
|
|
config.availabilityWindowOverride = 4 * 60;
|
|
parser.configure(config);
|
|
|
|
Date.now = () => 600000; /* 10 minutes */
|
|
const manifest = await parser.start('dummy://foo', playerInterface);
|
|
|
|
expect(manifest).toBeTruthy();
|
|
const timeline = manifest.presentationTimeline;
|
|
expect(timeline).toBeTruthy();
|
|
|
|
// The parser was configured to have a manifest availability window
|
|
// of 4 minutes.
|
|
const end = timeline.getSegmentAvailabilityEnd();
|
|
const start = timeline.getSegmentAvailabilityStart();
|
|
expect(end - start).toBe(4 * 60);
|
|
});
|
|
});
|
|
|
|
describe('maxSegmentDuration', () => {
|
|
it('uses @maxSegmentDuration', async () => {
|
|
const manifestText = [
|
|
'<MPD type="dynamic" suggestedPresentationDelay="PT0S"',
|
|
' minimumUpdatePeriod="PT5S"',
|
|
' timeShiftBufferDepth="PT2M"',
|
|
' maxSegmentDuration="PT15S"',
|
|
' availabilityStartTime="1970-01-01T00:05:00Z">',
|
|
' <Period id="1">',
|
|
' <AdaptationSet id="2" mimeType="video/mp4">',
|
|
' <Representation id="3" bandwidth="500">',
|
|
' <BaseURL>http://example.com</BaseURL>',
|
|
'<SegmentTemplate media="s$Number$.mp4" duration="2" />',
|
|
' </Representation>',
|
|
' </AdaptationSet>',
|
|
' </Period>',
|
|
'</MPD>',
|
|
].join('\n');
|
|
fakeNetEngine.setResponseText('dummy://foo', manifestText);
|
|
|
|
Date.now = () => 600000; /* 10 minutes */
|
|
const manifest = await parser.start('dummy://foo', playerInterface);
|
|
|
|
expect(manifest).toBeTruthy();
|
|
const timeline = manifest.presentationTimeline;
|
|
expect(timeline).toBeTruthy();
|
|
expect(timeline.getMaxSegmentDuration()).toBe(15);
|
|
});
|
|
|
|
it('derived from SegmentTemplate w/ SegmentTimeline', async () => {
|
|
const lines = [
|
|
'<SegmentTemplate media="s$Number$.mp4">',
|
|
' <SegmentTimeline>',
|
|
' <S t="0" d="7" />',
|
|
' <S d="8" />',
|
|
' <S d="6" />',
|
|
' </SegmentTimeline>',
|
|
'</SegmentTemplate>',
|
|
];
|
|
await testDerived(lines);
|
|
});
|
|
|
|
it('derived from SegmentTemplate w/ @duration', async () => {
|
|
const lines = [
|
|
'<SegmentTemplate media="s$Number$.mp4" duration="8" />',
|
|
];
|
|
await testDerived(lines);
|
|
});
|
|
|
|
it('derived from SegmentList', async () => {
|
|
const lines = [
|
|
'<SegmentList duration="8">',
|
|
' <SegmentURL media="s1.mp4" />',
|
|
' <SegmentURL media="s2.mp4" />',
|
|
'</SegmentList>',
|
|
];
|
|
await testDerived(lines);
|
|
});
|
|
|
|
it('derived from SegmentList w/ SegmentTimeline', async () => {
|
|
const lines = [
|
|
'<SegmentList duration="8">',
|
|
' <SegmentTimeline>',
|
|
' <S t="0" d="5" />',
|
|
' <S d="4" />',
|
|
' <S d="8" />',
|
|
' </SegmentTimeline>',
|
|
' <SegmentURL media="s1.mp4" />',
|
|
' <SegmentURL media="s2.mp4" />',
|
|
'</SegmentList>',
|
|
];
|
|
await testDerived(lines);
|
|
});
|
|
|
|
async function testDerived(lines) {
|
|
const template = [
|
|
'<MPD type="dynamic" suggestedPresentationDelay="PT0S"',
|
|
' minimumUpdatePeriod="PT5S"',
|
|
' timeShiftBufferDepth="PT2M"',
|
|
' availabilityStartTime="1970-01-01T00:05:00Z">',
|
|
' <Period id="1">',
|
|
' <AdaptationSet id="2" mimeType="video/mp4">',
|
|
' <Representation id="3" bandwidth="500">',
|
|
' <BaseURL>http://example.com</BaseURL>',
|
|
'%(contents)s',
|
|
' </Representation>',
|
|
' </AdaptationSet>',
|
|
' </Period>',
|
|
'</MPD>',
|
|
].join('\n');
|
|
const manifestText = sprintf(template, {contents: lines.join('\n')});
|
|
|
|
fakeNetEngine.setResponseText('dummy://foo', manifestText);
|
|
Date.now = () => 600000; /* 10 minutes */
|
|
const manifest = await parser.start('dummy://foo', playerInterface);
|
|
|
|
expect(manifest).toBeTruthy();
|
|
const timeline = manifest.presentationTimeline;
|
|
expect(timeline).toBeTruthy();
|
|
|
|
// NOTE: the largest segment is 8 seconds long in each test.
|
|
expect(timeline.getMaxSegmentDuration()).toBe(8);
|
|
}
|
|
}); // describe('maxSegmentDuration')
|
|
|
|
describe('stop', () => {
|
|
const manifestRequestType = shaka.net.NetworkingEngine.RequestType.MANIFEST;
|
|
const manifestContext = {
|
|
type: shaka.net.NetworkingEngine.AdvancedRequestType.MPD,
|
|
};
|
|
const dateRequestType = shaka.net.NetworkingEngine.RequestType.TIMING;
|
|
const manifestUri = 'dummy://foo';
|
|
const dateUri = 'http://foo.bar/date';
|
|
|
|
beforeEach(() => {
|
|
const manifest = [
|
|
'<MPD type="dynamic" availabilityStartTime="1970-01-01T00:00:00Z"',
|
|
' minimumUpdatePeriod="PT' + updateTime + 'S">',
|
|
' <UTCTiming schemeIdUri="urn:mpeg:dash:utc:http-xsdate:2014"',
|
|
' value="http://foo.bar/date" />',
|
|
' <UTCTiming schemeIdUri="urn:mpeg:dash:utc:http-xsdate:2014"',
|
|
' value="http://foo.bar/date" />',
|
|
' <Period id="1">',
|
|
' <AdaptationSet mimeType="video/mp4">',
|
|
' <Representation id="3" bandwidth="500">',
|
|
' <BaseURL>http://example.com</BaseURL>',
|
|
' <SegmentTemplate startNumber="1" media="s$Number$.mp4"',
|
|
' duration="2" />',
|
|
' </Representation>',
|
|
' </AdaptationSet>',
|
|
' </Period>',
|
|
'</MPD>',
|
|
].join('\n');
|
|
fakeNetEngine
|
|
.setResponseText('http://foo.bar/date', '1970-01-01T00:00:30Z')
|
|
.setResponseText('dummy://foo', manifest);
|
|
});
|
|
|
|
it('stops updates', async () => {
|
|
await parser.start(manifestUri, playerInterface);
|
|
|
|
fakeNetEngine.expectRequest(
|
|
manifestUri, manifestRequestType, manifestContext);
|
|
fakeNetEngine.request.calls.reset();
|
|
|
|
parser.stop();
|
|
await updateManifest();
|
|
expect(fakeNetEngine.request).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('stops initial parsing', async () => {
|
|
const expectation =
|
|
expectAsync(parser.start('dummy://foo', playerInterface))
|
|
.toBeRejected();
|
|
// start will only begin the network request, calling stop here will be
|
|
// after the request has started but before any parsing has been done.
|
|
expect(fakeNetEngine.request).toHaveBeenCalledTimes(1);
|
|
parser.stop();
|
|
await expectation;
|
|
|
|
fakeNetEngine.expectRequest(
|
|
manifestUri, manifestRequestType, manifestContext);
|
|
fakeNetEngine.request.calls.reset();
|
|
await updateManifest();
|
|
// An update should not occur.
|
|
expect(fakeNetEngine.request).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('interrupts manifest updates', async () => {
|
|
const manifest = await parser.start('dummy://foo', playerInterface);
|
|
|
|
expect(manifest).toBeTruthy();
|
|
fakeNetEngine.expectRequest(
|
|
manifestUri, manifestRequestType, manifestContext);
|
|
fakeNetEngine.request.calls.reset();
|
|
/** @type {!shaka.util.PublicPromise} */
|
|
const delay = fakeNetEngine.delayNextRequest();
|
|
|
|
await updateManifest();
|
|
// The request was made but should not be resolved yet.
|
|
expect(fakeNetEngine.request).toHaveBeenCalledTimes(1);
|
|
fakeNetEngine.expectRequest(
|
|
manifestUri, manifestRequestType, manifestContext);
|
|
fakeNetEngine.request.calls.reset();
|
|
parser.stop();
|
|
delay.resolve();
|
|
|
|
// Wait for another update period.
|
|
await updateManifest();
|
|
// A second update should not occur.
|
|
expect(fakeNetEngine.request).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('interrupts UTCTiming requests', async () => {
|
|
/** @type {!shaka.util.PublicPromise} */
|
|
let delay = fakeNetEngine.delayNextRequest();
|
|
const expectation =
|
|
expectAsync(parser.start('dummy://foo', playerInterface))
|
|
.toBeRejected();
|
|
|
|
await Util.shortDelay();
|
|
// This is the initial manifest request.
|
|
expect(fakeNetEngine.request).toHaveBeenCalledTimes(1);
|
|
fakeNetEngine.expectRequest(
|
|
manifestUri, manifestRequestType, manifestContext);
|
|
fakeNetEngine.request.calls.reset();
|
|
// Resolve the manifest request and wait on the UTCTiming request.
|
|
delay.resolve();
|
|
delay = fakeNetEngine.delayNextRequest();
|
|
await Util.shortDelay();
|
|
|
|
// This is the first UTCTiming request.
|
|
expect(fakeNetEngine.request).toHaveBeenCalledTimes(1);
|
|
fakeNetEngine.expectRequest(dateUri, dateRequestType);
|
|
fakeNetEngine.request.calls.reset();
|
|
// Interrupt the parser, then fail the request.
|
|
parser.stop();
|
|
delay.reject();
|
|
await expectation;
|
|
|
|
// Wait for another update period.
|
|
await updateManifest();
|
|
|
|
// No more updates should occur.
|
|
expect(fakeNetEngine.request).not.toHaveBeenCalled();
|
|
});
|
|
});
|
|
|
|
describe('SegmentTemplate w/ SegmentTimeline', () => {
|
|
const basicLines = [
|
|
'<SegmentTemplate startNumber="1" media="s$Number$.mp4">',
|
|
' <SegmentTimeline>',
|
|
' <S d="10" t="0" />',
|
|
' <S d="5" />',
|
|
' <S d="15" />',
|
|
' </SegmentTimeline>',
|
|
'</SegmentTemplate>',
|
|
];
|
|
const basicRefs = [
|
|
shaka.test.ManifestParser.makeReference('s1.mp4', 0, 10, originalUri),
|
|
shaka.test.ManifestParser.makeReference('s2.mp4', 10, 15, originalUri),
|
|
shaka.test.ManifestParser.makeReference('s3.mp4', 15, 30, originalUri),
|
|
];
|
|
const updateLines = [
|
|
'<SegmentTemplate startNumber="1" media="s$Number$.mp4">',
|
|
' <SegmentTimeline>',
|
|
' <S d="10" t="0" />',
|
|
' <S d="5" />',
|
|
' <S d="15" />',
|
|
' <S d="10" />',
|
|
' </SegmentTimeline>',
|
|
'</SegmentTemplate>',
|
|
];
|
|
const updateRefs = [
|
|
shaka.test.ManifestParser.makeReference('s1.mp4', 0, 10, originalUri),
|
|
shaka.test.ManifestParser.makeReference('s2.mp4', 10, 15, originalUri),
|
|
shaka.test.ManifestParser.makeReference('s3.mp4', 15, 30, originalUri),
|
|
shaka.test.ManifestParser.makeReference('s4.mp4', 30, 40, originalUri),
|
|
];
|
|
const partialUpdateLines = [
|
|
'<SegmentTemplate startNumber="3" media="s$Number$.mp4">',
|
|
' <SegmentTimeline>',
|
|
' <S d="15" t="15" />',
|
|
' <S d="10" />',
|
|
' </SegmentTimeline>',
|
|
'</SegmentTemplate>',
|
|
];
|
|
|
|
testCommonBehaviors(
|
|
basicLines, basicRefs, updateLines, updateRefs, partialUpdateLines);
|
|
});
|
|
|
|
describe('SegmentList w/ SegmentTimeline', () => {
|
|
const basicLines = [
|
|
'<SegmentList>',
|
|
' <SegmentURL media="s1.mp4" />',
|
|
' <SegmentURL media="s2.mp4" />',
|
|
' <SegmentURL media="s3.mp4" />',
|
|
' <SegmentTimeline>',
|
|
' <S d="10" t="0" />',
|
|
' <S d="5" />',
|
|
' <S d="15" />',
|
|
' </SegmentTimeline>',
|
|
'</SegmentList>',
|
|
];
|
|
const basicRefs = [
|
|
shaka.test.ManifestParser.makeReference('s1.mp4', 0, 10, originalUri),
|
|
shaka.test.ManifestParser.makeReference('s2.mp4', 10, 15, originalUri),
|
|
shaka.test.ManifestParser.makeReference('s3.mp4', 15, 30, originalUri),
|
|
];
|
|
const updateLines = [
|
|
'<SegmentList>',
|
|
' <SegmentURL media="s1.mp4" />',
|
|
' <SegmentURL media="s2.mp4" />',
|
|
' <SegmentURL media="s3.mp4" />',
|
|
' <SegmentURL media="s4.mp4" />',
|
|
' <SegmentTimeline>',
|
|
' <S d="10" t="0" />',
|
|
' <S d="5" />',
|
|
' <S d="15" />',
|
|
' <S d="10" />',
|
|
' </SegmentTimeline>',
|
|
'</SegmentList>',
|
|
];
|
|
const updateRefs = [
|
|
shaka.test.ManifestParser.makeReference('s1.mp4', 0, 10, originalUri),
|
|
shaka.test.ManifestParser.makeReference('s2.mp4', 10, 15, originalUri),
|
|
shaka.test.ManifestParser.makeReference('s3.mp4', 15, 30, originalUri),
|
|
shaka.test.ManifestParser.makeReference('s4.mp4', 30, 40, originalUri),
|
|
];
|
|
const partialUpdateLines = [
|
|
'<SegmentList startNumber="3">',
|
|
' <SegmentURL media="s3.mp4" />',
|
|
' <SegmentURL media="s4.mp4" />',
|
|
' <SegmentTimeline>',
|
|
' <S d="15" t="15" />',
|
|
' <S d="10" />',
|
|
' </SegmentTimeline>',
|
|
'</SegmentList>',
|
|
];
|
|
|
|
testCommonBehaviors(
|
|
basicLines, basicRefs, updateLines, updateRefs, partialUpdateLines);
|
|
});
|
|
|
|
describe('SegmentList w/ @duration', () => {
|
|
const basicLines = [
|
|
'<SegmentList duration="10">',
|
|
' <SegmentURL media="s1.mp4" />',
|
|
' <SegmentURL media="s2.mp4" />',
|
|
' <SegmentURL media="s3.mp4" />',
|
|
'</SegmentList>',
|
|
];
|
|
const basicRefs = [
|
|
shaka.test.ManifestParser.makeReference('s1.mp4', 0, 10, originalUri),
|
|
shaka.test.ManifestParser.makeReference('s2.mp4', 10, 20, originalUri),
|
|
shaka.test.ManifestParser.makeReference('s3.mp4', 20, 30, originalUri),
|
|
];
|
|
const updateLines = [
|
|
'<SegmentList duration="10">',
|
|
' <SegmentURL media="s1.mp4" />',
|
|
' <SegmentURL media="s2.mp4" />',
|
|
' <SegmentURL media="s3.mp4" />',
|
|
' <SegmentURL media="s4.mp4" />',
|
|
'</SegmentList>',
|
|
];
|
|
const updateRefs = [
|
|
shaka.test.ManifestParser.makeReference('s1.mp4', 0, 10, originalUri),
|
|
shaka.test.ManifestParser.makeReference('s2.mp4', 10, 20, originalUri),
|
|
shaka.test.ManifestParser.makeReference('s3.mp4', 20, 30, originalUri),
|
|
shaka.test.ManifestParser.makeReference('s4.mp4', 30, 40, originalUri),
|
|
];
|
|
const partialUpdateLines = [
|
|
'<SegmentList startNumber="3" duration="10">',
|
|
' <SegmentURL media="s3.mp4" />',
|
|
' <SegmentURL media="s4.mp4" />',
|
|
'</SegmentList>',
|
|
];
|
|
|
|
testCommonBehaviors(
|
|
basicLines, basicRefs, updateLines, updateRefs, partialUpdateLines);
|
|
});
|
|
|
|
describe('SegmentTemplate w/ duration', () => {
|
|
const templateLines = [
|
|
'<SegmentTemplate startNumber="1" media="s$Number$.mp4" duration="2" />',
|
|
];
|
|
|
|
it('produces sane references without assertions', async () => {
|
|
const manifestText =
|
|
makeSimpleLiveManifestText(templateLines, updateTime);
|
|
|
|
fakeNetEngine.setResponseText('dummy://foo', manifestText);
|
|
const manifest = await parser.start('dummy://foo', playerInterface);
|
|
|
|
const stream = manifest.variants[0].video;
|
|
await stream.createSegmentIndex();
|
|
|
|
const liveEdge =
|
|
manifest.presentationTimeline.getSegmentAvailabilityEnd();
|
|
|
|
// In https://github.com/shaka-project/shaka-player/issues/1204, a get on
|
|
// the final segment failed an assertion and returned endTime == 0.
|
|
// Find the last segment by looking just before the live edge. Looking
|
|
// right on the live edge creates test flake, and the segments are 2
|
|
// seconds in duration.
|
|
const idx = stream.segmentIndex.find(liveEdge - 0.5);
|
|
goog.asserts.assert(idx != null, 'Live edge not found!');
|
|
|
|
// This should not throw an assertion.
|
|
const ref = stream.segmentIndex.get(idx);
|
|
// The segment's endTime should definitely not be 0.
|
|
expect(ref.endTime).toBeGreaterThan(0);
|
|
});
|
|
});
|
|
|
|
describe('EventStream', () => {
|
|
const originalManifest = [
|
|
'<MPD type="dynamic" minimumUpdatePeriod="PT' + updateTime + 'S"',
|
|
' availabilityStartTime="1970-01-01T00:00:00Z">',
|
|
' <Period id="1" duration="PT60S" start="PT10S">',
|
|
' <EventStream schemeIdUri="http://example.com" value="foobar"',
|
|
' timescale="100">',
|
|
' <Event duration="5000" />',
|
|
' <Event id="abc" presentationTime="300" duration="1000" />',
|
|
' </EventStream>',
|
|
' <AdaptationSet mimeType="video/mp4">',
|
|
' <Representation bandwidth="1">',
|
|
' <SegmentTemplate startNumber="1" media="s$Number$.mp4"',
|
|
' duration="2" />',
|
|
' </Representation>',
|
|
' </AdaptationSet>',
|
|
' </Period>',
|
|
'</MPD>',
|
|
].join('\n');
|
|
|
|
/** @type {!jasmine.Spy} */
|
|
let onTimelineRegionAddedSpy;
|
|
|
|
beforeEach(() => {
|
|
onTimelineRegionAddedSpy = jasmine.createSpy('onTimelineRegionAdded');
|
|
playerInterface.onTimelineRegionAdded =
|
|
shaka.test.Util.spyFunc(onTimelineRegionAddedSpy);
|
|
});
|
|
|
|
it('will parse EventStream nodes', async () => {
|
|
fakeNetEngine.setResponseText('dummy://foo', originalManifest);
|
|
await parser.start('dummy://foo', playerInterface);
|
|
|
|
expect(onTimelineRegionAddedSpy).toHaveBeenCalledTimes(2);
|
|
|
|
expect(onTimelineRegionAddedSpy).toHaveBeenCalledWith({
|
|
schemeIdUri: 'http://example.com',
|
|
value: 'foobar',
|
|
startTime: 10,
|
|
endTime: 60,
|
|
id: '',
|
|
eventElement: jasmine.any(Element),
|
|
});
|
|
expect(onTimelineRegionAddedSpy).toHaveBeenCalledWith({
|
|
schemeIdUri: 'http://example.com',
|
|
value: 'foobar',
|
|
startTime: 13,
|
|
endTime: 23,
|
|
id: 'abc',
|
|
eventElement: jasmine.any(Element),
|
|
});
|
|
});
|
|
|
|
it('will add timeline regions on manifest update', async () => {
|
|
const newManifest = [
|
|
'<MPD type="dynamic" minimumUpdatePeriod="PT' + updateTime + 'S"',
|
|
' availabilityStartTime="1970-01-01T00:00:00Z">',
|
|
' <Period id="1" duration="PT30S">',
|
|
' <EventStream schemeIdUri="http://example.com" timescale="100">',
|
|
' <Event id="100" />',
|
|
' </EventStream>',
|
|
' <AdaptationSet mimeType="video/mp4">',
|
|
' <Representation bandwidth="1">',
|
|
' <SegmentTemplate startNumber="1" media="s$Number$.mp4"',
|
|
' duration="2" />',
|
|
' </Representation>',
|
|
' </AdaptationSet>',
|
|
' </Period>',
|
|
'</MPD>',
|
|
].join('\n');
|
|
|
|
fakeNetEngine.setResponseText('dummy://foo', originalManifest);
|
|
await parser.start('dummy://foo', playerInterface);
|
|
|
|
expect(onTimelineRegionAddedSpy).toHaveBeenCalledTimes(2);
|
|
onTimelineRegionAddedSpy.calls.reset();
|
|
|
|
fakeNetEngine.setResponseText('dummy://foo', newManifest);
|
|
await updateManifest();
|
|
|
|
expect(onTimelineRegionAddedSpy).toHaveBeenCalledTimes(1);
|
|
});
|
|
|
|
it('will not let an event exceed the Period duration', async () => {
|
|
const newManifest = [
|
|
'<MPD>',
|
|
' <Period id="1" duration="PT30S">',
|
|
' <EventStream schemeIdUri="http://example.com" timescale="1">',
|
|
' <Event presentationTime="10" duration="15"/>',
|
|
' <Event presentationTime="25" duration="50"/>',
|
|
' <Event presentationTime="50" duration="10"/>',
|
|
' </EventStream>',
|
|
' <AdaptationSet mimeType="video/mp4">',
|
|
' <Representation bandwidth="1">',
|
|
' <SegmentTemplate startNumber="1" media="s$Number$.mp4"',
|
|
' duration="2" />',
|
|
' </Representation>',
|
|
' </AdaptationSet>',
|
|
' </Period>',
|
|
'</MPD>',
|
|
].join('\n');
|
|
|
|
fakeNetEngine.setResponseText('dummy://foo', newManifest);
|
|
await parser.start('dummy://foo', playerInterface);
|
|
|
|
expect(onTimelineRegionAddedSpy).toHaveBeenCalledTimes(3);
|
|
expect(onTimelineRegionAddedSpy)
|
|
.toHaveBeenCalledWith(
|
|
jasmine.objectContaining({startTime: 10, endTime: 25}));
|
|
expect(onTimelineRegionAddedSpy)
|
|
.toHaveBeenCalledWith(
|
|
jasmine.objectContaining({startTime: 25, endTime: 30}));
|
|
expect(onTimelineRegionAddedSpy)
|
|
.toHaveBeenCalledWith(
|
|
jasmine.objectContaining({startTime: 30, endTime: 30}));
|
|
});
|
|
|
|
it('will parse multiple events at same offset', async () => {
|
|
const newManifest = [
|
|
'<MPD>',
|
|
' <Period id="1" duration="PT30S">',
|
|
' <EventStream schemeIdUri="http://example.com" timescale="1">',
|
|
' <Event id="1" presentationTime="10" duration="15"/>',
|
|
' <Event id="2" presentationTime="10" duration="15"/>',
|
|
' </EventStream>',
|
|
' <AdaptationSet mimeType="video/mp4">',
|
|
' <Representation bandwidth="1">',
|
|
' <SegmentTemplate startNumber="1" media="s$Number$.mp4"',
|
|
' duration="2" />',
|
|
' </Representation>',
|
|
' </AdaptationSet>',
|
|
' </Period>',
|
|
'</MPD>',
|
|
].join('\n');
|
|
|
|
fakeNetEngine.setResponseText('dummy://foo', newManifest);
|
|
await parser.start('dummy://foo', playerInterface);
|
|
|
|
expect(onTimelineRegionAddedSpy).toHaveBeenCalledTimes(2);
|
|
expect(onTimelineRegionAddedSpy)
|
|
.toHaveBeenCalledWith(
|
|
jasmine.objectContaining({id: '1', startTime: 10, endTime: 25}));
|
|
expect(onTimelineRegionAddedSpy)
|
|
.toHaveBeenCalledWith(
|
|
jasmine.objectContaining({id: '2', startTime: 10, endTime: 25}));
|
|
});
|
|
|
|
it('will not add timeline regions outside the DVR window', async () => {
|
|
const manifest = [
|
|
'<MPD type="dynamic" minimumUpdatePeriod="PT' + updateTime + 'S"',
|
|
' availabilityStartTime="1970-01-01T00:00:00Z"',
|
|
' suggestedPresentationDelay="PT0S"',
|
|
' timeShiftBufferDepth="PT30S">',
|
|
' <Period id="1">',
|
|
' <EventStream schemeIdUri="http://example.com" timescale="1">',
|
|
' <Event id="0" presentationTime="0" duration="10"/>',
|
|
' <Event id="1" presentationTime="10" duration="10"/>',
|
|
' <Event id="2" presentationTime="20" duration="10"/>',
|
|
' <Event id="3" presentationTime="30" duration="10"/>',
|
|
' <Event id="4" presentationTime="40" duration="10"/>',
|
|
' </EventStream>',
|
|
' <AdaptationSet mimeType="video/mp4">',
|
|
' <Representation bandwidth="1">',
|
|
' <SegmentTemplate startNumber="1" media="s$Number$.mp4"',
|
|
' duration="2" />',
|
|
' </Representation>',
|
|
' </AdaptationSet>',
|
|
' </Period>',
|
|
'</MPD>',
|
|
].join('\n');
|
|
|
|
// 45 seconds after the epoch, which is also 45 seconds after the
|
|
// presentation started. Only the last 30 seconds are available, from
|
|
// time 15 to 45.
|
|
Date.now = () => 45 * 1000;
|
|
|
|
fakeNetEngine.setResponseText('dummy://foo', manifest);
|
|
await parser.start('dummy://foo', playerInterface);
|
|
|
|
expect(onTimelineRegionAddedSpy).toHaveBeenCalledTimes(4);
|
|
expect(onTimelineRegionAddedSpy).toHaveBeenCalledWith(
|
|
jasmine.objectContaining({id: '1'}));
|
|
expect(onTimelineRegionAddedSpy).toHaveBeenCalledWith(
|
|
jasmine.objectContaining({id: '2'}));
|
|
expect(onTimelineRegionAddedSpy).toHaveBeenCalledWith(
|
|
jasmine.objectContaining({id: '3'}));
|
|
expect(onTimelineRegionAddedSpy).toHaveBeenCalledWith(
|
|
jasmine.objectContaining({id: '4'}));
|
|
});
|
|
});
|
|
|
|
it('honors clockSyncUri for in-progress recordings', async () => {
|
|
const manifestText = [
|
|
'<MPD type="dynamic" availabilityStartTime="1970-01-01T00:05:00Z"',
|
|
' mediaPresentationDuration="PT3600S">',
|
|
' <Period id="1">',
|
|
' <AdaptationSet mimeType="video/mp4">',
|
|
' <Representation id="3" bandwidth="500">',
|
|
' <BaseURL>http://example.com</BaseURL>',
|
|
' <SegmentTemplate media="s$Number$.mp4" duration="2" />',
|
|
' </Representation>',
|
|
' </AdaptationSet>',
|
|
' </Period>',
|
|
'</MPD>',
|
|
].join('\n');
|
|
fakeNetEngine.setResponseText('dummy://foo', manifestText);
|
|
|
|
// Simulate a realistic clock sync URI.
|
|
fakeNetEngine.setResponseText('dummy://time', '');
|
|
fakeNetEngine.setHeaders('dummy://time', {
|
|
'date': (new Date()).toUTCString(),
|
|
});
|
|
|
|
const config = shaka.util.PlayerConfiguration.createDefault().manifest;
|
|
config.dash.clockSyncUri = 'dummy://time';
|
|
parser.configure(config);
|
|
|
|
const manifest = await parser.start('dummy://foo', playerInterface);
|
|
|
|
// Make sure we're testing what we think we're testing.
|
|
// This should be seen as in-progress.
|
|
expect(manifest.presentationTimeline.isInProgress()).toBe(true);
|
|
|
|
// Now make sure we made the time sync request.
|
|
const timingRequest = shaka.net.NetworkingEngine.RequestType.TIMING;
|
|
fakeNetEngine.expectRequest('dummy://time', timingRequest);
|
|
});
|
|
|
|
it('adds segments to in-progress recordings', async () => {
|
|
const manifestText = [
|
|
'<MPD type="dynamic" availabilityStartTime="1970-01-01T00:00:00Z"',
|
|
' mediaPresentationDuration="PT10S">',
|
|
' <Period id="1">',
|
|
' <AdaptationSet mimeType="video/mp4">',
|
|
' <Representation id="3" bandwidth="500">',
|
|
' <BaseURL>http://example.com</BaseURL>',
|
|
' <SegmentTemplate media="s$Number$.mp4" duration="2" />',
|
|
' </Representation>',
|
|
' </AdaptationSet>',
|
|
' </Period>',
|
|
'</MPD>',
|
|
].join('\n');
|
|
fakeNetEngine.setResponseText('dummy://foo', manifestText);
|
|
|
|
// The presentation started just over 4 seconds ago. There should be 2
|
|
// segments so far.
|
|
Date.now = () => 4.1 * 1000;
|
|
const manifest = await parser.start('dummy://foo', playerInterface);
|
|
|
|
// Make sure we're testing what we think we're testing.
|
|
// This should be seen as in-progress.
|
|
expect(manifest.presentationTimeline.isInProgress()).toBe(true);
|
|
|
|
const stream = manifest.variants[0].video;
|
|
expect(stream).toBeTruthy();
|
|
|
|
await stream.createSegmentIndex();
|
|
expect(stream.segmentIndex).toBeTruthy();
|
|
|
|
// Check for the 2 initial segments we're expecting.
|
|
ManifestParser.verifySegmentIndex(stream, [
|
|
shaka.test.ManifestParser.makeReference('s1.mp4', 0, 2, originalUri),
|
|
shaka.test.ManifestParser.makeReference('s2.mp4', 2, 4, originalUri),
|
|
]);
|
|
|
|
// Just over 10 seconds after the presentation started, we should now have
|
|
// all 5 segments. In order to trick the system into updating, we must both
|
|
// fake the current time and wait long enough for the timer to fire and
|
|
// update the references.
|
|
Date.now = () => 10.1 * 1000;
|
|
await shaka.test.Util.delay(2.1); // A little longer than the segments are.
|
|
|
|
ManifestParser.verifySegmentIndex(stream, [
|
|
shaka.test.ManifestParser.makeReference('s1.mp4', 0, 2, originalUri),
|
|
shaka.test.ManifestParser.makeReference('s2.mp4', 2, 4, originalUri),
|
|
shaka.test.ManifestParser.makeReference('s3.mp4', 4, 6, originalUri),
|
|
shaka.test.ManifestParser.makeReference('s4.mp4', 6, 8, originalUri),
|
|
shaka.test.ManifestParser.makeReference('s5.mp4', 8, 10, originalUri),
|
|
]);
|
|
});
|
|
});
|