@stremio/stremio-video 0.0.78 → 0.0.79-tizen02

package/package.json

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

package/src/HTMLVideo/HTMLVideo.js

@@ -99,6 +99,13 @@ function HTMLVideo(options) {
     };
     containerElement.appendChild(videoElement);
 
+    function onFullscreenChanged() {
+        onPropChanged('fullscreen');
+    }
+    videoElement.addEventListener('webkitbeginfullscreen', onFullscreenChanged);
+    videoElement.addEventListener('webkitendfullscreen', onFullscreenChanged);
+    videoElement.addEventListener('fullscreenchange', onFullscreenChanged);
+
     var hls = null;
     var events = new EventEmitter();
     var destroyed = false;
@@ -125,7 +132,8 @@ function HTMLVideo(options) {
         volume: false,
         muted: false,
         playbackSpeed: false,
-        videoScale: false
+        videoScale: false,
+        fullscreen: false
     };
 
     function getProp(propName) {
@@ -323,6 +331,12 @@ function HTMLVideo(options) {
             case 'videoScale': {
                 return videoElement.style.objectFit || 'contain';
             }
+            case 'fullscreen': {
+                if (stream === null) {
+                    return null;
+                }
+                return videoElement.webkitDisplayingFullscreen === true || document.fullscreenElement === videoElement;
+            }
             default: {
                 return null;
             }
@@ -550,6 +564,23 @@ function HTMLVideo(options) {
 
                 break;
             }
+            case 'fullscreen': {
+                if (stream === null) break;
+                if (propValue) {
+                    if (typeof videoElement.webkitEnterFullscreen === 'function') {
+                        videoElement.webkitEnterFullscreen();
+                    } else if (typeof videoElement.requestFullscreen === 'function') {
+                        videoElement.requestFullscreen();
+                    }
+                } else {
+                    if (typeof videoElement.webkitExitFullscreen === 'function' && videoElement.webkitDisplayingFullscreen) {
+                        videoElement.webkitExitFullscreen();
+                    } else if (document.fullscreenElement === videoElement) {
+                        document.exitFullscreen();
+                    }
+                }
+                break;
+            }
         }
     }
     function command(commandName, commandArgs) {
@@ -571,6 +602,7 @@ function HTMLVideo(options) {
                     onPropChanged('selectedSubtitlesTrackId');
                     onPropChanged('audioTracks');
                     onPropChanged('selectedAudioTrackId');
+                    onPropChanged('fullscreen');
                     getContentType(stream)
                         .then(function(contentType) {
                             if (stream !== commandArgs.stream) {
@@ -636,6 +668,7 @@ function HTMLVideo(options) {
                 onPropChanged('selectedSubtitlesTrackId');
                 onPropChanged('audioTracks');
                 onPropChanged('selectedAudioTrackId');
+                onPropChanged('fullscreen');
                 break;
             }
             case 'destroy': {
@@ -668,6 +701,9 @@ function HTMLVideo(options) {
                 videoElement.onvolumechange = null;
                 videoElement.onratechange = null;
                 videoElement.textTracks.onchange = null;
+                videoElement.removeEventListener('webkitbeginfullscreen', onFullscreenChanged);
+                videoElement.removeEventListener('webkitendfullscreen', onFullscreenChanged);
+                videoElement.removeEventListener('fullscreenchange', onFullscreenChanged);
                 containerElement.removeChild(videoElement);
                 containerElement.removeChild(styleElement);
                 break;
@@ -727,7 +763,7 @@ HTMLVideo.canPlayStream = function(stream) {
 HTMLVideo.manifest = {
     name: 'HTMLVideo',
     external: false,
-    props: ['stream', 'loaded', 'paused', 'time', 'duration', 'buffering', 'buffered', 'audioTracks', 'selectedAudioTrackId', 'subtitlesTracks', 'selectedSubtitlesTrackId', 'subtitlesOffset', 'subtitlesSize', 'subtitlesTextColor', 'subtitlesBackgroundColor', 'subtitlesOutlineColor', 'subtitlesOpacity', 'volume', 'muted', 'playbackSpeed', 'videoScale'],
+    props: ['stream', 'loaded', 'paused', 'time', 'duration', 'buffering', 'buffered', 'audioTracks', 'selectedAudioTrackId', 'subtitlesTracks', 'selectedSubtitlesTrackId', 'subtitlesOffset', 'subtitlesSize', 'subtitlesTextColor', 'subtitlesBackgroundColor', 'subtitlesOutlineColor', 'subtitlesOpacity', 'volume', 'muted', 'playbackSpeed', 'videoScale', 'fullscreen'],
     commands: ['load', 'unload', 'destroy'],
     events: ['propValue', 'propChanged', 'ended', 'error', 'subtitlesTrackLoaded', 'audioTrackLoaded']
 };

package/src/TizenVideo/AVPlay.js

@@ -0,0 +1,98 @@
+const SCOPE = 'AVPlay';
+
+const createAVPlay = (transport) => {
+    const getState = () => {
+        return transport.request(SCOPE, 'getState');
+    };
+
+    const getCurrentTime = () => {
+        return transport.request(SCOPE, 'getCurrentTime');
+    };
+
+    const getDuration = () => {
+        return transport.request(SCOPE, 'getDuration');
+    };
+
+    const getTotalTrackInfo = () => {
+        return transport.request(SCOPE, 'getTotalTrackInfo');
+    };
+
+    const getCurrentStreamInfo = () => {
+        return transport.request(SCOPE, 'getCurrentStreamInfo');
+    };
+
+    const open = (path) => {
+        return transport.request(SCOPE, 'open', path);
+    };
+
+    const prepareAsync = async (successHandler, errorHandler) => {
+        const [handler, handlerResult] = await transport.request(SCOPE, 'prepareAsync', 'handler:success', 'handler:error');
+        if (handler === 'handler:success') successHandler();
+        if (handler === 'handler:error') errorHandler(...handlerResult);
+    };
+
+    const pause = () => {
+        return transport.request(SCOPE, 'pause');
+    };
+
+    const play = () => {
+        return transport.request(SCOPE, 'play');
+    };
+
+    const stop = () => {
+        return transport.request(SCOPE, 'stop');
+    };
+
+    const seekTo = (time) => {
+        return transport.request(SCOPE, 'seekTo', time);
+    };
+
+    const setSpeed = (rate) => {
+        return transport.request(SCOPE, 'setSpeed', rate);
+    };
+
+    const setSelectTrack = (type, id) => {
+        return transport.request(SCOPE, 'setSelectTrack', type, id);
+    };
+
+    const setDisplayRect = (x, y, width, height) => {
+        return transport.request(SCOPE, 'setDisplayRect', x, y, width, height);
+    };
+
+    const setDisplayMethod = (method) => {
+        return transport.request(SCOPE, 'setDisplayMethod', method);
+    };
+
+    const setListener = (listener) => {
+        const handlers = Object.keys(listener).map((name) => `handler:${name}`);
+        const onHandlerResponse = (handler, handlerResult) => {
+            const name = handler.replace('handler:', '');
+            if (listener[name]) {
+                handlerResult ? listener[name](...handlerResult) : listener[name]();
+            }
+        };
+
+        transport.listen(SCOPE, 'setListener', onHandlerResponse, ...handlers);
+    };
+
+    return {
+        getState,
+        getCurrentTime,
+        getDuration,
+        getTotalTrackInfo,
+        getCurrentStreamInfo,
+        open,
+        prepareAsync,
+        pause,
+        play,
+        stop,
+        seekTo,
+        setSpeed,
+        setSelectTrack,
+        setDisplayRect,
+        setDisplayMethod,
+        setListener,
+    };
+};
+
+module.exports = createAVPlay;

package/src/TizenVideo/TizenVideo.js

@@ -4,6 +4,7 @@ var deepFreeze = require('deep-freeze');
 var Color = require('color');
 var ERROR = require('../error');
 var getTracksData = require('../tracksData');
+var createAVPlay = require('./AVPlay');
 
 var SSA_DESCRIPTORS_REGEX = /^\{(\\an[1-8])+\}/i;
 
@@ -20,7 +21,7 @@ function TizenVideo(options) {
         throw new Error('Container element required to be instance of HTMLElement');
     }
 
-    var AVPlay = window.webapis.avplay;
+    var AVPlay = createAVPlay(options.transport);
 
     var promiseAudioTrackChange = false;
 
@@ -40,17 +41,17 @@ function TizenVideo(options) {
     var lastSub;
     var disabledSubs = true;
 
-    function refreshSubtitle() {
+    async function refreshSubtitle() {
         if (lastSub) {
-            var currentTime = getProp('time');
+            var currentTime = await getProp('time');
             var lastSubDurationDiff = lastSub.duration - (currentTime - lastSub.now);
             if (lastSubDurationDiff > 0) renderSubtitle(lastSubDurationDiff, lastSub.text);
         }
     }
 
-    function renderSubtitle(duration, text) {
+    async function renderSubtitle(duration, text) {
         if (disabledSubs) return;
-        var now = getProp('time');
+        var now = await getProp('time');
         var cleanedText = text.replace(SSA_DESCRIPTORS_REGEX, '');
 
         // we ignore custom delay here, it's not needed for embedded subs
@@ -177,7 +178,7 @@ function TizenVideo(options) {
         }
     }
 
-    function getProp(propName) {
+    async function getProp(propName) {
         switch (propName) {
             case 'stream': {
                 return stream;
@@ -190,7 +191,7 @@ function TizenVideo(options) {
                     return null;
                 }
 
-                var state = AVPlay.getState();
+                var state = await AVPlay.getState();
                 var isPaused = !!(state === 'PAUSED');
 
                 if (!isPaused && promiseAudioTrackChange) {
@@ -201,7 +202,7 @@ function TizenVideo(options) {
                 return isPaused;
             }
             case 'time': {
-                var currentTime = AVPlay.getCurrentTime();
+                var currentTime = await AVPlay.getCurrentTime();
                 if (stream === null || currentTime === null || !isFinite(currentTime)) {
                     return null;
                 }
@@ -209,7 +210,7 @@ function TizenVideo(options) {
                 return Math.floor(currentTime);
             }
             case 'duration': {
-                var duration = AVPlay.getDuration();
+                var duration = await AVPlay.getDuration();
                 if (stream === null || duration === null || !isFinite(duration)) {
                     return null;
                 }
@@ -228,7 +229,7 @@ function TizenVideo(options) {
                     return [];
                 }
 
-                var totalTrackInfo = AVPlay.getTotalTrackInfo();
+                var totalTrackInfo = await AVPlay.getTotalTrackInfo();
                 var textTracks = [];
 
                 for (var i = 0; i < totalTrackInfo.length; i++) {
@@ -268,7 +269,7 @@ function TizenVideo(options) {
                     return null;
                 }
 
-                var currentTracks = AVPlay.getCurrentStreamInfo();
+                var currentTracks = await AVPlay.getCurrentStreamInfo();
                 var currentIndex;
 
                 for (var i = 0; i < currentTracks.length; i++) {
@@ -329,7 +330,7 @@ function TizenVideo(options) {
                     return [];
                 }
 
-                var totalTrackInfo = AVPlay.getTotalTrackInfo();
+                var totalTrackInfo = await AVPlay.getTotalTrackInfo();
                 var audioTracks = [];
 
                 for (var i = 0; i < totalTrackInfo.length; i++) {
@@ -376,7 +377,7 @@ function TizenVideo(options) {
                     return promiseAudioTrackChange;
                 }
 
-                var currentTracks = AVPlay.getCurrentStreamInfo();
+                var currentTracks = await AVPlay.getCurrentStreamInfo();
                 var currentIndex = false;
 
                 for (var i = 0; i < currentTracks.length; i++) {
@@ -410,20 +411,20 @@ function TizenVideo(options) {
     function onEnded() {
         events.emit('ended');
     }
-    function onPropChanged(propName) {
+    async function onPropChanged(propName) {
         if (observedProps[propName]) {
-            var propValue = getProp(propName);
+            var propValue = await getProp(propName);
             events.emit('propChanged', propName, propValue);
         }
     }
-    function observeProp(propName) {
+    async function observeProp(propName) {
         if (observedProps.hasOwnProperty(propName)) {
-            var propValue = getProp(propName);
+            var propValue = await getProp(propName);
             events.emit('propValue', propName, propValue);
             observedProps[propName] = true;
         }
     }
-    function setProp(propName, propValue) {
+    async function setProp(propName, propValue) {
         switch (propName) {
             case 'paused': {
                 if (stream !== null) {
@@ -442,10 +443,10 @@ function TizenVideo(options) {
 
                 // 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');
+                var lastKnownProp = await getProp('paused');
 
-                setTimeout(function() {
-                    if (getProp('paused') !== lastKnownProp) {
+                setTimeout(async function() {
+                    if (await getProp('paused') !== lastKnownProp) {
                         onPropChanged('paused');
                     }
                 }, 1000);
@@ -470,7 +471,7 @@ function TizenVideo(options) {
                         return;
                     }
 
-                    var subtitlesTracks = getProp('subtitlesTracks');
+                    var subtitlesTracks = await getProp('subtitlesTracks');
                     var selectedSubtitlesTrack = subtitlesTracks
                         .find(function(track) {
                             return track.id === propValue;
@@ -574,13 +575,13 @@ function TizenVideo(options) {
                 if (stream !== null) {
                     currentAudioTrack = propValue;
 
-                    var audioTracks = getProp('audioTracks');
+                    var audioTracks = await getProp('audioTracks');
                     var selectedAudioTrack = audioTracks
                         .find(function(track) {
                             return track.id === propValue;
                         });
 
-                    if (getProp('paused')) {
+                    if (await 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

package/src/withHTMLSubtitles/withHTMLSubtitles.js

@@ -40,6 +40,63 @@ function withHTMLSubtitles(Video) {
         containerElement.style.zIndex = '0';
         containerElement.appendChild(subtitlesElement);
 
+        var videoElement = containerElement.querySelector('video');
+        var nativeTextTrack = null;
+        var syntheticNativeTextTracks = [];
+
+        function createNativeTrack() {
+            removeNativeTrack();
+            if (cuesByTime === null || selectedTrackId === null) return false;
+            var selectedTrack = tracks.find(function(track) { return track.id === selectedTrackId; });
+            if (!selectedTrack) return false;
+            var delayMs = delay || 0;
+            nativeTextTrack = videoElement.addTextTrack('subtitles', selectedTrack.label || selectedTrack.lang, selectedTrack.lang || '');
+            syntheticNativeTextTracks.push(nativeTextTrack);
+            cuesByTime.times.forEach(function(time) {
+                cuesByTime[time].forEach(function(cue) {
+                    if (cue.startTime !== time) return;
+                    var start = (cue.startTime + delayMs) / 1000;
+                    var end = (cue.endTime + delayMs) / 1000;
+                    if (start < 0) start = 0;
+                    if (end <= start) return;
+                    nativeTextTrack.addCue(new VTTCue(start, end, cue.text));
+                });
+            });
+            nativeTextTrack.mode = 'showing';
+            return true;
+        }
+        function removeNativeTrack() {
+            if (nativeTextTrack !== null) {
+                nativeTextTrack.mode = 'disabled';
+                nativeTextTrack = null;
+            }
+        }
+        function isNativeTextTrack(track) {
+            return syntheticNativeTextTracks.includes(track);
+        }
+        function getEmbeddedTrackIndex(trackId) {
+            if (typeof trackId !== 'string' || !trackId.startsWith('EMBEDDED_')) {
+                return null;
+            }
+            var index = parseInt(trackId.replace('EMBEDDED_', ''), 10);
+            return isNaN(index) ? null : index;
+        }
+        function isWebkitDisplayingFullscreen() {
+            return videoElement && videoElement.webkitDisplayingFullscreen === true;
+        }
+        function onWebkitBeginFullscreen() {
+            createNativeTrack();
+            subtitlesElement.style.display = 'none';
+        }
+        function onWebkitEndFullscreen() {
+            removeNativeTrack();
+            subtitlesElement.style.display = '';
+        }
+        if (videoElement) {
+            videoElement.addEventListener('webkitbeginfullscreen', onWebkitBeginFullscreen);
+            videoElement.addEventListener('webkitendfullscreen', onWebkitEndFullscreen);
+        }
+
         var videoState = {
             time: null,
             paused: false,
@@ -190,7 +247,7 @@ function withHTMLSubtitles(Video) {
 
             events.emit(eventName, propName, getProp(propName, propValue));
 
-            if (propName === 'selectedSubtitlesTrackId' && propValue !== null && selectedTrackId !== null) {
+            if (propName === 'selectedSubtitlesTrackId' && propValue !== null && selectedTrackId !== null && nativeTextTrack === null) {
                 setProp('selectedExtraSubtitlesTrackId', null);
             }
         }
@@ -276,6 +333,24 @@ function withHTMLSubtitles(Video) {
 
                     return opacity;
                 }
+                case 'subtitlesTracks': {
+                    if (Array.isArray(videoPropValue) && videoElement && videoElement.textTracks) {
+                        return videoPropValue.filter(function(track) {
+                            var index = getEmbeddedTrackIndex(track.id);
+                            return index === null || !isNativeTextTrack(videoElement.textTracks[index]);
+                        });
+                    }
+
+                    return videoPropValue;
+                }
+                case 'selectedSubtitlesTrackId': {
+                    if (typeof videoPropValue === 'string' && videoElement && videoElement.textTracks) {
+                        var index = getEmbeddedTrackIndex(videoPropValue);
+                        return index !== null && isNativeTextTrack(videoElement.textTracks[index]) ? null : videoPropValue;
+                    }
+
+                    return videoPropValue;
+                }
                 default: {
                     return videoPropValue;
                 }
@@ -369,6 +444,9 @@ function withHTMLSubtitles(Video) {
 
                                     cuesByTime = result;
                                     startRenderLoop();
+                                    if (isWebkitDisplayingFullscreen() && nativeTextTrack === null) {
+                                        createNativeTrack();
+                                    }
                                     events.emit('extraSubtitlesTrackLoaded', selectedTrack);
                                 })
                                 .catch(function(error) {
@@ -556,6 +634,7 @@ function withHTMLSubtitles(Video) {
                     return false;
                 }
                 case 'unload': {
+                    removeNativeTrack();
                     stopRenderLoop();
                     lastTimeIndex = null;
                     cuesByTime = null;
@@ -571,6 +650,10 @@ function withHTMLSubtitles(Video) {
                 case 'destroy': {
                     command('unload');
                     destroyed = true;
+                    if (videoElement) {
+                        videoElement.removeEventListener('webkitbeginfullscreen', onWebkitBeginFullscreen);
+                        videoElement.removeEventListener('webkitendfullscreen', onWebkitEndFullscreen);
+                    }
                     onPropChanged('extraSubtitlesSize');
                     onPropChanged('extraSubtitlesOffset');
                     onPropChanged('extraSubtitlesTextColor');

package/src/withStreamingServer/convertStream.js

@@ -46,13 +46,33 @@ function convertStream(streamingServerURL, stream, seriesInfo, streamingServerSe
             } else {
                 var proxyStreamsEnabled = streamingServerSettings && streamingServerSettings.proxyStreamsEnabled;
                 var proxyHeaders = stream.behaviorHints && stream.behaviorHints.proxyHeaders;
+                var resolved;
                 if (proxyStreamsEnabled || proxyHeaders) {
                     var requestHeaders = proxyHeaders && proxyHeaders.request ? proxyHeaders.request : {};
                     var responseHeaders = proxyHeaders && proxyHeaders.response ? proxyHeaders.response : {};
-                    resolve({ url: buildProxyUrl(streamingServerURL, stream.url, requestHeaders, responseHeaders) });
+                    resolved = { url: buildProxyUrl(streamingServerURL, stream.url, requestHeaders, responseHeaders) };
                 } else {
-                    resolve({ url: stream.url });
+                    resolved = { url: stream.url };
                 }
+                // Propagate infoHash/fileIdx so fetchFilename can hit stats.json
+                // instead of leaking the URL fragment as the filename.
+                if (typeof stream.infoHash === 'string' && stream.infoHash.length > 0) {
+                    resolved.infoHash = stream.infoHash.toLowerCase();
+                    if (stream.fileIdx !== null && stream.fileIdx !== undefined && isFinite(stream.fileIdx)) {
+                        resolved.fileIdx = stream.fileIdx;
+                    }
+                } else {
+                    // Fallback for addons shipping pre-computed streaming-server URLs.
+                    try {
+                        var parsed = new URL(stream.url);
+                        var parts = parsed.pathname.split('/').filter(Boolean);
+                        if (parts.length === 2 && /^[a-f0-9]{40}$/i.test(parts[0]) && /^-?\d+$/.test(parts[1])) {
+                            resolved.infoHash = parts[0].toLowerCase();
+                            resolved.fileIdx = parseInt(parts[1], 10);
+                        }
+                    } catch (_e) { /* unparsable URL */ }
+                }
+                resolve(resolved);
             }
 
             return;

package/src/withStreamingServer/fetchVideoParams.js

@@ -46,7 +46,30 @@ function fetchFilename(streamingServerURL, mediaURL, infoHash, fileIdx, behavior
     }
 
     if (infoHash) {
-        return fetch(url.resolve(streamingServerURL, '/' + encodeURIComponent(infoHash) + '/' + encodeURIComponent(fileIdx) + '/stats.json'))
+        // fileIdx -1 means auto-pick; /-1/stats.json has no streamName,
+        // so resolve via engine guessedFileIdx instead.
+        var fileIdxNum = typeof fileIdx === 'string' ? parseInt(fileIdx, 10) : fileIdx;
+        var hasSpecificFileIdx = fileIdxNum !== null && fileIdxNum !== -1 && isFinite(fileIdxNum);
+
+        if (hasSpecificFileIdx) {
+            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 fetch(url.resolve(streamingServerURL, '/' + encodeURIComponent(infoHash) + '/stats.json'))
             .then(function(resp) {
                 if (resp.ok) {
                     return resp.json();
@@ -54,12 +77,31 @@ function fetchFilename(streamingServerURL, mediaURL, infoHash, fileIdx, behavior
 
                 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');
+            .then(function(stats) {
+                if (!stats || !Array.isArray(stats.files)) {
+                    throw new Error('Could not retrieve file list from torrent');
+                }
+
+                // Prefer guessedFileIdx — the file the engine is streaming.
+                var guessed = typeof stats.guessedFileIdx === 'number' ? stats.files[stats.guessedFileIdx] : null;
+                if (guessed && typeof guessed.name === 'string') {
+                    return guessed.name;
+                }
+
+                // Fallback: largest video file (mirrors server's GuessFileIdx for movies).
+                var videoExt = /\.(mp4|mkv|avi|mov|wmv|flv|webm|m4v|mpg|mpeg|ts|m2ts)$/i;
+                var pool = stats.files.filter(function(f) { return f && typeof f.name === 'string' && videoExt.test(f.name); });
+                if (pool.length === 0) {
+                    pool = stats.files.filter(function(f) { return f && typeof f.name === 'string'; });
+                }
+                var largest = pool.reduce(function(best, f) {
+                    return (!best || (f.length || 0) > (best.length || 0)) ? f : best;
+                }, null);
+                if (largest && typeof largest.name === 'string') {
+                    return largest.name;
                 }
 
-                return resp.streamName;
+                throw new Error('Could not retrieve filename from torrent');
             });
     }
 

package/src/withStreamingServer/withStreamingServer.js

@@ -365,6 +365,7 @@ function withStreamingServer(Video) {
                         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 &&
@@ -378,7 +379,13 @@ function withStreamingServer(Video) {
                         var hasEmbeddedSubtitles = probe.streams.some(function(stream) {
                             return stream.track === 'subtitle';
                         });
-                        return isFormatSupported && areStreamsSupported && !hasEmbeddedSubtitles;
+
+                        // HTML5 video doesn't support multiple audio tracks, so we can't switch languages
+                        var supportedAudioTracks = probe.streams.filter(function(stream) {
+                            return stream.track === 'audio' && options.audioCodecs.indexOf(stream.codec) !== -1;
+                        });
+
+                        return isFormatSupported && areStreamsSupported && !hasEmbeddedSubtitles && supportedAudioTracks.length < 2;
                     })
                     .catch(function() {
                         // this uses content-type header in HTMLVideo which