@stremio/stremio-video 0.0.23 → 0.0.24

package/package.json

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

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

@@ -3,6 +3,7 @@ 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 ERROR = require('../error');
 
@@ -96,7 +97,29 @@ function withStreamingServer(Video) {
                         onPropChanged('stream');
                         convertStream(commandArgs.streamingServerURL, commandArgs.stream, commandArgs.seriesInfo)
                             .then(function(mediaURL) {
-                                return (commandArgs.forceTranscoding ? Promise.resolve(false) : Video.canPlayStream({ url: mediaURL }))
+                                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;
@@ -113,9 +136,16 @@ 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()),
@@ -269,8 +299,38 @@ 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 = {