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

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

@@ -0,0 +1,209 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import pushInitSegment from "../push_init_segment";
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+
+const mockAppendSegmentToBuffer = vi.hoisted(() => vi.fn());
+
+vi.mock("../append_segment_to_buffer", () => ({
+  default: mockAppendSegmentToBuffer,
+}));
+
+describe("pushInitSegment", () => {
+  let mockPlaybackObserver: any;
+  let mockSegmentSink: any;
+  let mockBufferGoal: any;
+  let mockCancelSignal: any;
+  let mockContent: any;
+  let mockSegment: any;
+
+  beforeEach(() => {
+    vi.resetAllMocks();
+
+    mockPlaybackObserver = {};
+
+    mockSegmentSink = {};
+
+    mockBufferGoal = {
+      getValue: vi.fn().mockReturnValue(30),
+    };
+
+    mockCancelSignal = {
+      signal: { aborted: false },
+      cancellationError: null,
+    };
+
+    mockContent = {
+      adaptation: { id: "adaptation-1" },
+      manifest: { id: "manifest-1" },
+      period: { id: "period-1" },
+      representation: {
+        id: "rep-1",
+        getMimeTypeString: vi.fn().mockReturnValue('video/mp4; codecs="avc1.42E01E"'),
+      },
+    };
+
+    mockSegment = {
+      id: "init-segment",
+      isInit: true,
+      time: 0,
+      duration: 0,
+    };
+  });
+
+  it("should call appendSegmentToBuffer with correct data structure", async () => {
+    mockAppendSegmentToBuffer.mockResolvedValue({
+      start: 0,
+      end: 10,
+    });
+
+    const initSegmentUniqueId = "unique-init-123";
+
+    await pushInitSegment(
+      {
+        playbackObserver: mockPlaybackObserver,
+        content: mockContent,
+        initSegmentUniqueId,
+        segmentData: null,
+        segment: mockSegment,
+        segmentSink: mockSegmentSink,
+        bufferGoal: mockBufferGoal,
+      },
+      mockCancelSignal,
+    );
+
+    expect(mockAppendSegmentToBuffer).toHaveBeenCalledTimes(1);
+
+    const callArgs = mockAppendSegmentToBuffer.mock.calls[0];
+    expect(callArgs[0]).toBe(mockPlaybackObserver);
+    expect(callArgs[1]).toBe(mockSegmentSink);
+    expect(callArgs[3]).toBe(mockBufferGoal);
+    expect(callArgs[4]).toBe(mockCancelSignal);
+
+    const { data, inventoryInfos } = callArgs[2];
+    expect(data).toEqual({
+      initSegmentUniqueId,
+      chunk: null,
+      timestampOffset: 0,
+      appendWindow: [undefined, undefined],
+      codec: 'video/mp4; codecs="avc1.42E01E"',
+    });
+
+    expect(inventoryInfos).toMatchObject({
+      segment: mockSegment,
+      chunkSize: undefined,
+      start: 0,
+      end: 0,
+      adaptation: mockContent.adaptation,
+      manifest: mockContent.manifest,
+      period: mockContent.period,
+      representation: mockContent.representation,
+    });
+  });
+
+  it("should return correct payload with buffered result", async () => {
+    const mockBuffered = { start: 0, end: 10 };
+    mockAppendSegmentToBuffer.mockResolvedValue(mockBuffered);
+
+    const result = await pushInitSegment(
+      {
+        playbackObserver: mockPlaybackObserver,
+        content: mockContent,
+        initSegmentUniqueId: "init-456",
+        segmentData: null,
+        segment: mockSegment,
+        segmentSink: mockSegmentSink,
+        bufferGoal: mockBufferGoal,
+      },
+      mockCancelSignal,
+    );
+
+    expect(result).toEqual({
+      content: mockContent,
+      segment: mockSegment,
+      buffered: mockBuffered,
+    });
+  });
+
+  it("should call getMimeTypeString on representation", async () => {
+    mockAppendSegmentToBuffer.mockResolvedValue({ start: 0, end: 0 });
+
+    await pushInitSegment(
+      {
+        playbackObserver: mockPlaybackObserver,
+        content: mockContent,
+        initSegmentUniqueId: "init-789",
+        segmentData: null,
+        segment: mockSegment,
+        segmentSink: mockSegmentSink,
+        bufferGoal: mockBufferGoal,
+      },
+      mockCancelSignal,
+    );
+
+    expect(mockContent.representation.getMimeTypeString).toHaveBeenCalledTimes(1);
+  });
+
+  it("should set chunk to null for init segments", async () => {
+    mockAppendSegmentToBuffer.mockResolvedValue({});
+
+    await pushInitSegment(
+      {
+        playbackObserver: mockPlaybackObserver,
+        content: mockContent,
+        initSegmentUniqueId: "init-abc",
+        segmentData: { someData: "value" },
+        segment: mockSegment,
+        segmentSink: mockSegmentSink,
+        bufferGoal: mockBufferGoal,
+      },
+      mockCancelSignal,
+    );
+
+    const { data } = mockAppendSegmentToBuffer.mock.calls[0][2];
+    expect(data.chunk).toBeNull();
+  });
+
+  it("should set timestampOffset to 0", async () => {
+    mockAppendSegmentToBuffer.mockResolvedValue({});
+
+    await pushInitSegment(
+      {
+        playbackObserver: mockPlaybackObserver,
+        content: mockContent,
+        initSegmentUniqueId: "init-def",
+        segmentData: null,
+        segment: mockSegment,
+        segmentSink: mockSegmentSink,
+        bufferGoal: mockBufferGoal,
+      },
+      mockCancelSignal,
+    );
+
+    const { data } = mockAppendSegmentToBuffer.mock.calls[0][2];
+    expect(data.timestampOffset).toBe(0);
+  });
+
+  it("should set appendWindow to [undefined, undefined]", async () => {
+    mockAppendSegmentToBuffer.mockResolvedValue({});
+
+    await pushInitSegment(
+      {
+        playbackObserver: mockPlaybackObserver,
+        content: mockContent,
+        initSegmentUniqueId: "init-ghi",
+        segmentData: null,
+        segment: mockSegment,
+        segmentSink: mockSegmentSink,
+        bufferGoal: mockBufferGoal,
+      },
+      mockCancelSignal,
+    );
+
+    const { data } = mockAppendSegmentToBuffer.mock.calls[0][2];
+    expect(data.appendWindow).toEqual([undefined, undefined]);
+  });
+});

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

