rx-player 3.25.2 → 3.26.3-dev.2022021400

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

@@ -29,25 +29,18 @@ import {
   concat as observableConcat,
   defer as observableDefer,
   EMPTY,
+  ignoreElements,
   merge as observableMerge,
+  mergeMap,
   Observable,
   of as observableOf,
-  ReplaySubject,
-  Subject,
-} from "rxjs";
-import {
-  finalize,
-  ignoreElements,
-  map,
-  mergeMap,
   share,
   startWith,
-  switchMap,
+  Subject,
   take,
   takeWhile,
   withLatestFrom,
-} from "rxjs/operators";
-import { ICustomError } from "../../../errors";
+} from "rxjs";
 import log from "../../../log";
 import Manifest, {
   Adaptation,
@@ -55,19 +48,11 @@ import Manifest, {
   Period,
   Representation,
 } from "../../../manifest";
-import {
-  ISegmentParserInitSegment,
-  ISegmentParserParsedInitSegment,
-  ISegmentParserSegment,
-} from "../../../transports";
 import assertUnreachable from "../../../utils/assert_unreachable";
 import objectAssign from "../../../utils/object_assign";
-import { IStalledStatus } from "../../api";
-import {
-  IPrioritizedSegmentFetcher,
-  IPrioritizedSegmentFetcherEvent,
-  ISegmentFetcherWarning,
-} from "../../fetchers";
+import { createSharedReference } from "../../../utils/reference";
+import { IReadOnlyPlaybackObserver } from "../../api";
+import { IPrioritizedSegmentFetcher } from "../../fetchers";
 import { SegmentBuffer } from "../../segment_buffers";
 import EVENTS from "../events_generators";
 import {
@@ -80,23 +65,26 @@ import {
   IStreamStatusEvent,
   IStreamTerminatingEvent,
   IInbandEventsEvent,
+  IStreamWarningEvent,
 } from "../types";
+import DownloadingQueue, {
+  IDownloadingQueueEvent,
+  IDownloadQueueItem,
+  IParsedInitSegmentEvent,
+  IParsedSegmentEvent,
+} from "./downloading_queue";
 import getBufferStatus from "./get_buffer_status";
 import getSegmentPriority from "./get_segment_priority";
 import pushInitSegment from "./push_init_segment";
 import pushMediaSegment from "./push_media_segment";
 
-/** Object emitted by the Stream's clock$ at each tick. */
-export interface IRepresentationStreamClockTick {
-  /** The position, in seconds, the media element was in at the time of the tick. */
+/** Object that should be emitted by the given `IReadOnlyPlaybackObserver`. */
+export interface IRepresentationStreamPlaybackObservation {
+  /**
+   * The position, in seconds, the media element was in at the time of the
+   * playback observation.
+   */
   position : number;
- /**
-  * Gap between the current position and the edge of a live content.
-  * Not set for non-live contents.
-  */
-  liveGap? : number;
-  /** If set, the player is currently stalled (blocked). */
-  stalled : IStalledStatus|null;
   /**
    * Offset in seconds to add to the time to obtain the position we
    * actually want to download from.
@@ -105,8 +93,6 @@ export interface IRepresentationStreamClockTick {
    * starting position different from `0`.
    */
   wantedTimeOffset : number;
-  /** Fetch the precize position currently in the HTMLMediaElement. */
-  getCurrentTime() : number;
 }
 
 /** Item emitted by the `terminate$` Observable given to a RepresentationStream. */
@@ -121,18 +107,16 @@ export interface ITerminationOrder {
 }
 
 /** Arguments to give to the RepresentationStream. */
-export interface IRepresentationStreamArguments<T> {
-  /** Periodically emits the current playback conditions. */
-  clock$ : Observable<IRepresentationStreamClockTick>;
+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<T>;
+  segmentBuffer : SegmentBuffer;
   /** Interface used to load new segments. */
-  segmentFetcher : IPrioritizedSegmentFetcher<T>;
+  segmentFetcher : IPrioritizedSegmentFetcher<TSegmentDataType>;
   /**
    * Observable emitting when the RepresentationStream should "terminate".
    *
@@ -144,6 +128,8 @@ export interface IRepresentationStreamArguments<T> {
    * Observable once the corresponding segments have been pushed).
    */
   terminate$ : Observable<ITerminationOrder>;
+  /** Periodically emits the current playback conditions. */
+  playbackObserver : IReadOnlyPlaybackObserver<IRepresentationStreamPlaybackObservation>;
   /** Supplementary arguments which configure the RepresentationStream's behavior. */
   options: IRepresentationStreamOptions;
 }
@@ -191,38 +177,23 @@ export interface IRepresentationStreamOptions {
   fastSwitchThreshold$: Observable< undefined | number>;
 }
 
-/** Internal event used to notify that the initialization segment has been parsed. */
-type IParsedInitSegmentEvent<T> = ISegmentParserInitSegment<T> &
-                                  { segment : ISegment };
-
-/** Internal event used to notify that a media segment has been parsed. */
-type IParsedSegmentEvent<T> = ISegmentParserSegment<T> &
-                              { segment : ISegment };
-
-/** Internal event used to notify that a segment has been fully-loaded. */
-interface IEndOfSegmentEvent { type : "end-of-segment";
-                               value: { segment : ISegment }; }
-
-/** Internal event used to notify that a segment request is retried. */
-interface ILoaderRetryEvent { type : "retry";
-                              value : { segment : ISegment;
-                                        error : ICustomError; };
-}
-
-/** Internal event sent when loading a segment. */
-type ISegmentLoadingEvent<T> = IParsedSegmentEvent<T> |
-                               IParsedInitSegmentEvent<T> |
-                               IEndOfSegmentEvent |
-                               ILoaderRetryEvent;
-
-/** Object describing a pending Segment request. */
-interface ISegmentRequestObject<T> {
-  /** The segment the request is for. */
-  segment : ISegment; // The Segment the request is for
-  /** The request Observable itself. Can be used to update its priority. */
-  request$ : Observable<IPrioritizedSegmentFetcherEvent<T>>;
-  /** Last set priority of the segment request (lower number = higher priority). */
-  priority : number; // The current priority of the request
+/**
+ * Information about the initialization segment linked to the Representation
+ * which the RepresentationStream try to download segments for.
+ */
+interface IInitSegmentState<T> {
+  /**
+   * Segment Object describing that initialization segment.
+   * `null` if there's no initialization segment for that Representation.
+   */
+  segment : ISegment | null;
+  /**
+   * Initialization segment data.
+   * `null` either when it doesn't exist or when it has not been loaded yet.
+   */
+  segmentData : T | null;
+  /** `true` if the initialization segment has been loaded and parsed. */
+  isLoaded : boolean;
 }
 
 /**
@@ -237,144 +208,159 @@ interface ISegmentRequestObject<T> {
  * @param {Object} args
  * @returns {Observable}
  */
-export default function RepresentationStream<T>({
-  clock$,
+export default function RepresentationStream<TSegmentDataType>({
   content,
+  options,
+  playbackObserver,
   segmentBuffer,
   segmentFetcher,
   terminate$,
-  options,
-} : IRepresentationStreamArguments<T>) : Observable<IRepresentationStreamEvent<T>> {
-  const { manifest, period, adaptation, representation } = content;
-  const { bufferGoal$, drmSystemId, fastSwitchThreshold$ } = options;
+} : IRepresentationStreamArguments<TSegmentDataType>
+) : Observable<IRepresentationStreamEvent> {
+  const { period,
+          adaptation,
+          representation } = content;
+  const { bufferGoal$,
+          drmSystemId,
+          fastSwitchThreshold$ } = options;
   const bufferType = adaptation.type;
-  const initSegment = representation.index.getInitSegment();
 
-  /**
-   * Saved initialization segment state for this representation.
-   * `null` if the initialization segment hasn't been loaded yet.
-   */
-  let initSegmentObject : ISegmentParserParsedInitSegment<T> | null =
-    initSegment === null ? { initializationData: null,
-                             protectionDataUpdate: false,
-                             initTimescale: undefined } :
-                           null;
-
-  /** Segments queued for download in this RepresentationStream. */
-  let downloadQueue : IQueuedSegment[] = [];
-
-  /** Emit to start/restart a downloading Queue. */
-  const startDownloadingQueue$ = new ReplaySubject<void>(1);
+  /** Saved initialization segment state for this representation. */
+  const initSegmentState : IInitSegmentState<TSegmentDataType> = {
+    segment: representation.index.getInitSegment(),
+    segmentData: null,
+    isLoaded: false,
+  };
 
-  /** Emit when the RepresentationStream asks to re-check which segments are needed. */
+  /** Allows to manually re-check which segments are needed. */
   const reCheckNeededSegments$ = new Subject<void>();
 
+  /** Emit the last scheduled downloading queue for segments. */
+  const lastSegmentQueue = createSharedReference<IDownloadQueueItem>({
+    initSegment: null,
+    segmentQueue: [],
+  });
+  const hasInitSegment = initSegmentState.segment !== null;
+
+  /** Will load every segments in `lastSegmentQueue` */
+  const downloadingQueue = new DownloadingQueue(content,
+                                                lastSegmentQueue,
+                                                segmentFetcher,
+                                                hasInitSegment);
+
+  if (!hasInitSegment) {
+    initSegmentState.segmentData = null;
+    initSegmentState.isLoaded = true;
+  }
+
   /**
-   * Keep track of the information about the pending segment request.
-   * `null` if no segment request is pending in that RepresentationStream.
+   * `true` if the event notifying about encryption data has already been
+   * constructed.
+   * Allows to avoid sending multiple times protection events.
    */
-  let currentSegmentRequest : ISegmentRequestObject<T>|null = null;
+  let hasSentEncryptionData = false;
+  let encryptionEvent$ : Observable<IEncryptionDataEncounteredEvent> = EMPTY;
+  if (drmSystemId !== undefined) {
+    const encryptionData = representation.getEncryptionData(drmSystemId);
+    if (encryptionData.length > 0) {
+      encryptionEvent$ = observableOf(...encryptionData.map(d =>
+        EVENTS.encryptionDataEncountered(d)));
+      hasSentEncryptionData = true;
+    }
+  }
+
+  /** Observable loading and pushing segments scheduled through `lastSegmentQueue`. */
+  const queue$ = downloadingQueue.start()
+    .pipe(mergeMap(onQueueEvent));
 
+  /** Observable emitting the stream "status" and filling `lastSegmentQueue`. */
   const status$ = observableCombineLatest([
-    clock$,
+    playbackObserver.observe(true),
     bufferGoal$,
     terminate$.pipe(take(1),
                     startWith(null)),
-    reCheckNeededSegments$.pipe(startWith(undefined)) ]
-  ).pipe(
+    reCheckNeededSegments$.pipe(startWith(undefined)),
+  ]).pipe(
     withLatestFrom(fastSwitchThreshold$),
     mergeMap(function (
-      [ [ tick, bufferGoal, terminate ],
+      [ [ observation, bufferGoal, terminate ],
         fastSwitchThreshold ]
     ) : Observable<IStreamStatusEvent |
                    IStreamNeedsManifestRefresh |
                    IStreamTerminatingEvent>
     {
+      const wantedStartPosition = observation.position + observation.wantedTimeOffset;
       const status = getBufferStatus(content,
-                                     tick,
+                                     wantedStartPosition,
+                                     playbackObserver,
                                      fastSwitchThreshold,
                                      bufferGoal,
                                      segmentBuffer);
       const { neededSegments } = status;
 
+      let neededInitSegment : IQueuedSegment | null = null;
+
       // Add initialization segment if required
       if (!representation.index.isInitialized()) {
-        if (initSegment === null) {
+        if (initSegmentState.segment === null) {
           log.warn("Stream: Uninitialized index without an initialization segment");
-        } else if (initSegmentObject !== null) {
+        } else if (initSegmentState.isLoaded) {
           log.warn("Stream: Uninitialized index with an already loaded " +
                    "initialization segment");
         } else {
-          neededSegments.unshift({ segment: initSegment,
-                                   priority: getSegmentPriority(period.start, tick) });
+          const wantedStart = observation.position + observation.wantedTimeOffset;
+          neededInitSegment = { segment: initSegmentState.segment,
+                                priority: getSegmentPriority(period.start,
+                                                             wantedStart) };
         }
       } else if (neededSegments.length > 0 &&
-                 initSegment !== null &&
-                 initSegmentObject === null)
+                 !initSegmentState.isLoaded &&
+                 initSegmentState.segment !== null)
       {
-        // prepend initialization segment
         const initSegmentPriority = neededSegments[0].priority;
-        neededSegments.unshift({ segment: initSegment,
-                                 priority: initSegmentPriority });
+        neededInitSegment = { segment: initSegmentState.segment,
+                              priority: initSegmentPriority };
       }
 
-      const mostNeededSegment = neededSegments[0];
-
-      if (terminate !== null) {
-        downloadQueue = [];
-        if (terminate.urgent) {
-          log.debug("Stream: urgent termination request, terminate.", bufferType);
-          startDownloadingQueue$.next(); // interrupt current requests
-          startDownloadingQueue$.complete(); // complete the downloading queue
-          return observableOf(EVENTS.streamTerminating());
-        } else if (
-          currentSegmentRequest === null ||
-          mostNeededSegment === undefined ||
-          currentSegmentRequest.segment.id !== mostNeededSegment.segment.id
-        ) {
-          log.debug("Stream: cancel request and terminate.",
-                    currentSegmentRequest === null,
-                    bufferType);
-          startDownloadingQueue$.next(); // interrupt the current request
-          startDownloadingQueue$.complete(); // complete the downloading queue
+      if (terminate === null) {
+        lastSegmentQueue.setValue({ initSegment: neededInitSegment,
+                                    segmentQueue: neededSegments });
+      } else if (terminate.urgent) {
+        log.debug("Stream: Urgent switch, terminate now.", bufferType);
+        lastSegmentQueue.setValue({ initSegment: null, segmentQueue: [] });
+        lastSegmentQueue.finish();
+        return observableOf(EVENTS.streamTerminating());
+      } else {
+        // Non-urgent termination wanted:
+        // End the download of the current media segment if pending and
+        // terminate once either that request is finished or another segment
+        // is wanted instead, whichever comes first.
+
+        const mostNeededSegment = neededSegments[0];
+        const initSegmentRequest = downloadingQueue.getRequestedInitSegment();
+        const currentSegmentRequest = downloadingQueue.getRequestedMediaSegment();
+
+        const nextQueue = currentSegmentRequest === null ||
+                          mostNeededSegment === undefined ||
+                          currentSegmentRequest.id !== mostNeededSegment.segment.id ?
+          [] :
+          [mostNeededSegment];
+
+        const nextInit = initSegmentRequest === null ? null :
+                                                       neededInitSegment;
+        lastSegmentQueue.setValue({ initSegment: nextInit,
+                                    segmentQueue: nextQueue });
+        if (nextQueue.length === 0 && nextInit === null) {
+          log.debug("Stream: No request left, terminate", bufferType);
+          lastSegmentQueue.finish();
           return observableOf(EVENTS.streamTerminating());
-        } else if (currentSegmentRequest.priority !== mostNeededSegment.priority) {
-          const { request$ } = currentSegmentRequest;
-          currentSegmentRequest.priority = mostNeededSegment.priority;
-          segmentFetcher.updatePriority(request$, mostNeededSegment.priority);
         }
-        log.debug("Stream: terminate after request.", bufferType);
-      } else if (mostNeededSegment === undefined) {
-        if (currentSegmentRequest !== null) {
-          log.debug("Stream: interrupt segment request.", bufferType);
-        }
-        downloadQueue = [];
-        startDownloadingQueue$.next(); // (re-)start with an empty queue
-      } else if (currentSegmentRequest === null) {
-        log.debug("Stream: start downloading queue.", bufferType);
-        downloadQueue = neededSegments;
-        startDownloadingQueue$.next(); // restart the queue
-      } else if (currentSegmentRequest.segment.id !== mostNeededSegment.segment.id) {
-        log.debug("Stream: restart download queue.", bufferType);
-        downloadQueue = neededSegments;
-        startDownloadingQueue$.next(); // restart the queue
-      } else if (currentSegmentRequest.priority !== mostNeededSegment.priority) {
-        log.debug("Stream: update request priority.", bufferType);
-        const { request$ } = currentSegmentRequest;
-        currentSegmentRequest.priority = mostNeededSegment.priority;
-        segmentFetcher.updatePriority(request$, mostNeededSegment.priority);
-      } else {
-        log.debug("Stream: update downloading queue", bufferType);
-
-        // Update the previous queue to be all needed segments but the first one,
-        // for which a request is already pending
-        downloadQueue = neededSegments.slice().splice(1, neededSegments.length);
       }
 
       const bufferStatusEvt : Observable<IStreamStatusEvent> =
         observableOf({ type: "stream-status" as const,
                        value: { period,
-                                position: tick.position,
+                                position: observation.position,
                                 bufferType,
                                 imminentDiscontinuity: status.imminentDiscontinuity,
                                 hasFinishedLoading: status.hasFinishedLoading,
@@ -388,105 +374,17 @@ export default function RepresentationStream<T>({
     takeWhile((e) => e.type !== "stream-terminating", true)
   );
 
-  /**
-   * `true` if the event notifying about encryption data has already been
-   * constructed.
-   * Allows to avoid sending multiple times protection events.
-   */
-  let hasSentEncryptionData = false;
-  let encryptionEvent$ : Observable<IEncryptionDataEncounteredEvent> = EMPTY;
-  if (drmSystemId !== undefined) {
-    const encryptionData = representation.getEncryptionData(drmSystemId);
-    if (encryptionData.length > 0) {
-      encryptionEvent$ = observableOf(...encryptionData.map(d =>
-        EVENTS.encryptionDataEncountered(d)));
-      hasSentEncryptionData = true;
-    }
-  }
+  return observableMerge(status$, queue$, encryptionEvent$).pipe(share());
 
   /**
-   * Stream Queue:
-   *   - download every segments queued sequentially
-   *   - when a segment is loaded, append it to the SegmentBuffer
-   */
-  const streamQueue$ = startDownloadingQueue$.pipe(
-    switchMap(() => downloadQueue.length > 0 ? loadSegmentsFromQueue() : EMPTY),
-    mergeMap(onLoaderEvent));
-
-  return observableConcat(encryptionEvent$,
-                          observableMerge(status$, streamQueue$).pipe(share()));
-
-  /**
-   * Request every Segment in the ``downloadQueue`` on subscription.
-   * Emit the data of a segment when a request succeeded.
-   *
-   * Important side-effects:
-   *   - Mutates `currentSegmentRequest` when doing and finishing a request.
-   *   - Will emit from reCheckNeededSegments$ Subject when it's done.
-   *
-   * Might emit warnings when a request is retried.
-   *
-   * Throws when the request will not be retried (configuration or un-retryable
-   * error).
-   * @returns {Observable}
-   */
-  function loadSegmentsFromQueue() : Observable<ISegmentLoadingEvent<T>> {
-    const requestNextSegment$ =
-      observableDefer(() : Observable<ISegmentLoadingEvent<T>> => {
-        const currentNeededSegment = downloadQueue.shift();
-        if (currentNeededSegment === undefined) {
-          nextTick(() => { reCheckNeededSegments$.next(); });
-          return EMPTY;
-        }
-
-        const { segment, priority } = currentNeededSegment;
-        const context = { manifest, period, adaptation, representation, segment };
-        const request$ = segmentFetcher.createRequest(context, priority);
-
-        currentSegmentRequest = { segment, priority, request$ };
-        return request$
-          .pipe(mergeMap((evt) : Observable<ISegmentLoadingEvent<T>> => {
-            switch (evt.type) {
-              case "warning":
-                return observableOf({ type: "retry" as const,
-                                      value: { segment, error: evt.value } });
-              case "chunk-complete":
-                currentSegmentRequest = null;
-                return observableOf({ type: "end-of-segment" as const,
-                                      value: { segment } });
-
-              case "interrupted":
-                log.info("Stream: segment request interrupted temporarly.", segment);
-                return EMPTY;
-
-              case "chunk":
-                const initTimescale = initSegmentObject?.initTimescale;
-                return evt.parse(initTimescale).pipe(map(parserResponse => {
-                  return objectAssign({ segment }, parserResponse);
-                }));
-
-              case "ended":
-                return requestNextSegment$;
-
-              default:
-                assertUnreachable(evt);
-            }
-          }));
-      });
-
-    return requestNextSegment$
-      .pipe(finalize(() => { currentSegmentRequest = null; }));
-  }
-
-  /**
-   * React to event from `loadSegmentsFromQueue`.
+   * React to event from the `DownloadingQueue`.
    * @param {Object} evt
    * @returns {Observable}
    */
-  function onLoaderEvent(
-    evt : ISegmentLoadingEvent<T>
-  ) : Observable<IStreamEventAddedSegment<T> |
-                 ISegmentFetcherWarning |
+  function onQueueEvent(
+    evt : IDownloadingQueueEvent<TSegmentDataType>
+  ) : Observable<IStreamEventAddedSegment<TSegmentDataType> |
+                 IStreamWarningEvent |
                  IEncryptionDataEncounteredEvent |
                  IInbandEventsEvent |
                  IStreamNeedsManifestRefresh |
@@ -507,67 +405,100 @@ export default function RepresentationStream<T>({
             return EMPTY; // else, ignore.
           }));
 
-      case "parsed-init-segment": {
-        initSegmentObject = evt.value;
-
-        // Now that the initialization segment has been parsed - which may have
-        // included encryption information - take care of the encryption event
-        // if not already done.
-        const allEncryptionData = representation.getAllEncryptionData();
-        const initEncEvt$ = !hasSentEncryptionData &&
-                            allEncryptionData.length > 0 ?
-          observableOf(...allEncryptionData.map(p =>
-            EVENTS.encryptionDataEncountered(p))) :
-          EMPTY;
-        const pushEvent$ = pushInitSegment({ clock$,
-                                             content,
-                                             segment: evt.segment,
-                                             segmentData: evt.value.initializationData,
-                                             segmentBuffer });
-        return observableMerge(initEncEvt$, pushEvent$);
-      }
+      case "parsed-init":
+      case "parsed-media":
+        return onParsedChunk(evt);
 
-      case "parsed-segment": {
-        const initSegmentData = initSegmentObject?.initializationData ?? null;
-        const { inbandEvents,
-                needsManifestRefresh } = evt.value;
-
-        // TODO better handle use cases like key rotation by not always grouping
-        // every protection data together? To check.
-        const segmentEncryptionEvent = evt.value.protectionDataUpdate &&
-                                       !hasSentEncryptionData ?
-          observableOf(...representation.getAllEncryptionData().map(p =>
-            EVENTS.encryptionDataEncountered(p))) :
-          EMPTY;
-
-        const manifestRefresh$ = needsManifestRefresh === true ?
-          observableOf(EVENTS.needsManifestRefresh()) :
-          EMPTY;
-
-        const inbandEvents$ = inbandEvents !== undefined &&
-                              inbandEvents.length > 0 ?
-          observableOf({ type: "inband-events" as const,
-                         value: inbandEvents }) :
-          EMPTY;
-
-        return observableConcat(segmentEncryptionEvent,
-                                manifestRefresh$,
-                                inbandEvents$,
-                                pushMediaSegment({ clock$,
-                                                   content,
-                                                   initSegmentData,
-                                                   parsedSegment: evt.value,
-                                                   segment: evt.segment,
-                                                   segmentBuffer }));
-      }
       case "end-of-segment": {
         const { segment } = evt.value;
         return segmentBuffer.endOfSegment(objectAssign({ segment }, content))
+          // NOTE As of now (RxJS 7.4.0), RxJS defines `ignoreElements` default
+          // first type parameter as `any` instead of the perfectly fine `unknown`,
+          // leading to linter issues, as it forbids the usage of `any`.
+          // This is why we're disabling the eslint rule.
+          /* eslint-disable-next-line @typescript-eslint/no-unsafe-argument */
           .pipe(ignoreElements());
       }
 
+      case "end-of-queue":
+        reCheckNeededSegments$.next();
+        return EMPTY;
+
       default:
         assertUnreachable(evt);
     }
   }
+
+  /**
+   * Process a chunk that has just been parsed by pushing it to the
+   * SegmentBuffer and emitting the right events.
+   * @param {Object} evt
+   * @returns {Observable}
+   */
+  function onParsedChunk(
+    evt : IParsedInitSegmentEvent<TSegmentDataType> |
+          IParsedSegmentEvent<TSegmentDataType>
+  ) : Observable<IStreamEventAddedSegment<TSegmentDataType> |
+                 IEncryptionDataEncounteredEvent |
+                 IInbandEventsEvent |
+                 IStreamNeedsManifestRefresh |
+                 IStreamManifestMightBeOutOfSync>
+  {
+    if (evt.segmentType === "init") {
+      nextTick(() => {
+        reCheckNeededSegments$.next();
+      });
+      initSegmentState.segmentData = evt.initializationData;
+      initSegmentState.isLoaded = true;
+
+      // Now that the initialization segment has been parsed - which may have
+      // included encryption information - take care of the encryption event
+      // if not already done.
+      const allEncryptionData = representation.getAllEncryptionData();
+      const initEncEvt$ = !hasSentEncryptionData &&
+                          allEncryptionData.length > 0 ?
+        observableOf(...allEncryptionData.map(p =>
+          EVENTS.encryptionDataEncountered(p))) :
+        EMPTY;
+      const pushEvent$ = pushInitSegment({ playbackObserver,
+                                           content,
+                                           segment: evt.segment,
+                                           segmentData: evt.initializationData,
+                                           segmentBuffer });
+      return observableMerge(initEncEvt$, pushEvent$);
+    } else {
+      const { inbandEvents,
+              needsManifestRefresh,
+              protectionDataUpdate } = evt;
+
+      // TODO better handle use cases like key rotation by not always grouping
+      // every protection data together? To check.
+      const segmentEncryptionEvent$ = protectionDataUpdate &&
+                                     !hasSentEncryptionData ?
+        observableOf(...representation.getAllEncryptionData().map(p =>
+          EVENTS.encryptionDataEncountered(p))) :
+        EMPTY;
+
+      const manifestRefresh$ =  needsManifestRefresh === true ?
+        observableOf(EVENTS.needsManifestRefresh()) :
+        EMPTY;
+      const inbandEvents$ = inbandEvents !== undefined &&
+                            inbandEvents.length > 0 ?
+        observableOf({ type: "inband-events" as const,
+                       value: inbandEvents }) :
+        EMPTY;
+
+      const initSegmentData = initSegmentState.segmentData;
+      const pushMediaSegment$ = pushMediaSegment({ playbackObserver,
+                                                   content,
+                                                   initSegmentData,
+                                                   parsedSegment: evt,
+                                                   segment: evt.segment,
+                                                   segmentBuffer });
+      return observableConcat(segmentEncryptionEvent$,
+                              manifestRefresh$,
+                              inbandEvents$,
+                              pushMediaSegment$);
+    }
+  }
 }