rx-player 4.2.0-dev.2024090600 → 4.2.0-dev.2024091600

package/src/core/cmcd/cmcd_data_builder.ts

@@ -16,6 +16,7 @@ import createUuid from "../../utils/create_uuid";
 import isNullOrUndefined from "../../utils/is_null_or_undefined";
 import type { IRange } from "../../utils/ranges";
 import TaskCanceller from "../../utils/task_canceller";
+import { getRelativeUrl } from "../../utils/url-utils";
 
 /**
  * `rtp`, for "REQUESTED_MAXIMUM_THROUGHPUT", indicates the maximum throughput
@@ -44,6 +45,18 @@ export interface ICmcdSegmentInfo {
   representation: IRepresentation;
   /** Segment metadata linked to the wanted segment. */
   segment: ISegment;
+  /**
+   * Optional next segment that may be requested after this one.
+   * Should only be set (to something else than `undefined`) if that following
+   * segment is part of the same `Representation`.
+   *
+   * This information is used to produce the "next object request" and "next
+   * range request" part of the CMCD payload, used for segment prefetching.
+   *
+   * If `null` no segment will be requested next for now.
+   * If `undefined` we do not know which next segment will be requested.
+   */
+  nextSegment: ISegment | null | undefined;
 }
 
 /**
@@ -221,7 +234,6 @@ export default class CmcdDataBuilder {
     const props = this._getCommonCmcdData(this._lastThroughput[content.adaptation.type]);
     props.br = Math.round(content.representation.bitrate / 1000);
     props.d = Math.round(content.segment.duration * 1000);
-    // TODO nor (next object request) and nrr (next range request)
 
     switch (content.adaptation.type) {
       case "video":
@@ -238,6 +250,33 @@ export default class CmcdDataBuilder {
       props.ot = "i";
     }
 
+    if (
+      !isNullOrUndefined(content.nextSegment) &&
+      content.segment.url !== null &&
+      content.nextSegment.url !== null
+    ) {
+      // We add a special case for some initialization segment which need
+      // multiple byte-ranges to fully request, as the `CmcdDataBuilder`
+      // is not supposed to keep track of how the requesting part of the
+      // RxPlayer actually perform its multi-byte-range requests
+      if (!content.nextSegment.isInit || content.nextSegment.indexRange === undefined) {
+        const currSegmentUrl = content.segment.url;
+        const nextSegmentUrl = content.nextSegment.url;
+        const relativeUrl = getRelativeUrl(currSegmentUrl, nextSegmentUrl);
+        if (relativeUrl !== null) {
+          if (relativeUrl !== ".") {
+            props.nor = encodeURIComponent(relativeUrl);
+          }
+          if (content.nextSegment.range !== undefined) {
+            props.nrr = String(content.nextSegment.range[0]) + "-";
+            if (isFinite(content.nextSegment.range[1])) {
+              props.nrr += String(content.nextSegment.range[1]);
+            }
+          }
+        }
+      }
+    }
+
     let precizeBufferLengthMs;
     if (
       lastObservation !== undefined &&
@@ -355,7 +394,7 @@ export default class CmcdDataBuilder {
     };
 
     const addStringProperty = (
-      prop: "cid" | "sid",
+      prop: "cid" | "sid" | "nor" | "nrr",
       headerName: keyof typeof headers,
     ): void => {
       const val = props[prop];
@@ -384,6 +423,8 @@ export default class CmcdDataBuilder {
     addNumberProperty("d", "object");
     addNumberProperty("dl", "request");
     addNumberProperty("mtp", "request");
+    addStringProperty("nor", "request");
+    addStringProperty("nrr", "request");
     addTokenProperty("ot", "object");
     addNumberProperty("pr", "session");
     addNumberProperty("rtp", "status");
@@ -518,6 +559,31 @@ interface ICmcdProperties {
    * In kbps.
    */
   mtp?: number | undefined;
