p2p-media-loader-hlsjs/lib/segment-manager.js

P2P Media Loader hls.js integration

import * as Utils from "./utils.js";
import { generateStreamShortId } from "p2p-media-loader-core";
export class SegmentManager {
    constructor(core) {
        Object.defineProperty(this, "core", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
        });
        this.core = core;
    }
    processMainManifest(data) {
        const { levels, audioTracks } = data;
        // in the case of audio only stream it is stored in levels
        for (const level of levels) {
            const { url, bitrate, maxBitrate, videoCodec, width, height } = level;
            // maxBitrate tracks the peak BANDWIDTH tag, whereas bitrate tracks AVERAGE-BANDWIDTH.
            // We prioritize maxBitrate to universally match Shaka's variant.bandwidth parsing.
            const b = maxBitrate !== null && maxBitrate !== void 0 ? maxBitrate : bitrate;
            const isMissingMetadata = b === 0;
            const frameRate = level.attrs["FRAME-RATE"];
            const videoRange = level.attrs["VIDEO-RANGE"];
            const index = generateStreamShortId({
                bitrate: b,
                codecs: isMissingMetadata ? undefined : videoCodec,
                width: isMissingMetadata ? undefined : width,
                height: isMissingMetadata ? undefined : height,
                frameRate: isMissingMetadata ? undefined : frameRate,
                videoRange: isMissingMetadata ? undefined : videoRange,
            });
            this.core.addStreamIfNoneExists({
                runtimeId: Array.isArray(url) ? url[0] : url,
                type: "main",
                index,
            });
        }
        for (const track of audioTracks) {
            // Object properties vary across hls.js versions so we cast to any:
            const { url, audioCodec, lang, channels, name } = track;
            const index = generateStreamShortId({
                bitrate: 0, // Match Shaka behavior for audio stream without variant
                codecs: audioCodec,
                language: lang,
                channels,
                name,
            });
            this.core.addStreamIfNoneExists({
                runtimeId: Array.isArray(url) ? url[0] : url,
                type: "secondary",
                index,
            });
        }
    }
    updatePlaylist(data) {
        const { details: { url, fragments, live }, } = data;
        const playlist = this.core.getStream(url);
        if (!playlist)
            return;
        const segmentToRemoveIds = new Set(playlist.segments.keys());
        const newSegments = [];
        fragments.forEach((fragment, index) => {
            const { url: responseUrl, byteRange: fragByteRange, sn, start: startTime, end: endTime, } = fragment;
            const [start, end] = fragByteRange;
            const byteRange = Utils.getByteRange(start, end !== undefined ? end - 1 : undefined);
            const runtimeId = Utils.getSegmentRuntimeId(responseUrl, byteRange);
            segmentToRemoveIds.delete(runtimeId);
            if (playlist.segments.has(runtimeId))
                return;
            newSegments.push({
                runtimeId,
                url: responseUrl,
                externalId: live ? sn : index,
                byteRange,
                startTime,
                endTime,
            });
        });
        if (!newSegments.length && !segmentToRemoveIds.size)
            return;
        this.core.updateStream(url, newSegments, segmentToRemoveIds.values());
    }
}
//# sourceMappingURL=segment-manager.js.map