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 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'
36 NextPreviousVideoButtonOptions,
37 P2PMediaLoaderPluginOptions,
38 PeerTubeLinkButtonOptions,
40 PlaylistPluginOptions,
44 } from './peertube-videojs-typings'
45 import { TranslationsManager } from './translations-manager'
46 import { buildVideoOrPlaylistEmbed, getRtcConfig, isIOS, isSafari } from './utils'
48 // Change 'Playback Rate' to 'Speed' (smaller for our settings menu)
49 (videojs.getComponent('PlaybackRateMenuButton') as any).prototype.controlText_ = 'Speed'
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_ = ' '
57 export type PlayerMode = 'webtorrent' | 'p2p-media-loader'
59 export type WebtorrentOptions = {
60 videoFiles: VideoFile[]
63 export type P2PMediaLoaderOptions = {
65 segmentsSha256Url: string
66 trackerAnnounce: string[]
67 redundancyBaseUrls: string[]
68 videoFiles: VideoFile[]
71 export interface CustomizationOptions {
72 startTime: number | string
73 stopTime: number | string
84 export interface CommonOptions extends CustomizationOptions {
85 playerElement: HTMLVideoElement
86 onPlayerElementChange: (element: HTMLVideoElement) => void
91 nextVideo?: () => void
92 hasNextVideo?: () => boolean
94 previousVideo?: () => void
95 hasPreviousVideo?: () => boolean
97 playlist?: PlaylistPluginOptions
100 enableHotkeys: boolean
101 inactivityTimeout: number
104 theaterButton: boolean
115 videoCaptions: VideoJSCaption[]
118 videoShortUUID: string
120 userWatching?: UserWatching
125 export type PeertubePlayerManagerOptions = {
126 common: CommonOptions
127 webtorrent: WebtorrentOptions
128 p2pMediaLoader?: P2PMediaLoaderOptions
130 pluginsManager: PluginsManager
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
139 static initState () {
140 PeertubePlayerManager.alreadyPlayed = false
143 static async initialize (mode: PlayerMode, options: PeertubePlayerManagerOptions, onPlayerChange: (player: videojs.Player) => void) {
144 this.pluginsManager = options.pluginsManager
146 let p2pMediaLoader: any
148 this.onPlayerChange = onPlayerChange
149 this.playerElementClassName = options.common.playerElement.className
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')
159 const videojsOptions = await this.getVideojsOptions(mode, options, p2pMediaLoader)
161 await TranslationsManager.loadLocaleInVideoJS(options.common.serverUrl, options.common.language, videojs)
164 return new Promise(res => {
165 videojs(options.common.playerElement, videojsOptions, function (this: videojs.Player) {
168 let alreadyFallback = false
170 player.tech(true).one('error', () => {
171 if (!alreadyFallback) self.maybeFallbackToWebTorrent(mode, player, options)
172 alreadyFallback = true
175 player.one('error', () => {
176 if (!alreadyFallback) self.maybeFallbackToWebTorrent(mode, player, options)
177 alreadyFallback = true
180 player.one('play', () => {
181 PeertubePlayerManager.alreadyPlayed = true
184 self.addContextMenu({
187 videoShortUUID: options.common.videoShortUUID,
188 videoEmbedUrl: options.common.embedUrl,
189 videoEmbedTitle: options.common.embedTitle
194 videoUUID: options.common.videoUUID,
195 videoIsLive: options.common.isLive,
197 p2pEnabled: options.common.p2pEnabled
200 player.on('p2pInfo', (_, data: PlayerNetworkInfo) => {
201 if (data.source !== 'p2p-media-loader' || isNaN(data.bandwidthEstimate)) return
203 saveAverageBandwidth(data.bandwidthEstimate)
211 private static async maybeFallbackToWebTorrent (currentMode: PlayerMode, player: any, options: PeertubePlayerManagerOptions) {
212 if (currentMode === 'webtorrent') return
214 console.log('Fallback to webtorrent.')
216 const newVideoElement = document.createElement('video')
217 newVideoElement.className = this.playerElementClassName
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
224 currentParentPlayerElement.parentNode.insertBefore(newVideoElement, currentParentPlayerElement)
226 options.common.playerElement = newVideoElement
227 options.common.onPlayerElementChange(newVideoElement)
231 await import('./webtorrent/webtorrent-plugin')
233 const mode = 'webtorrent'
234 const videojsOptions = await this.getVideojsOptions(mode, options)
237 videojs(newVideoElement, videojsOptions, function (this: videojs.Player) {
240 self.addContextMenu({
243 videoShortUUID: options.common.videoShortUUID,
244 videoEmbedUrl: options.common.embedUrl,
245 videoEmbedTitle: options.common.embedTitle
248 PeertubePlayerManager.onPlayerChange(player)
252 private static async getVideojsOptions (
254 options: PeertubePlayerManagerOptions,
255 p2pMediaLoaderModule?: any
256 ): Promise<videojs.PlayerOptions> {
257 const commonOptions = options.common
258 const isHLS = mode === 'p2p-media-loader'
260 let autoplay = this.getAutoPlayValue(commonOptions.autoplay)
262 preloadTextTracks: false
265 const plugins: VideoJSPluginOptions = {
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
280 if (commonOptions.playlist) {
281 plugins.playlist = commonOptions.playlist
284 if (commonOptions.enableHotkeys === true) {
285 PeertubePlayerManager.addHotkeysOptions(plugins)
289 const { hlsjs } = PeertubePlayerManager.addP2PMediaLoaderOptions(plugins, options, p2pMediaLoaderModule)
291 Object.assign(html5, hlsjs.html5)
294 if (mode === 'webtorrent') {
295 PeertubePlayerManager.addWebTorrentOptions(plugins, options)
297 // WebTorrent plugin handles autoplay, because we do some hackish stuff in there
301 const videojsOptions = {
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,
309 muted: commonOptions.muted !== undefined
310 ? commonOptions.muted
311 : undefined, // Undefined so the player knows it has to check the local storage
313 autoplay: this.getAutoPlayValue(autoplay),
315 poster: commonOptions.poster,
316 inactivityTimeout: commonOptions.inactivityTimeout,
317 playbackRates: [ 0.5, 0.75, 1, 1.25, 1.5, 1.75, 2 ],
322 children: this.getControlBarChildren(mode, {
323 videoShortUUID: commonOptions.videoShortUUID,
324 p2pEnabled: commonOptions.p2pEnabled,
326 captions: commonOptions.captions,
327 peertubeLink: commonOptions.peertubeLink,
328 theaterButton: commonOptions.theaterButton,
330 nextVideo: commonOptions.nextVideo,
331 hasNextVideo: commonOptions.hasNextVideo,
333 previousVideo: commonOptions.previousVideo,
334 hasPreviousVideo: commonOptions.hasPreviousVideo
335 }) as any // FIXME: typings
339 if (commonOptions.language && !isDefaultLocale(commonOptions.language)) {
340 Object.assign(videojsOptions, { language: commonOptions.language })
343 return this.pluginsManager.runHook('filter:internal.player.videojs.options.result', videojsOptions)
346 private static addP2PMediaLoaderOptions (
347 plugins: VideoJSPluginOptions,
348 options: PeertubePlayerManagerOptions,
349 p2pMediaLoaderModule: any
351 const p2pMediaLoaderOptions = options.p2pMediaLoader
352 const commonOptions = options.common
354 const trackerAnnounce = p2pMediaLoaderOptions.trackerAnnounce
355 .filter(t => t.startsWith('ws'))
357 const redundancyUrlManager = new RedundancyUrlManager(options.p2pMediaLoader.redundancyBaseUrls)
359 const p2pMediaLoader: P2PMediaLoaderPluginOptions = {
360 redundancyUrlManager,
361 type: 'application/x-mpegURL',
362 startTime: commonOptions.startTime,
363 src: p2pMediaLoaderOptions.playlistUrl
366 let consumeOnly = false
367 if ((navigator as any)?.connection?.type === 'cellular') {
368 console.log('We are on a cellular connection: disabling seeding.')
372 const p2pMediaLoaderConfig: HlsJsEngineSettings = {
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,
384 swarmId: p2pMediaLoaderOptions.playlistUrl
389 levelLabelHandler: (level: { height: number, width: number }) => {
390 const resolution = Math.min(level.height || 0, level.width || 0)
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
396 let label = file.resolution.label
397 if (file.fps >= 50) label += file.fps
402 hlsjsConfig: this.getHLSOptions(p2pMediaLoaderModule, p2pMediaLoaderConfig)
406 const toAssign = { p2pMediaLoader, hlsjs }
407 Object.assign(plugins, toAssign)
412 private static getHLSOptions (p2pMediaLoaderModule: any, p2pMediaLoaderConfig: HlsJsEngineSettings) {
414 capLevelToPlayerSize: true,
415 autoStartLoad: false,
416 liveSyncDurationCount: 5,
418 loader: new p2pMediaLoaderModule.Engine(p2pMediaLoaderConfig).createLoaderClass()
421 const averageBandwidth = getAverageBandwidthInStore()
422 if (!averageBandwidth) return base
427 abrEwmaDefaultEstimate: averageBandwidth * 8, // We want bit/s
429 testBandwidth: false,
434 private static addWebTorrentOptions (plugins: VideoJSPluginOptions, options: PeertubePlayerManagerOptions) {
435 const commonOptions = options.common
436 const webtorrentOptions = options.webtorrent
437 const p2pMediaLoaderOptions = options.p2pMediaLoader
439 const autoplay = this.getAutoPlayValue(commonOptions.autoplay) === 'play'
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
453 Object.assign(plugins, { webtorrent })
456 private static getControlBarChildren (mode: PlayerMode, options: {
458 videoShortUUID: string
460 peertubeLink: boolean
461 theaterButton: boolean
464 nextVideo?: () => void
465 hasNextVideo?: () => boolean
467 previousVideo?: () => void
468 hasPreviousVideo?: () => boolean
470 const settingEntries = []
471 const loadProgressBar = mode === 'webtorrent' ? 'peerTubeLoadProgressBar' : 'loadProgressBar'
474 settingEntries.push('playbackRateMenuButton')
475 if (options.captions === true) settingEntries.push('captionsButton')
476 settingEntries.push('resolutionMenuButton')
480 if (options.previousVideo) {
481 const buttonOptions: NextPreviousVideoButtonOptions = {
483 handler: options.previousVideo,
485 if (!options.hasPreviousVideo) return false
487 return !options.hasPreviousVideo()
491 Object.assign(children, {
492 previousVideoButton: buttonOptions
496 Object.assign(children, { playToggle: {} })
498 if (options.nextVideo) {
499 const buttonOptions: NextPreviousVideoButtonOptions = {
501 handler: options.nextVideo,
503 if (!options.hasNextVideo) return false
505 return !options.hasNextVideo()
509 Object.assign(children, {
510 nextVideoButton: buttonOptions
514 Object.assign(children, {
515 currentTimeDisplay: {},
520 flexibleWidthSpacer: {},
525 [loadProgressBar]: {},
526 mouseTimeDisplay: {},
534 p2pEnabled: options.p2pEnabled
544 entries: settingEntries
548 if (options.peertubeLink === true) {
549 Object.assign(children, {
550 peerTubeLinkButton: { shortUUID: options.videoShortUUID } as PeerTubeLinkButtonOptions
554 if (options.theaterButton === true) {
555 Object.assign(children, {
560 Object.assign(children, {
567 private static addContextMenu (options: {
569 player: videojs.Player
570 videoShortUUID: string
571 videoEmbedUrl: string
572 videoEmbedTitle: string
574 const { mode, player, videoEmbedTitle, videoEmbedUrl, videoShortUUID } = options
576 const content = () => {
577 const isLoopEnabled = player.options_['loop']
581 label: player.localize('Play in loop') + (isLoopEnabled ? '<span class="vjs-icon-tick-white"></span>' : ''),
582 listener: function () {
583 player.options_['loop'] = !isLoopEnabled
587 label: player.localize('Copy the video URL'),
588 listener: function () {
589 copyToClipboard(buildVideoLink({ shortUUID: videoShortUUID }))
593 label: player.localize('Copy the video URL at the current time'),
594 listener: function (this: videojs.Player) {
595 const url = buildVideoLink({ shortUUID: videoShortUUID })
597 copyToClipboard(decorateVideoLink({ url, startTime: this.currentTime() }))
602 label: player.localize('Copy embed code'),
604 copyToClipboard(buildVideoOrPlaylistEmbed(videoEmbedUrl, videoEmbedTitle))
609 if (mode === 'webtorrent') {
611 label: player.localize('Copy magnet URI'),
612 listener: function (this: videojs.Player) {
613 copyToClipboard(this.webtorrent().getCurrentVideoFile().magnetUri)
620 label: player.localize('Stats for nerds'),
622 player.stats().show()
626 return items.map(i => ({
628 label: `<span class="vjs-icon-${i.icon || 'link-2'}"></span>` + i.label
633 player.contextmenuUI({ content })
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)
640 Object.assign(plugins, {
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'
650 enableVolumeScroll: false,
651 enableModifiersForNumbers: false,
653 rewindKey: function (event: KeyboardEvent) {
654 return isNaked(event, 'ArrowLeft')
657 forwardKey: function (event: KeyboardEvent) {
658 return isNaked(event, 'ArrowRight')
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')
667 increasePlaybackRateKey: {
668 key: function (event: KeyboardEvent) {
669 return isNaked(event, '>')
671 handler: function (player: videojs.Player) {
672 const newValue = Math.min(player.playbackRate() + 0.1, 5)
673 player.playbackRate(parseFloat(newValue.toFixed(2)))
676 decreasePlaybackRateKey: {
677 key: function (event: KeyboardEvent) {
678 return isNaked(event, '<')
680 handler: function (player: videojs.Player) {
681 const newValue = Math.max(player.playbackRate() - 0.1, 0.10)
682 player.playbackRate(parseFloat(newValue.toFixed(2)))
686 key: function (event: KeyboardEvent) {
687 return isNaked(event, '.')
689 handler: function (player: videojs.Player) {
691 // Calculate movement distance (assuming 30 fps)
693 player.currentTime(player.currentTime() + dist)
701 private static getAutoPlayValue (autoplay: any) {
702 if (autoplay !== true) return autoplay
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
714 // ############################################################################