5 files changed, 0 insertions, 767 deletions

diff --git a/client/src/assets/player/p2p-media-loader/hls-plugin.ts b/client/src/assets/player/p2p-media-loader/hls-plugin.ts
deleted file mode 100644
index ccee2d90f..000000000
--- a/client/src/assets/player/p2p-media-loader/hls-plugin.ts
+++ /dev/null
@@ -1,419 +0,0 @@
-// 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 '../peertube-videojs-typings'
-
-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/p2p-media-loader/p2p-media-loader-plugin.ts b/client/src/assets/player/p2p-media-loader/p2p-media-loader-plugin.ts
deleted file mode 100644
index 1d7a39b4e..000000000
--- a/client/src/assets/player/p2p-media-loader/p2p-media-loader-plugin.ts
+++ /dev/null
@@ -1,183 +0,0 @@
-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 '../peertube-videojs-typings'
-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/p2p-media-loader/redundancy-url-manager.ts b/client/src/assets/player/p2p-media-loader/redundancy-url-manager.ts
deleted file mode 100644
index abab8aa99..000000000
--- a/client/src/assets/player/p2p-media-loader/redundancy-url-manager.ts
+++ /dev/null
@@ -1,42 +0,0 @@
-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/p2p-media-loader/segment-url-builder.ts b/client/src/assets/player/p2p-media-loader/segment-url-builder.ts
deleted file mode 100644
index 9d324078a..000000000
--- a/client/src/assets/player/p2p-media-loader/segment-url-builder.ts
+++ /dev/null
@@ -1,17 +0,0 @@
-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/p2p-media-loader/segment-validator.ts b/client/src/assets/player/p2p-media-loader/segment-validator.ts
deleted file mode 100644
index f7f83a8a4..000000000
--- a/client/src/assets/player/p2p-media-loader/segment-validator.ts
+++ /dev/null
@@ -1,106 +0,0 @@
-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
-}