rx-player 3.33.0 → 3.33.1

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

@@ -1,292 +0,0 @@
-import Manifest, {
-  Adaptation,
-  ISegment,
-  Period,
-  Representation,
-} from "../../../manifest";
-import { IEMSG } from "../../../parsers/containers/isobmff";
-import { IPlayerError } from "../../../public_types";
-import { IReadOnlySharedReference } from "../../../utils/reference";
-import { IReadOnlyPlaybackObserver } from "../../api";
-import { IContentProtection } from "../../decrypt";
-import { IPrioritizedSegmentFetcher } from "../../fetchers";
-import {
-  IBufferType,
-  SegmentBuffer,
-} from "../../segment_buffers";
-
-/** Callbacks called by the `RepresentationStream` on various events. */
-export interface IRepresentationStreamCallbacks<TSegmentDataType> {
-  /**
-   * Called to announce the current status regarding the buffer for its
-   * associated Period and type (e.g. "audio", "video", "text" etc.).
-   *
-   * Each new `IStreamStatusPayload` event replace the precedent one for the
-   * same Period and type.
-   */
-  streamStatusUpdate(payload : IStreamStatusPayload) : void;
-  /** Called after a new segment has been succesfully added to the SegmentBuffer */
-  addedSegment(payload : IStreamEventAddedSegmentPayload<TSegmentDataType>) : void;
-  /** Called when a segment with protection information has been encountered. */
-  encryptionDataEncountered(payload : IContentProtection[]) : void;
-  /**
-   * Called when the Manifest is possibly out-of-sync and needs to be refreshed
-   * completely.
-   *
-   * The Stream made that guess because a segment that should have been available
-   * is not and because it suspects this is due to a synchronization problem.
-   */
-  manifestMightBeOufOfSync() : void;
-  /**
-   * Callback called when a `RepresentationStream` is being terminated:
-   *
-   *   - it has finished all its segment requests and won't do new ones.
-   *
-   *   - it has stopped regularly checking for its current status.
-   *
-   *   - it only waits until all the segments it has loaded have been pushed to the
-   *     SegmentBuffer before actually stopping everything it does.
-   *
-   * You can use this call as a hint that a new `RepresentationStream` can be
-   * created for the same `Period` and type (e.g. to switch quality).
-   */
-  terminating() : void;
-  /**
-   * Called when the Manifest needs to be refreshed.
-   * Note that segment might still be loaded and pushed even after calling
-   * this callback.
-   */
-  needsManifestRefresh() : void;
-  /**
-   * Called when an "inband" event, as found in a media segment, has been
-   * encountered.
-   */
-  inbandEvent(payload : IInbandEvent[]) : void;
-  /**
-   * Called when a minor error has been encountered, that does not interrupt
-   * the segment loading and pushing operations.
-   */
-  warning(payload : IPlayerError) : void;
-  /**
-   * Called when a fatal error has been encountered.
-   * Such errors have led to all the Stream's operations to be stopped.
-   */
-  error(payload : unknown) : void;
-}
-
-/** Payload for the `streamStatusUpdate` callback. */
-export interface IStreamStatusPayload {
-  /** Period concerned. */
-  period : Period;
-  /** Buffer type concerned. */
-  bufferType : IBufferType;
-  /**
-   * Present or future "hole" in the SegmentBuffer's buffer that will not be
-   * filled by a segment, despite being part of the time period indicated by
-   * the associated Period.
-   *
-   * This value is set to the most imminent of such "discontinuity", which
-   * can be either:
-   *
-   *   - current (no segment available at `position` but future segments are
-   *     available), in which case this discontinuity's true beginning might
-   *     be unknown.
-   *
-   *   - a future hole between two segments in that Period.
-   *
-   *   - missing media data at the end of the time period associated to that
-   *     Period.
-   *
-   * The presence or absence of a discontinuity can evolve during playback
-   * (because new tracks or qualities might not have the same ones).
-   * As such, it is advised to only consider the last discontinuity sent
-   * through a `"stream-status"` event.
-   */
-  imminentDiscontinuity : IBufferDiscontinuity | null;
-  /**
-   * If `true`, no segment are left to be loaded to be able to play until the
-   * end of the Period.
-   */
-  hasFinishedLoading : boolean;
-  /**
-   * If `true`, this stream is a placeholder stream which will never load any
-   * segment.
-   */
-  isEmptyStream : boolean;
-  /**
-   * Segments that will be scheduled for download to fill the buffer until
-   * the buffer goal (first element of that list might already be loading).
-   */
-  neededSegments : IQueuedSegment[];
-  /** Position in the content in seconds from which this status was done.  */
-  position : number;
-}
-
-/** Payload for the `addedSegment` callback. */
-export interface IStreamEventAddedSegmentPayload<T> {
-  /** Context about the content that has been added. */
-  content: { period : Period;
-             adaptation : Adaptation;
-             representation : Representation; };
-  /** The concerned Segment. */
-  segment : ISegment;
-  /** TimeRanges of the concerned SegmentBuffer after the segment was pushed. */
-  buffered : TimeRanges;
-  /* The data pushed */
-  segmentData : T;
-}
-
-/** Structure describing an "inband" event, as found in a media segment. */
-export interface IInbandEvent {
-  /** Type when the event was foud inside a "emsg` ISOBMFF box */
-  type: "emsg";
-  /** Value when the event was foud inside a "emsg` ISOBMFF box */
-  value: IEMSG;
-}
-
-/** Information about a Segment waiting to be loaded by the Stream. */
-export interface IQueuedSegment {
-  /** Priority of the segment request (lower number = higher priority). */
-  priority : number;
-  /** Segment wanted. */
-  segment : ISegment;
-}
-
-/** Describe an encountered hole in the buffer, called a "discontinuity". */
-export interface IBufferDiscontinuity {
-  /**
-   * Start time, in seconds, at which the discontinuity starts.
-   *
-   * if set to `undefined`, its true start time is unknown but the current
-   * position is part of it.  It is thus a discontinuity that is currently
-   * encountered.
-   */
-  start : number | undefined;
-  /**
-   * End time, in seconds at which the discontinuity ends (and thus where
-   * new segments are encountered).
-   *
-   * If `null`, no new media segment is available for that Period and
-   * buffer type until the end of the Period.
-   */
-  end : number | null;
-}
-
-/** Object that should be emitted by the given `IReadOnlyPlaybackObserver`. */
-export interface IRepresentationStreamPlaybackObservation {
-  /**
-   * Information on the current media position in seconds at the time of a
-   * Playback Observation.
-   */
-  position : IPositionPlaybackObservation;
-}
-
-/** Position-related information linked to an emitted Playback observation. */
-export interface IPositionPlaybackObservation {
-  /**
-   * Known position at the time the Observation was emitted, in seconds.
-   *
-   * Note that it might have changed since. If you want truly precize
-   * information, you should recuperate it from the HTMLMediaElement directly
-   * through another mean.
-   */
-  last : number;
-  /**
-   * Actually wanted position in seconds that is not yet reached.
-   *
-   * This might for example be set to the initial position when the content is
-   * loading (and thus potentially at a `0` position) but which will be seeked
-   * to a given position once possible.
-   */
-  pending : number | undefined;
-}
-
-/** Item emitted by the `terminate` reference given to a RepresentationStream. */
-export interface ITerminationOrder {
-  /*
-   * If `true`, the RepresentationStream should interrupt immediately every long
-   * pending operations such as segment downloads.
-   * If it is set to `false`, it can continue until those operations are
-   * finished.
-   */
-  urgent : boolean;
-}
-
-/** Arguments to give to the RepresentationStream. */
-export interface IRepresentationStreamArguments<TSegmentDataType> {
-  /** The context of the Representation you want to load. */
-  content: { adaptation : Adaptation;
-             manifest : Manifest;
-             period : Period;
-             representation : Representation; };
-  /** The `SegmentBuffer` on which segments will be pushed. */
-  segmentBuffer : SegmentBuffer;
-  /** Interface used to load new segments. */
-  segmentFetcher : IPrioritizedSegmentFetcher<TSegmentDataType>;
-  /**
-   * Reference emitting when the RepresentationStream should "terminate".
-   *
-   * When this Reference emits an object, the RepresentationStream will begin a
-   * "termination process": it will, depending on the type of termination
-   * wanted, either stop immediately pending segment requests or wait until they
-   * are finished before fully terminating (calling the `terminating` callback
-   * and stopping all `RepresentationStream` current tasks).
-   */
-  terminate : IReadOnlySharedReference<null | ITerminationOrder>;
-  /** Periodically emits the current playback conditions. */
-  playbackObserver : IReadOnlyPlaybackObserver<IRepresentationStreamPlaybackObservation>;
-  /** Supplementary arguments which configure the RepresentationStream's behavior. */
-  options: IRepresentationStreamOptions;
-}
-
-
-/**
- * Various specific stream "options" which tweak the behavior of the
- * RepresentationStream.
- */
-export interface IRepresentationStreamOptions {
-  /**
-   * The buffer size we have to reach in seconds (compared to the current
-   * position. When that size is reached, no segments will be loaded until it
-   * goes below that size again.
-   */
-  bufferGoal : IReadOnlySharedReference<number>;
-
-  /**
-   *  The buffer size limit in memory that we can reach.
-   *  Once reached, no segments will be loaded until it
-   *  goes below that size again
-   */
-  maxBufferSize : IReadOnlySharedReference<number>;
-
-  /**
-   * Hex-encoded DRM "system ID" as found in:
-   * https://dashif.org/identifiers/content_protection/
-   *
-   * Allows to identify which DRM system is currently used, to allow potential
-   * optimizations.
-   *
-   * Set to `undefined` in two cases:
-   *   - no DRM system is used (e.g. the content is unencrypted).
-   *   - We don't know which DRM system is currently used.
-   */
-  drmSystemId : string | undefined;
-  /**
-   * Bitrate threshold from which no "fast-switching" should occur on a segment.
-   *
-   * Fast-switching is an optimization allowing to replace segments from a
-   * low-bitrate Representation by segments from a higher-bitrate
-   * Representation. This allows the user to see/hear an improvement in quality
-   * faster, hence "fast-switching".
-   *
-   * This Reference allows to limit this behavior to only allow the replacement
-   * of segments with a bitrate lower than a specific value - the number emitted
-   * by that Reference.
-   *
-   * If set to `undefined`, no threshold is active and any segment can be
-   * replaced by higher quality segment(s).
-   *
-   * `0` can be emitted to disable any kind of fast-switching.
-   */
-  fastSwitchThreshold: IReadOnlySharedReference< undefined | number>;
-}

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