@@ -0,0 +1,343 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import type { CancellationSignal } from "../../../../../utils/task_canceller";
+import pushMediaSegment from "../push_media_segment";
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+
+// Mock dependencies with vi.hoisted
+const mockGetCurrent = vi.hoisted(() => vi.fn());
+const mockObjectAssign = vi.hoisted(() => vi.fn());
+const mockAppendSegmentToBuffer = vi.hoisted(() => vi.fn());
+
+vi.mock("../../../../../config", () => ({
+  default: {
+    getCurrent: mockGetCurrent,
+  },
+}));
+
+vi.mock("../../../../../utils/object_assign", () => ({
+  default: mockObjectAssign,
+}));
+
+vi.mock("../append_segment_to_buffer.ts", () => ({
+  default: mockAppendSegmentToBuffer,
+}));
+
+describe("pushMediaSegment", () => {
+  const mockPlaybackObserver = {} as any;
+  const mockBufferGoal = { getValue: () => 30 } as any;
+  const mockCancelSignal = {} as CancellationSignal;
+  const mockSegmentSink = {} as any;
+
+  const mockContent = {
+    adaptation: {} as any,
+    manifest: {} as any,
+    period: {} as any,
+    representation: {
+      getMimeTypeString: vi.fn(() => 'video/mp4; codecs="avc1.42E01E"'),
+    } as any,
+  };
+
+  const mockSegment = {
+    time: 10,
+    duration: 5,
+  } as any;
+
+  beforeEach(() => {
+    vi.resetAllMocks();
+    mockGetCurrent.mockReturnValue({
+      APPEND_WINDOW_SECURITIES: {
+        START: 0.1,
+        END: 0.2,
+      },
+    });
+    mockObjectAssign.mockImplementation((target, ...sources) =>
+      // eslint-disable-next-line no-restricted-properties
+      Object.assign(target, ...sources),
+    );
+  });
+
+  it("should return null when chunkData is null", async () => {
+    const parsedSegment: any = {
+      chunkData: null,
+      chunkInfos: null,
+      chunkOffset: 0,
+      chunkSize: 0,
+      appendWindow: [undefined, undefined] as [number | undefined, number | undefined],
+    };
+
+    const result = await pushMediaSegment(
+      {
+        playbackObserver: mockPlaybackObserver,
+        bufferGoal: mockBufferGoal,
+        content: mockContent,
+        initSegmentUniqueId: "init-123",
+        parsedSegment,
+        segment: mockSegment,
+        segmentSink: mockSegmentSink,
+      },
+      mockCancelSignal,
+    );
+
+    expect(result).toBeNull();
+    expect(mockAppendSegmentToBuffer).not.toHaveBeenCalled();
+  });
+
+  it("should append segment with basic data when chunkData is present", async () => {
+    const mockChunkData = new Uint8Array([1, 2, 3]);
+    const parsedSegment: any = {
+      chunkData: mockChunkData,
+      chunkInfos: null,
+      chunkOffset: 2.5,
+      chunkSize: 1024,
+      appendWindow: [undefined, undefined] as [number | undefined, number | undefined],
+    };
+
+    const mockBuffered = [{ start: 10, end: 15 }];
+    mockAppendSegmentToBuffer.mockResolvedValue(mockBuffered);
+
+    const result = await pushMediaSegment(
+      {
+        playbackObserver: mockPlaybackObserver,
+        bufferGoal: mockBufferGoal,
+        content: mockContent,
+        initSegmentUniqueId: "init-123",
+        parsedSegment,
+        segment: mockSegment,
+        segmentSink: mockSegmentSink,
+      },
+      mockCancelSignal,
+    );
+
+    expect(mockAppendSegmentToBuffer).toHaveBeenCalledWith(
+      mockPlaybackObserver,
+      mockSegmentSink,
+      {
+        data: {
+          initSegmentUniqueId: "init-123",
+          chunk: mockChunkData,
+          timestampOffset: 2.5,
+          appendWindow: [undefined, undefined],
+          codec: 'video/mp4; codecs="avc1.42E01E"',
+        },
+        inventoryInfos: expect.objectContaining({
+          segment: mockSegment,
+          chunkSize: 1024,
+          start: 10,
+          end: 15,
+        }),
+      },
+      mockBufferGoal,
+      mockCancelSignal,
+    );
+
+    expect(result).toEqual({
+      content: mockContent,
+      segment: mockSegment,
+      buffered: mockBuffered,
+    });
+  });
+
+  it("should use chunkInfos for time calculations when available", async () => {
+    const mockChunkData = new Uint8Array([1, 2, 3]);
+    const parsedSegment: any = {
+      chunkData: mockChunkData,
+      chunkInfos: { time: 20, duration: 8 },
+      chunkOffset: 0,
+      chunkSize: 2048,
+      appendWindow: [undefined, undefined] as [number | undefined, number | undefined],
+    };
+
+    mockAppendSegmentToBuffer.mockResolvedValue([]);
+
+    await pushMediaSegment(
+      {
+        playbackObserver: mockPlaybackObserver,
+        bufferGoal: mockBufferGoal,
+        content: mockContent,
+        initSegmentUniqueId: null,
+        parsedSegment,
+        segment: mockSegment,
+        segmentSink: mockSegmentSink,
+      },
+      mockCancelSignal,
+    );
+
+    expect(mockAppendSegmentToBuffer).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.anything(),
+      expect.objectContaining({
+        inventoryInfos: expect.objectContaining({
+          start: 20,
+          end: 28,
+        }),
+      }),
+      expect.anything(),
+      expect.anything(),
+    );
+  });
+
+  it("should apply append window securities to start window", async () => {
+    const mockChunkData = new Uint8Array([1, 2, 3]);
+    const parsedSegment: any = {
+      chunkData: mockChunkData,
+      chunkInfos: null,
+      chunkOffset: 0,
+      chunkSize: 1024,
+      appendWindow: [5, undefined] as [number | undefined, number | undefined],
+    };
+
+    mockAppendSegmentToBuffer.mockResolvedValue([]);
+
+    await pushMediaSegment(
+      {
+        playbackObserver: mockPlaybackObserver,
+        bufferGoal: mockBufferGoal,
+        content: mockContent,
+        initSegmentUniqueId: "init-123",
+        parsedSegment,
+        segment: mockSegment,
+        segmentSink: mockSegmentSink,
+      },
+      mockCancelSignal,
+    );
+
+    expect(mockAppendSegmentToBuffer).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.anything(),
+      expect.objectContaining({
+        data: expect.objectContaining({
+          appendWindow: [4.9, undefined], // 5 - 0.1
+        }),
+        inventoryInfos: expect.objectContaining({
+          start: 10, // max(10, 4.9)
+        }),
+      }),
+      expect.anything(),
+      expect.anything(),
+    );
+  });
+
+  it("should apply append window securities to end window", async () => {
+    const mockChunkData = new Uint8Array([1, 2, 3]);
+    const parsedSegment: any = {
+      chunkData: mockChunkData,
+      chunkInfos: null,
+      chunkOffset: 0,
+      chunkSize: 1024,
+      appendWindow: [undefined, 20] as [number | undefined, number | undefined],
+    };
+
+    mockAppendSegmentToBuffer.mockResolvedValue([]);
+
+    await pushMediaSegment(
+      {
+        playbackObserver: mockPlaybackObserver,
+        bufferGoal: mockBufferGoal,
+        content: mockContent,
+        initSegmentUniqueId: "init-123",
+        parsedSegment,
+        segment: mockSegment,
+        segmentSink: mockSegmentSink,
+      },
+      mockCancelSignal,
+    );
+
+    expect(mockAppendSegmentToBuffer).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.anything(),
+      expect.objectContaining({
+        data: expect.objectContaining({
+          appendWindow: [undefined, 20.2], // 20 + 0.2
+        }),
+        inventoryInfos: expect.objectContaining({
+          end: 15, // min(15, 20.2)
+        }),
+      }),
+      expect.anything(),
+      expect.anything(),
+    );
+  });
+
+  it("should apply both start and end append windows", async () => {
+    const mockChunkData = new Uint8Array([1, 2, 3]);
+    const parsedSegment: any = {
+      chunkData: mockChunkData,
+      chunkInfos: { time: 8, duration: 4 },
+      chunkOffset: 0,
+      chunkSize: 1024,
+      appendWindow: [9, 11] as [number | undefined, number | undefined],
+    };
+
+    mockAppendSegmentToBuffer.mockResolvedValue([]);
+
+    await pushMediaSegment(
+      {
+        playbackObserver: mockPlaybackObserver,
+        bufferGoal: mockBufferGoal,
+        content: mockContent,
+        initSegmentUniqueId: "init-123",
+        parsedSegment,
+        segment: mockSegment,
+        segmentSink: mockSegmentSink,
+      },
+      mockCancelSignal,
+    );
+
+    expect(mockAppendSegmentToBuffer).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.anything(),
+      expect.objectContaining({
+        data: expect.objectContaining({
+          appendWindow: [8.9, 11.2], // [9 - 0.1, 11 + 0.2]
+        }),
+        inventoryInfos: expect.objectContaining({
+          start: 8.9, // max(8, 8.9)
+          end: 11.2, // min(12, 11.2)
+        }),
+      }),
+      expect.anything(),
+      expect.anything(),
+    );
+  });
+
+  it("should not go below 0 for start append window", async () => {
+    const mockChunkData = new Uint8Array([1, 2, 3]);
+    const parsedSegment: any = {
+      chunkData: mockChunkData,
+      chunkInfos: null,
+      chunkOffset: 0,
+      chunkSize: 1024,
+      appendWindow: [0.05, undefined] as [number | undefined, number | undefined],
+    };
+
+    mockAppendSegmentToBuffer.mockResolvedValue([]);
+
+    await pushMediaSegment(
+      {
+        playbackObserver: mockPlaybackObserver,
+        bufferGoal: mockBufferGoal,
+        content: mockContent,
+        initSegmentUniqueId: "init-123",
+        parsedSegment,
+        segment: mockSegment,
+        segmentSink: mockSegmentSink,
+      },
+      mockCancelSignal,
+    );
+
+    expect(mockAppendSegmentToBuffer).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.anything(),
+      expect.objectContaining({
+        data: expect.objectContaining({
+          appendWindow: [0, undefined], // max(0, 0.05 - 0.1)
+        }),
+      }),
+      expect.anything(),
+      expect.anything(),
+    );
+  });
+});

