@gcorevideo/player 2.28.28 → 2.28.29

package/dist/core.js

@@ -12862,6 +12862,8 @@ class DashPlayback extends BasePlayback {
     startChangeQuality = false;
     manifestInfo = null;
     _timeUpdateTimer = null;
+    oncueenter = null;
+    oncueexit = null;
     get name() {
         return 'dash';
     }
@@ -12904,6 +12906,7 @@ class DashPlayback extends BasePlayback {
         }
     }
     get _startTime() {
+        // TODO review
         if (this._playbackType === Playback.LIVE &&
             this._playlistType !== 'EVENT') {
             return this._extrapolatedStartTime;
@@ -12958,12 +12961,12 @@ class DashPlayback extends BasePlayback {
                 streaming: {
                     text: {
                         defaultEnabled: false,
+                        dispatchForManualRendering: true,
                     },
                 },
             }, this.options.dash);
             this._dash.updateSettings(settings);
         }
-        assert.ok(this.el instanceof HTMLMediaElement, 'el must be an HTMLMediaElement');
         this._dash.attachView(this.el);
         this._dash.setAutoPlay(false);
         this._dash.attachSource(this.options.src);
@@ -13007,6 +13010,19 @@ class DashPlayback extends BasePlayback {
                 this.trigger(Events$1.PLAYBACK_AUDIO_CHANGED, toClapprTrack$1(e.newMediaInfo));
             }
         });