@@ -1,77 +0,0 @@
-/**
- * Copyright 2015 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-/**
- * This file allows any Stream to push data to a SegmentBuffer.
- */
-
-import { MediaError } from "../../../../errors";
-import { CancellationError, CancellationSignal } from "../../../../utils/task_canceller";
-import { IReadOnlyPlaybackObserver } from "../../../api";
-import {
-  IInsertedChunkInfos,
-  IPushChunkInfos,
-  SegmentBuffer,
-} from "../../../segment_buffers";
-import { IRepresentationStreamPlaybackObservation } from "../types";
-import forceGarbageCollection from "./force_garbage_collection";
-
-/**
- * Append a segment to the given segmentBuffer.
- * If it leads to a QuotaExceededError, try to run our custom range
- * _garbage collector_ then retry.
- * @param {Object} playbackObserver
- * @param {Object} segmentBuffer
- * @param {Object} dataInfos
- * @param {Object} cancellationSignal
- * @returns {Promise}
- */
-export default async function appendSegmentToBuffer<T>(
-  playbackObserver : IReadOnlyPlaybackObserver<IRepresentationStreamPlaybackObservation>,
-  segmentBuffer : SegmentBuffer,
-  dataInfos : IPushChunkInfos<T> & { inventoryInfos: IInsertedChunkInfos },
-  cancellationSignal : CancellationSignal
-) : Promise<void> {
-  try {
-    await segmentBuffer.pushChunk(dataInfos, cancellationSignal);
-  } catch (appendError : unknown) {
-    if (cancellationSignal.isCancelled() && appendError instanceof CancellationError) {
-      throw appendError;
-    } else if (!(appendError instanceof Error) ||
-               appendError.name !== "QuotaExceededError")
-    {
-      const reason = appendError instanceof Error ?
-        appendError.toString() :
-        "An unknown error happened when pushing content";
-      throw new MediaError("BUFFER_APPEND_ERROR",
-                           reason,
-                           { adaptation: dataInfos.inventoryInfos.adaptation });
-    }
-    const { position } = playbackObserver.getReference().getValue();
-    const currentPos = position.pending ?? position.last;
-    try {
-      await forceGarbageCollection(currentPos, segmentBuffer, cancellationSignal);
-      await segmentBuffer.pushChunk(dataInfos, cancellationSignal);
-    } catch (err2) {
-      const reason = err2 instanceof Error ? err2.toString() :
-                                             "Could not clean the buffer";
-
-      throw new MediaError("BUFFER_FULL_ERROR",
-                           reason,
-                           { adaptation: dataInfos.inventoryInfos.adaptation });
-    }
-  }
-}

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

