rx-player 4.5.0-dev.2026012302 → 4.5.0-dev.2026021900

package/src/core/stream/representation/representation_stream.ts

@@ -33,6 +33,7 @@ import type {
   IParsedInitSegmentPayload,
   IParsedSegmentPayload,
 } from "../../fetchers/segment/segment_queue";
+import EncryptionDataNotifier from "./encryption_data_notifier";
 import type {
   IQueuedSegment,
   IRepresentationStreamArguments,
@@ -125,33 +126,16 @@ export default function RepresentationStream<TSegmentDataType>(
     initSegmentState.isLoaded = true;
   }
 
-  /**
-   * `true` if the event notifying about encryption data has already been
-   * constructed.
-   * Allows to avoid sending multiple times protection events.
-   */
-  let hasSentEncryptionData = false;
-
-  // If the DRM system id is already known, and if we already have encryption data
-  // for it, we may not need to wait until the initialization segment is loaded to
-  // signal required protection data, thus performing License negotiations sooner
-  if (drmSystemId !== undefined) {
-    const encryptionData = representation.getEncryptionData(drmSystemId);
-
-    // If some key ids are not known yet, it may be safer to wait for this initialization
-    // segment to be loaded first
-    if (
-      encryptionData.length > 0 &&
-      encryptionData.every((e) => e.keyIds !== undefined)
-    ) {
-      hasSentEncryptionData = true;
+  const drmNotifier = new EncryptionDataNotifier({
+    drmSystemId,
+    representation,
+    notify: (encryptionData) =>
       callbacks.encryptionDataEncountered(
         encryptionData.map((d) => objectAssign({ content }, d)),
-      );
-      if (canceller.isUsed()) {
-        return; // previous callback has stopped everything by side-effect
-      }
-    }
+      ),
+  });
+  if (canceller.isUsed()) {
+    return;
   }
 
   segmentQueue.addEventListener(
@@ -260,7 +244,7 @@ export default function RepresentationStream<TSegmentDataType>(
       } else if (initSegmentState.isLoaded) {
         log.warn(
           "Stream",
-          "Uninitialized index with an already loaded " + "initialization segment",
+          "Uninitialized index with an already loaded initialization segment",
           {
             bufferType,
             representationBitrate: content.representation.bitrate,
@@ -369,29 +353,7 @@ export default function RepresentationStream<TSegmentDataType>(
       | IParsedInitSegmentPayload<TSegmentDataType>
       | IParsedSegmentPayload<TSegmentDataType>,
   ): void {
-    // Supplementary encryption information might have been parsed.
-    for (const protInfo of evt.protectionData) {
-      // TODO better handle use cases like key rotation by not always grouping
-      // every protection data together? To check.
-      representation.addProtectionData(
-        protInfo.initDataType,
-        protInfo.keyId,
-        protInfo.initData,
-      );
-    }
-
-    // Now that the initialization segment has been parsed - which may have
-    // included encryption information - take care of the encryption event
-    // if not already done.
-    if (!hasSentEncryptionData) {
-      const allEncryptionData = representation.getAllEncryptionData();
-      if (allEncryptionData.length > 0) {
-        callbacks.encryptionDataEncountered(
-          allEncryptionData.map((p) => objectAssign({ content }, p)),
-        );
-        hasSentEncryptionData = true;
-      }
-    }
+    drmNotifier.onNewProtectionData(evt.protectionData);
 
     if (evt.segmentType === "init") {
       if (!representation.index.isInitialized() && evt.segmentList !== undefined) {

package/src/core/stream/representation/utils/__tests__/append_segment_to_buffer.test.ts

@@ -0,0 +1,321 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { MediaError, SourceBufferError } from "../../../../../errors";
+import SharedReference from "../../../../../utils/reference";
+import TaskCanceller, { CancellationError } from "../../../../../utils/task_canceller";
+import appendSegmentToBuffer from "../append_segment_to_buffer";
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
+
+vi.mock("../../../../../log", () => ({
+  default: {
+    debug: vi.fn(),
+    warn: vi.fn(),
+  },
+}));
+vi.mock("../../../../../utils/sleep", () => ({
+  default: vi.fn(() => Promise.resolve()),
+}));
+
+describe("appendSegmentToBuffer", () => {
+  let mockPlaybackObserver: any;
+  let mockSegmentSink: any;
+  let mockDataInfos: any;
+  let mockBufferGoal: SharedReference<number>;
+  let mockTaskCanceller = new TaskCanceller("test canceller");
+
+  beforeEach(() => {
+    mockPlaybackObserver = {
+      getReference: vi.fn(
+        () =>
+          new SharedReference({
+            position: {
+              getWanted: () => 10,
+            },
+          }),
+      ),
+    };
+    mockSegmentSink = {
+      pushChunk: vi.fn(() => Promise.resolve([{ start: 0, end: 10 }])),
+      removeBuffer: vi.fn(() => Promise.resolve(undefined)),
+    };
+    mockDataInfos = {
+      inventoryInfos: {
+        adaptation: { id: "test-adaptation", type: "video", representations: [] },
+      },
+    };
+    mockBufferGoal = new SharedReference(30);
+    mockTaskCanceller.cancel("test end");
+    mockTaskCanceller = new TaskCanceller("test canceller");
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe("successful append", () => {
+    it("should push chunk successfully on first try", async () => {
+      const result = await appendSegmentToBuffer(
+        mockPlaybackObserver,
+        mockSegmentSink,
+        mockDataInfos,
+        mockBufferGoal,
+        mockTaskCanceller.signal,
+      );
+
+      expect(mockSegmentSink.pushChunk).toHaveBeenCalledTimes(1);
+      expect(mockSegmentSink.pushChunk).toHaveBeenCalledWith(mockDataInfos);
+      expect(result).toEqual([{ start: 0, end: 10 }]);
+    });
+  });
+
+  describe("buffer full error handling", () => {
+    it("should run garbage collector and retry on buffer full error", async () => {
+      const bufferFullError = new SourceBufferError(
+        "BUFFER_FULL",
+        "Buffer is full",
+        true,
+      );
+
+      mockSegmentSink.pushChunk
+        .mockRejectedValueOnce(bufferFullError)
+        .mockResolvedValueOnce([{ start: 0, end: 10 }]);
+
+      const result = await appendSegmentToBuffer(
+        mockPlaybackObserver,
+        mockSegmentSink,
+        mockDataInfos,
+        mockBufferGoal,
+        mockTaskCanceller.signal,
+      );
+
+      expect(mockSegmentSink.pushChunk).toHaveBeenCalledTimes(2);
+      expect(mockSegmentSink.removeBuffer).toHaveBeenCalledTimes(2);
+      expect(result).toEqual([{ start: 0, end: 10 }]);
+    });
+
+    it("should remove buffer before current position (start)", async () => {
+      const bufferFullError = new SourceBufferError(
+        "BUFFER_FULL",
+        "Buffer is full",
+        true,
+      );
+
+      mockSegmentSink.pushChunk
+        .mockRejectedValueOnce(bufferFullError)
+        .mockResolvedValueOnce([{ start: 0, end: 10 }]);
+
+      await appendSegmentToBuffer(
+        mockPlaybackObserver,
+        mockSegmentSink,
+        mockDataInfos,
+        mockBufferGoal,
+        mockTaskCanceller.signal,
+      );
+
+      // Should remove from 0 to (currentPos - 5) = 5
+      expect(mockSegmentSink.removeBuffer).toHaveBeenCalledWith(0, 5);
+    });
+
+    it("should remove buffer after buffer goal (end)", async () => {
+      const bufferFullError = new SourceBufferError(
+        "BUFFER_FULL",
+        "Buffer is full",
+        true,
+      );
+
+      mockSegmentSink.pushChunk
+        .mockRejectedValueOnce(bufferFullError)
+        .mockResolvedValueOnce([{ start: 0, end: 10 }]);
+
+      mockBufferGoal.setValue(30);
+
+      await appendSegmentToBuffer(
+        mockPlaybackObserver,
+        mockSegmentSink,
+        mockDataInfos,
+        mockBufferGoal,
+        mockTaskCanceller.signal,
+      );
+
+      // Should remove from (currentPos + bufferGoal + 12) = 52 to MAX_VALUE
+      expect(mockSegmentSink.removeBuffer).toHaveBeenCalledWith(52, Number.MAX_VALUE);
+    });
+
+    it("should not remove start buffer when position is < 5", async () => {
+      const bufferFullError = new SourceBufferError(
+        "BUFFER_FULL",
+        "Buffer is full",
+        true,
+      );
+
+      mockSegmentSink.pushChunk
+        .mockRejectedValueOnce(bufferFullError)
+        .mockResolvedValueOnce([{ start: 0, end: 10 }]);
+
+      mockPlaybackObserver.getReference.mockReturnValue(
+        new SharedReference({
+          position: {
+            getWanted: vi.fn(() => 3),
+          },
+        }),
+      );
+      await appendSegmentToBuffer(
+        mockPlaybackObserver,
+        mockSegmentSink,
+        mockDataInfos,
+        mockBufferGoal,
+        mockTaskCanceller.signal,
+      );
+      expect(mockSegmentSink.removeBuffer).toHaveBeenCalledWith(45, Number.MAX_VALUE);
+
+      // Should only be called once for the end buffer
+      expect(mockSegmentSink.removeBuffer).toHaveBeenCalledTimes(1);
+    });
+
+    it("should throw BUFFER_FULL_ERROR if retry fails", async () => {
+      const bufferFullError = new SourceBufferError(
+        "BUFFER_FULL",
+        "Buffer is full",
+        true,
+      );
+
+      const retryError = new Error("Retry failed");
+
+      mockSegmentSink.pushChunk
+        .mockRejectedValueOnce(bufferFullError)
+        .mockRejectedValueOnce(retryError);
+
+      await expect(
+        appendSegmentToBuffer(
+          mockPlaybackObserver,
+          mockSegmentSink,
+          mockDataInfos,
+          mockBufferGoal,
+          mockTaskCanceller.signal,
+        ),
+      ).rejects.toThrow("BUFFER_FULL_ERROR");
+    });
+  });
+
+  describe("non-buffer-full errors", () => {
+    it("should throw BUFFER_APPEND_ERROR for non-buffer-full SourceBufferError", async () => {
+      const error = new SourceBufferError("SOME_ERROR", "Some error", false);
+      mockSegmentSink.pushChunk.mockRejectedValueOnce(error);
+      await expect(
+        appendSegmentToBuffer(
+          mockPlaybackObserver,
+          mockSegmentSink,
+          mockDataInfos,
+          mockBufferGoal,
+          mockTaskCanceller.signal,
+        ),
+      ).rejects.toThrow(
+        new MediaError("BUFFER_APPEND_ERROR", "SOME_ERROR: Some error", {
+          tracks: [
+            {
+              type: "video",
+              track: {
+                id: "test-adaptation",
+                representations: [],
+              },
+            },
+          ],
+        }),
+      );
+    });
+
+    it("should throw BUFFER_APPEND_ERROR for generic Error", async () => {
+      const error = new Error("Generic error");
+      mockSegmentSink.pushChunk.mockRejectedValueOnce(error);
+
+      await expect(
+        appendSegmentToBuffer(
+          mockPlaybackObserver,
+          mockSegmentSink,
+          mockDataInfos,
+          mockBufferGoal,
+          mockTaskCanceller.signal,
+        ),
+      ).rejects.toThrow(MediaError);
+    });
+
+    it("should throw BUFFER_APPEND_ERROR for unknown error type", async () => {
+      mockSegmentSink.pushChunk.mockRejectedValueOnce("string error");
+
+      await expect(
+        appendSegmentToBuffer(
+          mockPlaybackObserver,
+          mockSegmentSink,
+          mockDataInfos,
+          mockBufferGoal,
+          mockTaskCanceller.signal,
+        ),
+      ).rejects.toThrow(MediaError);
+    });
+  });
+
+  describe("cancellation handling", () => {
+    it("should throw CancellationError on initial pushChunk if cancelled", async () => {
+      const cancellationError = new CancellationError("Test", "test");
+      mockTaskCanceller.cancel("test cancellation");
+      mockSegmentSink.pushChunk.mockRejectedValueOnce(cancellationError);
+
+      await expect(
+        appendSegmentToBuffer(
+          mockPlaybackObserver,
+          mockSegmentSink,
+          mockDataInfos,
+          mockBufferGoal,
+          mockTaskCanceller.signal,
+        ),
+      ).rejects.toThrow(CancellationError);
+    });
+
+    it("should throw CancellationError during retry if cancelled", async () => {
+      const bufferFullError = new SourceBufferError(
+        "BUFFER_FULL",
+        "Buffer is full",
+        true,
+      );
+
+      mockSegmentSink.pushChunk.mockRejectedValueOnce(bufferFullError);
+      mockTaskCanceller.cancel("test 523");
+
+      await expect(
+        appendSegmentToBuffer(
+          mockPlaybackObserver,
+          mockSegmentSink,
+          mockDataInfos,
+          mockBufferGoal,
+          mockTaskCanceller.signal,
+        ),
+      ).rejects.toThrow(CancellationError);
+    });
+
+    it("should throw CancellationError if retry pushChunk is cancelled", async () => {
+      const bufferFullError = new SourceBufferError(
+        "BUFFER_FULL",
+        "Buffer is full",
+        true,
+      );
+
+      const cancellationError = new CancellationError("Test", "test");
+
+      mockSegmentSink.pushChunk
+        .mockRejectedValueOnce(bufferFullError)
+        .mockRejectedValueOnce(cancellationError);
+
+      await expect(
+        appendSegmentToBuffer(
+          mockPlaybackObserver,
+          mockSegmentSink,
+          mockDataInfos,
+          mockBufferGoal,
+          mockTaskCanceller.signal,
+        ),
+      ).rejects.toThrow(CancellationError);
+    });
+  });
+});