@stremio/stremio-video 0.0.23 → 0.0.25-rc.1

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@stremio/stremio-video",
-    "version": "0.0.23",
+    "version": "0.0.25-rc.1",
     "description": "Abstraction layer on top of different media players",
     "author": "Smart Code OOD",
     "main": "src/index.js",

package/src/ChromecastSenderVideo/ChromecastSenderVideo.js

@@ -63,6 +63,7 @@ function ChromecastSenderVideo(options) {
         volume: false,
         muted: false,
         playbackSpeed: false,
+        videoParams: false,
         extraSubtitlesTracks: false,
         selectedExtraSubtitlesTrackId: false,
         extraSubtitlesDelay: false,
@@ -126,6 +127,7 @@ function ChromecastSenderVideo(options) {
                 onPropChanged('volume', null);
                 onPropChanged('muted', null);
                 onPropChanged('playbackSpeed', null);
+                onPropChanged('videoParams', null);
                 onPropChanged('extraSubtitlesTracks', []);
                 onPropChanged('selectedExtraSubtitlesTrackId', null);
                 onPropChanged('extraSubtitlesDelay', null);
@@ -190,7 +192,7 @@ ChromecastSenderVideo.canPlayStream = function() {
 ChromecastSenderVideo.manifest = {
     name: 'ChromecastSenderVideo',
     external: true,
-    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'],
+    props: ['stream', 'loaded', 'paused', 'time', 'duration', 'buffering', 'buffered', 'audioTracks', 'selectedAudioTrackId', 'subtitlesTracks', 'selectedSubtitlesTrackId', 'subtitlesOffset', 'subtitlesSize', 'subtitlesTextColor', 'subtitlesBackgroundColor', 'subtitlesOutlineColor', 'volume', 'muted', 'playbackSpeed', 'videoParams', 'extraSubtitlesTracks', 'selectedExtraSubtitlesTrackId', 'extraSubtitlesDelay', 'extraSubtitlesSize', 'extraSubtitlesOffset', 'extraSubtitlesTextColor', 'extraSubtitlesBackgroundColor', 'extraSubtitlesOutlineColor'],
     commands: ['load', 'unload', 'destroy', 'addExtraSubtitlesTracks'],
     events: ['propValue', 'propChanged', 'ended', 'error', 'subtitlesTrackLoaded', 'audioTrackLoaded', 'extraSubtitlesTrackLoaded', 'implementationChanged']
 };

package/src/StremioVideo/selectVideoImplementation.js

@@ -7,6 +7,7 @@ var IFrameVideo = require('../IFrameVideo');
 var YouTubeVideo = require('../YouTubeVideo');
 var withStreamingServer = require('../withStreamingServer');
 var withHTMLSubtitles = require('../withHTMLSubtitles');
+var withVideoParams = require('../withVideoParams');
 
 function selectVideoImplementation(commandArgs, options) {
     if (!commandArgs.stream || typeof commandArgs.stream.externalUrl === 'string') {
@@ -18,11 +19,11 @@ function selectVideoImplementation(commandArgs, options) {
     }
 
     if (typeof commandArgs.stream.ytId === 'string') {
-        return withHTMLSubtitles(YouTubeVideo);
+        return withVideoParams(withHTMLSubtitles(YouTubeVideo));
     }
 
     if (typeof commandArgs.stream.playerFrameUrl === 'string') {
-        return IFrameVideo;
+        return withVideoParams(IFrameVideo);
     }
 
     if (options.shellTransport) {
@@ -41,12 +42,12 @@ function selectVideoImplementation(commandArgs, options) {
 
     if (typeof commandArgs.stream.url === 'string') {
         if (typeof global.webOS !== 'undefined') {
-            return withHTMLSubtitles(WebOsVideo);
+            return withVideoParams(withHTMLSubtitles(WebOsVideo));
         }
         if (typeof global.tizen !== 'undefined') {
-            return withHTMLSubtitles(TizenVideo);
+            return withVideoParams(withHTMLSubtitles(TizenVideo));
         }
-        return withHTMLSubtitles(HTMLVideo);
+        return withVideoParams(withHTMLSubtitles(HTMLVideo));
     }
 
     return null;

package/src/mediaCapabilities.js

@@ -0,0 +1,94 @@
+var VIDEO_CODEC_CONFIGS = [
+    {
+        codec: 'h264',
+        mime: 'video/mp4; codecs="avc1.42E01E"',
+    },
+    {
+        codec: 'h265',
+        mime: 'video/mp4; codecs="hev1.1.6.L150.B0"',
+        aliases: ['hevc']
+    },
+    {
+        codec: 'vp8',
+        mime: 'video/mp4; codecs="vp8"'
+    },
+    {
+        codec: 'vp9',
+        mime: 'video/mp4; codecs="vp9"'
+    }
+];
+
+var AUDIO_CODEC_CONFIGS = [
+    {
+        codec: 'aac',
+        mime: 'audio/mp4; codecs="mp4a.40.2"'
+    },
+    {
+        codec: 'mp3',
+        mime: 'audio/mp4; codecs="mp3"'
+    },
+    {
+        codec: 'ac3',
+        mime: 'audio/mp4; codecs="ac-3"'
+    },
+    {
+        codec: 'eac3',
+        mime: 'audio/mp4; codecs="ec-3"'
+    },
+    {
+        codec: 'vorbis',
+        mime: 'audio/mp4; codecs="vorbis"'
+    },
+    {
+        codec: 'opus',
+        mime: 'audio/mp4; codecs="opus"'
+    }
+];
+
+function canPlay(config, options) {
+    return options.mediaElement.canPlayType(config.mime) ?
+        [config.codec].concat(config.aliases || [])
+        :
+        [];
+}
+
+function getMaxAudioChannels() {
+    if (/firefox/i.test(window.navigator.userAgent)) {
+        return 6;
+    }
+
+    if (!window.AudioContext) {
+        return 2;
+    }
+
+    var maxChannelCount = new AudioContext().destination.maxChannelCount;
+    return maxChannelCount > 0 ? maxChannelCount : 2;
+}
+
+function getMediaCapabilities() {
+    var mediaElement = document.createElement('video');
+    var formats = ['mp4'];
+    var videoCodecs = VIDEO_CODEC_CONFIGS
+        .map(function(config) {
+            return canPlay(config, { mediaElement: mediaElement });
+        })
+        .reduce(function(result, value) {
+            return result.concat(value);
+        }, []);
+    var audioCodecs = AUDIO_CODEC_CONFIGS
+        .map(function(config) {
+            return canPlay(config, { mediaElement: mediaElement });
+        })
+        .reduce(function(result, value) {
+            return result.concat(value);
+        }, []);
+    var maxAudioChannels = getMaxAudioChannels();
+    return {
+        formats: formats,
+        videoCodecs: videoCodecs,
+        audioCodecs: audioCodecs,
+        maxAudioChannels: maxAudioChannels
+    };
+}
+
+module.exports = getMediaCapabilities();

package/src/withStreamingServer/convertStream.js

@@ -23,14 +23,14 @@ function convertStream(streamingServerURL, stream, seriesInfo) {
                     :
                     [];
                 createTorrent(streamingServerURL, parsedMagnetURI.infoHash, null, sources, seriesInfo)
-                    .then(function(url) {
-                        resolve(url);
+                    .then(function(torrent) {
+                        resolve({ url: torrent.url, infoHash: torrent.infoHash, fileIdx: torrent.fileIdx });
                     })
                     .catch(function(error) {
                         reject(error);
                     });
             } else {
-                resolve(stream.url);
+                resolve({ url: stream.url });
             }
 
             return;
@@ -38,8 +38,8 @@ function convertStream(streamingServerURL, stream, seriesInfo) {
 
         if (typeof stream.infoHash === 'string') {
             createTorrent(streamingServerURL, stream.infoHash, stream.fileIdx, stream.announce, seriesInfo)
-                .then(function(url) {
-                    resolve(url);
+                .then(function(torrent) {
+                    resolve({ url: torrent.url, infoHash: torrent.infoHash, fileIdx: torrent.fileIdx });
                 })
                 .catch(function(error) {
                     reject(error);

package/src/withStreamingServer/createTorrent.js

@@ -1,18 +1,23 @@
 var url = require('url');
 
-function buildTorrentUrl(streamingServerURL, infoHash, fileIdx, sources) {
+function buildTorrent(streamingServerURL, infoHash, fileIdx, sources) {
     var query = Array.isArray(sources) && sources.length > 0 ?
         '?' + new URLSearchParams(sources.map(function(source) {
             return ['tr', source];
         }))
         :
         '';
-    return url.resolve(streamingServerURL, '/' + encodeURIComponent(infoHash) + '/' + encodeURIComponent(fileIdx)) + query;
+    return {
+        url: url.resolve(streamingServerURL, '/' + encodeURIComponent(infoHash) + '/' + encodeURIComponent(fileIdx)) + query,
+        infoHash: infoHash,
+        fileIdx: fileIdx,
+        sources: sources
+    };
 }
 
 function createTorrent(streamingServerURL, infoHash, fileIdx, sources, seriesInfo) {
     if ((!Array.isArray(sources) || sources.length === 0) && (fileIdx !== null && isFinite(fileIdx))) {
-        return Promise.resolve(buildTorrentUrl(streamingServerURL, infoHash, fileIdx, sources));
+        return Promise.resolve(buildTorrent(streamingServerURL, infoHash, fileIdx, sources));
     }
 
     var body = {
@@ -58,7 +63,7 @@ function createTorrent(streamingServerURL, infoHash, fileIdx, sources, seriesInf
 
         throw new Error(resp.status + ' (' + resp.statusText + ')');
     }).then(function(resp) {
-        return buildTorrentUrl(streamingServerURL, infoHash, body.guessFileIdx ? resp.guessedFileIdx : fileIdx, body.peerSearch ? body.peerSearch.sources : []);
+        return buildTorrent(streamingServerURL, infoHash, body.guessFileIdx ? resp.guessedFileIdx : fileIdx, body.peerSearch ? body.peerSearch.sources : []);
     });
 }
 

package/src/withStreamingServer/fetchVideoParams.js

@@ -0,0 +1,95 @@
+var url = require('url');
+
+function fetchOpensubtitlesParams(streamingServerURL, mediaURL, behaviorHints) {
+    var hash = behaviorHints && typeof behaviorHints.videoHash === 'string' ? behaviorHints.videoHash : null;
+    var size = behaviorHints && isFinite(behaviorHints.videoSize) ? behaviorHints.videoSize : null;
+    if (typeof hash === 'string' && size !== null && isFinite(size)) {
+        return Promise.resolve({ hash: hash, size: size });
+    }
+
+    var queryParams = new URLSearchParams([['videoUrl', mediaURL]]);
+    return fetch(url.resolve(streamingServerURL, '/opensubHash?' + queryParams.toString()))
+        .then(function(resp) {
+            if (resp.ok) {
+                return resp.json();
+            }
+
+            throw new Error(resp.status + ' (' + resp.statusText + ')');
+        })
+        .then(function(resp) {
+            if (resp.error) {
+                throw new Error(resp.error);
+            }
+
+            return {
+                hash: typeof hash === 'string' ?
+                    hash
+                    :
+                    resp.result && typeof resp.result.hash === 'string' ?
+                        resp.result.hash
+                        :
+                        null,
+                size: size !== null && isFinite(size) ?
+                    size
+                    :
+                    resp.result && typeof resp.result.size ?
+                        resp.result.size
+                        :
+                        null
+            };
+        });
+}
+
+function fetchFilename(streamingServerURL, mediaURL, infoHash, fileIdx, behaviorHints) {
+    if (behaviorHints && typeof behaviorHints.filename === 'string') {
+        return Promise.resolve(behaviorHints.filename);
+    }
+
+    if (infoHash) {
+        return fetch(url.resolve(streamingServerURL, '/' + encodeURIComponent(infoHash) + '/' + encodeURIComponent(fileIdx) + '/stats.json'))
+            .then(function(resp) {
+                if (resp.ok) {
+                    return resp.json();
+                }
+
+                throw new Error(resp.status + ' (' + resp.statusText + ')');
+            })
+            .then(function(resp) {
+                if (!resp || typeof resp.streamName !== 'string') {
+                    throw new Error('Could not retrieve filename from torrent');
+                }
+
+                return resp.streamName;
+            });
+    }
+
+    return Promise.resolve(decodeURIComponent(mediaURL.split('/').pop()));
+}
+
+function fetchVideoParams(streamingServerURL, mediaURL, infoHash, fileIdx, behaviorHints) {
+    return Promise.allSettled([
+        fetchOpensubtitlesParams(streamingServerURL, mediaURL, behaviorHints),
+        fetchFilename(streamingServerURL, mediaURL, infoHash, fileIdx, behaviorHints)
+    ]).then(function(results) {
+        var result = { hash: null, size: null, filename: null };
+
+        if (results[0].status === 'fulfilled') {
+            result.hash = results[0].value.hash;
+            result.size = results[0].value.size;
+        } else if (results[0].reason) {
+            // eslint-disable-next-line no-console
+            console.error(results[0].reason);
+        }
+
+        if (results[1].status === 'fulfilled') {
+            result.filename = results[1].value;
+        } else if (results[1].reason) {
+            // eslint-disable-next-line no-console
+            console.error(results[1].reason);
+        }
+
+        return result;
+    });
+}
+
+module.exports = fetchVideoParams;

package/src/withStreamingServer/withStreamingServer.js

@@ -3,7 +3,9 @@ var url = require('url');
 var hat = require('hat');
 var cloneDeep = require('lodash.clonedeep');
 var deepFreeze = require('deep-freeze');
+var mediaCapabilities = require('../mediaCapabilities');
 var convertStream = require('./convertStream');
+var fetchVideoParams = require('./fetchVideoParams');
 var ERROR = require('../error');
 
 function withStreamingServer(Video) {
@@ -26,10 +28,12 @@ function withStreamingServer(Video) {
         var loadArgs = null;
         var loaded = false;
         var actionsQueue = [];
+        var videoParams = null;
         var events = new EventEmitter();
         var destroyed = false;
         var observedProps = {
-            stream: false
+            stream: false,
+            videoParams: false
         };
 
         function flushActionsQueue() {
@@ -69,6 +73,9 @@ function withStreamingServer(Video) {
                 case 'stream': {
                     return loadArgs !== null ? loadArgs.stream : null;
                 }
+                case 'videoParams': {
+                    return videoParams;
+                }
                 default: {
                     return videoPropValue;
                 }
@@ -76,7 +83,8 @@ function withStreamingServer(Video) {
         }
         function observeProp(propName) {
             switch (propName) {
-                case 'stream': {
+                case 'stream':
+                case 'videoParams': {
                     events.emit('propValue', propName, getProp(propName, null));
                     observedProps[propName] = true;
                     return true;
@@ -95,8 +103,33 @@ function withStreamingServer(Video) {
                         loadArgs = commandArgs;
                         onPropChanged('stream');
                         convertStream(commandArgs.streamingServerURL, commandArgs.stream, commandArgs.seriesInfo)
-                            .then(function(mediaURL) {
-                                return (commandArgs.forceTranscoding ? Promise.resolve(false) : Video.canPlayStream({ url: mediaURL }))
+                            .then(function(result) {
+                                var mediaURL = result.url;
+                                var infoHash = result.infoHash;
+                                var fileIdx = result.fileIdx;
+                                var formats = Array.isArray(commandArgs.formats) ?
+                                    commandArgs.formats
+                                    :
+                                    mediaCapabilities.formats;
+                                var videoCodecs = Array.isArray(commandArgs.videoCodecs) ?
+                                    commandArgs.videoCodecs
+                                    :
+                                    mediaCapabilities.videoCodecs;
+                                var audioCodecs = Array.isArray(commandArgs.audioCodecs) ?
+                                    commandArgs.audioCodecs
+                                    :
+                                    mediaCapabilities.audioCodecs;
+                                var maxAudioChannels = commandArgs.maxAudioChannels !== null && isFinite(commandArgs.maxAudioChannels) ?
+                                    commandArgs.maxAudioChannels
+                                    :
+                                    mediaCapabilities.maxAudioChannels;
+                                var canPlayStreamOptions = Object.assign({}, commandArgs, {
+                                    formats: formats,
+                                    videoCodecs: videoCodecs,
+                                    audioCodecs: audioCodecs,
+                                    maxAudioChannels: maxAudioChannels
+                                });
+                                return (commandArgs.forceTranscoding ? Promise.resolve(false) : VideoWithStreamingServer.canPlayStream({ url: mediaURL }, canPlayStreamOptions))
                                     .catch(function(error) {
                                         console.warn('Media probe error', error);
                                         return false;
@@ -104,7 +137,12 @@ function withStreamingServer(Video) {
                                     .then(function(canPlay) {
                                         if (canPlay) {
                                             return {
-                                                url: mediaURL
+                                                mediaURL: mediaURL,
+                                                infoHash: infoHash,
+                                                fileIdx: fileIdx,
+                                                stream: {
+                                                    url: mediaURL
+                                                }
                                             };
                                         }
 
@@ -113,32 +151,44 @@ function withStreamingServer(Video) {
                                         if (commandArgs.forceTranscoding) {
                                             queryParams.set('forceTranscoding', '1');
                                         }
-                                        if (commandArgs.maxAudioChannels !== null && isFinite(commandArgs.maxAudioChannels)) {
-                                            queryParams.set('maxAudioChannels', commandArgs.maxAudioChannels);
-                                        }
+
+                                        videoCodecs.forEach(function(videoCodec) {
+                                            queryParams.append('videoCodecs', videoCodec);
+                                        });
+
+                                        audioCodecs.forEach(function(audioCodec) {
+                                            queryParams.append('audioCodecs', audioCodec);
+                                        });
+
+                                        queryParams.set('maxAudioChannels', maxAudioChannels);
 
                                         return {
-                                            url: url.resolve(commandArgs.streamingServerURL, '/hlsv2/' + id + '/master.m3u8?' + queryParams.toString()),
-                                            subtitles: Array.isArray(commandArgs.stream.subtitles) ?
-                                                commandArgs.stream.subtitles.map(function(track) {
-                                                    return Object.assign({}, track, {
-                                                        url: typeof track.url === 'string' ?
-                                                            url.resolve(commandArgs.streamingServerURL, '/subtitles.vtt?' + new URLSearchParams([['from', track.url]]).toString())
-                                                            :
-                                                            track.url
-                                                    });
-                                                })
-                                                :
-                                                [],
-                                            behaviorHints: {
-                                                headers: {
-                                                    'content-type': 'application/vnd.apple.mpegurl'
+                                            mediaURL: mediaURL,
+                                            infoHash: infoHash,
+                                            fileIdx: fileIdx,
+                                            stream: {
+                                                url: url.resolve(commandArgs.streamingServerURL, '/hlsv2/' + id + '/master.m3u8?' + queryParams.toString()),
+                                                subtitles: Array.isArray(commandArgs.stream.subtitles) ?
+                                                    commandArgs.stream.subtitles.map(function(track) {
+                                                        return Object.assign({}, track, {
+                                                            url: typeof track.url === 'string' ?
+                                                                url.resolve(commandArgs.streamingServerURL, '/subtitles.vtt?' + new URLSearchParams([['from', track.url]]).toString())
+                                                                :
+                                                                track.url
+                                                        });
+                                                    })
+                                                    :
+                                                    [],
+                                                behaviorHints: {
+                                                    headers: {
+                                                        'content-type': 'application/vnd.apple.mpegurl'
+                                                    }
                                                 }
                                             }
                                         };
                                     });
                             })
-                            .then(function(stream) {
+                            .then(function(result) {
                                 if (commandArgs !== loadArgs) {
                                     return;
                                 }
@@ -147,11 +197,30 @@ function withStreamingServer(Video) {
                                     type: 'command',
                                     commandName: 'load',
                                     commandArgs: Object.assign({}, commandArgs, {
-                                        stream: stream
+                                        stream: result.stream
                                     })
                                 });
                                 loaded = true;
                                 flushActionsQueue();
+                                fetchVideoParams(commandArgs.streamingServerURL, result.mediaURL, result.infoHash, result.fileIdx, commandArgs.stream.behaviorHints)
+                                    .then(function(result) {
+                                        if (commandArgs !== loadArgs) {
+                                            return;
+                                        }
+
+                                        videoParams = result;
+                                        onPropChanged('videoParams');
+                                    })
+                                    .catch(function(error) {
+                                        if (commandArgs !== loadArgs) {
+                                            return;
+                                        }
+
+                                        // eslint-disable-next-line no-console
+                                        console.error(error);
+                                        videoParams = { hash: null, size: null, filename: null };
+                                        onPropChanged('videoParams');
+                                    });
                             })
                             .catch(function(error) {
                                 if (commandArgs !== loadArgs) {
@@ -207,7 +276,9 @@ function withStreamingServer(Video) {
                     loadArgs = null;
                     loaded = false;
                     actionsQueue = [];
+                    videoParams = null;
                     onPropChanged('stream');
+                    onPropChanged('videoParams');
                     return false;
                 }
                 case 'destroy': {
@@ -269,14 +340,44 @@ function withStreamingServer(Video) {
         };
     }
 
-    VideoWithStreamingServer.canPlayStream = function(stream) {
-        return Video.canPlayStream(stream);
+    VideoWithStreamingServer.canPlayStream = function(stream, options) {
+        return Video.canPlayStream(stream)
+            .then(function(canPlay) {
+                if (!canPlay) {
+                    throw new Error('Fallback using /hlsv2/probe');
+                }
+
+                return canPlay;
+            })
+            .catch(function() {
+                var queryParams = new URLSearchParams([['mediaURL', stream.url]]);
+                return fetch(url.resolve(options.streamingServerURL, '/hlsv2/probe?' + queryParams.toString()))
+                    .then(function(resp) {
+                        return resp.json();
+                    })
+                    .then(function(probe) {
+                        var isFormatSupported = options.formats.some(function(format) {
+                            return probe.format.name.indexOf(format) !== -1;
+                        });
+                        var areStreamsSupported = probe.streams.every(function(stream) {
+                            if (stream.track === 'audio') {
+                                return stream.channels <= options.maxAudioChannels &&
+                                    options.audioCodecs.indexOf(stream.codec) !== -1;
+                            } else if (stream.track === 'video') {
+                                return options.videoCodecs.indexOf(stream.codec) !== -1;
+                            }
+
+                            return true;
+                        });
+                        return isFormatSupported && areStreamsSupported;
+                    });
+            });
     };
 
     VideoWithStreamingServer.manifest = {
         name: Video.manifest.name + 'WithStreamingServer',
         external: Video.manifest.external,
-        props: Video.manifest.props.concat(['stream'])
+        props: Video.manifest.props.concat(['stream', 'videoParams'])
             .filter(function(value, index, array) { return array.indexOf(value) === index; }),
         commands: Video.manifest.commands.concat(['load', 'unload', 'destroy', 'addExtraSubtitlesTracks'])
             .filter(function(value, index, array) { return array.indexOf(value) === index; }),

package/src/withVideoParams/index.js

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

package/src/withVideoParams/withVideoParams.js

@@ -0,0 +1,143 @@
+var EventEmitter = require('eventemitter3');
+var cloneDeep = require('lodash.clonedeep');
+var deepFreeze = require('deep-freeze');
+
+function withVideoParams(Video) {
+    function VideoWithVideoParams(options) {
+        options = options || {};
+
+        var video = new Video(options);
+        video.on('propValue', onVideoPropEvent.bind(null, 'propValue'));
+        video.on('propChanged', onVideoPropEvent.bind(null, 'propChanged'));
+        Video.manifest.events
+            .filter(function(eventName) {
+                return !['propValue', 'propChanged'].includes(eventName);
+            })
+            .forEach(function(eventName) {
+                video.on(eventName, onOtherVideoEvent(eventName));
+            });
+
+        var stream = null;
+        var events = new EventEmitter();
+        var destroyed = false;
+        var observedProps = {
+            videoParams: false
+        };
+
+        function onVideoPropEvent(eventName, propName, propValue) {
+            if (propName !== 'videoParams') {
+                events.emit(eventName, propName, getProp(propName, propValue));
+            }
+            if (propName === 'stream') {
+                stream = propValue;
+                onPropChanged('videoParams');
+            }
+        }
+        function onOtherVideoEvent(eventName) {
+            return function() {
+                events.emit.apply(events, [eventName].concat(Array.from(arguments)));
+            };
+        }
+        function onPropChanged(propName) {
+            if (observedProps[propName]) {
+                events.emit('propChanged', propName, getProp(propName, null));
+            }
+        }
+        function getProp(propName, videoPropValue) {
+            switch (propName) {
+                case 'videoParams': {
+                    if (stream === null) {
+                        return null;
+                    }
+
+                    var hash = stream.behaviorHints && typeof stream.behaviorHints.videoHash === 'string' ? stream.behaviorHints.videoHash : null;
+                    var size = stream.behaviorHints && stream.behaviorHints.videoSize !== null && isFinite(stream.behaviorHints.videoSize) ? stream.behaviorHints.videoSize : null;
+                    var filename = stream.behaviorHints && typeof stream.behaviorHints.filename === 'string' ? stream.behaviorHints.filename : null;
+                    return { hash: hash, size: size, filename: filename };
+                }
+                default: {
+                    return videoPropValue;
+                }
+            }
+        }
+        function observeProp(propName) {
+            switch (propName) {
+                case 'videoParams': {
+                    events.emit('propValue', propName, getProp(propName, null));
+                    observedProps[propName] = true;
+                    return true;
+                }
+                default: {
+                    return false;
+                }
+            }
+        }
+        function command(commandName) {
+            switch (commandName) {
+                case 'destroy': {
+                    destroyed = true;
+                    video.dispatch({ type: 'command', commandName: 'destroy' });
+                    events.removeAllListeners();
+                    return true;
+                }
+                default: {
+                    return false;
+                }
+            }
+        }
+
+        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': {
+                        if (observeProp(action.propName)) {
+                            return;
+                        }
+
+                        break;
+                    }
+                    case 'command': {
+                        if (command(action.commandName, action.commandArgs)) {
+                            return;
+                        }
+
+                        break;
+                    }
+                }
+            }
+
+            video.dispatch(action);
+        };
+    }
+
+    VideoWithVideoParams.canPlayStream = function(stream, options) {
+        return Video.canPlayStream(stream, options);
+    };
+
+    VideoWithVideoParams.manifest = {
+        name: Video.manifest.name + 'WithVideoParams',
+        external: Video.manifest.external,
+        props: Video.manifest.props.concat(['videoParams'])
+            .filter(function(value, index, array) { return array.indexOf(value) === index; }),
+        commands: Video.manifest.commands.concat(['destroy'])
+            .filter(function(value, index, array) { return array.indexOf(value) === index; }),
+        events: Video.manifest.events.concat(['propValue', 'propChanged'])
+            .filter(function(value, index, array) { return array.indexOf(value) === index; })
+    };
+
+    return VideoWithVideoParams;
+}
+
+module.exports = withVideoParams;