+  /**
+   * Next Object Request (nor)
+   * Relative path of the next object to be requested.
+   * This can be used to trigger pre-fetching by the CDN.
+   * This MUST be a path relative to the current request.
+   * This string MUST be URLEncoded.
+   * The client SHOULD NOT depend upon any pre-fetch action being taken - it is
+   * merely a request for such a pre-fetch to take place.
+   */
+  nor?: string | undefined;
+  /**
+   * Next Range Request (nrr)
+   * If the next request will be a partial object request, then this string
+   * denotes the byte range to be requested. If the ‘nor’ field is not set, then
+   * the object is assumed to match the object currently being requested.
+   * The client SHOULD NOT depend upon any pre-fetch action being taken – it is
+   * merely a request for such a pre-fetch to take place. Formatting is similar
+   * to the HTTP Range header, except that the unit MUST be ‘byte’, the ‘Range:’
+   * prefix is NOT required and specifying multiple ranges is NOT allowed.
+   * Valid combinations are:
+   * "<range-start>-"
+   * "<range-start>-<range-end>"
+   * "-<suffix-length>"
+   */
+  nrr?: string | undefined;
   /**
    * Object type (ot)
    * The media type of the current object being requested:

package/src/core/fetchers/segment/segment_fetcher.ts

@@ -427,11 +427,35 @@ export interface ISegmentFetcherCallbacks<TSegmentDataType> {
 
 /** Content used by the segment loader as a context to load a new segment. */
 export interface ISegmentLoaderContent {
+  /** Manifest metadata linked to the wanted segment. */
   manifest: IManifest;
+  /** Period metadata linked to the wanted segment. */
   period: IPeriod;
+  /** Adaptation metadata linked to the wanted segment. */
   adaptation: IAdaptation;
+  /** Representation metadata linked to the wanted segment. */
   representation: IRepresentation;
+  /** Segment metadata linked to the wanted segment. */
   segment: ISegment;
+  /**
+   * Optional next segment that may be requested after this one.
+   * Should only be set (to something else than `undefined`) if that following
+   * segment is part of the same `Representation`.
+   *
+   * This is only used as an hint, finally requesting another segment after this
+   * one due to unexpected changes (e.g. bandwidth update, track change etc.) is
+   * OK.
+   *
+   * This information is then used mostly for matters related yet not required
+   * by requests, such as CMCD reporting. In scenarios when it's not
+   * straightforward to guess which segment will be requested after this one,
+   * this property can be ignored (set to `undefined`).
+   *
+   * If `null` no segment will be requested next for now.
+   *
+   * If `undefined` we do not know which next segment will be requested.
+   */
+  nextSegment: ISegment | null | undefined;
 }
 
 /**

package/src/core/fetchers/segment/segment_queue.ts

@@ -255,11 +255,10 @@ export default class SegmentQueue<T> extends EventEmitter<ISegmentQueueEvent<T>>
     }
 
     const { downloadQueue, content, initSegmentInfoRef, currentCanceller } = contentInfo;
-    const { segmentQueue } = downloadQueue.getValue();
-    const currentNeededSegment = segmentQueue[0];
-    const recursivelyRequestSegments = (
-      startingSegment: IQueuedSegment | undefined,
-    ): void => {
+
+    const recursivelyRequestSegments = (): void => {
+      const { segmentQueue } = downloadQueue.getValue();
+      const startingSegment = segmentQueue[0];
       if (currentCanceller !== null && currentCanceller.isUsed()) {
         contentInfo.mediaSegmentRequest = null;
         return;
@@ -276,7 +275,10 @@ export default class SegmentQueue<T> extends EventEmitter<ISegmentQueueEvent<T>>
           : canceller.linkToSignal(currentCanceller.signal);
 
       const { segment, priority } = startingSegment;
-      const context = objectAssign({ segment }, content);
+      const context = objectAssign(
+        { segment, nextSegment: segmentQueue[1]?.segment },
+        content,
+      );
 
       /**
        * If `true` , the current task has either errored, finished, or was
@@ -318,7 +320,7 @@ export default class SegmentQueue<T> extends EventEmitter<ISegmentQueueEvent<T>>
           lastQueue.shift();
         }
         isComplete = true;
-        recursivelyRequestSegments(lastQueue[0]);
+        recursivelyRequestSegments();
       };
 
       /** Scheduled actual segment request. */
@@ -422,7 +424,7 @@ export default class SegmentQueue<T> extends EventEmitter<ISegmentQueueEvent<T>>
 
       contentInfo.mediaSegmentRequest = { segment, priority, request, canceller };
     };