@@ -1,305 +0,0 @@
-/**
- * Copyright 2015 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import log from "../../../../log";
-import Manifest, {
-  Adaptation,
-  Period,
-  Representation,
-} from "../../../../manifest";
-import { IBufferedChunk } from "../../../segment_buffers";
-import { IBufferDiscontinuity } from "../types";
-
-/**
- * Check if there is a soon-to-be-encountered discontinuity in the buffer that
- * won't be filled by any future segment.
- * This function will only check discontinuities for the given `checkedRange`.
- *
- * @param {Object} content - The content we are currently loading.
- * @param {Object} checkedRange - The time range that will be checked for
- * discontinuities.
- * Both `nextSegmentStart` and `bufferedSegments` arguments can only refer to
- * that range.
- * @param {number|null} nextSegmentStart - The start time in seconds of the next
- * not-yet-pushed segment that can be pushed, in the limits of `checkedRange`.
- * This includes segments which have not been loaded or pushed yet, but also
- * segments which might be re-downloaded because currently incomplete in the
- * buffer, the point being to know what is the earliest time in the buffer where
- * a segment might be pushed in the future.
- * `null` if no segment in `checkedRange` will be pushed under current buffer's
- * conditions.
- * @param {boolean} hasFinishedLoading - if `true`, all segments for the current
- * Period have been loaded and none will be loaded in the future under the
- * current buffer's state.
- * @param {Array.<Object>} bufferedSegments - Information about every segments
- * currently in the buffer, in chronological order.
- * Only segments overlapping with the given `checkedRange` will be looked at,
- * though the array given can be larger.
- */
-export default function checkForDiscontinuity(
-  content : { adaptation : Adaptation;
-              manifest : Manifest;
-              period : Period;
-              representation : Representation; },
-  checkedRange : { start : number; end : number },
-  nextSegmentStart : number | null,
-  hasFinishedLoading : boolean,
-  bufferedSegments : IBufferedChunk[]
-) : IBufferDiscontinuity | null {
-  const { period, adaptation, representation } = content;
-
-  // `bufferedSegments` might also contains segments which are before
-  // `checkedRange`.
-  // Here we want the first one that goes over `checkedRange.start`, to  see
-  // if there's a discontinuity at the beginning in the buffer
-  const nextBufferedInRangeIdx = getIndexOfFirstChunkInRange(bufferedSegments,
-                                                             checkedRange);
-  if (nextBufferedInRangeIdx === null) {
-    // There's no segment currently buffered for the current range.
-
-    if (nextSegmentStart === null) { // No segment to load in that range
-      // Check if we are in a discontinuity at the end of the current Period
-      if (hasFinishedLoading &&
-          period.end !== undefined &&
-          checkedRange.end >= period.end)
-      {
-        return { start: undefined, end: null }; // discontinuity to Period's end
-      }
-
-      // Check that there is a discontinuity announced in the Manifest there
-      const discontinuityEnd = representation.index
-        .checkDiscontinuity(checkedRange.start);
-      if (discontinuityEnd !== null) {
-        return { start: undefined,
-                 end: discontinuityEnd };
-      }
-    }
-    return null;
-  }
-
-  const nextBufferedSegment = bufferedSegments[nextBufferedInRangeIdx];
-
-  // Check if there is a hole that won't be filled before `nextSegmentStart`
-  if (
-    // Next buffered segment starts after the start of the current range
-    nextBufferedSegment.bufferedStart !== undefined &&
-    nextBufferedSegment.bufferedStart > checkedRange.start &&
-
-    // and no segment will fill in that hole
-    (nextSegmentStart === null ||
-     nextBufferedSegment.infos.segment.end <= nextSegmentStart)
-  ) {
-    const discontinuityEnd = nextBufferedSegment.bufferedStart;
-    if (!hasFinishedLoading &&
-        representation.index.awaitSegmentBetween(checkedRange.start,
-                                                 discontinuityEnd) !== false)
-    {
-      return null;
-    }
-    log.debug("RS: current discontinuity encountered",
-              adaptation.type, nextBufferedSegment.bufferedStart);
-    return { start: undefined,
-             end: discontinuityEnd };
-  }
-
-  // Check if there's a discontinuity BETWEEN segments of the current range
-  const nextHoleIdx =
-    getIndexOfFirstDiscontinuityBetweenChunks(bufferedSegments,
-                                              checkedRange,
-                                              nextBufferedInRangeIdx + 1);
-
-  // If there was a hole between two consecutives segments, and if this hole
-  // comes before the next segment to load, there is a discontinuity (that hole!)
-  if (nextHoleIdx !== null) {
-    const segmentInfoBeforeHole = bufferedSegments[nextHoleIdx - 1];
-    const segmentInfoAfterHole = bufferedSegments[nextHoleIdx];
-
-    if (nextSegmentStart === null ||
-        segmentInfoAfterHole.infos.segment.end <= nextSegmentStart)
-    {
-      if (!hasFinishedLoading && representation.index
-        .awaitSegmentBetween(segmentInfoBeforeHole.infos.segment.end,
-                             segmentInfoAfterHole.infos.segment.time) !== false)
-      {
-        return null;
-      }
-      const start = segmentInfoBeforeHole.bufferedEnd as number;
-      const end = segmentInfoAfterHole.bufferedStart as number;
-      log.debug("RS: future discontinuity encountered", adaptation.type, start, end);
-      return { start, end };
-    }
-  }
-
-  if (nextSegmentStart === null) {
-    // If no hole between segments and no segment to load, check for a
-    // discontinuity at the end of the Period
-
-    if (hasFinishedLoading && period.end !== undefined) { // Period is finished
-      if (checkedRange.end < period.end) { // We've not reached the Period's end yet
-        return null;
-      }
-
-      // Check if the last buffered segment ends before this Period's end
-      // In which case there is a discontinuity between those
-      const lastBufferedInPeriodIdx = getIndexOfLastChunkInPeriod(bufferedSegments,
-                                                                  period.end);
-      if (lastBufferedInPeriodIdx !== null) {
-        const lastSegment = bufferedSegments[lastBufferedInPeriodIdx];
-        if (lastSegment.bufferedEnd !== undefined &&
-            lastSegment.bufferedEnd < period.end)
-        {
-          log.debug("RS: discontinuity encountered at the end of the current period",
-                    adaptation.type, lastSegment.bufferedEnd, period.end);
-          return { start: lastSegment.bufferedEnd,
-                   end: null };
-        }
-      }
-    }
-
-    // At last, check if we don't have a discontinuity at the end of the current
-    // range, announced in the Manifest, that is too big to be detected through
-    // the previous checks.
-
-    if (period.end !== undefined && checkedRange.end >= period.end) {
-      return null; // The previous checks should have taken care of those
-    }
-
-    for (let bufIdx = bufferedSegments.length - 1; bufIdx >= 0; bufIdx--) {
-      const bufSeg = bufferedSegments[bufIdx];
-      if (bufSeg.bufferedStart === undefined) {
-        break;
-      }
-
-      if (bufSeg.bufferedStart < checkedRange.end) {
-        if (bufSeg.bufferedEnd !== undefined && bufSeg.bufferedEnd < checkedRange.end) {
-          const discontinuityEnd = representation.index
-            .checkDiscontinuity(checkedRange.end);
-          if (discontinuityEnd !== null) {
-            return { start: bufSeg.bufferedEnd,
-                     end: discontinuityEnd };
-          }
-        }
-        return null;
-      }
-    }
-  }
-  return null;
-}
-
-/**
- * Returns the index of the first element in `bufferedChunks` that is part of
- * `range` (starts before it ends and ends after it starts).
- *
- * Returns `null` if no element is found in that range or if we cannot know the
- * index of the first element in it.
- * @param {Array.<Object>} bufferedChunks
- * @param {Object} range
- * @returns {number|null}
- */
-function getIndexOfFirstChunkInRange(
-  bufferedChunks : IBufferedChunk[],
-  range : { start : number; end : number }
-) : number | null {
-  for (let bufIdx = 0; bufIdx < bufferedChunks.length; bufIdx++) {
-    const bufSeg = bufferedChunks[bufIdx];
-    if (bufSeg.bufferedStart === undefined ||
-        bufSeg.bufferedEnd === undefined ||
-        bufSeg.bufferedStart >= range.end)
-    {
-      return null;
-    }
-    if (bufSeg.bufferedEnd > range.start) {
-      return bufIdx;
-    }
-  }
-  return null;
-}
-
-/**
- * Returns the index of the first element in `bufferedChunks` which is not
- * immediately consecutive to the one before it.
- *
- * `startFromIndex` is the index of the first segment that will be checked with
- * the element coming before it. As such, it has to be superior to 0.
- *
- * If the element at `startFromIndex` comes immediately after the one before it,
- * the element at `startFromIndex + 1` will be checked instead and so on until a
- * segment completely out of `checkedRange` (which starts after it) is detected.
- *
- * If no hole between elements is found, `null` is returned.
- * @param {Array.<Object>} bufferedChunks
- * @param {Object} range
- * @param {number} startFromIndex
- * @returns {number|null}
- */
-function getIndexOfFirstDiscontinuityBetweenChunks(
-  bufferedChunks : IBufferedChunk[],
-  range : { start : number; end : number },
-  startFromIndex : number
-) : number | null {
-  if (startFromIndex <= 0) {
-    log.error("RS: Asked to check a discontinuity before the first chunk.");
-    return null;
-  }
-  for (
-    let bufIdx = startFromIndex;
-    bufIdx < bufferedChunks.length;
-    bufIdx++
-  ) {
-    const currSegment = bufferedChunks[bufIdx];
-    const prevSegment = bufferedChunks[bufIdx - 1];
-
-    // Exit as soon we miss information or when we go further than `checkedRange`
-    if (currSegment.bufferedStart === undefined ||
-        prevSegment.bufferedEnd === undefined ||
-        currSegment.bufferedStart >= range.end)
-    {
-      return null;
-    }
-
-    // If there is a hole between two consecutive buffered segment
-    if (currSegment.bufferedStart - prevSegment.bufferedEnd > 0) {
-      return bufIdx;
-    }
-  }
-  return null;
-}
-
-/**
- * Returns the index of the last element in `bufferedChunks` that is part of
- * `range` (starts before it ends and ends after it starts).
- *
- * Returns `null` if no element is found in that range or if we cannot know the
- * index of the last element in it.
- * @param {Array.<Object>} bufferedChunks
- * @param {number} periodEnd
- * @returns {number|null}
- */
-function getIndexOfLastChunkInPeriod(
-  bufferedChunks : IBufferedChunk[],
-  periodEnd : number
-) : number | null {
-  for (let bufIdx = bufferedChunks.length - 1; bufIdx >= 0; bufIdx--) {
-    const bufSeg = bufferedChunks[bufIdx];
-    if (bufSeg.bufferedStart === undefined) {
-      return null;
-    }
-    if (bufSeg.bufferedStart < periodEnd) {
-      return bufIdx;
-    }
-  }
-  return null;
-}