@stremio/stremio-video 0.0.20-rc.7 → 0.0.22

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@stremio/stremio-video",
-    "version": "0.0.20-rc.7",
+    "version": "0.0.22",
     "description": "Abstraction layer on top of different media players",
     "author": "Smart Code OOD",
     "main": "src/index.js",
@@ -13,6 +13,8 @@
         "lint": "eslint src"
     },
     "dependencies": {
+        "buffer": "6.0.3",
+        "color": "4.2.3",
         "deep-freeze": "0.0.1",
         "eventemitter3": "4.0.7",
         "hat": "0.0.3",
@@ -21,8 +23,7 @@
         "magnet-uri": "6.2.0",
         "url": "0.11.0",
         "video-name-parser": "1.4.6",
-        "vtt.js": "github:jaruba/vtt.js#e4f5f5603730866bacb174a93f51b734c9f29e6a",
-        "color": "4.2.3"
+        "vtt.js": "github:jaruba/vtt.js#e4f5f5603730866bacb174a93f51b734c9f29e6a"
     },
     "devDependencies": {
         "eslint": "7.32.0"

package/src/ChromecastSenderVideo/ChromecastSenderVideo.js

@@ -45,6 +45,7 @@ function ChromecastSenderVideo(options) {
     var destroyed = false;
     var observedProps = {
         stream: false,
+        loaded: false,
         paused: false,
         time: false,
         duration: false,
@@ -107,6 +108,7 @@ function ChromecastSenderVideo(options) {
             case 'destroy': {
                 destroyed = true;
                 onPropChanged('stream', null);
+                onPropChanged('loaded', null);
                 onPropChanged('paused', null);
                 onPropChanged('time', null);
                 onPropChanged('duration', null);
@@ -188,7 +190,7 @@ ChromecastSenderVideo.canPlayStream = function() {
 ChromecastSenderVideo.manifest = {
     name: 'ChromecastSenderVideo',
     external: true,
-    props: ['stream', 'paused', 'time', 'duration', 'buffering', 'buffered', 'audioTracks', 'selectedAudioTrackId', 'subtitlesTracks', 'selectedSubtitlesTrackId', 'subtitlesOffset', 'subtitlesSize', 'subtitlesTextColor', 'subtitlesBackgroundColor', 'subtitlesOutlineColor', 'volume', 'muted', 'playbackSpeed', 'extraSubtitlesTracks', 'selectedExtraSubtitlesTrackId', 'extraSubtitlesDelay', 'extraSubtitlesSize', 'extraSubtitlesOffset', 'extraSubtitlesTextColor', 'extraSubtitlesBackgroundColor', 'extraSubtitlesOutlineColor'],
+    props: ['stream', 'loaded', 'paused', 'time', 'duration', 'buffering', 'buffered', 'audioTracks', 'selectedAudioTrackId', 'subtitlesTracks', 'selectedSubtitlesTrackId', 'subtitlesOffset', 'subtitlesSize', 'subtitlesTextColor', 'subtitlesBackgroundColor', 'subtitlesOutlineColor', 'volume', 'muted', 'playbackSpeed', 'extraSubtitlesTracks', 'selectedExtraSubtitlesTrackId', 'extraSubtitlesDelay', 'extraSubtitlesSize', 'extraSubtitlesOffset', 'extraSubtitlesTextColor', 'extraSubtitlesBackgroundColor', 'extraSubtitlesOutlineColor'],
     commands: ['load', 'unload', 'destroy', 'addExtraSubtitlesTracks'],
     events: ['propValue', 'propChanged', 'ended', 'error', 'subtitlesTrackLoaded', 'audioTrackLoaded', 'extraSubtitlesTrackLoaded', 'implementationChanged']
 };

package/src/HTMLVideo/HTMLVideo.js

@@ -47,10 +47,12 @@ function HTMLVideo(options) {
         onPropChanged('buffered');
     };
     videoElement.onseeking = function() {
+        onPropChanged('time');
         onPropChanged('buffering');
         onPropChanged('buffered');
     };
     videoElement.onseeked = function() {
+        onPropChanged('time');
         onPropChanged('buffering');
         onPropChanged('buffered');
     };
@@ -59,6 +61,7 @@ function HTMLVideo(options) {
         onPropChanged('buffered');
     };
     videoElement.onplaying = function() {
+        onPropChanged('time');
         onPropChanged('buffering');
         onPropChanged('buffered');
     };
@@ -70,6 +73,9 @@ function HTMLVideo(options) {
         onPropChanged('buffering');
         onPropChanged('buffered');
     };
+    videoElement.onloadedmetadata = function() {
+        onPropChanged('loaded');
+    };
     videoElement.onloadeddata = function() {
         onPropChanged('buffering');
         onPropChanged('buffered');
@@ -98,6 +104,7 @@ function HTMLVideo(options) {
     var subtitlesOffset = 0;
     var observedProps = {
         stream: false,
+        loaded: false,
         paused: false,
         time: false,
         duration: false,
@@ -122,6 +129,13 @@ function HTMLVideo(options) {
             case 'stream': {
                 return stream;
             }
+            case 'loaded': {
+                if (stream === null) {
+                    return null;
+                }
+
+                return videoElement.readyState >= videoElement.HAVE_METADATA;
+            }
             case 'paused': {
                 if (stream === null) {
                     return null;
@@ -355,6 +369,7 @@ function HTMLVideo(options) {
             case 'paused': {
                 if (stream !== null) {
                     propValue ? videoElement.pause() : videoElement.play();
+                    onPropChanged('paused');
                 }
 
                 break;
@@ -362,6 +377,7 @@ function HTMLVideo(options) {
             case 'time': {
                 if (stream !== null && propValue !== null && isFinite(propValue)) {
                     videoElement.currentTime = parseInt(propValue, 10) / 1000;
+                    onPropChanged('time');
                 }
 
                 break;
@@ -377,6 +393,7 @@ function HTMLVideo(options) {
                             return track.id === propValue;
                         });
                     if (selecterdSubtitlesTrack) {
+                        onPropChanged('selectedSubtitlesTrackId');
                         events.emit('subtitlesTrackLoaded', selecterdSubtitlesTrack);
                     }
                 }
@@ -450,6 +467,7 @@ function HTMLVideo(options) {
                         });
                     hls.audioTrack = selecterdAudioTrack ? parseInt(selecterdAudioTrack.id.split('_').pop(), 10) : -1;
                     if (selecterdAudioTrack) {
+                        onPropChanged('selectedAudioTrackId');
                         events.emit('audioTrackLoaded', selecterdAudioTrack);
                     }
                 }
@@ -460,17 +478,21 @@ function HTMLVideo(options) {
                 if (propValue !== null && isFinite(propValue)) {
                     videoElement.muted = false;
                     videoElement.volume = Math.max(0, Math.min(100, parseInt(propValue, 10))) / 100;
+                    onPropChanged('muted');
+                    onPropChanged('volume');
                 }
 
                 break;
             }
             case 'muted': {
                 videoElement.muted = !!propValue;
+                onPropChanged('muted');
                 break;
             }
             case 'playbackSpeed': {
                 if (propValue !== null && isFinite(propValue)) {
                     videoElement.playbackRate = parseFloat(propValue);
+                    onPropChanged('playbackSpeed');
                 }
 
                 break;
@@ -484,6 +506,7 @@ function HTMLVideo(options) {
                 if (commandArgs && commandArgs.stream && typeof commandArgs.stream.url === 'string') {
                     stream = commandArgs.stream;
                     onPropChanged('stream');
+                    onPropChanged('loaded');
                     videoElement.autoplay = typeof commandArgs.autoplay === 'boolean' ? commandArgs.autoplay : true;
                     videoElement.currentTime = commandArgs.time !== null && isFinite(commandArgs.time) ? parseInt(commandArgs.time, 10) / 1000 : 0;
                     onPropChanged('paused');
@@ -547,6 +570,7 @@ function HTMLVideo(options) {
                 videoElement.load();
                 videoElement.currentTime = 0;
                 onPropChanged('stream');
+                onPropChanged('loaded');
                 onPropChanged('paused');
                 onPropChanged('time');
                 onPropChanged('duration');
@@ -646,7 +670,7 @@ HTMLVideo.canPlayStream = function(stream) {
 HTMLVideo.manifest = {
     name: 'HTMLVideo',
     external: false,
-    props: ['stream', 'paused', 'time', 'duration', 'buffering', 'buffered', 'audioTracks', 'selectedAudioTrackId', 'subtitlesTracks', 'selectedSubtitlesTrackId', 'subtitlesOffset', 'subtitlesSize', 'subtitlesTextColor', 'subtitlesBackgroundColor', 'subtitlesOutlineColor', 'volume', 'muted', 'playbackSpeed'],
+    props: ['stream', 'loaded', 'paused', 'time', 'duration', 'buffering', 'buffered', 'audioTracks', 'selectedAudioTrackId', 'subtitlesTracks', 'selectedSubtitlesTrackId', 'subtitlesOffset', 'subtitlesSize', 'subtitlesTextColor', 'subtitlesBackgroundColor', 'subtitlesOutlineColor', 'volume', 'muted', 'playbackSpeed'],
     commands: ['load', 'unload', 'destroy'],
     events: ['propValue', 'propChanged', 'ended', 'error', 'subtitlesTrackLoaded', 'audioTrackLoaded']
 };

package/src/IFrameVideo/IFrameVideo.js

@@ -24,6 +24,7 @@ function IFrameVideo(options) {
     var destroyed = false;
     var observedProps = {
         stream: false,
+        loaded: false,
         paused: false,
         time: false,
         duration: false,
@@ -95,6 +96,7 @@ function IFrameVideo(options) {
                 iframeElement.onload = null;
                 iframeElement.removeAttribute('src');
                 onPropChanged('stream', null);
+                onPropChanged('loaded', null);
                 onPropChanged('paused', null);
                 onPropChanged('time', null);
                 onPropChanged('duration', null);
@@ -108,15 +110,6 @@ function IFrameVideo(options) {
             case 'destroy': {
                 command('unload');
                 destroyed = true;
-                onPropChanged('stream', null);
-                onPropChanged('paused', null);
-                onPropChanged('time', null);
-                onPropChanged('duration', null);
-                onPropChanged('buffering', null);
-                onPropChanged('buffered', null);
-                onPropChanged('volume', null);
-                onPropChanged('muted', null);
-                onPropChanged('playbackSpeed', null);
                 events.removeAllListeners();
                 containerElement.removeChild(iframeElement);
                 return true;
@@ -169,7 +162,7 @@ IFrameVideo.canPlayStream = function(stream) {
 IFrameVideo.manifest = {
     name: 'IFrameVideo',
     external: true,
-    props: ['stream', 'paused', 'time', 'duration', 'buffering', 'buffered', 'audioTracks', 'selectedAudioTrackId', 'subtitlesTracks', 'selectedSubtitlesTrackId', 'subtitlesOffset', 'subtitlesSize', 'subtitlesTextColor', 'subtitlesBackgroundColor', 'subtitlesOutlineColor', 'volume', 'muted', 'playbackSpeed', 'extraSubtitlesTracks', 'selectedExtraSubtitlesTrackId', 'extraSubtitlesDelay', 'extraSubtitlesSize', 'extraSubtitlesOffset', 'extraSubtitlesTextColor', 'extraSubtitlesBackgroundColor', 'extraSubtitlesOutlineColor'],
+    props: ['stream', 'loaded', 'paused', 'time', 'duration', 'buffering', 'buffered', 'audioTracks', 'selectedAudioTrackId', 'subtitlesTracks', 'selectedSubtitlesTrackId', 'subtitlesOffset', 'subtitlesSize', 'subtitlesTextColor', 'subtitlesBackgroundColor', 'subtitlesOutlineColor', 'volume', 'muted', 'playbackSpeed', 'extraSubtitlesTracks', 'selectedExtraSubtitlesTrackId', 'extraSubtitlesDelay', 'extraSubtitlesSize', 'extraSubtitlesOffset', 'extraSubtitlesTextColor', 'extraSubtitlesBackgroundColor', 'extraSubtitlesOutlineColor'],
     commands: ['load', 'unload', 'destroy', 'addExtraSubtitlesTracks'],
     events: ['propValue', 'propChanged', 'ended', 'error', 'subtitlesTrackLoaded', 'audioTrackLoaded', 'extraSubtitlesTrackLoaded', 'implementationChanged']
 };

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');
@@ -23,6 +24,10 @@ function selectVideoImplementation(commandArgs, options) {
         return IFrameVideo;
     }
 
+    if (options.shellTransport) {
+        return withStreamingServer(withHTMLSubtitles(ShellVideo));
+    }
+
     if (typeof commandArgs.streamingServerURL === 'string') {
         if (typeof global.tizen !== 'undefined') {
             return withStreamingServer(withHTMLSubtitles(TizenVideo));

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/YouTubeVideo/YouTubeVideo.js

@@ -39,6 +39,7 @@ function YouTubeVideo(options) {
     var selectedSubtitlesTrackId = null;
     var observedProps = {
         stream: false,
+        loaded: false,
         paused: false,
         time: false,
         duration: false,
@@ -190,6 +191,13 @@ function YouTubeVideo(options) {
             case 'stream': {
                 return stream;
             }
+            case 'loaded': {
+                if (stream === null) {
+                    return null;
+                }
+
+                return true;
+            }
             case 'paused': {
                 if (stream === null || typeof video.getPlayerState !== 'function') {
                     return null;
@@ -360,6 +368,7 @@ function YouTubeVideo(options) {
                     if (ready) {
                         stream = commandArgs.stream;
                         onPropChanged('stream');
+                        onPropChanged('loaded');
                         var autoplay = typeof commandArgs.autoplay === 'boolean' ? commandArgs.autoplay : true;
                         var time = commandArgs.time !== null && isFinite(commandArgs.time) ? parseInt(commandArgs.time, 10) / 1000 : 0;
                         if (autoplay && typeof video.loadVideoById === 'function') {
@@ -397,6 +406,7 @@ function YouTubeVideo(options) {
                 pendingLoadArgs = null;
                 stream = null;
                 onPropChanged('stream');
+                onPropChanged('loaded');
                 selectedSubtitlesTrackId = null;
                 if (ready && typeof video.stopVideo === 'function') {
                     video.stopVideo();
@@ -467,7 +477,7 @@ YouTubeVideo.canPlayStream = function(stream) {
 YouTubeVideo.manifest = {
     name: 'YouTubeVideo',
     external: false,
-    props: ['stream', 'paused', 'time', 'duration', 'buffering', 'volume', 'muted', 'subtitlesTracks', 'selectedSubtitlesTrackId'],
+    props: ['stream', 'loaded', 'paused', 'time', 'duration', 'buffering', 'volume', 'muted', 'subtitlesTracks', 'selectedSubtitlesTrackId'],
     commands: ['load', 'unload', 'destroy'],
     events: ['propValue', 'propChanged', 'ended', 'error', 'subtitlesTrackLoaded']
 };

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: {