-    recursivelyRequestSegments(currentNeededSegment);
+    recursivelyRequestSegments();
   }
 
   /**
@@ -449,7 +451,7 @@ export default class SegmentQueue<T> extends EventEmitter<ISegmentQueueEvent<T>>
         ? noop
         : canceller.linkToSignal(contentInfo.currentCanceller.signal);
     const { segment, priority } = queuedInitSegment;
-    const context = objectAssign({ segment }, content);
+    const context = objectAssign({ segment, nextSegment: undefined }, content);
 
     /**
      * If `true` , the current task has either errored, finished, or was

package/src/experimental/tools/VideoThumbnailLoader/video_thumbnail_loader.ts

@@ -207,7 +207,10 @@ export default class VideoThumbnailLoader {
           lastRepInfo.initSegmentUniqueId = null;
           return sourceBufferInterface;
         }
-        const segmentInfo = objectAssign({ segment: initSegment }, content);
+        const segmentInfo = objectAssign(
+          { segment: initSegment, nextSegment: undefined },
+          content,
+        );
         await loadAndPushSegment(
           segmentInfo,
           sourceBufferInterface,
@@ -272,7 +275,10 @@ export default class VideoThumbnailLoader {
             const unlinkSignal = requestCanceller.linkToSignal(
               lastRepInfo.cleaner.signal,
             );
-            const segmentInfo = objectAssign({ segment }, content);
+            const segmentInfo = objectAssign(
+              { segment, nextSegment: undefined },
+              content,
+            );
             const prom = loadAndPushSegment(
               segmentInfo,
               sourceBufferInterface,

package/src/main_thread/api/public_api.ts

@@ -409,7 +409,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     // See: https://bugzilla.mozilla.org/show_bug.cgi?id=1194624
     videoElement.preload = "auto";
 
-    this.version = /* PLAYER_VERSION */ "4.2.0-dev.2024090600";
+    this.version = /* PLAYER_VERSION */ "4.2.0-dev.2024091600";
     this.log = log;
     this.state = "STOPPED";
     this.videoElement = videoElement;
@@ -3313,7 +3313,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     }
   }
 }
