6 files changed, 772 insertions, 0 deletions

diff --git a/client/src/assets/player/shared/p2p-media-loader/hls-plugin.ts b/client/src/assets/player/shared/p2p-media-loader/hls-plugin.ts
new file mode 100644
index 000000000..d0105fa36
--- /dev/null
+++ b/client/src/assets/player/shared/p2p-media-loader/hls-plugin.ts
@@ -0,0 +1,419 @@
+// Thanks https://github.com/streamroot/videojs-hlsjs-plugin
+// We duplicated this plugin to choose the hls.js version we want, because streamroot only provide a bundled file
+
+import Hlsjs, { ErrorData, HlsConfig, Level, LevelSwitchingData, ManifestParsedData } from 'hls.js'
+import videojs from 'video.js'
+import { HlsjsConfigHandlerOptions, PeerTubeResolution, VideoJSTechHLS } from '../../types'
+
+type ErrorCounts = {
+  [ type: string ]: number
+}
+
+type Metadata = {
+  levels: Level[]
+}
+
+type HookFn = (player: videojs.Player, hljs: Hlsjs) => void
+
+const registerSourceHandler = function (vjs: typeof videojs) {
+  if (!Hlsjs.isSupported()) {
+    console.warn('Hls.js is not supported in this browser!')
+    return
+  }
+
+  const html5 = vjs.getTech('Html5')
+
+  if (!html5) {
+    console.error('No Hml5 tech found in videojs')
+    return
+  }
+
+  // FIXME: typings
+  (html5 as any).registerSourceHandler({
+    canHandleSource: function (source: videojs.Tech.SourceObject) {
+      const hlsTypeRE = /^application\/x-mpegURL|application\/vnd\.apple\.mpegurl$/i
+      const hlsExtRE = /\.m3u8/i
+
+      if (hlsTypeRE.test(source.type)) return 'probably'
+      if (hlsExtRE.test(source.src)) return 'maybe'
+
+      return ''
+    },
+
+    handleSource: function (source: videojs.Tech.SourceObject, tech: VideoJSTechHLS) {
+      if (tech.hlsProvider) {
+        tech.hlsProvider.dispose()
+      }
+
+      tech.hlsProvider = new Html5Hlsjs(vjs, source, tech)
+
+      return tech.hlsProvider
+    }
+  }, 0);
+
+  // FIXME: typings
+  (vjs as any).Html5Hlsjs = Html5Hlsjs
+}
+
+function hlsjsConfigHandler (this: videojs.Player, options: HlsjsConfigHandlerOptions) {
+  const player = this
+
+  if (!options) return
+
+  if (!player.srOptions_) {
+    player.srOptions_ = {}
+  }
+
+  if (!player.srOptions_.hlsjsConfig) {
+    player.srOptions_.hlsjsConfig = options.hlsjsConfig
+  }
+
+  if (options.levelLabelHandler && !player.srOptions_.levelLabelHandler) {
+    player.srOptions_.levelLabelHandler = options.levelLabelHandler
+  }
+}
+
+const registerConfigPlugin = function (vjs: typeof videojs) {
+  // Used in Brightcove since we don't pass options directly there
+  const registerVjsPlugin = vjs.registerPlugin || vjs.plugin
+  registerVjsPlugin('hlsjs', hlsjsConfigHandler)
+}
+
+class Html5Hlsjs {
+  private static readonly hooks: { [id: string]: HookFn[] } = {}
+
+  private readonly videoElement: HTMLVideoElement
+  private readonly errorCounts: ErrorCounts = {}
+  private readonly player: videojs.Player
+  private readonly tech: videojs.Tech
+  private readonly source: videojs.Tech.SourceObject
+  private readonly vjs: typeof videojs
+
+  private maxNetworkErrorRecovery = 5
+
+  private hls: Hlsjs
+  private hlsjsConfig: Partial<HlsConfig & { cueHandler: any }> = null
+
+  private _duration: number = null
+  private metadata: Metadata = null
+  private isLive: boolean = null
+  private dvrDuration: number = null
+  private edgeMargin: number = null
+
+  private handlers: { [ id in 'play' ]: EventListener } = {
+    play: null
+  }
+
+  constructor (vjs: typeof videojs, source: videojs.Tech.SourceObject, tech: videojs.Tech) {
+    this.vjs = vjs
+    this.source = source
+
+    this.tech = tech;
+    (this.tech as any).name_ = 'Hlsjs'
+
+    this.videoElement = tech.el() as HTMLVideoElement
+    this.player = vjs((tech.options_ as any).playerId)
+
+    this.videoElement.addEventListener('error', event => {
+      let errorTxt: string
+      const mediaError = ((event.currentTarget || event.target) as HTMLVideoElement).error
+
+      if (!mediaError) return
+
+      console.log(mediaError)
+      switch (mediaError.code) {
+        case mediaError.MEDIA_ERR_ABORTED:
+          errorTxt = 'You aborted the video playback'
+          break
+        case mediaError.MEDIA_ERR_DECODE:
+          errorTxt = 'The video playback was aborted due to a corruption problem or because the video used features ' +
+                     'your browser did not support'
+          this._handleMediaError(mediaError)
+          break
+        case mediaError.MEDIA_ERR_NETWORK:
+          errorTxt = 'A network error caused the video download to fail part-way'
+          break
+        case mediaError.MEDIA_ERR_SRC_NOT_SUPPORTED:
+          errorTxt = 'The video could not be loaded, either because the server or network failed or because the format is not supported'
+          break
+
+        default:
+          errorTxt = mediaError.message
+      }
+
+      console.error('MEDIA_ERROR: ', errorTxt)
+    })
+
+    this.initialize()
+  }
+
+  duration () {
+    if (this._duration === Infinity) return Infinity
+    if (!isNaN(this.videoElement.duration)) return this.videoElement.duration
+
+    return this._duration || 0
+  }
+
+  seekable () {
+    if (this.hls.media) {
+      if (!this.isLive) {
+        return this.vjs.createTimeRanges(0, this.hls.media.duration)
+      }
+
+      // Video.js doesn't seem to like floating point timeranges
+      const startTime = Math.round(this.hls.media.duration - this.dvrDuration)
+      const endTime = Math.round(this.hls.media.duration - this.edgeMargin)
+
+      return this.vjs.createTimeRanges(startTime, endTime)
+    }
+
+    return this.vjs.createTimeRanges()
+  }
+
+  // See comment for `initialize` method.
+  dispose () {
+    this.videoElement.removeEventListener('play', this.handlers.play)
+
+    // FIXME: https://github.com/video-dev/hls.js/issues/4092
+    const untypedHLS = this.hls as any
+    untypedHLS.log = untypedHLS.warn = () => {
+      // empty
+    }
+
+    this.hls.destroy()
+  }
+
+  static addHook (type: string, callback: HookFn) {
+    Html5Hlsjs.hooks[type] = this.hooks[type] || []
+    Html5Hlsjs.hooks[type].push(callback)
+  }
+
+  static removeHook (type: string, callback: HookFn) {
+    if (Html5Hlsjs.hooks[type] === undefined) return false
+
+    const index = Html5Hlsjs.hooks[type].indexOf(callback)
+    if (index === -1) return false
+
+    Html5Hlsjs.hooks[type].splice(index, 1)
+
+    return true
+  }
+
+  private _executeHooksFor (type: string) {
+    if (Html5Hlsjs.hooks[type] === undefined) {
+      return
+    }
+
+    // ES3 and IE < 9
+    for (let i = 0; i < Html5Hlsjs.hooks[type].length; i++) {
+      Html5Hlsjs.hooks[type][i](this.player, this.hls)
+    }
+  }
+
+  private _handleMediaError (error: any) {
+    if (this.errorCounts[Hlsjs.ErrorTypes.MEDIA_ERROR] === 1) {
+      console.info('trying to recover media error')
+      this.hls.recoverMediaError()
+      return
+    }
+
+    if (this.errorCounts[Hlsjs.ErrorTypes.MEDIA_ERROR] === 2) {
+      console.info('2nd try to recover media error (by swapping audio codec')
+      this.hls.swapAudioCodec()
+      this.hls.recoverMediaError()
+      return
+    }
+
+    if (this.errorCounts[Hlsjs.ErrorTypes.MEDIA_ERROR] > 2) {
+      console.info('bubbling media error up to VIDEOJS')
+      this.hls.destroy()
+      this.tech.error = () => error
+      this.tech.trigger('error')
+    }
+  }
+
+  private _handleNetworkError (error: any) {
+    if (this.errorCounts[Hlsjs.ErrorTypes.NETWORK_ERROR] <= this.maxNetworkErrorRecovery) {
+      console.info('trying to recover network error')
+
+      // Wait 1 second and retry
+      setTimeout(() => this.hls.startLoad(), 1000)
+
+      // Reset error count on success
+      this.hls.once(Hlsjs.Events.FRAG_LOADED, () => {
+        this.errorCounts[Hlsjs.ErrorTypes.NETWORK_ERROR] = 0
+      })
+
+      return
+    }
+
+    console.info('bubbling network error up to VIDEOJS')
+    this.hls.destroy()
+    this.tech.error = () => error
+    this.tech.trigger('error')
+  }
+
+  private _onError (_event: any, data: ErrorData) {
+    const error: { message: string, code?: number } = {
+      message: `HLS.js error: ${data.type} - fatal: ${data.fatal} - ${data.details}`
+    }
+
+    // increment/set error count
+    if (this.errorCounts[data.type]) this.errorCounts[data.type] += 1
+    else this.errorCounts[data.type] = 1
+
+    if (data.fatal) console.warn(error.message)
+    else console.error(error.message, data)
+
+    if (data.type === Hlsjs.ErrorTypes.NETWORK_ERROR) {
+      error.code = 2
+      this._handleNetworkError(error)
+    } else if (data.fatal && data.type === Hlsjs.ErrorTypes.MEDIA_ERROR && data.details !== 'manifestIncompatibleCodecsError') {
+      error.code = 3
+      this._handleMediaError(error)
+    } else if (data.fatal) {
+      this.hls.destroy()
+      console.info('bubbling error up to VIDEOJS')
+      this.tech.error = () => error as any
+      this.tech.trigger('error')
+    }
+  }
+
+  private buildLevelLabel (level: Level) {
+    if (this.player.srOptions_.levelLabelHandler) {
+      return this.player.srOptions_.levelLabelHandler(level as any)
+    }
+
+    if (level.height) return level.height + 'p'
+    if (level.width) return Math.round(level.width * 9 / 16) + 'p'
+    if (level.bitrate) return (level.bitrate / 1000) + 'kbps'
+
+    return '0'
+  }
+
+  private _notifyVideoQualities () {
+    if (!this.metadata) return
+
+    const resolutions: PeerTubeResolution[] = []
+
+    this.metadata.levels.forEach((level, index) => {
+      resolutions.push({
+        id: index,
+        height: level.height,
+        width: level.width,
+        bitrate: level.bitrate,
+        label: this.buildLevelLabel(level),
+        selected: level.id === this.hls.manualLevel,
+
+        selectCallback: () => {
+          this.hls.currentLevel = index
+        }
+      })
+    })
+
+    resolutions.push({
+      id: -1,
+      label: this.player.localize('Auto'),
+      selected: true,
+      selectCallback: () => this.hls.currentLevel = -1
+    })
+
+    this.player.peertubeResolutions().add(resolutions)
+  }
+
+  private _startLoad () {
+    this.hls.startLoad(-1)
+    this.videoElement.removeEventListener('play', this.handlers.play)
+  }
+
+  private _oneLevelObjClone (obj: { [ id: string ]: any }) {
+    const result = {}
+    const objKeys = Object.keys(obj)
+    for (let i = 0; i < objKeys.length; i++) {
+      result[objKeys[i]] = obj[objKeys[i]]
+    }
+
+    return result
+  }
+
+  private _onMetaData (_event: any, data: ManifestParsedData) {
+    // This could arrive before 'loadedqualitydata' handlers is registered, remember it so we can raise it later
+    this.metadata = data
+    this._notifyVideoQualities()
+  }
+
+  private _initHlsjs () {
+    const techOptions = this.tech.options_ as HlsjsConfigHandlerOptions
+    const srOptions_ = this.player.srOptions_
+
+    const hlsjsConfigRef = srOptions_?.hlsjsConfig || techOptions.hlsjsConfig
+    // Hls.js will write to the reference thus change the object for later streams
+    this.hlsjsConfig = hlsjsConfigRef ? this._oneLevelObjClone(hlsjsConfigRef) : {}
+
+    if ([ '', 'auto' ].includes(this.videoElement.preload) && !this.videoElement.autoplay && this.hlsjsConfig.autoStartLoad === undefined) {
+      this.hlsjsConfig.autoStartLoad = false
+    }
+
+    // If the user explicitly sets autoStartLoad to false, we're not going to enter the if block above
+    // That's why we have a separate if block here to set the 'play' listener
+    if (this.hlsjsConfig.autoStartLoad === false) {
+      this.handlers.play = this._startLoad.bind(this)
+      this.videoElement.addEventListener('play', this.handlers.play)
+    }
+
+    this.hls = new Hlsjs(this.hlsjsConfig)
+
+    this._executeHooksFor('beforeinitialize')
+
+    this.hls.on(Hlsjs.Events.ERROR, (event, data) => this._onError(event, data))
+    this.hls.on(Hlsjs.Events.MANIFEST_PARSED, (event, data) => this._onMetaData(event, data))
+    this.hls.on(Hlsjs.Events.LEVEL_LOADED, (event, data) => {
+      // The DVR plugin will auto seek to "live edge" on start up
+      if (this.hlsjsConfig.liveSyncDuration) {
+        this.edgeMargin = this.hlsjsConfig.liveSyncDuration
+      } else if (this.hlsjsConfig.liveSyncDurationCount) {
+        this.edgeMargin = this.hlsjsConfig.liveSyncDurationCount * data.details.targetduration
+      }
+
+      this.isLive = data.details.live
+      this.dvrDuration = data.details.totalduration
+
+      this._duration = this.isLive ? Infinity : data.details.totalduration
+
+      // Increase network error recovery for lives since they can be broken (server restart, stream interruption etc)
+      if (this.isLive) this.maxNetworkErrorRecovery = 300
+    })
+
+    this.hls.once(Hlsjs.Events.FRAG_LOADED, () => {
+      // Emit custom 'loadedmetadata' event for parity with `videojs-contrib-hls`
+      // Ref: https://github.com/videojs/videojs-contrib-hls#loadedmetadata
+      this.tech.trigger('loadedmetadata')
+    })
+
+    this.hls.on(Hlsjs.Events.LEVEL_SWITCHING, (_e, data: LevelSwitchingData) => {
+      const resolutionId = this.hls.autoLevelEnabled
+        ? -1
+        : data.level
+
+      const autoResolutionChosenId = this.hls.autoLevelEnabled
+        ? data.level
+        : -1
+
+      this.player.peertubeResolutions().select({ id: resolutionId, autoResolutionChosenId, byEngine: true })
+    })
+
+    this.hls.attachMedia(this.videoElement)
+
+    this.hls.loadSource(this.source.src)
+  }
+
+  private initialize () {
+    this._initHlsjs()
+  }
+}
+
+export {
+  Html5Hlsjs,
+  registerSourceHandler,
+  registerConfigPlugin
+}
diff --git a/client/src/assets/player/shared/p2p-media-loader/index.ts b/client/src/assets/player/shared/p2p-media-loader/index.ts
new file mode 100644
index 000000000..02fe71e73
--- /dev/null
+++ b/client/src/assets/player/shared/p2p-media-loader/index.ts
@@ -0,0 +1,5 @@
+export * from './hls-plugin'
+export * from './p2p-media-loader-plugin'
+export * from './redundancy-url-manager'
+export * from './segment-url-builder'
+export * from './segment-validator'
diff --git a/client/src/assets/player/shared/p2p-media-loader/p2p-media-loader-plugin.ts b/client/src/assets/player/shared/p2p-media-loader/p2p-media-loader-plugin.ts
new file mode 100644
index 000000000..5c0f0021f
--- /dev/null
+++ b/client/src/assets/player/shared/p2p-media-loader/p2p-media-loader-plugin.ts
@@ -0,0 +1,183 @@
+import Hlsjs from 'hls.js'
+import videojs from 'video.js'
+import { Events, Segment } from '@peertube/p2p-media-loader-core'
+import { Engine, initHlsJsPlayer, initVideoJsContribHlsJsPlayer } from '@peertube/p2p-media-loader-hlsjs'
+import { timeToInt } from '@shared/core-utils'
+import { P2PMediaLoaderPluginOptions, PlayerNetworkInfo } from '../../types'
+import { registerConfigPlugin, registerSourceHandler } from './hls-plugin'
+
+registerConfigPlugin(videojs)
+registerSourceHandler(videojs)
+
+const Plugin = videojs.getPlugin('plugin')
+class P2pMediaLoaderPlugin extends Plugin {
+
+  private readonly CONSTANTS = {
+    INFO_SCHEDULER: 1000 // Don't change this
+  }
+  private readonly options: P2PMediaLoaderPluginOptions
+
+  private hlsjs: Hlsjs
+  private p2pEngine: Engine
+  private statsP2PBytes = {
+    pendingDownload: [] as number[],
+    pendingUpload: [] as number[],
+    numPeers: 0,
+    totalDownload: 0,
+    totalUpload: 0
+  }
+  private statsHTTPBytes = {
+    pendingDownload: [] as number[],
+    pendingUpload: [] as number[],
+    totalDownload: 0,
+    totalUpload: 0
+  }
+  private startTime: number
+
+  private networkInfoInterval: any
+
+  constructor (player: videojs.Player, options?: P2PMediaLoaderPluginOptions) {
+    super(player)
+
+    this.options = options
+
+    // FIXME: typings https://github.com/Microsoft/TypeScript/issues/14080
+    if (!(videojs as any).Html5Hlsjs) {
+      console.warn('HLS.js does not seem to be supported. Try to fallback to built in HLS.')
+
+      if (!player.canPlayType('application/vnd.apple.mpegurl')) {
+        const message = 'Cannot fallback to built-in HLS'
+        console.warn(message)
+
+        player.ready(() => player.trigger('error', new Error(message)))
+        return
+      }
+    } else {
+      // FIXME: typings https://github.com/Microsoft/TypeScript/issues/14080
+      (videojs as any).Html5Hlsjs.addHook('beforeinitialize', (videojsPlayer: any, hlsjs: any) => {
+        this.hlsjs = hlsjs
+      })
+
+      initVideoJsContribHlsJsPlayer(player)
+    }
+
+    this.startTime = timeToInt(options.startTime)
+
+    player.src({
+      type: options.type,
+      src: options.src
+    })
+
+    player.ready(() => {
+      this.initializeCore()
+
+      if ((videojs as any).Html5Hlsjs) {
+        this.initializePlugin()
+      }
+    })
+  }
+
+  dispose () {
+    if (this.hlsjs) this.hlsjs.destroy()
+    if (this.p2pEngine) this.p2pEngine.destroy()
+
+    clearInterval(this.networkInfoInterval)
+  }
+
+  getCurrentLevel () {
+    return this.hlsjs.levels[this.hlsjs.currentLevel]
+  }
+
+  getLiveLatency () {
+    return Math.round(this.hlsjs.latency)
+  }
+
+  getHLSJS () {
+    return this.hlsjs
+  }
+
+  private initializeCore () {
+    this.player.one('play', () => {
+      this.player.addClass('vjs-has-big-play-button-clicked')
+    })
+
+    this.player.one('canplay', () => {
+      if (this.startTime) {
+        this.player.currentTime(this.startTime)
+      }
+    })
+  }
+
+  private initializePlugin () {
+    initHlsJsPlayer(this.hlsjs)
+
+    this.p2pEngine = this.options.loader.getEngine()
+
+    this.p2pEngine.on(Events.SegmentError, (segment: Segment, err) => {
+      console.error('Segment error.', segment, err)
+
+      this.options.redundancyUrlManager.removeBySegmentUrl(segment.requestUrl)
+    })
+
+    this.statsP2PBytes.numPeers = 1 + this.options.redundancyUrlManager.countBaseUrls()
+
+    this.runStats()
+  }
+
+  private runStats () {
+    this.p2pEngine.on(Events.PieceBytesDownloaded, (method: string, _segment, bytes: number) => {
+      const elem = method === 'p2p' ? this.statsP2PBytes : this.statsHTTPBytes
+
+      elem.pendingDownload.push(bytes)
+      elem.totalDownload += bytes
+    })
+
+    this.p2pEngine.on(Events.PieceBytesUploaded, (method: string, _segment, bytes: number) => {
+      const elem = method === 'p2p' ? this.statsP2PBytes : this.statsHTTPBytes
+
+      elem.pendingUpload.push(bytes)
+      elem.totalUpload += bytes
+    })
+
+    this.p2pEngine.on(Events.PeerConnect, () => this.statsP2PBytes.numPeers++)
+    this.p2pEngine.on(Events.PeerClose, () => this.statsP2PBytes.numPeers--)
+
+    this.networkInfoInterval = setInterval(() => {
+      const p2pDownloadSpeed = this.arraySum(this.statsP2PBytes.pendingDownload)
+      const p2pUploadSpeed = this.arraySum(this.statsP2PBytes.pendingUpload)
+
+      const httpDownloadSpeed = this.arraySum(this.statsHTTPBytes.pendingDownload)
+      const httpUploadSpeed = this.arraySum(this.statsHTTPBytes.pendingUpload)
+
+      this.statsP2PBytes.pendingDownload = []
+      this.statsP2PBytes.pendingUpload = []
+      this.statsHTTPBytes.pendingDownload = []
+      this.statsHTTPBytes.pendingUpload = []
+
+      return this.player.trigger('p2pInfo', {
+        source: 'p2p-media-loader',
+        http: {
+          downloadSpeed: httpDownloadSpeed,
+          uploadSpeed: httpUploadSpeed,
+          downloaded: this.statsHTTPBytes.totalDownload,
+          uploaded: this.statsHTTPBytes.totalUpload
+        },
+        p2p: {
+          downloadSpeed: p2pDownloadSpeed,
+          uploadSpeed: p2pUploadSpeed,
+          numPeers: this.statsP2PBytes.numPeers,
+          downloaded: this.statsP2PBytes.totalDownload,
+          uploaded: this.statsP2PBytes.totalUpload
+        },
+        bandwidthEstimate: (this.hlsjs as any).bandwidthEstimate / 8
+      } as PlayerNetworkInfo)
+    }, this.CONSTANTS.INFO_SCHEDULER)
+  }
+
+  private arraySum (data: number[]) {
+    return data.reduce((a: number, b: number) => a + b, 0)
+  }
+}
+
+videojs.registerPlugin('p2pMediaLoader', P2pMediaLoaderPlugin)
+export { P2pMediaLoaderPlugin }
diff --git a/client/src/assets/player/shared/p2p-media-loader/redundancy-url-manager.ts b/client/src/assets/player/shared/p2p-media-loader/redundancy-url-manager.ts
new file mode 100644
index 000000000..abab8aa99
--- /dev/null
+++ b/client/src/assets/player/shared/p2p-media-loader/redundancy-url-manager.ts
@@ -0,0 +1,42 @@
+import { basename, dirname } from 'path'
+
+class RedundancyUrlManager {
+
+  constructor (private baseUrls: string[] = []) {
+    // empty
+  }
+
+  removeBySegmentUrl (segmentUrl: string) {
+    console.log('Removing redundancy of segment URL %s.', segmentUrl)
+
+    const baseUrl = dirname(segmentUrl)
+
+    this.baseUrls = this.baseUrls.filter(u => u !== baseUrl && u !== baseUrl + '/')
+  }
+
+  buildUrl (url: string) {
+    const max = this.baseUrls.length + 1
+    const i = this.getRandomInt(max)
+
+    if (i === max - 1) return url
+
+    const newBaseUrl = this.baseUrls[i]
+    const slashPart = newBaseUrl.endsWith('/') ? '' : '/'
+
+    return newBaseUrl + slashPart + basename(url)
+  }
+
+  countBaseUrls () {
+    return this.baseUrls.length
+  }
+
+  private getRandomInt (max: number) {
+    return Math.floor(Math.random() * Math.floor(max))
+  }
+}
+
+// ---------------------------------------------------------------------------
+
+export {
+  RedundancyUrlManager
+}
diff --git a/client/src/assets/player/shared/p2p-media-loader/segment-url-builder.ts b/client/src/assets/player/shared/p2p-media-loader/segment-url-builder.ts
new file mode 100644
index 000000000..9d324078a
--- /dev/null
+++ b/client/src/assets/player/shared/p2p-media-loader/segment-url-builder.ts
@@ -0,0 +1,17 @@
+import { Segment } from '@peertube/p2p-media-loader-core'
+import { RedundancyUrlManager } from './redundancy-url-manager'
+
+function segmentUrlBuilderFactory (redundancyUrlManager: RedundancyUrlManager, useOriginPriority: number) {
+  return function segmentBuilder (segment: Segment) {
+    // Don't use redundancy for high priority segments
+    if (segment.priority <= useOriginPriority) return segment.url
+
+    return redundancyUrlManager.buildUrl(segment.url)
+  }
+}
+
+// ---------------------------------------------------------------------------
+
+export {
+  segmentUrlBuilderFactory
+}
diff --git a/client/src/assets/player/shared/p2p-media-loader/segment-validator.ts b/client/src/assets/player/shared/p2p-media-loader/segment-validator.ts
new file mode 100644
index 000000000..f7f83a8a4
--- /dev/null
+++ b/client/src/assets/player/shared/p2p-media-loader/segment-validator.ts
@@ -0,0 +1,106 @@
+import { wait } from '@root-helpers/utils'
+import { Segment } from '@peertube/p2p-media-loader-core'
+import { basename } from 'path'
+
+type SegmentsJSON = { [filename: string]: string | { [byterange: string]: string } }
+
+const maxRetries = 3
+
+function segmentValidatorFactory (segmentsSha256Url: string, isLive: boolean) {
+  let segmentsJSON = fetchSha256Segments(segmentsSha256Url)
+  const regex = /bytes=(\d+)-(\d+)/
+
+  return async function segmentValidator (segment: Segment, _method: string, _peerId: string, retry = 1) {
+    // Wait for hash generation from the server
+    if (isLive) await wait(1000)
+
+    const filename = basename(segment.url)
+
+    const segmentValue = (await segmentsJSON)[filename]
+
+    if (!segmentValue && retry > maxRetries) {
+      throw new Error(`Unknown segment name ${filename} in segment validator`)
+    }
+
+    if (!segmentValue) {
+      console.log('Refetching sha segments for %s.', filename)
+
+      await wait(1000)
+
+      segmentsJSON = fetchSha256Segments(segmentsSha256Url)
+      await segmentValidator(segment, _method, _peerId, retry + 1)
+
+      return
+    }
+
+    let hashShouldBe: string
+    let range = ''
+
+    if (typeof segmentValue === 'string') {
+      hashShouldBe = segmentValue
+    } else {
+      const captured = regex.exec(segment.range)
+      range = captured[1] + '-' + captured[2]
+
+      hashShouldBe = segmentValue[range]
+    }
+
+    if (hashShouldBe === undefined) {
+      throw new Error(`Unknown segment name ${filename}/${range} in segment validator`)
+    }
+
+    const calculatedSha = await sha256Hex(segment.data)
+    if (calculatedSha !== hashShouldBe) {
+      throw new Error(
+        `Hashes does not correspond for segment ${filename}/${range}` +
+        `(expected: ${hashShouldBe} instead of ${calculatedSha})`
+      )
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+
+export {
+  segmentValidatorFactory
+}
+
+// ---------------------------------------------------------------------------
+
+function fetchSha256Segments (url: string) {
+  return fetch(url)
+    .then(res => res.json() as Promise<SegmentsJSON>)
+    .catch(err => {
+      console.error('Cannot get sha256 segments', err)
+      return {}
+    })
+}
+
+async function sha256Hex (data?: ArrayBuffer) {
+  if (!data) return undefined
+
+  if (window.crypto.subtle) {
+    return window.crypto.subtle.digest('SHA-256', data)
+      .then(data => bufferToHex(data))
+  }
+
+  // Fallback for non HTTPS context
+  const shaModule = (await import('sha.js') as any).default
+  // eslint-disable-next-line new-cap
+  return new shaModule.sha256().update(Buffer.from(data)).digest('hex')
+}
+
+// Thanks: https://stackoverflow.com/a/53307879
+function bufferToHex (buffer?: ArrayBuffer) {
+  if (!buffer) return ''
+
+  let s = ''
+  const h = '0123456789abcdef'
+  const o = new Uint8Array(buffer)
+
+  o.forEach((v: any) => {
+    s += h[v >> 4] + h[v & 15]
+  })
+
+  return s
+}