<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>JSDoc: Source: virtual-source-buffer.js</title>
<script src="scripts/prettify/prettify.js"> </script>
<script src="scripts/prettify/lang-css.js"> </script>
<!--[if lt IE 9]>
<script src="//html5shiv.googlecode.com/svn/trunk/html5.js"></script>
<![endif]-->
<link type="text/css" rel="stylesheet" href="styles/prettify-tomorrow.css">
<link type="text/css" rel="stylesheet" href="styles/jsdoc-default.css">
</head>
<body>
<div id="main">
<h1 class="page-title">Source: virtual-source-buffer.js</h1>
<section>
<article>
<pre class="prettyprint source linenums"><code>/**
* @file virtual-source-buffer.js
*/
import videojs from 'video.js';
import createTextTracksIfNecessary from './create-text-tracks-if-necessary';
import removeCuesFromTrack from './remove-cues-from-track';
import {addTextTrackData} from './add-text-track-data';
import work from 'webworkify';
import transmuxWorker from './transmuxer-worker';
import {isAudioCodec, isVideoCodec} from './codec-utils';
// We create a wrapper around the SourceBuffer so that we can manage the
// state of the `updating` property manually. We have to do this because
// Firefox changes `updating` to false long before triggering `updateend`
// events and that was causing strange problems in videojs-contrib-hls
const makeWrappedSourceBuffer = function(mediaSource, mimeType) {
const sourceBuffer = mediaSource.addSourceBuffer(mimeType);
const wrapper = Object.create(null);
wrapper.updating = false;
wrapper.realBuffer_ = sourceBuffer;
for (let key in sourceBuffer) {
if (typeof sourceBuffer[key] === 'function') {
wrapper[key] = (...params) => sourceBuffer[key](...params);
} else if (typeof wrapper[key] === 'undefined') {
Object.defineProperty(wrapper, key, {
get: () => sourceBuffer[key],
set: (v) => sourceBuffer[key] = v
});
}
}
return wrapper;
};
/**
* Returns a list of gops in the buffer that have a pts value of 3 seconds or more in
* front of current time.
*
* @param {Array} buffer
* The current buffer of gop information
* @param {Player} player
* The player instance
* @param {Double} mapping
* Offset to map display time to stream presentation time
* @return {Array}
* List of gops considered safe to append over
*/
export const gopsSafeToAlignWith = (buffer, player, mapping) => {
if (!player || !buffer.length) {
return [];
}
// pts value for current time + 3 seconds to give a bit more wiggle room
const currentTimePts = Math.ceil((player.currentTime() - mapping + 3) * 90000);
let i;
for (i = 0; i < buffer.length; i++) {
if (buffer[i].pts > currentTimePts) {
break;
}
}
return buffer.slice(i);
};
/**
* Appends gop information (timing and byteLength) received by the transmuxer for the
* gops appended in the last call to appendBuffer
*
* @param {Array} buffer
* The current buffer of gop information
* @param {Array} gops
* List of new gop information
* @param {boolean} replace
* If true, replace the buffer with the new gop information. If false, append the
* new gop information to the buffer in the right location of time.
* @return {Array}
* Updated list of gop information
*/
export const updateGopBuffer = (buffer, gops, replace) => {
if (!gops.length) {
return buffer;
}
if (replace) {
// If we are in safe append mode, then completely overwrite the gop buffer
// with the most recent appeneded data. This will make sure that when appending
// future segments, we only try to align with gops that are both ahead of current
// time and in the last segment appended.
return gops.slice();
}
const start = gops[0].pts;
let i = 0;
for (i; i < buffer.length; i++) {
if (buffer[i].pts >= start) {
break;
}
}
return buffer.slice(0, i).concat(gops);
};
/**
* Removes gop information in buffer that overlaps with provided start and end
*
* @param {Array} buffer
* The current buffer of gop information
* @param {Double} start
* position to start the remove at
* @param {Double} end
* position to end the remove at
* @param {Double} mapping
* Offset to map display time to stream presentation time
*/
export const removeGopBuffer = (buffer, start, end, mapping) => {
const startPts = Math.ceil((start - mapping) * 90000);
const endPts = Math.ceil((end - mapping) * 90000);
const updatedBuffer = buffer.slice();
let i = buffer.length;
while (i--) {
if (buffer[i].pts <= endPts) {
break;
}
}
if (i === -1) {
// no removal because end of remove range is before start of buffer
return updatedBuffer;
}
let j = i + 1;
while (j--) {
if (buffer[j].pts <= startPts) {
break;
}
}
// clamp remove range start to 0 index
j = Math.max(j, 0);
updatedBuffer.splice(j, i - j + 1);
return updatedBuffer;
};
/**
* VirtualSourceBuffers exist so that we can transmux non native formats
* into a native format, but keep the same api as a native source buffer.
* It creates a transmuxer, that works in its own thread (a web worker) and
* that transmuxer muxes the data into a native format. VirtualSourceBuffer will
* then send all of that data to the naive sourcebuffer so that it is
* indestinguishable from a natively supported format.
*
* @param {HtmlMediaSource} mediaSource the parent mediaSource
* @param {Array} codecs array of codecs that we will be dealing with
* @class VirtualSourceBuffer
* @extends video.js.EventTarget
*/
export default class VirtualSourceBuffer extends videojs.EventTarget {
constructor(mediaSource, codecs) {
super(videojs.EventTarget);
this.timestampOffset_ = 0;
this.pendingBuffers_ = [];
this.bufferUpdating_ = false;
this.mediaSource_ = mediaSource;
this.codecs_ = codecs;
this.audioCodec_ = null;
this.videoCodec_ = null;
this.audioDisabled_ = false;
this.appendAudioInitSegment_ = true;
this.gopBuffer_ = [];
this.timeMapping_ = 0;
this.safeAppend_ = videojs.browser.IE_VERSION >= 11;
let options = {
remux: false,
alignGopsAtEnd: this.safeAppend_
};
this.codecs_.forEach((codec) => {
if (isAudioCodec(codec)) {
this.audioCodec_ = codec;
} else if (isVideoCodec(codec)) {
this.videoCodec_ = codec;
}
});
// append muxed segments to their respective native buffers as
// soon as they are available
this.transmuxer_ = work(transmuxWorker);
this.transmuxer_.postMessage({action: 'init', options });
this.transmuxer_.onmessage = (event) => {
if (event.data.action === 'data') {
return this.data_(event);
}
if (event.data.action === 'done') {
return this.done_(event);
}
if (event.data.action === 'gopInfo') {
return this.appendGopInfo_(event);
}
};
// this timestampOffset is a property with the side-effect of resetting
// baseMediaDecodeTime in the transmuxer on the setter
Object.defineProperty(this, 'timestampOffset', {
get() {
return this.timestampOffset_;
},
set(val) {
if (typeof val === 'number' && val >= 0) {
this.timestampOffset_ = val;
this.appendAudioInitSegment_ = true;
// reset gop buffer on timestampoffset as this signals a change in timeline
this.gopBuffer_.length = 0;
this.timeMapping_ = 0;
// We have to tell the transmuxer to set the baseMediaDecodeTime to
// the desired timestampOffset for the next segment
this.transmuxer_.postMessage({
action: 'setTimestampOffset',
timestampOffset: val
});
}
}
});
// setting the append window affects both source buffers
Object.defineProperty(this, 'appendWindowStart', {
get() {
return (this.videoBuffer_ || this.audioBuffer_).appendWindowStart;
},
set(start) {
if (this.videoBuffer_) {
this.videoBuffer_.appendWindowStart = start;
}
if (this.audioBuffer_) {
this.audioBuffer_.appendWindowStart = start;
}
}
});
// this buffer is "updating" if either of its native buffers are
Object.defineProperty(this, 'updating', {
get() {
return !!(this.bufferUpdating_ ||
(!this.audioDisabled_ && this.audioBuffer_ && this.audioBuffer_.updating) ||
(this.videoBuffer_ && this.videoBuffer_.updating));
}
});
// the buffered property is the intersection of the buffered
// ranges of the native source buffers
Object.defineProperty(this, 'buffered', {
get() {
let start = null;
let end = null;
let arity = 0;
let extents = [];
let ranges = [];
// neither buffer has been created yet
if (!this.videoBuffer_ && !this.audioBuffer_) {
return videojs.createTimeRange();
}
// only one buffer is configured
if (!this.videoBuffer_) {
return this.audioBuffer_.buffered;
}
if (!this.audioBuffer_) {
return this.videoBuffer_.buffered;
}
// both buffers are configured
if (this.audioDisabled_) {
return this.videoBuffer_.buffered;
}
// both buffers are empty
if (this.videoBuffer_.buffered.length === 0 &&
this.audioBuffer_.buffered.length === 0) {
return videojs.createTimeRange();
}
// Handle the case where we have both buffers and create an
// intersection of the two
let videoBuffered = this.videoBuffer_.buffered;
let audioBuffered = this.audioBuffer_.buffered;
let count = videoBuffered.length;
// A) Gather up all start and end times
while (count--) {
extents.push({time: videoBuffered.start(count), type: 'start'});
extents.push({time: videoBuffered.end(count), type: 'end'});
}
count = audioBuffered.length;
while (count--) {
extents.push({time: audioBuffered.start(count), type: 'start'});
extents.push({time: audioBuffered.end(count), type: 'end'});
}
// B) Sort them by time
extents.sort(function(a, b) {
return a.time - b.time;
});
// C) Go along one by one incrementing arity for start and decrementing
// arity for ends
for (count = 0; count < extents.length; count++) {
if (extents[count].type === 'start') {
arity++;
// D) If arity is ever incremented to 2 we are entering an
// overlapping range
if (arity === 2) {
start = extents[count].time;
}
} else if (extents[count].type === 'end') {
arity--;
// E) If arity is ever decremented to 1 we leaving an
// overlapping range
if (arity === 1) {
end = extents[count].time;
}
}
// F) Record overlapping ranges
if (start !== null && end !== null) {
ranges.push([start, end]);
start = null;
end = null;
}
}
return videojs.createTimeRanges(ranges);
}
});
}
/**
* When we get a data event from the transmuxer
* we call this function and handle the data that
* was sent to us
*
* @private
* @param {Event} event the data event from the transmuxer
*/
data_(event) {
let segment = event.data.segment;
// Cast ArrayBuffer to TypedArray
segment.data = new Uint8Array(
segment.data,
event.data.byteOffset,
event.data.byteLength
);
segment.initSegment = new Uint8Array(
segment.initSegment.data,
segment.initSegment.byteOffset,
segment.initSegment.byteLength
);
createTextTracksIfNecessary(this, this.mediaSource_, segment);
// Add the segments to the pendingBuffers array
this.pendingBuffers_.push(segment);
return;
}
/**
* When we get a done event from the transmuxer
* we call this function and we process all
* of the pending data that we have been saving in the
* data_ function
*
* @private
* @param {Event} event the done event from the transmuxer
*/
done_(event) {
// Don't process and append data if the mediaSource is closed
if (this.mediaSource_.readyState === 'closed') {
this.pendingBuffers_.length = 0;
return;
}
// All buffers should have been flushed from the muxer
// start processing anything we have received
this.processPendingSegments_();
return;
}
/**
* Create our internal native audio/video source buffers and add
* event handlers to them with the following conditions:
* 1. they do not already exist on the mediaSource
* 2. this VSB has a codec for them
*
* @private
*/
createRealSourceBuffers_() {
let types = ['audio', 'video'];
types.forEach((type) => {
// Don't create a SourceBuffer of this type if we don't have a
// codec for it
if (!this[`${type}Codec_`]) {
return;
}
// Do nothing if a SourceBuffer of this type already exists
if (this[`${type}Buffer_`]) {
return;
}
let buffer = null;
// If the mediasource already has a SourceBuffer for the codec
// use that
if (this.mediaSource_[`${type}Buffer_`]) {
buffer = this.mediaSource_[`${type}Buffer_`];
// In multiple audio track cases, the audio source buffer is disabled
// on the main VirtualSourceBuffer by the HTMLMediaSource much earlier
// than createRealSourceBuffers_ is called to create the second
// VirtualSourceBuffer because that happens as a side-effect of
// videojs-contrib-hls starting the audioSegmentLoader. As a result,
// the audioBuffer is essentially "ownerless" and no one will toggle
// the `updating` state back to false once the `updateend` event is received
//
// Setting `updating` to false manually will work around this
// situation and allow work to continue
buffer.updating = false;
} else {
const codecProperty = `${type}Codec_`;
const mimeType = `${type}/mp4;codecs="${this[codecProperty]}"`;
buffer = makeWrappedSourceBuffer(this.mediaSource_.nativeMediaSource_, mimeType);
this.mediaSource_[`${type}Buffer_`] = buffer;
}
this[`${type}Buffer_`] = buffer;
// Wire up the events to the SourceBuffer
['update', 'updatestart', 'updateend'].forEach((event) => {
buffer.addEventListener(event, () => {
// if audio is disabled
if (type === 'audio' && this.audioDisabled_) {
return;
}
if (event === 'updateend') {
this[`${type}Buffer_`].updating = false;
}
let shouldTrigger = types.every((t) => {
// skip checking audio's updating status if audio
// is not enabled
if (t === 'audio' && this.audioDisabled_) {
return true;
}
// if the other type if updating we don't trigger
if (type !== t &&
this[`${t}Buffer_`] &&
this[`${t}Buffer_`].updating) {
return false;
}
return true;
});
if (shouldTrigger) {
return this.trigger(event);
}
});
});
});
}
/**
* Emulate the native mediasource function, but our function will
* send all of the proposed segments to the transmuxer so that we
* can transmux them before we append them to our internal
* native source buffers in the correct format.
*
* @link https://developer.mozilla.org/en-US/docs/Web/API/SourceBuffer/appendBuffer
* @param {Uint8Array} segment the segment to append to the buffer
*/
appendBuffer(segment) {
// Start the internal "updating" state
this.bufferUpdating_ = true;
if (this.audioBuffer_ && this.audioBuffer_.buffered.length) {
let audioBuffered = this.audioBuffer_.buffered;
this.transmuxer_.postMessage({
action: 'setAudioAppendStart',
appendStart: audioBuffered.end(audioBuffered.length - 1)
});
}
if (this.videoBuffer_) {
this.transmuxer_.postMessage({
action: 'alignGopsWith',
gopsToAlignWith: gopsSafeToAlignWith(this.gopBuffer_,
this.mediaSource_.player_,
this.timeMapping_)
});
}
this.transmuxer_.postMessage({
action: 'push',
// Send the typed-array of data as an ArrayBuffer so that
// it can be sent as a "Transferable" and avoid the costly
// memory copy
data: segment.buffer,
// To recreate the original typed-array, we need information
// about what portion of the ArrayBuffer it was a view into
byteOffset: segment.byteOffset,
byteLength: segment.byteLength
},
[segment.buffer]);
this.transmuxer_.postMessage({action: 'flush'});
}
/**
* Appends gop information (timing and byteLength) received by the transmuxer for the
* gops appended in the last call to appendBuffer
*
* @param {Event} event
* The gopInfo event from the transmuxer
* @param {Array} event.data.gopInfo
* List of gop info to append
*/
appendGopInfo_(event) {
this.gopBuffer_ = updateGopBuffer(this.gopBuffer_,
event.data.gopInfo,
this.safeAppend_);
}
/**
* Emulate the native mediasource function and remove parts
* of the buffer from any of our internal buffers that exist
*
* @link https://developer.mozilla.org/en-US/docs/Web/API/SourceBuffer/remove
* @param {Double} start position to start the remove at
* @param {Double} end position to end the remove at
*/
remove(start, end) {
if (this.videoBuffer_) {
this.videoBuffer_.updating = true;
this.videoBuffer_.remove(start, end);
this.gopBuffer_ = removeGopBuffer(this.gopBuffer_, start, end, this.timeMapping_);
}
if (!this.audioDisabled_ && this.audioBuffer_) {
this.audioBuffer_.updating = true;
this.audioBuffer_.remove(start, end);
}
// Remove Metadata Cues (id3)
removeCuesFromTrack(start, end, this.metadataTrack_);
// Remove Any Captions
if (this.inbandTextTracks_) {
for (let track in this.inbandTextTracks_) {
removeCuesFromTrack(start, end, this.inbandTextTracks_[track]);
}
}
}
/**
* Process any segments that the muxer has output
* Concatenate segments together based on type and append them into
* their respective sourceBuffers
*
* @private
*/
processPendingSegments_() {
let sortedSegments = {
video: {
segments: [],
bytes: 0
},
audio: {
segments: [],
bytes: 0
},
captions: [],
metadata: []
};
// Sort segments into separate video/audio arrays and
// keep track of their total byte lengths
sortedSegments = this.pendingBuffers_.reduce(function(segmentObj, segment) {
let type = segment.type;
let data = segment.data;
let initSegment = segment.initSegment;
segmentObj[type].segments.push(data);
segmentObj[type].bytes += data.byteLength;
segmentObj[type].initSegment = initSegment;
// Gather any captions into a single array
if (segment.captions) {
segmentObj.captions = segmentObj.captions.concat(segment.captions);
}
if (segment.info) {
segmentObj[type].info = segment.info;
}
// Gather any metadata into a single array
if (segment.metadata) {
segmentObj.metadata = segmentObj.metadata.concat(segment.metadata);
}
return segmentObj;
}, sortedSegments);
// Create the real source buffers if they don't exist by now since we
// finally are sure what tracks are contained in the source
if (!this.videoBuffer_ && !this.audioBuffer_) {
// Remove any codecs that may have been specified by default but
// are no longer applicable now
if (sortedSegments.video.bytes === 0) {
this.videoCodec_ = null;
}
if (sortedSegments.audio.bytes === 0) {
this.audioCodec_ = null;
}
this.createRealSourceBuffers_();
}
if (sortedSegments.audio.info) {
this.mediaSource_.trigger({type: 'audioinfo', info: sortedSegments.audio.info});
}
if (sortedSegments.video.info) {
this.mediaSource_.trigger({type: 'videoinfo', info: sortedSegments.video.info});
}
if (this.appendAudioInitSegment_) {
if (!this.audioDisabled_ && this.audioBuffer_) {
sortedSegments.audio.segments.unshift(sortedSegments.audio.initSegment);
sortedSegments.audio.bytes += sortedSegments.audio.initSegment.byteLength;
}
this.appendAudioInitSegment_ = false;
}
let triggerUpdateend = false;
// Merge multiple video and audio segments into one and append
if (this.videoBuffer_ && sortedSegments.video.bytes) {
sortedSegments.video.segments.unshift(sortedSegments.video.initSegment);
sortedSegments.video.bytes += sortedSegments.video.initSegment.byteLength;
this.concatAndAppendSegments_(sortedSegments.video, this.videoBuffer_);
// TODO: are video tracks the only ones with text tracks?
addTextTrackData(this, sortedSegments.captions, sortedSegments.metadata);
} else if (this.videoBuffer_ && (this.audioDisabled_ || !this.audioBuffer_)) {
// The transmuxer did not return any bytes of video, meaning it was all trimmed
// for gop alignment. Since we have a video buffer and audio is disabled, updateend
// will never be triggered by this source buffer, which will cause contrib-hls
// to be stuck forever waiting for updateend. If audio is not disabled, updateend
// will be triggered by the audio buffer, which will be sent upwards since the video
// buffer will not be in an updating state.
triggerUpdateend = true;
}
if (!this.audioDisabled_ && this.audioBuffer_) {
this.concatAndAppendSegments_(sortedSegments.audio, this.audioBuffer_);
}
this.pendingBuffers_.length = 0;
if (triggerUpdateend) {
this.trigger('updateend');
}
// We are no longer in the internal "updating" state
this.bufferUpdating_ = false;
}
/**
* Combine all segments into a single Uint8Array and then append them
* to the destination buffer
*
* @param {Object} segmentObj
* @param {SourceBuffer} destinationBuffer native source buffer to append data to
* @private
*/
concatAndAppendSegments_(segmentObj, destinationBuffer) {
let offset = 0;
let tempBuffer;
if (segmentObj.bytes) {
tempBuffer = new Uint8Array(segmentObj.bytes);
// Combine the individual segments into one large typed-array
segmentObj.segments.forEach(function(segment) {
tempBuffer.set(segment, offset);
offset += segment.byteLength;
});
try {
destinationBuffer.updating = true;
destinationBuffer.appendBuffer(tempBuffer);
} catch (error) {
if (this.mediaSource_.player_) {
this.mediaSource_.player_.error({
code: -3,
type: 'APPEND_BUFFER_ERR',
message: error.message,
originalError: error
});
}
}
}
}
/**
* Emulate the native mediasource function. abort any soureBuffer
* actions and throw out any un-appended data.
*
* @link https://developer.mozilla.org/en-US/docs/Web/API/SourceBuffer/abort
*/
abort() {
if (this.videoBuffer_) {
this.videoBuffer_.abort();
}
if (!this.audioDisabled_ && this.audioBuffer_) {
this.audioBuffer_.abort();
}
if (this.transmuxer_) {
this.transmuxer_.postMessage({action: 'reset'});
}
this.pendingBuffers_.length = 0;
this.bufferUpdating_ = false;
}
}
</code></pre>
</article>
</section>
</div>
<nav>
<h2><a href="index.html">Home</a></h2><h3>Classes</h3><ul><li><a href="FlashMediaSource.html">FlashMediaSource</a></li><li><a href="FlashSourceBuffer.html">FlashSourceBuffer</a></li><li><a href="HtmlMediaSource.html">HtmlMediaSource</a></li><li><a href="MessageHandlers.html">MessageHandlers</a></li><li><a href="VirtualSourceBuffer.html">VirtualSourceBuffer</a></li></ul><h3>Global</h3><ul><li><a href="global.html#abort">abort</a></li><li><a href="global.html#addSourceBuffer">addSourceBuffer</a></li><li><a href="global.html#appendBuffer">appendBuffer</a></li><li><a href="global.html#appendGopInfo_">appendGopInfo_</a></li><li><a href="global.html#endOfStream">endOfStream</a></li><li><a href="global.html#FlashTransmuxerWorker">FlashTransmuxerWorker</a></li><li><a href="global.html#get">get</a></li><li><a href="global.html#gopsSafeToAlignWith">gopsSafeToAlignWith</a></li><li><a href="global.html#MediaSource">MediaSource</a></li><li><a href="global.html#open">open</a></li><li><a href="global.html#remove">remove</a></li><li><a href="global.html#removeGopBuffer">removeGopBuffer</a></li><li><a href="global.html#set">set</a></li><li><a href="global.html#supportsNativeMediaSources">supportsNativeMediaSources</a></li><li><a href="global.html#TransmuxerWorker">TransmuxerWorker</a></li><li><a href="global.html#updateGopBuffer">updateGopBuffer</a></li><li><a href="global.html#URL">URL</a></li></ul>
</nav>
<br class="clear">
<footer>
Documentation generated by <a href="https://github.com/jsdoc3/jsdoc">JSDoc 3.5.4</a> on Thu Nov 02 2017 12:03:25 GMT-0400 (EDT)
</footer>
<script> prettyPrint(); </script>
<script src="scripts/linenumber.js"> </script>
</body>
</html>