Fix an error when no buffer sink is available due to media segments have been preloaded (#4871)

Author: dsilhavy

src/streaming/SourceBufferSink.js

@@ -265,7 +265,7 @@ function SourceBufferSink(config) {
 
     function getAllBufferRanges() {
         try {
-            return buffer.buffered;
+            return buffer?.buffered;
         } catch (e) {
             logger.error('getAllBufferRanges exception: ' + e.message);
             return null;
@@ -461,7 +461,7 @@ function SourceBufferSink(config) {
         try {
             callbacks.push(callback);
 
-            if (!buffer.updating) {
+            if (buffer && !buffer.updating) {
                 _executeCallback();
             }
         } catch (e) {

src/streaming/Stream.js

@@ -190,14 +190,14 @@ function Stream(config) {
     /**
      * Activates Stream by re-initializing some of its components
      * @param {MediaSource} mediaSource
-     * @param {array} previousBufferSinks
+     * @param {array} previousSourceBufferSinks
      * @param representationsFromPreviousPeriod
      * @memberof Stream#
      */
-    function activate(mediaSource, previousBufferSinks, representationsFromPreviousPeriod = []) {
+    function activate(mediaSource, previousSourceBufferSinks, representationsFromPreviousPeriod = []) {
         return new Promise((resolve, reject) => {
             if (isActive) {
-                resolve(previousBufferSinks);
+                resolve();
                 return;
             }
 
@@ -206,21 +206,21 @@ function Stream(config) {
                 eventBus.trigger(Events.STREAM_ACTIVATED, {
                     streamInfo
                 });
-                resolve(previousBufferSinks);
+                resolve();
                 return;
             }
 
 
-            _initializeMedia(mediaSource, previousBufferSinks, representationsFromPreviousPeriod)
-                .then((bufferSinks) => {
+            _initializeMedia(mediaSource, previousSourceBufferSinks, representationsFromPreviousPeriod)
+                .then(() => {
                     isActive = true;
                     if (representationsFromPreviousPeriod && representationsFromPreviousPeriod.length > 0) {
                         startScheduleControllers();
                     }
                     eventBus.trigger(Events.STREAM_ACTIVATED, {
                         streamInfo
                     });
-                    resolve(bufferSinks);
+                    resolve();
                 })
                 .catch((e) => {
                     reject(e);
@@ -257,23 +257,23 @@ function Stream(config) {
     /**
      *
      * @param {object} mediaSource
-     * @param {array} previousBufferSinks
+     * @param {array} previousSourceBufferSinks
      * @param representationsFromPreviousPeriod
      * @return {Promise<Array>}
      * @private
      */
-    function _initializeMedia(mediaSource, previousBufferSinks, representationsFromPreviousPeriod = []) {
-        return _commonMediaInitialization(mediaSource, previousBufferSinks, representationsFromPreviousPeriod);
+    function _initializeMedia(mediaSource, previousSourceBufferSinks, representationsFromPreviousPeriod = []) {
+        return _commonMediaInitialization(mediaSource, previousSourceBufferSinks, representationsFromPreviousPeriod);
     }
 
     /**
      *
      * @param {object} mediaSource
-     * @param {array} previousBufferSinks
+     * @param {array} previousSourceBufferSinks
      * @return {Promise<array>}
      * @private
      */
-    function _commonMediaInitialization(mediaSource, previousBufferSinks, representationsFromPreviousPeriod) {
+    function _commonMediaInitialization(mediaSource, previousSourceBufferSinks, representationsFromPreviousPeriod) {
         return new Promise((resolve, reject) => {
             checkConfig();
 
@@ -294,7 +294,7 @@ function Stream(config) {
 
             Promise.all(promises)
                 .then(() => {
-                    return _createBufferSinks(previousBufferSinks)
+                    return _createBufferSinks(previousSourceBufferSinks)
                 })
                 .then((bufferSinks) => {
                     if (streamProcessors.length === 0) {
@@ -522,16 +522,16 @@ function Stream(config) {
 
     /**
      * Creates the SourceBufferSink objects for all StreamProcessors
-     * @param {array} previousBuffersSinks
+     * @param {array} previousSourceBufferSinks
      * @return {Promise<object>}
      * @private
      */
-    function _createBufferSinks(previousBuffersSinks) {
+    function _createBufferSinks(previousSourceBufferSinks) {
         return new Promise((resolve) => {
             const buffers = {};
             const promises = streamProcessors.map((sp) => {
                 const oldRepresentation = sp.getRepresentation();
-                return sp.createBufferSinks(previousBuffersSinks, oldRepresentation);
+                return sp.createBufferSinks(previousSourceBufferSinks, oldRepresentation);
             });
 
             Promise.all(promises)

src/streaming/controllers/BufferController.js

@@ -161,18 +161,18 @@ function BufferController(config) {
     /**
      * Creates a SourceBufferSink object
      * @param {object} mediaInfo
-     * @param {array} oldBufferSinks
+     * @param {Map<any, any>} previousBufferSinks
      * @return {Promise<Object>} SourceBufferSink
      */
-    function createBufferSink(mediaInfo, oldBufferSinks = [], oldRepresentation) {
+    function createBufferSink(mediaInfo, previousBufferSinks = new Map(), oldRepresentation) {
         return new Promise((resolve, reject) => {
             if (!initCache || !mediaInfo) {
                 resolve(null);
                 return;
             }
             if (mediaSource) {
                 isPrebuffering = false;
-                _initializeSinkForMseBuffering(mediaInfo, oldBufferSinks, oldRepresentation)
+                _initializeSinkForMseBuffering(mediaInfo, previousBufferSinks, oldRepresentation)
                     .then((sink) => {
                         resolve(sink);
                     })
@@ -205,14 +205,14 @@ function BufferController(config) {
         })
     }
 
-    function _initializeSinkForMseBuffering(mediaInfo, oldBufferSinks, oldRepresentation) {
+    function _initializeSinkForMseBuffering(mediaInfo, previousBufferSinks, oldRepresentation) {
         return new Promise((resolve) => {
             sourceBufferSink = SourceBufferSink(context).create({
                 mediaSource,
                 textController,
                 eventBus
             });
-            _initializeSink(mediaInfo, oldBufferSinks, oldRepresentation)
+            _initializeSink(mediaInfo, previousBufferSinks, oldRepresentation)
                 .then(() => {
                     return updateBufferTimestampOffset(representationController.getCurrentRepresentation());
                 })
@@ -226,18 +226,23 @@ function BufferController(config) {
         })
     }
 
-    function _initializeSink(mediaInfo, oldBufferSinks, oldRepresentation) {
+    function _initializeSink(mediaInfo, previousBufferSinks, oldRepresentation) {
         const newRepresentation = representationController.getCurrentRepresentation();
+        let previousBufferSink = null;
 
-        if (oldBufferSinks && oldBufferSinks[type] && (type === Constants.VIDEO || type === Constants.AUDIO)) {
-            return _initializeSinkForStreamSwitch(mediaInfo, newRepresentation, oldBufferSinks, oldRepresentation)
+        if (type === Constants.VIDEO || type === Constants.AUDIO) {
+            previousBufferSink = previousBufferSinks.get(type);
+        }
+
+        if (previousBufferSink) {
+            return _initializeSinkForBufferReuse(mediaInfo, newRepresentation, previousBufferSink, oldRepresentation)
         } else {
             return _initializeSinkForFirstUse(mediaInfo, newRepresentation);
         }
     }
 
-    function _initializeSinkForStreamSwitch(mediaInfo, newRepresentation, oldBufferSinks, oldRepresentation) {
-        sourceBufferSink.initializeForStreamSwitch(mediaInfo, newRepresentation, oldBufferSinks[type]);
+    function _initializeSinkForBufferReuse(mediaInfo, newRepresentation, previousBufferSink, oldRepresentation) {
+        sourceBufferSink.initializeForStreamSwitch(mediaInfo, newRepresentation, previousBufferSink);
 
         const promises = [];
         promises.push(sourceBufferSink.abortBeforeAppend());

src/streaming/controllers/StreamController.js

@@ -64,7 +64,7 @@ function StreamController() {
         protectionData, extUrlQueryInfoController,
         autoPlay, isStreamSwitchingInProgress, hasMediaError, hasInitialisationError, mediaSource, videoModel,
         playbackController, serviceDescriptionController, mediaPlayerModel, customParametersModel, isPaused,
-        initialPlayback, initialSteeringRequest, playbackEndedTimerInterval, bufferSinks, preloadingStreams, settings,
+        initialPlayback, initialSteeringRequest, playbackEndedTimerInterval, preloadingStreams, settings,
         firstLicenseIsFetched, waitForPlaybackStartTimeout, providedStartTime, errorInformation;
 
     function setup() {
@@ -430,6 +430,7 @@ function StreamController() {
 
             let keepBuffers = false;
             let representationsFromPreviousPeriod = [];
+            let sourceBufferSinksFromPreviousPeriod = _getSourceBufferSinksFromPreviousPeriod(previousStream);
             activeStream = stream;
 
             if (previousStream) {
@@ -451,9 +452,15 @@ function StreamController() {
 
             // If we have a video element we are not preloading into a virtual buffer
             if (videoModel.getElement()) {
-                _openMediaSource({ seekTime, keepBuffers, streamActivated: false, representationsFromPreviousPeriod });
+                _openMediaSource({
+                    seekTime,
+                    keepBuffers,
+                    sourceBufferSinksFromPreviousPeriod,
+                    streamActivated: false,
+                    representationsFromPreviousPeriod
+                });
             } else {
-                _activateStream({ seekTime, keepBuffers });
+                _activateStream({ seekTime, keepBuffers, sourceBufferSinksFromPreviousPeriod });
             }
         } catch (e) {
             isStreamSwitchingInProgress = false;
@@ -524,11 +531,8 @@ function StreamController() {
      */
     function _activateStream(inputParameters) {
         const representationsFromPreviousPeriod = inputParameters.representationsFromPreviousPeriod || [];
-        activeStream.activate(mediaSource, inputParameters.keepBuffers ? bufferSinks : undefined, representationsFromPreviousPeriod)
-            .then((sinks) => {
-                if (sinks) {
-                    bufferSinks = sinks;
-                }
+        activeStream.activate(mediaSource, inputParameters.sourceBufferSinksFromPreviousPeriod, representationsFromPreviousPeriod)
+            .then(() => {
 
                 // Set the initial time for this stream in the StreamProcessor
                 if (!isNaN(inputParameters.seekTime)) {
@@ -549,6 +553,25 @@ function StreamController() {
         })
     }
 
+    function _getSourceBufferSinksFromPreviousPeriod(previousStream) {
+        const sourceBufferSinkMap = new Map();
+
+        if (!previousStream) {
+            return sourceBufferSinkMap;
+        }
+
+        const previousStreamProcessors = previousStream ? previousStream.getStreamProcessors() : [];
+
+        previousStreamProcessors.forEach((streamProcessor) => {
+            const sourceBufferSink = streamProcessor.getBuffer();
+            if (sourceBufferSink) {
+                sourceBufferSinkMap.set(sourceBufferSink.getType(), sourceBufferSink);
+            }
+        })
+
+        return sourceBufferSinkMap
+    }
+
     /**
      * A playback seeking event was triggered. We need to disable the preloading streams and call the respective seeking handler.
      * We distinguish between inner period seeks and outer period seeks
@@ -693,17 +716,22 @@ function StreamController() {
      */
     function _onStreamCanLoadNext(nextStream, previousStream = null) {
 
-        if (mediaSource && !nextStream.getPreloaded()) {
-            let seamlessPeriodSwitch = _canSourceBuffersBeKept(nextStream, previousStream);
+        if (!mediaSource || nextStream.getPreloaded()) {
+            return;
+        }
 
-            if (seamlessPeriodSwitch) {
-                const representationsFromPreviousPeriod = _getRepresentationsFromPreviousPeriod(previousStream);
-                nextStream.startPreloading(mediaSource, bufferSinks, representationsFromPreviousPeriod)
-                    .then(() => {
-                        preloadingStreams.push(nextStream);
-                    });
-            }
+        let seamlessPeriodSwitch = _canSourceBuffersBeKept(nextStream, previousStream);
+
+        if (!seamlessPeriodSwitch) {
+            return;
         }
+
+        const representationsFromPreviousPeriod = _getRepresentationsFromPreviousPeriod(previousStream);
+        const previousSourceBufferSinks = _getSourceBufferSinksFromPreviousPeriod(previousStream);
+        nextStream.startPreloading(mediaSource, previousSourceBufferSinks, representationsFromPreviousPeriod)
+            .then(() => {
+                preloadingStreams.push(nextStream);
+            });
     }
 
     /**
@@ -904,9 +932,7 @@ function StreamController() {
 
             // If the preloading for the current stream is not scheduled, but its predecessor has finished buffering we can start prebuffering this stream
             if (!stream.getPreloaded() && previousStream.getHasFinishedBuffering()) {
-                if (mediaSource) {
-                    _onStreamCanLoadNext(stream, previousStream);
-                }
+                _onStreamCanLoadNext(stream, previousStream);
             }
             i += 1;
         }
@@ -1307,7 +1333,6 @@ function StreamController() {
 
                     let allUTCTimingSources = (!adapter.getIsDynamic()) ? manifestUTCTimingSources : manifestUTCTimingSources.concat(customParametersModel.getUTCTimingSources());
                     timeSyncController.attemptSync(allUTCTimingSources, adapter.getIsDynamic());
-
                     extUrlQueryInfoController.createFinalQueryStrings(manifest);
                 });
         } else {