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

   1 import 'videojs-hotkeys/videojs.hotkeys'
   2 import 'videojs-dock'
   3 import '@peertube/videojs-contextmenu'
   4 import './upnext/end-card'
   5 import './upnext/upnext-plugin'
   6 import './stats/stats-card'
   7 import './stats/stats-plugin'
   8 import './bezels/bezels-plugin'
   9 import './peertube-plugin'
  10 import './peertube-resolutions-plugin'
  11 import './videojs-components/next-previous-video-button'
  12 import './videojs-components/p2p-info-button'
  13 import './videojs-components/peertube-link-button'
  14 import './videojs-components/peertube-load-progress-bar'
  15 import './videojs-components/resolution-menu-button'
  16 import './videojs-components/resolution-menu-item'
  17 import './videojs-components/settings-dialog'
  18 import './videojs-components/settings-menu-button'
  19 import './videojs-components/settings-menu-item'
  20 import './videojs-components/settings-panel'
  21 import './videojs-components/settings-panel-child'
  22 import './videojs-components/theater-button'
  23 import './playlist/playlist-plugin'
  24 import videojs from 'video.js'
  25 import { HlsJsEngineSettings } from '@peertube/p2p-media-loader-hlsjs'
  26 import { PluginsManager } from '@root-helpers/plugins-manager'
  27 import { buildVideoLink, decorateVideoLink } from '@shared/core-utils'
  28 import { isDefaultLocale } from '@shared/core-utils/i18n'
  29 import { VideoFile } from '@shared/models'
  30 import { copyToClipboard } from '../../root-helpers/utils'
  31 import { RedundancyUrlManager } from './p2p-media-loader/redundancy-url-manager'
  32 import { segmentUrlBuilderFactory } from './p2p-media-loader/segment-url-builder'
  33 import { segmentValidatorFactory } from './p2p-media-loader/segment-validator'
  34 import { getAverageBandwidthInStore, saveAverageBandwidth } from './peertube-player-local-storage'
  35 import {
  36   NextPreviousVideoButtonOptions,
  37   P2PMediaLoaderPluginOptions,
  38   PeerTubeLinkButtonOptions,
  39   PlayerNetworkInfo,
  40   PlaylistPluginOptions,
  41   UserWatching,
  42   VideoJSCaption,
  43   VideoJSPluginOptions
  44 } from './peertube-videojs-typings'
  45 import { TranslationsManager } from './translations-manager'
  46 import { buildVideoOrPlaylistEmbed, getRtcConfig, isIOS, isSafari } from './utils'
  47
  48 // Change 'Playback Rate' to 'Speed' (smaller for our settings menu)
  49 (videojs.getComponent('PlaybackRateMenuButton') as any).prototype.controlText_ = 'Speed'
  50
  51 const CaptionsButton = videojs.getComponent('CaptionsButton') as any
  52 // Change Captions to Subtitles/CC
  53 CaptionsButton.prototype.controlText_ = 'Subtitles/CC'
  54 // We just want to display 'Off' instead of 'captions off', keep a space so the variable == true (hacky I know)
  55 CaptionsButton.prototype.label_ = ' '
  56
  57 export type PlayerMode = 'webtorrent' | 'p2p-media-loader'
  58
  59 export type WebtorrentOptions = {
  60   videoFiles: VideoFile[]
  61 }
  62
  63 export type P2PMediaLoaderOptions = {
  64   playlistUrl: string
  65   segmentsSha256Url: string
  66   trackerAnnounce: string[]
  67   redundancyBaseUrls: string[]
  68   videoFiles: VideoFile[]
  69 }
  70
  71 export interface CustomizationOptions {
  72   startTime: number | string
  73   stopTime: number | string
  74
  75   controls?: boolean
  76   muted?: boolean
  77   loop?: boolean
  78   subtitle?: string
  79   resume?: string
  80
  81   peertubeLink: boolean
  82 }
  83
  84 export interface CommonOptions extends CustomizationOptions {
  85   playerElement: HTMLVideoElement
  86   onPlayerElementChange: (element: HTMLVideoElement) => void
  87
  88   autoplay: boolean
  89   p2pEnabled: boolean
  90
  91   nextVideo?: () => void
  92   hasNextVideo?: () => boolean
  93
  94   previousVideo?: () => void
  95   hasPreviousVideo?: () => boolean
  96
  97   playlist?: PlaylistPluginOptions
  98
  99   videoDuration: number
 100   enableHotkeys: boolean
 101   inactivityTimeout: number
 102   poster: string
 103
 104   theaterButton: boolean
 105   captions: boolean
 106
 107   videoViewUrl: string
 108   embedUrl: string
 109   embedTitle: string
 110
 111   isLive: boolean
 112
 113   language?: string
 114
 115   videoCaptions: VideoJSCaption[]
 116
 117   videoUUID: string
 118   videoShortUUID: string
 119
 120   userWatching?: UserWatching
 121
 122   serverUrl: string
 123 }
 124
 125 export type PeertubePlayerManagerOptions = {
 126   common: CommonOptions
 127   webtorrent: WebtorrentOptions
 128   p2pMediaLoader?: P2PMediaLoaderOptions
 129
 130   pluginsManager: PluginsManager
 131 }
 132
 133 export class PeertubePlayerManager {
 134   private static playerElementClassName: string
 135   private static onPlayerChange: (player: videojs.Player) => void
 136   private static alreadyPlayed = false
 137   private static pluginsManager: PluginsManager
 138
 139   static initState () {
 140     PeertubePlayerManager.alreadyPlayed = false
 141   }
 142
 143   static async initialize (mode: PlayerMode, options: PeertubePlayerManagerOptions, onPlayerChange: (player: videojs.Player) => void) {
 144     this.pluginsManager = options.pluginsManager
 145
 146     let p2pMediaLoader: any
 147
 148     this.onPlayerChange = onPlayerChange
 149     this.playerElementClassName = options.common.playerElement.className
 150
 151     if (mode === 'webtorrent') await import('./webtorrent/webtorrent-plugin')
 152     if (mode === 'p2p-media-loader') {
 153       [ p2pMediaLoader ] = await Promise.all([
 154         import('@peertube/p2p-media-loader-hlsjs'),
 155         import('./p2p-media-loader/p2p-media-loader-plugin')
 156       ])
 157     }
 158
 159     const videojsOptions = await this.getVideojsOptions(mode, options, p2pMediaLoader)
 160
 161     await TranslationsManager.loadLocaleInVideoJS(options.common.serverUrl, options.common.language, videojs)
 162
 163     const self = this
 164     return new Promise(res => {
 165       videojs(options.common.playerElement, videojsOptions, function (this: videojs.Player) {
 166         const player = this
 167
 168         let alreadyFallback = false
 169
 170         player.tech(true).one('error', () => {
 171           if (!alreadyFallback) self.maybeFallbackToWebTorrent(mode, player, options)
 172           alreadyFallback = true
 173         })
 174
 175         player.one('error', () => {
 176           if (!alreadyFallback) self.maybeFallbackToWebTorrent(mode, player, options)
 177           alreadyFallback = true
 178         })
 179
 180         player.one('play', () => {
 181           PeertubePlayerManager.alreadyPlayed = true
 182         })
 183
 184         self.addContextMenu({
 185           mode,
 186           player,
 187           videoShortUUID: options.common.videoShortUUID,
 188           videoEmbedUrl: options.common.embedUrl,
 189           videoEmbedTitle: options.common.embedTitle
 190         })
 191
 192         player.bezels()
 193         player.stats({
 194           videoUUID: options.common.videoUUID,
 195           videoIsLive: options.common.isLive,
 196           mode,
 197           p2pEnabled: options.common.p2pEnabled
 198         })
 199
 200         player.on('p2pInfo', (_, data: PlayerNetworkInfo) => {
 201           if (data.source !== 'p2p-media-loader' || isNaN(data.bandwidthEstimate)) return
 202
 203           saveAverageBandwidth(data.bandwidthEstimate)
 204         })
 205
 206         return res(player)
 207       })
 208     })
 209   }
 210
 211   private static async maybeFallbackToWebTorrent (currentMode: PlayerMode, player: any, options: PeertubePlayerManagerOptions) {
 212     if (currentMode === 'webtorrent') return
 213
 214     console.log('Fallback to webtorrent.')
 215
 216     const newVideoElement = document.createElement('video')
 217     newVideoElement.className = this.playerElementClassName
 218
 219     // VideoJS wraps our video element inside a div
 220     let currentParentPlayerElement = options.common.playerElement.parentNode
 221     // Fix on IOS, don't ask me why
 222     if (!currentParentPlayerElement) currentParentPlayerElement = document.getElementById(options.common.playerElement.id).parentNode
 223
 224     currentParentPlayerElement.parentNode.insertBefore(newVideoElement, currentParentPlayerElement)
 225
 226     options.common.playerElement = newVideoElement
 227     options.common.onPlayerElementChange(newVideoElement)
 228
 229     player.dispose()
 230
 231     await import('./webtorrent/webtorrent-plugin')
 232
 233     const mode = 'webtorrent'
 234     const videojsOptions = await this.getVideojsOptions(mode, options)
 235
 236     const self = this
 237     videojs(newVideoElement, videojsOptions, function (this: videojs.Player) {
 238       const player = this
 239
 240       self.addContextMenu({
 241         mode,
 242         player,
 243         videoShortUUID: options.common.videoShortUUID,
 244         videoEmbedUrl: options.common.embedUrl,
 245         videoEmbedTitle: options.common.embedTitle
 246       })
 247
 248       PeertubePlayerManager.onPlayerChange(player)
 249     })
 250   }
 251
 252   private static async getVideojsOptions (
 253     mode: PlayerMode,
 254     options: PeertubePlayerManagerOptions,
 255     p2pMediaLoaderModule?: any
 256   ): Promise<videojs.PlayerOptions> {
 257     const commonOptions = options.common
 258     const isHLS = mode === 'p2p-media-loader'
 259
 260     let autoplay = this.getAutoPlayValue(commonOptions.autoplay)
 261     const html5 = {
 262       preloadTextTracks: false
 263     }
 264
 265     const plugins: VideoJSPluginOptions = {
 266       peertube: {
 267         mode,
 268         autoplay, // Use peertube plugin autoplay because we could get the file by webtorrent
 269         videoViewUrl: commonOptions.videoViewUrl,
 270         videoDuration: commonOptions.videoDuration,
 271         userWatching: commonOptions.userWatching,
 272         subtitle: commonOptions.subtitle,
 273         videoCaptions: commonOptions.videoCaptions,
 274         stopTime: commonOptions.stopTime,
 275         isLive: commonOptions.isLive,
 276         videoUUID: commonOptions.videoUUID
 277       }
 278     }
 279
 280     if (commonOptions.playlist) {
 281       plugins.playlist = commonOptions.playlist
 282     }
 283
 284     if (commonOptions.enableHotkeys === true) {
 285       PeertubePlayerManager.addHotkeysOptions(plugins)
 286     }
 287
 288     if (isHLS) {
 289       const { hlsjs } = PeertubePlayerManager.addP2PMediaLoaderOptions(plugins, options, p2pMediaLoaderModule)
 290
 291       Object.assign(html5, hlsjs.html5)
 292     }
 293
 294     if (mode === 'webtorrent') {
 295       PeertubePlayerManager.addWebTorrentOptions(plugins, options)
 296
 297       // WebTorrent plugin handles autoplay, because we do some hackish stuff in there
 298       autoplay = false
 299     }
 300
 301     const videojsOptions = {
 302       html5,
 303
 304       // We don't use text track settings for now
 305       textTrackSettings: false as any, // FIXME: typings
 306       controls: commonOptions.controls !== undefined ? commonOptions.controls : true,
 307       loop: commonOptions.loop !== undefined ? commonOptions.loop : false,
 308
 309       muted: commonOptions.muted !== undefined
 310         ? commonOptions.muted
 311         : undefined, // Undefined so the player knows it has to check the local storage
 312
 313       autoplay: this.getAutoPlayValue(autoplay),
 314
 315       poster: commonOptions.poster,
 316       inactivityTimeout: commonOptions.inactivityTimeout,
 317       playbackRates: [ 0.5, 0.75, 1, 1.25, 1.5, 1.75, 2 ],
 318
 319       plugins,
 320
 321       controlBar: {
 322         children: this.getControlBarChildren(mode, {
 323           videoShortUUID: commonOptions.videoShortUUID,
 324           p2pEnabled: commonOptions.p2pEnabled,
 325
 326           captions: commonOptions.captions,
 327           peertubeLink: commonOptions.peertubeLink,
 328           theaterButton: commonOptions.theaterButton,
 329
 330           nextVideo: commonOptions.nextVideo,
 331           hasNextVideo: commonOptions.hasNextVideo,
 332
 333           previousVideo: commonOptions.previousVideo,
 334           hasPreviousVideo: commonOptions.hasPreviousVideo
 335         }) as any // FIXME: typings
 336       }
 337     }
 338
 339     if (commonOptions.language && !isDefaultLocale(commonOptions.language)) {
 340       Object.assign(videojsOptions, { language: commonOptions.language })
 341     }
 342
 343     return this.pluginsManager.runHook('filter:internal.player.videojs.options.result', videojsOptions)
 344   }
 345
 346   private static addP2PMediaLoaderOptions (
 347     plugins: VideoJSPluginOptions,
 348     options: PeertubePlayerManagerOptions,
 349     p2pMediaLoaderModule: any
 350   ) {
 351     const p2pMediaLoaderOptions = options.p2pMediaLoader
 352     const commonOptions = options.common
 353
 354     const trackerAnnounce = p2pMediaLoaderOptions.trackerAnnounce
 355                                                  .filter(t => t.startsWith('ws'))
 356
 357     const redundancyUrlManager = new RedundancyUrlManager(options.p2pMediaLoader.redundancyBaseUrls)
 358
 359     const p2pMediaLoader: P2PMediaLoaderPluginOptions = {
 360       redundancyUrlManager,
 361       type: 'application/x-mpegURL',
 362       startTime: commonOptions.startTime,
 363       src: p2pMediaLoaderOptions.playlistUrl
 364     }
 365
 366     let consumeOnly = false
 367     if ((navigator as any)?.connection?.type === 'cellular') {
 368       console.log('We are on a cellular connection: disabling seeding.')
 369       consumeOnly = true
 370     }
 371
 372     const p2pMediaLoaderConfig: HlsJsEngineSettings = {
 373       loader: {
 374         trackerAnnounce,
 375         segmentValidator: segmentValidatorFactory(options.p2pMediaLoader.segmentsSha256Url, options.common.isLive),
 376         rtcConfig: getRtcConfig(),
 377         requiredSegmentsPriority: 1,
 378         simultaneousHttpDownloads: 1,
 379         segmentUrlBuilder: segmentUrlBuilderFactory(redundancyUrlManager, 1),
 380         useP2P: commonOptions.p2pEnabled,
 381         consumeOnly
 382       },
 383       segments: {
 384         swarmId: p2pMediaLoaderOptions.playlistUrl
 385       }
 386     }
 387
 388     const hlsjs = {
 389       levelLabelHandler: (level: { height: number, width: number }) => {
 390         const resolution = Math.min(level.height || 0, level.width || 0)
 391
 392         const file = p2pMediaLoaderOptions.videoFiles.find(f => f.resolution.id === resolution)
 393         // We don't have files for live videos
 394         if (!file) return level.height
 395
 396         let label = file.resolution.label
 397         if (file.fps >= 50) label += file.fps
 398
 399         return label
 400       },
 401       html5: {
 402         hlsjsConfig: this.getHLSOptions(p2pMediaLoaderModule, p2pMediaLoaderConfig)
 403       }
 404     }
 405
 406     const toAssign = { p2pMediaLoader, hlsjs }
 407     Object.assign(plugins, toAssign)
 408
 409     return toAssign
 410   }
 411
 412   private static getHLSOptions (p2pMediaLoaderModule: any, p2pMediaLoaderConfig: HlsJsEngineSettings) {
 413     const base = {
 414       capLevelToPlayerSize: true,
 415       autoStartLoad: false,
 416       liveSyncDurationCount: 5,
 417
 418       loader: new p2pMediaLoaderModule.Engine(p2pMediaLoaderConfig).createLoaderClass()
 419     }
 420
 421     const averageBandwidth = getAverageBandwidthInStore()
 422     if (!averageBandwidth) return base
 423
 424     return {
 425       ...base,
 426
 427       abrEwmaDefaultEstimate: averageBandwidth * 8, // We want bit/s
 428       startLevel: -1,
 429       testBandwidth: false,
 430       debug: false
 431     }
 432   }
 433
 434   private static addWebTorrentOptions (plugins: VideoJSPluginOptions, options: PeertubePlayerManagerOptions) {
 435     const commonOptions = options.common
 436     const webtorrentOptions = options.webtorrent
 437     const p2pMediaLoaderOptions = options.p2pMediaLoader
 438
 439     const autoplay = this.getAutoPlayValue(commonOptions.autoplay) === 'play'
 440
 441     const webtorrent = {
 442       autoplay,
 443       playerRefusedP2P: commonOptions.p2pEnabled === false,
 444       videoDuration: commonOptions.videoDuration,
 445       playerElement: commonOptions.playerElement,
 446       videoFiles: webtorrentOptions.videoFiles.length !== 0
 447         ? webtorrentOptions.videoFiles
 448         // The WebTorrent plugin won't be able to play these files, but it will fallback to HTTP mode
 449         : p2pMediaLoaderOptions?.videoFiles || [],
 450       startTime: commonOptions.startTime
 451     }
 452
 453     Object.assign(plugins, { webtorrent })
 454   }
 455
 456   private static getControlBarChildren (mode: PlayerMode, options: {
 457     p2pEnabled: boolean
 458     videoShortUUID: string
 459
 460     peertubeLink: boolean
 461     theaterButton: boolean
 462     captions: boolean
 463
 464     nextVideo?: () => void
 465     hasNextVideo?: () => boolean
 466
 467     previousVideo?: () => void
 468     hasPreviousVideo?: () => boolean
 469   }) {
 470     const settingEntries = []
 471     const loadProgressBar = mode === 'webtorrent' ? 'peerTubeLoadProgressBar' : 'loadProgressBar'
 472
 473     // Keep an order
 474     settingEntries.push('playbackRateMenuButton')
 475     if (options.captions === true) settingEntries.push('captionsButton')
 476     settingEntries.push('resolutionMenuButton')
 477
 478     const children = {}
 479
 480     if (options.previousVideo) {
 481       const buttonOptions: NextPreviousVideoButtonOptions = {
 482         type: 'previous',
 483         handler: options.previousVideo,
 484         isDisabled: () => {
 485           if (!options.hasPreviousVideo) return false
 486
 487           return !options.hasPreviousVideo()
 488         }
 489       }
 490
 491       Object.assign(children, {
 492         previousVideoButton: buttonOptions
 493       })
 494     }
 495
 496     Object.assign(children, { playToggle: {} })
 497
 498     if (options.nextVideo) {
 499       const buttonOptions: NextPreviousVideoButtonOptions = {
 500         type: 'next',
 501         handler: options.nextVideo,
 502         isDisabled: () => {
 503           if (!options.hasNextVideo) return false
 504
 505           return !options.hasNextVideo()
 506         }
 507       }
 508
 509       Object.assign(children, {
 510         nextVideoButton: buttonOptions
 511       })
 512     }
 513
 514     Object.assign(children, {
 515       currentTimeDisplay: {},
 516       timeDivider: {},
 517       durationDisplay: {},
 518       liveDisplay: {},
 519
 520       flexibleWidthSpacer: {},
 521       progressControl: {
 522         children: {
 523           seekBar: {
 524             children: {
 525               [loadProgressBar]: {},
 526               mouseTimeDisplay: {},
 527               playProgressBar: {}
 528             }
 529           }
 530         }
 531       },
 532
 533       p2PInfoButton: {
 534         p2pEnabled: options.p2pEnabled
 535       },
 536
 537       muteToggle: {},
 538       volumeControl: {},
 539
 540       settingsButton: {
 541         setup: {
 542           maxHeightOffset: 40
 543         },
 544         entries: settingEntries
 545       }
 546     })
 547
 548     if (options.peertubeLink === true) {
 549       Object.assign(children, {
 550         peerTubeLinkButton: { shortUUID: options.videoShortUUID } as PeerTubeLinkButtonOptions
 551       })
 552     }
 553
 554     if (options.theaterButton === true) {
 555       Object.assign(children, {
 556         theaterButton: {}
 557       })
 558     }
 559
 560     Object.assign(children, {
 561       fullscreenToggle: {}
 562     })
 563
 564     return children
 565   }
 566
 567   private static addContextMenu (options: {
 568     mode: PlayerMode
 569     player: videojs.Player
 570     videoShortUUID: string
 571     videoEmbedUrl: string
 572     videoEmbedTitle: string
 573   }) {
 574     const { mode, player, videoEmbedTitle, videoEmbedUrl, videoShortUUID } = options
 575
 576     const content = () => {
 577       const isLoopEnabled = player.options_['loop']
 578       const items = [
 579         {
 580           icon: 'repeat',
 581           label: player.localize('Play in loop') + (isLoopEnabled ? '<span class="vjs-icon-tick-white"></span>' : ''),
 582           listener: function () {
 583             player.options_['loop'] = !isLoopEnabled
 584           }
 585         },
 586         {
 587           label: player.localize('Copy the video URL'),
 588           listener: function () {
 589             copyToClipboard(buildVideoLink({ shortUUID: videoShortUUID }))
 590           }
 591         },
 592         {
 593           label: player.localize('Copy the video URL at the current time'),
 594           listener: function (this: videojs.Player) {
 595             const url = buildVideoLink({ shortUUID: videoShortUUID })
 596
 597             copyToClipboard(decorateVideoLink({ url, startTime: this.currentTime() }))
 598           }
 599         },
 600         {
 601           icon: 'code',
 602           label: player.localize('Copy embed code'),
 603           listener: () => {
 604             copyToClipboard(buildVideoOrPlaylistEmbed(videoEmbedUrl, videoEmbedTitle))
 605           }
 606         }
 607       ]
 608
 609       if (mode === 'webtorrent') {
 610         items.push({
 611           label: player.localize('Copy magnet URI'),
 612           listener: function (this: videojs.Player) {
 613             copyToClipboard(this.webtorrent().getCurrentVideoFile().magnetUri)
 614           }
 615         })
 616       }
 617
 618       items.push({
 619         icon: 'info',
 620         label: player.localize('Stats for nerds'),
 621         listener: () => {
 622           player.stats().show()
 623         }
 624       })
 625
 626       return items.map(i => ({
 627         ...i,
 628         label: `<span class="vjs-icon-${i.icon || 'link-2'}"></span>` + i.label
 629       }))
 630     }
 631
 632     // adding the menu
 633     player.contextmenuUI({ content })
 634   }
 635
 636   private static addHotkeysOptions (plugins: VideoJSPluginOptions) {
 637     const isNaked = (event: KeyboardEvent, key: string) =>
 638       (!event.ctrlKey && !event.altKey && !event.metaKey && !event.shiftKey && event.key === key)
 639
 640     Object.assign(plugins, {
 641       hotkeys: {
 642         skipInitialFocus: true,
 643         enableInactiveFocus: false,
 644         captureDocumentHotkeys: true,
 645         documentHotkeysFocusElementFilter: (e: HTMLElement) => {
 646           const tagName = e.tagName.toLowerCase()
 647           return e.id === 'content' || tagName === 'body' || tagName === 'video'
 648         },
 649
 650         enableVolumeScroll: false,
 651         enableModifiersForNumbers: false,
 652
 653         rewindKey: function (event: KeyboardEvent) {
 654           return isNaked(event, 'ArrowLeft')
 655         },
 656
 657         forwardKey: function (event: KeyboardEvent) {
 658           return isNaked(event, 'ArrowRight')
 659         },
 660
 661         fullscreenKey: function (event: KeyboardEvent) {
 662           // fullscreen with the f key or Ctrl+Enter
 663           return isNaked(event, 'f') || (!event.altKey && event.ctrlKey && event.key === 'Enter')
 664         },
 665
 666         customKeys: {
 667           increasePlaybackRateKey: {
 668             key: function (event: KeyboardEvent) {
 669               return isNaked(event, '>')
 670             },
 671             handler: function (player: videojs.Player) {
 672               const newValue = Math.min(player.playbackRate() + 0.1, 5)
 673               player.playbackRate(parseFloat(newValue.toFixed(2)))
 674             }
 675           },
 676           decreasePlaybackRateKey: {
 677             key: function (event: KeyboardEvent) {
 678               return isNaked(event, '<')
 679             },
 680             handler: function (player: videojs.Player) {
 681               const newValue = Math.max(player.playbackRate() - 0.1, 0.10)
 682               player.playbackRate(parseFloat(newValue.toFixed(2)))
 683             }
 684           },
 685           frameByFrame: {
 686             key: function (event: KeyboardEvent) {
 687               return isNaked(event, '.')
 688             },
 689             handler: function (player: videojs.Player) {
 690               player.pause()
 691               // Calculate movement distance (assuming 30 fps)
 692               const dist = 1 / 30
 693               player.currentTime(player.currentTime() + dist)
 694             }
 695           }
 696         }
 697       }
 698     })
 699   }
 700
 701   private static getAutoPlayValue (autoplay: any) {
 702     if (autoplay !== true) return autoplay
 703
 704     // On first play, disable autoplay to avoid issues
 705     // But if the player already played videos, we can safely autoplay next ones
 706     if (isIOS() || isSafari()) {
 707       return PeertubePlayerManager.alreadyPlayed ? 'play' : false
 708     }
 709
 710     return 'play'
 711   }
 712 }
 713
 714 // ############################################################################
 715
 716 export {
 717   videojs
 718 }