1 import 'videojs-hotkeys/videojs.hotkeys'
3 import 'videojs-contextmenu-ui'
4 import 'videojs-contrib-quality-levels'
5 import './upnext/end-card'
6 import './upnext/upnext-plugin'
7 import './bezels/bezels-plugin'
8 import './peertube-plugin'
9 import './videojs-components/next-previous-video-button'
10 import './videojs-components/p2p-info-button'
11 import './videojs-components/peertube-link-button'
12 import './videojs-components/peertube-load-progress-bar'
13 import './videojs-components/resolution-menu-button'
14 import './videojs-components/resolution-menu-item'
15 import './videojs-components/settings-dialog'
16 import './videojs-components/settings-menu-button'
17 import './videojs-components/settings-menu-item'
18 import './videojs-components/settings-panel'
19 import './videojs-components/settings-panel-child'
20 import './videojs-components/theater-button'
21 import './playlist/playlist-plugin'
22 import videojs from 'video.js'
23 import { isDefaultLocale } from '@shared/core-utils/i18n'
24 import { VideoFile } from '@shared/models'
25 import { RedundancyUrlManager } from './p2p-media-loader/redundancy-url-manager'
26 import { segmentUrlBuilderFactory } from './p2p-media-loader/segment-url-builder'
27 import { segmentValidatorFactory } from './p2p-media-loader/segment-validator'
28 import { getStoredP2PEnabled } from './peertube-player-local-storage'
30 NextPreviousVideoButtonOptions,
31 P2PMediaLoaderPluginOptions,
32 PlaylistPluginOptions,
36 } from './peertube-videojs-typings'
37 import { TranslationsManager } from './translations-manager'
38 import { buildVideoOrPlaylistEmbed, buildVideoLink, getRtcConfig, isSafari, isIOS } from './utils'
39 import { copyToClipboard } from '../../root-helpers/utils'
41 // Change 'Playback Rate' to 'Speed' (smaller for our settings menu)
42 (videojs.getComponent('PlaybackRateMenuButton') as any).prototype.controlText_ = 'Speed'
44 const CaptionsButton = videojs.getComponent('CaptionsButton') as any
45 // Change Captions to Subtitles/CC
46 CaptionsButton.prototype.controlText_ = 'Subtitles/CC'
47 // We just want to display 'Off' instead of 'captions off', keep a space so the variable == true (hacky I know)
48 CaptionsButton.prototype.label_ = ' '
50 export type PlayerMode = 'webtorrent' | 'p2p-media-loader'
52 export type WebtorrentOptions = {
53 videoFiles: VideoFile[]
56 export type P2PMediaLoaderOptions = {
58 segmentsSha256Url: string
59 trackerAnnounce: string[]
60 redundancyBaseUrls: string[]
61 videoFiles: VideoFile[]
64 export interface CustomizationOptions {
65 startTime: number | string
66 stopTime: number | string
77 export interface CommonOptions extends CustomizationOptions {
78 playerElement: HTMLVideoElement
79 onPlayerElementChange: (element: HTMLVideoElement) => void
83 nextVideo?: () => void
84 hasNextVideo?: () => boolean
86 previousVideo?: () => void
87 hasPreviousVideo?: () => boolean
89 playlist?: PlaylistPluginOptions
92 enableHotkeys: boolean
93 inactivityTimeout: number
96 theaterButton: boolean
106 videoCaptions: VideoJSCaption[]
108 userWatching?: UserWatching
113 export type PeertubePlayerManagerOptions = {
114 common: CommonOptions,
115 webtorrent: WebtorrentOptions,
116 p2pMediaLoader?: P2PMediaLoaderOptions
119 export class PeertubePlayerManager {
120 private static playerElementClassName: string
121 private static onPlayerChange: (player: videojs.Player) => void
123 private static alreadyPlayed = false
125 static initState () {
126 PeertubePlayerManager.alreadyPlayed = false
129 static async initialize (mode: PlayerMode, options: PeertubePlayerManagerOptions, onPlayerChange: (player: videojs.Player) => void) {
130 let p2pMediaLoader: any
132 this.onPlayerChange = onPlayerChange
133 this.playerElementClassName = options.common.playerElement.className
135 if (mode === 'webtorrent') await import('./webtorrent/webtorrent-plugin')
136 if (mode === 'p2p-media-loader') {
137 [ p2pMediaLoader ] = await Promise.all([
138 import('p2p-media-loader-hlsjs'),
139 import('./p2p-media-loader/p2p-media-loader-plugin')
143 const videojsOptions = this.getVideojsOptions(mode, options, p2pMediaLoader)
145 await TranslationsManager.loadLocaleInVideoJS(options.common.serverUrl, options.common.language, videojs)
148 return new Promise(res => {
149 videojs(options.common.playerElement, videojsOptions, function (this: videojs.Player) {
152 let alreadyFallback = false
154 player.tech(true).one('error', () => {
155 if (!alreadyFallback) self.maybeFallbackToWebTorrent(mode, player, options)
156 alreadyFallback = true
159 player.one('error', () => {
160 if (!alreadyFallback) self.maybeFallbackToWebTorrent(mode, player, options)
161 alreadyFallback = true
164 player.one('play', () => {
165 PeertubePlayerManager.alreadyPlayed = true
168 self.addContextMenu(mode, player, options.common.embedUrl)
177 private static async maybeFallbackToWebTorrent (currentMode: PlayerMode, player: any, options: PeertubePlayerManagerOptions) {
178 if (currentMode === 'webtorrent') return
180 console.log('Fallback to webtorrent.')
182 const newVideoElement = document.createElement('video')
183 newVideoElement.className = this.playerElementClassName
185 // VideoJS wraps our video element inside a div
186 let currentParentPlayerElement = options.common.playerElement.parentNode
187 // Fix on IOS, don't ask me why
188 if (!currentParentPlayerElement) currentParentPlayerElement = document.getElementById(options.common.playerElement.id).parentNode
190 currentParentPlayerElement.parentNode.insertBefore(newVideoElement, currentParentPlayerElement)
192 options.common.playerElement = newVideoElement
193 options.common.onPlayerElementChange(newVideoElement)
197 await import('./webtorrent/webtorrent-plugin')
199 const mode = 'webtorrent'
200 const videojsOptions = this.getVideojsOptions(mode, options)
203 videojs(newVideoElement, videojsOptions, function (this: videojs.Player) {
206 self.addContextMenu(mode, player, options.common.embedUrl)
208 PeertubePlayerManager.onPlayerChange(player)
212 private static getVideojsOptions (
214 options: PeertubePlayerManagerOptions,
215 p2pMediaLoaderModule?: any
216 ): videojs.PlayerOptions {
217 const commonOptions = options.common
218 const isHLS = mode === 'p2p-media-loader'
220 let autoplay = this.getAutoPlayValue(commonOptions.autoplay)
223 const plugins: VideoJSPluginOptions = {
226 autoplay, // Use peertube plugin autoplay because we could get the file by webtorrent
227 videoViewUrl: commonOptions.videoViewUrl,
228 videoDuration: commonOptions.videoDuration,
229 userWatching: commonOptions.userWatching,
230 subtitle: commonOptions.subtitle,
231 videoCaptions: commonOptions.videoCaptions,
232 stopTime: commonOptions.stopTime,
233 isLive: commonOptions.isLive
237 if (commonOptions.playlist) {
238 plugins.playlist = commonOptions.playlist
241 if (commonOptions.enableHotkeys === true) {
242 PeertubePlayerManager.addHotkeysOptions(plugins)
246 const { hlsjs } = PeertubePlayerManager.addP2PMediaLoaderOptions(plugins, options, p2pMediaLoaderModule)
251 if (mode === 'webtorrent') {
252 PeertubePlayerManager.addWebTorrentOptions(plugins, options)
254 // WebTorrent plugin handles autoplay, because we do some hackish stuff in there
258 const videojsOptions = {
261 // We don't use text track settings for now
262 textTrackSettings: false as any, // FIXME: typings
263 controls: commonOptions.controls !== undefined ? commonOptions.controls : true,
264 loop: commonOptions.loop !== undefined ? commonOptions.loop : false,
266 muted: commonOptions.muted !== undefined
267 ? commonOptions.muted
268 : undefined, // Undefined so the player knows it has to check the local storage
270 autoplay: this.getAutoPlayValue(autoplay),
272 poster: commonOptions.poster,
273 inactivityTimeout: commonOptions.inactivityTimeout,
274 playbackRates: [ 0.5, 0.75, 1, 1.25, 1.5, 1.75, 2 ],
279 children: this.getControlBarChildren(mode, {
280 captions: commonOptions.captions,
281 peertubeLink: commonOptions.peertubeLink,
282 theaterButton: commonOptions.theaterButton,
284 nextVideo: commonOptions.nextVideo,
285 hasNextVideo: commonOptions.hasNextVideo,
287 previousVideo: commonOptions.previousVideo,
288 hasPreviousVideo: commonOptions.hasPreviousVideo
289 }) as any // FIXME: typings
293 if (commonOptions.language && !isDefaultLocale(commonOptions.language)) {
294 Object.assign(videojsOptions, { language: commonOptions.language })
297 return videojsOptions
300 private static addP2PMediaLoaderOptions (
301 plugins: VideoJSPluginOptions,
302 options: PeertubePlayerManagerOptions,
303 p2pMediaLoaderModule: any
305 const p2pMediaLoaderOptions = options.p2pMediaLoader
306 const commonOptions = options.common
308 const trackerAnnounce = p2pMediaLoaderOptions.trackerAnnounce
309 .filter(t => t.startsWith('ws'))
311 const redundancyUrlManager = new RedundancyUrlManager(options.p2pMediaLoader.redundancyBaseUrls)
313 const p2pMediaLoader: P2PMediaLoaderPluginOptions = {
314 redundancyUrlManager,
315 type: 'application/x-mpegURL',
316 startTime: commonOptions.startTime,
317 src: p2pMediaLoaderOptions.playlistUrl
320 let consumeOnly = false
322 if (navigator && (navigator as any).connection && (navigator as any).connection.type === 'cellular') {
323 console.log('We are on a cellular connection: disabling seeding.')
327 const p2pMediaLoaderConfig = {
330 segmentValidator: segmentValidatorFactory(options.p2pMediaLoader.segmentsSha256Url, options.common.isLive),
331 rtcConfig: getRtcConfig(),
332 requiredSegmentsPriority: 1,
333 segmentUrlBuilder: segmentUrlBuilderFactory(redundancyUrlManager),
334 useP2P: getStoredP2PEnabled(),
338 swarmId: p2pMediaLoaderOptions.playlistUrl
342 levelLabelHandler: (level: { height: number, width: number }) => {
343 const resolution = Math.min(level.height || 0, level.width || 0)
345 const file = p2pMediaLoaderOptions.videoFiles.find(f => f.resolution.id === resolution)
346 // We don't have files for live videos
347 if (!file) return level.height
349 let label = file.resolution.label
350 if (file.fps >= 50) label += file.fps
356 capLevelToPlayerSize: true,
357 autoStartLoad: false,
358 liveSyncDurationCount: 5,
359 loader: new p2pMediaLoaderModule.Engine(p2pMediaLoaderConfig).createLoaderClass()
364 const toAssign = { p2pMediaLoader, hlsjs }
365 Object.assign(plugins, toAssign)
370 private static addWebTorrentOptions (plugins: VideoJSPluginOptions, options: PeertubePlayerManagerOptions) {
371 const commonOptions = options.common
372 const webtorrentOptions = options.webtorrent
374 const autoplay = this.getAutoPlayValue(commonOptions.autoplay) === 'play'
380 videoDuration: commonOptions.videoDuration,
381 playerElement: commonOptions.playerElement,
382 videoFiles: webtorrentOptions.videoFiles,
383 startTime: commonOptions.startTime
386 Object.assign(plugins, { webtorrent })
389 private static getControlBarChildren (mode: PlayerMode, options: {
390 peertubeLink: boolean
391 theaterButton: boolean
395 hasNextVideo?: () => boolean
397 previousVideo?: Function
398 hasPreviousVideo?: () => boolean
400 const settingEntries = []
401 const loadProgressBar = mode === 'webtorrent' ? 'peerTubeLoadProgressBar' : 'loadProgressBar'
404 settingEntries.push('playbackRateMenuButton')
405 if (options.captions === true) settingEntries.push('captionsButton')
406 settingEntries.push('resolutionMenuButton')
410 if (options.previousVideo) {
411 const buttonOptions: NextPreviousVideoButtonOptions = {
413 handler: options.previousVideo,
415 if (!options.hasPreviousVideo) return false
417 return !options.hasPreviousVideo()
421 Object.assign(children, {
422 'previousVideoButton': buttonOptions
426 Object.assign(children, { playToggle: {} })
428 if (options.nextVideo) {
429 const buttonOptions: NextPreviousVideoButtonOptions = {
431 handler: options.nextVideo,
433 if (!options.hasNextVideo) return false
435 return !options.hasNextVideo()
439 Object.assign(children, {
440 'nextVideoButton': buttonOptions
444 Object.assign(children, {
445 'currentTimeDisplay': {},
447 'durationDisplay': {},
450 'flexibleWidthSpacer': {},
455 [loadProgressBar]: {},
456 'mouseTimeDisplay': {},
457 'playProgressBar': {}
472 entries: settingEntries
476 if (options.peertubeLink === true) {
477 Object.assign(children, {
478 'peerTubeLinkButton': {}
482 if (options.theaterButton === true) {
483 Object.assign(children, {
488 Object.assign(children, {
489 'fullscreenToggle': {}
495 private static addContextMenu (mode: PlayerMode, player: videojs.Player, videoEmbedUrl: string) {
498 label: player.localize('Copy the video URL'),
499 listener: function () {
500 copyToClipboard(buildVideoLink())
504 label: player.localize('Copy the video URL at the current time'),
505 listener: function (this: videojs.Player) {
506 copyToClipboard(buildVideoLink({ startTime: this.currentTime() }))
510 label: player.localize('Copy embed code'),
512 copyToClipboard(buildVideoOrPlaylistEmbed(videoEmbedUrl))
517 if (mode === 'webtorrent') {
519 label: player.localize('Copy magnet URI'),
520 listener: function (this: videojs.Player) {
521 copyToClipboard(this.webtorrent().getCurrentVideoFile().magnetUri)
526 player.contextmenuUI({ content })
529 private static addHotkeysOptions (plugins: VideoJSPluginOptions) {
530 const isNaked = (event: KeyboardEvent, key: string) =>
531 (!event.ctrlKey && !event.altKey && !event.metaKey && !event.shiftKey && event.key === key)
533 Object.assign(plugins, {
535 skipInitialFocus: true,
536 enableInactiveFocus: false,
537 captureDocumentHotkeys: true,
538 documentHotkeysFocusElementFilter: (e: HTMLElement) => {
539 const tagName = e.tagName.toLowerCase()
540 return e.id === 'content' || tagName === 'body' || tagName === 'video'
543 enableVolumeScroll: false,
544 enableModifiersForNumbers: false,
546 rewindKey: function (event: KeyboardEvent) {
547 return isNaked(event, 'ArrowLeft')
550 forwardKey: function (event: KeyboardEvent) {
551 return isNaked(event, 'ArrowRight')
554 fullscreenKey: function (event: KeyboardEvent) {
555 // fullscreen with the f key or Ctrl+Enter
556 return isNaked(event, 'f') || (!event.altKey && event.ctrlKey && event.key === 'Enter')
560 increasePlaybackRateKey: {
561 key: function (event: KeyboardEvent) {
562 return isNaked(event, '>')
564 handler: function (player: videojs.Player) {
565 const newValue = Math.min(player.playbackRate() + 0.1, 5)
566 player.playbackRate(parseFloat(newValue.toFixed(2)))
569 decreasePlaybackRateKey: {
570 key: function (event: KeyboardEvent) {
571 return isNaked(event, '<')
573 handler: function (player: videojs.Player) {
574 const newValue = Math.max(player.playbackRate() - 0.1, 0.10)
575 player.playbackRate(parseFloat(newValue.toFixed(2)))
579 key: function (event: KeyboardEvent) {
580 return isNaked(event, '.')
582 handler: function (player: videojs.Player) {
584 // Calculate movement distance (assuming 30 fps)
586 player.currentTime(player.currentTime() + dist)
594 private static getAutoPlayValue (autoplay: any) {
595 if (autoplay !== true) return autoplay
597 // On first play, disable autoplay to avoid issues
598 // But if the player already played videos, we can safely autoplay next ones
599 if (isIOS() || isSafari()) {
600 return PeertubePlayerManager.alreadyPlayed ? 'play' : false
607 // ############################################################################