1 import 'videojs-hotkeys/videojs.hotkeys'
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 './mobile/peertube-mobile-plugin'
25 import videojs from 'video.js'
26 import { HlsJsEngineSettings } from '@peertube/p2p-media-loader-hlsjs'
27 import { PluginsManager } from '@root-helpers/plugins-manager'
28 import { buildVideoLink, decorateVideoLink } from '@shared/core-utils'
29 import { isDefaultLocale } from '@shared/core-utils/i18n'
30 import { VideoFile } from '@shared/models'
31 import { copyToClipboard } from '../../root-helpers/utils'
32 import { RedundancyUrlManager } from './p2p-media-loader/redundancy-url-manager'
33 import { segmentUrlBuilderFactory } from './p2p-media-loader/segment-url-builder'
34 import { segmentValidatorFactory } from './p2p-media-loader/segment-validator'
35 import { getAverageBandwidthInStore, saveAverageBandwidth } from './peertube-player-local-storage'
37 NextPreviousVideoButtonOptions,
38 P2PMediaLoaderPluginOptions,
39 PeerTubeLinkButtonOptions,
41 PlaylistPluginOptions,
45 } from './peertube-videojs-typings'
46 import { TranslationsManager } from './translations-manager'
47 import { buildVideoOrPlaylistEmbed, getRtcConfig, isIOS, isMobile, isSafari } from './utils'
49 // Change 'Playback Rate' to 'Speed' (smaller for our settings menu)
50 (videojs.getComponent('PlaybackRateMenuButton') as any).prototype.controlText_ = 'Speed'
52 const CaptionsButton = videojs.getComponent('CaptionsButton') as any
53 // Change Captions to Subtitles/CC
54 CaptionsButton.prototype.controlText_ = 'Subtitles/CC'
55 // We just want to display 'Off' instead of 'captions off', keep a space so the variable == true (hacky I know)
56 CaptionsButton.prototype.label_ = ' '
58 export type PlayerMode = 'webtorrent' | 'p2p-media-loader'
60 export type WebtorrentOptions = {
61 videoFiles: VideoFile[]
64 export type P2PMediaLoaderOptions = {
66 segmentsSha256Url: string
67 trackerAnnounce: string[]
68 redundancyBaseUrls: string[]
69 videoFiles: VideoFile[]
72 export interface CustomizationOptions {
73 startTime: number | string
74 stopTime: number | string
85 export interface CommonOptions extends CustomizationOptions {
86 playerElement: HTMLVideoElement
87 onPlayerElementChange: (element: HTMLVideoElement) => void
92 nextVideo?: () => void
93 hasNextVideo?: () => boolean
95 previousVideo?: () => void
96 hasPreviousVideo?: () => boolean
98 playlist?: PlaylistPluginOptions
100 videoDuration: number
101 enableHotkeys: boolean
102 inactivityTimeout: number
105 theaterButton: boolean
116 videoCaptions: VideoJSCaption[]
119 videoShortUUID: string
121 userWatching?: UserWatching
126 export type PeertubePlayerManagerOptions = {
127 common: CommonOptions
128 webtorrent: WebtorrentOptions
129 p2pMediaLoader?: P2PMediaLoaderOptions
131 pluginsManager: PluginsManager
134 export class PeertubePlayerManager {
135 private static playerElementClassName: string
136 private static onPlayerChange: (player: videojs.Player) => void
137 private static alreadyPlayed = false
138 private static pluginsManager: PluginsManager
140 static initState () {
141 PeertubePlayerManager.alreadyPlayed = false
144 static async initialize (mode: PlayerMode, options: PeertubePlayerManagerOptions, onPlayerChange: (player: videojs.Player) => void) {
145 this.pluginsManager = options.pluginsManager
147 let p2pMediaLoader: any
149 this.onPlayerChange = onPlayerChange
150 this.playerElementClassName = options.common.playerElement.className
152 if (mode === 'webtorrent') await import('./webtorrent/webtorrent-plugin')
153 if (mode === 'p2p-media-loader') {
154 [ p2pMediaLoader ] = await Promise.all([
155 import('@peertube/p2p-media-loader-hlsjs'),
156 import('./p2p-media-loader/p2p-media-loader-plugin')
160 const videojsOptions = await this.getVideojsOptions(mode, options, p2pMediaLoader)
162 await TranslationsManager.loadLocaleInVideoJS(options.common.serverUrl, options.common.language, videojs)
165 return new Promise(res => {
166 videojs(options.common.playerElement, videojsOptions, function (this: videojs.Player) {
169 let alreadyFallback = false
171 player.tech(true).one('error', () => {
172 if (!alreadyFallback) self.maybeFallbackToWebTorrent(mode, player, options)
173 alreadyFallback = true
176 player.one('error', () => {
177 if (!alreadyFallback) self.maybeFallbackToWebTorrent(mode, player, options)
178 alreadyFallback = true
181 player.one('play', () => {
182 PeertubePlayerManager.alreadyPlayed = true
185 self.addContextMenu({
188 videoShortUUID: options.common.videoShortUUID,
189 videoEmbedUrl: options.common.embedUrl,
190 videoEmbedTitle: options.common.embedTitle
193 if (isMobile()) player.peertubeMobile()
198 videoUUID: options.common.videoUUID,
199 videoIsLive: options.common.isLive,
201 p2pEnabled: options.common.p2pEnabled
204 player.on('p2pInfo', (_, data: PlayerNetworkInfo) => {
205 if (data.source !== 'p2p-media-loader' || isNaN(data.bandwidthEstimate)) return
207 saveAverageBandwidth(data.bandwidthEstimate)
215 private static async maybeFallbackToWebTorrent (currentMode: PlayerMode, player: any, options: PeertubePlayerManagerOptions) {
216 if (currentMode === 'webtorrent') return
218 console.log('Fallback to webtorrent.')
220 const newVideoElement = document.createElement('video')
221 newVideoElement.className = this.playerElementClassName
223 // VideoJS wraps our video element inside a div
224 let currentParentPlayerElement = options.common.playerElement.parentNode
225 // Fix on IOS, don't ask me why
226 if (!currentParentPlayerElement) currentParentPlayerElement = document.getElementById(options.common.playerElement.id).parentNode
228 currentParentPlayerElement.parentNode.insertBefore(newVideoElement, currentParentPlayerElement)
230 options.common.playerElement = newVideoElement
231 options.common.onPlayerElementChange(newVideoElement)
235 await import('./webtorrent/webtorrent-plugin')
237 const mode = 'webtorrent'
238 const videojsOptions = await this.getVideojsOptions(mode, options)
241 videojs(newVideoElement, videojsOptions, function (this: videojs.Player) {
244 self.addContextMenu({
247 videoShortUUID: options.common.videoShortUUID,
248 videoEmbedUrl: options.common.embedUrl,
249 videoEmbedTitle: options.common.embedTitle
252 PeertubePlayerManager.onPlayerChange(player)
256 private static async getVideojsOptions (
258 options: PeertubePlayerManagerOptions,
259 p2pMediaLoaderModule?: any
260 ): Promise<videojs.PlayerOptions> {
261 const commonOptions = options.common
262 const isHLS = mode === 'p2p-media-loader'
264 let autoplay = this.getAutoPlayValue(commonOptions.autoplay)
266 preloadTextTracks: false
269 const plugins: VideoJSPluginOptions = {
272 autoplay, // Use peertube plugin autoplay because we could get the file by webtorrent
273 videoViewUrl: commonOptions.videoViewUrl,
274 videoDuration: commonOptions.videoDuration,
275 userWatching: commonOptions.userWatching,
276 subtitle: commonOptions.subtitle,
277 videoCaptions: commonOptions.videoCaptions,
278 stopTime: commonOptions.stopTime,
279 isLive: commonOptions.isLive,
280 videoUUID: commonOptions.videoUUID
284 if (commonOptions.playlist) {
285 plugins.playlist = commonOptions.playlist
288 if (commonOptions.enableHotkeys === true) {
289 PeertubePlayerManager.addHotkeysOptions(plugins)
293 const { hlsjs } = PeertubePlayerManager.addP2PMediaLoaderOptions(plugins, options, p2pMediaLoaderModule)
295 Object.assign(html5, hlsjs.html5)
298 if (mode === 'webtorrent') {
299 PeertubePlayerManager.addWebTorrentOptions(plugins, options)
301 // WebTorrent plugin handles autoplay, because we do some hackish stuff in there
305 const videojsOptions = {
308 // We don't use text track settings for now
309 textTrackSettings: false as any, // FIXME: typings
310 controls: commonOptions.controls !== undefined ? commonOptions.controls : true,
311 loop: commonOptions.loop !== undefined ? commonOptions.loop : false,
313 muted: commonOptions.muted !== undefined
314 ? commonOptions.muted
315 : undefined, // Undefined so the player knows it has to check the local storage
317 autoplay: this.getAutoPlayValue(autoplay),
319 poster: commonOptions.poster,
320 inactivityTimeout: commonOptions.inactivityTimeout,
321 playbackRates: [ 0.5, 0.75, 1, 1.25, 1.5, 1.75, 2 ],
326 children: this.getControlBarChildren(mode, {
327 videoShortUUID: commonOptions.videoShortUUID,
328 p2pEnabled: commonOptions.p2pEnabled,
330 captions: commonOptions.captions,
331 peertubeLink: commonOptions.peertubeLink,
332 theaterButton: commonOptions.theaterButton,
334 nextVideo: commonOptions.nextVideo,
335 hasNextVideo: commonOptions.hasNextVideo,
337 previousVideo: commonOptions.previousVideo,
338 hasPreviousVideo: commonOptions.hasPreviousVideo
339 }) as any // FIXME: typings
343 if (commonOptions.language && !isDefaultLocale(commonOptions.language)) {
344 Object.assign(videojsOptions, { language: commonOptions.language })
347 return this.pluginsManager.runHook('filter:internal.player.videojs.options.result', videojsOptions)
350 private static addP2PMediaLoaderOptions (
351 plugins: VideoJSPluginOptions,
352 options: PeertubePlayerManagerOptions,
353 p2pMediaLoaderModule: any
355 const p2pMediaLoaderOptions = options.p2pMediaLoader
356 const commonOptions = options.common
358 const trackerAnnounce = p2pMediaLoaderOptions.trackerAnnounce
359 .filter(t => t.startsWith('ws'))
361 const redundancyUrlManager = new RedundancyUrlManager(options.p2pMediaLoader.redundancyBaseUrls)
363 const p2pMediaLoader: P2PMediaLoaderPluginOptions = {
364 redundancyUrlManager,
365 type: 'application/x-mpegURL',
366 startTime: commonOptions.startTime,
367 src: p2pMediaLoaderOptions.playlistUrl
370 let consumeOnly = false
371 if ((navigator as any)?.connection?.type === 'cellular') {
372 console.log('We are on a cellular connection: disabling seeding.')
376 const p2pMediaLoaderConfig: HlsJsEngineSettings = {
379 segmentValidator: segmentValidatorFactory(options.p2pMediaLoader.segmentsSha256Url, options.common.isLive),
380 rtcConfig: getRtcConfig(),
381 requiredSegmentsPriority: 1,
382 simultaneousHttpDownloads: 1,
383 segmentUrlBuilder: segmentUrlBuilderFactory(redundancyUrlManager, 1),
384 useP2P: commonOptions.p2pEnabled,
388 swarmId: p2pMediaLoaderOptions.playlistUrl
393 levelLabelHandler: (level: { height: number, width: number }) => {
394 const resolution = Math.min(level.height || 0, level.width || 0)
396 const file = p2pMediaLoaderOptions.videoFiles.find(f => f.resolution.id === resolution)
397 // We don't have files for live videos
398 if (!file) return level.height
400 let label = file.resolution.label
401 if (file.fps >= 50) label += file.fps
406 hlsjsConfig: this.getHLSOptions(p2pMediaLoaderModule, p2pMediaLoaderConfig)
410 const toAssign = { p2pMediaLoader, hlsjs }
411 Object.assign(plugins, toAssign)
416 private static getHLSOptions (p2pMediaLoaderModule: any, p2pMediaLoaderConfig: HlsJsEngineSettings) {
418 capLevelToPlayerSize: true,
419 autoStartLoad: false,
420 liveSyncDurationCount: 5,
422 loader: new p2pMediaLoaderModule.Engine(p2pMediaLoaderConfig).createLoaderClass()
425 const averageBandwidth = getAverageBandwidthInStore()
426 if (!averageBandwidth) return base
431 abrEwmaDefaultEstimate: averageBandwidth * 8, // We want bit/s
433 testBandwidth: false,
438 private static addWebTorrentOptions (plugins: VideoJSPluginOptions, options: PeertubePlayerManagerOptions) {
439 const commonOptions = options.common
440 const webtorrentOptions = options.webtorrent
441 const p2pMediaLoaderOptions = options.p2pMediaLoader
443 const autoplay = this.getAutoPlayValue(commonOptions.autoplay) === 'play'
447 playerRefusedP2P: commonOptions.p2pEnabled === false,
448 videoDuration: commonOptions.videoDuration,
449 playerElement: commonOptions.playerElement,
450 videoFiles: webtorrentOptions.videoFiles.length !== 0
451 ? webtorrentOptions.videoFiles
452 // The WebTorrent plugin won't be able to play these files, but it will fallback to HTTP mode
453 : p2pMediaLoaderOptions?.videoFiles || [],
454 startTime: commonOptions.startTime
457 Object.assign(plugins, { webtorrent })
460 private static getControlBarChildren (mode: PlayerMode, options: {
462 videoShortUUID: string
464 peertubeLink: boolean
465 theaterButton: boolean
468 nextVideo?: () => void
469 hasNextVideo?: () => boolean
471 previousVideo?: () => void
472 hasPreviousVideo?: () => boolean
474 const settingEntries = []
475 const loadProgressBar = mode === 'webtorrent' ? 'peerTubeLoadProgressBar' : 'loadProgressBar'
478 settingEntries.push('playbackRateMenuButton')
479 if (options.captions === true) settingEntries.push('captionsButton')
480 settingEntries.push('resolutionMenuButton')
484 if (options.previousVideo) {
485 const buttonOptions: NextPreviousVideoButtonOptions = {
487 handler: options.previousVideo,
489 if (!options.hasPreviousVideo) return false
491 return !options.hasPreviousVideo()
495 Object.assign(children, {
496 previousVideoButton: buttonOptions
500 Object.assign(children, { playToggle: {} })
502 if (options.nextVideo) {
503 const buttonOptions: NextPreviousVideoButtonOptions = {
505 handler: options.nextVideo,
507 if (!options.hasNextVideo) return false
509 return !options.hasNextVideo()
513 Object.assign(children, {
514 nextVideoButton: buttonOptions
518 Object.assign(children, {
519 currentTimeDisplay: {},
524 flexibleWidthSpacer: {},
529 [loadProgressBar]: {},
530 mouseTimeDisplay: {},
538 p2pEnabled: options.p2pEnabled
548 entries: settingEntries
552 if (options.peertubeLink === true) {
553 Object.assign(children, {
554 peerTubeLinkButton: { shortUUID: options.videoShortUUID } as PeerTubeLinkButtonOptions
558 if (options.theaterButton === true) {
559 Object.assign(children, {
564 Object.assign(children, {
571 private static addContextMenu (options: {
573 player: videojs.Player
574 videoShortUUID: string
575 videoEmbedUrl: string
576 videoEmbedTitle: string
578 const { mode, player, videoEmbedTitle, videoEmbedUrl, videoShortUUID } = options
580 const content = () => {
581 const isLoopEnabled = player.options_['loop']
585 label: player.localize('Play in loop') + (isLoopEnabled ? '<span class="vjs-icon-tick-white"></span>' : ''),
586 listener: function () {
587 player.options_['loop'] = !isLoopEnabled
591 label: player.localize('Copy the video URL'),
592 listener: function () {
593 copyToClipboard(buildVideoLink({ shortUUID: videoShortUUID }))
597 label: player.localize('Copy the video URL at the current time'),
598 listener: function (this: videojs.Player) {
599 const url = buildVideoLink({ shortUUID: videoShortUUID })
601 copyToClipboard(decorateVideoLink({ url, startTime: this.currentTime() }))
606 label: player.localize('Copy embed code'),
608 copyToClipboard(buildVideoOrPlaylistEmbed(videoEmbedUrl, videoEmbedTitle))
613 if (mode === 'webtorrent') {
615 label: player.localize('Copy magnet URI'),
616 listener: function (this: videojs.Player) {
617 copyToClipboard(this.webtorrent().getCurrentVideoFile().magnetUri)
624 label: player.localize('Stats for nerds'),
626 player.stats().show()
630 return items.map(i => ({
632 label: `<span class="vjs-icon-${i.icon || 'link-2'}"></span>` + i.label
637 player.contextmenuUI({ content })
640 private static addHotkeysOptions (plugins: VideoJSPluginOptions) {
641 const isNaked = (event: KeyboardEvent, key: string) =>
642 (!event.ctrlKey && !event.altKey && !event.metaKey && !event.shiftKey && event.key === key)
644 Object.assign(plugins, {
646 skipInitialFocus: true,
647 enableInactiveFocus: false,
648 captureDocumentHotkeys: true,
649 documentHotkeysFocusElementFilter: (e: HTMLElement) => {
650 const tagName = e.tagName.toLowerCase()
651 return e.id === 'content' || tagName === 'body' || tagName === 'video'
654 enableVolumeScroll: false,
655 enableModifiersForNumbers: false,
657 rewindKey: function (event: KeyboardEvent) {
658 return isNaked(event, 'ArrowLeft')
661 forwardKey: function (event: KeyboardEvent) {
662 return isNaked(event, 'ArrowRight')
665 fullscreenKey: function (event: KeyboardEvent) {
666 // fullscreen with the f key or Ctrl+Enter
667 return isNaked(event, 'f') || (!event.altKey && event.ctrlKey && event.key === 'Enter')
671 increasePlaybackRateKey: {
672 key: function (event: KeyboardEvent) {
673 return isNaked(event, '>')
675 handler: function (player: videojs.Player) {
676 const newValue = Math.min(player.playbackRate() + 0.1, 5)
677 player.playbackRate(parseFloat(newValue.toFixed(2)))
680 decreasePlaybackRateKey: {
681 key: function (event: KeyboardEvent) {
682 return isNaked(event, '<')
684 handler: function (player: videojs.Player) {
685 const newValue = Math.max(player.playbackRate() - 0.1, 0.10)
686 player.playbackRate(parseFloat(newValue.toFixed(2)))
690 key: function (event: KeyboardEvent) {
691 return isNaked(event, '.')
693 handler: function (player: videojs.Player) {
695 // Calculate movement distance (assuming 30 fps)
697 player.currentTime(player.currentTime() + dist)
705 private static getAutoPlayValue (autoplay: any) {
706 if (autoplay !== true) return autoplay
708 // On first play, disable autoplay to avoid issues
709 // But if the player already played videos, we can safely autoplay next ones
710 if (isIOS() || isSafari()) {
711 return PeertubePlayerManager.alreadyPlayed ? 'play' : false
718 // ############################################################################