+        this._dash.on(_.events.CUE_ENTER, (e) => {
+            this.oncueenter?.({
+                end: e.end,
+                id: e.id,
+                start: e.start,
+                text: e.text,
+            });
+        });
+        this._dash.on(_.events.CUE_EXIT, (e) => {
+            this.oncueexit?.({
+                id: e.id,
+            });
+        });
     }
     render() {
         this._ready();
@@ -13095,8 +13111,7 @@ class DashPlayback extends BasePlayback {
         this.trigger(Events$1.PLAYBACK_SETTINGSUPDATE);
     }
     _onPlaybackError = (event) => {
-        // TODO
-        trace(`${T$3} _onPlaybackError`, { event });
+        trace(`${T$3} _onPlaybackError`, { type: event.type, code: event.error.code, message: event.error.message });
     };
     _onDASHJSSError = (event) => {
         this._stopTimeUpdateTimer();
@@ -13215,7 +13230,14 @@ class DashPlayback extends BasePlayback {
             this._dash.off(_.events.ERROR, this._onDASHJSSError);
             this._dash.off(_.events.PLAYBACK_ERROR, this._onPlaybackError);
             this._dash.off(_.events.MANIFEST_LOADED, this.getDuration);
+            const tracks = this._dash.getTracksFor('text');
+            tracks.forEach(track => {
+                if (track.id) {
+                    this._dash.removeExternalSubtitleById(track.id);
+                }
+            });
             this._dash.reset();
+            this._dash.destroy();
             this._dash = null;
         }
     }
@@ -13233,8 +13255,6 @@ class DashPlayback extends BasePlayback {
         }
     }
     _fillLevels(levels) {
-        // TOOD check that levels[i].index === i
-        trace(`${T$3} _fillLevels`, { levels });
         this._levels = levels.map((level) => {
             return {
                 level: level.index,
@@ -13311,6 +13331,31 @@ class DashPlayback extends BasePlayback {
         super._handleTextTrackChange();
         this._dash?.setTextTrack(this.closedCaptionsTrackId);
     }
+    setTextTrack(id) {
+        this._dash?.setTextTrack(id);
+    }
+    /**
+     * @override
+     */
+    get closedCaptionsTracks() {
+        const tt = this.getTextTracks();
+        return tt;
+    }
+    getTextTracks() {
+        return this._dash?.getTracksFor('text').map((t, index) => ({
+            id: index,
+            name: getTextTrackLabel(t) || "",
+            track: {
+                id: index,
+                label: getTextTrackLabel(t) || "",
+                language: t.lang,
+                mode: "hidden",
+            },
+        })) || [];
+    }
+}
+function getTextTrackLabel(t) {
+    return t.labels.find((l) => !l.lang || l.lang === t.lang)?.text;
 }
 DashPlayback.canPlay = function (resource, mimeType) {
     if (!isDashSource(resource, mimeType)) {
@@ -49965,11 +50010,9 @@ const CLAPPR_VERSION = '0.13.0';
 const { now } = Utils;
 const AUTO = -1;
 const DEFAULT_RECOVER_ATTEMPTS = 16;
-Events$1.register('PLAYBACK_FRAGMENT_CHANGED');
 Events$1.register('PLAYBACK_FRAGMENT_PARSING_METADATA');
 const T$2 = 'playback.hls';
 class HlsPlayback extends BasePlayback {
-    _ccIsSetup = false;
     _ccTracksUpdated = false;
     _currentFragment = null;
     _currentLevel = null;
@@ -49993,6 +50036,10 @@ class HlsPlayback extends BasePlayback {
     _recoveredDecodingError = false;
     _segmentTargetDuration = null;
     _timeUpdateTimer = null;
+    oncueenter = null;
+    oncueexit = null;
+    cues = []; // TODO check the list size and use BST if needed
+    currentCueId = null;
     /**
      * @internal
      */
@@ -50187,7 +50234,7 @@ class HlsPlayback extends BasePlayback {
             return;
         }
         this._manifestParsed = false;
-        this._ccIsSetup = false;
+        // this._ccIsSetup = false
         this._ccTracksUpdated = false;
         this._setInitialState();
         this._hls.destroy();
@@ -50198,6 +50245,7 @@ class HlsPlayback extends BasePlayback {
             maxBufferLength: 2,
             maxMaxBufferLength: 4,
             autoStartLoad: false,
+            renderTextTracksNatively: false,
         }, this.options.playback.hlsjsConfig);
         this._hls = new Hls(config);
     }
@@ -50211,7 +50259,7 @@ class HlsPlayback extends BasePlayback {
         if (!this._hls) {
             return;
         }
-        this._hls.once(Hls.Events.MEDIA_ATTACHED, () => {
+        this._hls.once(Events.MEDIA_ATTACHED, () => {
             assert.ok(this._hls, 'HLS.js is not initialized');
             this.options.hlsPlayback.preload && this._hls.loadSource(this.options.src);
         });
@@ -50226,25 +50274,29 @@ class HlsPlayback extends BasePlayback {
             this.el.removeEventListener('playing', onPlaying);
         };
         this.el.addEventListener('playing', onPlaying);
-        this._hls.on(Hls.Events.MANIFEST_PARSED, () => {
+        this._hls.on(Events.MANIFEST_PARSED, () => {
             this._manifestParsed = true;
-            this._hls.startLoad(-1);
+            this.reload();
         });
-        this._hls.on(Hls.Events.LEVEL_LOADED, (evt, data) => {
+        this._hls.on(Events.LEVEL_LOADED, (evt, data) => {
             this._updatePlaybackType(evt, data);
         });
-        this._hls.on(Hls.Events.LEVEL_UPDATED, (evt, data) => this._onLevelUpdated(evt, data));
-        this._hls.on(Hls.Events.LEVEL_SWITCHING, (evt, data) => this._onLevelSwitch(evt, data));
-        this._hls.on(Hls.Events.LEVEL_SWITCHED, (evt, data) => this._onLevelSwitched(evt, data));
-        this._hls.on(Hls.Events.FRAG_CHANGED, (evt, data) => this._onFragmentChanged(evt, data));
-        this._hls.on(Hls.Events.FRAG_LOADED, (evt, data) => this._onFragmentLoaded(evt, data));
-        this._hls.on(Hls.Events.FRAG_PARSING_METADATA, (evt, data) => this._onFragmentParsingMetadata(evt, data));
-        this._hls.on(Hls.Events.ERROR, (evt, data) => this._onHLSJSError(evt, data));
-        // this._hls.on(HLSJS.Events.SUBTITLE_TRACK_LOADED, () =>
-        //   this._onSubtitleLoaded(),
-        // )
+        this._hls.on(Events.LEVEL_UPDATED, (evt, data) => this._onLevelUpdated(evt, data));
+        this._hls.on(Events.LEVEL_SWITCHING, (evt, data) => this._onLevelSwitch(evt, data));
+        this._hls.on(Events.LEVEL_SWITCHED, (evt, data) => this._onLevelSwitched(evt, data));
+        this._hls.on(Events.ERROR, (evt, data) => this._onHLSJSError(evt, data));
         this._hls.on(Events.AUDIO_TRACKS_UPDATED, (evt, data) => this._onAudioTracksUpdated(evt, data));
         this._hls.on(Events.AUDIO_TRACK_SWITCHED, (evt, data) => this._onAudioTrackSwitched(evt, data));
+        this._hls.on(Events.CUES_PARSED, (evt, data) => {
+            data.cues?.forEach((cue) => {
+                this.cues.push({
+                    id: cue.id,
+                    start: cue.startTime,
+                    end: cue.endTime,
+                    text: cue.text,
+                });
+            });
+        });
         this.bindCustomListeners();
     }
     bindCustomListeners() {
@@ -50263,13 +50315,6 @@ class HlsPlayback extends BasePlayback {
             requestedEventName && this._hls.off(requestedEventName, item.callback);
         });
     }
-    _onFragmentParsingMetadata(evt, data) {
-        // @ts-ignore
-        this.trigger(Events$1.Custom.PLAYBACK_FRAGMENT_PARSING_METADATA, {
-            evt,
-            data,
-        });
-    }
     render() {
         this._ready();
         return super.render();
@@ -50351,6 +50396,7 @@ class HlsPlayback extends BasePlayback {
         this.dvrEnabled && this._updateDvr(time < this.getDuration() - 3);
         time += this._startTime;
         this.el.currentTime = time;
+        this.triggerCues();
     }
     seekToLivePoint() {
         this.seek(this.getDuration());
@@ -50399,20 +50445,20 @@ class HlsPlayback extends BasePlayback {
             if (this._recoverAttemptsRemaining > 0) {
                 this._recoverAttemptsRemaining -= 1;
                 switch (data.type) {
-                    case Hls.ErrorTypes.NETWORK_ERROR:
+                    case ErrorTypes.NETWORK_ERROR:
                         switch (data.details) {
                             // The following network errors cannot be recovered with HLS.startLoad()
                             // For more details, see https://github.com/video-dev/hls.js/blob/master/doc/design.md#error-detection-and-handling
                             // For "level load" fatal errors, see https://github.com/video-dev/hls.js/issues/1138
                             // TODO test handling of these errors
-                            case Hls.ErrorDetails.MANIFEST_LOAD_ERROR:
-                            case Hls.ErrorDetails.MANIFEST_LOAD_TIMEOUT:
-                            case Hls.ErrorDetails.MANIFEST_PARSING_ERROR:
+                            case ErrorDetails.MANIFEST_LOAD_ERROR:
+                            case ErrorDetails.MANIFEST_LOAD_TIMEOUT:
+                            case ErrorDetails.MANIFEST_PARSING_ERROR:
                             // TODO sort out the errors below, perhaps some of them are recoverable
-                            case Hls.ErrorDetails.LEVEL_LOAD_ERROR:
-                            case Hls.ErrorDetails.LEVEL_LOAD_TIMEOUT:
-                            case Hls.ErrorDetails.FRAG_LOAD_ERROR:
-                            case Hls.ErrorDetails.FRAG_LOAD_TIMEOUT:
+                            case ErrorDetails.LEVEL_LOAD_ERROR:
+                            case ErrorDetails.LEVEL_LOAD_TIMEOUT:
+                            case ErrorDetails.FRAG_LOAD_ERROR:
+                            case ErrorDetails.FRAG_LOAD_TIMEOUT:
                                 Log.error('hlsjs: unrecoverable network fatal error.', {
                                     evt,
                                     data,
@@ -50429,11 +50475,11 @@ class HlsPlayback extends BasePlayback {
                                     details: data.details,
                                 });
                                 error.level = PlayerError.Levels.WARN;
-                                this._hls?.startLoad();
+                                this.reload();
                                 break;
                         }
                         break;
-                    case Hls.ErrorTypes.MEDIA_ERROR:
+                    case ErrorTypes.MEDIA_ERROR:
                         Log.warn('hlsjs: trying to recover from media error.', {
                             evt,
                             data,
@@ -50474,9 +50520,14 @@ class HlsPlayback extends BasePlayback {
             });
         }
     }
+    reload() {
+        this.cues = [];
+        this.currentCueId = null;
+        this._hls?.startLoad(-1);
+    }
     _keyIsDenied(data) {
-        return (data.type === Hls.ErrorTypes.NETWORK_ERROR &&
-            data.details === Hls.ErrorDetails.KEY_LOAD_ERROR &&
+        return (data.type === ErrorTypes.NETWORK_ERROR &&
+            data.details === ErrorDetails.KEY_LOAD_ERROR &&
             data.response &&
             data.response.code &&
             data.response.code >= 400);
@@ -50494,6 +50545,7 @@ class HlsPlayback extends BasePlayback {
         }
         this._lastTimeUpdate = update;
         this.trigger(Events$1.PLAYBACK_TIMEUPDATE, update, this.name);
+        this.triggerCues();
     }
     _onDurationChange() {
         const duration = this.getDuration();
@@ -50532,6 +50584,20 @@ class HlsPlayback extends BasePlayback {
         };
         this.trigger(Events$1.PLAYBACK_PROGRESS, progress, buffered);
     }
+    triggerCues() {
+        const currentTime = this.getCurrentTime();
+        // const cues = Object.values(this.cues)
+        // TODO build a search tree
+        const cue = this.cues.find((cue) => currentTime >= cue.start && currentTime <= cue.end);
+        if (cue) {
+            this.currentCueId = cue.id;
+            this.oncueenter?.(cue);
+        }
+        else if (this.currentCueId) {
+            this.oncueexit?.({ id: this.currentCueId });
+            this.currentCueId = null;
+        }
+    }
     load(url) {
         this._stopTimeUpdateTimer();
         this.options.src = url;
@@ -50723,26 +50789,6 @@ class HlsPlayback extends BasePlayback {
         durationChanged && this._onDurationChange();
         startTimeChanged && this._onProgress();
     }
-    _onFragmentChanged(evt, data) {
-        this._currentFragment = data.frag;
-        // @ts-ignore
-        this.trigger(Events$1.Custom.PLAYBACK_FRAGMENT_CHANGED, data);
-    }
-    _onFragmentLoaded(evt, data) {
-        this.trigger(Events$1.PLAYBACK_FRAGMENT_LOADED, data);
-    }
-    // _onSubtitleLoaded() {
-    //   trace(`${T} _onSubtitleLoaded`)
-    //   // This event may be triggered multiple times
-    //   // Setup CC only once (disable CC by default)
-    //   if (!this._ccIsSetup) {
-    //     this.trigger(Events.PLAYBACK_SUBTITLE_AVAILABLE)
-    //     const trackId =
-    //       this._playbackType === Playback.LIVE ? -1 : this.closedCaptionsTrackId
-    //     this.closedCaptionsTrackId = trackId
-    //     this._ccIsSetup = true
-    //   }
-    // }
     _onLevelSwitch(evt, data) {
         if (!this.levels.length) {
             this._fillLevels();
@@ -50814,6 +50860,26 @@ class HlsPlayback extends BasePlayback {
         const track = this._hls.audioTracks[data.id];
         this.trigger(Events$1.PLAYBACK_AUDIO_CHANGED, toClapprTrack(track));
     }
+    setTextTrack(id) {
+        this._hls.subtitleTrack = id;
+    }
+    /**
+     * @override
+     */
+    get closedCaptionsTracks() {
+        return this.getTextTracks();
+    }
+    getTextTracks() {
+        return this._hls?.subtitleTracks.map((t) => ({
+            id: t.id,
+            name: t.name,
+            track: {
+                id: t.id,
+                label: t.name,
+                language: t.lang,
+            },
+        })) || [];
+    }
 }
 HlsPlayback.canPlay = function (resource, mimeType) {
     if (!isHlsSource(resource, mimeType)) {
@@ -51415,7 +51481,7 @@ class Player {
     }
 }
 
-var version$1 = "2.28.28";
+var version$1 = "2.28.29";
 
 var packages = {
 	"node_modules/@clappr/core": {