client/src/assets/player/peertube-player-manager.ts

   1 import { VideoFile } from '../../../../shared/models/videos'
   2 // @ts-ignore
   3 import * as videojs from 'video.js'
   4 import 'videojs-hotkeys'
   5 import 'videojs-dock'
   6 import 'videojs-contextmenu-ui'
   7 import 'videojs-contrib-quality-levels'
   8 import './upnext/upnext-plugin'
   9 import './peertube-plugin'
  10 import './videojs-components/peertube-link-button'
  11 import './videojs-components/resolution-menu-button'
  12 import './videojs-components/settings-menu-button'
  13 import './videojs-components/p2p-info-button'
  14 import './videojs-components/peertube-load-progress-bar'
  15 import './videojs-components/theater-button'
  16 import { P2PMediaLoaderPluginOptions, UserWatching, VideoJSCaption, VideoJSPluginOptions, videojsUntyped } from './peertube-videojs-typings'
  17 import { buildVideoEmbed, buildVideoLink, copyToClipboard, getRtcConfig } from './utils'
  18 import { getCompleteLocale, getShortLocale, is18nLocale, isDefaultLocale } from '../../../../shared/models/i18n/i18n'
  19 import { segmentValidatorFactory } from './p2p-media-loader/segment-validator'
  20 import { segmentUrlBuilderFactory } from './p2p-media-loader/segment-url-builder'
  21 import { RedundancyUrlManager } from './p2p-media-loader/redundancy-url-manager'
  22 import { getStoredP2PEnabled } from './peertube-player-local-storage'
  23
  24 // Change 'Playback Rate' to 'Speed' (smaller for our settings menu)
  25 videojsUntyped.getComponent('PlaybackRateMenuButton').prototype.controlText_ = 'Speed'
  26 // Change Captions to Subtitles/CC
  27 videojsUntyped.getComponent('CaptionsButton').prototype.controlText_ = 'Subtitles/CC'
  28 // We just want to display 'Off' instead of 'captions off', keep a space so the variable == true (hacky I know)
  29 videojsUntyped.getComponent('CaptionsButton').prototype.label_ = ' '
  30
  31 export type PlayerMode = 'webtorrent' | 'p2p-media-loader'
  32
  33 export type WebtorrentOptions = {
  34   videoFiles: VideoFile[]
  35 }
  36
  37 export type P2PMediaLoaderOptions = {
  38   playlistUrl: string
  39   segmentsSha256Url: string
  40   trackerAnnounce: string[]
  41   redundancyBaseUrls: string[]
  42   videoFiles: VideoFile[]
  43 }
  44
  45 export interface CustomizationOptions {
  46   startTime: number | string
  47   stopTime: number | string
  48
  49   controls?: boolean
  50   muted?: boolean
  51   loop?: boolean
  52   subtitle?: string
  53
  54   peertubeLink: boolean
  55 }
  56
  57 export interface CommonOptions extends CustomizationOptions {
  58   playerElement: HTMLVideoElement
  59   onPlayerElementChange: (element: HTMLVideoElement) => void
  60
  61   autoplay: boolean
  62   videoDuration: number
  63   enableHotkeys: boolean
  64   inactivityTimeout: number
  65   poster: string
  66
  67   theaterButton: boolean
  68   captions: boolean
  69
  70   videoViewUrl: string
  71   embedUrl: string
  72
  73   language?: string
  74
  75   videoCaptions: VideoJSCaption[]
  76
  77   userWatching?: UserWatching
  78
  79   serverUrl: string
  80 }
  81
  82 export type PeertubePlayerManagerOptions = {
  83   common: CommonOptions,
  84   webtorrent: WebtorrentOptions,
  85   p2pMediaLoader?: P2PMediaLoaderOptions
  86 }
  87
  88 export class PeertubePlayerManager {
  89
  90   private static videojsLocaleCache: { [ path: string ]: any } = {}
  91   private static playerElementClassName: string
  92   private static onPlayerChange: (player: any) => void
  93
  94   static getServerTranslations (serverUrl: string, locale: string) {
  95     const path = PeertubePlayerManager.getLocalePath(serverUrl, locale)
  96     // It is the default locale, nothing to translate
  97     if (!path) return Promise.resolve(undefined)
  98
  99     return fetch(path + '/server.json')
 100       .then(res => res.json())
 101       .catch(err => {
 102         console.error('Cannot get server translations', err)
 103         return undefined
 104       })
 105   }
 106
 107   static async initialize (mode: PlayerMode, options: PeertubePlayerManagerOptions, onPlayerChange: (player: any) => void) {
 108     let p2pMediaLoader: any
 109
 110     this.onPlayerChange = onPlayerChange
 111     this.playerElementClassName = options.common.playerElement.className
 112
 113     if (mode === 'webtorrent') await import('./webtorrent/webtorrent-plugin')
 114     if (mode === 'p2p-media-loader') {
 115       [ p2pMediaLoader ] = await Promise.all([
 116         import('p2p-media-loader-hlsjs'),
 117         import('./p2p-media-loader/p2p-media-loader-plugin')
 118       ])
 119     }
 120
 121     const videojsOptions = this.getVideojsOptions(mode, options, p2pMediaLoader)
 122
 123     await this.loadLocaleInVideoJS(options.common.serverUrl, options.common.language)
 124
 125     const self = this
 126     return new Promise(res => {
 127       videojs(options.common.playerElement, videojsOptions, function (this: any) {
 128         const player = this
 129
 130         let alreadyFallback = false
 131
 132         player.tech_.one('error', () => {
 133           if (!alreadyFallback) self.maybeFallbackToWebTorrent(mode, player, options)
 134           alreadyFallback = true
 135         })
 136
 137         player.one('error', () => {
 138           if (!alreadyFallback) self.maybeFallbackToWebTorrent(mode, player, options)
 139           alreadyFallback = true
 140         })
 141
 142         self.addContextMenu(mode, player, options.common.embedUrl)
 143
 144         return res(player)
 145       })
 146     })
 147   }
 148
 149   private static async maybeFallbackToWebTorrent (currentMode: PlayerMode, player: any, options: PeertubePlayerManagerOptions) {
 150     if (currentMode === 'webtorrent') return
 151
 152     console.log('Fallback to webtorrent.')
 153
 154     const newVideoElement = document.createElement('video')
 155     newVideoElement.className = this.playerElementClassName
 156
 157     // VideoJS wraps our video element inside a div
 158     let currentParentPlayerElement = options.common.playerElement.parentNode
 159     // Fix on IOS, don't ask me why
 160     if (!currentParentPlayerElement) currentParentPlayerElement = document.getElementById(options.common.playerElement.id).parentNode
 161
 162     currentParentPlayerElement.parentNode.insertBefore(newVideoElement, currentParentPlayerElement)
 163
 164     options.common.playerElement = newVideoElement
 165     options.common.onPlayerElementChange(newVideoElement)
 166
 167     player.dispose()
 168
 169     await import('./webtorrent/webtorrent-plugin')
 170
 171     const mode = 'webtorrent'
 172     const videojsOptions = this.getVideojsOptions(mode, options)
 173
 174     const self = this
 175     videojs(newVideoElement, videojsOptions, function (this: any) {
 176       const player = this
 177
 178       self.addContextMenu(mode, player, options.common.embedUrl)
 179
 180       PeertubePlayerManager.onPlayerChange(player)
 181     })
 182   }
 183
 184   private static loadLocaleInVideoJS (serverUrl: string, locale: string) {
 185     const path = PeertubePlayerManager.getLocalePath(serverUrl, locale)
 186     // It is the default locale, nothing to translate
 187     if (!path) return Promise.resolve(undefined)
 188
 189     let p: Promise<any>
 190
 191     if (PeertubePlayerManager.videojsLocaleCache[path]) {
 192       p = Promise.resolve(PeertubePlayerManager.videojsLocaleCache[path])
 193     } else {
 194       p = fetch(path + '/player.json')
 195         .then(res => res.json())
 196         .then(json => {
 197           PeertubePlayerManager.videojsLocaleCache[path] = json
 198           return json
 199         })
 200         .catch(err => {
 201           console.error('Cannot get player translations', err)
 202           return undefined
 203         })
 204     }
 205
 206     const completeLocale = getCompleteLocale(locale)
 207     return p.then(json => videojs.addLanguage(getShortLocale(completeLocale), json))
 208   }
 209
 210   private static getVideojsOptions (mode: PlayerMode, options: PeertubePlayerManagerOptions, p2pMediaLoaderModule?: any) {
 211     const commonOptions = options.common
 212
 213     let autoplay = commonOptions.autoplay
 214     let html5 = {}
 215
 216     const plugins: VideoJSPluginOptions = {
 217       peertube: {
 218         mode,
 219         autoplay, // Use peertube plugin autoplay because we get the file by webtorrent
 220         videoViewUrl: commonOptions.videoViewUrl,
 221         videoDuration: commonOptions.videoDuration,
 222         userWatching: commonOptions.userWatching,
 223         subtitle: commonOptions.subtitle,
 224         videoCaptions: commonOptions.videoCaptions,
 225         stopTime: commonOptions.stopTime
 226       }
 227     }
 228
 229     if (commonOptions.enableHotkeys === true) {
 230       PeertubePlayerManager.addHotkeysOptions(plugins)
 231     }
 232
 233     if (mode === 'p2p-media-loader') {
 234       const { streamrootHls } = PeertubePlayerManager.addP2PMediaLoaderOptions(plugins, options, p2pMediaLoaderModule)
 235
 236       html5 = streamrootHls.html5
 237     }
 238
 239     if (mode === 'webtorrent') {
 240       PeertubePlayerManager.addWebTorrentOptions(plugins, options)
 241
 242       // WebTorrent plugin handles autoplay, because we do some hackish stuff in there
 243       autoplay = false
 244     }
 245
 246     const videojsOptions = {
 247       html5,
 248
 249       // We don't use text track settings for now
 250       textTrackSettings: false,
 251       controls: commonOptions.controls !== undefined ? commonOptions.controls : true,
 252       loop: commonOptions.loop !== undefined ? commonOptions.loop : false,
 253
 254       muted: commonOptions.muted !== undefined
 255         ? commonOptions.muted
 256         : undefined, // Undefined so the player knows it has to check the local storage
 257
 258       autoplay: autoplay === true
 259         ? 'any' // Use 'any' instead of true to get notifier by videojs if autoplay fails
 260         : autoplay,
 261
 262       poster: commonOptions.poster,
 263       inactivityTimeout: commonOptions.inactivityTimeout,
 264       playbackRates: [ 0.5, 0.75, 1, 1.25, 1.5, 2 ],
 265
 266       plugins,
 267
 268       controlBar: {
 269         children: this.getControlBarChildren(mode, {
 270           captions: commonOptions.captions,
 271           peertubeLink: commonOptions.peertubeLink,
 272           theaterButton: commonOptions.theaterButton
 273         })
 274       }
 275     }
 276
 277     if (commonOptions.language && !isDefaultLocale(commonOptions.language)) {
 278       Object.assign(videojsOptions, { language: commonOptions.language })
 279     }
 280
 281     return videojsOptions
 282   }
 283
 284   private static addP2PMediaLoaderOptions (
 285     plugins: VideoJSPluginOptions,
 286     options: PeertubePlayerManagerOptions,
 287     p2pMediaLoaderModule: any
 288   ) {
 289     const p2pMediaLoaderOptions = options.p2pMediaLoader
 290     const commonOptions = options.common
 291
 292     const trackerAnnounce = p2pMediaLoaderOptions.trackerAnnounce
 293                                                  .filter(t => t.startsWith('ws'))
 294
 295     const redundancyUrlManager = new RedundancyUrlManager(options.p2pMediaLoader.redundancyBaseUrls)
 296
 297     const p2pMediaLoader: P2PMediaLoaderPluginOptions = {
 298       redundancyUrlManager,
 299       type: 'application/x-mpegURL',
 300       startTime: commonOptions.startTime,
 301       src: p2pMediaLoaderOptions.playlistUrl
 302     }
 303
 304     let consumeOnly = false
 305     // FIXME: typings
 306     if (navigator && (navigator as any).connection && (navigator as any).connection.type === 'cellular') {
 307       console.log('We are on a cellular connection: disabling seeding.')
 308       consumeOnly = true
 309     }
 310
 311     const p2pMediaLoaderConfig = {
 312       loader: {
 313         trackerAnnounce,
 314         segmentValidator: segmentValidatorFactory(options.p2pMediaLoader.segmentsSha256Url),
 315         rtcConfig: getRtcConfig(),
 316         requiredSegmentsPriority: 5,
 317         segmentUrlBuilder: segmentUrlBuilderFactory(redundancyUrlManager),
 318         useP2P: getStoredP2PEnabled(),
 319         consumeOnly
 320       },
 321       segments: {
 322         swarmId: p2pMediaLoaderOptions.playlistUrl
 323       }
 324     }
 325     const streamrootHls = {
 326       levelLabelHandler: (level: { height: number, width: number }) => {
 327         const file = p2pMediaLoaderOptions.videoFiles.find(f => f.resolution.id === level.height)
 328
 329         let label = file.resolution.label
 330         if (file.fps >= 50) label += file.fps
 331
 332         return label
 333       },
 334       html5: {
 335         hlsjsConfig: {
 336           capLevelToPlayerSize: true,
 337           autoStartLoad: false,
 338           liveSyncDurationCount: 7,
 339           loader: new p2pMediaLoaderModule.Engine(p2pMediaLoaderConfig).createLoaderClass()
 340         }
 341       }
 342     }
 343
 344     const toAssign = { p2pMediaLoader, streamrootHls }
 345     Object.assign(plugins, toAssign)
 346
 347     return toAssign
 348   }
 349
 350   private static addWebTorrentOptions (plugins: VideoJSPluginOptions, options: PeertubePlayerManagerOptions) {
 351     const commonOptions = options.common
 352     const webtorrentOptions = options.webtorrent
 353
 354     const webtorrent = {
 355       autoplay: commonOptions.autoplay,
 356       videoDuration: commonOptions.videoDuration,
 357       playerElement: commonOptions.playerElement,
 358       videoFiles: webtorrentOptions.videoFiles,
 359       startTime: commonOptions.startTime
 360     }
 361
 362     Object.assign(plugins, { webtorrent })
 363   }
 364
 365   private static getControlBarChildren (mode: PlayerMode, options: {
 366     peertubeLink: boolean
 367     theaterButton: boolean,
 368     captions: boolean
 369   }) {
 370     const settingEntries = []
 371     const loadProgressBar = mode === 'webtorrent' ? 'peerTubeLoadProgressBar' : 'loadProgressBar'
 372
 373     // Keep an order
 374     settingEntries.push('playbackRateMenuButton')
 375     if (options.captions === true) settingEntries.push('captionsButton')
 376     settingEntries.push('resolutionMenuButton')
 377
 378     const children = {
 379       'playToggle': {},
 380       'currentTimeDisplay': {},
 381       'timeDivider': {},
 382       'durationDisplay': {},
 383       'liveDisplay': {},
 384
 385       'flexibleWidthSpacer': {},
 386       'progressControl': {
 387         children: {
 388           'seekBar': {
 389             children: {
 390               [loadProgressBar]: {},
 391               'mouseTimeDisplay': {},
 392               'playProgressBar': {}
 393             }
 394           }
 395         }
 396       },
 397
 398       'p2PInfoButton': {},
 399
 400       'muteToggle': {},
 401       'volumeControl': {},
 402
 403       'settingsButton': {
 404         setup: {
 405           maxHeightOffset: 40
 406         },
 407         entries: settingEntries
 408       }
 409     }
 410
 411     if (options.peertubeLink === true) {
 412       Object.assign(children, {
 413         'peerTubeLinkButton': {}
 414       })
 415     }
 416
 417     if (options.theaterButton === true) {
 418       Object.assign(children, {
 419         'theaterButton': {}
 420       })
 421     }
 422
 423     Object.assign(children, {
 424       'fullscreenToggle': {}
 425     })
 426
 427     return children
 428   }
 429
 430   private static addContextMenu (mode: PlayerMode, player: any, videoEmbedUrl: string) {
 431     const content = [
 432       {
 433         label: player.localize('Copy the video URL'),
 434         listener: function () {
 435           copyToClipboard(buildVideoLink())
 436         }
 437       },
 438       {
 439         label: player.localize('Copy the video URL at the current time'),
 440         listener: function () {
 441           const player = this as videojs.Player
 442           copyToClipboard(buildVideoLink({ startTime: player.currentTime() }))
 443         }
 444       },
 445       {
 446         label: player.localize('Copy embed code'),
 447         listener: () => {
 448           copyToClipboard(buildVideoEmbed(videoEmbedUrl))
 449         }
 450       }
 451     ]
 452
 453     if (mode === 'webtorrent') {
 454       content.push({
 455         label: player.localize('Copy magnet URI'),
 456         listener: function () {
 457           const player = this as videojs.Player
 458           copyToClipboard(player.webtorrent().getCurrentVideoFile().magnetUri)
 459         }
 460       })
 461     }
 462
 463     player.contextmenuUI({ content })
 464   }
 465
 466   private static addHotkeysOptions (plugins: VideoJSPluginOptions) {
 467     Object.assign(plugins, {
 468       hotkeys: {
 469         enableVolumeScroll: false,
 470         enableModifiersForNumbers: false,
 471
 472         fullscreenKey: function (event: KeyboardEvent) {
 473           // fullscreen with the f key or Ctrl+Enter
 474           return event.key === 'f' || (event.ctrlKey && event.key === 'Enter')
 475         },
 476
 477         seekStep: function (event: KeyboardEvent) {
 478           // mimic VLC seek behavior, and default to 5 (original value is 5).
 479           if (event.ctrlKey && event.altKey) {
 480             return 5 * 60
 481           } else if (event.ctrlKey) {
 482             return 60
 483           } else if (event.altKey) {
 484             return 10
 485           } else {
 486             return 5
 487           }
 488         },
 489
 490         customKeys: {
 491           increasePlaybackRateKey: {
 492             key: function (event: KeyboardEvent) {
 493               return event.key === '>'
 494             },
 495             handler: function (player: videojs.Player) {
 496               player.playbackRate((player.playbackRate() + 0.1).toFixed(2))
 497             }
 498           },
 499           decreasePlaybackRateKey: {
 500             key: function (event: KeyboardEvent) {
 501               return event.key === '<'
 502             },
 503             handler: function (player: videojs.Player) {
 504               player.playbackRate((player.playbackRate() - 0.1).toFixed(2))
 505             }
 506           },
 507           frameByFrame: {
 508             key: function (event: KeyboardEvent) {
 509               return event.key === '.'
 510             },
 511             handler: function (player: videojs.Player) {
 512               player.pause()
 513               // Calculate movement distance (assuming 30 fps)
 514               const dist = 1 / 30
 515               player.currentTime(player.currentTime() + dist)
 516             }
 517           }
 518         }
 519       }
 520     })
 521   }
 522
 523   private static getLocalePath (serverUrl: string, locale: string) {
 524     const completeLocale = getCompleteLocale(locale)
 525
 526     if (!is18nLocale(completeLocale) || isDefaultLocale(completeLocale)) return undefined
 527
 528     return serverUrl + '/client/locales/' + completeLocale
 529   }
 530 }
 531
 532 // ############################################################################
 533
 534 export {
 535   videojs
 536 }