@stremio/stremio-video 0.0.8 → 0.0.12

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@stremio/stremio-video",
-    "version": "0.0.8",
+    "version": "0.0.12",
     "description": "Abstraction layer on top of different media players",
     "author": "Smart Code OOD",
     "main": "src/index.js",
@@ -15,14 +15,15 @@
     "dependencies": {
         "deep-freeze": "0.0.1",
         "eventemitter3": "4.0.7",
-        "hls.js": "0.14.16",
+        "hat": "0.0.3",
+        "hls.js": "https://github.com/Stremio/hls.js/releases/download/v1.0.10-patch1/hls.js-1.0.10-patch1.tgz",
         "lodash.clonedeep": "4.5.0",
-        "magnet-uri": "5.2.4",
+        "magnet-uri": "6.2.0",
         "url": "0.11.0",
         "video-name-parser": "1.4.6",
-        "vtt.js": "0.13.0"
+        "vtt.js": "git://github.com/jaruba/vtt.js.git#e4f5f5603730866bacb174a93f51b734c9f29e6a"
     },
     "devDependencies": {
-        "eslint": "7.6.0"
+        "eslint": "7.32.0"
     }
 }

package/src/ChromecastSenderVideo/ChromecastSenderVideo.js

@@ -63,9 +63,10 @@ function ChromecastSenderVideo(options) {
         extraSubtitlesShadowColor: false
     };
 
