alternative fixes for timing issues and cmcd reporting for vast events

Author: cotid-qualabs

samples/alternative/alternative-media-presentations.html

@@ -100,7 +100,7 @@ <h5>VOD Configuration</h5>
 
                         <div class="mb-3">
                             <label class="form-label">Alternative VOD URL:</label>
-                            <input type="text" id="alternativeUrl" class="form-control" value="https://dash.akamaized.net/akamai/tos/tears-blend-no-steering.mpd" />
+                            <input type="text" id="alternativeUrl" class="form-control" value="http://localhost:3000/api/list-mpd?vasturl=http://localhost:3000/samples/dash-alt-mpd/vast-sample.xml" />
                         </div>
 
                         <div class="event-type-selector">
@@ -422,6 +422,29 @@ <h6>Generated Manifest Events:</h6>
             // Load without events - use attachSource with the URL
             player.attachSource(manifestUrl);
         }
+
+        player.on("alternativeContentReady", function(e) {
+            console.log(">>> Alternative content READY at:", performance.now());
+            const altPlayer = e.player;
+            if (altPlayer) {
+                const reporter = altPlayer.getCmcdReporter();
+                console.log(">>> Reporter:", reporter);
+
+                altPlayer.on("urn:mpeg:dash:event:callback:2015", function(callbackEvent, extra) {
+                    const eventType = callbackEvent.event.id;
+                    console.log(">>> Callback event received:", eventType, "mode:", extra?.mode, "at:", performance.now());
+
+                    if (reporter) {
+                        reporter.recordEvent("ce", { cen: `callback-event-${eventType}` });
+                    } else {
+                        console.log(">>> Reporter is null");
+                    }
+                });
+            } else {
+                console.log("AltPlayer not found")
+            }
+        });
+
     }
 
     document.addEventListener('DOMContentLoaded', function () {

src/dash/models/DashManifestModel.js

@@ -1350,9 +1350,12 @@ function DashManifestModel() {
                         event.duration = currentMpdEvent.duration / eventStream.timescale;
                     }
                     if (currentMpdEvent.hasOwnProperty(DashConstants.ID)) {
-                        event.id = parseInt(currentMpdEvent.id);
+                        // Preserve original ID (can be string or number) and also store parsed integer
+                        event.id = currentMpdEvent.id;
+                        event.idInt = parseInt(currentMpdEvent.id);
                     } else {
                         event.id = null;
+                        event.idInt = null;
                     }
                     if (currentMpdEvent.hasOwnProperty(DashConstants.STATUS)) {
                         event.status = currentMpdEvent.status;
@@ -1378,9 +1381,11 @@ function DashManifestModel() {
                         // to specifying a complete XML element(s) in the Event.
                         // It is useful when an event leans itself to a compact
                         // string representation'.
+                        // Support both __cdata (legacy) and #cdata (current XML parser format)
                         event.messageData =
                             currentMpdEvent.messageData ||
                             currentMpdEvent.__cdata ||
+                            currentMpdEvent['#cdata']?.nodeValue ||
                             currentMpdEvent.__text;
                     }
 

src/streaming/MediaManager.js

@@ -148,7 +148,7 @@ function MediaManager() {
         }
     }
 
-    function initializeAlternativePlayer(alternativeMpdUrl) {
+    function createAlternativePlayer() {
         if (altPlayer) {
             altPlayer.off(Events.ERROR, onAlternativePlayerError, this);
         }
@@ -158,10 +158,16 @@ function MediaManager() {
                 cacheInitSegments: true
             }
         });
-        altPlayer.initialize(null, alternativeMpdUrl, false, NaN);
-        altPlayer.preload();
         altPlayer.setAutoPlay(false);
         altPlayer.on(Events.ERROR, onAlternativePlayerError, this);
+        return altPlayer;
+    }
+
+    function loadAlternativeManifest(alternativeMpdUrl) {
+        if (altPlayer) {
+            altPlayer.initialize(null, alternativeMpdUrl, false, NaN);
+            altPlayer.preload();
+        }
     }
 
     function onAlternativePlayerError(e) {
@@ -170,7 +176,7 @@ function MediaManager() {
         }
     }
 
-    function switchToAlternativeContent(playerId, alternativeMpdUrl, time = 0) {
+    function switchToAlternativeContent(playerId, alternativeMpdUrl, time = 0, onReady = null) {
         if (isSwitching) {
             logger.debug('Switch already in progress - ignoring request');
             return
@@ -185,8 +191,23 @@ function MediaManager() {
             logger.info(`Using prebuffered content for player ${playerId}`);
             altPlayer = prebufferedContent.player;
             prebufferedPlayers.delete(playerId);
+
+            // Call onReady callback - for prebuffered, manifest is already loaded
+            if (onReady && typeof onReady === 'function') {
+                onReady(altPlayer);
+            }
         } else {
-            initializeAlternativePlayer(alternativeMpdUrl);
+            // Create player first WITHOUT loading manifest
+            createAlternativePlayer();
+
+            // Call onReady callback BEFORE loading manifest
+            // This allows listeners to be registered before ON_RECEIVE events fire
+            if (onReady && typeof onReady === 'function') {
+                onReady(altPlayer);
+            }
+
+            // Now load the manifest - this will trigger ON_RECEIVE events
+            loadAlternativeManifest(alternativeMpdUrl);
         }
 
         if (!altVideoElement) {

src/streaming/MediaPlayer.js

@@ -1372,6 +1372,18 @@ function MediaPlayer() {
         return dashMetrics;
     }
 
+    /**
+     * Returns the CmcdReporter instance for external access.
+     * This allows custom event recording and data updates from outside the player.
+     *
+     * @returns {CmcdReporter|null} The CmcdReporter instance or null if not initialized
+     * @memberof module:MediaPlayer
+     * @instance
+     */
+    function getCmcdReporter() {
+        return cmcdController ? cmcdController.getReporter() : null;
+    }
+
     /*
     ---------------------------------------------------------------------------
 
@@ -2908,6 +2920,7 @@ function MediaPlayer() {
         getCurrentSteeringResponseData,
         getCurrentTextTrackIndex,
         getCurrentTrackFor,
+        getCmcdReporter,
         getDashAdapter,
         getDashMetrics,
         getDebug,

src/streaming/constants/Constants.js

@@ -427,6 +427,7 @@ export default {
             NO_JUMP_DEFAULT: 1,
             NO_JUMP_PRIORITY: 2
         },
+        CONTENT_READY: 'alternativeContentReady',
         CONTENT_START: 'alternativeContentStart',
         CONTENT_END: 'alternativeContentEnd',
         EVENT_UPDATED: 'alternativeEventUpdated'

src/streaming/controllers/AlternativeMediaController.js

@@ -196,15 +196,27 @@ function AlternativeMediaController() {
                 actualEventPresentationTime = playbackController.getTime();
                 timeToSwitch = parsedEvent.startWithOffset ? actualEventPresentationTime - parsedEvent.presentationTime : 0;
                 timeToSwitch = timeToSwitch + _getAnchor(parsedEvent.alternativeMPD.url);
+
+                // Callback to trigger CONTENT_READY when player is ready but before playback starts
+                const onPlayerReady = (altPlayer) => {
+                    if (eventBus) {
+                        eventBus.trigger(Constants.ALTERNATIVE_MPD.CONTENT_READY, {
+                            event: parsedEvent,
+                            player: altPlayer
+                        });
+                    }
+                };
+
                 mediaManager.switchToAlternativeContent(
                     parsedEvent.id,
                     parsedEvent.alternativeMPD.url,
-                    timeToSwitch
+                    timeToSwitch,
+                    onPlayerReady
                 );
-                
+
                 // Trigger content start event
                 if (eventBus){
-                    eventBus.trigger(Constants.ALTERNATIVE_MPD.CONTENT_START, { 
+                    eventBus.trigger(Constants.ALTERNATIVE_MPD.CONTENT_START, {
                         event: parsedEvent,
                         player: mediaManager.getAlternativePlayer()
                     });

src/streaming/controllers/CmcdController.js

@@ -580,6 +580,15 @@ function CmcdController() {
         return cmcdModel.getCmcdParametersFromManifest();
     }
 
+    /**
+     * Returns the CmcdReporter instance for external access.
+     * This allows custom event recording and data updates from outside the player.
+     * @returns {CmcdReporter|null} The CmcdReporter instance or null if not initialized
+     */
+    function getReporter() {
+        return cmcdReporter;
+    }
+
     function reset() {
         eventBus.off(MediaPlayerEvents.PLAYBACK_RATE_CHANGED, _onPlaybackRateChanged, this);
         eventBus.off(MediaPlayerEvents.MANIFEST_LOADED, _onManifestLoaded, this);
@@ -605,6 +614,7 @@ function CmcdController() {
         getCmcdRequestInterceptors,
         getCmcdResponseInterceptors,
         getCmcdParametersFromManifest,
+        getReporter,
         initialize,
         isCmcdEnabled,
         reset,

src/streaming/controllers/EventController.js

@@ -185,13 +185,18 @@ function EventController() {
      */
     function _triggerEvents(events, presentationTimeThreshold, currentVideoTime) {
         try {
+            // Skip event processing if currentVideoTime is null or undefined (playback hasn't started)
+            if (currentVideoTime === null || currentVideoTime === undefined) {
+                return;
+            }
+
             const callback = function (event, currentPeriodEvents) {
                 if (event !== undefined) {
                     const duration = !isNaN(event.duration) ? event.duration : 0;
                     const isRetriggerable = _isRetriggerable(event);
                     const hasNoJump = _hasNoJumpValue(event);
                     const hasExecuteOnce = _hasExecuteOnceValue(event);
-                    
+
                     // Check if event is ready to resolve (earliestResolutionTimeOffset feature)
                     if (_checkEventReadyToResolve(event, currentVideoTime)) {
                         _triggerEventReadyToResolve(event);
@@ -200,12 +205,20 @@ function EventController() {
                     if (isRetriggerable && _canEventRetrigger(event, currentVideoTime, presentationTimeThreshold, hasExecuteOnce)) {
                         event.triggeredStartEvent = false;
                     }
-                    
+
                     // Handle noJump events first - these ignore duration and trigger when skipping ahead
                     if (hasNoJump && _shouldTriggerNoJumpEvent(event, currentVideoTime, currentPeriodEvents)) {
                         event.triggeredNoJumpEvent = true;
                         _startEvent(event, MediaPlayerEvents.EVENT_MODE_ON_START);
                     }
+                    // Special handling for presentationTime=0 events - fire ON_START immediately when playback starts
+                    // These events semantically mean "fire at the start of content" and should trigger as soon as playback begins
+                    else if (event.calculatedPresentationTime === 0 && currentVideoTime > 0) {
+                        _startEvent(event, MediaPlayerEvents.EVENT_MODE_ON_START);
+                        if (hasNoJump) {
+                            event.triggeredNoJumpEvent = true;
+                        }
+                    }
                     // Handle regular events - these check duration and timing
                     else if (event.calculatedPresentationTime <= currentVideoTime && event.calculatedPresentationTime + presentationTimeThreshold + duration >= currentVideoTime) {
                         _startEvent(event, MediaPlayerEvents.EVENT_MODE_ON_START);
@@ -267,7 +280,9 @@ function EventController() {
                     let event = values[i];
                     const currentTime = playbackController.getTime();
                     const duration = !isNaN(event.duration) ? event.duration : 0;
-                    if (!_eventHasExpired(currentTime, duration, event.calculatedPresentationTime)) {
+                    const isExpired = _eventHasExpired(currentTime, duration, event.calculatedPresentationTime, false, true);
+
+                    if (!isExpired) {
                         let result = _addOrUpdateEvent(event, inlineEvents[periodId], true);
 
                         if (result === EVENT_HANDLED_STATES.ADDED) {
@@ -812,15 +827,21 @@ function EventController() {
      * @param {number} threshold
      * @param {number} calculatedPresentationTimeInSeconds
      * @param {boolean} isRetriggerable
+     * @param {boolean} isInitialCheck - Whether this is the initial check during addInlineEvents
      * @return {boolean}
      * @private
      */
-    function _eventHasExpired(currentVideoTime, threshold, calculatedPresentationTimeInSeconds, isRetriggerable = false) {
+    function _eventHasExpired(currentVideoTime, threshold, calculatedPresentationTimeInSeconds, isRetriggerable = false, isInitialCheck = false) {
         try {
             // Retriggerables events don't expire in the traditional sense
             if (isRetriggerable) {
                 return false;
             }
+            // Events at presentationTime=0 should not be considered expired during the initial check
+            // because they semantically mean "fire at the start of content" and should always be processed
+            if (isInitialCheck && calculatedPresentationTimeInSeconds === 0) {
+                return false;
+            }
             return currentVideoTime - threshold > calculatedPresentationTimeInSeconds;
         } catch (e) {
             logger.error(e);
@@ -876,6 +897,8 @@ function EventController() {
                     logger.debug(`Starting callback event ${eventId} at ${currentVideoTime}`);
                     const url = event.messageData instanceof Uint8Array ? Utils.uint8ArrayToString(event.messageData) : event.messageData;
                     _sendCallbackRequest(url);
+                    // Also dispatch the callback event so external listeners can capture it (e.g., for CMCD reporting)
+                    eventBus.trigger(event.eventStream.schemeIdUri, { event }, { mode });
                 } else {
                     logger.debug(`Starting event ${eventId} from period ${event.eventStream.period.id} at ${currentVideoTime}`);
                     eventBus.trigger(event.eventStream.schemeIdUri, { event }, { mode });