package/src/core/stream/representation/utils/get_needed_segments.ts

@@ -326,7 +326,7 @@ function getAvailableBufferSize(
 /**
  * From the given array of buffered chunks (`bufferedSegments`) returns the last
  * buffered chunk contiguous with the one at the `startIndex` index given.
- * @param {Array.<Object>}
+ * @param {Array.<Object>} bufferedSegments
  * @param {number} startIndex
  * @returns {Object}
  */

package/src/default_config.ts

@@ -1333,6 +1333,12 @@ const DEFAULT_CONFIG = {
    * announcing the content as loaded.
    */
   FORCE_WAIT_FOR_HAVE_ENOUGH_DATA: false,
+
+  /**
+   * If `true`, forces an initial seek to 0. Mainly needed for Safari HLS,
+   * where the player may start at the live position instead of 0.
+   */
+  FORCE_INITIAL_SEEK_TO_ZERO: false,
 };
 
 export type IDefaultConfig = typeof DEFAULT_CONFIG;

package/src/experimental/features/worker/index.ts

@@ -1,5 +1,3 @@
-export { DASH, DASH_WASM } from "../../../features/list";
+export { DASH, DASH_WASM, SMOOTH } from "../../../features/list";
 export { LOCAL_MANIFEST } from "../local";
-
-// TODO: `SMOOTH` (has to be made worker-compatible)
-// TODO: `METAPLAYLIST` (once every transport is ported)
+export { METAPLAYLIST } from "../metaplaylist";

package/src/main_thread/api/public_api.ts

@@ -437,7 +437,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     // See: https://bugzilla.mozilla.org/show_bug.cgi?id=1194624
     videoElement.preload = "auto";
 
-    this.version = /* PLAYER_VERSION */ "4.5.0-dev.2026012302";
+    this.version = /* PLAYER_VERSION */ "4.5.0-dev.2026031700";
     this.log = log;
     this.state = "STOPPED";
     this.videoElement = videoElement;
@@ -2772,6 +2772,13 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     }
 
     if (this._priv_contentInfos.isDirectFile) {
+      if (this.videoElement === null) {
+        log.error("API", "getMinimumPosition() called on a disposed player");
+        return 0;
+      }
+      if (this.videoElement.seekable.length > 0) {
+        return this.videoElement.seekable.start(0);
+      }
       return 0;
     }
 
