videojs-contrib-hls
Version:
Play back HLS with video.js, even where it's not natively supported
2,463 lines • 86.2 kB
JavaScript
import QUnit from 'qunit';
import videojs from 'video.js';
import {
useFakeEnvironment,
useFakeMediaSource,
createPlayer,
standardXHRResponse,
openMediaSource
} from './test-helpers.js';
import manifests from './test-manifests.js';
import {
MasterPlaylistController,
mimeTypesForPlaylist_,
mapLegacyAvcCodecs_
} from '../src/master-playlist-controller';
/* eslint-disable no-unused-vars */
// we need this so that it can register hls with videojs
import { Hls } from '../src/videojs-contrib-hls';
/* eslint-enable no-unused-vars */
import Playlist from '../src/playlist';
import Config from '../src/config';
const generateMedia = function(isMaat, isMuxed, hasVideoCodec, hasAudioCodec, isFMP4) {
const codec = (hasVideoCodec ? 'avc1.deadbeef' : '') +
(hasVideoCodec && hasAudioCodec ? ',' : '') +
(hasAudioCodec ? 'mp4a.40.E' : '');
const master = {
mediaGroups: {},
playlists: []
};
const media = {
attributes: {}
};
if (isMaat) {
master.mediaGroups.AUDIO = {
test: {
demuxed: {
uri: 'foo.bar'
}
}
};
if (isMuxed) {
master.mediaGroups.AUDIO.test.muxed = {};
}
media.attributes.AUDIO = 'test';
}
if (isFMP4) {
// This is not a great way to signal that the playlist is fmp4 but
// this is how we currently detect it in HLS so let's emulate it here
media.segments = [
{
map: 'test'
}
];
}
if (hasVideoCodec || hasAudioCodec) {
media.attributes.CODECS = codec;
}
return [master, media];
};
QUnit.module('MasterPlaylistController', {
beforeEach(assert) {
this.env = useFakeEnvironment(assert);
this.clock = this.env.clock;
this.requests = this.env.requests;
this.mse = useFakeMediaSource();
// force the HLS tech to run
this.origSupportsNativeHls = videojs.Hls.supportsNativeHls;
videojs.Hls.supportsNativeHls = false;
this.oldBrowser = videojs.browser;
videojs.browser = videojs.mergeOptions({}, videojs.browser);
this.player = createPlayer();
this.player.src({
src: 'manifest/master.m3u8',
type: 'application/vnd.apple.mpegurl'
});
this.clock.tick(1);
this.standardXHRResponse = (request, data) => {
standardXHRResponse(request, data);
// Because SegmentLoader#fillBuffer_ is now scheduled asynchronously
// we have to use clock.tick to get the expected side effects of
// SegmentLoader#handleUpdateEnd_
this.clock.tick(1);
};
this.masterPlaylistController = this.player.tech_.hls.masterPlaylistController_;
// Make segment metadata noop since most test segments dont have real data
this.masterPlaylistController.mainSegmentLoader_.addSegmentMetadataCue_ = () => {};
},
afterEach() {
this.env.restore();
this.mse.restore();
videojs.Hls.supportsNativeHls = this.origSupportsNativeHls;
videojs.browser = this.oldBrowser;
this.player.dispose();
}
});
QUnit.test('throws error when given an empty URL', function(assert) {
let options = {
url: 'test',
tech: this.player.tech_
};
assert.ok(new MasterPlaylistController(options), 'can create with options');
options.url = '';
assert.throws(() => {
new MasterPlaylistController(options); // eslint-disable-line no-new
}, /A non-empty playlist URL is required/, 'requires a non empty url');
});
QUnit.test('obeys none preload option', function(assert) {
this.player.preload('none');
// master
this.standardXHRResponse(this.requests.shift());
// playlist
this.standardXHRResponse(this.requests.shift());
openMediaSource(this.player, this.clock);
assert.equal(this.requests.length, 0, 'no segment requests');
// verify stats
assert.equal(this.player.tech_.hls.stats.bandwidth, 4194304, 'default bandwidth');
});
QUnit.test('passes options to PlaylistLoader', function(assert) {
const options = {
url: 'test',
tech: this.player.tech_
};
let controller = new MasterPlaylistController(options);
assert.notOk(controller.masterPlaylistLoader_.withCredentials, 'credentials wont be sent by default');
assert.notOk(controller.masterPlaylistLoader_.handleManifestRedirects, 'redirects are ignored by default');
controller = new MasterPlaylistController(Object.assign({
withCredentials: true,
handleManifestRedirects: true
}, options));
assert.ok(controller.masterPlaylistLoader_.withCredentials, 'withCredentials enabled');
assert.ok(controller.masterPlaylistLoader_.handleManifestRedirects, 'handleManifestRedirects enabled');
});
QUnit.test('obeys auto preload option', function(assert) {
this.player.preload('auto');
// master
this.standardXHRResponse(this.requests.shift());
// playlist
this.standardXHRResponse(this.requests.shift());
openMediaSource(this.player, this.clock);
assert.equal(this.requests.length, 1, '1 segment request');
// verify stats
assert.equal(this.player.tech_.hls.stats.bandwidth, 4194304, 'default bandwidth');
});
QUnit.test('obeys metadata preload option', function(assert) {
this.player.preload('metadata');
// master
this.standardXHRResponse(this.requests.shift());
// playlist
this.standardXHRResponse(this.requests.shift());
openMediaSource(this.player, this.clock);
assert.equal(this.requests.length, 1, '1 segment request');
// verify stats
assert.equal(this.player.tech_.hls.stats.bandwidth, 4194304, 'default bandwidth');
});
QUnit.test('resets SegmentLoader when seeking in flash for both in and out of buffer',
function(assert) {
let resets = 0;
// master
this.standardXHRResponse(this.requests.shift());
// media
this.standardXHRResponse(this.requests.shift());
this.masterPlaylistController.mediaSource.trigger('sourceopen');
let mpc = this.masterPlaylistController;
let segmentLoader = mpc.mainSegmentLoader_;
segmentLoader.resetEverything = function() {
resets++;
};
let buffered;
mpc.tech_.buffered = function() {
return buffered;
};
buffered = videojs.createTimeRanges([[0, 20]]);
mpc.mode_ = 'html5';
mpc.setCurrentTime(10);
assert.equal(resets, 0,
'does not reset loader when seeking into a buffered region in html5');
mpc.setCurrentTime(21);
assert.equal(resets, 1,
'does reset loader when seeking outside of the buffered region in html5');
mpc.mode_ = 'flash';
mpc.setCurrentTime(10);
assert.equal(resets, 2,
'does reset loader when seeking into a buffered region in flash');
mpc.setCurrentTime(21);
assert.equal(resets, 3,
'does reset loader when seeking outside of the buffered region in flash');
});
QUnit.test('selects lowest bitrate rendition when enableLowInitialPlaylist is set',
function(assert) {
// Set requests.length to 0, otherwise it will use the requests generated in the
// beforeEach function
this.requests.length = 0;
this.player = createPlayer({ html5: { hls: { enableLowInitialPlaylist: true } } });
this.player.src({
src: 'manifest/master.m3u8',
type: 'application/vnd.apple.mpegurl'
});
this.clock.tick(1);
this.masterPlaylistController = this.player.tech_.hls.masterPlaylistController_;
let numCallsToSelectInitialPlaylistCalls = 0;
let numCallsToSelectPlaylist = 0;
this.masterPlaylistController.selectPlaylist = () => {
numCallsToSelectPlaylist++;
return this.masterPlaylistController.master().playlists[0];
};
this.masterPlaylistController.selectInitialPlaylist = () => {
numCallsToSelectInitialPlaylistCalls++;
return this.masterPlaylistController.master().playlists[0];
};
this.masterPlaylistController.mediaSource.trigger('sourceopen');
// master
this.standardXHRResponse(this.requests.shift());
// media
this.standardXHRResponse(this.requests.shift());
this.clock.tick(1);
assert.equal(numCallsToSelectInitialPlaylistCalls, 1, 'selectInitialPlaylist');
assert.equal(numCallsToSelectPlaylist, 0, 'selectPlaylist');
// Simulate a live reload
this.masterPlaylistController.masterPlaylistLoader_.trigger('loadedplaylist');
assert.equal(numCallsToSelectInitialPlaylistCalls, 1, 'selectInitialPlaylist');
assert.equal(numCallsToSelectPlaylist, 0, 'selectPlaylist');
});
QUnit.test('resyncs SegmentLoader for a fast quality change', function(assert) {
let resyncs = 0;
this.masterPlaylistController.mediaSource.trigger('sourceopen');
// master
this.standardXHRResponse(this.requests.shift());
// media
this.standardXHRResponse(this.requests.shift());
let segmentLoader = this.masterPlaylistController.mainSegmentLoader_;
segmentLoader.resyncLoader = function() {
resyncs++;
};
this.masterPlaylistController.selectPlaylist = () => {
return this.masterPlaylistController.master().playlists[0];
};
this.masterPlaylistController.fastQualityChange_();
assert.equal(resyncs, 1, 'resynced the segmentLoader');
// verify stats
assert.equal(this.player.tech_.hls.stats.bandwidth, 4194304, 'default bandwidth');
});
QUnit.test('does not resync the segmentLoader when no fast quality change occurs',
function(assert) {
let resyncs = 0;
// master
this.standardXHRResponse(this.requests.shift());
// media
this.standardXHRResponse(this.requests.shift());
this.masterPlaylistController.mediaSource.trigger('sourceopen');
let segmentLoader = this.masterPlaylistController.mainSegmentLoader_;
segmentLoader.resyncLoader = function() {
resyncs++;
};
this.masterPlaylistController.fastQualityChange_();
assert.equal(resyncs, 0, 'did not resync the segmentLoader');
// verify stats
assert.equal(this.player.tech_.hls.stats.bandwidth, 4194304, 'default bandwidth');
});
QUnit.test('fast quality change resyncs audio segment loader', function(assert) {
this.requests.length = 0;
this.player = createPlayer();
this.player.src({
src: 'alternate-audio-multiple-groups.m3u8',
type: 'application/vnd.apple.mpegurl'
});
this.clock.tick(1);
const masterPlaylistController = this.player.tech_.hls.masterPlaylistController_;
masterPlaylistController.selectPlaylist = () => {
return masterPlaylistController.master().playlists[0];
};
// master
this.standardXHRResponse(this.requests.shift());
// media
this.standardXHRResponse(this.requests.shift());
masterPlaylistController.mediaSource.trigger('sourceopen');
this.player.audioTracks()[0].enabled = true;
let resyncs = 0;
let resets = 0;
let realReset = masterPlaylistController.audioSegmentLoader_.resetLoader;
masterPlaylistController.audioSegmentLoader_.resetLoader = function() {
resets++;
realReset.call(this);
};
masterPlaylistController.audioSegmentLoader_.resyncLoader = () => resyncs++;
masterPlaylistController.fastQualityChange_();
assert.equal(resyncs, 0, 'does not resync the audio segment loader when media same');
// force different media
masterPlaylistController.selectPlaylist = () => {
return masterPlaylistController.master().playlists[1];
};
assert.equal(this.requests.length, 1, 'one request');
masterPlaylistController.fastQualityChange_();
assert.equal(this.requests.length, 2, 'added a request for new media');
assert.equal(resyncs, 0, 'does not resync the audio segment loader yet');
// new media request
this.standardXHRResponse(this.requests[1]);
assert.equal(resyncs, 1, 'resyncs the audio segment loader when media changes');
assert.equal(resets, 0, 'does not reset the audio segment loader when media changes');
});
QUnit.test('audio segment loader is reset on audio track change', function(assert) {
this.requests.length = 0;
this.player = createPlayer();
this.player.src({
src: 'alternate-audio-multiple-groups.m3u8',
type: 'application/vnd.apple.mpegurl'
});
this.clock.tick(1);
const masterPlaylistController = this.player.tech_.hls.masterPlaylistController_;
masterPlaylistController.selectPlaylist = () => {
return masterPlaylistController.master().playlists[0];
};
// master
this.standardXHRResponse(this.requests.shift());
// media
this.standardXHRResponse(this.requests.shift());
masterPlaylistController.mediaSource.trigger('sourceopen');
let resyncs = 0;
let resets = 0;
let realReset = masterPlaylistController.audioSegmentLoader_.resetLoader;
masterPlaylistController.audioSegmentLoader_.resetLoader = function() {
resets++;
realReset.call(this);
};
masterPlaylistController.audioSegmentLoader_.resyncLoader = () => resyncs++;
assert.equal(this.requests.length, 1, 'one request');
assert.equal(resyncs, 0, 'does not resync the audio segment loader yet');
this.player.audioTracks()[1].enabled = true;
assert.equal(this.requests.length, 2, 'two requests');
assert.equal(resyncs, 1, 'resyncs the audio segment loader when audio track changes');
assert.equal(resets, 1, 'resets the audio segment loader when audio track changes');
});
QUnit.test('if buffered, will request second segment byte range', function(assert) {
this.requests.length = 0;
this.player.src({
src: 'manifest/playlist.m3u8',
type: 'application/vnd.apple.mpegurl'
});
this.clock.tick(1);
this.masterPlaylistController = this.player.tech_.hls.masterPlaylistController_;
// Make segment metadata noop since most test segments dont have real data
this.masterPlaylistController.mainSegmentLoader_.addSegmentMetadataCue_ = () => {};
// mock that the user has played the video before
this.player.tech_.triggerReady();
this.clock.tick(1);
this.player.tech_.trigger('play');
this.player.tech_.paused_ = false;
this.player.tech_.played = () => videojs.createTimeRanges([[0, 20]]);
openMediaSource(this.player, this.clock);
// playlist
this.standardXHRResponse(this.requests[0]);
this.masterPlaylistController.mainSegmentLoader_.sourceUpdater_.buffered = () => {
return videojs.createTimeRanges([[0, 20]]);
};
// 1ms has passed to upload 1kb
// that gives us a bandwidth of 1024 / 1 * 8 * 1000 = 8192000
this.clock.tick(1);
// segment
this.standardXHRResponse(this.requests[1]);
this.masterPlaylistController.mainSegmentLoader_.fetchAtBuffer_ = true;
this.masterPlaylistController.mediaSource.sourceBuffers[0].trigger('updateend');
this.clock.tick(10 * 1000);
this.clock.tick(1);
assert.equal(this.requests[2].headers.Range, 'bytes=522828-1110327');
// verify stats
assert.equal(this.player.tech_.hls.stats.bandwidth, 8192000, 'Live stream');
assert.equal(this.player.tech_.hls.stats.mediaRequests, 1, '1 segment request');
assert.equal(this.player.tech_.hls.stats.mediaBytesTransferred,
1024,
'1024 bytes downloaded');
});
QUnit.test('re-initializes the combined playlist loader when switching sources',
function(assert) {
openMediaSource(this.player, this.clock);
// master
this.standardXHRResponse(this.requests.shift());
// playlist
this.standardXHRResponse(this.requests.shift());
// segment
this.standardXHRResponse(this.requests.shift());
// change the source
this.player.src({
src: 'manifest/master.m3u8',
type: 'application/vnd.apple.mpegurl'
});
this.clock.tick(1);
this.masterPlaylistController = this.player.tech_.hls.masterPlaylistController_;
// Make segment metadata noop since most test segments dont have real data
this.masterPlaylistController.mainSegmentLoader_.addSegmentMetadataCue_ = () => {};
// maybe not needed if https://github.com/videojs/video.js/issues/2326 gets fixed
this.clock.tick(1);
assert.ok(!this.masterPlaylistController.masterPlaylistLoader_.media(),
'no media playlist');
assert.equal(this.masterPlaylistController.masterPlaylistLoader_.state,
'HAVE_NOTHING',
'reset the playlist loader state');
assert.equal(this.requests.length, 1, 'requested the new src');
// buffer check
this.clock.tick(10 * 1000);
assert.equal(this.requests.length, 1, 'did not request a stale segment');
// sourceopen
openMediaSource(this.player, this.clock);
assert.equal(this.requests.length, 1, 'made one request');
assert.ok(
this.requests[0].url.indexOf('master.m3u8') >= 0,
'requested only the new playlist'
);
});
QUnit.test('updates the combined segment loader on live playlist refreshes',
function(assert) {
let updates = [];
openMediaSource(this.player, this.clock);
// master
this.standardXHRResponse(this.requests.shift());
// media
this.standardXHRResponse(this.requests.shift());
this.masterPlaylistController.mainSegmentLoader_.playlist = function(update) {
updates.push(update);
};
this.masterPlaylistController.masterPlaylistLoader_.trigger('loadedplaylist');
assert.equal(updates.length, 1, 'updated the segment list');
// verify stats
assert.equal(this.player.tech_.hls.stats.bandwidth, 4194304, 'default bandwidth');
});
QUnit.test(
'fires a progress event after downloading a segment from combined segment loader',
function(assert) {
let progressCount = 0;
openMediaSource(this.player, this.clock);
// master
this.standardXHRResponse(this.requests.shift());
// media
this.standardXHRResponse(this.requests.shift());
this.player.tech_.on('progress', function() {
progressCount++;
});
// 1ms has passed to upload 1kb
// that gives us a bandwidth of 1024 / 1 * 8 * 1000 = 8192000
this.clock.tick(1);
// segment
this.standardXHRResponse(this.requests.shift());
this.masterPlaylistController.mainSegmentLoader_.trigger('progress');
assert.equal(progressCount, 1, 'fired a progress event');
// verify stats
assert.equal(this.player.tech_.hls.stats.bandwidth, 8192000, 'Live stream');
assert.equal(this.player.tech_.hls.stats.mediaRequests, 1, '1 segment request');
assert.equal(this.player.tech_.hls.stats.mediaBytesTransferred,
1024,
'1024 bytes downloaded');
});
QUnit.test('updates the active loader when switching from unmuxed to muxed audio group',
function(assert) {
openMediaSource(this.player, this.clock);
// master
this.requests.shift().respond(200, null,
manifests.multipleAudioGroupsCombinedMain);
// media
this.standardXHRResponse(this.requests.shift());
// init segment
this.standardXHRResponse(this.requests.shift());
// video segment
this.standardXHRResponse(this.requests.shift());
// audio media
this.standardXHRResponse(this.requests.shift());
// ignore audio segment requests
this.requests.length = 0;
let mpc = this.masterPlaylistController;
let combinedPlaylist = mpc.master().playlists[0];
assert.ok(mpc.mediaTypes_.AUDIO.activePlaylistLoader,
'starts with an active playlist loader');
mpc.masterPlaylistLoader_.media(combinedPlaylist);
// updated media
this.requests.shift().respond(200, null,
'#EXTM3U\n' +
'#EXTINF:5.0\n' +
'0.ts\n' +
'#EXT-X-ENDLIST\n');
assert.notOk(mpc.mediaTypes_.AUDIO.activePlaylistLoader,
'enabled a track in the new audio group');
});
QUnit.test('waits for both main and audio loaders to finish before calling endOfStream',
function(assert) {
openMediaSource(this.player, this.clock);
const videoMedia = '#EXTM3U\n' +
'#EXT-X-VERSION:3\n' +
'#EXT-X-PLAYLIST-TYPE:VOD\n' +
'#EXT-X-MEDIA-SEQUENCE:0\n' +
'#EXT-X-TARGETDURATION:10\n' +
'#EXTINF:10,\n' +
'video-0.ts\n' +
'#EXT-X-ENDLIST\n';
const audioMedia = '#EXTM3U\n' +
'#EXT-X-VERSION:3\n' +
'#EXT-X-PLAYLIST-TYPE:VOD\n' +
'#EXT-X-MEDIA-SEQUENCE:0\n' +
'#EXT-X-TARGETDURATION:10\n' +
'#EXTINF:10,\n' +
'audio-0.ts\n' +
'#EXT-X-ENDLIST\n';
let videoEnded = 0;
let audioEnded = 0;
const MPC = this.masterPlaylistController;
MPC.mainSegmentLoader_.on('ended', () => videoEnded++);
MPC.audioSegmentLoader_.on('ended', () => audioEnded++);
// master
this.standardXHRResponse(this.requests.shift(), manifests.demuxed);
// video media
this.standardXHRResponse(this.requests.shift(), videoMedia);
// audio media
this.standardXHRResponse(this.requests.shift(), audioMedia);
// video segment
this.standardXHRResponse(this.requests.shift());
MPC.mediaSource.sourceBuffers[0].trigger('updateend');
assert.equal(videoEnded, 1, 'main segment loader triggered endded');
assert.equal(audioEnded, 0, 'audio segment loader did not trigger ended');
assert.equal(MPC.mediaSource.readyState, 'open', 'Media Source not yet ended');
// audio segment
this.standardXHRResponse(this.requests.shift());
MPC.mediaSource.sourceBuffers[1].trigger('updateend');
assert.equal(videoEnded, 1, 'main segment loader did not trigger ended again');
assert.equal(audioEnded, 1, 'audio segment loader triggered ended');
assert.equal(MPC.mediaSource.readyState, 'ended', 'Media Source ended');
});
QUnit.test('Segment loaders are unpaused when seeking after player has ended',
function(assert) {
openMediaSource(this.player, this.clock);
const videoMedia = '#EXTM3U\n' +
'#EXT-X-VERSION:3\n' +
'#EXT-X-PLAYLIST-TYPE:VOD\n' +
'#EXT-X-MEDIA-SEQUENCE:0\n' +
'#EXT-X-TARGETDURATION:10\n' +
'#EXTINF:10,\n' +
'video-0.ts\n' +
'#EXT-X-ENDLIST\n';
let ended = 0;
this.masterPlaylistController.mainSegmentLoader_.on('ended', () => ended++);
this.player.tech_.trigger('play');
// master
this.standardXHRResponse(this.requests.shift());
// media
this.standardXHRResponse(this.requests.shift(), videoMedia);
// segment
this.standardXHRResponse(this.requests.shift());
assert.notOk(this.masterPlaylistController.mainSegmentLoader_.paused(),
'segment loader not yet paused');
this.masterPlaylistController.mediaSource.sourceBuffers[0].trigger('updateend');
assert.ok(this.masterPlaylistController.mainSegmentLoader_.paused(),
'segment loader is paused after ending');
assert.equal(ended, 1, 'segment loader triggered ended event');
this.player.currentTime(5);
this.clock.tick(1);
assert.notOk(this.masterPlaylistController.mainSegmentLoader_.paused(),
'segment loader unpaused after a seek');
assert.equal(ended, 1, 'segment loader did not trigger ended event again yet');
});
QUnit.test('detects if the player is stuck at the playlist end', function(assert) {
let playlistCopy = Hls.Playlist.playlistEnd;
this.masterPlaylistController.mediaSource.trigger('sourceopen');
this.standardXHRResponse(this.requests.shift());
let playlist = this.player.tech_.hls.selectPlaylist();
// not stuck at playlist end when no seekable, even if empty buffer
// and positive currentTime
this.masterPlaylistController.seekable = () => videojs.createTimeRange();
this.player.tech_.buffered = () => videojs.createTimeRange();
this.player.tech_.setCurrentTime(170);
assert.ok(!this.masterPlaylistController.stuckAtPlaylistEnd_(playlist),
'not stuck at playlist end');
// not stuck at playlist end when no seekable, even if empty buffer
// and currentTime 0
this.player.tech_.setCurrentTime(0);
assert.ok(!this.masterPlaylistController.stuckAtPlaylistEnd_(playlist),
'not stuck at playlist end');
// not stuck at playlist end when no seekable but current time is at
// the end of the buffered range
this.player.tech_.buffered = () => videojs.createTimeRange(0, 170);
assert.ok(!this.masterPlaylistController.stuckAtPlaylistEnd_(playlist),
'not stuck at playlist end');
// not stuck at playlist end when currentTime not at seekable end
// even if the buffer is empty
this.masterPlaylistController.seekable = () => videojs.createTimeRange(0, 130);
this.masterPlaylistController.syncController_.getExpiredTime = () => 0;
this.player.tech_.setCurrentTime(50);
this.player.tech_.buffered = () => videojs.createTimeRange();
Hls.Playlist.playlistEnd = () => 130;
assert.ok(!this.masterPlaylistController.stuckAtPlaylistEnd_(playlist),
'not stuck at playlist end');
// not stuck at playlist end when buffer reached the absolute end of the playlist
// and current time is in the buffered range
this.player.tech_.setCurrentTime(159);
this.player.tech_.buffered = () => videojs.createTimeRange(0, 160);
Hls.Playlist.playlistEnd = () => 160;
assert.ok(!this.masterPlaylistController.stuckAtPlaylistEnd_(playlist),
'not stuck at playlist end');
// stuck at playlist end when there is no buffer and playhead
// reached absolute end of playlist
this.player.tech_.setCurrentTime(160);
assert.ok(this.masterPlaylistController.stuckAtPlaylistEnd_(playlist),
'stuck at playlist end');
// stuck at playlist end when current time reached the buffer end
// and buffer has reached absolute end of playlist
this.masterPlaylistController.seekable = () => videojs.createTimeRange(90, 130);
this.player.tech_.buffered = () => videojs.createTimeRange(0, 170);
this.player.tech_.setCurrentTime(170);
Hls.Playlist.playlistEnd = () => 170;
assert.ok(this.masterPlaylistController.stuckAtPlaylistEnd_(playlist),
'stuck at playlist end');
Hls.Playlist.playlistEnd = playlistCopy;
});
QUnit.test('blacklists switching from video+audio playlists to audio only',
function(assert) {
let audioPlaylist;
openMediaSource(this.player, this.clock);
this.player.tech_.hls.bandwidth = 1e10;
// master
this.requests.shift().respond(200, null,
'#EXTM3U\n' +
'#EXT-X-STREAM-INF:BANDWIDTH=1,CODECS="mp4a.40.2"\n' +
'media.m3u8\n' +
'#EXT-X-STREAM-INF:BANDWIDTH=10,RESOLUTION=1x1\n' +
'media1.m3u8\n');
// media1
this.standardXHRResponse(this.requests.shift());
assert.equal(this.masterPlaylistController.masterPlaylistLoader_.media(),
this.masterPlaylistController.masterPlaylistLoader_.master.playlists[1],
'selected video+audio');
audioPlaylist = this.masterPlaylistController.masterPlaylistLoader_.master.playlists[0];
assert.equal(audioPlaylist.excludeUntil, Infinity, 'excluded incompatible playlist');
// verify stats
assert.equal(this.player.tech_.hls.stats.bandwidth, 1e10, 'bandwidth we set above');
});
QUnit.test('blacklists switching from audio-only playlists to video+audio',
function(assert) {
let videoAudioPlaylist;
openMediaSource(this.player, this.clock);
this.player.tech_.hls.bandwidth = 1;
// master
this.requests.shift().respond(200, null,
'#EXTM3U\n' +
'#EXT-X-STREAM-INF:BANDWIDTH=1,CODECS="mp4a.40.2"\n' +
'media.m3u8\n' +
'#EXT-X-STREAM-INF:BANDWIDTH=10,RESOLUTION=1x1\n' +
'media1.m3u8\n');
// media1
this.standardXHRResponse(this.requests.shift());
assert.equal(this.masterPlaylistController.masterPlaylistLoader_.media(),
this.masterPlaylistController.masterPlaylistLoader_.master.playlists[0],
'selected audio only');
videoAudioPlaylist =
this.masterPlaylistController.masterPlaylistLoader_.master.playlists[1];
assert.equal(videoAudioPlaylist.excludeUntil,
Infinity,
'excluded incompatible playlist');
// verify stats
assert.equal(this.player.tech_.hls.stats.bandwidth, 1, 'bandwidth we set above');
});
QUnit.test('blacklists switching from video-only playlists to video+audio',
function(assert) {
let videoAudioPlaylist;
openMediaSource(this.player, this.clock);
this.player.tech_.hls.bandwidth = 1;
// master
this.requests.shift()
.respond(200, null,
'#EXTM3U\n' +
'#EXT-X-STREAM-INF:BANDWIDTH=1,CODECS="avc1.4d400d"\n' +
'media.m3u8\n' +
'#EXT-X-STREAM-INF:BANDWIDTH=10,CODECS="avc1.4d400d,mp4a.40.2"\n' +
'media1.m3u8\n');
// media
this.standardXHRResponse(this.requests.shift());
assert.equal(this.masterPlaylistController.masterPlaylistLoader_.media(),
this.masterPlaylistController.masterPlaylistLoader_.master.playlists[0],
'selected video only');
videoAudioPlaylist =
this.masterPlaylistController.masterPlaylistLoader_.master.playlists[1];
assert.equal(videoAudioPlaylist.excludeUntil,
Infinity,
'excluded incompatible playlist');
// verify stats
assert.equal(this.player.tech_.hls.stats.bandwidth, 1, 'bandwidth we set above');
});
QUnit.test('blacklists switching between playlists with incompatible audio codecs',
function(assert) {
let alternatePlaylist;
openMediaSource(this.player, this.clock);
this.player.tech_.hls.bandwidth = 1;
// master
this.requests.shift()
.respond(200, null,
'#EXTM3U\n' +
'#EXT-X-STREAM-INF:BANDWIDTH=1,CODECS="avc1.4d400d,mp4a.40.5"\n' +
'media.m3u8\n' +
'#EXT-X-STREAM-INF:BANDWIDTH=10,CODECS="avc1.4d400d,mp4a.40.2"\n' +
'media1.m3u8\n');
// media
this.standardXHRResponse(this.requests.shift());
assert.equal(this.masterPlaylistController.masterPlaylistLoader_.media(),
this.masterPlaylistController.masterPlaylistLoader_.master.playlists[0],
'selected HE-AAC stream');
alternatePlaylist =
this.masterPlaylistController.masterPlaylistLoader_.master.playlists[1];
assert.equal(alternatePlaylist.excludeUntil,
undefined,
'not excluded incompatible playlist');
// verify stats
assert.equal(this.player.tech_.hls.stats.bandwidth, 1, 'bandwidth we set above');
});
QUnit.test('updates the combined segment loader on media changes', function(assert) {
let updates = [];
this.masterPlaylistController.mediaSource.trigger('sourceopen');
this.masterPlaylistController.mainSegmentLoader_.bandwidth = 1;
// master
this.standardXHRResponse(this.requests.shift());
// media
this.standardXHRResponse(this.requests.shift());
this.masterPlaylistController.mainSegmentLoader_.playlist = function(update) {
updates.push(update);
};
// 1ms has passed to upload 1kb
// that gives us a bandwidth of 1024 / 1 * 8 * 1000 = 8192000
this.clock.tick(1);
this.masterPlaylistController.mainSegmentLoader_.mediaIndex = 0;
// downloading the new segment will update bandwidth and cause a
// playlist change
// segment 0
this.standardXHRResponse(this.requests.shift());
// update the buffer to reflect the appended segment, and have enough buffer to
// change playlist
this.masterPlaylistController.tech_.buffered = () => {
return videojs.createTimeRanges([[0, 30]]);
};
this.masterPlaylistController.mediaSource.sourceBuffers[0].trigger('updateend');
// media
this.standardXHRResponse(this.requests.shift());
assert.ok(updates.length > 0, 'updated the segment list');
// verify stats
assert.equal(this.player.tech_.hls.stats.bandwidth, 8192000, 'Live stream');
assert.equal(this.player.tech_.hls.stats.mediaRequests, 1, '1 segment request');
assert.equal(this.player.tech_.hls.stats.mediaBytesTransferred,
1024,
'1024 bytes downloaded');
});
QUnit.test('selects a playlist after main/combined segment downloads', function(assert) {
let calls = 0;
this.masterPlaylistController.selectPlaylist = () => {
calls++;
return this.masterPlaylistController.masterPlaylistLoader_.master.playlists[0];
};
this.masterPlaylistController.mediaSource.trigger('sourceopen');
// master
this.standardXHRResponse(this.requests.shift());
// media
this.standardXHRResponse(this.requests.shift());
// "downloaded" a segment
this.masterPlaylistController.mainSegmentLoader_.trigger('bandwidthupdate');
assert.strictEqual(calls, 2, 'selects after the initial segment');
// and another
this.masterPlaylistController.mainSegmentLoader_.trigger('bandwidthupdate');
assert.strictEqual(calls, 3, 'selects after additional segments');
// verify stats
assert.equal(this.player.tech_.hls.stats.bandwidth, 4194304, 'default bandwidth');
});
QUnit.test('re-triggers bandwidthupdate events on the tech', function(assert) {
this.masterPlaylistController.mediaSource.trigger('sourceopen');
// master
this.standardXHRResponse(this.requests.shift());
// media
this.standardXHRResponse(this.requests.shift());
let bandwidthupdateEvents = 0;
this.player.tech_.on('bandwidthupdate', () => bandwidthupdateEvents++);
this.masterPlaylistController.mainSegmentLoader_.trigger('bandwidthupdate');
assert.equal(bandwidthupdateEvents, 1, 'triggered bandwidthupdate');
this.masterPlaylistController.mainSegmentLoader_.trigger('bandwidthupdate');
assert.equal(bandwidthupdateEvents, 2, 'triggered bandwidthupdate');
});
QUnit.test('switches to lower renditions immediately, higher dependent on buffer',
function(assert) {
this.masterPlaylistController.mediaSource.trigger('sourceopen');
// master
this.standardXHRResponse(this.requests.shift());
// media
this.standardXHRResponse(this.requests.shift());
let buffered = [];
let currentPlaylistBandwidth = 0;
let nextPlaylistBandwidth = 0;
let mediaChanges = [];
let currentTime = 0;
let endList = true;
let duration = 100;
this.masterPlaylistController.tech_.currentTime = () => currentTime;
this.masterPlaylistController.tech_.buffered = () => videojs.createTimeRanges(buffered);
this.masterPlaylistController.duration = () => duration;
this.masterPlaylistController.selectPlaylist = () => {
return {
attributes: {
BANDWIDTH: nextPlaylistBandwidth
},
endList
};
};
this.masterPlaylistController.masterPlaylistLoader_.media = (media) => {
if (!media) {
return {
attributes: {
BANDWIDTH: currentPlaylistBandwidth
},
endList
};
}
mediaChanges.push(media);
};
currentTime = 0;
currentPlaylistBandwidth = 1000;
nextPlaylistBandwidth = 1000;
buffered = [];
this.masterPlaylistController.mainSegmentLoader_.trigger('bandwidthupdate');
assert.equal(mediaChanges.length,
1,
'changes media when no buffer and equal bandwidth playlist');
buffered = [[0, 9]];
this.masterPlaylistController.mainSegmentLoader_.trigger('bandwidthupdate');
assert.equal(mediaChanges.length,
2,
'changes media when sufficient forward buffer and equal ' +
'bandwidth playlist');
buffered = [[0, 30]];
this.masterPlaylistController.mainSegmentLoader_.trigger('bandwidthupdate');
assert.equal(mediaChanges.length,
3,
'changes media when sufficient forward buffer and equal ' +
'bandwidth playlist');
mediaChanges.length = 0;
currentTime = 10;
currentPlaylistBandwidth = 1000;
nextPlaylistBandwidth = 1001;
buffered = [];
this.masterPlaylistController.mainSegmentLoader_.trigger('bandwidthupdate');
assert.equal(mediaChanges.length,
0,
'did not change media when no buffer and and higher bandwidth playlist');
buffered = [[0, 19]];
this.masterPlaylistController.mainSegmentLoader_.trigger('bandwidthupdate');
assert.equal(mediaChanges.length,
0,
'did not change media when insufficient forward buffer and higher ' +
'bandwidth playlist');
buffered = [[0, 20]];
this.masterPlaylistController.mainSegmentLoader_.trigger('bandwidthupdate');
assert.equal(mediaChanges.length,
1,
'changes media when sufficient forward buffer and higher ' +
'bandwidth playlist');
buffered = [[0, 21]];
this.masterPlaylistController.mainSegmentLoader_.trigger('bandwidthupdate');
assert.equal(mediaChanges.length,
2,
'changes media when sufficient forward buffer and higher ' +
'bandwidth playlist');
mediaChanges.length = 0;
currentTime = 100;
currentPlaylistBandwidth = 1000;
nextPlaylistBandwidth = 1001;
buffered = [];
this.masterPlaylistController.mainSegmentLoader_.trigger('bandwidthupdate');
assert.equal(mediaChanges.length,
0,
'did not change media when no buffer and higher bandwidth playlist');
buffered = [[0, 100], [100, 109]];
this.masterPlaylistController.mainSegmentLoader_.trigger('bandwidthupdate');
assert.equal(mediaChanges.length,
0,
'did not change media when insufficient forward buffer and higher ' +
'bandwidth playlist');
buffered = [[0, 100], [100, 130]];
this.masterPlaylistController.mainSegmentLoader_.trigger('bandwidthupdate');
assert.equal(mediaChanges.length,
1,
'changes media when sufficient forward buffer and higher ' +
'bandwidth playlist');
mediaChanges.length = 0;
buffered = [];
currentPlaylistBandwidth = 1000;
nextPlaylistBandwidth = 999;
this.masterPlaylistController.mainSegmentLoader_.trigger('bandwidthupdate');
assert.equal(mediaChanges.length,
1,
'changes media when no buffer but lower bandwidth playlist');
buffered = [[100, 109]];
this.masterPlaylistController.mainSegmentLoader_.trigger('bandwidthupdate');
assert.equal(mediaChanges.length,
2,
'changes media when insufficient forward buffer but lower ' +
'bandwidth playlist');
buffered = [[100, 110]];
this.masterPlaylistController.mainSegmentLoader_.trigger('bandwidthupdate');
assert.equal(mediaChanges.length,
3,
'changes media when sufficient forward buffer and lower ' +
'bandwidth playlist');
mediaChanges.length = 0;
endList = false;
currentTime = 100;
currentPlaylistBandwidth = 1000;
nextPlaylistBandwidth = 1001;
buffered = [];
this.masterPlaylistController.mainSegmentLoader_.trigger('bandwidthupdate');
assert.equal(mediaChanges.length,
1,
'changes live media when no buffer and higher bandwidth playlist');
buffered = [[0, 100], [100, 109]];
this.masterPlaylistController.mainSegmentLoader_.trigger('bandwidthupdate');
assert.equal(mediaChanges.length,
2,
'changes live media when insufficient forward buffer and higher ' +
'bandwidth playlist');
buffered = [[0, 100], [100, 130]];
this.masterPlaylistController.mainSegmentLoader_.trigger('bandwidthupdate');
assert.equal(mediaChanges.length,
3,
'changes live media when sufficient forward buffer and higher ' +
'bandwidth playlist');
mediaChanges.length = 0;
endList = true;
currentTime = 9;
duration = 18;
buffered = [];
this.masterPlaylistController.mainSegmentLoader_.trigger('bandwidthupdate');
assert.equal(mediaChanges.length,
1,
'changes media when no buffer and duration less than low water line');
buffered = [[0, 10]];
this.masterPlaylistController.mainSegmentLoader_.trigger('bandwidthupdate');
assert.equal(mediaChanges.length,
2,
'changes media when insufficient forward buffer and duration ' +
'less than low water line');
});
QUnit.test('blacklists playlist on earlyabort', function(assert) {
this.masterPlaylistController.mediaSource.trigger('sourceopen');
// master
this.standardXHRResponse(this.requests.shift());
// media
this.standardXHRResponse(this.requests.shift());
let mediaChanges = [];
const playlistLoader = this.masterPlaylistController.masterPlaylistLoader_;
const currentMedia = playlistLoader.media();
const origMedia = playlistLoader.media.bind(playlistLoader);
const origWarn = videojs.log.warn;
let warnings = [];
this.masterPlaylistController.masterPlaylistLoader_.media = (media) => {
if (media) {
mediaChanges.push(media);
}
return origMedia(media);
};
videojs.log.warn = (text) => warnings.push(text);
assert.notOk(currentMedia.excludeUntil > 0, 'playlist not blacklisted');
assert.equal(mediaChanges.length, 0, 'no media change');
this.masterPlaylistController.mainSegmentLoader_.trigger('earlyabort');
assert.ok(currentMedia.excludeUntil > 0, 'playlist blacklisted');
assert.equal(mediaChanges.length, 1, 'one media change');
assert.equal(warnings.length, 1, 'one warning logged');
assert.equal(warnings[0],
'Problem encountered with the current HLS playlist. ' +
'Aborted early because there isn\'t enough bandwidth to complete the ' +
'request without rebuffering. Switching to another playlist.',
'warning message is correct');
videojs.log.warn = origWarn;
});
QUnit.test('does not get stuck in a loop due to inconsistent network/caching',
function(assert) {
/*
* This test is a long one, but it is meant to follow a true path to a possible loop.
* The reason for the loop is due to inconsistent network bandwidth, often caused or
* amplified by caching at the browser or edge server level.
* The steps are as follows:
*
* 1) Request segment 0 from low bandwidth playlist
* 2) Request segment 1 from low bandwidth playlist
* 3) Switch up due to good bandwidth (2 segments are required before upswitching)
* 4) Request segment 0 from high bandwidth playlist
* 5) Abort request early due to low bandwidth
* 6) Request segment 0 from low bandwidth playlist
* 7) Request segment 1 from low bandwidth playlist
* 8) Request segment 2 from low bandwidth playlist, despite enough bandwidth to
* upswitch. This part is the key, as the behavior we want to avoid is an upswitch
* back to the high bandwidth playlist (thus starting a potentially infinite loop).
*/
const mediaContents =
'#EXTM3U\n' +
'#EXTINF:10\n' +
'0.ts\n' +
'#EXTINF:10\n' +
'1.ts\n' +
'#EXTINF:10\n' +
'2.ts\n' +
'#EXTINF:10\n' +
'3.ts\n' +
'#EXT-X-ENDLIST\n';
const segmentLoader = this.masterPlaylistController.mainSegmentLoader_;
// start on lowest bandwidth rendition (will be media.m3u8)
segmentLoader.bandwidth = 0;
this.player.tech_.paused = () => false;
this.masterPlaylistController.mediaSource.trigger('sourceopen');
// master
this.requests.shift().respond(200, null,
'#EXTM3U\n' +
'#EXT-X-STREAM-INF:BANDWIDTH=10\n' +
'media.m3u8\n' +
'#EXT-X-STREAM-INF:BANDWIDTH=100\n' +
'media1.m3u8\n');
// media.m3u8
this.requests.shift().respond(200, null, mediaContents);
let playlistLoader = this.masterPlaylistController.masterPlaylistLoader_;
let origMedia = playlistLoader.media.bind(playlistLoader);
let mediaChanges = [];
this.masterPlaylistController.masterPlaylistLoader_.media = (media) => {
if (media) {
mediaChanges.push(media);
}
return origMedia(media);
};
this.clock.tick(1);
let segmentRequest = this.requests[0];
assert.equal(segmentRequest.uri.substring(segmentRequest.uri.length - 4),
'0.ts',
'requested first segment');
// 100ms for the segment response
this.clock.tick(100);
// 10 bytes in 100ms = 800 bits/s
this.requests[0].response = new Uint8Array(10).buffer;
this.requests.shift().respond(200, null, '');
segmentLoader.mediaSource_.sourceBuffers[0].trigger('updateend');
this.clock.tick(1);
segmentRequest = this.requests[0];
// should be walking forwards (need two segments before we can switch)
assert.equal(segmentLoader.bandwidth, 800, 'bandwidth is correct');
assert.equal(segmentRequest.uri.substring(segmentRequest.uri.length - 4),
'1.ts',
'requested second segment');
assert.equal(mediaChanges.length, 0, 'no media changes');
// 100ms for the segment response
this.clock.tick(100);
// 11 bytes in 100ms = 880 bits/s
this.requests[0].response = new Uint8Array(11).buffer;
this.requests.shift().respond(200, null, '');
segmentLoader.mediaSource_.sourceBuffers[0].trigger('updateend');
this.clock.tick(1);
let mediaRequest = this.requests[0];
// after two segments, bandwidth is high enough to switch up to media1.m3u8
assert.equal(segmentLoader.bandwidth, 880, 'bandwidth is correct');
assert.equal(mediaChanges.length, 1, 'changed media');
assert.equal(mediaChanges[0].uri, 'media1.m3u8', 'changed to media1');
assert.equal(mediaRequest.uri.substring(mediaRequest.uri.length - 'media1.m3u8'.length),
'media1.m3u8',
'requested media1');
// media1.m3u8
this.requests.shift().respond(200, null, mediaContents);
this.clock.tick(1);
segmentRequest = this.requests[0];
assert.equal(segmentLoader.playlist_.uri,
'media1.m3u8',
'segment loader playlist is media1');
const media1ResolvedPlaylist = segmentLoader.playlist_;
assert.notOk(media1ResolvedPlaylist.excludeUntil, 'media1 not blacklisted');
assert.equal(segmentRequest.uri.substring(segmentRequest.uri.length - 4),
'0.ts',
'requested first segment');
// needs a timeout for early abort to occur (we skip the function otherwise, since no
// timeout means we are on the last rendition)
segmentLoader.xhrOptions_.timeout = 60000;
// we need to wait 1 second from first byte receieved in order to consider aborting
this.requests[0].downloadProgress({
target: this.requests[0],
total: 100,
loaded: 1
});
this.clock.tick(1000);
// should abort request early because we don't have enough bandwidth
this.requests[0].downloadProgress({
target: this.requests[0],
total: 100,
// 1 bit per second
loaded: 2
});
this.clock.tick(1);
// aborted request, so switched back to lowest rendition
assert.equal(segmentLoader.bandwidth,
10 * Config.BANDWIDTH_VARIANCE + 1,
'bandwidth is correct for abort');
assert.equal(mediaChanges.length, 2, 'changed media');
assert.equal(mediaChanges[1].uri, 'media.m3u8', 'changed to media');
assert.ok(media1ResolvedPlaylist.excludeUntil, 'blacklisted media1');
assert.equal(segmentRequest.uri.substring(segmentRequest.uri.length - 4),
'0.ts',
'requested first segment');
// remove aborted request
this.requests.shift();
// 1ms for the cached segment response
this.clock.tick(1);
// 10 bytes in 1ms = 80 kbps
this.requests[0].response = new Uint8Array(10).buffer;
this.requests.shift().respond(200, null, '');
segmentLoader.mediaSource_.sourceBuffers[0].trigger('updateend');
this.clock.tick(1);
segmentRequest = this.requests[0];
// walking forwards, still need two segments before trying to change rendition
assert.equal(segmentLoader.bandwidth, 80000, 'bandwidth is correct');
assert.equal(mediaChanges.length, 2, 'did not change media');
assert.equal(segmentRequest.uri.substring(segmentRequest.uri.length - 4),
'1.ts',
'requested second segment');
// 1ms for the cached segment response
this.clock.tick(1);
// 11 bytes in 1ms = 88 kbps
this.requests[0].response = new Uint8Array(11).buffer;
this.requests.shift().respond(200, null, '');
segmentLoader.mediaSource_.sourceBuffers[0].trigger('updateend');
this.clock.tick(1);
// Media may be changed, but it should be changed to the same media. In the future, this
// can safely not be changed.
assert.equal(segmentLoader.bandwidth, 88000, 'bandwidth is correct');
assert.equal(mediaChanges.length, 3, 'changed media');
assert.equal(mediaChanges[2].uri, 'media.m3u8', 'media remains unchanged');
segmentRequest = this.requests[0];
assert.equal(segmentRequest.uri.substring(segmentRequest.uri.length - 4),
'2.ts',
'requested third segment');
assert.equal(this.env.log.warn.callCount, 1, 'logged a warning');
this.env.log.warn.callCount = 0;
});
QUnit.test('updates the duration after switching playlists', function(assert) {
let selectedPlaylist = false;
this.masterPlaylistController.mediaSource.trigger('sourceopen');
this.masterPlaylistController.bandwidth = 1e20;
// master
this.standardXHRResponse(this.requests[0]);
// media
this.standardXHRResponse(this.requests[1]);
this.masterPlaylistController.selectPlaylist = () => {
selectedPlaylist = true;
// this duration should be overwritten by the playlist change
this.masterPlaylistController.mediaSource.duration = 0;
this.masterPlaylistController.mediaSource.readyState = 'open';
return this.masterPlaylistController.masterPlaylistLoader_.master.playlists[1];
};
// 1ms has passed to upload 1kb
// that gives us a bandwidth of 1024 / 1 * 8 * 1000 = 8192000
this.clock.tick(1);
this.masterPlaylistController.mainSegmentLoader_.mediaIndex = 0;
// segment 0
this.standardXHRResponse(this.requests[2]);
this.masterPlaylistController.mediaSource.sourceBuffers[0].trigger('updateend');
// media1
this.standardXHRResponse(this.requests[3]);
assert.ok(selectedPlaylist, 'selected playlist');
assert.ok(this.masterPlaylistController.mediaSource.duration !== 0,
'updates the duration');
// verify stats
assert.equal(this.player.tech_.hls.stats.bandwidth, 8192000, 'Live stream');
assert.equal(this.player.tech_.hls.stats.mediaRequests, 1, '1 segment request');
assert.equal(this.player.tech_.hls.stats.mediaBytesTransferred,
1024,
'1024 bytes downloaded');
});
QUnit.test('playlist selection uses systemBandwidth', function(assert) {
this.masterPlaylistController.mediaSource.trigger('sourceopen');
this.player.width(1000);
this.player.height(900);
// master
this.standardXHRResponse(this.requests[0]);
// media
this.standardXHRResponse(this.requests[1]);
assert.ok(/media3\.m3u8/i.test(this.requests[1].url), 'Selected the highest rendition');
// 1ms has passed to upload 1kb
// that gives us a bandwidth of 1024 / 1 * 8 * 1000 = 8192000
this.clock.tick(1);
this.masterPlaylistController.mainSegmentLoader_.mediaIndex = 0;
// segment 0
this.standardXHRResponse(this.requests[2]);
// 20ms have passed to upload 1kb
// that gives us a throughput of 1024 / 20 * 8 * 1000 = 409600
this.clock.tick(20);
this.masterPlaylistController.mediaSource.sourceBuffers[0].trigger('updateend');
// systemBandwidth is 1 / (1 / 8192000 + 1 / 409600) = ~390095
// media1
this.standardXHRResponse(this.requests[3]);
assert.ok(/media\.m3u8/i.test(this.requests[3].url), 'Selected the rendition < 390095');
assert.ok(this.masterPlaylistController.mediaSource.duration !== 0,
'updates the duration');
// verify stats
assert.equal(this.player.tech_.hls.stats.bandwidth, 8192000, 'Live stream');
assert.equal(this.player.tech_.hls.stats.mediaRequests, 1, '1 segment request');
assert.equal(this.player.tech_.hls.stats.mediaBytesTransferred,
1024,
'1024 bytes downloaded');
});
QUnit.test('removes request timeout when segment timesout on lowest rendition',
function(assert) {
this.masterPlaylistController.mediaSource.trigger('sourceopen');
// master
this.standardXHRResponse(this.requests[0]);
// media
this.standardXHRResponse(this.requests[1]);
assert.equal(this.masterPlaylistController.requestOptions_.timeout,
this.masterPlaylistController.masterPlaylistLoader_.targetDuration * 1.5 *
1000,
'default request timeout');
assert.ok(!Playlist.isLowestEnabledRendition(
this.masterPlaylistController.masterPlaylistLoader_.master,
this.masterPlaylistController.masterPlaylistLoader_.media()),
'not on lowest rendition');
// Cause segment to timeout to force player into lowest rendition
this.requests[2].timedout = true;
// Downloading segment should cause media change and timeout removal
// segment 0
this.standardXHRResponse(this.requests[2]);
// Download new segment after media change
this.standardXHRResponse(this.requests[3]);
assert.ok(Playlist.isLowestEnabledRendition(
this.masterPlaylistController.masterPlaylistLoader_.master,
this.masterPlaylistController.masterPlaylistLoader_.media()),
'on lowest rendition');
assert.equal(this.masterPlaylistController.requestOptions_.timeout, 0,
'request timeout 0');
});
QUnit.test('removes request timeout when the source is a media playlist and not master',
function(assert) {
this.requests.length = 0;
this.player.src({
src: 'manifest/media.m3u8',
type: 'application/vnd.apple.mpegurl'
});
this.clock.tick(1);
this.masterPlaylistController = this.player.tech_.hls.masterPlaylistController_;
// media
this.standardXHRResponse(this.requests.shift());
assert.equal(this.masterPlaylistController.requestOptions_.timeout, 0,
'request timeout set to 0 when loading a non master playlist');
});
QUnit.test('seekable uses the intersection of alternate audio and combined tracks',
function(assert) {
let origSeekable = Playlist.seekable;
let mpc = this.masterPlaylistController;
let mainMedia = {};
let audioMedia = {};
let mainTimeRanges = [];
let audioTimeRanges = [];
let assertTimeRangesEqual = (left, right, message) => {
if (left.length === 0 && right.length === 0) {
return;
}
assert.equal(left.length, 1, message);
assert.equal(right.length, 1, message);
assert.equal(left.start(0), right.start(0), message);
assert.equal(left.end(0), right.end(0), message);
};
this.masterPlaylistController.masterPlaylistLoader_.media = () => mainMedia;
this.masterPlaylistController.syncController_.getExpiredTime = () => 0;
Playlist.seekable = (media) => {
if (media === mainMedia) {
return videojs.createTimeRanges(mainTimeRanges);
}
return videojs.createTimeRanges(audioTimeRanges);
};
assertTimeRangesEqual(mpc.seekable(),
videojs.createTimeRanges(),
'empty when main empty');
mainTimeRanges = [[0, 10]];
mpc.seekable_ = videojs.createTimeRanges();
mpc.onSyncInfoUpdate_();
assertTimeRangesEqual(mpc.seekable(),
videojs.createTimeRanges([[0, 10]]),
'main when no audio');
mpc.mediaTypes_.AUDIO.activePlaylistLoader = {
media: () => audioMedia,
dispose() {},
expired_: 0
};
mainTimeRanges = [];
mpc.seekable_ = videojs.createTimeRanges();
mpc.onSyncInfoUpdate_();
assertTimeRangesEqual(mpc.seekable(),
videojs.createTimeRanges(),
'empty when both empty');
mainTimeRanges = [[0, 10]];
mpc.seekable_ = videojs.createTimeRanges();
mpc.onSyncInfoUpdate_();
assertTimeRangesEqual(mpc.seekable(),
videojs.createTimeRanges(),
'empty when audio empty');
mainTimeRanges = [];
audioTimeRanges = [[0, 10]];
mpc.seekable_ = videojs.createTimeRanges();
mpc.onSyncInfoUpdate_();
assertTimeRangesEqual(mpc.seekable(),
videojs.createTimeRanges(),
'empty when main empty');
mainTimeRanges = [[0, 10]];
audioTimeRanges = [[0, 10]];
mpc.seekable_ = videojs.createTimeRanges();
mpc.onSyncInfoUpdate_();
assertTimeRangesEqual(mpc.seekable(),
videojs.createTimeRanges([[0, 10]]),
'ranges equal');
mainTimeRanges = [[5, 10]];
mpc.seekable_ = videojs.createTimeRanges();
mpc.onSyncInfoUpdate_();
assertTimeRangesEqual(mpc.seekable(),
videojs.createTimeRanges([[5, 10]]),
'main later start');
mainTimeRanges = [[0, 10]];
audioTimeRanges = [[5, 10]];
mpc.seekable_ = videojs.createTimeRanges();
mpc.onSyncInfoUpdate_();
assertTimeRangesEqual(mpc.seekable(),
videojs.createTimeRanges([[5, 10]]),
'audio later start');
mainTimeRanges = [[0, 9]];
audioTimeRanges = [[0, 10]];
mpc.seekable_ = videojs.createTimeRanges();
mpc.onSyncInfoUpdate_();
assertTimeRangesEqual(mpc.seekable(),
videojs.createTimeRanges([[0, 9]]),
'main earlier end');
mainTimeRanges = [[0, 10]];
audioTimeRanges = [[0, 9]];
mpc.seekable_ = videojs.createTimeRanges();
mpc.onSyncInfoUpdate_();
assertTimeRangesEqual(mpc.seekable(),
videojs.createTimeRanges([[0, 9]]),
'audio earlier end');
mainTimeRanges = [[1, 10]];
audioTimeRanges = [[0, 9]];
mpc.seekable_ = videojs.createTimeRanges();
mpc.onSyncInfoUpdate_();
assertTimeRangesEqual(mpc.seekable(),
videojs.createTimeRanges([[1, 9]]),
'main later start, audio earlier end');
mainTimeRanges = [[0, 9]];
audioTimeRanges = [[1, 10]];
mpc.seekable_ = videojs.createTimeRanges();
mpc.onSyncInfoUpdate_();
assertTimeRangesEqual(mpc.seekable(),
videojs.createTimeRanges([[1, 9]]),
'audio later start, main earlier end');
mainTimeRanges = [[2, 9]];
mpc.seekable_ = videojs.createTimeRanges();
mpc.onSyncInfoUpdate_();
assertTimeRangesEqual(mpc.seekable(),
videojs.createTimeRanges([[2, 9]]),
'main later start, main earlier end');
mainTimeRanges = [[1, 10]];
audioTimeRanges = [[2, 9]];
mpc.seekable_ = videojs.createTimeRanges();
mpc.onSyncInfoUpdate_();
assertTimeRangesEqual(mpc.seekable(),
videojs.createTimeRanges([[2, 9]]),
'audio later start, audio earlier end');
mainTimeRanges = [[1, 10]];
audioTimeRanges = [[11, 20]];
mpc.seekable_ = videojs.createTimeRanges();
mpc.onSyncInfoUpdate_();
assertTimeRangesEqual(mpc.seekable(),
videojs.createTimeRanges([[1, 10]]),
'no intersection, audio later');
mainTimeRanges = [[11, 20]];
audioTimeRanges = [[1, 10]];
mpc.seekable_ = videojs.createTimeRanges();
mpc.onSyncInfoUpdate_();
assertTimeRangesEqual(mpc.seekable(),
videojs.createTimeRanges([[11, 20]]),
'no intersection, main later');
Playlist.seekable = origSeekable;
});
QUnit.test('syncInfoUpdate triggers seekablechanged when seekable is updated',
function(assert) {
let origSeekable = Playlist.seekable;
let mpc = this.masterPlaylistController;
let tech = this.player.tech_;
let mainTimeRanges = [];
let media = {};
let seekablechanged = 0;
tech.on('seekablechanged', () => seekablechanged++);
Playlist.seekable = () => {
return videojs.createTimeRanges(mainTimeRanges);
};
this.masterPlaylistController.masterPlaylistLoader_.media = () => media;
this.masterPlaylistController.syncController_.getExpiredTime = () => 0;
mainTimeRanges = [[0, 10]];
mpc.seekable_ = videojs.createTimeRanges();
mpc.onSyncInfoUpdate_();
assert.equal(seekablechanged, 1, 'seekablechanged triggered');
Playlist.seekable = origSeekable;
});
QUnit.test('calls to update cues on new media', function(assert) {
let origHlsOptions = videojs.options.hls;
videojs.options.hls = {
useCueTags: true
};
this.player = createPlayer();
this.player.src({
src: 'manifest/media.m3u8',
type: 'application/vnd.apple.mpegurl'
});
this.clock.tick(1);
this.masterPlaylistController = this.player.tech_.hls.masterPlaylistController_;
let callCount = 0;
this.masterPlaylistController.updateAdCues_ = (media) => callCount++;
// master
this.standardXHRResponse(this.requests.shift());
assert.equal(callCount, 0, 'no call to update cues on master');
// media
this.standardXHRResponse(this.requests.shift());
assert.equal(callCount, 1, 'calls to update cues on first media');
this.masterPlaylistController.masterPlaylistLoader_.trigger('loadedplaylist');
assert.equal(callCount, 2, 'calls to update cues on subsequent media');
videojs.options.hls = origHlsOptions;
});
QUnit.test('calls to update cues on media when no master', function(assert) {
this.requests.length = 0;
this.player.src({
src: 'manifest/media.m3u8',
type: 'application/vnd.apple.mpegurl'
});
this.clock.tick(1);
this.masterPlaylistController = this.player.tech_.hls.masterPlaylistController_;
this.masterPlaylistController.useCueTags_ = true;
let callCount = 0;
this.masterPlaylistController.updateAdCues_ = (media) => callCount++;
// media
this.standardXHRResponse(this.requests.shift());
assert.equal(callCount, 1, 'calls to update cues on first media');
this.masterPlaylistController.masterPlaylistLoader_.trigger('loadedplaylist');
assert.equal(callCount, 2, 'calls to update cues on subsequent media');
});
QUnit.test('respects useCueTags option', function(assert) {
let origHlsOptions = videojs.options.hls;
let hlsPlaylistCueTagsEvents = 0;
videojs.options.hls = {
useCueTags: true
};
this.player = createPlayer();
this.player.tech_.on('usage', (event) => {
if (event.name === 'hls-playlist-cue-tags') {
hlsPlaylistCueTagsEvents++;
}
});
this.player.src({
src: 'manifest/media.m3u8',
type: 'application/vnd.apple.mpegurl'
});
this.clock.tick(1);
this.masterPlaylistController = this.player.tech_.hls.masterPlaylistController_;
this.standardXHRResponse(this.requests.shift());
this.standardXHRResponse(this.requests.shift());
assert.equal(hlsPlaylistCueTagsEvents, 1, 'cue tags event has been triggered once');
assert.ok(this.masterPlaylistController.cueTagsTrack_,
'creates cueTagsTrack_ if useCueTags is truthy');
assert.equal(this.masterPlaylistController.cueTagsTrack_.label,
'ad-cues',
'cueTagsTrack_ has label of ad-cues');
assert.equal(this.player.textTracks()[0], this.masterPlaylistController.cueTagsTrack_,
'adds cueTagsTrack as a text track if useCueTags is truthy');
videojs.options.hls = origHlsOptions;
});
QUnit.test('correctly sets alternate audio track kinds', function(assert) {
this.requests.length = 0;
this.player = createPlayer();
this.player.src({
src: 'manifest/alternate-audio-accessibility.m3u8',
type: 'application/vnd.apple.mpegurl'
});
this.clock.tick(1);
// master
this.standardXHRResponse(this.requests.shift());
// media - required for loadedmetadata
this.standardXHRResponse(this.requests.shift());
const audioTracks = this.player.tech_.audioTracks();
assert.equal(audioTracks.length, 4, 'added 4 audio tracks');
assert.equal(audioTracks[0].id, 'English', 'contains english track');
assert.equal(audioTracks[0].kind, 'main', 'english track\'s kind is "main"');
assert.equal(audioTracks[1].id,
'English Descriptions',
'contains english descriptions track');
assert.equal(audioTracks[1].kind,
'main-desc',
'english descriptions track\'s kind is "main-desc"');
assert.equal(audioTracks[2].id, 'Français', 'contains french track');
assert.equal(audioTracks[2].kind,
'alternative',
'french track\'s kind is "alternative"');
assert.equal(audioTracks[3].id, 'Espanol', 'contains spanish track');
assert.equal(audioTracks[3].kind,
'alternative',
'spanish track\'s kind is "alternative"');
});
QUnit.test('trigger events when video and audio is demuxed by default', function(assert) {
let hlsDemuxedEvents = 0;
this.requests.length = 0;
this.player = createPlayer();
this.player.src({
src: 'manifest/multipleAudioGroups.m3u8',
type: 'application/vnd.apple.mpegurl'
});
this.player.tech_.on('usage', (event) => {
if (event.name === 'hls-demuxed') {
hlsDemuxedEvents++;
}
});
openMediaSource(this.player, this.clock);
// master
this.standardXHRResponse(this.requests.shift());
// media
this.standardXHRResponse(this.requests.shift());
assert.equal(hlsDemuxedEvents, 1, 'video and audio is demuxed by default');
});
QUnit.test('trigger events when an AES is detected', function(assert) {
let hlsAesEvents = 0;
let isAesCopy = Hls.Playlist.isAes;
Hls.Playlist.isAes = (media) => {
return true;
};
this.player.tech_.on('usage', (event) => {
if (event.name === 'hls-aes') {
hlsAesEvents++;
}
});
// master
this.standardXHRResponse(this.requests.shift());
// media
this.standardXHRResponse(this.requests.shift());
this.masterPlaylistController.mediaSource.trigger('sourceopen');
assert.equal(hlsAesEvents, 1, 'an AES HLS stream is detected');
Hls.Playlist.isAes = isAesCopy;
});
QUnit.test('trigger events when an fMP4 stream is detected', function(assert) {
let hlsFmp4Events = 0;
let isFmp4Copy = Hls.Playlist.isFmp4;
Hls.Playlist.isFmp4 = (media) => {
return true;
};
this.player.tech_.on('usage', (event) => {
if (event.name === 'hls-fmp4') {
hlsFmp4Events++;
}
});
// master
this.standardXHRResponse(this.requests.shift());
// media
this.standardXHRResponse(this.requests.shift());
this.masterPlaylistController.mediaSource.trigger('sourceopen');
assert.equal(hlsFmp4Events, 1, 'an fMP4 stream is detected');
Hls.Playlist.isFmp4 = isFmp4Copy;
});
QUnit.test('adds only CEA608 closed-caption tracks when a master playlist is loaded',
function(assert) {
this.requests.length = 0;
this.player = createPlayer();
this.player.src({
src: 'manifest/master-captions.m3u8',
type: 'application/vnd.apple.mpegurl'
});
// wait for async player.src to complete
this.clock.tick(1);
const masterPlaylistController = this.player.tech_.hls.masterPlaylistController_;
assert.equal(this.player.textTracks().length, 1, 'one text track to start');
assert.equal(this.player.textTracks()[0].label,
'segment-metadata',
'only segment-metadata text track');
// master, contains media groups for captions
this.standardXHRResponse(this.requests.shift());
// we wait for loadedmetadata before setting caption tracks, so we need to wait for a
// media playlist
assert.equal(this.player.textTracks().length, 1, 'only one text track after master');
// media
this.standardXHRResponse(this.requests.shift());
const master = masterPlaylistController.masterPlaylistLoader_.master;
const caps = master.mediaGroups['CLOSED-CAPTIONS'].CCs;
const capsArr = Object.keys(caps).map(key => Object.assign({name: key}, caps[key]));
const addedCaps = masterPlaylistController.mediaTypes_['CLOSED-CAPTIONS'].groups.CCs
.map(cap => Object.assign({name: cap.id}, cap));
assert.equal(capsArr.length, 4, '4 closed-caption tracks defined in playlist');
assert.equal(addedCaps.length, 2, '2 CEA608 tracks added internally');
assert.equal(addedCaps[0].instreamId, 'CC1', 'first 608 track is CC1');
assert.equal(addedCaps[1].instreamId, 'CC3', 'second 608 track is CC3');
const textTracks = this.player.textTracks();
assert.equal(textTracks.length, 3, '2 text tracks were added');
assert.equal(textTracks[1].mode, 'disabled', 'track starts disabled');
assert.equal(textTracks[2].mode, 'disabled', 'track starts disabled');
assert.equal(textTracks[1].id, addedCaps[0].instreamId,
'text track 1\'s id is CC\'s instreamId');
assert.equal(textTracks[2].id, addedCaps[1].instreamId,
'text track 2\'s id is CC\'s instreamId');
assert.equal(textTracks[1].label, addedCaps[0].name,
'text track 1\'s label is CC\'s name');
assert.equal(textTracks[2].label, addedCaps[1].name,
'text track 2\'s label is CC\'s name');
});
QUnit.test('adds subtitle tracks when a media playlist is loaded', function(assert) {
let hlsWebvttEvents = 0;
this.requests.length = 0;
this.player = createPlayer();
this.player.src({
src: 'manifest/master-subtitles.m3u8',
type: 'application/vnd.apple.mpegurl'
});
this.clock.tick(1);
this.player.tech_.on('usage', (event) => {
if (event.name === 'hls-webvtt') {
hlsWebvttEvents++;
}
});
const masterPlaylistController = this.player.tech_.hls.masterPlaylistController_;
assert.equal(hlsWebvttEvents, 0, 'there is no webvtt detected');
assert.equal(this.player.textTracks().length, 1, 'one text track to start');
assert.equal(this.player.textTracks()[0].label,
'segment-metadata',
'only segment-metadata text track');
// master, contains media groups for subtitles
this.standardXHRResponse(this.requests.shift());
// we wait for loadedmetadata before setting subtitle tracks, so we need to wait for a
// media playlist
assert.equal(this.player.textTracks().length, 1, 'only one text track after master');
// media
this.standardXHRResponse(this.requests.shift());
const master = masterPlaylistController.masterPlaylistLoader_.master;
const subs = master.mediaGroups.SUBTITLES.subs;
const subsArr = Object.keys(subs).map(key => subs[key]);
assert.equal(subsArr.length, 4, 'got 4 subtitles');
assert.equal(subsArr.filter(sub => sub.forced === false).length, 2, '2 forced');
assert.equal(subsArr.filter(sub => sub.forced === true).length, 2, '2 non-forced');
const textTracks = this.player.textTracks();
assert.equal(textTracks.length, 3, 'non-forced text tracks were added');
assert.equal(textTracks[1].mode, 'disabled', 'track starts disabled');
assert.equal(textTracks[2].mode, 'disabled', 'track starts disabled');
assert.equal(hlsWebvttEvents, 1, 'there is webvtt detected in the rendition');
// change source to make sure tracks are cleaned up
this.player.src({
src: 'http://example.com/media.mp4',
type: 'video/mp4'
});
this.clock.tick(1);
assert.equal(this.player.textTracks().length, 0, 'text tracks cleaned');
});
QUnit.test('switches off subtitles on subtitle errors', function(assert) {
this.requests.length = 0;
this.player = createPlayer();
this.player.src({
src: 'manifest/master-subtitles.m3u8',
type: 'application/vnd.apple.mpegurl'
});
this.clock.tick(1);
const masterPlaylistController = this.player.tech_.hls.masterPlaylistController_;
// sets up listener for text track changes
masterPlaylistController.trigger('sourceopen');
// master, contains media groups for subtitles
this.standardXHRResponse(this.requests.shift());
// media
this.standardXHRResponse(this.requests.shift());
const textTracks = this.player.textTracks();
assert.equal(this.requests.length, 0, 'no outstanding requests');
// enable first subtitle text track
assert.notEqual(textTracks[0].kind, 'subtitles', 'kind is not subtitles');
assert.equal(textTracks[1].kind, 'subtitles', 'kind is subtitles');
textTracks[1].mode = 'showing';
assert.equal(this.requests.length, 1, 'made a request');
assert.equal(textTracks[1].mode, 'showing', 'text track still showing');
// request failed
this.requests.shift().respond(404, null, '');
assert.equal(textTracks[1].mode, 'disabled', 'disabled text track');
assert.equal(this.env.log.warn.callCount, 1, 'logged a warning');
this.env.log.warn.callCount = 0;
assert.equal(this.requests.length, 0, 'no outstanding requests');
// re-enable first text track
textTracks[1].mode = 'showing';
assert.equal(this.requests.length, 1, 'made a request');
assert.equal(textTracks[1].mode, 'showing', 'text track still showing');
this.requests.shift().respond(200, null, `
#EXTM3U
#EXT-X-TARGETDURATION:10
#EXT-X-MEDIA-SEQUENCE:0
#EXTINF:10
0.webvtt
#EXT-X-ENDLIST
`);
const syncController = masterPlaylistController.subtitleSegmentLoader_.syncController_;
// required for the vtt request to be made
syncController.timestampOffsetForTimeline = () => 0;
this.clock.tick(1);
assert.equal(this.requests.length, 1, 'made a request');
assert.ok(this.requests[0].url.endsWith('0.webvtt'), 'made a webvtt request');
assert.equal(textTracks[1].mode, 'showing', 'text track still showing');
this.requests.shift().respond(404, null, '');
assert.equal(textTracks[1].mode, 'disabled', 'disabled text track');
assert.equal(this.env.log.warn.callCount, 1, 'logged a warning');
this.env.log.warn.callCount = 0;
});
QUnit.test('pauses subtitle segment loader on tech errors', function(assert) {
this.requests.length = 0;
this.player = createPlayer();
this.player.src({
src: 'manifest/master-subtitles.m3u8',
type: 'application/vnd.apple.mpegurl'
});
this.clock.tick(1);
const masterPlaylistController = this.player.tech_.hls.masterPlaylistController_;
// sets up listener for text track changes
masterPlaylistController.trigger('sourceopen');
// master, contains media groups for subtitles
this.standardXHRResponse(this.requests.shift());
// media
this.standardXHRResponse(this.requests.shift());
const textTracks = this.player.textTracks();
// enable first subtitle text track
assert.notEqual(textTracks[0].kind, 'subtitles', 'kind is not subtitles');
assert.equal(textTracks[1].kind, 'subtitles', 'kind is subtitles');
textTracks[1].mode = 'showing';
let pauseCount = 0;
masterPlaylistController.subtitleSegmentLoader_.pause = () => pauseCount++;
this.player.tech_.trigger('error');
assert.equal(pauseCount, 1, 'paused subtitle segment loader');
});
QUnit.test('disposes subtitle loaders on dispose', function(assert) {
this.requests.length = 0;
this.player = createPlayer();
this.player.src({
src: 'manifest/master-subtitles.m3u8',
type: 'application/vnd.apple.mpegurl'
});
this.clock.tick(1);
let masterPlaylistController = this.player.tech_.hls.masterPlaylistController_;
assert.notOk(masterPlaylistController.mediaTypes_.SUBTITLES.activePlaylistLoader,
'does not start with a subtitle playlist loader');
assert.ok(masterPlaylistController.subtitleSegmentLoader_,
'starts with a subtitle segment loader');
let segmentLoaderDisposeCount = 0;
masterPlaylistController.subtitleSegmentLoader_.dispose =
() => segmentLoaderDisposeCount++;
masterPlaylistController.dispose();
assert.equal(segmentLoaderDisposeCount, 1, 'disposed the subtitle segment loader');
this.requests.length = 0;
this.player = createPlayer();
this.player.src({
src: 'manifest/master-subtitles.m3u8',
type: 'application/vnd.apple.mpegurl'
});
this.clock.tick(1);
masterPlaylistController = this.player.tech_.hls.masterPlaylistController_;
// sets up listener for text track changes
masterPlaylistController.trigger('sourceopen');
// master, contains media groups for subtitles
this.standardXHRResponse(this.requests.shift());
// media
this.standardXHRResponse(this.requests.shift());
const textTracks = this.player.textTracks();
// enable first subtitle text track
assert.notEqual(textTracks[0].kind, 'subtitles', 'kind is not subtitles');
assert.equal(textTracks[1].kind, 'subtitles', 'kind is subtitles');
textTracks[1].mode = 'showing';
assert.ok(masterPlaylistController.mediaTypes_.SUBTITLES.activePlaylistLoader,
'has a subtitle playlist loader');
assert.ok(masterPlaylistController.subtitleSegmentLoader_,
'has a subtitle segment loader');
let playlistLoaderDisposeCount = 0;
segmentLoaderDisposeCount = 0;
masterPlaylistController.mediaTypes_.SUBTITLES.activePlaylistLoader.dispose =
() => playlistLoaderDisposeCount++;
masterPlaylistController.subtitleSegmentLoader_.dispose =
() => segmentLoaderDisposeCount++;
masterPlaylistController.dispose();
assert.equal(playlistLoaderDisposeCount, 1, 'disposed the subtitle playlist loader');
assert.equal(segmentLoaderDisposeCount, 1, 'disposed the subtitle segment loader');
});
QUnit.test('subtitle segment loader resets on seeks', function(assert) {
this.requests.length = 0;
this.player = createPlayer();
this.player.src({
src: 'manifest/master-subtitles.m3u8',
type: 'application/vnd.apple.mpegurl'
});
this.clock.tick(1);
const masterPlaylistController = this.player.tech_.hls.masterPlaylistController_;
// sets up listener for text track changes
masterPlaylistController.trigger('sourceopen');
// master, contains media groups for subtitles
this.standardXHRResponse(this.requests.shift());
// media
this.standardXHRResponse(this.requests.shift());
const textTracks = this.player.textTracks();
// enable first subtitle text track
assert.notEqual(textTracks[0].kind, 'subtitles', 'kind is not subtitles');
assert.equal(textTracks[1].kind, 'subtitles', 'kind is subtitles');
textTracks[1].mode = 'showing';
let resetCount = 0;
let abortCount = 0;
let loadCount = 0;
masterPlaylistController.subtitleSegmentLoader_.resetEverything = () => resetCount++;
masterPlaylistController.subtitleSegmentLoader_.abort = () => abortCount++;
masterPlaylistController.subtitleSegmentLoader_.load = () => loadCount++;
this.player.pause();
masterPlaylistController.setCurrentTime(5);
assert.equal(resetCount, 1, 'reset subtitle segment loader');
assert.equal(abortCount, 1, 'aborted subtitle segment loader');
assert.equal(loadCount, 1, 'called load on subtitle segment loader');
this.player.play();
resetCount = 0;
abortCount = 0;
loadCount = 0;
masterPlaylistController.setCurrentTime(10);
assert.equal(resetCount, 1, 'reset subtitle segment loader');
assert.equal(abortCount, 1, 'aborted subtitle segment loader');
assert.equal(loadCount, 1, 'called load on subtitle segment loader');
});
QUnit.test('calculates dynamic GOAL_BUFFER_LENGTH', function(assert) {
const configOld = {
GOAL_BUFFER_LENGTH: Config.GOAL_BUFFER_LENGTH,
MAX_GOAL_BUFFER_LENGTH: Config.MAX_GOAL_BUFFER_LENGTH,
GOAL_BUFFER_LENGTH_RATE: Config.GOAL_BUFFER_LENGTH_RATE
};
const mpc = this.masterPlaylistController;
let currentTime = 0;
Config.GOAL_BUFFER_LENGTH = 30;
Config.MAX_GOAL_BUFFER_LENGTH = 60;
Config.GOAL_BUFFER_LENGTH_RATE = 0.5;
mpc.tech_.currentTime = () => currentTime;
assert.equal(mpc.goalBufferLength(), 30, 'dynamic GBL uses starting value at time 0');
currentTime = 10;
assert.equal(mpc.goalBufferLength(), 35, 'dynamic GBL increases by currentTime * rate');
currentTime = 60;
assert.equal(mpc.goalBufferLength(), 60, 'dynamic GBL uses max value');
currentTime = 70;
assert.equal(mpc.goalBufferLength(), 60, 'dynamic GBL continues to use max value');
// restore config
Object.keys(configOld).forEach((key) => Config[key] = configOld[key]);
});
QUnit.test('calculates dynamic BUFFER_LOW_WATER_LINE', function(assert) {
const configOld = {
BUFFER_LOW_WATER_LINE: Config.BUFFER_LOW_WATER_LINE,
MAX_BUFFER_LOW_WATER_LINE: Config.MAX_BUFFER_LOW_WATER_LINE,
BUFFER_LOW_WATER_LINE_RATE: Config.BUFFER_LOW_WATER_LINE_RATE
};
const mpc = this.masterPlaylistController;
let currentTime = 0;
Config.BUFFER_LOW_WATER_LINE = 0;
Config.MAX_BUFFER_LOW_WATER_LINE = 30;
Config.BUFFER_LOW_WATER_LINE_RATE = 0.5;
mpc.tech_.currentTime = () => currentTime;
assert.equal(mpc.bufferLowWaterLine(), 0, 'dynamic BLWL uses starting value at time 0');
currentTime = 10;
assert.equal(mpc.bufferLowWaterLine(), 5,
'dynamic BLWL increases by currentTime * rate');
currentTime = 60;
assert.equal(mpc.bufferLowWaterLine(), 30, 'dynamic BLWL uses max value');
currentTime = 70;
assert.equal(mpc.bufferLowWaterLine(), 30, 'dynamic BLWL continues to use max value');
// restore config
Object.keys(configOld).forEach((key) => Config[key] = configOld[key]);
});
QUnit.test('Exception in play promise should be caught', function(assert) {
const mpc = this.masterPlaylistController;
mpc.setupSourceBuffers = () => true;
mpc.tech_ = {
autoplay: () => true,
play: () => new Promise(function(resolve, reject) {
reject(new DOMException());
})
};
mpc.handleSourceOpen_();
assert.ok(true, 'rejects dom exception');
});
QUnit.module('Codec to MIME Type Conversion');
const testMimeTypes = function(assert, isFMP4) {
let container = isFMP4 ? 'mp4' : 'mp2t';
let videoMime = `video/${container}`;
let audioMime = `audio/${container}`;
// no MAAT
assert.deepEqual(mimeTypesForPlaylist_.apply(null,
generateMedia(false, true, false, false, isFMP4)),
[`${videoMime}; codecs="avc1.4d400d, mp4a.40.2"`],
`no MAAT, container: ${container}, codecs: none`);
assert.deepEqual(mimeTypesForPlaylist_.apply(null,
generateMedia(false, true, true, false, isFMP4)),
[`${videoMime}; codecs="avc1.deadbeef"`],
`no MAAT, container: ${container}, codecs: video`);
assert.deepEqual(mimeTypesForPlaylist_.apply(null,
generateMedia(false, true, false, true, isFMP4)),
[`${audioMime}; codecs="mp4a.40.E"`],
`no MAAT, container: ${container}, codecs: audio`);
assert.deepEqual(mimeTypesForPlaylist_.apply(null,
generateMedia(false, true, true, true, isFMP4)),
[`${videoMime}; codecs="avc1.deadbeef, mp4a.40.E"`],
`no MAAT, container: ${container}, codecs: video, audio`);
// MAAT, not muxed
assert.deepEqual(mimeTypesForPlaylist_.apply(null,
generateMedia(true, false, false, false, isFMP4)),
[`${videoMime}; codecs="avc1.4d400d"`,
`${audioMime}; codecs="mp4a.40.2"`],
`MAAT, demuxed, container: ${container}, codecs: none`);
assert.deepEqual(mimeTypesForPlaylist_.apply(null,
generateMedia(true, false, true, false, isFMP4)),
[`${videoMime}; codecs="avc1.deadbeef"`,
`${audioMime}; codecs="mp4a.40.2"`],
`MAAT, demuxed, container: ${container}, codecs: video`);
assert.deepEqual(mimeTypesForPlaylist_.apply(null,
generateMedia(true, false, false, true, isFMP4)),
[`${videoMime}; codecs="mp4a.40.E"`,
`${audioMime}; codecs="mp4a.40.E"`],
`MAAT, demuxed, container: ${container}, codecs: audio`);
assert.deepEqual(mimeTypesForPlaylist_.apply(null,
generateMedia(true, false, true, true, isFMP4)),
[`${videoMime}; codecs="avc1.deadbeef"`,
`${audioMime}; codecs="mp4a.40.E"`],
`MAAT, demuxed, container: ${container}, codecs: video, audio`);
// MAAT, muxed
assert.deepEqual(mimeTypesForPlaylist_.apply(null,
generateMedia(true, true, false, false, isFMP4)),
[`${videoMime}; codecs="avc1.4d400d, mp4a.40.2"`,
`${audioMime}; codecs="mp4a.40.2"`],
`MAAT, muxed, container: ${container}, codecs: none`);
assert.deepEqual(mimeTypesForPlaylist_.apply(null,
generateMedia(true, true, true, false, isFMP4)),
[`${videoMime}; codecs="avc1.deadbeef, mp4a.40.2"`,
`${audioMime}; codecs="mp4a.40.2"`],
`MAAT, muxed, container: ${container}, codecs: video`);
assert.deepEqual(mimeTypesForPlaylist_.apply(null,
generateMedia(true, true, false, true, isFMP4)),
[`${videoMime}; codecs="mp4a.40.E"`,
`${audioMime}; codecs="mp4a.40.E"`],
`MAAT, muxed, container: ${container}, codecs: audio`);
assert.deepEqual(mimeTypesForPlaylist_.apply(null,
generateMedia(true, true, true, true, isFMP4)),
[`${videoMime}; codecs="avc1.deadbeef, mp4a.40.E"`,
`${audioMime}; codecs="mp4a.40.E"`],
`MAAT, muxed, container: ${container}, codecs: video, audio`);
};
QUnit.test('recognizes muxed codec configurations', function(assert) {
testMimeTypes(assert, false);
testMimeTypes(assert, true);
});
QUnit.module('Map Legacy AVC Codec');
QUnit.test('maps legacy AVC codecs', function(assert) {
assert.equal(mapLegacyAvcCodecs_('avc1.deadbeef'),
'avc1.deadbeef',
'does nothing for non legacy pattern');
assert.equal(mapLegacyAvcCodecs_('avc1.dead.beef, mp4a.something'),
'avc1.dead.beef, mp4a.something',
'does nothing for non legacy pattern');
assert.equal(mapLegacyAvcCodecs_('avc1.dead.beef,mp4a.something'),
'avc1.dead.beef,mp4a.something',
'does nothing for non legacy pattern');
assert.equal(mapLegacyAvcCodecs_('mp4a.something,avc1.dead.beef'),
'mp4a.something,avc1.dead.beef',
'does nothing for non legacy pattern');
assert.equal(mapLegacyAvcCodecs_('mp4a.something, avc1.dead.beef'),
'mp4a.something, avc1.dead.beef',
'does nothing for non legacy pattern');
assert.equal(mapLegacyAvcCodecs_('avc1.42001e'),
'avc1.42001e',
'does nothing for non legacy pattern');
assert.equal(mapLegacyAvcCodecs_('avc1.4d0020,mp4a.40.2'),
'avc1.4d0020,mp4a.40.2',
'does nothing for non legacy pattern');
assert.equal(mapLegacyAvcCodecs_('mp4a.40.2,avc1.4d0020'),
'mp4a.40.2,avc1.4d0020',
'does nothing for non legacy pattern');
assert.equal(mapLegacyAvcCodecs_('mp4a.40.40'),
'mp4a.40.40',
'does nothing for non video codecs');
assert.equal(mapLegacyAvcCodecs_('avc1.66.30'),
'avc1.42001e',
'translates legacy video codec alone');
assert.equal(mapLegacyAvcCodecs_('avc1.66.30, mp4a.40.2'),
'avc1.42001e, mp4a.40.2',
'translates legacy video codec when paired with audio');
assert.equal(mapLegacyAvcCodecs_('mp4a.40.2, avc1.66.30'),
'mp4a.40.2, avc1.42001e',
'translates video codec when specified second');
});