-Player.version = /* PLAYER_VERSION */ "4.2.0-dev.2024090600";
+Player.version = /* PLAYER_VERSION */ "4.2.0-dev.2024091600";
 
 /** Every events sent by the RxPlayer's public API. */
 interface IPublicAPIEvent {

package/src/parsers/manifest/dash/common/parse_mpd.ts

@@ -20,7 +20,7 @@ import type { IManifest } from "../../../../manifest";
 import arrayFind from "../../../../utils/array_find";
 import isNullOrUndefined from "../../../../utils/is_null_or_undefined";
 import getMonotonicTimeStamp from "../../../../utils/monotonic_timestamp";
-import { getFilenameIndexInUrl } from "../../../../utils/resolve_url";
+import { getFilenameIndexInUrl } from "../../../../utils/url-utils";
 import type { IParsedManifest } from "../../types";
 import type {
   IMPDIntermediateRepresentation,

package/src/parsers/manifest/dash/common/resolve_base_urls.ts

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-import resolveURL from "../../../../utils/resolve_url";
+import { resolveURL } from "../../../../utils/url-utils";
 import type { IBaseUrlIntermediateRepresentation } from "../node_parser_types";
 
 export interface IResolvedBaseUrl {

package/src/parsers/manifest/dash/wasm-parser/rs/events.rs

@@ -86,6 +86,9 @@ pub enum TagName {
     // -- Inside a <SegmentList> --
     /// Indicate a <SegmentURL> node
     SegmentUrl = 20,
+
+    /// Indicate a <Label> node
+    Label = 21,
 }
 
 #[derive(PartialEq, Clone, Copy)]
@@ -276,8 +279,6 @@ pub enum AttributeName {
     /// namespaces that will appear in it.
     Namespace = 70,
 
-    Label = 71, // String
-
     ServiceLocation = 72, // String
 
     // SegmentTemplate

package/src/parsers/manifest/dash/wasm-parser/rs/processor/mod.rs

@@ -114,7 +114,10 @@ impl MPDProcessor {
                     }
                     b"cenc:pssh" => self.process_cenc_element(),
                     b"Location" => self.process_location_element(),
-                    b"Label" => self.process_label_element(),
+                    b"Label" => {
+                        TagName::Label.report_tag_open();
+                        self.process_label_element();
+                    }
                     b"SegmentTimeline" => self.process_segment_timeline_element(),
 
                     b"EventStream" => {
@@ -274,7 +277,7 @@ impl MPDProcessor {
                 Ok(Event::Text(t)) => {
                     if t.len() > 0 {
                         match t.unescape() {
-                            Ok(unescaped) => AttributeName::Label.report(unescaped),
+                            Ok(unescaped) => AttributeName::Text.report(unescaped),
                             Err(err) => ParsingError::from(err).report_err(),
                         }
                     }
@@ -284,6 +287,7 @@ impl MPDProcessor {
                     if inner_tag > 0 {
                         inner_tag -= 1;
                     } else {
+                        TagName::Label.report_tag_close();
                         break;
                     }
                 }

package/src/parsers/manifest/dash/wasm-parser/ts/generators/AdaptationSet.ts

@@ -27,6 +27,7 @@ import { parseFloatOrBool, parseString } from "../utils";
 import { generateBaseUrlAttrParser } from "./BaseURL";
 import { generateContentComponentAttrParser } from "./ContentComponent";
 import { generateContentProtectionAttrParser } from "./ContentProtection";
+import { generateLabelElementParser } from "./Label";
 import {
   generateRepresentationAttrParser,
   generateRepresentationChildrenParser,
@@ -209,6 +210,15 @@ export function generateAdaptationSetChildrenParser(
         break;
       }
 
+      case TagName.Label: {
+        parsersStack.pushParsers(
+          nodeId,
+          noop, // Label as treated like an attribute
+          generateLabelElementParser(adaptationSetChildren, linearMemory),
+        );
+        break;
+      }
+
       default:
         // Allows to make sure we're not mistakenly closing a re-opened
         // tag.
@@ -363,11 +373,6 @@ export function generateAdaptationSetAttrParser(
       case AttributeName.AvailabilityTimeComplete:
         adaptationAttrs.availabilityTimeComplete = dataView.getUint8(0) === 0;
         break;
-      case AttributeName.Label: {
-        const label = parseString(textDecoder, linearMemory.buffer, ptr, len);
-        adaptationAttrs.label = label;
-        break;
-      }
 
       // TODO
       // case AttributeName.StartsWithSap:

package/src/parsers/manifest/dash/wasm-parser/ts/generators/Label.ts

@@ -0,0 +1,16 @@
+import type { IAdaptationSetChildren } from "../../../node_parser_types";
+import type { IAttributeParser } from "../parsers_stack";
+import { AttributeName } from "../types";
+import { parseString } from "../utils";
+
+export function generateLabelElementParser(
+  adaptationSet: IAdaptationSetChildren,
+  linearMemory: WebAssembly.Memory,
+): IAttributeParser {
+  const textDecoder = new TextDecoder();
+  return function onMPDAttribute(attr: AttributeName, ptr: number, len: number) {
+    if (attr === AttributeName.Text) {
+      adaptationSet.label = parseString(textDecoder, linearMemory.buffer, ptr, len);
+    }
+  };
+}

package/src/parsers/manifest/dash/wasm-parser/ts/types.ts

@@ -108,6 +108,9 @@ export const enum TagName {
 
   /// Indicate a <SegmentURL> node
   SegmentUrl = 20,
+
+  /// Indicate a <Label> node
+  Label = 21,
 }
 
 /**

package/src/parsers/manifest/metaplaylist/metaplaylist_parser.ts

@@ -22,7 +22,7 @@ import type { ITrackType } from "../../../public_types";
 import idGenerator from "../../../utils/id_generator";
 import isNullOrUndefined from "../../../utils/is_null_or_undefined";
 import getMonotonicTimeStamp from "../../../utils/monotonic_timestamp";
-import { getFilenameIndexInUrl } from "../../../utils/resolve_url";
+import { getFilenameIndexInUrl } from "../../../utils/url-utils";
 import type {
   IParsedAdaptation,
   IParsedAdaptations,

package/src/parsers/manifest/smooth/create_parser.ts

@@ -23,8 +23,8 @@ import isNonEmptyString from "../../../utils/is_non_empty_string";
 import isNullOrUndefined from "../../../utils/is_null_or_undefined";
 import getMonotonicTimeStamp from "../../../utils/monotonic_timestamp";
 import objectAssign from "../../../utils/object_assign";
-import { getFilenameIndexInUrl } from "../../../utils/resolve_url";
 import { hexToBytes } from "../../../utils/string_parsing";
+import { getFilenameIndexInUrl } from "../../../utils/url-utils";
 import { createBox } from "../../containers/isobmff";
 import type {
   IParsedAdaptation,

package/src/transports/dash/construct_segment_url.ts

@@ -16,7 +16,7 @@
 
 import type { ISegment } from "../../manifest";
 import type { ICdnMetadata } from "../../parsers/manifest";
-import resolveURL from "../../utils/resolve_url";
+import { resolveURL } from "../../utils/url-utils";
 
 export default function constructSegmentUrl(
   wantedCdn: ICdnMetadata | null,

package/src/transports/smooth/utils.ts

@@ -16,7 +16,7 @@
 
 import type { ISegment, IRepresentation } from "../../manifest";
 import type { ICdnMetadata } from "../../parsers/manifest";
-import resolveURL from "../../utils/resolve_url";
+import { resolveURL } from "../../utils/url-utils";
 
 /**
  * Returns `true` if the given Representation refers to segments in an MP4

package/src/utils/__tests__/{resolve_url.test.ts → url-utils.test.ts}

@@ -1,5 +1,5 @@
 import { describe, it, expect } from "vitest";
-import resolveURL, { getFilenameIndexInUrl } from "../resolve_url";
+import { getFilenameIndexInUrl, getRelativeUrl, resolveURL } from "../url-utils";
 
 describe(`utils - resolveURL ${resolveURL.name}`, () => {
   it("should return an empty string if no argument is given", () => {
@@ -155,3 +155,150 @@ describe("utils - getFilenameIndexInUrl", () => {
     expect(getFilenameIndexInUrl("https://ww/rr/d/?test/toto/efewf/ffe/")).toEqual(16);
   });
 });
+
+describe("utils - getRelativeUrl", () => {
+  it("should succeed on two absolute URLs on the same domain", () => {
+    expect(
+      getRelativeUrl("https://foo.com/foo/bar/cil/", "https://foo.com/foo/bar/cil/diub"),
+    ).toEqual("diub");
+    expect(
+      getRelativeUrl(
+        "https://foo.com/foo/bar/cil/",
+        "https://foo.com/foo/bar/cil/diub/emp",
+      ),
+    ).toEqual("diub/emp");
+    expect(
+      getRelativeUrl(
+        "https://foo.com/foo/bar/cil/diub/emp/",
+        "https://foo.com/foo/bar/cil/f/g/h/i",
+      ),
+    ).toEqual("../../f/g/h/i");
+
+    expect(
+      getRelativeUrl(
+        "https://foo.com/foo/bar/cil/emp",
+        "https://foo.com/foo/bar/cil/emp",
+      ),
+    ).toEqual("");
+  });
+
+  it("should handle it right when one of the input is just a domain name without a path", () => {
+    expect(
+      getRelativeUrl(
+        "http://github.com" /** Without a starting slash */,
+        "http://github.com/rx-player",
+      ),
+    ).toBe("/rx-player");
+    expect(
+      getRelativeUrl(
+        "http://github.com/rx-player/",
+        "http://github.com" /** Without a starting slash */,
+      ),
+    ).toBe("..");
+  });
+
+  it("should handle it right when one of the input has a path of length 0", () => {
+    expect(getRelativeUrl("http://github.com/", "http://github.com/rx-player")).toBe(
+      "rx-player",
+    );
+    expect(
+      getRelativeUrl(
+        "http://github.com/rx-player/",
+        "http://github.com" /** Without a starting slash */,
+      ),
+    ).toBe("..");
+  });
+
+  it("should fail if scheme is different", () => {
+    expect(
+      getRelativeUrl("http://foo.com/foo/bar/cil/emp", "https://foo.com/foo/bar/cil/emp"),
+    ).toEqual(null);
+
+    expect(
+      getRelativeUrl("https://foo.com/foo/bar/cil/emp", "http://foo.com/foo/bar/cil/emp"),
+    ).toEqual(null);
+  });
+
+  it("should fail if domain is different", () => {
+    expect(
+      getRelativeUrl(
+        "https://bar.com/foo/bar/cil/emp",
+        "https://foo.com/foo/bar/cil/emp",
+      ),
+    ).toEqual(null);
+  });
+
+  it("should fail if one anounce a domain but not the other", () => {
+    expect(getRelativeUrl("https://foo.com/foo/bar/cil/diub/emp", "/a")).toEqual(null);
+
+    expect(getRelativeUrl("../url", "https://foo.com")).toEqual(null);
+  });
+
+  it('should output "." if the URL points to the same file', () => {
+    expect(getRelativeUrl("../url", "../url")).toEqual("");
+    expect(
+      getRelativeUrl(
+        "https://foo.com/foo/bar/cil/diub/emp",
+        "https://foo.com/foo/bar/cil/diub/emp",
+      ),
+    ).toEqual("");
+    expect(
+      getRelativeUrl(
+        "https://foo.com/foo/bar/cil/diub/emp",
+        "https://foo.com/foo/bar/../bar/cil/diub/emp",
+      ),
+    ).toEqual("");
+  });
+
+  it("should succeed on two relative URLs", () => {
+    expect(getRelativeUrl("../url/a", "../url/a/b")).toEqual("a/b");
+    expect(getRelativeUrl("../url/a", "../url/b/c")).toEqual("b/c");
+  });
+
+  it("should fail if one seems to be relative to the domain's root, yet we don't know it", () => {
+    expect(getRelativeUrl("/url/a", "../../../url/b/c")).toEqual(null);
+    expect(getRelativeUrl("./url/a", "/url/b/c")).toEqual(null);
+    expect(getRelativeUrl("http://foo.com/url/a", "../url/b/c")).toEqual(null);
+  });
+
+  it("should succeed if both seem to be relative to the domain's root, even if we don't know it", () => {
+    expect(getRelativeUrl("/url/a", "/url/b/c")).toEqual("b/c");
+  });
+
+  const normalExamples = [
+    { input: "http://a/b/c/g", output: "g" },
+    { input: "http://a/b/c/g/", output: "g/" },
+    { input: "http://a/g", output: "../../g" },
+    { input: "http://a/b/c/d;p?y", output: "?y" },
+    { input: "http://a/b/c/g?y", output: "g?y" },
+    { input: "http://a/b/c/d;p?q#s", output: "#s" },
+    { input: "http://a/b/c/g#s", output: "g#s" },
+    { input: "http://a/b/c/g?y#s", output: "g?y#s" },
+    { input: "http://a/b/c/;x", output: ";x" },
+    { input: "http://a/b/c/g;x", output: "g;x" },
+    { input: "http://a/b/c/g;x?y#s", output: "g;x?y#s" },
+    { input: "http://a/b/c/d;p?q", output: "" },
+    { input: "http://a/b/c/", output: "." },
+    { input: "http://a/b/", output: ".." },
+    { input: "http://a/b/g", output: "../g" },
+    { input: "http://a/", output: "../.." },
+    { input: "http://a/g", output: "../../g" },
+  ];
+  normalExamples.forEach((example) => {
+    it("should conform to RFC 3986 normal examples - case: " + example.input, () => {
+      const baseURL: string = "http://a/b/c/d;p?q";
+      // https://datatracker.ietf.org/doc/html/rfc3986#section-5.4.1
+      expect(getRelativeUrl(baseURL, example.input)).toBe(example.output);
+    });
+  });
+
+  it("should succeed on two relative URLs", () => {
+    expect(getRelativeUrl("../url/a", "../url/a/b")).toEqual("a/b");
+    expect(getRelativeUrl("../url/a", "../url/b/c")).toEqual("b/c");
+  });
+
+  it("should return null if the relation between the two URLs is unclear", () => {
+    expect(getRelativeUrl("/url/a", "url/a/b")).toEqual(null);
+    expect(getRelativeUrl("url/a", "/url/a/b")).toEqual(null);
+  });
+});