@stremio/stremio-video 0.0.20-rc.6 → 0.0.21

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@stremio/stremio-video",
-    "version": "0.0.20-rc.6",
+    "version": "0.0.21",
     "description": "Abstraction layer on top of different media players",
     "author": "Smart Code OOD",
     "main": "src/index.js",
@@ -16,7 +16,7 @@
         "deep-freeze": "0.0.1",
         "eventemitter3": "4.0.7",
         "hat": "0.0.3",
-        "hls.js": "https://github.com/Stremio/hls.js/releases/download/v1.0.10-patch2/hls.js-1.0.10-patch2.tgz",
+        "hls.js": "https://github.com/Stremio/hls.js/releases/download/v1.2.3-patch1/hls.js-1.2.3-patch1.tgz",
         "lodash.clonedeep": "4.5.0",
         "magnet-uri": "6.2.0",
         "url": "0.11.0",

package/src/HTMLVideo/getContentType.js

@@ -3,8 +3,8 @@ function getContentType(stream) {
         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']);
+    if (stream.behaviorHints && stream.behaviorHints.proxyHeaders && stream.behaviorHints.proxyHeaders.response && typeof stream.behaviorHints.proxyHeaders.response['content-type'] === 'string') {
+        return Promise.resolve(stream.behaviorHints.proxyHeaders.response['content-type']);
     }
 
     return fetch(stream.url, { method: 'HEAD' })

package/src/ShellVideo/ShellVideo.js

@@ -0,0 +1,436 @@
+var EventEmitter = require('eventemitter3');
+var cloneDeep = require('lodash.clonedeep');
+var deepFreeze = require('deep-freeze');
+var ERROR = require('../error');
+
+var SUBS_SCALE_FACTOR = 0.0066;
+
+var stremioToMPVProps = {
+    'stream': null,
+    'paused': 'pause',
+    'time': 'time-pos',
+    'duration': 'duration',
+    'buffering': 'buffering',
+    'volume': 'volume',
+    'muted': 'mute',
+    'playbackSpeed': 'speed',
+    'audioTracks': 'audioTracks',
+    'selectedAudioTrackId': 'aid',
+    'subtitlesTracks': 'subtitlesTracks',
+    'selectedSubtitlesTrackId': 'sid',
+    'subtitlesSize': 'sub-scale',
+    'subtitlesTextColor': 'sub-color',
+    'subtitlesBackgroundColor': 'sub-back-color',
+    'subtitlesOutlineColor': 'sub-border-color',
+};
+
+function ShellVideo(options) {
+    options = options || {};
+
+    var ipc = options.shellTransport;
+
+    var stremioProps = {};
+    Object.keys(stremioToMPVProps).forEach(function(key) {
+        if(stremioToMPVProps[key]) {
+            stremioProps[stremioToMPVProps[key]] = key;
+        }
+    });
+
+    ipc.send('mpv-command', ['stop']);
+    ipc.send('mpv-observe-prop', 'path');
+
+    ipc.send('mpv-observe-prop', 'time-pos');
+    ipc.send('mpv-observe-prop', 'volume');
+    ipc.send('mpv-observe-prop', 'pause');
+    ipc.send('mpv-observe-prop', 'seeking');
+    ipc.send('mpv-observe-prop', 'eof-reached');
+
+    ipc.send('mpv-observe-prop', 'duration');
+    ipc.send('mpv-observe-prop', 'metadata');
+    ipc.send('mpv-observe-prop', 'video-params'); // video width/height
+    ipc.send('mpv-observe-prop', 'track-list');
+
+    ipc.send('mpv-observe-prop', 'paused-for-cache');
+    ipc.send('mpv-observe-prop', 'cache-buffering-state');
+
+    ipc.send('mpv-observe-prop', 'aid');
+    ipc.send('mpv-observe-prop', 'vid');
+    ipc.send('mpv-observe-prop', 'sid');
+    ipc.send('mpv-observe-prop', 'sub-scale');
+    ipc.send('mpv-observe-prop', 'sub-pos');
+    ipc.send('mpv-observe-prop', 'speed');
+
+    ipc.send('mpv-observe-prop', 'mpv-version');
+    ipc.send('mpv-observe-prop', 'ffmpeg-version');
+
+    var events = new EventEmitter();
+    var destroyed = false;
+    var stream = null;
+    // var selectedSubtitlesTrackId = null;
+    var observedProps = {};
+    var continueFrom = 0;
+
+    var avgDuration = 0;
+    var minClipDuration = 30;
+    var props = { };
+
+    function setBackground(visible) {
+        // This is a bit of a hack but there is no better way so far
+        var bg = visible ? '' : 'transparent';
+        for(var container = options.containerElement; container; container = container.parentElement) {
+            container.style.background = bg;
+        }
+    }
+    function logProp(args) {
+        // eslint-disable-next-line no-console
+        console.log(args.name+': '+args.data);
+    }
+    function embeddedProp(args) {
+        return args.data ? 'EMBEDDED_' + args.data.toString() : null;
+    }
+
+    var last_time = 0;
+    ipc.on('mpv-prop-change', function(args) {
+        switch (args.name) {
+            case 'mpv-version':
+            case 'ffmpeg-version': {
+                props[args.name] = logProp(args);
+                break;
+            }
+            case 'duration': {
+                var intDuration = args.data | 0;
+                // Accumulate average duration over time. if it is greater than minClipDuration
+                // and equal to the currently reported duration, it is returned as video length.
+                // If the reported duration changes over time the average duration is always
+                // smaller than the currently reported one so we set the video length to 0 as
+                // this is a live stream.
+                props[args.name] = args.data >= minClipDuration && (!avgDuration || intDuration === avgDuration) ? Math.round(args.data * 1000) : null;
+                // The average duration is calculated using right bit shifting by one of the sum of
+                // the previous average and the currently reported value. This method is not very precise
+                // as we get integer value but we avoid floating point errors. JS uses 32 bit values
+                // for bitwise maths so the maximum supported video duration is 1073741823 (2 ^ 30 - 1)
+                // which is around 34 years of playback time.
+                avgDuration = avgDuration ? (avgDuration + intDuration) >> 1 : intDuration;
+                break;
+            }
+            case 'time-pos': {
+                props[args.name] = Math.round(args.data*1000);
+                if(continueFrom) {
+                    ipc.send('mpv-set-prop', ['time-pos', continueFrom]);
+                    props[args.name] = Math.round(continueFrom);
+                    continueFrom = 0;
+                }
+                break;
+            }
+            case 'sub-scale': {
+                props[args.name] = Math.round(args.data / SUBS_SCALE_FACTOR);
+                break;
+            }
+            case 'paused-for-cache':
+            case 'seeking':
+            {
+                if(props.buffering !== args.data) {
+                    props.buffering = args.data;
+                    onPropChanged('buffering');
+                }
+                break;
+            }
+            case 'aid':
+            case 'sid':
+            case 'vid': {
+                props[args.name] = embeddedProp(args);
+                break;
+            }
+            // In that case onPropChanged() is manually invoked as track-list contains all
+            // the tracks but we have different event for each track type
+            case 'track-list': {
+                props.audioTracks = args.data.filter(function(x) { return x.type === 'audio'; })
+                    .map(function(x, index) {
+                        return {
+                            id: 'EMBEDDED_' + x.id,
+                            lang: x.lang === undefined ? 'Track' + (index + 1) : x.lang,
+                            label: x.title === undefined || x.lang === undefined ? '' : x.title || x.lang,
+                            origin: 'EMBEDDED',
+                            embedded: true,
+                            mode: x.id === props.aid ? 'showing' : 'disabled',
+                        };
+                    });
+                onPropChanged('audioTracks');
+
+                props.subtitlesTracks = args.data
+                    .filter(function(x) { return x.type === 'sub'; })
+                    .map(function(x, index) {
+                        return {
+                            id: 'EMBEDDED_' + x.id,
+                            lang: x.lang === undefined ? 'Track ' + (index + 1) : x.lang,
+                            label: x.title === undefined || x.lang === undefined ? '' : x.title || x.lang,
+                            origin: 'EMBEDDED',
+                            embedded: true,
+                            mode: x.id === props.sid ? 'showing' : 'disabled',
+                        };
+                    });
+                onPropChanged('subtitlesTracks');
+                break;
+            }
+            default: {
+                props[args.name] = args.data;
+                break;
+            }
+        }
+
+        // Cap time update to update only when a second passes
+        var current_time = args.name === 'time-pos' ? Math.floor(props['time-pos'] / 1000) : null;
+        if((!current_time || last_time !== current_time)&& stremioProps[args.name]) {
+            if(current_time) {
+                last_time = current_time;
+            }
+            onPropChanged(stremioProps[args.name]);
+        }
+    });
+    ipc.on('mpv-event-ended', function(args) {
+        if (args.error) onError(args.error);
+        else onEnded();
+    });
+
+    function getProp(propName) {
+        if(stremioToMPVProps[propName]) return props[stremioToMPVProps[propName]];
+        // eslint-disable-next-line no-console
+        console.log('Unsupported prop requested', propName);
+        return null;
+    }
+    function onError(error) {
+        events.emit('error', error);
+        if (error.critical) {
+            command('unload');
+        }
+    }
+    function onEnded() {
+        events.emit('ended');
+    }
+    function onPropChanged(propName) {
+        if (observedProps[propName]) {
+            events.emit('propChanged', propName, getProp(propName));
+        }
+    }
+    function observeProp(propName) {
+        events.emit('propValue', propName, getProp(propName));
+        observedProps[propName] = true;
+    }
+    function setProp(propName, propValue) {
+        switch (propName) {
+            case 'paused': {
+                if (stream !== null) {
+                    ipc.send('mpv-set-prop', ['pause', propValue]);
+                }
+
+                break;
+            }
+            case 'time': {
+                if (stream !== null && propValue !== null && isFinite(propValue)) {
+                    ipc.send('mpv-set-prop', ['time-pos', propValue/1000]);
+                }
+
+                break;
+            }
+            case 'playbackSpeed': {
+                if (stream !== null && propValue !== null && isFinite(propValue)) {
+                    ipc.send('mpv-set-prop', ['speed', propValue]);
+                }
+                break;
+            }
+            case 'volume': {
+                if (stream !== null && propValue !== null && isFinite(propValue)) {
+                    props.mute = false;
+                    ipc.send('mpv-set-prop', ['mute', 'no']);
+                    ipc.send('mpv-set-prop', ['volume', propValue]);
+                    onPropChanged('muted');
+                    onPropChanged('volume');
+                }
+                break;
+            }
+            case 'muted': {
+                if (stream !== null) {
+                    ipc.send('mpv-set-prop', ['mute', propValue ? 'yes' : 'no']);
+                    props.mute = propValue;
+                    onPropChanged('muted');
+                }
+                break;
+            }
+            case 'selectedAudioTrackId': {
+                if (stream !== null) {
+                    var actualId = propValue.slice('EMBEDDED_'.length);
+                    ipc.send('mpv-set-prop', ['aid', actualId]);
+                }
+                break;
+            }
+            case 'selectedSubtitlesTrackId': {
+                if (stream !== null) {
+                    if(propValue) {
+                        var actualId = propValue.slice('EMBEDDED_'.length);
+                        ipc.send('mpv-set-prop', ['sid', actualId]);
+                        events.emit('subtitlesTrackLoaded', propValue);
+                    } else {
+                        // turn off subs
+                        ipc.send('mpv-set-prop', ['sid', 'no']);
+                        props.sid = null;
+                    }
+                }
+                onPropChanged('selectedSubtitlesTrackId');
+                break;
+            }
+            case 'subtitlesSize': {
+                ipc.send('mpv-set-prop', [stremioToMPVProps[propName], propValue * SUBS_SCALE_FACTOR]);
+                break;
+            }
+            case 'subtitlesOffset': {
+                ipc.send('mpv-set-prop', [stremioToMPVProps[propName], propValue]);
+                break;
+            }
+            case 'subtitlesTextColor':
+            case 'subtitlesBackgroundColor':
+            case 'subtitlesOutlineColor':
+            {
+                // MPV accepts color in #AARRGGBB
+                var argb = propValue.replace(/^#(\w{6})(\w{2})$/, '#$2$1');
+                ipc.send('mpv-set-prop', [stremioToMPVProps[propName], argb]);
+                break;
+            }
+            default: {
+                // eslint-disable-next-line no-console
+                console.log('Unhandled setProp for', propName);
+            }
+        }
+    }
+    function command(commandName, commandArgs) {
+        switch (commandName) {
+            case 'load': {
+                command('unload');
+                if (commandArgs && commandArgs.stream && typeof commandArgs.stream.url === 'string') {
+                    stream = commandArgs.stream;
+                    onPropChanged('stream');
+                    continueFrom = commandArgs.time !== null && isFinite(commandArgs.time) ? parseInt(commandArgs.time, 10) / 1000 : 0;
+
+                    setBackground(false);
+
+                    ipc.send('mpv-set-prop', ['no-sub-ass']);
+
+                    // opengl-cb is an alias for the new name "libmpv", as shown in mpv's video/out/vo.c aliases
+                    // opengl is an alias for the new name "gpu"
+                    // When on Windows we use d3d for the rendering in separate window
+                    var windowRenderer = navigator.platform === 'Win32' ? 'direct3d' : 'opengl';
+                    var videoOutput = options.mpvSeparateWindow ? windowRenderer : 'opengl-cb';
+                    var separateWindow = options.mpvSeparateWindow ? 'yes' : 'no';
+                    ipc.send('mpv-set-prop', ['vo', videoOutput]);
+                    ipc.send('mpv-set-prop', ['osc', separateWindow]);
+                    ipc.send('mpv-set-prop', ['input-defalt-bindings', separateWindow]);
+                    ipc.send('mpv-set-prop', ['input-vo-keyboard', separateWindow]);
+
+                    ipc.send('mpv-command', ['loadfile', stream.url]);
+                    ipc.send('mpv-set-prop', ['pause', false]);
+                    ipc.send('mpv-set-prop', ['speed', props.speed]);
+                    ipc.send('mpv-set-prop', ['aid', props.aid]);
+                    ipc.send('mpv-set-prop', ['mute', 'no']);
+
+                    onPropChanged('paused');
+                    onPropChanged('time');
+                    onPropChanged('duration');
+                    onPropChanged('buffering');
+                    onPropChanged('volume');
+                    onPropChanged('muted');
+                    onPropChanged('subtitlesTracks');
+                    onPropChanged('selectedSubtitlesTrackId');
+                } else {
+                    onError(Object.assign({}, ERROR.UNSUPPORTED_STREAM, {
+                        critical: true,
+                        stream: commandArgs ? commandArgs.stream : null
+                    }));
+                }
+
+                break;
+            }
+            case 'unload': {
+                props = {
+                    mute: false,
+                    speed: 1,
+                    subtitlesTracks: [],
+                    buffering: true,
+                    aid: null,
+                    sid: null,
+                };
+                continueFrom = 0;
+                avgDuration = 0;
+                ipc.send('mpv-command', ['stop']);
+                onPropChanged('stream');
+                onPropChanged('paused');
+                onPropChanged('time');
+                onPropChanged('duration');
+                onPropChanged('buffering');
+                onPropChanged('volume');
+                onPropChanged('muted');
+                onPropChanged('subtitlesTracks');
+                onPropChanged('selectedSubtitlesTrackId');
+                setBackground(true);
+                break;
+            }
+            case 'destroy': {
+                command('unload');
+                destroyed = true;
+                events.removeAllListeners();
+                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);
+                    break;
+                }
+                case 'setProp': {
+                    setProp(action.propName, action.propValue);
+                    return;
+                }
+                case 'command': {
+                    command(
+                        action.commandName,
+                        action.commandArgs
+                    );
+                    return;
+                }
+            }
+        }
+    };
+}
+ShellVideo.canPlayStream = function() {
+    return Promise.resolve(true);
+};
+
+ShellVideo.manifest = {
+    name: 'ShellVideo',
+    external: false,
+    props: Object.keys(stremioToMPVProps),
+    commands: ['load', 'unload', 'destroy'],
+    events: [
+        'propValue',
+        'propChanged',
+        'ended',
+        'error',
+        'subtitlesTrackLoaded',
+    ],
+};
+
+module.exports = ShellVideo;

