9 files changed, 194 insertions, 80 deletions

diff --git a/server/helpers/core-utils.ts b/server/helpers/core-utils.ts
index 224e4fe92..84e33c0e9 100644
--- a/server/helpers/core-utils.ts
+++ b/server/helpers/core-utils.ts
@@ -21,6 +21,7 @@ const timeTable = {
   week:         3600000 * 24 * 7,
   month:        3600000 * 24 * 30
 }
+
 export function parseDuration (duration: number | string): number {
   if (typeof duration === 'number') return duration
 
@@ -41,6 +42,53 @@ export function parseDuration (duration: number | string): number {
   throw new Error('Duration could not be properly parsed')
 }
 
+export function parseBytes (value: string | number): number {
+  if (typeof value === 'number') return value
+
+  const tgm = /^(\d+)\s*TB\s*(\d+)\s*GB\s*(\d+)\s*MB$/
+  const tg = /^(\d+)\s*TB\s*(\d+)\s*GB$/
+  const tm = /^(\d+)\s*TB\s*(\d+)\s*MB$/
+  const gm = /^(\d+)\s*GB\s*(\d+)\s*MB$/
+  const t = /^(\d+)\s*TB$/
+  const g = /^(\d+)\s*GB$/
+  const m = /^(\d+)\s*MB$/
+  const b = /^(\d+)\s*B$/
+  let match
+
+  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
+  } 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
+  } else if (value.match(tm)) {
+    match = value.match(tm)
+    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
+  } else if (value.match(t)) {
+    match = value.match(t)
+    return parseInt(match[1], 10) * 1024 * 1024 * 1024 * 1024
+  } else if (value.match(g)) {
+    match = value.match(g)
+    return parseInt(match[1], 10) * 1024 * 1024 * 1024
+  } else if (value.match(m)) {
+    match = value.match(m)
+    return parseInt(match[1], 10) * 1024 * 1024
+  } else if (value.match(b)) {
+    match = value.match(b)
+    return parseInt(match[1], 10) * 1024
+  } else {
+    return parseInt(value, 10)
+  }
+}
+
 function sanitizeUrl (url: string) {
   const urlObject = new URL(url)
 
diff --git a/server/helpers/custom-validators/activitypub/videos.ts b/server/helpers/custom-validators/activitypub/videos.ts
index f88d26561..95fe824b9 100644
--- a/server/helpers/custom-validators/activitypub/videos.ts
+++ b/server/helpers/custom-validators/activitypub/videos.ts
@@ -81,19 +81,20 @@ function isRemoteVideoUrlValid (url: any) {
 
   return url.type === 'Link' &&
     (
-      ACTIVITY_PUB.URL_MIME_TYPES.VIDEO.indexOf(url.mimeType) !== -1 &&
+      // TODO: remove mimeType (backward compatibility, introduced in v1.1.0)
+      ACTIVITY_PUB.URL_MIME_TYPES.VIDEO.indexOf(url.mediaType || url.mimeType) !== -1 &&
       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.mimeType) !== -1 &&
+      ACTIVITY_PUB.URL_MIME_TYPES.TORRENT.indexOf(url.mediaType || url.mimeType) !== -1 &&
       isActivityPubUrlValid(url.href) &&
       validator.isInt(url.height + '', { min: 0 })
     ) ||
     (
-      ACTIVITY_PUB.URL_MIME_TYPES.MAGNET.indexOf(url.mimeType) !== -1 &&
+      ACTIVITY_PUB.URL_MIME_TYPES.MAGNET.indexOf(url.mediaType || url.mimeType) !== -1 &&
       validator.isLength(url.href, { min: 5 }) &&
       validator.isInt(url.height + '', { min: 0 })
     )
diff --git a/server/helpers/custom-validators/users.ts b/server/helpers/custom-validators/users.ts
index 90fc74a48..1cb5e5b0f 100644
--- a/server/helpers/custom-validators/users.ts
+++ b/server/helpers/custom-validators/users.ts
@@ -42,6 +42,10 @@ function isUserNSFWPolicyValid (value: any) {
   return exists(value) && nsfwPolicies.indexOf(value) !== -1
 }
 
+function isUserWebTorrentEnabledValid (value: any) {
+  return isBooleanValid(value)
+}
+
 function isUserAutoPlayVideoValid (value: any) {
   return isBooleanValid(value)
 }
@@ -78,6 +82,7 @@ export {
   isUserUsernameValid,
   isUserEmailVerifiedValid,
   isUserNSFWPolicyValid,
+  isUserWebTorrentEnabledValid,
   isUserAutoPlayVideoValid,
   isUserDisplayNameValid,
   isUserDescriptionValid,
diff --git a/server/helpers/custom-validators/videos.ts b/server/helpers/custom-validators/videos.ts
index 9875c68bd..a13b09ac8 100644
--- a/server/helpers/custom-validators/videos.ts
+++ b/server/helpers/custom-validators/videos.ts
@@ -3,7 +3,7 @@ import 'express-validator'
 import { values } from 'lodash'
 import 'multer'
 import * as validator from 'validator'
-import { UserRight, VideoPrivacy, VideoRateType } from '../../../shared'
+import { UserRight, VideoFilter, VideoPrivacy, VideoRateType } from '../../../shared'
 import {
   CONSTRAINTS_FIELDS,
   VIDEO_CATEGORIES,
@@ -22,6 +22,10 @@ import { fetchVideo, VideoFetchType } from '../video'
 
 const VIDEOS_CONSTRAINTS_FIELDS = CONSTRAINTS_FIELDS.VIDEOS
 
+function isVideoFilterValid (filter: VideoFilter) {
+  return filter === 'local' || filter === 'all-local'
+}
+
 function isVideoCategoryValid (value: any) {
   return value === null || VIDEO_CATEGORIES[ value ] !== undefined
 }
@@ -154,7 +158,9 @@ function checkUserCanManageVideo (user: UserModel, video: VideoModel, right: Use
 }
 
 async function isVideoExist (id: string, res: Response, fetchType: VideoFetchType = 'all') {
-  const video = await fetchVideo(id, fetchType)
+  const userId = res.locals.oauth ? res.locals.oauth.token.User.id : undefined
+
+  const video = await fetchVideo(id, fetchType, userId)
 
   if (video === null) {
     res.status(404)
@@ -223,5 +229,6 @@ export {
   isVideoExist,
   isVideoImage,
   isVideoChannelOfAccountExist,
-  isVideoSupportValid
+  isVideoSupportValid,
+  isVideoFilterValid
 }
diff --git a/server/helpers/express-utils.ts b/server/helpers/express-utils.ts
index 8a9cee8c5..162fe2244 100644
--- a/server/helpers/express-utils.ts
+++ b/server/helpers/express-utils.ts
@@ -2,7 +2,6 @@ import * as express from 'express'
 import * as multer from 'multer'
 import { CONFIG, REMOTE_SCHEME } from '../initializers'
 import { logger } from './logger'
-import { User } from '../../shared/models/users'
 import { deleteFileAsync, generateRandomString } from './utils'
 import { extname } from 'path'
 import { isArray } from './custom-validators/misc'
@@ -101,7 +100,7 @@ function createReqFiles (
 }
 
 function isUserAbleToSearchRemoteURI (res: express.Response) {
-  const user: User = res.locals.oauth ? res.locals.oauth.token.User : undefined
+  const user: UserModel = res.locals.oauth ? res.locals.oauth.token.User : undefined
 
   return CONFIG.SEARCH.REMOTE_URI.ANONYMOUS === true ||
     (CONFIG.SEARCH.REMOTE_URI.USERS === true && user !== undefined)
diff --git a/server/helpers/ffmpeg-utils.ts b/server/helpers/ffmpeg-utils.ts
index 22bc25476..8b9045038 100644
--- a/server/helpers/ffmpeg-utils.ts
+++ b/server/helpers/ffmpeg-utils.ts
@@ -1,6 +1,6 @@
 import * as ffmpeg from 'fluent-ffmpeg'
 import { join } from 'path'
-import { VideoResolution } from '../../shared/models/videos'
+import { getTargetBitrate, VideoResolution } from '../../shared/models/videos'
 import { CONFIG, FFMPEG_NICE, VIDEO_TRANSCODING_FPS } from '../initializers'
 import { processImage } from './image-utils'
 import { logger } from './logger'
@@ -55,6 +55,16 @@ async function getVideoFileFPS (path: string) {
   return 0
 }
 
+async function getVideoFileBitrate (path: string) {
+  return new Promise<number>((res, rej) => {
+    ffmpeg.ffprobe(path, (err, metadata) => {
+      if (err) return rej(err)
+
+      return res(metadata.format.bit_rate)
+    })
+  })
+}
+
 function getDurationFromVideoFile (path: string) {
   return new Promise<number>((res, rej) => {
     ffmpeg.ffprobe(path, (err, metadata) => {
@@ -106,45 +116,50 @@ type TranscodeOptions = {
 
 function transcode (options: TranscodeOptions) {
   return new Promise<void>(async (res, rej) => {
-    let command = ffmpeg(options.inputPath, { niceness: FFMPEG_NICE.TRANSCODING })
-                    .output(options.outputPath)
-                    .preset(standard)
-
-    if (CONFIG.TRANSCODING.THREADS > 0) {
-      // if we don't set any threads ffmpeg will chose automatically
-      command = command.outputOption('-threads ' + CONFIG.TRANSCODING.THREADS)
-    }
-
-    let fps = await getVideoFileFPS(options.inputPath)
-    if (options.resolution !== undefined) {
-      // '?x720' or '720x?' for example
-      const size = options.isPortraitMode === true ? `${options.resolution}x?` : `?x${options.resolution}`
-      command = command.size(size)
-
+    try {
+      let fps = await getVideoFileFPS(options.inputPath)
       // On small/medium resolutions, limit FPS
       if (
+        options.resolution !== undefined &&
         options.resolution < VIDEO_TRANSCODING_FPS.KEEP_ORIGIN_FPS_RESOLUTION_MIN &&
         fps > VIDEO_TRANSCODING_FPS.AVERAGE
       ) {
         fps = VIDEO_TRANSCODING_FPS.AVERAGE
       }
-    }
 
-    if (fps) {
-      // Hard FPS limits
-      if (fps > VIDEO_TRANSCODING_FPS.MAX) fps = VIDEO_TRANSCODING_FPS.MAX
-      else if (fps < VIDEO_TRANSCODING_FPS.MIN) fps = VIDEO_TRANSCODING_FPS.MIN
+      let command = ffmpeg(options.inputPath, { niceness: FFMPEG_NICE.TRANSCODING })
+        .output(options.outputPath)
+      command = await presetH264(command, options.resolution, fps)
 
-      command = command.withFPS(fps)
-    }
+      if (CONFIG.TRANSCODING.THREADS > 0) {
+        // if we don't set any threads ffmpeg will chose automatically
+        command = command.outputOption('-threads ' + CONFIG.TRANSCODING.THREADS)
+      }
+
+      if (options.resolution !== undefined) {
+        // '?x720' or '720x?' for example
+        const size = options.isPortraitMode === true ? `${options.resolution}x?` : `?x${options.resolution}`
+        command = command.size(size)
+      }
+
+      if (fps) {
+        // Hard FPS limits
+        if (fps > VIDEO_TRANSCODING_FPS.MAX) fps = VIDEO_TRANSCODING_FPS.MAX
+        else if (fps < VIDEO_TRANSCODING_FPS.MIN) fps = VIDEO_TRANSCODING_FPS.MIN
 
-    command
-      .on('error', (err, stdout, stderr) => {
-        logger.error('Error in transcoding job.', { stdout, stderr })
-        return rej(err)
-      })
-      .on('end', res)
-      .run()
+        command = command.withFPS(fps)
+      }
+
+      command
+        .on('error', (err, stdout, stderr) => {
+          logger.error('Error in transcoding job.', { stdout, stderr })
+          return rej(err)
+        })
+        .on('end', res)
+        .run()
+    } catch (err) {
+      return rej(err)
+    }
   })
 }
 
@@ -157,7 +172,8 @@ export {
   transcode,
   getVideoFileFPS,
   computeResolutionsToTranscode,
-  audio
+  audio,
+  getVideoFileBitrate
 }
 
 // ---------------------------------------------------------------------------
@@ -182,11 +198,10 @@ function getVideoFileStream (path: string) {
  * and quality. Superfast and ultrafast will give you better
  * performance, but then quality is noticeably worse.
  */
-function veryfast (_ffmpeg) {
-  _ffmpeg
-    .preset(standard)
-    .outputOption('-preset:v veryfast')
-    .outputOption(['--aq-mode=2', '--aq-strength=1.3'])
+async function presetH264VeryFast (command: ffmpeg.FfmpegCommand, resolution: VideoResolution, fps: number): Promise<ffmpeg.FfmpegCommand> {
+  let localCommand = await presetH264(command, resolution, fps)
+  localCommand = localCommand.outputOption('-preset:v veryfast')
+             .outputOption([ '--aq-mode=2', '--aq-strength=1.3' ])
   /*
   MAIN reference: https://slhck.info/video/2017/03/01/rate-control.html
   Our target situation is closer to a livestream than a stream,
@@ -198,31 +213,39 @@ function veryfast (_ffmpeg) {
     Make up for most of the loss of grain and macroblocking
     with less computing power.
   */
+
+  return localCommand
 }
 
 /**
  * A preset optimised for a stillimage audio video
  */
-function audio (_ffmpeg) {
-  _ffmpeg
-    .preset(veryfast)
-    .outputOption('-tune stillimage')
+async function presetStillImageWithAudio (
+  command: ffmpeg.FfmpegCommand,
+  resolution: VideoResolution,
+  fps: number
+): Promise<ffmpeg.FfmpegCommand> {
+  let localCommand = await presetH264VeryFast(command, resolution, fps)
+  localCommand = localCommand.outputOption('-tune stillimage')
+
+  return localCommand
 }
 
 /**
  * A toolbox to play with audio
  */
 namespace audio {
-  export const get = (_ffmpeg, pos: number | string = 0) => {
+  export const get = (option: ffmpeg.FfmpegCommand | 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) => {
-      _ffmpeg.ffprobe(pos, (err,data) => {
+
+      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')
+          const audioStream = data.streams.find(stream => stream['codec_type'] === 'audio')
           if (audioStream) {
             return res({
               absolutePath: data.format.filename,
@@ -230,8 +253,15 @@ namespace audio {
             })
           }
         }
+
         return res({ absolutePath: data.format.filename })
-      })
+      }
+
+      if (typeof option === 'string') {
+        return ffmpeg.ffprobe(option, parseFfprobe)
+      }
+
+      return option.ffprobe(parseFfprobe)
     })
   }
 
@@ -273,39 +303,48 @@ namespace audio {
  * As for the audio, quality '5' is the highest and ensures 96-112kbps/channel
  * See https://trac.ffmpeg.org/wiki/Encode/AAC#fdk_vbr
  */
-async function standard (_ffmpeg) {
-  let localFfmpeg = _ffmpeg
+async function presetH264 (command: ffmpeg.FfmpegCommand, resolution: VideoResolution, fps: number): Promise<ffmpeg.FfmpegCommand> {
+  let localCommand = command
     .format('mp4')
     .videoCodec('libx264')
     .outputOption('-level 3.1') // 3.1 is the minimal ressource allocation for our highest supported resolution
     .outputOption('-b_strategy 1') // NOTE: b-strategy 1 - heuristic algorythm, 16 is optimal B-frames for it
     .outputOption('-bf 16') // NOTE: Why 16: https://github.com/Chocobozzz/PeerTube/pull/774. b-strategy 2 -> B-frames<16
+    .outputOption('-pix_fmt yuv420p') // allows import of source material with incompatible pixel formats (e.g. MJPEG video)
     .outputOption('-map_metadata -1') // strip all metadata
     .outputOption('-movflags faststart')
-  const _audio = await audio.get(localFfmpeg)
 
-  if (!_audio.audioStream) {
-    return localFfmpeg.noAudio()
-  }
+  const parsedAudio = await audio.get(localCommand)
 
-  // we favor VBR, if a good AAC encoder is available
-  if ((await checkFFmpegEncoders()).get('libfdk_aac')) {
-    return localFfmpeg
+  if (!parsedAudio.audioStream) {
+    localCommand = localCommand.noAudio()
+  } else if ((await checkFFmpegEncoders()).get('libfdk_aac')) { // we favor VBR, if a good AAC encoder is available
+    localCommand = localCommand
       .audioCodec('libfdk_aac')
       .audioQuality(5)
+  } else {
+    // we try to reduce the ceiling bitrate by making rough correspondances of bitrates
+    // of course this is far from perfect, but it might save some space in the end
+    const audioCodecName = parsedAudio.audioStream[ 'codec_name' ]
+    let bitrate: number
+    if (audio.bitrate[ audioCodecName ]) {
+      bitrate = audio.bitrate[ audioCodecName ](parsedAudio.audioStream[ 'bit_rate' ])
+
+      if (bitrate === -1) localCommand = localCommand.audioCodec('copy')
+      else if (bitrate !== undefined) localCommand = localCommand.audioBitrate(bitrate)
+    }
   }
 
-  // we try to reduce the ceiling bitrate by making rough correspondances of bitrates
-  // of course this is far from perfect, but it might save some space in the end
-  const audioCodecName = _audio.audioStream['codec_name']
-  let bitrate: number
-  if (audio.bitrate[audioCodecName]) {
-    bitrate = audio.bitrate[audioCodecName](_audio.audioStream['bit_rate'])
-
-    if (bitrate === -1) return localFfmpeg.audioCodec('copy')
-  }
+  // Constrained Encoding (VBV)
+  // https://slhck.info/video/2017/03/01/rate-control.html
+  // https://trac.ffmpeg.org/wiki/Limiting%20the%20output%20bitrate
+  const targetBitrate = getTargetBitrate(resolution, fps, VIDEO_TRANSCODING_FPS)
+  localCommand = localCommand.outputOptions([`-maxrate ${ targetBitrate }`, `-bufsize ${ targetBitrate * 2 }`])
 
-  if (bitrate !== undefined) return localFfmpeg.audioBitrate(bitrate)
+  // Keyframe interval of 2 seconds for faster seeking and resolution switching.
+  // https://streaminglearningcenter.com/blogs/whats-the-right-keyframe-interval.html
+  // https://superuser.com/a/908325
+  localCommand = localCommand.outputOption(`-g ${ fps * 2 }`)
 
-  return localFfmpeg
+  return localCommand
 }
diff --git a/server/helpers/peertube-crypto.ts b/server/helpers/peertube-crypto.ts
index cb5f27240..8ef7b1359 100644
--- a/server/helpers/peertube-crypto.ts
+++ b/server/helpers/peertube-crypto.ts
@@ -62,10 +62,7 @@ function isJsonLDSignatureVerified (fromActor: ActorModel, signedDocument: any)
 
   return jsig.promises
              .verify(signedDocument, options)
-             .then((result: { verified: boolean }) => {
-               logger.info('coucou', result)
-               return result.verified
-             })
+             .then((result: { verified: boolean }) => result.verified)
              .catch(err => {
                logger.error('Cannot check signature.', { err })
                return false
diff --git a/server/helpers/utils.ts b/server/helpers/utils.ts
index 6228fec04..049c3f8bc 100644
--- a/server/helpers/utils.ts
+++ b/server/helpers/utils.ts
@@ -40,7 +40,10 @@ const getServerActor = memoizee(async function () {
   const application = await ApplicationModel.load()
   if (!application) throw Error('Could not load Application from database.')
 
-  return application.Account.Actor
+  const actor = application.Account.Actor
+  actor.Account = application.Account
+
+  return actor
 })
 
 function generateVideoTmpPath (target: string | ParseTorrent) {
@@ -77,6 +80,20 @@ async function getVersion () {
   return require('../../../package.json').version
 }
 
+/**
+ * From a filename like "ede4cba5-742b-46fa-a388-9a6eb3a3aeb3.mp4", returns
+ * only the "ede4cba5-742b-46fa-a388-9a6eb3a3aeb3" part. If the filename does
+ * not contain a UUID, returns null.
+ */
+function getUUIDFromFilename (filename: string) {
+  const regex = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/
+  const result = filename.match(regex)
+
+  if (!result || Array.isArray(result) === false) return null
+
+  return result[0]
+}
+
 // ---------------------------------------------------------------------------
 
 export {
@@ -86,5 +103,6 @@ export {
   getSecureTorrentName,
   getServerActor,
   getVersion,
-  generateVideoTmpPath
+  generateVideoTmpPath,
+  getUUIDFromFilename
 }
diff --git a/server/helpers/video.ts b/server/helpers/video.ts
index b1577a6b0..1bd21467d 100644
--- a/server/helpers/video.ts
+++ b/server/helpers/video.ts
@@ -2,8 +2,8 @@ import { VideoModel } from '../models/video/video'
 
 type VideoFetchType = 'all' | 'only-video' | 'id' | 'none'
 
-function fetchVideo (id: number | string, fetchType: VideoFetchType) {
-  if (fetchType === 'all') return VideoModel.loadAndPopulateAccountAndServerAndTags(id)
+function fetchVideo (id: number | string, fetchType: VideoFetchType, userId?: number) {
+  if (fetchType === 'all') return VideoModel.loadAndPopulateAccountAndServerAndTags(id, undefined, userId)
 
   if (fetchType === 'only-video') return VideoModel.load(id)