@@ -2818,8 +2825,14 @@ class Player extends EventEmitter<IPublicAPIEvent> {
 
     if (isDirectFile) {
       if (this.videoElement === null) {
-        throw new Error("Disposed player");
+        log.error("API", "getMaximumPosition() called on a disposed player");
+        return null;
       }
+
+      if (this.videoElement.seekable.length > 0) {
+        return this.videoElement.seekable.end(this.videoElement.seekable.length - 1);
+      }
+      // if for some reason seekable has no entry, fallback on duration
       return this.videoElement.duration;
     }
 
@@ -3526,6 +3539,22 @@ class Player extends EventEmitter<IPublicAPIEvent> {
       if (startDate !== undefined) {
         positionData.wallClockTime = startDate + observation.position.getPolled();
       }
+
+      let directFileMaximumPosition;
+      if (this.videoElement.seekable.length > 0) {
+        directFileMaximumPosition = this.videoElement.seekable.end(
+          this.videoElement.seekable.length - 1,
+        );
+      }
+
+      if (directFileMaximumPosition !== undefined && !isNaN(directFileMaximumPosition)) {
+        positionData.maximumPosition = directFileMaximumPosition;
+        // infinity duration means the content is live
+        if (this.videoElement.duration === Infinity) {
+          positionData.liveGap =
+            directFileMaximumPosition - this.videoElement.currentTime;
+        }
+      }
     }
     this.trigger("positionUpdate", positionData);
   }