package/src/ShellVideo/index.js

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

package/src/StremioVideo/selectVideoImplementation.js

@@ -1,4 +1,5 @@
 var ChromecastSenderVideo = require('../ChromecastSenderVideo');
+var ShellVideo = require('../ShellVideo');
 var HTMLVideo = require('../HTMLVideo');
 var TizenVideo = require('../TizenVideo');
 var IFrameVideo = require('../IFrameVideo');
@@ -22,6 +23,9 @@ function selectVideoImplementation(commandArgs, options) {
     if (typeof commandArgs.stream.playerFrameUrl === 'string') {
         return IFrameVideo;
     }
+    if (options.shellTransport) {
+        return withStreamingServer(withHTMLSubtitles(ShellVideo));
+    }
 
     if (typeof commandArgs.streamingServerURL === 'string') {
         if (typeof global.tizen !== 'undefined') {

package/src/TizenVideo/TizenVideo.js

@@ -17,6 +17,8 @@ function TizenVideo(options) {
         throw new Error('Container element required to be instance of HTMLElement');
     }
 
+    var promiseAudioTrackChange = false;
+
     var size = 100;
     var offset = 0;
     var textColor = 'rgb(255, 255, 255)';
@@ -151,7 +153,14 @@ function TizenVideo(options) {
                     return null;
                 }
 
-                return !!(window.webapis.avplay.getState() === 'PAUSED');
+                var isPaused = !!(window.webapis.avplay.getState() === 'PAUSED');
+
+                if (!isPaused && promiseAudioTrackChange) {
+                    window.webapis.avplay.setSelectTrack('AUDIO', parseInt(promiseAudioTrackChange.replace('EMBEDDED_', '')));
+                    promiseAudioTrackChange = false;
+                }
+
+                return isPaused;
             }
             case 'time': {
                 var currentTime = window.webapis.avplay.getCurrentTime();
@@ -301,8 +310,12 @@ function TizenVideo(options) {
                     return null;
                 }
 
+                if (promiseAudioTrackChange) {
+                    return promiseAudioTrackChange;
+                }
+
                 var currentTracks = window.webapis.avplay.getCurrentStreamInfo();
-                var currentIndex;
+                var currentIndex = false;
 
                 for (var i = 0; i < currentTracks.length; i++) {
                     if (currentTracks[i].type === 'AUDIO') {
@@ -312,7 +325,7 @@ function TizenVideo(options) {
                     }
                 }
 
-                return currentIndex ? 'EMBEDDED_' + String(currentIndex) : null;
+                return currentIndex !== false ? 'EMBEDDED_' + String(currentIndex) : null;
             }
             case 'playbackSpeed': {
                 if (destroyed || videoSpeed === null || !isFinite(videoSpeed)) {
@@ -375,6 +388,16 @@ function TizenVideo(options) {
 
                 onPropChanged('paused');
 
+                // the paused state is usually correct, but i have seen it not change on tizen 3
+                // which causes all kinds of issues in the UI: (only happens with some videos)
+                var lastKnownProp = getProp('paused');
+
+                setTimeout(function() {
+                    if (getProp('paused') !== lastKnownProp) {
+                        onPropChanged('paused');
+                    }
+                }, 1000);
+
                 break;
             }
             case 'time': {
@@ -493,8 +516,17 @@ function TizenVideo(options) {
                             return track.id === propValue;
                         });
 
-                    window.webapis.avplay.setSelectTrack('AUDIO', parseInt(currentAudioTrack.replace('EMBEDDED_', '')));
+                    if (getProp('paused')) {
+                        // issues before this logic:
+                        // tizen 3 does not allow changing audio track when paused
+                        // tizen 5 does, but it will only change getProp('selectedAudioTrackId') after playback starts
 
+                        // will be changed on next play event, until then we will overwrite the result of getProp('selectedAudioTrackId')
+                        promiseAudioTrackChange = propValue;
+                        onPropChanged('selectedAudioTrackId');
+                    } else {
+                        window.webapis.avplay.setSelectTrack('AUDIO', parseInt(currentAudioTrack.replace('EMBEDDED_', '')));
+                    }
                     if (selectedAudioTrack) {
                         events.emit('audioTrackLoaded', selectedAudioTrack);
                         onPropChanged('selectedAudioTrackId');

package/src/error.js

@@ -58,7 +58,7 @@ var ERROR = {
     WITH_STREAMING_SERVER: {
         CONVERT_FAILED: {
             code: 60,
-            message: 'Unable to convert stream'
+            message: 'Streaming server failed to convert torrent stream'
         }
     },
     UNKNOWN_ERROR: {