-    function onTransportError(error) {
+    function onTransportError(error, message) {
         events.emit('error', Object.assign({}, ERROR.CHROMECAST_SENDER_VIDEO.MESSAGE_SEND_FAILED, {
-            error: error
+            error: error,
+            message: message
         }));
     }
     function onMessage(message) {
@@ -75,14 +76,14 @@ function ChromecastSenderVideo(options) {
         } catch (error) {
             events.emit('error', Object.assign({}, ERROR.CHROMECAST_SENDER_VIDEO.INVALID_MESSAGE_RECEIVED, {
                 error: error,
-                data: message
+                message: message
             }));
             return;
         }
 
         if (!parsedMessage || typeof parsedMessage.event !== 'string') {
             events.emit('error', Object.assign({}, ERROR.CHROMECAST_SENDER_VIDEO.INVALID_MESSAGE_RECEIVED, {
-                data: message
+                message: message
             }));
             return;
         }
@@ -146,16 +147,22 @@ function ChromecastSenderVideo(options) {
             switch (action.type) {
                 case 'observeProp': {
                     observeProp(action.propName);
-                    chromecastTransport.sendMessage(action).catch(onTransportError);
+                    chromecastTransport.sendMessage(action).catch(function(error) {
+                        onTransportError(error, action);
+                    });
                     return;
                 }
                 case 'setProp': {
-                    chromecastTransport.sendMessage(action).catch(onTransportError);
+                    chromecastTransport.sendMessage(action).catch(function(error) {
+                        onTransportError(error, action);
+                    });
                     return;
                 }
                 case 'command': {
                     command(action.commandName, action.commandArgs);
-                    chromecastTransport.sendMessage(action).catch(onTransportError);
+                    chromecastTransport.sendMessage(action).catch(function(error) {
+                        onTransportError(error, action);
+                    });
                     return;
                 }
             }
@@ -174,7 +181,7 @@ ChromecastSenderVideo.manifest = {
     external: true,
     props: ['stream', 'paused', 'time', 'duration', 'buffering', 'buffered', 'volume', 'muted', 'subtitlesTracks', 'selectedSubtitlesTrackId', 'extraSubtitlesTracks', 'selectedExtraSubtitlesTrackId', 'extraSubtitlesDelay', 'extraSubtitlesSize', 'extraSubtitlesOffset', 'extraSubtitlesTextColor', 'extraSubtitlesBackgroundColor', 'extraSubtitlesShadowColor'],
     commands: ['load', 'unload', 'destroy', 'addExtraSubtitlesTracks'],
-    events: ['propChanged', 'propValue', 'ended', 'error', 'subtitlesTrackLoaded', 'extraSubtitlesTrackLoaded', 'implementationChanged']
+    events: ['propValue', 'propChanged', 'ended', 'error', 'subtitlesTrackLoaded', 'extraSubtitlesTrackLoaded', 'implementationChanged']
 };
 
 module.exports = ChromecastSenderVideo;

package/src/HTMLVideo/HTMLVideo.js

@@ -3,6 +3,8 @@ var Hls = require('hls.js');
 var cloneDeep = require('lodash.clonedeep');
 var deepFreeze = require('deep-freeze');
 var ERROR = require('../error');
+var getContentType = require('./getContentType');
+var HLS_CONFIG = require('./hlsConfig');
 
 function HTMLVideo(options) {
     options = options || {};
@@ -151,6 +153,9 @@ function HTMLVideo(options) {
 
                 return !!videoElement.muted;
             }
+            default: {
+                return null;
+            }
         }
     }
     function onVideoError() {
@@ -256,7 +261,7 @@ function HTMLVideo(options) {
                             }
 
                             if (contentType === 'application/vnd.apple.mpegurl' && Hls.isSupported()) {
-                                hls = new Hls();
+                                hls = new Hls(HLS_CONFIG);
                                 hls.loadSource(stream.url);
                                 hls.attachMedia(videoElement);
                             } else {
@@ -356,21 +361,6 @@ function HTMLVideo(options) {
     };
 }
 
-function getContentType(stream) {
-    if (!stream || typeof stream.url !== 'string') {
-        return Promise.reject(new Error('Invalid stream parameter!'));
-    }
-
-    if (stream.behaviorHints && stream.behaviorHints.headers && typeof stream.behaviorHints.headers['content-type'] === 'string') {
-        return Promise.resolve(stream.behaviorHints.headers['content-type']);
-    }
-
-    return fetch(stream.url, { method: 'HEAD' })
-        .then(function(resp) {
-            return resp.headers.get('content-type');
-        });
-}
-
 HTMLVideo.canPlayStream = function(stream) {
     if (!stream || (stream.behaviorHints && stream.behaviorHints.notWebReady)) {
         return Promise.resolve(false);
@@ -391,7 +381,7 @@ HTMLVideo.manifest = {
     external: false,
     props: ['stream', 'paused', 'time', 'duration', 'buffering', 'buffered', 'volume', 'muted'],
     commands: ['load', 'unload', 'destroy'],
-    events: ['propChanged', 'propValue', 'ended', 'error']
+    events: ['propValue', 'propChanged', 'ended', 'error']
 };
 
 module.exports = HTMLVideo;

package/src/HTMLVideo/getContentType.js

@@ -0,0 +1,16 @@
+function getContentType(stream) {
+    if (!stream || typeof stream.url !== 'string') {
+        return Promise.reject(new Error('Invalid stream parameter!'));
+    }
+
+    if (stream.behaviorHints && stream.behaviorHints.headers && typeof stream.behaviorHints.headers['content-type'] === 'string') {
+        return Promise.resolve(stream.behaviorHints.headers['content-type']);
+    }
+
+    return fetch(stream.url, { method: 'HEAD' })
+        .then(function(resp) {
+            return resp.headers.get('content-type');
+        });
+}
+
+module.exports = getContentType;

package/src/HTMLVideo/hlsConfig.js

@@ -0,0 +1,15 @@
+module.exports = {
+    debug: false,
+    enableWorker: true,
+    lowLatencyMode: false,
+    backBufferLength: 0,
+    maxBufferLength: 80,
+    maxMaxBufferLength: 80,
+    maxFragLookUpTolerance: 0,
+    maxBufferHole: 0,
+    appendErrorMaxRetry: 20,
+    nudgeMaxRetry: 20,
+    manifestLoadingTimeOut: 30000,
+    manifestLoadingMaxRetry: 10,
+    // liveDurationInfinity: false
+};

package/src/IFrameVideo/IFrameVideo.js

@@ -0,0 +1,130 @@
+var EventEmitter = require('eventemitter3');
+var cloneDeep = require('lodash.clonedeep');
+var deepFreeze = require('deep-freeze');
+var ERROR = require('../error');
+
+function IFrameVideo(options) {
+    options = options || {};
+
+    var containerElement = options.containerElement;
+    if (!(containerElement instanceof HTMLElement)) {
+        throw new Error('Container element required to be instance of HTMLElement');
+    }
+
+    var iframeElement = document.createElement('iframe');
+    iframeElement.style.width = '100%';
+    iframeElement.style.height = '100%';
+    iframeElement.style.border = 0;
+    iframeElement.style.backgroundColor = 'black';
+    iframeElement.allowFullscreen = false;
+    containerElement.appendChild(iframeElement);
+
+    var events = new EventEmitter();
+    var destroyed = false;
+    var stream = null;
+    var observedProps = {
+        stream: false
+    };
+
+    function getProp(propName) {
+        switch (propName) {
+            case 'stream': {
+                return stream;
+            }
+            default: {
+                return null;
+            }
+        }
+    }
+    function onError(error) {
+        events.emit('error', error);
+        if (error.critical) {
+            command('unload');
+        }
+    }
+    function onPropChanged(propName) {
+        if (observedProps[propName]) {
+            events.emit('propChanged', propName, getProp(propName));
+        }
+    }
+    function observeProp(propName) {
+        if (observedProps.hasOwnProperty(propName)) {
+            events.emit('propValue', propName, getProp(propName));
+            observedProps[propName] = true;
+        }
+    }
+    function command(commandName, commandArgs) {
+        switch (commandName) {
+            case 'load': {
+                command('unload');
+                if (commandArgs && commandArgs.stream && typeof commandArgs.stream.playerFrameUrl === 'string') {
+                    stream = commandArgs.stream;
+                    onPropChanged('stream');
+                    iframeElement.src = commandArgs.stream.playerFrameUrl;
+                } else {
+                    onError(Object.assign({}, ERROR.UNSUPPORTED_STREAM, {
+                        critical: true,
+                        stream: commandArgs ? commandArgs.stream : null
+                    }));
+                }
+                break;
+            }
+            case 'unload': {
+                stream = null;
+                iframeElement.removeAttribute('src');
+                onPropChanged('stream');
+                break;
+            }
+            case 'destroy': {
+                command('unload');
+                destroyed = true;
+                events.removeAllListeners();
+                containerElement.removeChild(iframeElement);
+                break;
+            }
+        }
+    }
+
+    this.on = function(eventName, listener) {
+        if (destroyed) {
+            throw new Error('Video is destroyed');
+        }
+
+        events.on(eventName, listener);
+    };
+    this.dispatch = function(action) {
+        if (destroyed) {
+            throw new Error('Video is destroyed');
+        }
+
+        if (action) {
+            action = deepFreeze(cloneDeep(action));
+            switch (action.type) {
+                case 'observeProp': {
+                    observeProp(action.propName);
+                    return;
+                }
+                case 'command': {
+                    command(action.commandName, action.commandArgs);
+                    return;
+                }
+            }
+        }
+
+        throw new Error('Invalid action dispatched: ' + JSON.stringify(action));
+    };
+}
+
+IFrameVideo.canPlayStream = function(stream) {
+    return Promise.resolve(stream && typeof stream.playerFrameUrl === 'string');
+};
+
+IFrameVideo.manifest = {
+    name: 'IFrameVideo',
+    external: false,
+    props: ['stream'],
+    commands: ['load', 'unload', 'destroy'],
+    events: ['propValue', 'propChanged', 'error']
+};
+
+module.exports = IFrameVideo;

package/src/IFrameVideo/index.js

@@ -0,0 +1,3 @@
+var IFrameVideo = require('./IFrameVideo');
+
+module.exports = IFrameVideo;

package/src/StremioVideo/StremioVideo.js

@@ -1,15 +1,12 @@
 var EventEmitter = require('eventemitter3');
 var cloneDeep = require('lodash.clonedeep');
 var deepFreeze = require('deep-freeze');
+var selectVideoImplementation = require('./selectVideoImplementation');
+var ERROR = require('../error');
 
 function StremioVideo(options) {
     options = options || {};
 
-    var selectVideoImplementation = options.selectVideoImplementation;
-    if (typeof selectVideoImplementation !== 'function') {
-        throw new Error('selectVideoImplementation argument required');
-    }
-
     var video = null;
     var events = new EventEmitter();
     var destroyed = false;
@@ -35,6 +32,15 @@ function StremioVideo(options) {
                     video = null;
                 }
                 if (video === null) {
+                    if (Video === null) {
+                        events.emit('error', Object.assign({}, ERROR.UNSUPPORTED_STREAM, {
+                            error: new Error('No video implementation was selected'),
+                            critical: true,
+                            stream: action.commandArgs.stream
+                        }));
+                        return;
+                    }
+
                     video = new Video(Object.assign({}, options, action.commandArgs));
                     video.on('ended', function() {
                         events.emit('ended');

package/src/StremioVideo/selectVideoImplementation.js

@@ -0,0 +1,36 @@
+var ChromecastSenderVideo = require('../ChromecastSenderVideo');
+var HTMLVideo = require('../HTMLVideo');
+var IFrameVideo = require('../IFrameVideo');
+var YouTubeVideo = require('../YouTubeVideo');
+var withStreamingServer = require('../withStreamingServer');
+var withHTMLSubtitles = require('../withHTMLSubtitles');
+
+function selectVideoImplementation(args) {
+    if (!args.stream || typeof args.stream.externalUrl === 'string') {
+        return null;
+    }
+
+    if (args.chromecastTransport && args.chromecastTransport.getCastState() === cast.framework.CastState.CONNECTED) {
+        return ChromecastSenderVideo;
+    }
+
+    if (typeof args.stream.ytId === 'string') {
+        return withHTMLSubtitles(YouTubeVideo);
+    }
+
+    if (typeof args.stream.playerFrameUrl === 'string') {
+        return IFrameVideo;
+    }
+
+    if (typeof args.streamingServerURL === 'string') {
+        return withStreamingServer(withHTMLSubtitles(HTMLVideo));
+    }
+
+    if (typeof args.stream.url === 'string') {
+        return withHTMLSubtitles(HTMLVideo);
+    }
+
+    return null;
+}
+
+module.exports = selectVideoImplementation;

package/src/YouTubeVideo/YouTubeVideo.js

@@ -258,6 +258,9 @@ function YouTubeVideo(options) {
 
                 return selectedSubtitlesTrackId;
             }
+            default: {
+                return null;
+            }
         }
     }
     function onError(error) {
@@ -352,9 +355,9 @@ function YouTubeVideo(options) {
     function command(commandName, commandArgs) {
         switch (commandName) {
             case 'load': {
-                if (ready) {
-                    command('unload');
-                    if (commandArgs && commandArgs.stream && typeof commandArgs.stream.ytId === 'string') {
+                command('unload');
+                if (commandArgs && commandArgs.stream && typeof commandArgs.stream.ytId === 'string') {
+                    if (ready) {
                         stream = commandArgs.stream;
                         onPropChanged('stream');
                         var autoplay = typeof commandArgs.autoplay === 'boolean' ? commandArgs.autoplay : true;
@@ -379,13 +382,13 @@ function YouTubeVideo(options) {
                         onPropChanged('subtitlesTracks');
                         onPropChanged('selectedSubtitlesTrackId');
                     } else {
-                        onError(Object.assign({}, ERROR.UNSUPPORTED_STREAM, {
-                            critical: true,
-                            stream: commandArgs ? commandArgs.stream : null
-                        }));
+                        pendingLoadArgs = commandArgs;
                     }
                 } else {
-                    pendingLoadArgs = commandArgs;
+                    onError(Object.assign({}, ERROR.UNSUPPORTED_STREAM, {
+                        critical: true,
+                        stream: commandArgs ? commandArgs.stream : null
+                    }));
                 }
 
                 break;
@@ -466,7 +469,7 @@ YouTubeVideo.manifest = {
     external: false,
     props: ['stream', 'paused', 'time', 'duration', 'buffering', 'volume', 'muted', 'subtitlesTracks', 'selectedSubtitlesTrackId'],
     commands: ['load', 'unload', 'destroy'],
-    events: ['propChanged', 'propValue', 'ended', 'error', 'subtitlesTrackLoaded']
+    events: ['propValue', 'propChanged', 'ended', 'error', 'subtitlesTrackLoaded']
 };
 
 module.exports = YouTubeVideo;

package/src/error.js

@@ -50,36 +50,16 @@ var ERROR = {
         }
     },
     WITH_HTML_SUBTITLES: {
-        FETCH_FAILED: {
+        LOAD_FAILED: {
             code: 70,
-            message: 'Failed to fetch subtitles'
-        },
-        PARSE_FAILED: {
-            code: 71,
-            message: 'Failed to parse subtitles'
+            message: 'Failed to load external subtitles'
         }
     },
     WITH_STREAMING_SERVER: {
-        STREAM_CONVERT_FAILED: {
+        CONVERT_FAILED: {
             code: 60,
-            message: 'Unable to convert stream to url',
-        },
-        TRANSCODING_FAILED: {
-            code: 61,
-            message: 'Unable to transcode the next segment of the stream',
-        },
-        TRANSCODER_CREATE_FAILED: {
-            code: 62,
-            message: 'Failed to create transcoder'
-        },
-        TORRENT_CREATE_FAILED: {
-            code: 63,
-            message: 'Failed to create torrent'
-        },
-        NO_MEDIA_FILES_FOUND: {
-            code: 64,
-            message: 'No media files found into the torrent'
-        },
+            message: 'Unable to convert stream'
+        }
     },
     UNKNOWN_ERROR: {
         code: 1,

package/src/index.js

@@ -1,15 +1,3 @@
 var StremioVideo = require('./StremioVideo');
-var HTMLVideo = require('./HTMLVideo');
-var YouTubeVideo = require('./YouTubeVideo');
-var ChromecastSenderVideo = require('./ChromecastSenderVideo');
-var withHTMLSubtitles = require('./withHTMLSubtitles');
-var withStreamingServer = require('./withStreamingServer');
 
-module.exports = {
-    StremioVideo: StremioVideo,
-    HTMLVideo: HTMLVideo,
-    YouTubeVideo: YouTubeVideo,
-    ChromecastSenderVideo: ChromecastSenderVideo,
-    withHTMLSubtitles: withHTMLSubtitles,
-    withStreamingServer: withStreamingServer
-};
+module.exports = StremioVideo;

package/src/withHTMLSubtitles/subtitlesParser.js

@@ -1,52 +1,81 @@
 var VTTJS = require('vtt.js');
 var binarySearchUpperBound = require('./binarySearchUpperBound');
 
+var CRITICAL_ERROR_CODE = 0;
+
 function parse(text) {
-    var nativeVTTCue = window.VTTCue;
-    window.VTTCue = VTTJS.VTTCue;
-    var parser = new VTTJS.WebVTT.Parser(window, VTTJS.WebVTT.StringDecoder());
-    var cues = [];
-    var cuesByTime = {};
-    parser.oncue = function(c) {
-        var cue = {
-            startTime: (c.startTime * 1000) | 0,
-            endTime: (c.endTime * 1000) | 0,
-            text: c.text
+    return new Promise(function(resolve, reject) {
+        var parser = new VTTJS.WebVTT.Parser(window, VTTJS.WebVTT.StringDecoder());
+        var errors = [];
+        var cues = [];
+        var cuesByTime = {};
+
+        parser.oncue = function(c) {
+            var cue = {
+                startTime: (c.startTime * 1000) | 0,
+                endTime: (c.endTime * 1000) | 0,
+                text: c.text
+            };
+            cues.push(cue);
+            cuesByTime[cue.startTime] = cuesByTime[cue.startTime] || [];
+            cuesByTime[cue.endTime] = cuesByTime[cue.endTime] || [];
+        };
+
+        parser.onparsingerror = function(error) {
+            if (error.code === CRITICAL_ERROR_CODE) {
+                parser.oncue = null;
+                parser.onparsingerror = null;
+                parser.onflush = null;
+                reject(error);
+            } else {
+                console.warn('Subtitles parsing error', error);
+                errors.push(error);
+            }
         };
-        cues.push(cue);
-        cuesByTime[cue.startTime] = cuesByTime[cue.startTime] || [];
-        cuesByTime[cue.endTime] = cuesByTime[cue.endTime] || [];
-    };
-    parser.parse(text);
-    parser.flush();
-    window.VTTCue = nativeVTTCue;
-    cuesByTime.times = Object.keys(cuesByTime)
-        .map(function(time) {
-            return parseInt(time, 10);
-        })
-        .sort(function(t1, t2) {
-            return t1 - t2;
-        });
-    for (var i = 0; i < cues.length; i++) {
-        cuesByTime[cues[i].startTime].push(cues[i]);
-        var startTimeIndex = binarySearchUpperBound(cuesByTime.times, cues[i].startTime);
-        for (var j = startTimeIndex + 1; j < cuesByTime.times.length; j++) {
-            if (cues[i].endTime <= cuesByTime.times[j]) {
-                break;
+
+        parser.onflush = function() {
+            cuesByTime.times = Object.keys(cuesByTime)
+                .map(function(time) {
+                    return parseInt(time, 10);
+                })
+                .sort(function(t1, t2) {
+                    return t1 - t2;
+                });
+            for (var i = 0; i < cues.length; i++) {
+                cuesByTime[cues[i].startTime].push(cues[i]);
+                var startTimeIndex = binarySearchUpperBound(cuesByTime.times, cues[i].startTime);
+                for (var j = startTimeIndex + 1; j < cuesByTime.times.length; j++) {
+                    if (cues[i].endTime <= cuesByTime.times[j]) {
+                        break;
+                    }
+
+                    cuesByTime[cuesByTime.times[j]].push(cues[i]);
+                }
             }
 
-            cuesByTime[cuesByTime.times[j]].push(cues[i]);
-        }
-    }
+            for (var k = 0; k < cuesByTime.times.length; k++) {
+                cuesByTime[cuesByTime.times[k]].sort(function(c1, c2) {
+                    return c1.startTime - c2.startTime ||
+                        c1.endTime - c2.endTime;
+                });
+            }
 
-    for (var k = 0; k < cuesByTime.times.length; k++) {
-        cuesByTime[cuesByTime.times[k]].sort(function(c1, c2) {
-            return c1.startTime - c2.startTime ||
-                c1.endTime - c2.endTime;
-        });
-    }
+            parser.oncue = null;
+            parser.onparsingerror = null;
+            parser.onflush = null;
+            // we may have multiple parsing errors here, but will only respond with the first
+            // if subtitle cues are available, we will not reject the promise
+            if (cues.length === 0 && errors.length) {
+                reject(errors[0]);
+            } else if (cuesByTime.times.length === 0) {
+                reject(new Error('Missing subtitle track cues'));
+            } else {
+                resolve(cuesByTime);
+            }
+        };
 
-    return cuesByTime;
+        parser.parse(text);
+    });
 }
 
 module.exports = {