@@ -3766,7 +3795,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
       // TODO: Make it work with multithread?
       return false;
     }
-    if (options.transport !== "dash" && options.transport !== "local") {
+    if (options.transport === "directfile") {
       return false;
     }
     if (
@@ -3802,7 +3831,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     return true;
   }
 }
-Player.version = /* PLAYER_VERSION */ "4.5.0-dev.2026012302";
+Player.version = /* PLAYER_VERSION */ "4.5.0-dev.2026031700";
 
 /** Every events sent by the RxPlayer's public API. */
 interface IPublicAPIEvent {

package/src/main_thread/init/directfile_content_initializer.ts

@@ -21,6 +21,7 @@
 
 import type { IMediaElement } from "../../compat/browser_compatibility_types";
 import clearElementSrc from "../../compat/clear_element_src";
+import getStartDate from "../../compat/get_start_date";
 import type { MediaError } from "../../errors";
 import log from "../../log";
 import type { IMediaElementPlaybackObserver } from "../../playback_observer";
@@ -307,7 +308,31 @@ function getDirectFileInitialTime(
   if (!isNullOrUndefined(startAt.position)) {
     return startAt.position;
   } else if (!isNullOrUndefined(startAt.wallClockTime)) {
-    return startAt.wallClockTime;
+    /**
+     * Special case for Safari with HLS in directfile mode:
+     *
+     * Safari's native HLS implementation uses `#EXT-X-PROGRAM-DATE-TIME` from the manifest
+     * as the time reference. This means `mediaElement.currentTime` represents time relative
+     * to the playlist's start date.
+     *
+     * When seeking to a specific `wallClockTime`, we calculate the position by subtracting
+     * the playlist's start date from `startPosition.wallClockTime`:
+     *   seekPosition = wallClockTime - startDate
+     *
+     * The startDate is retrieved via `mediaElement.getStartDate()`, which only returns
+     * a valid date once `mediaElement.readyState >= HAVE_CURRENT_DATA` (≥ 2).
+     * If unavailable, we return undefined.
+     */
+    const startDate = getStartDate(mediaElement);
+    if (startDate === undefined) {
+      log.warn(
+        "Init",
+        "startAt.wallClockTime set but startDate is not known, either it's too soon to seek" +
+          " or the browser has no API to get the startDate",
+      );
+      return undefined;
+    }
+    return startAt.wallClockTime - startDate;
   } else if (!isNullOrUndefined(startAt.fromFirstPosition)) {
     return startAt.fromFirstPosition;
   }