@cdn365/p2p-media-loader-hlsjs 1.0.0

package/src/playlist-loader.ts

@@ -0,0 +1,37 @@
+import {
+  HlsConfig,
+  Loader,
+  LoaderCallbacks,
+  LoaderConfiguration,
+  LoaderContext,
+  LoaderStats,
+  PlaylistLoaderContext,
+} from "hls.js";
+
+export class PlaylistLoaderBase implements Loader<PlaylistLoaderContext> {
+  #defaultLoader: Loader<LoaderContext>;
+  context: PlaylistLoaderContext;
+  stats: LoaderStats;
+
+  constructor(config: HlsConfig) {
+    this.#defaultLoader = new config.loader(config);
+    this.stats = this.#defaultLoader.stats;
+    this.context = this.#defaultLoader.context as PlaylistLoaderContext;
+  }
+
+  load(
+    context: LoaderContext,
+    config: LoaderConfiguration,
+    callbacks: LoaderCallbacks<LoaderContext>,
+  ) {
+    this.#defaultLoader.load(context, config, callbacks);
+  }
+
+  abort() {
+    this.#defaultLoader.abort();
+  }
+
+  destroy() {
+    this.#defaultLoader.destroy();
+  }
+}

package/src/segment-mananger.ts

@@ -0,0 +1,80 @@
+import * as Utils from "./utils.js";
+import type {
+  ManifestLoadedData,
+  LevelUpdatedData,
+  AudioTrackLoadedData,
+} from "hls.js";
+import { Core, Segment } from "p2p-media-loader-core";
+
+export class SegmentManager {
+  core: Core;
+
+  constructor(core: Core) {
+    this.core = core;
+  }
+
+  processMainManifest(data: ManifestLoadedData) {
+    const { levels, audioTracks } = data;
+    // in the case of audio only stream it is stored in levels
+
+    for (const [index, level] of levels.entries()) {
+      const { url } = level;
+      this.core.addStreamIfNoneExists({
+        runtimeId: Array.isArray(url) ? (url as string[])[0] : url,
+        type: "main",
+        index,
+      });
+    }
+
+    for (const [index, track] of audioTracks.entries()) {
+      const { url } = track;
+      this.core.addStreamIfNoneExists({
+        runtimeId: Array.isArray(url) ? (url as string[])[0] : url,
+        type: "secondary",
+        index,
+      });
+    }
+  }
+
+  updatePlaylist(data: LevelUpdatedData | AudioTrackLoadedData) {
+    const {
+      details: { url, fragments, live },
+    } = data;
+
+    const playlist = this.core.getStream(url);
+    if (!playlist) return;
+
+    const segmentToRemoveIds = new Set(playlist.segments.keys());
+    const newSegments: Segment[] = [];
+    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());
+  }
+}

package/src/utils.ts

@@ -0,0 +1,22 @@
+import { ByteRange } from "p2p-media-loader-core";
+
+export function getSegmentRuntimeId(
+  segmentRequestUrl: string,
+  byteRange?: ByteRange,
+) {
+  if (!byteRange) return segmentRequestUrl;
+  return `${segmentRequestUrl}|${byteRange.start}-${byteRange.end}`;
+}
+
+export function getByteRange(
+  rangeStart: number | undefined,
+  rangeEnd: number | undefined,
+): ByteRange | undefined {
+  if (
+    rangeStart !== undefined &&
+    rangeEnd !== undefined &&
+    rangeStart <= rangeEnd
+  ) {
+    return { start: rangeStart, end: rangeEnd };
+  }
+}