p2p-media-loader-shaka
Version:
P2P Media Loader Shaka Player integration
732 lines (731 loc) • 26 kB
JavaScript
var __defProp = Object.defineProperty;
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
import { debug, CoreRequestError, Core } from "p2p-media-loader-core";
class ManifestParserDecorator {
constructor(shaka, originalManifestParser) {
__publicField(this, "debug", debug("p2pml-shaka:manifest-parser"));
__publicField(this, "isHls");
__publicField(this, "segmentManager");
__publicField(this, "player");
this.shaka = shaka;
this.originalManifestParser = originalManifestParser;
this.isHls = this.originalManifestParser instanceof shaka.hls.HlsParser;
}
configure(config) {
return this.originalManifestParser.configure(config);
}
banLocation(uri) {
return this.originalManifestParser.banLocation(uri);
}
onInitialVariantChosen(variant) {
return this.originalManifestParser.onInitialVariantChosen(variant);
}
setP2PMediaLoaderData(p2pml) {
if (!p2pml) return;
this.segmentManager = p2pml.segmentManager;
this.player = p2pml.player;
p2pml.streamInfo.protocol = this.isHls ? "hls" : "dash";
}
async start(uri, playerInterface) {
const { p2pml } = playerInterface.networkingEngine;
this.setP2PMediaLoaderData(p2pml);
const manifest = await this.originalManifestParser.start(
uri,
playerInterface
);
if (!p2pml) return manifest;
if (this.isHls) {
this.hookHlsStreamMediaSequenceTimeMaps(manifest.variants);
}
this.processStreams(manifest.variants);
return manifest;
}
stop() {
return this.originalManifestParser.stop();
}
update() {
return this.originalManifestParser.update();
}
setMediaElement(mediaElement) {
return this.originalManifestParser.setMediaElement(mediaElement);
}
onExpirationUpdated(sessionId, expiration) {
return this.originalManifestParser.onExpirationUpdated(
sessionId,
expiration
);
}
processStreams(variants) {
const { segmentManager } = this;
if (!segmentManager) return;
const processedStreams = /* @__PURE__ */ new Set();
const processStream = (stream, type, order) => {
this.hookSegmentIndex(stream);
segmentManager.setStream(stream, type, order);
processedStreams.add(stream.id);
return true;
};
let videoCount = 0;
let audioCount = 0;
for (const variant of variants) {
const { video, audio } = variant;
if (video && !processedStreams.has(video.id)) {
processStream(video, "main", videoCount++);
}
if (audio && !processedStreams.has(audio.id)) {
processStream(audio, !video ? "main" : "secondary", audioCount++);
}
}
}
hookSegmentIndex(stream) {
const { segmentManager } = this;
if (!segmentManager) return;
const substituteSegmentIndexGet = (segmentIndex, callFromCreateSegmentIndexMethod = false) => {
let prevReference = null;
let prevFirstItemReference;
let prevLastItemReference;
const originalGet = segmentIndex.get;
const customGet = (position) => {
var _a, _b;
const reference = originalGet.call(segmentIndex, position);
if (reference === prevReference || !((_a = this.player) == null ? void 0 : _a.isLive()) && stream.isSegmentIndexAlreadyRead) {
return reference;
}
prevReference = reference;
segmentIndex.get = originalGet;
try {
const references = getReferencesArray(
segmentIndex,
this.shaka
);
if (!references) {
throw new Error("Segment references not found");
}
const firstItemReference = references[0];
const lastItemReference = references[references.length - 1];
if (firstItemReference === prevFirstItemReference && lastItemReference === prevLastItemReference) {
return reference;
}
prevFirstItemReference = firstItemReference;
prevLastItemReference = lastItemReference;
segmentManager.updateStreamSegments(stream, references);
stream.isSegmentIndexAlreadyRead = true;
this.debug(`Stream ${stream.id} is updated`);
} catch {
} finally {
if (!stream.isSegmentIndexAlreadyRead || !!((_b = this.player) == null ? void 0 : _b.isLive()) || !callFromCreateSegmentIndexMethod) {
segmentIndex.get = customGet;
}
}
return reference;
};
segmentIndex.get = customGet;
};
if (stream.segmentIndex) {
substituteSegmentIndexGet(stream.segmentIndex);
return;
}
const createSegmentIndexOriginal = stream.createSegmentIndex;
stream.createSegmentIndex = async () => {
const result = await createSegmentIndexOriginal.call(stream);
if (stream.segmentIndex) {
substituteSegmentIndexGet(stream.segmentIndex, true);
}
return result;
};
}
hookHlsStreamMediaSequenceTimeMaps(variants) {
var _a;
const maps = getMapPropertiesFromObject(
this.originalManifestParser
);
let videoMap;
let audioMap;
const keysToCheck = ["video", "audio", "text", "image"];
for (const map of maps) {
if (!keysToCheck.every((key) => map.has(key))) continue;
videoMap = map.get("video");
audioMap = map.get("audio");
}
if (videoMap && audioMap) {
for (const variant of variants) {
const { video: videoStream, audio: audioStream } = variant;
if (videoStream) {
videoStream.mediaSequenceTimeMap = videoMap;
}
if (audioStream) {
audioStream.mediaSequenceTimeMap = videoMap;
}
}
return;
}
const manifestVariantsMap = maps.find((map) => {
var _a2;
const item = map.values().next().value;
return (
// eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access
typeof item === "object" && ((_a2 = item == null ? void 0 : item.streams) == null ? void 0 : _a2.createSegmentIndex)
);
});
if (!manifestVariantsMap) return;
const manifestVariantMapValues = [...manifestVariantsMap.values()];
for (const variant of manifestVariantMapValues) {
if ((_a = variant == null ? void 0 : variant.stream) == null ? void 0 : _a.mediaSequenceTimeMap) continue;
const mediaSequenceTimeMap = getMapPropertiesFromObject(
variant
).find((map) => {
const [key, value] = map.entries().next().value ?? [];
return typeof key === "number" && typeof value === "number";
});
if (!mediaSequenceTimeMap) continue;
variant.stream.mediaSequenceTimeMap = mediaSequenceTimeMap;
}
}
}
class HlsManifestParser extends ManifestParserDecorator {
constructor(shaka) {
super(shaka, new shaka.hls.HlsParser());
}
}
class DashManifestParser extends ManifestParserDecorator {
constructor(shaka) {
super(shaka, new shaka.dash.DashParser());
}
}
function getReferencesArray(obj, shaka) {
for (const key in obj) {
if (Array.isArray(obj[key]) && obj[key].length > 0 && obj[key][0] instanceof shaka.media.SegmentReference) {
return obj[key];
} else if (typeof obj[key] === "object") {
const references = getReferencesArray(
obj[key],
shaka
);
if (references) return references;
}
}
return null;
}
function getMapPropertiesFromObject(object) {
return Object.values(object).filter(
(property) => property instanceof Map
);
}
function createSegment({
segmentReference,
externalId,
runtimeId
}) {
const { byteRange, url, startTime, endTime } = getSegmentInfoFromReference(segmentReference);
return {
runtimeId: runtimeId ?? getSegmentRuntimeId(url, byteRange),
externalId,
byteRange,
url,
startTime,
endTime
};
}
function getSegmentRuntimeIdFromReference(segmentReference) {
const { url, byteRange } = getSegmentInfoFromReference(segmentReference);
return getSegmentRuntimeId(url, byteRange);
}
function getSegmentRuntimeId(url, byteRange) {
if (!byteRange) return url;
const range = typeof byteRange === "string" ? getByteRangeFromHeaderString(byteRange) : byteRange;
if (!range) return url;
return `${url}|${range.start}-${range.end}`;
}
function getByteRangeFromHeaderString(rangeStr) {
if (!(rangeStr == null ? void 0 : rangeStr.includes("bytes="))) return void 0;
const range = rangeStr.split("=")[1].split("-").map((i) => parseInt(i));
const [start, end] = range;
return { start, end };
}
function getSegmentInfoFromReference(segmentReference) {
const uris = segmentReference.getUris();
const responseUrl = uris[1] ?? uris[0];
const start = segmentReference.getStartByte();
const end = segmentReference.getEndByte() ?? void 0;
const startTime = segmentReference.getStartTime();
const endTime = segmentReference.getEndTime();
return {
byteRange: end !== void 0 ? { start, end } : void 0,
url: responseUrl,
startTime,
endTime
};
}
function getStreamLastMediaSequence(stream) {
const { shakaStream } = stream;
const map = shakaStream.mediaSequenceTimeMap;
if (!map) return;
const firstMediaSequence = map.keys().next().value;
if (firstMediaSequence === void 0) return;
return firstMediaSequence + map.size - 1;
}
const SEGMENT_ID_RESOLUTION_IN_SECONDS = 0.5;
class SegmentManager {
constructor(streamInfo, core) {
__publicField(this, "core");
__publicField(this, "streamInfo");
this.core = core;
this.streamInfo = streamInfo;
}
setStream(shakaStream, type, index = -1) {
this.core.addStreamIfNoneExists({
runtimeId: shakaStream.id.toString(),
type,
index,
shakaStream
});
if (shakaStream.segmentIndex) this.updateStreamSegments(shakaStream);
}
updateStreamSegments(shakaStream, segmentReferences) {
const stream = this.core.getStream(shakaStream.id.toString());
if (!stream) return;
const { segmentIndex } = stream.shakaStream;
if (!segmentReferences && segmentIndex) {
try {
segmentReferences = [...segmentIndex];
} catch {
return;
}
}
if (!segmentReferences) return;
if (this.streamInfo.protocol === "hls") {
this.processHlsSegmentReferences(stream, segmentReferences);
} else {
this.processDashSegmentReferences(stream, segmentReferences);
}
}
processDashSegmentReferences(managerStream, segmentReferences) {
const staleSegmentsIds = new Set(managerStream.segments.keys());
const newSegments = [];
for (const reference of segmentReferences) {
const externalId = Math.trunc(
reference.getStartTime() / SEGMENT_ID_RESOLUTION_IN_SECONDS
);
const runtimeId = getSegmentRuntimeIdFromReference(reference);
if (!managerStream.segments.has(runtimeId)) {
const segment = createSegment({
segmentReference: reference,
externalId,
runtimeId
});
newSegments.push(segment);
}
staleSegmentsIds.delete(runtimeId);
}
if (!newSegments.length && !staleSegmentsIds.size) return;
this.core.updateStream(
managerStream.runtimeId,
newSegments,
staleSegmentsIds.values()
);
}
processHlsSegmentReferences(managerStream, segmentReferences) {
const { segments } = managerStream;
const lastMediaSequence = getStreamLastMediaSequence(managerStream);
const newSegments = [];
if (segments.size === 0) {
const firstReferenceMediaSequence = lastMediaSequence === void 0 ? 0 : lastMediaSequence - segmentReferences.length + 1;
for (const [index, reference] of segmentReferences.entries()) {
const segment = createSegment({
segmentReference: reference,
externalId: firstReferenceMediaSequence + index
});
newSegments.push(segment);
}
this.core.updateStream(managerStream.runtimeId, newSegments);
return;
}
if (!lastMediaSequence) return;
let mediaSequence = lastMediaSequence;
for (const reference of itemsBackwards(segmentReferences)) {
const runtimeId = getSegmentRuntimeIdFromReference(reference);
if (segments.has(runtimeId)) break;
const segment = createSegment({
runtimeId,
segmentReference: reference,
externalId: mediaSequence
});
newSegments.push(segment);
mediaSequence--;
}
newSegments.reverse();
const staleSegmentIds = [];
const countToDelete = newSegments.length;
for (const segment of nSegmentsBackwards(segments, countToDelete)) {
staleSegmentIds.push(segment.runtimeId);
}
if (!newSegments.length && !staleSegmentIds.length) return;
this.core.updateStream(
managerStream.runtimeId,
newSegments,
staleSegmentIds
);
}
}
function* itemsBackwards(items) {
for (let i = items.length - 1; i >= 0; i--) yield items[i];
}
function* nSegmentsBackwards(segments, count) {
let i = 0;
for (const segment of segments.values()) {
if (i >= count) break;
yield segment;
i++;
}
}
class Loader {
constructor(shaka, core, streamInfo) {
__publicField(this, "loadArgs");
this.shaka = shaka;
this.core = core;
this.streamInfo = streamInfo;
}
defaultLoad() {
const fetchPlugin = this.shaka.net.HttpFetchPlugin;
return fetchPlugin.parse(...this.loadArgs);
}
load(...args) {
this.loadArgs = args;
const { RequestType } = this.shaka.net.NetworkingEngine;
const [url, request, requestType] = args;
if (requestType === RequestType.SEGMENT) {
return this.loadSegment(url, request);
}
const loading = this.defaultLoad();
if (requestType === RequestType.MANIFEST) {
void this.handleManifestLoading(loading.promise);
}
return loading;
}
async handleManifestLoading(loadingPromise) {
if (!this.streamInfo.manifestResponseUrl) {
const response = await loadingPromise;
this.setManifestResponseUrl(response.uri);
}
}
loadSegment(segmentUrl, originalRequest) {
const byteRangeString = originalRequest.headers.Range;
const segmentRuntimeId = getSegmentRuntimeId(
segmentUrl,
byteRangeString
);
const isSegmentDownloadableByP2PCore = this.core.isSegmentLoadable(segmentRuntimeId);
if (!this.core.hasSegment(segmentRuntimeId) || !isSegmentDownloadableByP2PCore) {
return this.defaultLoad();
}
const loadSegment = async () => {
const { request, callbacks } = getSegmentRequest();
void this.core.loadSegment(segmentRuntimeId, callbacks);
try {
const { data, bandwidth } = await request;
return {
data,
headers: {},
originalRequest,
uri: segmentUrl,
originalUri: segmentUrl,
timeMs: getLoadingDurationBasedOnBandwidth(
bandwidth,
data.byteLength
)
};
} catch (error) {
if (error instanceof CoreRequestError) {
const { Error: ShakaError } = this.shaka.util;
if (error.type === "aborted") {
throw new ShakaError(
ShakaError.Severity.RECOVERABLE,
ShakaError.Category.NETWORK,
this.shaka.util.Error.Code.OPERATION_ABORTED
);
}
}
throw error;
}
};
return new this.shaka.util.AbortableOperation(loadSegment(), () => {
this.core.abortSegmentLoading(segmentRuntimeId);
return Promise.resolve();
});
}
setManifestResponseUrl(responseUrl) {
this.streamInfo.manifestResponseUrl = responseUrl;
this.core.setManifestResponseUrl(responseUrl);
}
}
function getLoadingDurationBasedOnBandwidth(bandwidth, bytesLoaded) {
const bits = bytesLoaded * 8;
return Math.round(bits / bandwidth) * 1e3;
}
function getSegmentRequest() {
let onSuccess;
let onError;
const request = new Promise((resolve, reject) => {
onSuccess = resolve;
onError = reject;
});
return {
request,
callbacks: {
// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
onSuccess,
// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
onError
}
};
}
const LIVE_EDGE_DELAY = 25;
class ShakaP2PEngine {
/**
* Constructs an instance of ShakaP2PEngine.
*
* @param config Optional configuration for customizing the P2P engine's behavior.
* @param shaka The Shaka Player library instance.
*/
constructor(config, shaka = window.shaka) {
__publicField(this, "player");
__publicField(this, "shaka");
__publicField(this, "streamInfo", {});
__publicField(this, "core");
__publicField(this, "segmentManager");
__publicField(this, "requestFilter");
__publicField(this, "updatePlayerEventHandlers", (type) => {
const { player } = this;
if (!player) return;
const networkingEngine = player.getNetworkingEngine();
if (networkingEngine) {
if (type === "register") {
const p2pml = {
player,
shaka: this.shaka,
core: this.core,
streamInfo: this.streamInfo,
segmentManager: this.segmentManager
};
this.requestFilter = (requestType, request) => {
request.p2pml = p2pml;
};
networkingEngine.p2pml = p2pml;
networkingEngine.registerRequestFilter(this.requestFilter);
} else {
networkingEngine.p2pml = void 0;
if (this.requestFilter) {
networkingEngine.unregisterRequestFilter(this.requestFilter);
}
}
}
const method = type === "register" ? "addEventListener" : "removeEventListener";
player[method]("loaded", this.handlePlayerLoaded);
player[method]("loading", this.destroyCurrentStreamContext);
player[method]("unloading", this.handlePlayerUnloading);
player[method]("adaptation", this.onVariantChanged);
player[method]("variantchanged", this.onVariantChanged);
});
__publicField(this, "onVariantChanged", () => {
if (!this.player) return;
const activeTrack = this.player.getVariantTracks().find((track) => track.active);
if (!activeTrack) return;
this.core.setActiveLevelBitrate(activeTrack.bandwidth);
});
__publicField(this, "handlePlayerLoaded", () => {
if (!this.player) return;
this.core.setIsLive(this.player.isLive());
this.updateMediaElementEventHandlers("register");
});
__publicField(this, "handlePlayerUnloading", () => {
this.destroyCurrentStreamContext();
this.updateMediaElementEventHandlers("unregister");
});
__publicField(this, "destroyCurrentStreamContext", () => {
this.streamInfo.protocol = void 0;
this.streamInfo.manifestResponseUrl = void 0;
this.core.destroy();
});
__publicField(this, "updateMediaElementEventHandlers", (type) => {
var _a;
const media = (_a = this.player) == null ? void 0 : _a.getMediaElement();
if (!media) return;
const method = type === "register" ? "addEventListener" : "removeEventListener";
media[method]("timeupdate", this.handlePlaybackUpdate);
media[method]("ratechange", this.handlePlaybackUpdate);
media[method]("seeking", this.handlePlaybackUpdate);
});
__publicField(this, "handlePlaybackUpdate", (event) => {
const media = event.target;
this.core.updatePlayback(media.currentTime, media.playbackRate);
});
validateShaka(shaka);
this.shaka = shaka;
this.core = new Core(config == null ? void 0 : config.core);
this.segmentManager = new SegmentManager(this.streamInfo, this.core);
}
/**
* Configures and initializes the Shaka Player instance with predefined settings for optimal P2P performance.
*
* @param player The Shaka Player instance to configure.
*/
bindShakaPlayer(player) {
if (this.player === player) return;
if (this.player) this.destroy();
this.player = player;
this.player.configure("manifest.defaultPresentationDelay", LIVE_EDGE_DELAY);
this.player.configure(
"manifest.dash.ignoreSuggestedPresentationDelay",
true
);
this.player.configure("streaming.useNativeHlsOnSafari", false);
this.updatePlayerEventHandlers("register");
}
/**
* Applies dynamic configuration updates to the P2P engine.
*
* @param dynamicConfig Configuration changes to apply.
*
* @example
* // Assuming `shakaP2PEngine` is an instance of ShakaP2PEngine
*
* const newDynamicConfig = {
* core: {
* // Increase the number of cached segments to 1000
* cachedSegmentsCount: 1000,
* // 50 minutes of segments will be downloaded further through HTTP connections if P2P fails
* httpDownloadTimeWindow: 3000,
* // 100 minutes of segments will be downloaded further through P2P connections
* p2pDownloadTimeWindow: 6000,
* };
*
* shakaP2PEngine.applyDynamicConfig(newDynamicConfig);
*/
applyDynamicConfig(dynamicConfig) {
if (dynamicConfig.core) this.core.applyDynamicConfig(dynamicConfig.core);
}
/**
* Retrieves the current configuration of the ShakaP2PEngine.
*
* @returns The configuration as a readonly object.
*/
getConfig() {
return { core: this.core.getConfig() };
}
/**
* Adds an event listener for the specified event.
* @param eventName The name of the event to listen for.
* @param listener The callback function to be invoked when the event is triggered.
*
* @example
* // Listening for a segment being successfully loaded
* shakaP2PEngine.addEventListener('onSegmentLoaded', (details) => {
* console.log('Segment Loaded:', details);
* });
*
* @example
* // Handling segment load errors
* shakaP2PEngine.addEventListener('onSegmentError', (errorDetails) => {
* console.error('Error loading segment:', errorDetails);
* });
*
* @example
* // Tracking data downloaded from peers
* shakaP2PEngine.addEventListener('onChunkDownloaded', (bytesLength, downloadSource, peerId) => {
* console.log(`Downloaded ${bytesLength} bytes from ${downloadSource} ${peerId ? 'from peer ' + peerId : 'from server'}`);
* });
*/
addEventListener(eventName, listener) {
this.core.addEventListener(eventName, listener);
}
/**
* Removes an event listener for the specified event.
* @param eventName The name of the event.
* @param listener The callback function that was previously added.
*/
removeEventListener(eventName, listener) {
this.core.removeEventListener(eventName, listener);
}
/** Clean up and release all resources. Unregister all event handlers. */
destroy() {
this.destroyCurrentStreamContext();
this.updatePlayerEventHandlers("unregister");
this.updateMediaElementEventHandlers("unregister");
this.player = void 0;
}
static registerManifestParsers(shaka) {
const hlsParserFactory = () => new HlsManifestParser(shaka);
const dashParserFactory = () => new DashManifestParser(shaka);
const Parser = shaka.media.ManifestParser;
Parser.registerParserByMime("application/dash+xml", dashParserFactory);
Parser.registerParserByMime("application/x-mpegurl", hlsParserFactory);
Parser.registerParserByMime(
"application/vnd.apple.mpegurl",
hlsParserFactory
);
}
static unregisterManifestParsers(shaka) {
const Parser = shaka.media.ManifestParser;
Parser.unregisterParserByMime("mpd");
Parser.unregisterParserByMime("application/dash+xml");
Parser.unregisterParserByMime("m3u8");
Parser.unregisterParserByMime("application/x-mpegurl");
Parser.unregisterParserByMime("application/vnd.apple.mpegurl");
}
static registerNetworkingEngineSchemes(shaka) {
const { NetworkingEngine } = shaka.net;
const handleLoading = (...args) => {
const request = args[1];
const { p2pml } = request;
if (!p2pml) {
return shaka.net.HttpFetchPlugin.parse(
...args
);
}
const loader = new Loader(p2pml.shaka, p2pml.core, p2pml.streamInfo);
return loader.load(...args);
};
NetworkingEngine.registerScheme("http", handleLoading);
NetworkingEngine.registerScheme("https", handleLoading);
NetworkingEngine.registerScheme("data", handleLoading);
}
static unregisterNetworkingEngineSchemes(shaka) {
const { NetworkingEngine } = shaka.net;
NetworkingEngine.unregisterScheme("http");
NetworkingEngine.unregisterScheme("https");
NetworkingEngine.unregisterScheme("data");
}
/**
* Registers plugins related to P2P functionality into the Shaka Player.
* Plugins must be registered before initializing the player to ensure proper integration.
*
* @param shaka - The Shaka Player library. Defaults to the global Shaka Player instance if not provided.
*/
static registerPlugins(shaka = window.shaka) {
validateShaka(shaka);
ShakaP2PEngine.registerManifestParsers(shaka);
ShakaP2PEngine.registerNetworkingEngineSchemes(shaka);
}
/**
* Unregister plugins related to P2P functionality from the Shaka Player.
*
* @param shaka - The Shaka Player library. Defaults to the global Shaka Player instance if not provided.
*/
static unregisterPlugins(shaka = window.shaka) {
validateShaka(shaka);
ShakaP2PEngine.unregisterManifestParsers(shaka);
ShakaP2PEngine.unregisterNetworkingEngineSchemes(shaka);
}
}
function validateShaka(shaka) {
if (!shaka) {
throw new Error(
"shaka namespace is not defined in global scope and not passed as an argument to Shaka P2P engine constructor"
);
}
}
export {
ShakaP2PEngine
};
//# sourceMappingURL=p2p-media-loader-shaka.es.js.map