33 files changed, 630 insertions, 393 deletions

diff --git a/server/helpers/activitypub.ts b/server/helpers/activitypub.ts
index 239d8291d..aeb8fde01 100644
--- a/server/helpers/activitypub.ts
+++ b/server/helpers/activitypub.ts
@@ -2,21 +2,35 @@ import * as Bluebird from 'bluebird'
 import validator from 'validator'
 import { ResultList } from '../../shared/models'
 import { Activity } from '../../shared/models/activitypub'
-import { ACTIVITY_PUB } from '../initializers/constants'
+import { ACTIVITY_PUB, REMOTE_SCHEME } from '../initializers/constants'
 import { signJsonLDObject } from './peertube-crypto'
 import { pageToStartAndCount } from './core-utils'
-import { parse } from 'url'
-import { MActor } from '../typings/models'
-
-function activityPubContextify <T> (data: T) {
-  return Object.assign(data, {
-    '@context': [
-      'https://www.w3.org/ns/activitystreams',
-      'https://w3id.org/security/v1',
-      {
-        RsaSignature2017: 'https://w3id.org/security#RsaSignature2017',
-        pt: 'https://joinpeertube.org/ns#',
-        sc: 'http://schema.org#',
+import { URL } from 'url'
+import { MActor, MVideoAccountLight } from '../typings/models'
+import { ContextType } from '@shared/models/activitypub/context'
+
+function getContextData (type: ContextType) {
+  const context: any[] = [
+    'https://www.w3.org/ns/activitystreams',
+    'https://w3id.org/security/v1',
+    {
+      RsaSignature2017: 'https://w3id.org/security#RsaSignature2017'
+    }
+  ]
+
+  if (type !== 'View' && type !== 'Announce') {
+    const additional = {
+      pt: 'https://joinpeertube.org/ns#',
+      sc: 'http://schema.org#'
+    }
+
+    if (type === 'CacheFile') {
+      Object.assign(additional, {
+        expires: 'sc:expires',
+        CacheFile: 'pt:CacheFile'
+      })
+    } else {
+      Object.assign(additional, {
         Hashtag: 'as:Hashtag',
         uuid: 'sc:identifier',
         category: 'sc:category',
@@ -24,8 +38,7 @@ function activityPubContextify <T> (data: T) {
         subtitleLanguage: 'sc:subtitleLanguage',
         sensitive: 'as:sensitive',
         language: 'sc:inLanguage',
-        expires: 'sc:expires',
-        CacheFile: 'pt:CacheFile',
+
         Infohash: 'pt:Infohash',
         originallyPublishedAt: 'sc:datePublished',
         views: {
@@ -71,9 +84,7 @@ function activityPubContextify <T> (data: T) {
         support: {
           '@type': 'sc:Text',
           '@id': 'pt:support'
-        }
-      },
-      {
+        },
         likes: {
           '@id': 'as:likes',
           '@type': '@id'
@@ -94,9 +105,19 @@ function activityPubContextify <T> (data: T) {
           '@id': 'as:comments',
           '@type': '@id'
         }
-      }
-    ]
-  })
+      })
+    }
+
+    context.push(additional)
+  }
+
+  return {
+    '@context': context
+  }
+}
+
+function activityPubContextify <T> (data: T, type: ContextType = 'All') {
+  return Object.assign({}, data, getContextData(type))
 }
 
 type ActivityPubCollectionPaginationHandler = (start: number, count: number) => Bluebird<ResultList<any>> | Promise<ResultList<any>>
@@ -148,8 +169,8 @@ async function activityPubCollectionPagination (
 
 }
 
-function buildSignedActivity (byActor: MActor, data: Object) {
-  const activity = activityPubContextify(data)
+function buildSignedActivity (byActor: MActor, data: Object, contextType?: ContextType) {
+  const activity = activityPubContextify(data, contextType)
 
   return signJsonLDObject(byActor, activity) as Promise<Activity>
 }
@@ -161,12 +182,18 @@ function getAPId (activity: string | { id: string }) {
 }
 
 function checkUrlsSameHost (url1: string, url2: string) {
-  const idHost = parse(url1).host
-  const actorHost = parse(url2).host
+  const idHost = new URL(url1).host
+  const actorHost = new URL(url2).host
 
   return idHost && actorHost && idHost.toLowerCase() === actorHost.toLowerCase()
 }
 
+function buildRemoteVideoBaseUrl (video: MVideoAccountLight, path: string) {
+  const host = video.VideoChannel.Account.Actor.Server.host
+
+  return REMOTE_SCHEME.HTTP + '://' + host + path
+}
+
 // ---------------------------------------------------------------------------
 
 export {
@@ -174,5 +201,6 @@ export {
   getAPId,
   activityPubContextify,
   activityPubCollectionPagination,
-  buildSignedActivity
+  buildSignedActivity,
+  buildRemoteVideoBaseUrl
 }
diff --git a/server/helpers/audit-logger.ts b/server/helpers/audit-logger.ts
index 9b258dc3a..0bbfbc753 100644
--- a/server/helpers/audit-logger.ts
+++ b/server/helpers/audit-logger.ts
@@ -36,7 +36,7 @@ const auditLogger = winston.createLogger({
       maxFiles: 5,
       format: winston.format.combine(
         winston.format.timestamp(),
-        labelFormatter,
+        labelFormatter(),
         winston.format.splat(),
         jsonLoggerFormat
       )
@@ -81,7 +81,8 @@ function auditLoggerFactory (domain: string) {
 }
 
 abstract class EntityAuditView {
-  constructor (private keysToKeep: Array<string>, private prefix: string, private entityInfos: object) { }
+  constructor (private readonly keysToKeep: string[], private readonly prefix: string, private readonly entityInfos: object) { }
+
   toLogKeys (): object {
     return chain(flatten(this.entityInfos, { delimiter: '-', safe: true }))
       .pick(this.keysToKeep)
@@ -121,7 +122,7 @@ const videoKeysToKeep = [
   'downloadEnabled'
 ]
 class VideoAuditView extends EntityAuditView {
-  constructor (private video: VideoDetails) {
+  constructor (private readonly video: VideoDetails) {
     super(videoKeysToKeep, 'video', video)
   }
 }
@@ -132,7 +133,7 @@ const videoImportKeysToKeep = [
   'video-name'
 ]
 class VideoImportAuditView extends EntityAuditView {
-  constructor (private videoImport: VideoImport) {
+  constructor (private readonly videoImport: VideoImport) {
     super(videoImportKeysToKeep, 'video-import', videoImport)
   }
 }
@@ -151,7 +152,7 @@ const commentKeysToKeep = [
   'account-name'
 ]
 class CommentAuditView extends EntityAuditView {
-  constructor (private comment: VideoComment) {
+  constructor (private readonly comment: VideoComment) {
     super(commentKeysToKeep, 'comment', comment)
   }
 }
@@ -180,7 +181,7 @@ const userKeysToKeep = [
   'videoChannels'
 ]
 class UserAuditView extends EntityAuditView {
-  constructor (private user: User) {
+  constructor (private readonly user: User) {
     super(userKeysToKeep, 'user', user)
   }
 }
@@ -206,7 +207,7 @@ const channelKeysToKeep = [
   'ownerAccount-displayedName'
 ]
 class VideoChannelAuditView extends EntityAuditView {
-  constructor (private channel: VideoChannel) {
+  constructor (private readonly channel: VideoChannel) {
     super(channelKeysToKeep, 'channel', channel)
   }
 }
@@ -221,7 +222,7 @@ const videoAbuseKeysToKeep = [
   'createdAt'
 ]
 class VideoAbuseAuditView extends EntityAuditView {
-  constructor (private videoAbuse: VideoAbuse) {
+  constructor (private readonly videoAbuse: VideoAbuse) {
     super(videoAbuseKeysToKeep, 'abuse', videoAbuse)
   }
 }
@@ -253,9 +254,12 @@ class CustomConfigAuditView extends EntityAuditView {
     const infos: any = customConfig
     const resolutionsDict = infos.transcoding.resolutions
     const resolutionsArray = []
-    Object.entries(resolutionsDict).forEach(([resolution, isEnabled]) => {
-      if (isEnabled) resolutionsArray.push(resolution)
-    })
+
+    Object.entries(resolutionsDict)
+          .forEach(([ resolution, isEnabled ]) => {
+            if (isEnabled) resolutionsArray.push(resolution)
+          })
+
     Object.assign({}, infos, { transcoding: { resolutions: resolutionsArray } })
     super(customConfigKeysToKeep, 'config', infos)
   }
diff --git a/server/helpers/core-utils.ts b/server/helpers/core-utils.ts
index 7e8252aa4..b1f5d9610 100644
--- a/server/helpers/core-utils.ts
+++ b/server/helpers/core-utils.ts
@@ -1,9 +1,11 @@
+/* eslint-disable no-useless-call */
+
 /*
-  Different from 'utils' because we don't not import other PeerTube modules.
+  Different from 'utils' because we don't import other PeerTube modules.
   Useful to avoid circular dependencies.
 */
 
-import { createHash, HexBase64Latin1Encoding, pseudoRandomBytes } from 'crypto'
+import { createHash, HexBase64Latin1Encoding, randomBytes } from 'crypto'
 import { basename, isAbsolute, join, resolve } from 'path'
 import * as pem from 'pem'
 import { URL } from 'url'
@@ -22,31 +24,31 @@ const objectConverter = (oldObject: any, keyConverter: (e: string) => string, va
   const newObject = {}
   Object.keys(oldObject).forEach(oldKey => {
     const newKey = keyConverter(oldKey)
-    newObject[ newKey ] = objectConverter(oldObject[ oldKey ], keyConverter, valueConverter)
+    newObject[newKey] = objectConverter(oldObject[oldKey], keyConverter, valueConverter)
   })
 
   return newObject
 }
 
 const timeTable = {
-  ms:           1,
-  second:       1000,
-  minute:       60000,
-  hour:         3600000,
-  day:          3600000 * 24,
-  week:         3600000 * 24 * 7,
-  month:        3600000 * 24 * 30
+  ms: 1,
+  second: 1000,
+  minute: 60000,
+  hour: 3600000,
+  day: 3600000 * 24,
+  week: 3600000 * 24 * 7,
+  month: 3600000 * 24 * 30
 }
 
 export function parseDurationToMs (duration: number | string): number {
   if (typeof duration === 'number') return duration
 
   if (typeof duration === 'string') {
-    const split = duration.match(/^([\d\.,]+)\s?(\w+)$/)
+    const split = duration.match(/^([\d.,]+)\s?(\w+)$/)
 
     if (split.length === 3) {
       const len = parseFloat(split[1])
-      let unit = split[2].replace(/s$/i,'').toLowerCase()
+      let unit = split[2].replace(/s$/i, '').toLowerCase()
       if (unit === 'm') {
         unit = 'ms'
       }
@@ -73,21 +75,21 @@ export function parseBytes (value: string | number): number {
 
   if (value.match(tgm)) {
     match = value.match(tgm)
-    return parseInt(match[1], 10) * 1024 * 1024 * 1024 * 1024
-    + parseInt(match[2], 10) * 1024 * 1024 * 1024
-    + parseInt(match[3], 10) * 1024 * 1024
+    return parseInt(match[1], 10) * 1024 * 1024 * 1024 * 1024 +
+      parseInt(match[2], 10) * 1024 * 1024 * 1024 +
+      parseInt(match[3], 10) * 1024 * 1024
   } else if (value.match(tg)) {
     match = value.match(tg)
-    return parseInt(match[1], 10) * 1024 * 1024 * 1024 * 1024
-    + parseInt(match[2], 10) * 1024 * 1024 * 1024
+    return parseInt(match[1], 10) * 1024 * 1024 * 1024 * 1024 +
+      parseInt(match[2], 10) * 1024 * 1024 * 1024
   } else if (value.match(tm)) {
     match = value.match(tm)
-    return parseInt(match[1], 10) * 1024 * 1024 * 1024 * 1024
-    + parseInt(match[2], 10) * 1024 * 1024
+    return parseInt(match[1], 10) * 1024 * 1024 * 1024 * 1024 +
+      parseInt(match[2], 10) * 1024 * 1024
   } else if (value.match(gm)) {
     match = value.match(gm)
-    return parseInt(match[1], 10) * 1024 * 1024 * 1024
-    + parseInt(match[2], 10) * 1024 * 1024
+    return parseInt(match[1], 10) * 1024 * 1024 * 1024 +
+      parseInt(match[2], 10) * 1024 * 1024
   } else if (value.match(t)) {
     match = value.match(t)
     return parseInt(match[1], 10) * 1024 * 1024 * 1024 * 1024
@@ -137,6 +139,7 @@ function getAppNumber () {
 }
 
 let rootPath: string
+
 function root () {
   if (rootPath) return rootPath
 
@@ -163,7 +166,7 @@ function escapeHTML (stringParam) {
     '=': '&#x3D;'
   }
 
-  return String(stringParam).replace(/[&<>"'`=\/]/g, s => entityMap[s])
+  return String(stringParam).replace(/[&<>"'`=/]/g, s => entityMap[s])
 }
 
 function pageToStartAndCount (page: number, itemsPerPage: number) {
@@ -202,6 +205,7 @@ function sha1 (str: string | Buffer, encoding: HexBase64Latin1Encoding = 'hex')
 function execShell (command: string, options?: ExecOptions) {
   return new Promise<{ err?: Error, stdout: string, stderr: string }>((res, rej) => {
     exec(command, options, (err, stdout, stderr) => {
+      // eslint-disable-next-line prefer-promise-reject-errors
       if (err) return rej({ err, stdout, stderr })
 
       return res({ stdout, stderr })
@@ -226,14 +230,6 @@ function promisify1<T, A> (func: (arg: T, cb: (err: any, result: A) => void) =>
   }
 }
 
-function promisify1WithVoid<T> (func: (arg: T, cb: (err: any) => void) => void): (arg: T) => Promise<void> {
-  return function promisified (arg: T): Promise<void> {
-    return new Promise<void>((resolve: () => void, reject: (err: any) => void) => {
-      func.apply(null, [ arg, (err: any) => err ? reject(err) : resolve() ])
-    })
-  }
-}
-
 function promisify2<T, U, A> (func: (arg1: T, arg2: U, cb: (err: any, result: A) => void) => void): (arg1: T, arg2: U) => Promise<A> {
   return function promisified (arg1: T, arg2: U): Promise<A> {
     return new Promise<A>((resolve: (arg: A) => void, reject: (err: any) => void) => {
@@ -242,15 +238,7 @@ function promisify2<T, U, A> (func: (arg1: T, arg2: U, cb: (err: any, result: A)
   }
 }
 
-function promisify2WithVoid<T, U> (func: (arg1: T, arg2: U, cb: (err: any) => void) => void): (arg1: T, arg2: U) => Promise<void> {
-  return function promisified (arg1: T, arg2: U): Promise<void> {
-    return new Promise<void>((resolve: () => void, reject: (err: any) => void) => {
-      func.apply(null, [ arg1, arg2, (err: any) => err ? reject(err) : resolve() ])
-    })
-  }
-}
-
-const pseudoRandomBytesPromise = promisify1<number, Buffer>(pseudoRandomBytes)
+const randomBytesPromise = promisify1<number, Buffer>(randomBytes)
 const createPrivateKey = promisify1<number, { key: string }>(pem.createPrivateKey)
 const getPublicKey = promisify1<string, { publicKey: string }>(pem.getPublicKey)
 const execPromise2 = promisify2<string, any, string>(exec)
@@ -280,7 +268,7 @@ export {
   promisify1,
   promisify2,
 
-  pseudoRandomBytesPromise,
+  randomBytesPromise,
   createPrivateKey,
   getPublicKey,
   execPromise2,
diff --git a/server/helpers/custom-jsonld-signature.ts b/server/helpers/custom-jsonld-signature.ts
index a407a9fec..749c50cb3 100644
--- a/server/helpers/custom-jsonld-signature.ts
+++ b/server/helpers/custom-jsonld-signature.ts
@@ -5,52 +5,52 @@ import { logger } from './logger'
 const CACHE = {
   'https://w3id.org/security/v1': {
     '@context': {
-      'id': '@id',
-      'type': '@type',
+      id: '@id',
+      type: '@type',
 
-      'dc': 'http://purl.org/dc/terms/',
-      'sec': 'https://w3id.org/security#',
-      'xsd': 'http://www.w3.org/2001/XMLSchema#',
+      dc: 'http://purl.org/dc/terms/',
+      sec: 'https://w3id.org/security#',
+      xsd: 'http://www.w3.org/2001/XMLSchema#',
 
-      'EcdsaKoblitzSignature2016': 'sec:EcdsaKoblitzSignature2016',
-      'Ed25519Signature2018': 'sec:Ed25519Signature2018',
-      'EncryptedMessage': 'sec:EncryptedMessage',
-      'GraphSignature2012': 'sec:GraphSignature2012',
-      'LinkedDataSignature2015': 'sec:LinkedDataSignature2015',
-      'LinkedDataSignature2016': 'sec:LinkedDataSignature2016',
-      'CryptographicKey': 'sec:Key',
+      EcdsaKoblitzSignature2016: 'sec:EcdsaKoblitzSignature2016',
+      Ed25519Signature2018: 'sec:Ed25519Signature2018',
+      EncryptedMessage: 'sec:EncryptedMessage',
+      GraphSignature2012: 'sec:GraphSignature2012',
+      LinkedDataSignature2015: 'sec:LinkedDataSignature2015',
+      LinkedDataSignature2016: 'sec:LinkedDataSignature2016',
+      CryptographicKey: 'sec:Key',
 
-      'authenticationTag': 'sec:authenticationTag',
-      'canonicalizationAlgorithm': 'sec:canonicalizationAlgorithm',
-      'cipherAlgorithm': 'sec:cipherAlgorithm',
-      'cipherData': 'sec:cipherData',
-      'cipherKey': 'sec:cipherKey',
-      'created': { '@id': 'dc:created', '@type': 'xsd:dateTime' },
-      'creator': { '@id': 'dc:creator', '@type': '@id' },
-      'digestAlgorithm': 'sec:digestAlgorithm',
-      'digestValue': 'sec:digestValue',
-      'domain': 'sec:domain',
-      'encryptionKey': 'sec:encryptionKey',
-      'expiration': { '@id': 'sec:expiration', '@type': 'xsd:dateTime' },
-      'expires': { '@id': 'sec:expiration', '@type': 'xsd:dateTime' },
-      'initializationVector': 'sec:initializationVector',
-      'iterationCount': 'sec:iterationCount',
-      'nonce': 'sec:nonce',
-      'normalizationAlgorithm': 'sec:normalizationAlgorithm',
-      'owner': { '@id': 'sec:owner', '@type': '@id' },
-      'password': 'sec:password',
-      'privateKey': { '@id': 'sec:privateKey', '@type': '@id' },
-      'privateKeyPem': 'sec:privateKeyPem',
-      'publicKey': { '@id': 'sec:publicKey', '@type': '@id' },
-      'publicKeyBase58': 'sec:publicKeyBase58',
-      'publicKeyPem': 'sec:publicKeyPem',
-      'publicKeyWif': 'sec:publicKeyWif',
-      'publicKeyService': { '@id': 'sec:publicKeyService', '@type': '@id' },
-      'revoked': { '@id': 'sec:revoked', '@type': 'xsd:dateTime' },
-      'salt': 'sec:salt',
-      'signature': 'sec:signature',
-      'signatureAlgorithm': 'sec:signingAlgorithm',
-      'signatureValue': 'sec:signatureValue'
+      authenticationTag: 'sec:authenticationTag',
+      canonicalizationAlgorithm: 'sec:canonicalizationAlgorithm',
+      cipherAlgorithm: 'sec:cipherAlgorithm',
+      cipherData: 'sec:cipherData',
+      cipherKey: 'sec:cipherKey',
+      created: { '@id': 'dc:created', '@type': 'xsd:dateTime' },
+      creator: { '@id': 'dc:creator', '@type': '@id' },
+      digestAlgorithm: 'sec:digestAlgorithm',
+      digestValue: 'sec:digestValue',
+      domain: 'sec:domain',
+      encryptionKey: 'sec:encryptionKey',
+      expiration: { '@id': 'sec:expiration', '@type': 'xsd:dateTime' },
+      expires: { '@id': 'sec:expiration', '@type': 'xsd:dateTime' },
+      initializationVector: 'sec:initializationVector',
+      iterationCount: 'sec:iterationCount',
+      nonce: 'sec:nonce',
+      normalizationAlgorithm: 'sec:normalizationAlgorithm',
+      owner: { '@id': 'sec:owner', '@type': '@id' },
+      password: 'sec:password',
+      privateKey: { '@id': 'sec:privateKey', '@type': '@id' },
+      privateKeyPem: 'sec:privateKeyPem',
+      publicKey: { '@id': 'sec:publicKey', '@type': '@id' },
+      publicKeyBase58: 'sec:publicKeyBase58',
+      publicKeyPem: 'sec:publicKeyPem',
+      publicKeyWif: 'sec:publicKeyWif',
+      publicKeyService: { '@id': 'sec:publicKeyService', '@type': '@id' },
+      revoked: { '@id': 'sec:revoked', '@type': 'xsd:dateTime' },
+      salt: 'sec:salt',
+      signature: 'sec:signature',
+      signatureAlgorithm: 'sec:signingAlgorithm',
+      signatureValue: 'sec:signatureValue'
     }
   }
 }
@@ -60,12 +60,12 @@ const nodeDocumentLoader = jsonld.documentLoaders.node()
 const lru = new AsyncLRU({
   max: 10,
   load: (url, cb) => {
-    if (CACHE[ url ] !== undefined) {
+    if (CACHE[url] !== undefined) {
       logger.debug('Using cache for JSON-LD %s.', url)
 
       return cb(null, {
         contextUrl: null,
-        document: CACHE[ url ],
+        document: CACHE[url],
         documentUrl: url
       })
     }
diff --git a/server/helpers/custom-validators/activitypub/actor.ts b/server/helpers/custom-validators/activitypub/actor.ts
index fa58e163f..2f44522a5 100644
--- a/server/helpers/custom-validators/activitypub/actor.ts
+++ b/server/helpers/custom-validators/activitypub/actor.ts
@@ -6,7 +6,7 @@ import { isHostValid } from '../servers'
 import { peertubeTruncate } from '@server/helpers/core-utils'
 
 function isActorEndpointsObjectValid (endpointObject: any) {
-  if (endpointObject && endpointObject.sharedInbox) {
+  if (endpointObject?.sharedInbox) {
     return isActivityPubUrlValid(endpointObject.sharedInbox)
   }
 
@@ -28,7 +28,7 @@ function isActorPublicKeyValid (publicKey: string) {
   return exists(publicKey) &&
     typeof publicKey === 'string' &&
     publicKey.startsWith('-----BEGIN PUBLIC KEY-----') &&
-    publicKey.indexOf('-----END PUBLIC KEY-----') !== -1 &&
+    publicKey.includes('-----END PUBLIC KEY-----') &&
     validator.isLength(publicKey, CONSTRAINTS_FIELDS.ACTORS.PUBLIC_KEY)
 }
 
@@ -43,7 +43,7 @@ function isActorPrivateKeyValid (privateKey: string) {
     typeof privateKey === 'string' &&
     privateKey.startsWith('-----BEGIN RSA PRIVATE KEY-----') &&
     // Sometimes there is a \n at the end, so just assert the string contains the end mark
-    privateKey.indexOf('-----END RSA PRIVATE KEY-----') !== -1 &&
+    privateKey.includes('-----END RSA PRIVATE KEY-----') &&
     validator.isLength(privateKey, CONSTRAINTS_FIELDS.ACTORS.PRIVATE_KEY)
 }
 
@@ -101,8 +101,6 @@ function normalizeActor (actor: any) {
       actor.summary = null
     }
   }
-
-  return
 }
 
 function isValidActorHandle (handle: string) {
diff --git a/server/helpers/custom-validators/activitypub/cache-file.ts b/server/helpers/custom-validators/activitypub/cache-file.ts
index 21d5c53ca..c5b3b4d9f 100644
--- a/server/helpers/custom-validators/activitypub/cache-file.ts
+++ b/server/helpers/custom-validators/activitypub/cache-file.ts
@@ -6,7 +6,7 @@ import { CacheFileObject } from '../../../../shared/models/activitypub/objects'
 function isCacheFileObjectValid (object: CacheFileObject) {
   return exists(object) &&
     object.type === 'CacheFile' &&
-    isDateValid(object.expires) &&
+    (object.expires === null || isDateValid(object.expires)) &&
     isActivityPubUrlValid(object.object) &&
     (isRemoteVideoUrlValid(object.url) || isPlaylistRedundancyUrlValid(object.url))
 }
diff --git a/server/helpers/custom-validators/activitypub/video-comments.ts b/server/helpers/custom-validators/activitypub/video-comments.ts
index aa3c246b5..ea852c491 100644
--- a/server/helpers/custom-validators/activitypub/video-comments.ts
+++ b/server/helpers/custom-validators/activitypub/video-comments.ts
@@ -48,8 +48,6 @@ function normalizeComment (comment: any) {
     if (typeof comment.url === 'object') comment.url = comment.url.href || comment.url.url
     else comment.url = comment.id
   }
-
-  return
 }
 
 function isCommentTypeValid (comment: any): boolean {
diff --git a/server/helpers/custom-validators/activitypub/videos.ts b/server/helpers/custom-validators/activitypub/videos.ts
index fe94bd58a..876cc7f50 100644
--- a/server/helpers/custom-validators/activitypub/videos.ts
+++ b/server/helpers/custom-validators/activitypub/videos.ts
@@ -13,6 +13,7 @@ import {
 import { isActivityPubUrlValid, isBaseActivityValid, setValidAttributedTo } from './misc'
 import { VideoState } from '../../../../shared/models/videos'
 import { logger } from '@server/helpers/logger'
+import { ActivityVideoFileMetadataObject } from '@shared/models'
 
 function sanitizeAndCheckVideoTorrentUpdateActivity (activity: any) {
   return isBaseActivityValid(activity, 'Update') &&
@@ -51,11 +52,16 @@ function sanitizeAndCheckVideoTorrentObject (video: any) {
     logger.debug('Video has invalid captions', { video })
     return false
   }
+  if (!setValidRemoteIcon(video)) {
+    logger.debug('Video has invalid icons', { video })
+    return false
+  }
 
   // Default attributes
   if (!isVideoStateValid(video.state)) video.state = VideoState.PUBLISHED
   if (!isBooleanValid(video.waitTranscoding)) video.waitTranscoding = false
   if (!isBooleanValid(video.downloadEnabled)) video.downloadEnabled = true
+  if (!isBooleanValid(video.commentsEnabled)) video.commentsEnabled = false
 
   return isActivityPubUrlValid(video.id) &&
     isVideoNameValid(video.name) &&
@@ -72,7 +78,6 @@ function sanitizeAndCheckVideoTorrentObject (video: any) {
     isDateValid(video.updated) &&
     (!video.originallyPublishedAt || isDateValid(video.originallyPublishedAt)) &&
     (!video.content || isRemoteVideoContentValid(video.mediaType, video.content)) &&
-    isRemoteVideoIconValid(video.icon) &&
     video.url.length !== 0 &&
     video.attributedTo.length !== 0
 }
@@ -80,19 +85,19 @@ function sanitizeAndCheckVideoTorrentObject (video: any) {
 function isRemoteVideoUrlValid (url: any) {
   return url.type === 'Link' &&
     (
-      ACTIVITY_PUB.URL_MIME_TYPES.VIDEO.indexOf(url.mediaType) !== -1 &&
+      ACTIVITY_PUB.URL_MIME_TYPES.VIDEO.includes(url.mediaType) &&
       isActivityPubUrlValid(url.href) &&
       validator.isInt(url.height + '', { min: 0 }) &&
       validator.isInt(url.size + '', { min: 0 }) &&
       (!url.fps || validator.isInt(url.fps + '', { min: -1 }))
     ) ||
     (
-      ACTIVITY_PUB.URL_MIME_TYPES.TORRENT.indexOf(url.mediaType) !== -1 &&
+      ACTIVITY_PUB.URL_MIME_TYPES.TORRENT.includes(url.mediaType) &&
       isActivityPubUrlValid(url.href) &&
       validator.isInt(url.height + '', { min: 0 })
     ) ||
     (
-      ACTIVITY_PUB.URL_MIME_TYPES.MAGNET.indexOf(url.mediaType) !== -1 &&
+      ACTIVITY_PUB.URL_MIME_TYPES.MAGNET.includes(url.mediaType) &&
       validator.isLength(url.href, { min: 5 }) &&
       validator.isInt(url.height + '', { min: 0 })
     ) ||
@@ -100,7 +105,15 @@ function isRemoteVideoUrlValid (url: any) {
       (url.mediaType || url.mimeType) === 'application/x-mpegURL' &&
       isActivityPubUrlValid(url.href) &&
       isArray(url.tag)
-    )
+    ) ||
+    isAPVideoFileMetadataObject(url)
+}
+
+function isAPVideoFileMetadataObject (url: any): url is ActivityVideoFileMetadataObject {
+  return url &&
+    url.type === 'Link' &&
+    url.mediaType === 'application/json' &&
+    isArray(url.rel) && url.rel.includes('metadata')
 }
 
 // ---------------------------------------------------------------------------
@@ -109,7 +122,8 @@ export {
   sanitizeAndCheckVideoTorrentUpdateActivity,
   isRemoteStringIdentifierValid,
   sanitizeAndCheckVideoTorrentObject,
-  isRemoteVideoUrlValid
+  isRemoteVideoUrlValid,
+  isAPVideoFileMetadataObject
 }
 
 // ---------------------------------------------------------------------------
@@ -131,6 +145,8 @@ function setValidRemoteCaptions (video: any) {
   if (Array.isArray(video.subtitleLanguage) === false) return false
 
   video.subtitleLanguage = video.subtitleLanguage.filter(caption => {
+    if (!isActivityPubUrlValid(caption.url)) caption.url = null
+
     return isRemoteStringIdentifierValid(caption)
   })
 
@@ -149,12 +165,19 @@ function isRemoteVideoContentValid (mediaType: string, content: string) {
   return mediaType === 'text/markdown' && isVideoTruncatedDescriptionValid(content)
 }
 
-function isRemoteVideoIconValid (icon: any) {
-  return icon.type === 'Image' &&
-    isActivityPubUrlValid(icon.url) &&
-    icon.mediaType === 'image/jpeg' &&
-    validator.isInt(icon.width + '', { min: 0 }) &&
-    validator.isInt(icon.height + '', { min: 0 })
+function setValidRemoteIcon (video: any) {
+  if (video.icon && !isArray(video.icon)) video.icon = [ video.icon ]
+  if (!video.icon) video.icon = []
+
+  video.icon = video.icon.filter(icon => {
+    return icon.type === 'Image' &&
+      isActivityPubUrlValid(icon.url) &&
+      icon.mediaType === 'image/jpeg' &&
+      validator.isInt(icon.width + '', { min: 0 }) &&
+      validator.isInt(icon.height + '', { min: 0 })
+  })
+
+  return video.icon.length !== 0
 }
 
 function setValidRemoteVideoUrls (video: any) {
diff --git a/server/helpers/custom-validators/feeds.ts b/server/helpers/custom-validators/feeds.ts
index 638e814f0..fa35a7da6 100644
--- a/server/helpers/custom-validators/feeds.ts
+++ b/server/helpers/custom-validators/feeds.ts
@@ -13,7 +13,7 @@ function isValidRSSFeed (value: string) {
     'atom1'
   ]
 
-  return feedExtensions.indexOf(value) !== -1
+  return feedExtensions.includes(value)
 }
 
 // ---------------------------------------------------------------------------
diff --git a/server/helpers/custom-validators/logs.ts b/server/helpers/custom-validators/logs.ts
index 30d0ce262..0f266ed3b 100644
--- a/server/helpers/custom-validators/logs.ts
+++ b/server/helpers/custom-validators/logs.ts
@@ -4,7 +4,7 @@ import { LogLevel } from '../../../shared/models/server/log-level.type'
 const logLevels: LogLevel[] = [ 'debug', 'info', 'warn', 'error' ]
 
 function isValidLogLevel (value: any) {
-  return exists(value) && logLevels.indexOf(value) !== -1
+  return exists(value) && logLevels.includes(value)
 }
 
 // ---------------------------------------------------------------------------
diff --git a/server/helpers/custom-validators/misc.ts b/server/helpers/custom-validators/misc.ts
index 89149b3e0..cf32201c4 100644
--- a/server/helpers/custom-validators/misc.ts
+++ b/server/helpers/custom-validators/misc.ts
@@ -94,13 +94,13 @@ function isFileValid (
   if (isArray(files)) return optional
 
   // Should have a file
-  const fileArray = files[ field ]
+  const fileArray = files[field]
   if (!fileArray || fileArray.length === 0) {
     return optional
   }
 
   // The file should exist
-  const file = fileArray[ 0 ]
+  const file = fileArray[0]
   if (!file || !file.originalname) return false
 
   // Check size
diff --git a/server/helpers/custom-validators/plugins.ts b/server/helpers/custom-validators/plugins.ts
index 3af72547b..d2fc03936 100644
--- a/server/helpers/custom-validators/plugins.ts
+++ b/server/helpers/custom-validators/plugins.ts
@@ -14,7 +14,7 @@ function isPluginTypeValid (value: any) {
 function isPluginNameValid (value: string) {
   return exists(value) &&
     validator.isLength(value, PLUGINS_CONSTRAINTS_FIELDS.NAME) &&
-    validator.matches(value, /^[a-z\-]+$/)
+    validator.matches(value, /^[a-z-0-9]+$/)
 }
 
 function isNpmPluginNameValid (value: string) {
@@ -146,8 +146,8 @@ function isPackageJSONValid (packageJSON: PluginPackageJson, pluginType: PluginT
 }
 
 function isLibraryCodeValid (library: any) {
-  return typeof library.register === 'function'
-    && typeof library.unregister === 'function'
+  return typeof library.register === 'function' &&
+    typeof library.unregister === 'function'
 }
 
 export {
diff --git a/server/helpers/custom-validators/user-notifications.ts b/server/helpers/custom-validators/user-notifications.ts
index 5a4d10504..8a33b895b 100644
--- a/server/helpers/custom-validators/user-notifications.ts
+++ b/server/helpers/custom-validators/user-notifications.ts
@@ -9,7 +9,8 @@ function isUserNotificationTypeValid (value: any) {
 
 function isUserNotificationSettingValid (value: any) {
   return exists(value) &&
-    validator.isInt('' + value) && (
+    validator.isInt('' + value) &&
+    (
       value === UserNotificationSettingValue.NONE ||
       value === UserNotificationSettingValue.WEB ||
       value === UserNotificationSettingValue.EMAIL ||
diff --git a/server/helpers/custom-validators/users.ts b/server/helpers/custom-validators/users.ts
index b4d5751e7..d6e91ad35 100644
--- a/server/helpers/custom-validators/users.ts
+++ b/server/helpers/custom-validators/users.ts
@@ -3,6 +3,7 @@ import { UserRole } from '../../../shared'
 import { CONSTRAINTS_FIELDS, NSFW_POLICY_TYPES } from '../../initializers/constants'
 import { exists, isArray, isBooleanValid, isFileValid } from './misc'
 import { values } from 'lodash'
+import { isEmailEnabled } from '../../initializers/config'
 
 const USERS_CONSTRAINTS_FIELDS = CONSTRAINTS_FIELDS.USERS
 
@@ -10,6 +11,13 @@ function isUserPasswordValid (value: string) {
   return validator.isLength(value, USERS_CONSTRAINTS_FIELDS.PASSWORD)
 }
 
+function isUserPasswordValidOrEmpty (value: string) {
+  // Empty password is only possible if emailing is enabled.
+  if (value === '') return isEmailEnabled()
+
+  return isUserPasswordValid(value)
+}
+
 function isUserVideoQuotaValid (value: string) {
   return exists(value) && validator.isInt(value + '', USERS_CONSTRAINTS_FIELDS.VIDEO_QUOTA)
 }
@@ -38,7 +46,7 @@ function isUserEmailVerifiedValid (value: any) {
 
 const nsfwPolicies = values(NSFW_POLICY_TYPES)
 function isUserNSFWPolicyValid (value: any) {
-  return exists(value) && nsfwPolicies.indexOf(value) !== -1
+  return exists(value) && nsfwPolicies.includes(value)
 }
 
 function isUserWebTorrentEnabledValid (value: any) {
@@ -103,6 +111,7 @@ export {
   isUserVideosHistoryEnabledValid,
   isUserBlockedValid,
   isUserPasswordValid,
+  isUserPasswordValidOrEmpty,
   isUserVideoLanguages,
   isUserBlockedReasonValid,
   isUserRoleValid,
diff --git a/server/helpers/custom-validators/video-abuses.ts b/server/helpers/custom-validators/video-abuses.ts
index a9478c76a..05e11b1c6 100644
--- a/server/helpers/custom-validators/video-abuses.ts
+++ b/server/helpers/custom-validators/video-abuses.ts
@@ -1,8 +1,8 @@
-import { Response } from 'express'
 import validator from 'validator'
+
 import { CONSTRAINTS_FIELDS, VIDEO_ABUSE_STATES } from '../../initializers/constants'
 import { exists } from './misc'
-import { VideoAbuseModel } from '../../models/video/video-abuse'
+import { VideoAbuseVideoIs } from '@shared/models/videos/abuse/video-abuse-video-is.type'
 
 const VIDEO_ABUSES_CONSTRAINTS_FIELDS = CONSTRAINTS_FIELDS.VIDEO_ABUSES
 
@@ -15,7 +15,14 @@ function isVideoAbuseModerationCommentValid (value: string) {
 }
 
 function isVideoAbuseStateValid (value: string) {
-  return exists(value) && VIDEO_ABUSE_STATES[ value ] !== undefined
+  return exists(value) && VIDEO_ABUSE_STATES[value] !== undefined
+}
+
+function isAbuseVideoIsValid (value: VideoAbuseVideoIs) {
+  return exists(value) && (
+    value === 'deleted' ||
+    value === 'blacklisted'
+  )
 }
 
 // ---------------------------------------------------------------------------
@@ -23,5 +30,6 @@ function isVideoAbuseStateValid (value: string) {
 export {
   isVideoAbuseStateValid,
   isVideoAbuseReasonValid,
+  isAbuseVideoIsValid,
   isVideoAbuseModerationCommentValid
 }
diff --git a/server/helpers/custom-validators/video-captions.ts b/server/helpers/custom-validators/video-captions.ts
index d06eb3695..528edf60c 100644
--- a/server/helpers/custom-validators/video-captions.ts
+++ b/server/helpers/custom-validators/video-captions.ts
@@ -2,13 +2,13 @@ import { CONSTRAINTS_FIELDS, MIMETYPES, VIDEO_LANGUAGES } from '../../initialize
 import { exists, isFileValid } from './misc'
 
 function isVideoCaptionLanguageValid (value: any) {
-  return exists(value) && VIDEO_LANGUAGES[ value ] !== undefined
+  return exists(value) && VIDEO_LANGUAGES[value] !== undefined
 }
 
-const videoCaptionTypes = Object.keys(MIMETYPES.VIDEO_CAPTIONS.MIMETYPE_EXT)
-                                .concat([ 'application/octet-stream' ]) // MacOS sends application/octet-stream ><
+const videoCaptionTypesRegex = Object.keys(MIMETYPES.VIDEO_CAPTIONS.MIMETYPE_EXT)
+                                .concat([ 'application/octet-stream' ]) // MacOS sends application/octet-stream
                                 .map(m => `(${m})`)
-const videoCaptionTypesRegex = videoCaptionTypes.join('|')
+                                .join('|')
 function isVideoCaptionFile (files: { [ fieldname: string ]: Express.Multer.File[] } | Express.Multer.File[], field: string) {
   return isFileValid(files, videoCaptionTypesRegex, field, CONSTRAINTS_FIELDS.VIDEO_CAPTIONS.CAPTION_FILE.FILE_SIZE.max)
 }
diff --git a/server/helpers/custom-validators/video-imports.ts b/server/helpers/custom-validators/video-imports.ts
index ffad482b4..33a1fa8ab 100644
--- a/server/helpers/custom-validators/video-imports.ts
+++ b/server/helpers/custom-validators/video-imports.ts
@@ -20,11 +20,13 @@ function isVideoImportTargetUrlValid (url: string) {
 }
 
 function isVideoImportStateValid (value: any) {
-  return exists(value) && VIDEO_IMPORT_STATES[ value ] !== undefined
+  return exists(value) && VIDEO_IMPORT_STATES[value] !== undefined
 }
 
-const videoTorrentImportTypes = Object.keys(MIMETYPES.TORRENT.MIMETYPE_EXT).map(m => `(${m})`)
-const videoTorrentImportRegex = videoTorrentImportTypes.join('|')
+const videoTorrentImportRegex = Object.keys(MIMETYPES.TORRENT.MIMETYPE_EXT)
+                                      .concat([ 'application/octet-stream' ]) // MacOS sends application/octet-stream
+                                      .map(m => `(${m})`)
+                                      .join('|')
 function isVideoImportTorrentFile (files: { [ fieldname: string ]: Express.Multer.File[] } | Express.Multer.File[]) {
   return isFileValid(files, videoTorrentImportRegex, 'torrentfile', CONSTRAINTS_FIELDS.VIDEO_IMPORTS.TORRENT_FILE.FILE_SIZE.max, true)
 }
diff --git a/server/helpers/custom-validators/video-playlists.ts b/server/helpers/custom-validators/video-playlists.ts
index 4bb8384ab..180018fc5 100644
--- a/server/helpers/custom-validators/video-playlists.ts
+++ b/server/helpers/custom-validators/video-playlists.ts
@@ -1,8 +1,6 @@
 import { exists } from './misc'
 import validator from 'validator'
 import { CONSTRAINTS_FIELDS, VIDEO_PLAYLIST_PRIVACIES, VIDEO_PLAYLIST_TYPES } from '../../initializers/constants'
-import * as express from 'express'
-import { VideoPlaylistModel } from '../../models/video/video-playlist'
 
 const PLAYLISTS_CONSTRAINT_FIELDS = CONSTRAINTS_FIELDS.VIDEO_PLAYLISTS
 
@@ -15,7 +13,7 @@ function isVideoPlaylistDescriptionValid (value: any) {
 }
 
 function isVideoPlaylistPrivacyValid (value: number) {
-  return validator.isInt(value + '') && VIDEO_PLAYLIST_PRIVACIES[ value ] !== undefined
+  return validator.isInt(value + '') && VIDEO_PLAYLIST_PRIVACIES[value] !== undefined
 }
 
 function isVideoPlaylistTimestampValid (value: any) {
@@ -23,7 +21,7 @@ function isVideoPlaylistTimestampValid (value: any) {
 }
 
 function isVideoPlaylistTypeValid (value: any) {
-  return exists(value) && VIDEO_PLAYLIST_TYPES[ value ] !== undefined
+  return exists(value) && VIDEO_PLAYLIST_TYPES[value] !== undefined
 }
 
 // ---------------------------------------------------------------------------
diff --git a/server/helpers/custom-validators/video-redundancies.ts b/server/helpers/custom-validators/video-redundancies.ts
new file mode 100644
index 000000000..50a559c4f
--- /dev/null
+++ b/server/helpers/custom-validators/video-redundancies.ts
@@ -0,0 +1,12 @@
+import { exists } from './misc'
+
+function isVideoRedundancyTarget (value: any) {
+  return exists(value) &&
+    (value === 'my-videos' || value === 'remote-videos')
+}
+
+// ---------------------------------------------------------------------------
+
+export {
+  isVideoRedundancyTarget
+}
diff --git a/server/helpers/custom-validators/videos.ts b/server/helpers/custom-validators/videos.ts
index a9e859e54..60e8075f6 100644
--- a/server/helpers/custom-validators/videos.ts
+++ b/server/helpers/custom-validators/videos.ts
@@ -20,15 +20,15 @@ function isVideoFilterValid (filter: VideoFilter) {
 }
 
 function isVideoCategoryValid (value: any) {
-  return value === null || VIDEO_CATEGORIES[ value ] !== undefined
+  return value === null || VIDEO_CATEGORIES[value] !== undefined
 }
 
 function isVideoStateValid (value: any) {
-  return exists(value) && VIDEO_STATES[ value ] !== undefined
+  return exists(value) && VIDEO_STATES[value] !== undefined
 }
 
 function isVideoLicenceValid (value: any) {
-  return value === null || VIDEO_LICENCES[ value ] !== undefined
+  return value === null || VIDEO_LICENCES[value] !== undefined
 }
 
 function isVideoLanguageValid (value: any) {
@@ -73,7 +73,7 @@ function isVideoViewsValid (value: string) {
 }
 
 function isVideoRatingTypeValid (value: string) {
-  return value === 'none' || values(VIDEO_RATE_TYPES).indexOf(value as VideoRateType) !== -1
+  return value === 'none' || values(VIDEO_RATE_TYPES).includes(value as VideoRateType)
 }
 
 function isVideoFileExtnameValid (value: string) {
@@ -98,7 +98,7 @@ function isVideoImage (files: { [ fieldname: string ]: Express.Multer.File[] } |
 }
 
 function isVideoPrivacyValid (value: number) {
-  return VIDEO_PRIVACIES[ value ] !== undefined
+  return VIDEO_PRIVACIES[value] !== undefined
 }
 
 function isScheduleVideoUpdatePrivacyValid (value: number) {
diff --git a/server/helpers/express-utils.ts b/server/helpers/express-utils.ts
index 9bf6d85a8..f46812977 100644
--- a/server/helpers/express-utils.ts
+++ b/server/helpers/express-utils.ts
@@ -12,7 +12,7 @@ function buildNSFWFilter (res?: express.Response, paramNSFW?: string) {
   if (paramNSFW === 'false') return false
   if (paramNSFW === 'both') return undefined
 
-  if (res && res.locals.oauth) {
+  if (res?.locals.oauth) {
     const user = res.locals.oauth.token.User
 
     // User does not want NSFW videos
@@ -28,7 +28,7 @@ function buildNSFWFilter (res?: express.Response, paramNSFW?: string) {
   return null
 }
 
-function cleanUpReqFiles (req: { files: { [ fieldname: string ]: Express.Multer.File[] } | Express.Multer.File[] }) {
+function cleanUpReqFiles (req: { files: { [fieldname: string]: Express.Multer.File[] } | Express.Multer.File[] }) {
   const files = req.files
 
   if (!files) return
@@ -39,7 +39,7 @@ function cleanUpReqFiles (req: { files: { [ fieldname: string ]: Express.Multer.
   }
 
   for (const key of Object.keys(files)) {
-    const file = files[ key ]
+    const file = files[key]
 
     if (isArray(file)) file.forEach(f => deleteFileAsync(f.path))
     else deleteFileAsync(file.path)
@@ -65,18 +65,18 @@ function badRequest (req: express.Request, res: express.Response) {
 
 function createReqFiles (
   fieldNames: string[],
-  mimeTypes: { [ id: string ]: string },
-  destinations: { [ fieldName: string ]: string }
+  mimeTypes: { [id: string]: string },
+  destinations: { [fieldName: string]: string }
 ) {
   const storage = multer.diskStorage({
     destination: (req, file, cb) => {
-      cb(null, destinations[ file.fieldname ])
+      cb(null, destinations[file.fieldname])
     },
 
     filename: async (req, file, cb) => {
       let extension: string
       const fileExtension = extname(file.originalname)
-      const extensionFromMimetype = mimeTypes[ file.mimetype ]
+      const extensionFromMimetype = mimeTypes[file.mimetype]
 
       // Take the file extension if we don't understand the mime type
       // We have the OGG/OGV exception too because firefox sends a bad mime type when sending an OGG file
@@ -99,7 +99,7 @@ function createReqFiles (
     }
   })
 
-  let fields: { name: string, maxCount: number }[] = []
+  const fields: { name: string, maxCount: number }[] = []
   for (const fieldName of fieldNames) {
     fields.push({
       name: fieldName,
diff --git a/server/helpers/ffmpeg-utils.ts b/server/helpers/ffmpeg-utils.ts
index 00c32e99a..557fb5e3a 100644
--- a/server/helpers/ffmpeg-utils.ts
+++ b/server/helpers/ffmpeg-utils.ts
@@ -1,12 +1,78 @@
 import * as ffmpeg from 'fluent-ffmpeg'
 import { dirname, join } from 'path'
-import { getTargetBitrate, getMaxBitrate, VideoResolution } from '../../shared/models/videos'
+import { getMaxBitrate, getTargetBitrate, VideoResolution } from '../../shared/models/videos'
 import { FFMPEG_NICE, VIDEO_TRANSCODING_FPS } from '../initializers/constants'
 import { processImage } from './image-utils'
 import { logger } from './logger'
 import { checkFFmpegEncoders } from '../initializers/checker-before-init'
 import { readFile, remove, writeFile } from 'fs-extra'
 import { CONFIG } from '../initializers/config'
+import { VideoFileMetadata } from '@shared/models/videos/video-file-metadata'
+
+/**
+ * A toolbox to play with audio
+ */
+namespace audio {
+  export const get = (videoPath: string) => {
+    // without position, ffprobe considers the last input only
+    // we make it consider the first input only
+    // if you pass a file path to pos, then ffprobe acts on that file directly
+    return new Promise<{ absolutePath: string, audioStream?: any }>((res, rej) => {
+
+      function parseFfprobe (err: any, data: ffmpeg.FfprobeData) {
+        if (err) return rej(err)
+
+        if ('streams' in data) {
+          const audioStream = data.streams.find(stream => stream['codec_type'] === 'audio')
+          if (audioStream) {
+            return res({
+              absolutePath: data.format.filename,
+              audioStream
+            })
+          }
+        }
+
+        return res({ absolutePath: data.format.filename })
+      }
+
+      return ffmpeg.ffprobe(videoPath, parseFfprobe)
+    })
+  }
+
+  export namespace bitrate {
+    const baseKbitrate = 384
+
+    const toBits = (kbits: number) => kbits * 8000
+
+    export const aac = (bitrate: number): number => {
+      switch (true) {
+        case bitrate > toBits(baseKbitrate):
+          return baseKbitrate
+
+        default:
+          return -1 // we interpret it as a signal to copy the audio stream as is
+      }
+    }
+
+    export const mp3 = (bitrate: number): number => {
+      /*
+      a 192kbit/sec mp3 doesn't hold as much information as a 192kbit/sec aac.
+      That's why, when using aac, we can go to lower kbit/sec. The equivalences
+      made here are not made to be accurate, especially with good mp3 encoders.
+      */
+      switch (true) {
+        case bitrate <= toBits(192):
+          return 128
+
+        case bitrate <= toBits(384):
+          return 256
+
+        default:
+          return baseKbitrate
+      }
+    }
+  }
+}
 
 function computeResolutionsToTranscode (videoFileHeight: number) {
   const resolutionsEnabled: number[] = []
@@ -24,7 +90,7 @@ function computeResolutionsToTranscode (videoFileHeight: number) {
   ]
 
   for (const resolution of resolutions) {
-    if (configResolutions[ resolution + 'p' ] === true && videoFileHeight > resolution) {
+    if (configResolutions[resolution + 'p'] === true && videoFileHeight > resolution) {
       resolutionsEnabled.push(resolution)
     }
   }
@@ -48,9 +114,9 @@ async function getVideoStreamCodec (path: string) {
   const videoCodec = videoStream.codec_tag_string
 
   const baseProfileMatrix = {
-    'High': '6400',
-    'Main': '4D40',
-    'Baseline': '42E0'
+    High: '6400',
+    Main: '4D40',
+    Baseline: '42E0'
   }
 
   let baseProfile = baseProfileMatrix[videoStream.profile]
@@ -59,7 +125,8 @@ async function getVideoStreamCodec (path: string) {
     baseProfile = baseProfileMatrix['High'] // Fallback
   }
 
-  const level = videoStream.level.toString(16)
+  let level = videoStream.level.toString(16)
+  if (level.length === 1) level = `0${level}`
 
   return `${videoCodec}.${baseProfile}${level}`
 }
@@ -91,7 +158,7 @@ async function getVideoFileFPS (path: string) {
   if (videoStream === null) return 0
 
   for (const key of [ 'avg_frame_rate', 'r_frame_rate' ]) {
-    const valuesText: string = videoStream[ key ]
+    const valuesText: string = videoStream[key]
     if (!valuesText) continue
 
     const [ frames, seconds ] = valuesText.split('/')
@@ -104,24 +171,26 @@ async function getVideoFileFPS (path: string) {
   return 0
 }
 
-async function getVideoFileBitrate (path: string) {
-  return new Promise<number>((res, rej) => {
+async function getMetadataFromFile <T> (path: string, cb = metadata => metadata) {
+  return new Promise<T>((res, rej) => {
     ffmpeg.ffprobe(path, (err, metadata) => {
       if (err) return rej(err)
 
-      return res(metadata.format.bit_rate)
+      return res(cb(new VideoFileMetadata(metadata)))
     })
   })
 }
 
+async function getVideoFileBitrate (path: string) {
+  return getMetadataFromFile<number>(path, metadata => metadata.format.bit_rate)
+}
+
 function getDurationFromVideoFile (path: string) {
-  return new Promise<number>((res, rej) => {
-    ffmpeg.ffprobe(path, (err, metadata) => {
-      if (err) return rej(err)
+  return getMetadataFromFile<number>(path, metadata => Math.floor(metadata.format.duration))
+}
 
-      return res(Math.floor(metadata.format.duration))
-    })
-  })
+function getVideoStreamFromFile (path: string) {
+  return getMetadataFromFile<any>(path, metadata => metadata.streams.find(s => s.codec_type === 'video') || null)
 }
 
 async function generateImageFromVideoFile (fromPath: string, folder: string, imageName: string, size: { width: number, height: number }) {
@@ -191,7 +260,8 @@ interface OnlyAudioTranscodeOptions extends BaseTranscodeOptions {
   type: 'only-audio'
 }
 
-type TranscodeOptions = HLSTranscodeOptions
+type TranscodeOptions =
+  HLSTranscodeOptions
   | VideoTranscodeOptions
   | MergeAudioTranscodeOptions
   | OnlyAudioTranscodeOptions
@@ -204,13 +274,13 @@ function transcode (options: TranscodeOptions) {
         .output(options.outputPath)
 
       if (options.type === 'quick-transcode') {
-        command = await buildQuickTranscodeCommand(command)
+        command = buildQuickTranscodeCommand(command)
       } else if (options.type === 'hls') {
         command = await buildHLSCommand(command, options)
       } else if (options.type === 'merge-audio') {
         command = await buildAudioMergeCommand(command, options)
       } else if (options.type === 'only-audio') {
-        command = await buildOnlyAudioCommand(command, options)
+        command = buildOnlyAudioCommand(command, options)
       } else {
         command = await buildx264Command(command, options)
       }
@@ -247,22 +317,27 @@ async function canDoQuickTranscode (path: string): Promise<boolean> {
 
   // check video params
   if (videoStream == null) return false
-  if (videoStream[ 'codec_name' ] !== 'h264') return false
-  if (videoStream[ 'pix_fmt' ] !== 'yuv420p') return false
+  if (videoStream['codec_name'] !== 'h264') return false
+  if (videoStream['pix_fmt'] !== 'yuv420p') return false
   if (fps < VIDEO_TRANSCODING_FPS.MIN || fps > VIDEO_TRANSCODING_FPS.MAX) return false
   if (bitRate > getMaxBitrate(resolution.videoFileResolution, fps, VIDEO_TRANSCODING_FPS)) return false
 
   // check audio params (if audio stream exists)
   if (parsedAudio.audioStream) {
-    if (parsedAudio.audioStream[ 'codec_name' ] !== 'aac') return false
+    if (parsedAudio.audioStream['codec_name'] !== 'aac') return false
 
-    const maxAudioBitrate = audio.bitrate[ 'aac' ](parsedAudio.audioStream[ 'bit_rate' ])
-    if (maxAudioBitrate !== -1 && parsedAudio.audioStream[ 'bit_rate' ] > maxAudioBitrate) return false
+    const maxAudioBitrate = audio.bitrate['aac'](parsedAudio.audioStream['bit_rate'])
+    if (maxAudioBitrate !== -1 && parsedAudio.audioStream['bit_rate'] > maxAudioBitrate) return false
   }
 
   return true
 }
 
+function getClosestFramerateStandard (fps: number, type: 'HD_STANDARD' | 'STANDARD'): number {
+  return VIDEO_TRANSCODING_FPS[type].slice(0)
+                                    .sort((a, b) => fps % a - fps % b)[0]
+}
+
 // ---------------------------------------------------------------------------
 
 export {
@@ -270,6 +345,7 @@ export {
   getAudioStreamCodec,
   getVideoStreamSize,
   getVideoFileResolution,
+  getMetadataFromFile,
   getDurationFromVideoFile,
   generateImageFromVideoFile,
   TranscodeOptions,
@@ -286,13 +362,14 @@ export {
 
 async function buildx264Command (command: ffmpeg.FfmpegCommand, options: TranscodeOptions) {
   let fps = await getVideoFileFPS(options.inputPath)
-  // On small/medium resolutions, limit FPS
   if (
+    // On small/medium resolutions, limit FPS
     options.resolution !== undefined &&
     options.resolution < VIDEO_TRANSCODING_FPS.KEEP_ORIGIN_FPS_RESOLUTION_MIN &&
     fps > VIDEO_TRANSCODING_FPS.AVERAGE
   ) {
-    fps = VIDEO_TRANSCODING_FPS.AVERAGE
+    // Get closest standard framerate by modulo: downsampling has to be done to a divisor of the nominal fps value
+    fps = getClosestFramerateStandard(fps, 'STANDARD')
   }
 
   command = await presetH264(command, options.inputPath, options.resolution, fps)
@@ -305,7 +382,7 @@ async function buildx264Command (command: ffmpeg.FfmpegCommand, options: Transco
 
   if (fps) {
     // Hard FPS limits
-    if (fps > VIDEO_TRANSCODING_FPS.MAX) fps = VIDEO_TRANSCODING_FPS.MAX
+    if (fps > VIDEO_TRANSCODING_FPS.MAX) fps = getClosestFramerateStandard(fps, 'HD_STANDARD')
     else if (fps < VIDEO_TRANSCODING_FPS.MIN) fps = VIDEO_TRANSCODING_FPS.MIN
 
     command = command.withFPS(fps)
@@ -327,14 +404,14 @@ async function buildAudioMergeCommand (command: ffmpeg.FfmpegCommand, options: M
   return command
 }
 
-async function buildOnlyAudioCommand (command: ffmpeg.FfmpegCommand, options: OnlyAudioTranscodeOptions) {
-  command = await presetOnlyAudio(command)
+function buildOnlyAudioCommand (command: ffmpeg.FfmpegCommand, options: OnlyAudioTranscodeOptions) {
+  command = presetOnlyAudio(command)
 
   return command
 }
 
-async function buildQuickTranscodeCommand (command: ffmpeg.FfmpegCommand) {
-  command = await presetCopy(command)
+function buildQuickTranscodeCommand (command: ffmpeg.FfmpegCommand) {
+  command = presetCopy(command)
 
   command = command.outputOption('-map_metadata -1') // strip all metadata
                    .outputOption('-movflags faststart')
@@ -345,7 +422,8 @@ async function buildQuickTranscodeCommand (command: ffmpeg.FfmpegCommand) {
 async function buildHLSCommand (command: ffmpeg.FfmpegCommand, options: HLSTranscodeOptions) {
   const videoPath = getHLSVideoPath(options)
 
-  if (options.copyCodecs) command = await presetCopy(command)
+  if (options.copyCodecs) command = presetCopy(command)
+  else if (options.resolution === VideoResolution.H_NOVIDEO) command = presetOnlyAudio(command)
   else command = await buildx264Command(command, options)
 
   command = command.outputOption('-hls_time 4')
@@ -378,17 +456,6 @@ async function fixHLSPlaylistIfNeeded (options: TranscodeOptions) {
   await writeFile(options.outputPath, newContent)
 }
 
-function getVideoStreamFromFile (path: string) {
-  return new Promise<any>((res, rej) => {
-    ffmpeg.ffprobe(path, (err, metadata) => {
-      if (err) return rej(err)
-
-      const videoStream = metadata.streams.find(s => s.codec_type === 'video')
-      return res(videoStream || null)
-    })
-  })
-}
-
 /**
  * A slightly customised version of the 'veryfast' x264 preset
  *
@@ -413,71 +480,6 @@ async function presetH264VeryFast (command: ffmpeg.FfmpegCommand, input: string,
 }
 
 /**
- * A toolbox to play with audio
- */
-namespace audio {
-  export const get = (videoPath: string) => {
-    // without position, ffprobe considers the last input only
-    // we make it consider the first input only
-    // if you pass a file path to pos, then ffprobe acts on that file directly
-    return new Promise<{ absolutePath: string, audioStream?: any }>((res, rej) => {
-
-      function parseFfprobe (err: any, data: ffmpeg.FfprobeData) {
-        if (err) return rej(err)
-
-        if ('streams' in data) {
-          const audioStream = data.streams.find(stream => stream[ 'codec_type' ] === 'audio')
-          if (audioStream) {
-            return res({
-              absolutePath: data.format.filename,
-              audioStream
-            })
-          }
-        }
-
-        return res({ absolutePath: data.format.filename })
-      }
-
-      return ffmpeg.ffprobe(videoPath, parseFfprobe)
-    })
-  }
-
-  export namespace bitrate {
-    const baseKbitrate = 384
-
-    const toBits = (kbits: number) => kbits * 8000
-
-    export const aac = (bitrate: number): number => {
-      switch (true) {
-        case bitrate > toBits(baseKbitrate):
-          return baseKbitrate
-
-        default:
-          return -1 // we interpret it as a signal to copy the audio stream as is
-      }
-    }
-
-    export const mp3 = (bitrate: number): number => {
-      /*
-      a 192kbit/sec mp3 doesn't hold as much information as a 192kbit/sec aac.
-      That's why, when using aac, we can go to lower kbit/sec. The equivalences
-      made here are not made to be accurate, especially with good mp3 encoders.
-      */
-      switch (true) {
-        case bitrate <= toBits(192):
-          return 128
-
-        case bitrate <= toBits(384):
-          return 256
-
-        default:
-          return baseKbitrate
-      }
-    }
-  }
-}
-
-/**
  * Standard profile, with variable bitrate audio and faststart.
  *
  * As for the audio, quality '5' is the highest and ensures 96-112kbps/channel
@@ -507,10 +509,10 @@ async function presetH264 (command: ffmpeg.FfmpegCommand, input: string, resolut
     // of course this is far from perfect, but it might save some space in the end
     localCommand = localCommand.audioCodec('aac')
 
-    const audioCodecName = parsedAudio.audioStream[ 'codec_name' ]
+    const audioCodecName = parsedAudio.audioStream['codec_name']
 
-    if (audio.bitrate[ audioCodecName ]) {
-      const bitrate = audio.bitrate[ audioCodecName ](parsedAudio.audioStream[ 'bit_rate' ])
+    if (audio.bitrate[audioCodecName]) {
+      const bitrate = audio.bitrate[audioCodecName](parsedAudio.audioStream['bit_rate'])
       if (bitrate !== undefined && bitrate !== -1) localCommand = localCommand.audioBitrate(bitrate)
     }
   }
@@ -531,14 +533,14 @@ async function presetH264 (command: ffmpeg.FfmpegCommand, input: string, resolut
   return localCommand
 }
 
-async function presetCopy (command: ffmpeg.FfmpegCommand): Promise<ffmpeg.FfmpegCommand> {
+function presetCopy (command: ffmpeg.FfmpegCommand): ffmpeg.FfmpegCommand {
   return command
     .format('mp4')
     .videoCodec('copy')
     .audioCodec('copy')
 }
 
-async function presetOnlyAudio (command: ffmpeg.FfmpegCommand): Promise<ffmpeg.FfmpegCommand> {
+function presetOnlyAudio (command: ffmpeg.FfmpegCommand): ffmpeg.FfmpegCommand {
   return command
     .format('mp4')
     .audioCodec('copy')
diff --git a/server/helpers/logger.ts b/server/helpers/logger.ts
index 395417612..9553f70e8 100644
--- a/server/helpers/logger.ts
+++ b/server/helpers/logger.ts
@@ -5,7 +5,7 @@ import * as winston from 'winston'
 import { FileTransportOptions } from 'winston/lib/winston/transports'
 import { CONFIG } from '../initializers/config'
 import { omit } from 'lodash'
-import { LOG_FILENAME } from '@server/initializers/constants'
+import { LOG_FILENAME } from '../initializers/constants'
 
 const label = CONFIG.WEBSERVER.HOSTNAME + ':' + CONFIG.WEBSERVER.PORT
 
@@ -27,7 +27,7 @@ function getLoggerReplacer () {
     if (value instanceof Error) {
       const error = {}
 
-      Object.getOwnPropertyNames(value).forEach(key => error[ key ] = value[ key ])
+      Object.getOwnPropertyNames(value).forEach(key => { error[key] = value[key] })
 
       return error
     }
@@ -54,9 +54,11 @@ const jsonLoggerFormat = winston.format.printf(info => {
 const timestampFormatter = winston.format.timestamp({
   format: 'YYYY-MM-DD HH:mm:ss.SSS'
 })
-const labelFormatter = winston.format.label({
-  label
-})
+const labelFormatter = (suffix?: string) => {
+  return winston.format.label({
+    label: suffix ? `${label} ${suffix}` : label
+  })
+}
 
 const fileLoggerOptions: FileTransportOptions = {
   filename: path.join(CONFIG.STORAGE.LOG_DIR, LOG_FILENAME),
@@ -72,25 +74,29 @@ if (CONFIG.LOG.ROTATION.ENABLED) {
   fileLoggerOptions.maxFiles = CONFIG.LOG.ROTATION.MAX_FILES
 }
 
-const logger = winston.createLogger({
-  level: CONFIG.LOG.LEVEL,
-  format: winston.format.combine(
-    labelFormatter,
-    winston.format.splat()
-  ),
-  transports: [
-    new winston.transports.File(fileLoggerOptions),
-    new winston.transports.Console({
-      handleExceptions: true,
-      format: winston.format.combine(
-        timestampFormatter,
-        winston.format.colorize(),
-        consoleLoggerFormat
-      )
-    })
-  ],
-  exitOnError: true
-})
+const logger = buildLogger()
+
+function buildLogger (labelSuffix?: string) {
+  return winston.createLogger({
+    level: CONFIG.LOG.LEVEL,
+    format: winston.format.combine(
+      labelFormatter(labelSuffix),
+      winston.format.splat()
+    ),
+    transports: [
+      new winston.transports.File(fileLoggerOptions),
+      new winston.transports.Console({
+        handleExceptions: true,
+        format: winston.format.combine(
+          timestampFormatter,
+          winston.format.colorize(),
+          consoleLoggerFormat
+        )
+      })
+    ],
+    exitOnError: true
+  })
+}
 
 function bunyanLogFactory (level: string) {
   return function () {
@@ -98,19 +104,20 @@ function bunyanLogFactory (level: string) {
     let args: any[] = []
     args.concat(arguments)
 
-    if (arguments[ 0 ] instanceof Error) {
-      meta = arguments[ 0 ].toString()
+    if (arguments[0] instanceof Error) {
+      meta = arguments[0].toString()
       args = Array.prototype.slice.call(arguments, 1)
       args.push(meta)
-    } else if (typeof (args[ 0 ]) !== 'string') {
-      meta = arguments[ 0 ]
+    } else if (typeof (args[0]) !== 'string') {
+      meta = arguments[0]
       args = Array.prototype.slice.call(arguments, 1)
       args.push(meta)
     }
 
-    logger[ level ].apply(logger, args)
+    logger[level].apply(logger, args)
   }
 }
+
 const bunyanLogger = {
   trace: bunyanLogFactory('debug'),
   debug: bunyanLogFactory('debug'),
@@ -122,6 +129,7 @@ const bunyanLogger = {
 // ---------------------------------------------------------------------------
 
 export {
+  buildLogger,
   timestampFormatter,
   labelFormatter,
   consoleLoggerFormat,
diff --git a/server/helpers/middlewares/video-abuses.ts b/server/helpers/middlewares/video-abuses.ts
index 8a1d3d618..97a5724b6 100644
--- a/server/helpers/middlewares/video-abuses.ts
+++ b/server/helpers/middlewares/video-abuses.ts
@@ -1,9 +1,17 @@
 import { Response } from 'express'
 import { VideoAbuseModel } from '../../models/video/video-abuse'
+import { fetchVideo } from '../video'
 
-async function doesVideoAbuseExist (abuseIdArg: number | string, videoId: number, res: Response) {
+async function doesVideoAbuseExist (abuseIdArg: number | string, videoUUID: string, res: Response) {
   const abuseId = parseInt(abuseIdArg + '', 10)
-  const videoAbuse = await VideoAbuseModel.loadByIdAndVideoId(abuseId, videoId)
+  let videoAbuse = await VideoAbuseModel.loadByIdAndVideoId(abuseId, null, videoUUID)
+
+  if (!videoAbuse) {
+    const userId = res.locals.oauth?.token.User.id
+    const video = await fetchVideo(videoUUID, 'all', userId)
+
+    if (video) videoAbuse = await VideoAbuseModel.loadByIdAndVideoId(abuseId, video.id)
+  }
 
   if (videoAbuse === null) {
     res.status(404)
diff --git a/server/helpers/middlewares/videos.ts b/server/helpers/middlewares/videos.ts
index 74f529804..a0bbcdb21 100644
--- a/server/helpers/middlewares/videos.ts
+++ b/server/helpers/middlewares/videos.ts
@@ -2,7 +2,17 @@ import { Response } from 'express'
 import { fetchVideo, VideoFetchType } from '../video'
 import { UserRight } from '../../../shared/models/users'
 import { VideoChannelModel } from '../../models/video/video-channel'
-import { MUser, MUserAccountId, MVideoAccountLight, MVideoFullLight, MVideoThumbnail, MVideoWithRights } from '@server/typings/models'
+import {
+  MUser,
+  MUserAccountId,
+  MVideoAccountLight,
+  MVideoFullLight,
+  MVideoIdThumbnail,
+  MVideoImmutable,
+  MVideoThumbnail,
+  MVideoWithRights
+} from '@server/typings/models'
+import { VideoFileModel } from '@server/models/video/video-file'
 
 async function doesVideoExist (id: number | string, res: Response, fetchType: VideoFetchType = 'all') {
   const userId = res.locals.oauth ? res.locals.oauth.token.User.id : undefined
@@ -22,8 +32,12 @@ async function doesVideoExist (id: number | string, res: Response, fetchType: Vi
       res.locals.videoAll = video as MVideoFullLight
       break
 
+    case 'only-immutable-attributes':
+      res.locals.onlyImmutableVideo = video as MVideoImmutable
+      break
+
     case 'id':
-      res.locals.videoId = video
+      res.locals.videoId = video as MVideoIdThumbnail
       break
 
     case 'only-video':
@@ -38,6 +52,18 @@ async function doesVideoExist (id: number | string, res: Response, fetchType: Vi
   return true
 }
 
+async function doesVideoFileOfVideoExist (id: number, videoIdOrUUID: number | string, res: Response) {
+  if (!await VideoFileModel.doesVideoExistForVideoFile(id, videoIdOrUUID)) {
+    res.status(404)
+       .json({ error: 'VideoFile matching Video not found' })
+       .end()
+
+    return false
+  }
+
+  return true
+}
+
 async function doesVideoChannelOfAccountExist (channelId: number, user: MUserAccountId, res: Response) {
   if (user.hasRight(UserRight.UPDATE_ANY_VIDEO) === true) {
     const videoChannel = await VideoChannelModel.loadAndPopulateAccount(channelId)
@@ -94,5 +120,6 @@ function checkUserCanManageVideo (user: MUser, video: MVideoAccountLight, right:
 export {
   doesVideoChannelOfAccountExist,
   doesVideoExist,
+  doesVideoFileOfVideoExist,
   checkUserCanManageVideo
 }
diff --git a/server/helpers/peertube-crypto.ts b/server/helpers/peertube-crypto.ts
index 89c0ab151..394e97fd5 100644
--- a/server/helpers/peertube-crypto.ts
+++ b/server/helpers/peertube-crypto.ts
@@ -5,7 +5,6 @@ import { jsonld } from './custom-jsonld-signature'
 import { logger } from './logger'
 import { cloneDeep } from 'lodash'
 import { createSign, createVerify } from 'crypto'
-import { buildDigest } from '../lib/job-queue/handlers/utils/activitypub-http-utils'
 import * as bcrypt from 'bcrypt'
 import { MActor } from '../typings/models'
 
@@ -104,12 +103,19 @@ async function signJsonLDObject (byActor: MActor, data: any) {
   return Object.assign(data, { signature })
 }
 
+function buildDigest (body: any) {
+  const rawBody = typeof body === 'string' ? body : JSON.stringify(body)
+
+  return 'SHA-256=' + sha256(rawBody, 'base64')
+}
+
 // ---------------------------------------------------------------------------
 
 export {
   isHTTPSignatureDigestValid,
   parseHTTPSignature,
   isHTTPSignatureVerified,
+  buildDigest,
   isJsonLDSignatureVerified,
   comparePassword,
   createPrivateAndPublicKeys,
diff --git a/server/helpers/regexp.ts b/server/helpers/regexp.ts
index 2336654b0..cfc2be488 100644
--- a/server/helpers/regexp.ts
+++ b/server/helpers/regexp.ts
@@ -1,8 +1,8 @@
 // Thanks to https://regex101.com
 function regexpCapture (str: string, regex: RegExp, maxIterations = 100) {
+  const result: RegExpExecArray[] = []
   let m: RegExpExecArray
   let i = 0
-  let result: RegExpExecArray[] = []
 
   // tslint:disable:no-conditional-assignment
   while ((m = regex.exec(str)) !== null && i < maxIterations) {
diff --git a/server/helpers/register-ts-paths.ts b/server/helpers/register-ts-paths.ts
index e8db369e3..eec7fed3e 100644
--- a/server/helpers/register-ts-paths.ts
+++ b/server/helpers/register-ts-paths.ts
@@ -1,5 +1,5 @@
 import { resolve } from 'path'
-const tsConfigPaths = require('tsconfig-paths')
+import tsConfigPaths = require('tsconfig-paths')
 
 const tsConfig = require('../../tsconfig.json')
 
diff --git a/server/helpers/signup.ts b/server/helpers/signup.ts
index 7c73f7c5c..d34ff2db5 100644
--- a/server/helpers/signup.ts
+++ b/server/helpers/signup.ts
@@ -21,7 +21,7 @@ async function isSignupAllowed (): Promise<{ allowed: boolean, errorMessage?: st
 
 function isSignupAllowedForCurrentIP (ip: string) {
   const addr = ipaddr.parse(ip)
-  let excludeList = [ 'blacklist' ]
+  const excludeList = [ 'blacklist' ]
   let matched = ''
 
   // if there is a valid, non-empty whitelist, we exclude all unknown adresses too
diff --git a/server/helpers/utils.ts b/server/helpers/utils.ts
index 4c6f200f8..ad3b7949e 100644
--- a/server/helpers/utils.ts
+++ b/server/helpers/utils.ts
@@ -1,12 +1,11 @@
 import { ResultList } from '../../shared'
-import { ApplicationModel } from '../models/application/application'
-import { execPromise, execPromise2, pseudoRandomBytesPromise, sha256 } from './core-utils'
+import { execPromise, execPromise2, randomBytesPromise, sha256 } from './core-utils'
 import { logger } from './logger'
 import { join } from 'path'
 import { Instance as ParseTorrent } from 'parse-torrent'
 import { remove } from 'fs-extra'
-import * as memoizee from 'memoizee'
 import { CONFIG } from '../initializers/config'
+import { isVideoFileExtnameValid } from './custom-validators/videos'
 
 function deleteFileAsync (path: string) {
   remove(path)
@@ -14,7 +13,7 @@ function deleteFileAsync (path: string) {
 }
 
 async function generateRandomString (size: number) {
-  const raw = await pseudoRandomBytesPromise(size)
+  const raw = await randomBytesPromise(size)
 
   return raw.toString('hex')
 }
@@ -32,21 +31,18 @@ function getFormattedObjects<U, V, T extends FormattableToJSON<U, V>> (objects:
   } as ResultList<V>
 }
 
-const getServerActor = memoizee(async function () {
-  const application = await ApplicationModel.load()
-  if (!application) throw Error('Could not load Application from database.')
+function generateVideoImportTmpPath (target: string | ParseTorrent, extensionArg?: string) {
+  const id = typeof target === 'string'
+    ? target
+    : target.infoHash
 
-  const actor = application.Account.Actor
-  actor.Account = application.Account
-
-  return actor
-}, { promise: true })
-
-function generateVideoImportTmpPath (target: string | ParseTorrent) {
-  const id = typeof target === 'string' ? target : target.infoHash
+  let extension = '.mp4'
+  if (extensionArg && isVideoFileExtnameValid(extensionArg)) {
+    extension = extensionArg
+  }
 
   const hash = sha256(id)
-  return join(CONFIG.STORAGE.TMP_DIR, hash + '-import.mp4')
+  return join(CONFIG.STORAGE.TMP_DIR, `${hash}-import${extension}`)
 }
 
 function getSecureTorrentName (originalName: string) {
@@ -97,7 +93,6 @@ export {
   generateRandomString,
   getFormattedObjects,
   getSecureTorrentName,
-  getServerActor,
   getServerCommit,
   generateVideoImportTmpPath,
   getUUIDFromFilename
diff --git a/server/helpers/video.ts b/server/helpers/video.ts
index 5b9c026b1..6f76cbdfc 100644
--- a/server/helpers/video.ts
+++ b/server/helpers/video.ts
@@ -1,17 +1,26 @@
 import { VideoModel } from '../models/video/video'
 import * as Bluebird from 'bluebird'
 import {
+  isStreamingPlaylist,
+  MStreamingPlaylistVideo,
+  MVideo,
   MVideoAccountLightBlacklistAllFiles,
+  MVideoFile,
   MVideoFullLight,
   MVideoIdThumbnail,
+  MVideoImmutable,
   MVideoThumbnail,
   MVideoWithRights
 } from '@server/typings/models'
 import { Response } from 'express'
+import { DEFAULT_AUDIO_RESOLUTION } from '@server/initializers/constants'
+import { JobQueue } from '@server/lib/job-queue'
+import { VideoTranscodingPayload } from '@shared/models'
 
-type VideoFetchType = 'all' | 'only-video' | 'only-video-with-rights' | 'id' | 'none'
+type VideoFetchType = 'all' | 'only-video' | 'only-video-with-rights' | 'id' | 'none' | 'only-immutable-attributes'
 
 function fetchVideo (id: number | string, fetchType: 'all', userId?: number): Bluebird<MVideoFullLight>
+function fetchVideo (id: number | string, fetchType: 'only-immutable-attributes'): Bluebird<MVideoImmutable>
 function fetchVideo (id: number | string, fetchType: 'only-video', userId?: number): Bluebird<MVideoThumbnail>
 function fetchVideo (id: number | string, fetchType: 'only-video-with-rights', userId?: number): Bluebird<MVideoWithRights>
 function fetchVideo (id: number | string, fetchType: 'id' | 'none', userId?: number): Bluebird<MVideoIdThumbnail>
@@ -19,14 +28,16 @@ function fetchVideo (
   id: number | string,
   fetchType: VideoFetchType,
   userId?: number
-): Bluebird<MVideoFullLight | MVideoThumbnail | MVideoWithRights | MVideoIdThumbnail>
+): Bluebird<MVideoFullLight | MVideoThumbnail | MVideoWithRights | MVideoIdThumbnail | MVideoImmutable>
 function fetchVideo (
   id: number | string,
   fetchType: VideoFetchType,
   userId?: number
-): Bluebird<MVideoFullLight | MVideoThumbnail | MVideoWithRights | MVideoIdThumbnail> {
+): Bluebird<MVideoFullLight | MVideoThumbnail | MVideoWithRights | MVideoIdThumbnail | MVideoImmutable> {
   if (fetchType === 'all') return VideoModel.loadAndPopulateAccountAndServerAndTags(id, undefined, userId)
 
+  if (fetchType === 'only-immutable-attributes') return VideoModel.loadImmutableAttributes(id)
+
   if (fetchType === 'only-video-with-rights') return VideoModel.loadWithRights(id)
 
   if (fetchType === 'only-video') return VideoModel.load(id)
@@ -34,14 +45,23 @@ function fetchVideo (
   if (fetchType === 'id' || fetchType === 'none') return VideoModel.loadOnlyId(id)
 }
 
-type VideoFetchByUrlType = 'all' | 'only-video'
+type VideoFetchByUrlType = 'all' | 'only-video' | 'only-immutable-attributes'
 
 function fetchVideoByUrl (url: string, fetchType: 'all'): Bluebird<MVideoAccountLightBlacklistAllFiles>
+function fetchVideoByUrl (url: string, fetchType: 'only-immutable-attributes'): Bluebird<MVideoImmutable>
 function fetchVideoByUrl (url: string, fetchType: 'only-video'): Bluebird<MVideoThumbnail>
-function fetchVideoByUrl (url: string, fetchType: VideoFetchByUrlType): Bluebird<MVideoAccountLightBlacklistAllFiles | MVideoThumbnail>
-function fetchVideoByUrl (url: string, fetchType: VideoFetchByUrlType): Bluebird<MVideoAccountLightBlacklistAllFiles | MVideoThumbnail> {
+function fetchVideoByUrl (
+  url: string,
+  fetchType: VideoFetchByUrlType
+): Bluebird<MVideoAccountLightBlacklistAllFiles | MVideoThumbnail | MVideoImmutable>
+function fetchVideoByUrl (
+  url: string,
+  fetchType: VideoFetchByUrlType
+): Bluebird<MVideoAccountLightBlacklistAllFiles | MVideoThumbnail | MVideoImmutable> {
   if (fetchType === 'all') return VideoModel.loadByUrlAndPopulateAccount(url)
 
+  if (fetchType === 'only-immutable-attributes') return VideoModel.loadByUrlImmutableAttributes(url)
+
   if (fetchType === 'only-video') return VideoModel.loadByUrl(url)
 }
 
@@ -49,10 +69,39 @@ function getVideoWithAttributes (res: Response) {
   return res.locals.videoAll || res.locals.onlyVideo || res.locals.onlyVideoWithRights
 }
 
+function addOptimizeOrMergeAudioJob (video: MVideo, videoFile: MVideoFile) {
+  let dataInput: VideoTranscodingPayload
+
+  if (videoFile.isAudio()) {
+    dataInput = {
+      type: 'merge-audio' as 'merge-audio',
+      resolution: DEFAULT_AUDIO_RESOLUTION,
+      videoUUID: video.uuid,
+      isNewVideo: true
+    }
+  } else {
+    dataInput = {
+      type: 'optimize' as 'optimize',
+      videoUUID: video.uuid,
+      isNewVideo: true
+    }
+  }
+
+  return JobQueue.Instance.createJobWithPromise({ type: 'video-transcoding', payload: dataInput })
+}
+
+function extractVideo (videoOrPlaylist: MVideo | MStreamingPlaylistVideo) {
+  return isStreamingPlaylist(videoOrPlaylist)
+    ? videoOrPlaylist.Video
+    : videoOrPlaylist
+}
+
 export {
   VideoFetchType,
   VideoFetchByUrlType,
   fetchVideo,
   getVideoWithAttributes,
-  fetchVideoByUrl
+  fetchVideoByUrl,
+  addOptimizeOrMergeAudioJob,
+  extractVideo
 }
diff --git a/server/helpers/webtorrent.ts b/server/helpers/webtorrent.ts
index 3a99518c6..7cd76d708 100644
--- a/server/helpers/webtorrent.ts
+++ b/server/helpers/webtorrent.ts
@@ -9,12 +9,12 @@ import { promisify2 } from './core-utils'
 import { MVideo } from '@server/typings/models/video/video'
 import { MVideoFile, MVideoFileRedundanciesOpt } from '@server/typings/models/video/video-file'
 import { isStreamingPlaylist, MStreamingPlaylistVideo } from '@server/typings/models/video/video-streaming-playlist'
-import { STATIC_PATHS, WEBSERVER } from '@server/initializers/constants'
+import { WEBSERVER } from '@server/initializers/constants'
 import * as parseTorrent from 'parse-torrent'
 import * as magnetUtil from 'magnet-uri'
 import { isArray } from '@server/helpers/custom-validators/misc'
-import { extractVideo } from '@server/lib/videos'
-import { getTorrentFileName, getVideoFilename, getVideoFilePath } from '@server/lib/video-paths'
+import { getTorrentFileName, getVideoFilePath } from '@server/lib/video-paths'
+import { extractVideo } from '@server/helpers/video'
 
 const createTorrentPromise = promisify2<string, any, any>(createTorrent)
 
@@ -39,7 +39,7 @@ async function downloadWebTorrentVideo (target: { magnetUri: string, torrentName
       if (torrent.files.length !== 1) {
         if (timer) clearTimeout(timer)
 
-        for (let file of torrent.files) {
+        for (const file of torrent.files) {
           deleteDownloadedFile({ directoryPath, filepath: file.path })
         }
 
@@ -47,15 +47,16 @@ async function downloadWebTorrentVideo (target: { magnetUri: string, torrentName
           .then(() => rej(new Error('Cannot import torrent ' + torrentId + ': there are multiple files in it')))
       }
 
-      file = torrent.files[ 0 ]
+      file = torrent.files[0]
 
       // FIXME: avoid creating another stream when https://github.com/webtorrent/webtorrent/issues/1517 is fixed
       const writeStream = createWriteStream(path)
       writeStream.on('finish', () => {
         if (timer) clearTimeout(timer)
 
-        return safeWebtorrentDestroy(webtorrent, torrentId, { directoryPath, filepath: file.path }, target.torrentName)
+        safeWebtorrentDestroy(webtorrent, torrentId, { directoryPath, filepath: file.path }, target.torrentName)
           .then(() => res(path))
+          .catch(err => logger.error('Cannot destroy webtorrent.', { err }))
       })
 
       file.createReadStream().pipe(writeStream)
@@ -63,9 +64,16 @@ async function downloadWebTorrentVideo (target: { magnetUri: string, torrentName
 
     torrent.on('error', err => rej(err))
 
-    timer = setTimeout(async () => {
-      return safeWebtorrentDestroy(webtorrent, torrentId, file ? { directoryPath, filepath: file.path } : undefined, target.torrentName)
-        .then(() => rej(new Error('Webtorrent download timeout.')))
+    timer = setTimeout(() => {
+      const err = new Error('Webtorrent download timeout.')
+
+      safeWebtorrentDestroy(webtorrent, torrentId, file ? { directoryPath, filepath: file.path } : undefined, target.torrentName)
+        .then(() => rej(err))
+        .catch(destroyErr => {
+          logger.error('Cannot destroy webtorrent.', { err: destroyErr })
+          rej(err)
+        })
+
     }, timeout)
   })
 }
diff --git a/server/helpers/youtube-dl.ts b/server/helpers/youtube-dl.ts
index 577a59dbf..f0944b94f 100644
--- a/server/helpers/youtube-dl.ts
+++ b/server/helpers/youtube-dl.ts
@@ -1,4 +1,4 @@
-import { CONSTRAINTS_FIELDS, VIDEO_CATEGORIES } from '../initializers/constants'
+import { CONSTRAINTS_FIELDS, VIDEO_CATEGORIES, VIDEO_LANGUAGES, VIDEO_LICENCES } from '../initializers/constants'
 import { logger } from './logger'
 import { generateVideoImportTmpPath } from './utils'
 import { join } from 'path'
@@ -12,40 +12,85 @@ export type YoutubeDLInfo = {
   name?: string
   description?: string
   category?: number
+  language?: string
   licence?: number
   nsfw?: boolean
   tags?: string[]
   thumbnailUrl?: string
+  fileExt?: string
   originallyPublishedAt?: Date
 }
 
+export type YoutubeDLSubs = {
+  language: string
+  filename: string
+  path: string
+}[]
+
 const processOptions = {
   maxBuffer: 1024 * 1024 * 10 // 10MB
 }
 
 function getYoutubeDLInfo (url: string, opts?: string[]): Promise<YoutubeDLInfo> {
-  return new Promise<YoutubeDLInfo>(async (res, rej) => {
+  return new Promise<YoutubeDLInfo>((res, rej) => {
     let args = opts || [ '-j', '--flat-playlist' ]
     args = wrapWithProxyOptions(args)
 
-    const youtubeDL = await safeGetYoutubeDL()
-    youtubeDL.getInfo(url, args, processOptions, (err, info) => {
-      if (err) return rej(err)
-      if (info.is_live === true) return rej(new Error('Cannot download a live streaming.'))
+    safeGetYoutubeDL()
+      .then(youtubeDL => {
+        youtubeDL.getInfo(url, args, processOptions, (err, info) => {
+          if (err) return rej(err)
+          if (info.is_live === true) return rej(new Error('Cannot download a live streaming.'))
 
-      const obj = buildVideoInfo(normalizeObject(info))
-      if (obj.name && obj.name.length < CONSTRAINTS_FIELDS.VIDEOS.NAME.min) obj.name += ' video'
+          const obj = buildVideoInfo(normalizeObject(info))
+          if (obj.name && obj.name.length < CONSTRAINTS_FIELDS.VIDEOS.NAME.min) obj.name += ' video'
 
-      return res(obj)
-    })
+          return res(obj)
+        })
+      })
+      .catch(err => rej(err))
+  })
+}
+
+function getYoutubeDLSubs (url: string, opts?: object): Promise<YoutubeDLSubs> {
+  return new Promise<YoutubeDLSubs>((res, rej) => {
+    const cwd = CONFIG.STORAGE.TMP_DIR
+    const options = opts || { all: true, format: 'vtt', cwd }
+
+    safeGetYoutubeDL()
+      .then(youtubeDL => {
+        youtubeDL.getSubs(url, options, (err, files) => {
+          if (err) return rej(err)
+
+          logger.debug('Get subtitles from youtube dl.', { url, files })
+
+          const subtitles = files.reduce((acc, filename) => {
+            const matched = filename.match(/\.([a-z]{2})\.(vtt|ttml)/i)
+
+            if (matched[1]) {
+              return [
+                ...acc,
+                {
+                  language: matched[1],
+                  path: join(cwd, filename),
+                  filename
+                }
+              ]
+            }
+          }, [])
+
+          return res(subtitles)
+        })
+      })
+      .catch(err => rej(err))
   })
 }
 
-function downloadYoutubeDLVideo (url: string, timeout: number) {
-  const path = generateVideoImportTmpPath(url)
+function downloadYoutubeDLVideo (url: string, extension: string, timeout: number) {
+  const path = generateVideoImportTmpPath(url, extension)
   let timer
 
-  logger.info('Importing youtubeDL video %s', url)
+  logger.info('Importing youtubeDL video %s to %s', url, path)
 
   let options = [ '-f', 'bestvideo[ext=mp4]+bestaudio[ext=m4a]/best', '-o', path ]
   options = wrapWithProxyOptions(options)
@@ -54,26 +99,34 @@ function downloadYoutubeDLVideo (url: string, timeout: number) {
     options = options.concat([ '--ffmpeg-location', process.env.FFMPEG_PATH ])
   }
 
-  return new Promise<string>(async (res, rej) => {
-    const youtubeDL = await safeGetYoutubeDL()
-    youtubeDL.exec(url, options, processOptions, err => {
-      clearTimeout(timer)
+  return new Promise<string>((res, rej) => {
+    safeGetYoutubeDL()
+      .then(youtubeDL => {
+        youtubeDL.exec(url, options, processOptions, err => {
+          clearTimeout(timer)
 
-      if (err) {
-        remove(path)
-          .catch(err => logger.error('Cannot delete path on YoutubeDL error.', { err }))
+          if (err) {
+            remove(path)
+              .catch(err => logger.error('Cannot delete path on YoutubeDL error.', { err }))
 
-        return rej(err)
-      }
+            return rej(err)
+          }
 
-      return res(path)
-    })
+          return res(path)
+        })
 
-    timer = setTimeout(async () => {
-      await remove(path)
+        timer = setTimeout(() => {
+          const err = new Error('YoutubeDL download timeout.')
 
-      return rej(new Error('YoutubeDL download timeout.'))
-    }, timeout)
+          remove(path)
+            .finally(() => rej(err))
+            .catch(err => {
+              logger.error('Cannot remove %s in youtubeDL timeout.', path, { err })
+              return rej(err)
+            })
+        }, timeout)
+      })
+      .catch(err => rej(err))
   })
 }
 
@@ -103,7 +156,7 @@ async function updateYoutubeDLBinary () {
 
       const url = result.headers.location
       const downloadFile = request.get(url)
-      const newVersion = /yt-dl\.org\/downloads\/(\d{4}\.\d\d\.\d\d(\.\d)?)\/youtube-dl/.exec(url)[ 1 ]
+      const newVersion = /yt-dl\.org\/downloads\/(\d{4}\.\d\d\.\d\d(\.\d)?)\/youtube-dl/.exec(url)[1]
 
       downloadFile.on('response', result => {
         if (result.statusCode !== 200) {
@@ -173,6 +226,7 @@ function buildOriginallyPublishedAt (obj: any) {
 export {
   updateYoutubeDLBinary,
   downloadYoutubeDLVideo,
+  getYoutubeDLSubs,
   getYoutubeDLInfo,
   safeGetYoutubeDL,
   buildOriginallyPublishedAt
@@ -199,16 +253,18 @@ function normalizeObject (obj: any) {
   return newObj
 }
 
-function buildVideoInfo (obj: any) {
+function buildVideoInfo (obj: any): YoutubeDLInfo {
   return {
     name: titleTruncation(obj.title),
     description: descriptionTruncation(obj.description),
     category: getCategory(obj.categories),
     licence: getLicence(obj.license),
+    language: getLanguage(obj.language),
     nsfw: isNSFW(obj),
     tags: getTags(obj.tags),
     thumbnailUrl: obj.thumbnail || undefined,
-    originallyPublishedAt: buildOriginallyPublishedAt(obj)
+    originallyPublishedAt: buildOriginallyPublishedAt(obj),
+    fileExt: obj.ext
   }
 }
 
@@ -246,7 +302,12 @@ function getTags (tags: any) {
 function getLicence (licence: string) {
   if (!licence) return undefined
 
-  if (licence.indexOf('Creative Commons Attribution') !== -1) return 1
+  if (licence.includes('Creative Commons Attribution')) return 1
+
+  for (const key of Object.keys(VIDEO_LICENCES)) {
+    const peertubeLicence = VIDEO_LICENCES[key]
+    if (peertubeLicence.toLowerCase() === licence.toLowerCase()) return parseInt(key, 10)
+  }
 
   return undefined
 }
@@ -267,6 +328,10 @@ function getCategory (categories: string[]) {
   return undefined
 }
 
+function getLanguage (language: string) {
+  return VIDEO_LANGUAGES[language] ? language : undefined
+}
+
 function wrapWithProxyOptions (options: string[]) {
   if (CONFIG.IMPORT.VIDEOS.HTTP.PROXY.ENABLED) {
     logger.debug('Using proxy for YoutubeDL')