173 files changed, 4922 insertions, 2343 deletions

diff --git a/server/controllers/activitypub/client.ts b/server/controllers/activitypub/client.ts
index 4e6bd5e25..c4d1be121 100644
--- a/server/controllers/activitypub/client.ts
+++ b/server/controllers/activitypub/client.ts
@@ -18,10 +18,10 @@ import {
 } from '../../lib/activitypub/url'
 import {
   asyncMiddleware,
+  ensureIsLocalChannel,
   executeIfActivityPub,
   localAccountValidator,
   videoChannelsNameWithHostValidator,
-  ensureIsLocalChannel,
   videosCustomGetValidator,
   videosShareValidator
 } from '../../middlewares'
@@ -265,8 +265,8 @@ async function videoAnnouncesController (req: express.Request, res: express.Resp
   const handler = async (start: number, count: number) => {
     const result = await VideoShareModel.listAndCountByVideoId(video.id, start, count)
     return {
-      total: result.count,
-      data: result.rows.map(r => r.url)
+      total: result.total,
+      data: result.data.map(r => r.url)
     }
   }
   const json = await activityPubCollectionPagination(getLocalVideoSharesActivityPubUrl(video), handler, req.query.page)
@@ -301,9 +301,10 @@ async function videoCommentsController (req: express.Request, res: express.Respo
 
   const handler = async (start: number, count: number) => {
     const result = await VideoCommentModel.listAndCountByVideoForAP(video, start, count)
+
     return {
-      total: result.count,
-      data: result.rows.map(r => r.url)
+      total: result.total,
+      data: result.data.map(r => r.url)
     }
   }
   const json = await activityPubCollectionPagination(getLocalVideoCommentsActivityPubUrl(video), handler, req.query.page)
@@ -425,8 +426,8 @@ function videoRates (req: express.Request, rateType: VideoRateType, video: MVide
   const handler = async (start: number, count: number) => {
     const result = await AccountVideoRateModel.listAndCountAccountUrlsByVideoId(rateType, video.id, start, count)
     return {
-      total: result.count,
-      data: result.rows.map(r => r.url)
+      total: result.total,
+      data: result.data.map(r => r.url)
     }
   }
   return activityPubCollectionPagination(url, handler, req.query.page)
diff --git a/server/controllers/api/accounts.ts b/server/controllers/api/accounts.ts
index 46d89bafa..8d9f92d93 100644
--- a/server/controllers/api/accounts.ts
+++ b/server/controllers/api/accounts.ts
@@ -213,7 +213,7 @@ async function listAccountRatings (req: express.Request, res: express.Response)
     sort: req.query.sort,
     type: req.query.rating
   })
-  return res.json(getFormattedObjects(resultList.rows, resultList.count))
+  return res.json(getFormattedObjects(resultList.data, resultList.total))
 }
 
 async function listAccountFollowers (req: express.Request, res: express.Response) {
diff --git a/server/controllers/api/config.ts b/server/controllers/api/config.ts
index 4e3dd4d80..821ed4ad3 100644
--- a/server/controllers/api/config.ts
+++ b/server/controllers/api/config.ts
@@ -256,6 +256,9 @@ function customConfig (): CustomConfig {
         }
       }
     },
+    videoEditor: {
+      enabled: CONFIG.VIDEO_EDITOR.ENABLED
+    },
     import: {
       videos: {
         concurrency: CONFIG.IMPORT.VIDEOS.CONCURRENCY,
diff --git a/server/controllers/api/users/index.ts b/server/controllers/api/users/index.ts
index 7efc3a137..8a06bfe93 100644
--- a/server/controllers/api/users/index.ts
+++ b/server/controllers/api/users/index.ts
@@ -3,8 +3,9 @@ import RateLimit from 'express-rate-limit'
 import { tokensRouter } from '@server/controllers/api/users/token'
 import { Hooks } from '@server/lib/plugins/hooks'
 import { OAuthTokenModel } from '@server/models/oauth/oauth-token'
-import { MUser, MUserAccountDefault } from '@server/types/models'
-import { HttpStatusCode, UserAdminFlag, UserCreate, UserCreateResult, UserRegister, UserRight, UserRole, UserUpdate } from '@shared/models'
+import { MUserAccountDefault } from '@server/types/models'
+import { pick } from '@shared/core-utils'
+import { HttpStatusCode, UserCreate, UserCreateResult, UserRegister, UserRight, UserUpdate } from '@shared/models'
 import { auditLoggerFactory, getAuditIdFromRes, UserAuditView } from '../../../helpers/audit-logger'
 import { logger } from '../../../helpers/logger'
 import { generateRandomString, getFormattedObjects } from '../../../helpers/utils'
@@ -14,7 +15,7 @@ import { sequelizeTypescript } from '../../../initializers/database'
 import { Emailer } from '../../../lib/emailer'
 import { Notifier } from '../../../lib/notifier'
 import { Redis } from '../../../lib/redis'
-import { createUserAccountAndChannelAndPlaylist, sendVerifyUserEmail } from '../../../lib/user'
+import { buildUser, createUserAccountAndChannelAndPlaylist, sendVerifyUserEmail } from '../../../lib/user'
 import {
   asyncMiddleware,
   asyncRetryTransactionMiddleware,
@@ -175,18 +176,11 @@ export {
 async function createUser (req: express.Request, res: express.Response) {
   const body: UserCreate = req.body
 
-  const userToCreate = new UserModel({
-    username: body.username,
-    password: body.password,
-    email: body.email,
-    nsfwPolicy: CONFIG.INSTANCE.DEFAULT_NSFW_POLICY,
-    p2pEnabled: CONFIG.DEFAULTS.P2P.WEBAPP.ENABLED,
-    autoPlayVideo: true,
-    role: body.role,
-    videoQuota: body.videoQuota,
-    videoQuotaDaily: body.videoQuotaDaily,
-    adminFlags: body.adminFlags || UserAdminFlag.NONE
-  }) as MUser
+  const userToCreate = buildUser({
+    ...pick(body, [ 'username', 'password', 'email', 'role', 'videoQuota', 'videoQuotaDaily', 'adminFlags' ]),
+
+    emailVerified: null
+  })
 
   // NB: due to the validator usersAddValidator, password==='' can only be true if we can send the mail.
   const createPassword = userToCreate.password === ''
@@ -225,16 +219,9 @@ async function createUser (req: express.Request, res: express.Response) {
 async function registerUser (req: express.Request, res: express.Response) {
   const body: UserRegister = req.body
 
-  const userToCreate = new UserModel({
-    username: body.username,
-    password: body.password,
-    email: body.email,
-    nsfwPolicy: CONFIG.INSTANCE.DEFAULT_NSFW_POLICY,
-    p2pEnabled: CONFIG.DEFAULTS.P2P.WEBAPP.ENABLED,
-    autoPlayVideo: true,
-    role: UserRole.USER,
-    videoQuota: CONFIG.USER.VIDEO_QUOTA,
-    videoQuotaDaily: CONFIG.USER.VIDEO_QUOTA_DAILY,
+  const userToCreate = buildUser({
+    ...pick(body, [ 'username', 'password', 'email' ]),
+
     emailVerified: CONFIG.SIGNUP.REQUIRES_EMAIL_VERIFICATION ? false : null
   })
 
diff --git a/server/controllers/api/users/me.ts b/server/controllers/api/users/me.ts
index c2ad0b710..595abcf95 100644
--- a/server/controllers/api/users/me.ts
+++ b/server/controllers/api/users/me.ts
@@ -1,7 +1,9 @@
 import 'multer'
 import express from 'express'
 import { auditLoggerFactory, getAuditIdFromRes, UserAuditView } from '@server/helpers/audit-logger'
+import { getBiggestActorImage } from '@server/lib/actor-image'
 import { Hooks } from '@server/lib/plugins/hooks'
+import { pick } from '@shared/core-utils'
 import { ActorImageType, HttpStatusCode, UserUpdateMe, UserVideoQuota, UserVideoRate as FormattedUserVideoRate } from '@shared/models'
 import { AttributesOnly } from '@shared/typescript-utils'
 import { createReqFiles } from '../../../helpers/express-utils'
@@ -10,7 +12,7 @@ import { CONFIG } from '../../../initializers/config'
 import { MIMETYPES } from '../../../initializers/constants'
 import { sequelizeTypescript } from '../../../initializers/database'
 import { sendUpdateActor } from '../../../lib/activitypub/send'
-import { deleteLocalActorImageFile, updateLocalActorImageFile } from '../../../lib/local-actor'
+import { deleteLocalActorImageFile, updateLocalActorImageFiles } from '../../../lib/local-actor'
 import { getOriginalVideoFileTotalDailyFromUser, getOriginalVideoFileTotalFromUser, sendVerifyUserEmail } from '../../../lib/user'
 import {
   asyncMiddleware,
@@ -30,11 +32,10 @@ import { AccountVideoRateModel } from '../../../models/account/account-video-rat
 import { UserModel } from '../../../models/user/user'
 import { VideoModel } from '../../../models/video/video'
 import { VideoImportModel } from '../../../models/video/video-import'
-import { pick } from '@shared/core-utils'
 
 const auditLogger = auditLoggerFactory('users')
 
-const reqAvatarFile = createReqFiles([ 'avatarfile' ], MIMETYPES.IMAGE.MIMETYPE_EXT, { avatarfile: CONFIG.STORAGE.TMP_DIR })
+const reqAvatarFile = createReqFiles([ 'avatarfile' ], MIMETYPES.IMAGE.MIMETYPE_EXT)
 
 const meRouter = express.Router()
 
@@ -253,9 +254,17 @@ async function updateMyAvatar (req: express.Request, res: express.Response) {
 
   const userAccount = await AccountModel.load(user.Account.id)
 
-  const avatar = await updateLocalActorImageFile(userAccount, avatarPhysicalFile, ActorImageType.AVATAR)
+  const avatars = await updateLocalActorImageFiles(
+    userAccount,
+    avatarPhysicalFile,
+    ActorImageType.AVATAR
+  )
 
-  return res.json({ avatar: avatar.toFormattedJSON() })
+  return res.json({
+    // TODO: remove, deprecated in 4.2
+    avatar: getBiggestActorImage(avatars).toFormattedJSON(),
+    avatars: avatars.map(avatar => avatar.toFormattedJSON())
+  })
 }
 
 async function deleteMyAvatar (req: express.Request, res: express.Response) {
@@ -264,5 +273,5 @@ async function deleteMyAvatar (req: express.Request, res: express.Response) {
   const userAccount = await AccountModel.load(user.Account.id)
   await deleteLocalActorImageFile(userAccount, ActorImageType.AVATAR)
 
-  return res.status(HttpStatusCode.NO_CONTENT_204).end()
+  return res.json({ avatars: [] })
 }
diff --git a/server/controllers/api/users/my-notifications.ts b/server/controllers/api/users/my-notifications.ts
index d107a306e..58732158f 100644
--- a/server/controllers/api/users/my-notifications.ts
+++ b/server/controllers/api/users/my-notifications.ts
@@ -3,7 +3,6 @@ import express from 'express'
 import { UserNotificationModel } from '@server/models/user/user-notification'
 import { HttpStatusCode } from '../../../../shared/models/http/http-error-codes'
 import { UserNotificationSetting } from '../../../../shared/models/users'
-import { getFormattedObjects } from '../../../helpers/utils'
 import {
   asyncMiddleware,
   asyncRetryTransactionMiddleware,
@@ -20,6 +19,7 @@ import {
 } from '../../../middlewares/validators/user-notifications'
 import { UserNotificationSettingModel } from '../../../models/user/user-notification-setting'
 import { meRouter } from './me'
+import { getFormattedObjects } from '@server/helpers/utils'
 
 const myNotificationsRouter = express.Router()
 
diff --git a/server/controllers/api/video-channel.ts b/server/controllers/api/video-channel.ts
index e65550a22..2454b1ec9 100644
--- a/server/controllers/api/video-channel.ts
+++ b/server/controllers/api/video-channel.ts
@@ -1,5 +1,6 @@
 import express from 'express'
 import { pickCommonVideoQuery } from '@server/helpers/query'
+import { getBiggestActorImage } from '@server/lib/actor-image'
 import { Hooks } from '@server/lib/plugins/hooks'
 import { ActorFollowModel } from '@server/models/actor/actor-follow'
 import { getServerActor } from '@server/models/application/application'
@@ -11,12 +12,11 @@ import { resetSequelizeInstance } from '../../helpers/database-utils'
 import { buildNSFWFilter, createReqFiles, getCountVideos, isUserAbleToSearchRemoteURI } from '../../helpers/express-utils'
 import { logger } from '../../helpers/logger'
 import { getFormattedObjects } from '../../helpers/utils'
-import { CONFIG } from '../../initializers/config'
 import { MIMETYPES } from '../../initializers/constants'
 import { sequelizeTypescript } from '../../initializers/database'
 import { sendUpdateActor } from '../../lib/activitypub/send'
 import { JobQueue } from '../../lib/job-queue'
-import { deleteLocalActorImageFile, updateLocalActorImageFile } from '../../lib/local-actor'
+import { deleteLocalActorImageFile, updateLocalActorImageFiles } from '../../lib/local-actor'
 import { createLocalVideoChannel, federateAllVideosOfChannel } from '../../lib/video-channel'
 import {
   asyncMiddleware,
@@ -50,8 +50,8 @@ import { VideoChannelModel } from '../../models/video/video-channel'
 import { VideoPlaylistModel } from '../../models/video/video-playlist'
 
 const auditLogger = auditLoggerFactory('channels')
-const reqAvatarFile = createReqFiles([ 'avatarfile' ], MIMETYPES.IMAGE.MIMETYPE_EXT, { avatarfile: CONFIG.STORAGE.TMP_DIR })
-const reqBannerFile = createReqFiles([ 'bannerfile' ], MIMETYPES.IMAGE.MIMETYPE_EXT, { bannerfile: CONFIG.STORAGE.TMP_DIR })
+const reqAvatarFile = createReqFiles([ 'avatarfile' ], MIMETYPES.IMAGE.MIMETYPE_EXT)
+const reqBannerFile = createReqFiles([ 'bannerfile' ], MIMETYPES.IMAGE.MIMETYPE_EXT)
 
 const videoChannelRouter = express.Router()
 
@@ -186,11 +186,15 @@ async function updateVideoChannelBanner (req: express.Request, res: express.Resp
   const videoChannel = res.locals.videoChannel
   const oldVideoChannelAuditKeys = new VideoChannelAuditView(videoChannel.toFormattedJSON())
 
-  const banner = await updateLocalActorImageFile(videoChannel, bannerPhysicalFile, ActorImageType.BANNER)
+  const banners = await updateLocalActorImageFiles(videoChannel, bannerPhysicalFile, ActorImageType.BANNER)
 
   auditLogger.update(getAuditIdFromRes(res), new VideoChannelAuditView(videoChannel.toFormattedJSON()), oldVideoChannelAuditKeys)
 
-  return res.json({ banner: banner.toFormattedJSON() })
+  return res.json({
+    // TODO: remove, deprecated in 4.2
+    banner: getBiggestActorImage(banners).toFormattedJSON(),
+    banners: banners.map(b => b.toFormattedJSON())
+  })
 }
 
 async function updateVideoChannelAvatar (req: express.Request, res: express.Response) {
@@ -198,11 +202,14 @@ async function updateVideoChannelAvatar (req: express.Request, res: express.Resp
   const videoChannel = res.locals.videoChannel
   const oldVideoChannelAuditKeys = new VideoChannelAuditView(videoChannel.toFormattedJSON())
 
-  const avatar = await updateLocalActorImageFile(videoChannel, avatarPhysicalFile, ActorImageType.AVATAR)
-
+  const avatars = await updateLocalActorImageFiles(videoChannel, avatarPhysicalFile, ActorImageType.AVATAR)
   auditLogger.update(getAuditIdFromRes(res), new VideoChannelAuditView(videoChannel.toFormattedJSON()), oldVideoChannelAuditKeys)
 
-  return res.json({ avatar: avatar.toFormattedJSON() })
+  return res.json({
+    // TODO: remove, deprecated in 4.2
+    avatar: getBiggestActorImage(avatars).toFormattedJSON(),
+    avatars: avatars.map(a => a.toFormattedJSON())
+  })
 }
 
 async function deleteVideoChannelAvatar (req: express.Request, res: express.Response) {
diff --git a/server/controllers/api/video-playlist.ts b/server/controllers/api/video-playlist.ts
index 795e14e73..1255d14c6 100644
--- a/server/controllers/api/video-playlist.ts
+++ b/server/controllers/api/video-playlist.ts
@@ -47,7 +47,7 @@ import { AccountModel } from '../../models/account/account'
 import { VideoPlaylistModel } from '../../models/video/video-playlist'
 import { VideoPlaylistElementModel } from '../../models/video/video-playlist-element'
 
-const reqThumbnailFile = createReqFiles([ 'thumbnailfile' ], MIMETYPES.IMAGE.MIMETYPE_EXT, { thumbnailfile: CONFIG.STORAGE.TMP_DIR })
+const reqThumbnailFile = createReqFiles([ 'thumbnailfile' ], MIMETYPES.IMAGE.MIMETYPE_EXT)
 
 const videoPlaylistRouter = express.Router()
 
@@ -453,13 +453,19 @@ async function getVideoPlaylistVideos (req: express.Request, res: express.Respon
   const user = res.locals.oauth ? res.locals.oauth.token.User : undefined
   const server = await getServerActor()
 
-  const resultList = await VideoPlaylistElementModel.listForApi({
+  const apiOptions = await Hooks.wrapObject({
     start: req.query.start,
     count: req.query.count,
     videoPlaylistId: videoPlaylistInstance.id,
     serverAccount: server.Account,
     user
-  })
+  }, 'filter:api.video-playlist.videos.list.params')
+
+  const resultList = await Hooks.wrapPromiseFun(
+    VideoPlaylistElementModel.listForApi,
+    apiOptions,
+    'filter:api.video-playlist.videos.list.result'
+  )
 
   const options = {
     displayNSFW: buildNSFWFilter(res, req.query.nsfw),
diff --git a/server/controllers/api/videos/captions.ts b/server/controllers/api/videos/captions.ts
index 2a9a9d233..2b511a398 100644
--- a/server/controllers/api/videos/captions.ts
+++ b/server/controllers/api/videos/captions.ts
@@ -1,26 +1,19 @@
 import express from 'express'
+import { Hooks } from '@server/lib/plugins/hooks'
 import { MVideoCaption } from '@server/types/models'
 import { HttpStatusCode } from '../../../../shared/models/http/http-error-codes'
 import { moveAndProcessCaptionFile } from '../../../helpers/captions-utils'
 import { createReqFiles } from '../../../helpers/express-utils'
 import { logger } from '../../../helpers/logger'
 import { getFormattedObjects } from '../../../helpers/utils'
-import { CONFIG } from '../../../initializers/config'
 import { MIMETYPES } from '../../../initializers/constants'
 import { sequelizeTypescript } from '../../../initializers/database'
 import { federateVideoIfNeeded } from '../../../lib/activitypub/videos'
 import { asyncMiddleware, asyncRetryTransactionMiddleware, authenticate } from '../../../middlewares'
 import { addVideoCaptionValidator, deleteVideoCaptionValidator, listVideoCaptionsValidator } from '../../../middlewares/validators'
 import { VideoCaptionModel } from '../../../models/video/video-caption'
-import { Hooks } from '@server/lib/plugins/hooks'
 
-const reqVideoCaptionAdd = createReqFiles(
-  [ 'captionfile' ],
-  MIMETYPES.VIDEO_CAPTIONS.MIMETYPE_EXT,
-  {
-    captionfile: CONFIG.STORAGE.CAPTIONS_DIR
-  }
-)
+const reqVideoCaptionAdd = createReqFiles([ 'captionfile' ], MIMETYPES.VIDEO_CAPTIONS.MIMETYPE_EXT)
 
 const videoCaptionsRouter = express.Router()
 
diff --git a/server/controllers/api/videos/editor.ts b/server/controllers/api/videos/editor.ts
new file mode 100644
index 000000000..588cc1a8c
--- /dev/null
+++ b/server/controllers/api/videos/editor.ts
@@ -0,0 +1,118 @@
+import express from 'express'
+import { createAnyReqFiles } from '@server/helpers/express-utils'
+import { MIMETYPES } from '@server/initializers/constants'
+import { JobQueue } from '@server/lib/job-queue'
+import { buildTaskFileFieldname, getTaskFile } from '@server/lib/video-editor'
+import {
+  HttpStatusCode,
+  VideoEditionTaskPayload,
+  VideoEditorCreateEdition,
+  VideoEditorTask,
+  VideoEditorTaskCut,
+  VideoEditorTaskIntro,
+  VideoEditorTaskOutro,
+  VideoEditorTaskWatermark,
+  VideoState
+} from '@shared/models'
+import { asyncMiddleware, authenticate, videosEditorAddEditionValidator } from '../../../middlewares'
+
+const editorRouter = express.Router()
+
+const tasksFiles = createAnyReqFiles(
+  MIMETYPES.VIDEO.MIMETYPE_EXT,
+  (req: express.Request, file: Express.Multer.File, cb: (err: Error, result?: boolean) => void) => {
+    const body = req.body as VideoEditorCreateEdition
+
+    // Fetch array element
+    const matches = file.fieldname.match(/tasks\[(\d+)\]/)
+    if (!matches) return cb(new Error('Cannot find array element indice for ' + file.fieldname))
+
+    const indice = parseInt(matches[1])
+    const task = body.tasks[indice]
+
+    if (!task) return cb(new Error('Cannot find array element of indice ' + indice + ' for ' + file.fieldname))
+
+    if (
+      [ 'add-intro', 'add-outro', 'add-watermark' ].includes(task.name) &&
+      file.fieldname === buildTaskFileFieldname(indice)
+    ) {
+      return cb(null, true)
+    }
+
+    return cb(null, false)
+  }
+)
+
+editorRouter.post('/:videoId/editor/edit',
+  authenticate,
+  tasksFiles,
+  asyncMiddleware(videosEditorAddEditionValidator),
+  asyncMiddleware(createEditionTasks)
+)
+
+// ---------------------------------------------------------------------------
+
+export {
+  editorRouter
+}
+
+// ---------------------------------------------------------------------------
+
+async function createEditionTasks (req: express.Request, res: express.Response) {
+  const files = req.files as Express.Multer.File[]
+  const body = req.body as VideoEditorCreateEdition
+  const video = res.locals.videoAll
+
+  video.state = VideoState.TO_EDIT
+  await video.save()
+
+  const payload = {
+    videoUUID: video.uuid,
+    tasks: body.tasks.map((t, i) => buildTaskPayload(t, i, files))
+  }
+
+  JobQueue.Instance.createJob({ type: 'video-edition', payload })
+
+  return res.sendStatus(HttpStatusCode.NO_CONTENT_204)
+}
+
+const taskPayloadBuilders: {
+  [id in VideoEditorTask['name']]: (task: VideoEditorTask, indice?: number, files?: Express.Multer.File[]) => VideoEditionTaskPayload
+} = {
+  'add-intro': buildIntroOutroTask,
+  'add-outro': buildIntroOutroTask,
+  'cut': buildCutTask,
+  'add-watermark': buildWatermarkTask
+}
+
+function buildTaskPayload (task: VideoEditorTask, indice: number, files: Express.Multer.File[]): VideoEditionTaskPayload {
+  return taskPayloadBuilders[task.name](task, indice, files)
+}
+
+function buildIntroOutroTask (task: VideoEditorTaskIntro | VideoEditorTaskOutro, indice: number, files: Express.Multer.File[]) {
+  return {
+    name: task.name,
+    options: {
+      file: getTaskFile(files, indice).path
+    }
+  }
+}
+
+function buildCutTask (task: VideoEditorTaskCut) {
+  return {
+    name: task.name,
+    options: {
+      start: task.options.start,
+      end: task.options.end
+    }
+  }
+}
+
+function buildWatermarkTask (task: VideoEditorTaskWatermark, indice: number, files: Express.Multer.File[]) {
+  return {
+    name: task.name,
+    options: {
+      file: getTaskFile(files, indice).path
+    }
+  }
+}
diff --git a/server/controllers/api/videos/import.ts b/server/controllers/api/videos/import.ts
index b54fa822c..44283e266 100644
--- a/server/controllers/api/videos/import.ts
+++ b/server/controllers/api/videos/import.ts
@@ -61,12 +61,7 @@ const videoImportsRouter = express.Router()
 
 const reqVideoFileImport = createReqFiles(
   [ 'thumbnailfile', 'previewfile', 'torrentfile' ],
-  Object.assign({}, MIMETYPES.TORRENT.MIMETYPE_EXT, MIMETYPES.IMAGE.MIMETYPE_EXT),
-  {
-    thumbnailfile: CONFIG.STORAGE.TMP_DIR,
-    previewfile: CONFIG.STORAGE.TMP_DIR,
-    torrentfile: CONFIG.STORAGE.TMP_DIR
-  }
+  { ...MIMETYPES.TORRENT.MIMETYPE_EXT, ...MIMETYPES.IMAGE.MIMETYPE_EXT }
 )
 
 videoImportsRouter.post('/imports',
diff --git a/server/controllers/api/videos/index.ts b/server/controllers/api/videos/index.ts
index 61a030ba1..a5ae07d95 100644
--- a/server/controllers/api/videos/index.ts
+++ b/server/controllers/api/videos/index.ts
@@ -35,6 +35,7 @@ import { VideoModel } from '../../../models/video/video'
 import { blacklistRouter } from './blacklist'
 import { videoCaptionsRouter } from './captions'
 import { videoCommentRouter } from './comment'
+import { editorRouter } from './editor'
 import { filesRouter } from './files'
 import { videoImportsRouter } from './import'
 import { liveRouter } from './live'
@@ -51,6 +52,7 @@ const videosRouter = express.Router()
 videosRouter.use('/', blacklistRouter)
 videosRouter.use('/', rateVideoRouter)
 videosRouter.use('/', videoCommentRouter)
+videosRouter.use('/', editorRouter)
 videosRouter.use('/', videoCaptionsRouter)
 videosRouter.use('/', videoImportsRouter)
 videosRouter.use('/', ownershipVideoRouter)
diff --git a/server/controllers/api/videos/live.ts b/server/controllers/api/videos/live.ts
index 8b8cacff9..49cabb6f3 100644
--- a/server/controllers/api/videos/live.ts
+++ b/server/controllers/api/videos/live.ts
@@ -1,6 +1,5 @@
 import express from 'express'
 import { createReqFiles } from '@server/helpers/express-utils'
-import { CONFIG } from '@server/initializers/config'
 import { ASSETS_PATH, MIMETYPES } from '@server/initializers/constants'
 import { getLocalVideoActivityPubUrl } from '@server/lib/activitypub/url'
 import { federateVideoIfNeeded } from '@server/lib/activitypub/videos'
@@ -19,14 +18,7 @@ import { VideoModel } from '../../../models/video/video'
 
 const liveRouter = express.Router()
 
-const reqVideoFileLive = createReqFiles(
-  [ 'thumbnailfile', 'previewfile' ],
-  MIMETYPES.IMAGE.MIMETYPE_EXT,
-  {
-    thumbnailfile: CONFIG.STORAGE.TMP_DIR,
-    previewfile: CONFIG.STORAGE.TMP_DIR
-  }
-)
+const reqVideoFileLive = createReqFiles([ 'thumbnailfile', 'previewfile' ], MIMETYPES.IMAGE.MIMETYPE_EXT)
 
 liveRouter.post('/live',
   authenticate,
diff --git a/server/controllers/api/videos/transcoding.ts b/server/controllers/api/videos/transcoding.ts
index fba4545c2..da3ea3c9c 100644
--- a/server/controllers/api/videos/transcoding.ts
+++ b/server/controllers/api/videos/transcoding.ts
@@ -1,5 +1,5 @@
 import express from 'express'
-import { computeLowerResolutionsToTranscode } from '@server/helpers/ffprobe-utils'
+import { computeLowerResolutionsToTranscode } from '@server/helpers/ffmpeg'
 import { logger, loggerTagsFactory } from '@server/helpers/logger'
 import { addTranscodingJob } from '@server/lib/video'
 import { HttpStatusCode, UserRight, VideoState, VideoTranscodingCreate } from '@shared/models'
@@ -29,7 +29,7 @@ async function createTranscoding (req: express.Request, res: express.Response) {
 
   const body: VideoTranscodingCreate = req.body
 
-  const { resolution: maxResolution, isPortraitMode, audioStream } = await video.getMaxQualityFileInfo()
+  const { resolution: maxResolution, isPortraitMode, audioStream } = await video.probeMaxQualityFile()
   const resolutions = computeLowerResolutionsToTranscode(maxResolution, 'vod').concat([ maxResolution ])
 
   video.state = VideoState.TO_TRANSCODE
diff --git a/server/controllers/api/videos/update.ts b/server/controllers/api/videos/update.ts
index c01d9276a..15899307d 100644
--- a/server/controllers/api/videos/update.ts
+++ b/server/controllers/api/videos/update.ts
@@ -11,7 +11,6 @@ import { auditLoggerFactory, getAuditIdFromRes, VideoAuditView } from '../../../
 import { resetSequelizeInstance } from '../../../helpers/database-utils'
 import { createReqFiles } from '../../../helpers/express-utils'
 import { logger, loggerTagsFactory } from '../../../helpers/logger'
-import { CONFIG } from '../../../initializers/config'
 import { MIMETYPES } from '../../../initializers/constants'
 import { sequelizeTypescript } from '../../../initializers/database'
 import { federateVideoIfNeeded } from '../../../lib/activitypub/videos'
@@ -26,14 +25,7 @@ const lTags = loggerTagsFactory('api', 'video')
 const auditLogger = auditLoggerFactory('videos')
 const updateRouter = express.Router()
 
-const reqVideoFileUpdate = createReqFiles(
-  [ 'thumbnailfile', 'previewfile' ],
-  MIMETYPES.IMAGE.MIMETYPE_EXT,
-  {
-    thumbnailfile: CONFIG.STORAGE.TMP_DIR,
-    previewfile: CONFIG.STORAGE.TMP_DIR
-  }
-)
+const reqVideoFileUpdate = createReqFiles([ 'thumbnailfile', 'previewfile' ], MIMETYPES.IMAGE.MIMETYPE_EXT)
 
 updateRouter.put('/:id',
   openapiOperationDoc({ operationId: 'putVideo' }),
diff --git a/server/controllers/api/videos/upload.ts b/server/controllers/api/videos/upload.ts
index fd90d9915..dd69cf238 100644
--- a/server/controllers/api/videos/upload.ts
+++ b/server/controllers/api/videos/upload.ts
@@ -24,9 +24,8 @@ import { HttpStatusCode, VideoCreate, VideoResolution, VideoState } from '@share
 import { auditLoggerFactory, getAuditIdFromRes, VideoAuditView } from '../../../helpers/audit-logger'
 import { retryTransactionWrapper } from '../../../helpers/database-utils'
 import { createReqFiles } from '../../../helpers/express-utils'
-import { ffprobePromise, getMetadataFromFile, getVideoFileFPS, getVideoFileResolution } from '../../../helpers/ffprobe-utils'
+import { buildFileMetadata, ffprobePromise, getVideoStreamDimensionsInfo, getVideoStreamFPS } from '../../../helpers/ffmpeg'
 import { logger, loggerTagsFactory } from '../../../helpers/logger'
-import { CONFIG } from '../../../initializers/config'
 import { MIMETYPES } from '../../../initializers/constants'
 import { sequelizeTypescript } from '../../../initializers/database'
 import { federateVideoIfNeeded } from '../../../lib/activitypub/videos'
@@ -52,21 +51,13 @@ const uploadRouter = express.Router()
 
 const reqVideoFileAdd = createReqFiles(
   [ 'videofile', 'thumbnailfile', 'previewfile' ],
-  Object.assign({}, MIMETYPES.VIDEO.MIMETYPE_EXT, MIMETYPES.IMAGE.MIMETYPE_EXT),
-  {
-    videofile: CONFIG.STORAGE.TMP_DIR,
-    thumbnailfile: CONFIG.STORAGE.TMP_DIR,
-    previewfile: CONFIG.STORAGE.TMP_DIR
-  }
+  { ...MIMETYPES.VIDEO.MIMETYPE_EXT, ...MIMETYPES.IMAGE.MIMETYPE_EXT }
 )
 
 const reqVideoFileAddResumable = createReqFiles(
   [ 'thumbnailfile', 'previewfile' ],
   MIMETYPES.IMAGE.MIMETYPE_EXT,
-  {
-    thumbnailfile: getResumableUploadPath(),
-    previewfile: getResumableUploadPath()
-  }
+  getResumableUploadPath()
 )
 
 uploadRouter.post('/upload',
@@ -246,7 +237,7 @@ async function buildNewFile (videoPhysicalFile: express.VideoUploadFile) {
     extname: getLowercaseExtension(videoPhysicalFile.filename),
     size: videoPhysicalFile.size,
     videoStreamingPlaylistId: null,
-    metadata: await getMetadataFromFile(videoPhysicalFile.path)
+    metadata: await buildFileMetadata(videoPhysicalFile.path)
   })
 
   const probe = await ffprobePromise(videoPhysicalFile.path)
@@ -254,8 +245,8 @@ async function buildNewFile (videoPhysicalFile: express.VideoUploadFile) {
   if (await isAudioFile(videoPhysicalFile.path, probe)) {
     videoFile.resolution = VideoResolution.H_NOVIDEO
   } else {
-    videoFile.fps = await getVideoFileFPS(videoPhysicalFile.path, probe)
-    videoFile.resolution = (await getVideoFileResolution(videoPhysicalFile.path, probe)).resolution
+    videoFile.fps = await getVideoStreamFPS(videoPhysicalFile.path, probe)
+    videoFile.resolution = (await getVideoStreamDimensionsInfo(videoPhysicalFile.path, probe)).resolution
   }
 
   videoFile.filename = generateWebTorrentVideoFilename(videoFile.resolution, videoFile.extname)
diff --git a/server/controllers/client.ts b/server/controllers/client.ts
index 8a56f2f75..f9514d988 100644
--- a/server/controllers/client.ts
+++ b/server/controllers/client.ts
@@ -68,7 +68,9 @@ const staticClientOverrides = [
   'assets/images/icons/icon-512x512.png',
   'assets/images/default-playlist.jpg',
   'assets/images/default-avatar-account.png',
-  'assets/images/default-avatar-video-channel.png'
+  'assets/images/default-avatar-account-48x48.png',
+  'assets/images/default-avatar-video-channel.png',
+  'assets/images/default-avatar-video-channel-48x48.png'
 ]
 
 for (const staticClientOverride of staticClientOverrides) {
diff --git a/server/controllers/lazy-static.ts b/server/controllers/lazy-static.ts
index a4076ee56..55bf02660 100644
--- a/server/controllers/lazy-static.ts
+++ b/server/controllers/lazy-static.ts
@@ -64,7 +64,15 @@ async function getActorImage (req: express.Request, res: express.Response, next:
     logger.info('Lazy serve remote actor image %s.', image.fileUrl)
 
     try {
-      await pushActorImageProcessInQueue({ filename: image.filename, fileUrl: image.fileUrl, type: image.type })
+      await pushActorImageProcessInQueue({
+        filename: image.filename,
+        fileUrl: image.fileUrl,
+        size: {
+          height: image.height,
+          width: image.width
+        },
+        type: image.type
+      })
     } catch (err) {
       logger.warn('Cannot process remote actor image %s.', image.fileUrl, { err })
       return res.status(HttpStatusCode.NOT_FOUND_404).end()
diff --git a/server/helpers/activitypub.ts b/server/helpers/activitypub.ts
index fe721cbac..cbba2f51c 100644
--- a/server/helpers/activitypub.ts
+++ b/server/helpers/activitypub.ts
@@ -38,6 +38,9 @@ function getContextData (type: ContextType) {
         sensitive: 'as:sensitive',
         language: 'sc:inLanguage',
 
+        // TODO: remove in a few versions, introduced in 4.2
+        icons: 'as:icon',
+
         isLiveBroadcast: 'sc:isLiveBroadcast',
         liveSaveReplay: {
           '@type': 'sc:Boolean',
diff --git a/server/helpers/custom-validators/actor-images.ts b/server/helpers/custom-validators/actor-images.ts
index 4fb0b7c70..89f5a2262 100644
--- a/server/helpers/custom-validators/actor-images.ts
+++ b/server/helpers/custom-validators/actor-images.ts
@@ -1,4 +1,5 @@
 
+import { UploadFilesForCheck } from 'express'
 import { CONSTRAINTS_FIELDS } from '../../initializers/constants'
 import { isFileValid } from './misc'
 
@@ -6,8 +7,14 @@ const imageMimeTypes = CONSTRAINTS_FIELDS.ACTORS.IMAGE.EXTNAME
   .map(v => v.replace('.', ''))
   .join('|')
 const imageMimeTypesRegex = `image/(${imageMimeTypes})`
-function isActorImageFile (files: { [ fieldname: string ]: Express.Multer.File[] } | Express.Multer.File[], fieldname: string) {
-  return isFileValid(files, imageMimeTypesRegex, fieldname, CONSTRAINTS_FIELDS.ACTORS.IMAGE.FILE_SIZE.max)
+
+function isActorImageFile (files: UploadFilesForCheck, fieldname: string) {
+  return isFileValid({
+    files,
+    mimeTypeRegex: imageMimeTypesRegex,
+    field: fieldname,
+    maxSize: CONSTRAINTS_FIELDS.ACTORS.IMAGE.FILE_SIZE.max
+  })
 }
 
 // ---------------------------------------------------------------------------
diff --git a/server/helpers/custom-validators/misc.ts b/server/helpers/custom-validators/misc.ts
index 81a60ee66..c80c86193 100644
--- a/server/helpers/custom-validators/misc.ts
+++ b/server/helpers/custom-validators/misc.ts
@@ -61,75 +61,43 @@ function isIntOrNull (value: any) {
 
 // ---------------------------------------------------------------------------
 
-function isFileFieldValid (
-  files: { [ fieldname: string ]: Express.Multer.File[] } | Express.Multer.File[],
-  field: string,
-  optional = false
-) {
-  // Should have files
-  if (!files) return optional
-  if (isArray(files)) return optional
+function isFileValid (options: {
+  files: UploadFilesForCheck
 
-  // Should have a file
-  const fileArray = files[field]
-  if (!fileArray || fileArray.length === 0) {
-    return optional
-  }
+  maxSize: number | null
+  mimeTypeRegex: string | null
 
-  // The file should exist
-  const file = fileArray[0]
-  if (!file || !file.originalname) return false
-  return file
-}
+  field?: string
 
-function isFileMimeTypeValid (
-  files: UploadFilesForCheck,
-  mimeTypeRegex: string,
-  field: string,
-  optional = false
-) {
-  // Should have files
-  if (!files) return optional
-  if (isArray(files)) return optional
+  optional?: boolean // Default false
+}) {
+  const { files, mimeTypeRegex, field, maxSize, optional = false } = options
 
-  // Should have a file
-  const fileArray = files[field]
-  if (!fileArray || fileArray.length === 0) {
-    return optional
-  }
-
-  // The file should exist
-  const file = fileArray[0]
-  if (!file || !file.originalname) return false
-
-  return new RegExp(`^${mimeTypeRegex}$`, 'i').test(file.mimetype)
-}
-
-function isFileValid (
-  files: { [ fieldname: string ]: Express.Multer.File[] } | Express.Multer.File[],
-  mimeTypeRegex: string,
-  field: string,
-  maxSize: number | null,
-  optional = false
-) {
   // Should have files
   if (!files) return optional
-  if (isArray(files)) return optional
 
-  // Should have a file
-  const fileArray = files[field]
-  if (!fileArray || fileArray.length === 0) {
+  const fileArray = isArray(files)
+    ? files
+    : files[field]
+
+  if (!fileArray || !isArray(fileArray) || fileArray.length === 0) {
     return optional
   }
 
-  // The file should exist
+  // The file exists
   const file = fileArray[0]
   if (!file || !file.originalname) return false
 
   // Check size
   if ((maxSize !== null) && file.size > maxSize) return false
 
-  return new RegExp(`^${mimeTypeRegex}$`, 'i').test(file.mimetype)
+  if (mimeTypeRegex === null) return true
+
+  return checkMimetypeRegex(file.mimetype, mimeTypeRegex)
+}
+
+function checkMimetypeRegex (fileMimeType: string, mimeTypeRegex: string) {
+  return new RegExp(`^${mimeTypeRegex}$`, 'i').test(fileMimeType)
 }
 
 // ---------------------------------------------------------------------------
@@ -204,7 +172,6 @@ export {
   areUUIDsValid,
   toArray,
   toIntArray,
-  isFileFieldValid,
-  isFileMimeTypeValid,
-  isFileValid
+  isFileValid,
+  checkMimetypeRegex
 }
diff --git a/server/helpers/custom-validators/video-captions.ts b/server/helpers/custom-validators/video-captions.ts
index 4cc7dcaf4..59ba005fe 100644
--- a/server/helpers/custom-validators/video-captions.ts
+++ b/server/helpers/custom-validators/video-captions.ts
@@ -1,5 +1,6 @@
-import { getFileSize } from '@shared/extra-utils'
+import { UploadFilesForCheck } from 'express'
 import { readFile } from 'fs-extra'
+import { getFileSize } from '@shared/extra-utils'
 import { CONSTRAINTS_FIELDS, MIMETYPES, VIDEO_LANGUAGES } from '../../initializers/constants'
 import { exists, isFileValid } from './misc'
 
@@ -11,8 +12,13 @@ const videoCaptionTypesRegex = Object.keys(MIMETYPES.VIDEO_CAPTIONS.MIMETYPE_EXT
                                 .concat([ 'application/octet-stream' ]) // MacOS sends application/octet-stream
                                 .map(m => `(${m})`)
                                 .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)
+function isVideoCaptionFile (files: UploadFilesForCheck, field: string) {
+  return isFileValid({
+    files,
+    mimeTypeRegex: videoCaptionTypesRegex,
+    field,
+    maxSize: CONSTRAINTS_FIELDS.VIDEO_CAPTIONS.CAPTION_FILE.FILE_SIZE.max
+  })
 }
 
 async function isVTTFileValid (filePath: string) {
diff --git a/server/helpers/custom-validators/video-editor.ts b/server/helpers/custom-validators/video-editor.ts
new file mode 100644
index 000000000..09238675e
--- /dev/null
+++ b/server/helpers/custom-validators/video-editor.ts
@@ -0,0 +1,52 @@
+import validator from 'validator'
+import { CONSTRAINTS_FIELDS } from '@server/initializers/constants'
+import { buildTaskFileFieldname } from '@server/lib/video-editor'
+import { VideoEditorTask } from '@shared/models'
+import { isArray } from './misc'
+import { isVideoFileMimeTypeValid, isVideoImageValid } from './videos'
+
+function isValidEditorTasksArray (tasks: any) {
+  if (!isArray(tasks)) return false
+
+  return tasks.length >= CONSTRAINTS_FIELDS.VIDEO_EDITOR.TASKS.min &&
+    tasks.length <= CONSTRAINTS_FIELDS.VIDEO_EDITOR.TASKS.max
+}
+
+function isEditorCutTaskValid (task: VideoEditorTask) {
+  if (task.name !== 'cut') return false
+  if (!task.options) return false
+
+  const { start, end } = task.options
+  if (!start && !end) return false
+
+  if (start && !validator.isInt(start + '', CONSTRAINTS_FIELDS.VIDEO_EDITOR.CUT_TIME)) return false
+  if (end && !validator.isInt(end + '', CONSTRAINTS_FIELDS.VIDEO_EDITOR.CUT_TIME)) return false
+
+  if (!start || !end) return true
+
+  return parseInt(start + '') < parseInt(end + '')
+}
+
+function isEditorTaskAddIntroOutroValid (task: VideoEditorTask, indice: number, files: Express.Multer.File[]) {
+  const file = files.find(f => f.fieldname === buildTaskFileFieldname(indice, 'file'))
+
+  return (task.name === 'add-intro' || task.name === 'add-outro') &&
+    file && isVideoFileMimeTypeValid([ file ], null)
+}
+
+function isEditorTaskAddWatermarkValid (task: VideoEditorTask, indice: number, files: Express.Multer.File[]) {
+  const file = files.find(f => f.fieldname === buildTaskFileFieldname(indice, 'file'))
+
+  return task.name === 'add-watermark' &&
+    file && isVideoImageValid([ file ], null, true)
+}
+
+// ---------------------------------------------------------------------------
+
+export {
+  isValidEditorTasksArray,
+
+  isEditorCutTaskValid,
+  isEditorTaskAddIntroOutroValid,
+  isEditorTaskAddWatermarkValid
+}
diff --git a/server/helpers/custom-validators/video-imports.ts b/server/helpers/custom-validators/video-imports.ts
index dbf6a3504..af93aea56 100644
--- a/server/helpers/custom-validators/video-imports.ts
+++ b/server/helpers/custom-validators/video-imports.ts
@@ -1,4 +1,5 @@
 import 'multer'
+import { UploadFilesForCheck } from 'express'
 import validator from 'validator'
 import { CONSTRAINTS_FIELDS, MIMETYPES, VIDEO_IMPORT_STATES } from '../../initializers/constants'
 import { exists, isFileValid } from './misc'
@@ -25,8 +26,14 @@ 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)
+function isVideoImportTorrentFile (files: UploadFilesForCheck) {
+  return isFileValid({
+    files,
+    mimeTypeRegex: videoTorrentImportRegex,
+    field: 'torrentfile',
+    maxSize: CONSTRAINTS_FIELDS.VIDEO_IMPORTS.TORRENT_FILE.FILE_SIZE.max,
+    optional: true
+  })
 }
 
 // ---------------------------------------------------------------------------
diff --git a/server/helpers/custom-validators/videos.ts b/server/helpers/custom-validators/videos.ts
index e526c4284..ca5f70fdc 100644
--- a/server/helpers/custom-validators/videos.ts
+++ b/server/helpers/custom-validators/videos.ts
@@ -13,7 +13,7 @@ import {
   VIDEO_RATE_TYPES,
   VIDEO_STATES
 } from '../../initializers/constants'
-import { exists, isArray, isDateValid, isFileMimeTypeValid, isFileValid } from './misc'
+import { exists, isArray, isDateValid, isFileValid } from './misc'
 
 const VIDEOS_CONSTRAINTS_FIELDS = CONSTRAINTS_FIELDS.VIDEOS
 
@@ -66,7 +66,7 @@ function isVideoTagValid (tag: string) {
   return exists(tag) && validator.isLength(tag, VIDEOS_CONSTRAINTS_FIELDS.TAG)
 }
 
-function isVideoTagsValid (tags: string[]) {
+function areVideoTagsValid (tags: string[]) {
   return tags === null || (
     isArray(tags) &&
     validator.isInt(tags.length.toString(), VIDEOS_CONSTRAINTS_FIELDS.TAGS) &&
@@ -86,8 +86,13 @@ function isVideoFileExtnameValid (value: string) {
   return exists(value) && (value === VIDEO_LIVE.EXTENSION || MIMETYPES.VIDEO.EXT_MIMETYPE[value] !== undefined)
 }
 
-function isVideoFileMimeTypeValid (files: UploadFilesForCheck) {
-  return isFileMimeTypeValid(files, MIMETYPES.VIDEO.MIMETYPES_REGEX, 'videofile')
+function isVideoFileMimeTypeValid (files: UploadFilesForCheck, field = 'videofile') {
+  return isFileValid({
+    files,
+    mimeTypeRegex: MIMETYPES.VIDEO.MIMETYPES_REGEX,
+    field,
+    maxSize: null
+  })
 }
 
 const videoImageTypes = CONSTRAINTS_FIELDS.VIDEOS.IMAGE.EXTNAME
@@ -95,8 +100,14 @@ const videoImageTypes = CONSTRAINTS_FIELDS.VIDEOS.IMAGE.EXTNAME
                                           .join('|')
 const videoImageTypesRegex = `image/(${videoImageTypes})`
 
-function isVideoImage (files: { [ fieldname: string ]: Express.Multer.File[] } | Express.Multer.File[], field: string) {
-  return isFileValid(files, videoImageTypesRegex, field, CONSTRAINTS_FIELDS.VIDEOS.IMAGE.FILE_SIZE.max, true)
+function isVideoImageValid (files: UploadFilesForCheck, field: string, optional = true) {
+  return isFileValid({
+    files,
+    mimeTypeRegex: videoImageTypesRegex,
+    field,
+    maxSize: CONSTRAINTS_FIELDS.VIDEOS.IMAGE.FILE_SIZE.max,
+    optional
+  })
 }
 
 function isVideoPrivacyValid (value: number) {
@@ -144,7 +155,7 @@ export {
   isVideoDescriptionValid,
   isVideoFileInfoHashValid,
   isVideoNameValid,
-  isVideoTagsValid,
+  areVideoTagsValid,
   isVideoFPSResolutionValid,
   isScheduleVideoUpdatePrivacyValid,
   isVideoOriginallyPublishedAtValid,
@@ -160,7 +171,7 @@ export {
   isVideoPrivacyValid,
   isVideoFileResolutionValid,
   isVideoFileSizeValid,
-  isVideoImage,
+  isVideoImageValid,
   isVideoSupportValid,
   isVideoFilterValid
 }
diff --git a/server/helpers/express-utils.ts b/server/helpers/express-utils.ts
index 780fd6345..82dd4c178 100644
--- a/server/helpers/express-utils.ts
+++ b/server/helpers/express-utils.ts
@@ -1,9 +1,9 @@
 import express, { RequestHandler } from 'express'
 import multer, { diskStorage } from 'multer'
+import { getLowercaseExtension } from '@shared/core-utils'
 import { HttpStatusCode } from '../../shared/models/http/http-error-codes'
 import { CONFIG } from '../initializers/config'
 import { REMOTE_SCHEME } from '../initializers/constants'
-import { getLowercaseExtension } from '@shared/core-utils'
 import { isArray } from './custom-validators/misc'
 import { logger } from './logger'
 import { deleteFileAndCatch, generateRandomString } from './utils'
@@ -68,36 +68,15 @@ function badRequest (_req: express.Request, res: express.Response) {
 function createReqFiles (
   fieldNames: string[],
   mimeTypes: { [id: string]: string | string[] },
-  destinations: { [fieldName: string]: string }
+  destination = CONFIG.STORAGE.TMP_DIR
 ): RequestHandler {
   const storage = diskStorage({
     destination: (req, file, cb) => {
-      cb(null, destinations[file.fieldname])
+      cb(null, destination)
     },
 
-    filename: async (req, file, cb) => {
-      let extension: string
-      const fileExtension = getLowercaseExtension(file.originalname)
-      const extensionFromMimetype = getExtFromMimetype(mimeTypes, file.mimetype)
-
-      // Take the file extension if we don't understand the mime type
-      if (!extensionFromMimetype) {
-        extension = fileExtension
-      } else {
-        // Take the first available extension for this mimetype
-        extension = extensionFromMimetype
-      }
-
-      let randomString = ''
-
-      try {
-        randomString = await generateRandomString(16)
-      } catch (err) {
-        logger.error('Cannot generate random string for file name.', { err })
-        randomString = 'fake-random-string'
-      }
-
-      cb(null, randomString + extension)
+    filename: (req, file, cb) => {
+      return generateReqFilename(file, mimeTypes, cb)
     }
   })
 
@@ -112,6 +91,23 @@ function createReqFiles (
   return multer({ storage }).fields(fields)
 }
 
+function createAnyReqFiles (
+  mimeTypes: { [id: string]: string | string[] },
+  fileFilter: (req: express.Request, file: Express.Multer.File, cb: (err: Error, result: boolean) => void) => void
+): RequestHandler {
+  const storage = diskStorage({
+    destination: (req, file, cb) => {
+      cb(null, CONFIG.STORAGE.TMP_DIR)
+    },
+
+    filename: (req, file, cb) => {
+      return generateReqFilename(file, mimeTypes, cb)
+    }
+  })
+
+  return multer({ storage, fileFilter }).any()
+}
+
 function isUserAbleToSearchRemoteURI (res: express.Response) {
   const user = res.locals.oauth ? res.locals.oauth.token.User : undefined
 
@@ -128,9 +124,41 @@ function getCountVideos (req: express.Request) {
 export {
   buildNSFWFilter,
   getHostWithPort,
+  createAnyReqFiles,
   isUserAbleToSearchRemoteURI,
   badRequest,
   createReqFiles,
   cleanUpReqFiles,
   getCountVideos
 }
+
+// ---------------------------------------------------------------------------
+
+async function generateReqFilename (
+  file: Express.Multer.File,
+  mimeTypes: { [id: string]: string | string[] },
+  cb: (err: Error, name: string) => void
+) {
+  let extension: string
+  const fileExtension = getLowercaseExtension(file.originalname)
+  const extensionFromMimetype = getExtFromMimetype(mimeTypes, file.mimetype)
+
+  // Take the file extension if we don't understand the mime type
+  if (!extensionFromMimetype) {
+    extension = fileExtension
+  } else {
+    // Take the first available extension for this mimetype
+    extension = extensionFromMimetype
+  }
+
+  let randomString = ''
+
+  try {
+    randomString = await generateRandomString(16)
+  } catch (err) {
+    logger.error('Cannot generate random string for file name.', { err })
+    randomString = 'fake-random-string'
+  }
+
+  cb(null, randomString + extension)
+}
diff --git a/server/helpers/ffmpeg-utils.ts b/server/helpers/ffmpeg-utils.ts
deleted file mode 100644
index 78ee5fa7f..000000000
--- a/server/helpers/ffmpeg-utils.ts
+++ /dev/null
@@ -1,781 +0,0 @@
-import { Job } from 'bull'
-import ffmpeg, { FfmpegCommand, FilterSpecification, getAvailableEncoders } from 'fluent-ffmpeg'
-import { readFile, remove, writeFile } from 'fs-extra'
-import { dirname, join } from 'path'
-import { FFMPEG_NICE, VIDEO_LIVE } from '@server/initializers/constants'
-import { pick } from '@shared/core-utils'
-import {
-  AvailableEncoders,
-  EncoderOptions,
-  EncoderOptionsBuilder,
-  EncoderOptionsBuilderParams,
-  EncoderProfile,
-  VideoResolution
-} from '../../shared/models/videos'
-import { CONFIG } from '../initializers/config'
-import { execPromise, promisify0 } from './core-utils'
-import { computeFPS, ffprobePromise, getAudioStream, getVideoFileBitrate, getVideoFileFPS, getVideoFileResolution } from './ffprobe-utils'
-import { processImage } from './image-utils'
-import { logger, loggerTagsFactory } from './logger'
-
-const lTags = loggerTagsFactory('ffmpeg')
-
-/**
- *
- * Functions that run transcoding/muxing ffmpeg processes
- * Mainly called by lib/video-transcoding.ts and lib/live-manager.ts
- *
- */
-
-// ---------------------------------------------------------------------------
-// Encoder options
-// ---------------------------------------------------------------------------
-
-type StreamType = 'audio' | 'video'
-
-// ---------------------------------------------------------------------------
-// Encoders support
-// ---------------------------------------------------------------------------
-
-// Detect supported encoders by ffmpeg
-let supportedEncoders: Map<string, boolean>
-async function checkFFmpegEncoders (peertubeAvailableEncoders: AvailableEncoders): Promise<Map<string, boolean>> {
-  if (supportedEncoders !== undefined) {
-    return supportedEncoders
-  }
-
-  const getAvailableEncodersPromise = promisify0(getAvailableEncoders)
-  const availableFFmpegEncoders = await getAvailableEncodersPromise()
-
-  const searchEncoders = new Set<string>()
-  for (const type of [ 'live', 'vod' ]) {
-    for (const streamType of [ 'audio', 'video' ]) {
-      for (const encoder of peertubeAvailableEncoders.encodersToTry[type][streamType]) {
-        searchEncoders.add(encoder)
-      }
-    }
-  }
-
-  supportedEncoders = new Map<string, boolean>()
-
-  for (const searchEncoder of searchEncoders) {
-    supportedEncoders.set(searchEncoder, availableFFmpegEncoders[searchEncoder] !== undefined)
-  }
-
-  logger.info('Built supported ffmpeg encoders.', { supportedEncoders, searchEncoders, ...lTags() })
-
-  return supportedEncoders
-}
-
-function resetSupportedEncoders () {
-  supportedEncoders = undefined
-}
-
-// ---------------------------------------------------------------------------
-// Image manipulation
-// ---------------------------------------------------------------------------
-
-function convertWebPToJPG (path: string, destination: string): Promise<void> {
-  const command = ffmpeg(path, { niceness: FFMPEG_NICE.THUMBNAIL })
-    .output(destination)
-
-  return runCommand({ command, silent: true })
-}
-
-function processGIF (
-  path: string,
-  destination: string,
-  newSize: { width: number, height: number }
-): Promise<void> {
-  const command = ffmpeg(path, { niceness: FFMPEG_NICE.THUMBNAIL })
-    .fps(20)
-    .size(`${newSize.width}x${newSize.height}`)
-    .output(destination)
-
-  return runCommand({ command })
-}
-
-async function generateImageFromVideoFile (fromPath: string, folder: string, imageName: string, size: { width: number, height: number }) {
-  const pendingImageName = 'pending-' + imageName
-
-  const options = {
-    filename: pendingImageName,
-    count: 1,
-    folder
-  }
-
-  const pendingImagePath = join(folder, pendingImageName)
-
-  try {
-    await new Promise<string>((res, rej) => {
-      ffmpeg(fromPath, { niceness: FFMPEG_NICE.THUMBNAIL })
-        .on('error', rej)
-        .on('end', () => res(imageName))
-        .thumbnail(options)
-    })
-
-    const destination = join(folder, imageName)
-    await processImage(pendingImagePath, destination, size)
-  } catch (err) {
-    logger.error('Cannot generate image from video %s.', fromPath, { err, ...lTags() })
-
-    try {
-      await remove(pendingImagePath)
-    } catch (err) {
-      logger.debug('Cannot remove pending image path after generation error.', { err, ...lTags() })
-    }
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Transcode meta function
-// ---------------------------------------------------------------------------
-
-type TranscodeOptionsType = 'hls' | 'hls-from-ts' | 'quick-transcode' | 'video' | 'merge-audio' | 'only-audio'
-
-interface BaseTranscodeOptions {
-  type: TranscodeOptionsType
-
-  inputPath: string
-  outputPath: string
-
-  availableEncoders: AvailableEncoders
-  profile: string
-
-  resolution: number
-
-  isPortraitMode?: boolean
-
-  job?: Job
-}
-
-interface HLSTranscodeOptions extends BaseTranscodeOptions {
-  type: 'hls'
-  copyCodecs: boolean
-  hlsPlaylist: {
-    videoFilename: string
-  }
-}
-
-interface HLSFromTSTranscodeOptions extends BaseTranscodeOptions {
-  type: 'hls-from-ts'
-
-  isAAC: boolean
-
-  hlsPlaylist: {
-    videoFilename: string
-  }
-}
-
-interface QuickTranscodeOptions extends BaseTranscodeOptions {
-  type: 'quick-transcode'
-}
-
-interface VideoTranscodeOptions extends BaseTranscodeOptions {
-  type: 'video'
-}
-
-interface MergeAudioTranscodeOptions extends BaseTranscodeOptions {
-  type: 'merge-audio'
-  audioPath: string
-}
-
-interface OnlyAudioTranscodeOptions extends BaseTranscodeOptions {
-  type: 'only-audio'
-}
-
-type TranscodeOptions =
-  HLSTranscodeOptions
-  | HLSFromTSTranscodeOptions
-  | VideoTranscodeOptions
-  | MergeAudioTranscodeOptions
-  | OnlyAudioTranscodeOptions
-  | QuickTranscodeOptions
-
-const builders: {
-  [ type in TranscodeOptionsType ]: (c: FfmpegCommand, o?: TranscodeOptions) => Promise<FfmpegCommand> | FfmpegCommand
-} = {
-  'quick-transcode': buildQuickTranscodeCommand,
-  'hls': buildHLSVODCommand,
-  'hls-from-ts': buildHLSVODFromTSCommand,
-  'merge-audio': buildAudioMergeCommand,
-  'only-audio': buildOnlyAudioCommand,
-  'video': buildx264VODCommand
-}
-
-async function transcode (options: TranscodeOptions) {
-  logger.debug('Will run transcode.', { options, ...lTags() })
-
-  let command = getFFmpeg(options.inputPath, 'vod')
-    .output(options.outputPath)
-
-  command = await builders[options.type](command, options)
-
-  await runCommand({ command, job: options.job })
-
-  await fixHLSPlaylistIfNeeded(options)
-}
-
-// ---------------------------------------------------------------------------
-// Live muxing/transcoding functions
-// ---------------------------------------------------------------------------
-
-async function getLiveTranscodingCommand (options: {
-  inputUrl: string
-
-  outPath: string
-  masterPlaylistName: string
-
-  resolutions: number[]
-
-  // Input information
-  fps: number
-  bitrate: number
-  ratio: number
-
-  availableEncoders: AvailableEncoders
-  profile: string
-}) {
-  const { inputUrl, outPath, resolutions, fps, bitrate, availableEncoders, profile, masterPlaylistName, ratio } = options
-
-  const command = getFFmpeg(inputUrl, 'live')
-
-  const varStreamMap: string[] = []
-
-  const complexFilter: FilterSpecification[] = [
-    {
-      inputs: '[v:0]',
-      filter: 'split',
-      options: resolutions.length,
-      outputs: resolutions.map(r => `vtemp${r}`)
-    }
-  ]
-
-  command.outputOption('-sc_threshold 0')
-
-  addDefaultEncoderGlobalParams({ command })
-
-  for (let i = 0; i < resolutions.length; i++) {
-    const resolution = resolutions[i]
-    const resolutionFPS = computeFPS(fps, resolution)
-
-    const baseEncoderBuilderParams = {
-      input: inputUrl,
-
-      availableEncoders,
-      profile,
-
-      inputBitrate: bitrate,
-      inputRatio: ratio,
-
-      resolution,
-      fps: resolutionFPS,
-
-      streamNum: i,
-      videoType: 'live' as 'live'
-    }
-
-    {
-      const streamType: StreamType = 'video'
-      const builderResult = await getEncoderBuilderResult({ ...baseEncoderBuilderParams, streamType })
-      if (!builderResult) {
-        throw new Error('No available live video encoder found')
-      }
-
-      command.outputOption(`-map [vout${resolution}]`)
-
-      addDefaultEncoderParams({ command, encoder: builderResult.encoder, fps: resolutionFPS, streamNum: i })
-
-      logger.debug(
-        'Apply ffmpeg live video params from %s using %s profile.', builderResult.encoder, profile,
-        { builderResult, fps: resolutionFPS, resolution, ...lTags() }
-      )
-
-      command.outputOption(`${buildStreamSuffix('-c:v', i)} ${builderResult.encoder}`)
-      applyEncoderOptions(command, builderResult.result)
-
-      complexFilter.push({
-        inputs: `vtemp${resolution}`,
-        filter: getScaleFilter(builderResult.result),
-        options: `w=-2:h=${resolution}`,
-        outputs: `vout${resolution}`
-      })
-    }
-
-    {
-      const streamType: StreamType = 'audio'
-      const builderResult = await getEncoderBuilderResult({ ...baseEncoderBuilderParams, streamType })
-      if (!builderResult) {
-        throw new Error('No available live audio encoder found')
-      }
-
-      command.outputOption('-map a:0')
-
-      addDefaultEncoderParams({ command, encoder: builderResult.encoder, fps: resolutionFPS, streamNum: i })
-
-      logger.debug(
-        'Apply ffmpeg live audio params from %s using %s profile.', builderResult.encoder, profile,
-        { builderResult, fps: resolutionFPS, resolution, ...lTags() }
-      )
-
-      command.outputOption(`${buildStreamSuffix('-c:a', i)} ${builderResult.encoder}`)
-      applyEncoderOptions(command, builderResult.result)
-    }
-
-    varStreamMap.push(`v:${i},a:${i}`)
-  }
-
-  command.complexFilter(complexFilter)
-
-  addDefaultLiveHLSParams(command, outPath, masterPlaylistName)
-
-  command.outputOption('-var_stream_map', varStreamMap.join(' '))
-
-  return command
-}
-
-function getLiveMuxingCommand (inputUrl: string, outPath: string, masterPlaylistName: string) {
-  const command = getFFmpeg(inputUrl, 'live')
-
-  command.outputOption('-c:v copy')
-  command.outputOption('-c:a copy')
-  command.outputOption('-map 0:a?')
-  command.outputOption('-map 0:v?')
-
-  addDefaultLiveHLSParams(command, outPath, masterPlaylistName)
-
-  return command
-}
-
-function buildStreamSuffix (base: string, streamNum?: number) {
-  if (streamNum !== undefined) {
-    return `${base}:${streamNum}`
-  }
-
-  return base
-}
-
-// ---------------------------------------------------------------------------
-// Default options
-// ---------------------------------------------------------------------------
-
-function addDefaultEncoderGlobalParams (options: {
-  command: FfmpegCommand
-}) {
-  const { command } = options
-
-  // avoid issues when transcoding some files: https://trac.ffmpeg.org/ticket/6375
-  command.outputOption('-max_muxing_queue_size 1024')
-         // strip all metadata
-         .outputOption('-map_metadata -1')
-         // allows import of source material with incompatible pixel formats (e.g. MJPEG video)
-         .outputOption('-pix_fmt yuv420p')
-}
-
-function addDefaultEncoderParams (options: {
-  command: FfmpegCommand
-  encoder: 'libx264' | string
-  streamNum?: number
-  fps?: number
-}) {
-  const { command, encoder, fps, streamNum } = options
-
-  if (encoder === 'libx264') {
-    // 3.1 is the minimal resource allocation for our highest supported resolution
-    command.outputOption(buildStreamSuffix('-level:v', streamNum) + ' 3.1')
-
-    if (fps) {
-      // 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
-      command.outputOption(buildStreamSuffix('-g:v', streamNum) + ' ' + (fps * 2))
-    }
-  }
-}
-
-function addDefaultLiveHLSParams (command: FfmpegCommand, outPath: string, masterPlaylistName: string) {
-  command.outputOption('-hls_time ' + VIDEO_LIVE.SEGMENT_TIME_SECONDS)
-  command.outputOption('-hls_list_size ' + VIDEO_LIVE.SEGMENTS_LIST_SIZE)
-  command.outputOption('-hls_flags delete_segments+independent_segments')
-  command.outputOption(`-hls_segment_filename ${join(outPath, '%v-%06d.ts')}`)
-  command.outputOption('-master_pl_name ' + masterPlaylistName)
-  command.outputOption(`-f hls`)
-
-  command.output(join(outPath, '%v.m3u8'))
-}
-
-// ---------------------------------------------------------------------------
-// Transcode VOD command builders
-// ---------------------------------------------------------------------------
-
-async function buildx264VODCommand (command: FfmpegCommand, options: TranscodeOptions) {
-  let fps = await getVideoFileFPS(options.inputPath)
-  fps = computeFPS(fps, options.resolution)
-
-  let scaleFilterValue: string
-
-  if (options.resolution !== undefined) {
-    scaleFilterValue = options.isPortraitMode === true
-      ? `w=${options.resolution}:h=-2`
-      : `w=-2:h=${options.resolution}`
-  }
-
-  command = await presetVideo({ command, input: options.inputPath, transcodeOptions: options, fps, scaleFilterValue })
-
-  return command
-}
-
-async function buildAudioMergeCommand (command: FfmpegCommand, options: MergeAudioTranscodeOptions) {
-  command = command.loop(undefined)
-
-  const scaleFilterValue = getScaleCleanerValue()
-  command = await presetVideo({ command, input: options.audioPath, transcodeOptions: options, scaleFilterValue })
-
-  command.outputOption('-preset:v veryfast')
-
-  command = command.input(options.audioPath)
-                   .outputOption('-tune stillimage')
-                   .outputOption('-shortest')
-
-  return command
-}
-
-function buildOnlyAudioCommand (command: FfmpegCommand, _options: OnlyAudioTranscodeOptions) {
-  command = presetOnlyAudio(command)
-
-  return command
-}
-
-function buildQuickTranscodeCommand (command: FfmpegCommand) {
-  command = presetCopy(command)
-
-  command = command.outputOption('-map_metadata -1') // strip all metadata
-                   .outputOption('-movflags faststart')
-
-  return command
-}
-
-function addCommonHLSVODCommandOptions (command: FfmpegCommand, outputPath: string) {
-  return command.outputOption('-hls_time 4')
-                .outputOption('-hls_list_size 0')
-                .outputOption('-hls_playlist_type vod')
-                .outputOption('-hls_segment_filename ' + outputPath)
-                .outputOption('-hls_segment_type fmp4')
-                .outputOption('-f hls')
-                .outputOption('-hls_flags single_file')
-}
-
-async function buildHLSVODCommand (command: FfmpegCommand, options: HLSTranscodeOptions) {
-  const videoPath = getHLSVideoPath(options)
-
-  if (options.copyCodecs) command = presetCopy(command)
-  else if (options.resolution === VideoResolution.H_NOVIDEO) command = presetOnlyAudio(command)
-  else command = await buildx264VODCommand(command, options)
-
-  addCommonHLSVODCommandOptions(command, videoPath)
-
-  return command
-}
-
-function buildHLSVODFromTSCommand (command: FfmpegCommand, options: HLSFromTSTranscodeOptions) {
-  const videoPath = getHLSVideoPath(options)
-
-  command.outputOption('-c copy')
-
-  if (options.isAAC) {
-    // Required for example when copying an AAC stream from an MPEG-TS
-    // Since it's a bitstream filter, we don't need to reencode the audio
-    command.outputOption('-bsf:a aac_adtstoasc')
-  }
-
-  addCommonHLSVODCommandOptions(command, videoPath)
-
-  return command
-}
-
-async function fixHLSPlaylistIfNeeded (options: TranscodeOptions) {
-  if (options.type !== 'hls' && options.type !== 'hls-from-ts') return
-
-  const fileContent = await readFile(options.outputPath)
-
-  const videoFileName = options.hlsPlaylist.videoFilename
-  const videoFilePath = getHLSVideoPath(options)
-
-  // Fix wrong mapping with some ffmpeg versions
-  const newContent = fileContent.toString()
-                                .replace(`#EXT-X-MAP:URI="${videoFilePath}",`, `#EXT-X-MAP:URI="${videoFileName}",`)
-
-  await writeFile(options.outputPath, newContent)
-}
-
-function getHLSVideoPath (options: HLSTranscodeOptions | HLSFromTSTranscodeOptions) {
-  return `${dirname(options.outputPath)}/${options.hlsPlaylist.videoFilename}`
-}
-
-// ---------------------------------------------------------------------------
-// Transcoding presets
-// ---------------------------------------------------------------------------
-
-// Run encoder builder depending on available encoders
-// Try encoders by priority: if the encoder is available, run the chosen profile or fallback to the default one
-// If the default one does not exist, check the next encoder
-async function getEncoderBuilderResult (options: EncoderOptionsBuilderParams & {
-  streamType: 'video' | 'audio'
-  input: string
-
-  availableEncoders: AvailableEncoders
-  profile: string
-
-  videoType: 'vod' | 'live'
-}) {
-  const { availableEncoders, profile, streamType, videoType } = options
-
-  const encodersToTry = availableEncoders.encodersToTry[videoType][streamType]
-  const encoders = availableEncoders.available[videoType]
-
-  for (const encoder of encodersToTry) {
-    if (!(await checkFFmpegEncoders(availableEncoders)).get(encoder)) {
-      logger.debug('Encoder %s not available in ffmpeg, skipping.', encoder, lTags())
-      continue
-    }
-
-    if (!encoders[encoder]) {
-      logger.debug('Encoder %s not available in peertube encoders, skipping.', encoder, lTags())
-      continue
-    }
-
-    // An object containing available profiles for this encoder
-    const builderProfiles: EncoderProfile<EncoderOptionsBuilder> = encoders[encoder]
-    let builder = builderProfiles[profile]
-
-    if (!builder) {
-      logger.debug('Profile %s for encoder %s not available. Fallback to default.', profile, encoder, lTags())
-      builder = builderProfiles.default
-
-      if (!builder) {
-        logger.debug('Default profile for encoder %s not available. Try next available encoder.', encoder, lTags())
-        continue
-      }
-    }
-
-    const result = await builder(pick(options, [ 'input', 'resolution', 'inputBitrate', 'fps', 'inputRatio', 'streamNum' ]))
-
-    return {
-      result,
-
-      // If we don't have output options, then copy the input stream
-      encoder: result.copy === true
-        ? 'copy'
-        : encoder
-    }
-  }
-
-  return null
-}
-
-async function presetVideo (options: {
-  command: FfmpegCommand
-  input: string
-  transcodeOptions: TranscodeOptions
-  fps?: number
-  scaleFilterValue?: string
-}) {
-  const { command, input, transcodeOptions, fps, scaleFilterValue } = options
-
-  let localCommand = command
-    .format('mp4')
-    .outputOption('-movflags faststart')
-
-  addDefaultEncoderGlobalParams({ command })
-
-  const probe = await ffprobePromise(input)
-
-  // Audio encoder
-  const parsedAudio = await getAudioStream(input, probe)
-  const bitrate = await getVideoFileBitrate(input, probe)
-  const { ratio } = await getVideoFileResolution(input, probe)
-
-  let streamsToProcess: StreamType[] = [ 'audio', 'video' ]
-
-  if (!parsedAudio.audioStream) {
-    localCommand = localCommand.noAudio()
-    streamsToProcess = [ 'video' ]
-  }
-
-  for (const streamType of streamsToProcess) {
-    const { profile, resolution, availableEncoders } = transcodeOptions
-
-    const builderResult = await getEncoderBuilderResult({
-      streamType,
-      input,
-      resolution,
-      availableEncoders,
-      profile,
-      fps,
-      inputBitrate: bitrate,
-      inputRatio: ratio,
-      videoType: 'vod' as 'vod'
-    })
-
-    if (!builderResult) {
-      throw new Error('No available encoder found for stream ' + streamType)
-    }
-
-    logger.debug(
-      'Apply ffmpeg params from %s for %s stream of input %s using %s profile.',
-      builderResult.encoder, streamType, input, profile,
-      { builderResult, resolution, fps, ...lTags() }
-    )
-
-    if (streamType === 'video') {
-      localCommand.videoCodec(builderResult.encoder)
-
-      if (scaleFilterValue) {
-        localCommand.outputOption(`-vf ${getScaleFilter(builderResult.result)}=${scaleFilterValue}`)
-      }
-    } else if (streamType === 'audio') {
-      localCommand.audioCodec(builderResult.encoder)
-    }
-
-    applyEncoderOptions(localCommand, builderResult.result)
-    addDefaultEncoderParams({ command: localCommand, encoder: builderResult.encoder, fps })
-  }
-
-  return localCommand
-}
-
-function presetCopy (command: FfmpegCommand): FfmpegCommand {
-  return command
-    .format('mp4')
-    .videoCodec('copy')
-    .audioCodec('copy')
-}
-
-function presetOnlyAudio (command: FfmpegCommand): FfmpegCommand {
-  return command
-    .format('mp4')
-    .audioCodec('copy')
-    .noVideo()
-}
-
-function applyEncoderOptions (command: FfmpegCommand, options: EncoderOptions): FfmpegCommand {
-  return command
-    .inputOptions(options.inputOptions ?? [])
-    .outputOptions(options.outputOptions ?? [])
-}
-
-function getScaleFilter (options: EncoderOptions): string {
-  if (options.scaleFilter) return options.scaleFilter.name
-
-  return 'scale'
-}
-
-// ---------------------------------------------------------------------------
-// Utils
-// ---------------------------------------------------------------------------
-
-function getFFmpeg (input: string, type: 'live' | 'vod') {
-  // We set cwd explicitly because ffmpeg appears to create temporary files when trancoding which fails in read-only file systems
-  const command = ffmpeg(input, {
-    niceness: type === 'live' ? FFMPEG_NICE.LIVE : FFMPEG_NICE.VOD,
-    cwd: CONFIG.STORAGE.TMP_DIR
-  })
-
-  const threads = type === 'live'
-    ? CONFIG.LIVE.TRANSCODING.THREADS
-    : CONFIG.TRANSCODING.THREADS
-
-  if (threads > 0) {
-    // If we don't set any threads ffmpeg will chose automatically
-    command.outputOption('-threads ' + threads)
-  }
-
-  return command
-}
-
-function getFFmpegVersion () {
-  return new Promise<string>((res, rej) => {
-    (ffmpeg() as any)._getFfmpegPath((err, ffmpegPath) => {
-      if (err) return rej(err)
-      if (!ffmpegPath) return rej(new Error('Could not find ffmpeg path'))
-
-      return execPromise(`${ffmpegPath} -version`)
-        .then(stdout => {
-          const parsed = stdout.match(/ffmpeg version .?(\d+\.\d+(\.\d+)?)/)
-          if (!parsed || !parsed[1]) return rej(new Error(`Could not find ffmpeg version in ${stdout}`))
-
-          // Fix ffmpeg version that does not include patch version (4.4 for example)
-          let version = parsed[1]
-          if (version.match(/^\d+\.\d+$/)) {
-            version += '.0'
-          }
-
-          return res(version)
-        })
-        .catch(err => rej(err))
-    })
-  })
-}
-
-async function runCommand (options: {
-  command: FfmpegCommand
-  silent?: boolean // false
-  job?: Job
-}) {
-  const { command, silent = false, job } = options
-
-  return new Promise<void>((res, rej) => {
-    let shellCommand: string
-
-    command.on('start', cmdline => { shellCommand = cmdline })
-
-    command.on('error', (err, stdout, stderr) => {
-      if (silent !== true) logger.error('Error in ffmpeg.', { stdout, stderr, shellCommand, ...lTags() })
-
-      rej(err)
-    })
-
-    command.on('end', (stdout, stderr) => {
-      logger.debug('FFmpeg command ended.', { stdout, stderr, shellCommand, ...lTags() })
-
-      res()
-    })
-
-    if (job) {
-      command.on('progress', progress => {
-        if (!progress.percent) return
-
-        job.progress(Math.round(progress.percent))
-          .catch(err => logger.warn('Cannot set ffmpeg job progress.', { err, ...lTags() }))
-      })
-    }
-
-    command.run()
-  })
-}
-
-// Avoid "height not divisible by 2" error
-function getScaleCleanerValue () {
-  return 'trunc(iw/2)*2:trunc(ih/2)*2'
-}
-
-// ---------------------------------------------------------------------------
-
-export {
-  getLiveTranscodingCommand,
-  getLiveMuxingCommand,
-  buildStreamSuffix,
-  convertWebPToJPG,
-  processGIF,
-  generateImageFromVideoFile,
-  TranscodeOptions,
-  TranscodeOptionsType,
-  transcode,
-  runCommand,
-  getFFmpegVersion,
-
-  resetSupportedEncoders,
-
-  // builders
-  buildx264VODCommand
-}
diff --git a/server/helpers/ffmpeg/ffmpeg-commons.ts b/server/helpers/ffmpeg/ffmpeg-commons.ts
new file mode 100644
index 000000000..ee338889c
--- /dev/null
+++ b/server/helpers/ffmpeg/ffmpeg-commons.ts
@@ -0,0 +1,114 @@
+import { Job } from 'bull'
+import ffmpeg, { FfmpegCommand } from 'fluent-ffmpeg'
+import { execPromise } from '@server/helpers/core-utils'
+import { logger, loggerTagsFactory } from '@server/helpers/logger'
+import { CONFIG } from '@server/initializers/config'
+import { FFMPEG_NICE } from '@server/initializers/constants'
+import { EncoderOptions } from '@shared/models'
+
+const lTags = loggerTagsFactory('ffmpeg')
+
+type StreamType = 'audio' | 'video'
+
+function getFFmpeg (input: string, type: 'live' | 'vod') {
+  // We set cwd explicitly because ffmpeg appears to create temporary files when trancoding which fails in read-only file systems
+  const command = ffmpeg(input, {
+    niceness: type === 'live' ? FFMPEG_NICE.LIVE : FFMPEG_NICE.VOD,
+    cwd: CONFIG.STORAGE.TMP_DIR
+  })
+
+  const threads = type === 'live'
+    ? CONFIG.LIVE.TRANSCODING.THREADS
+    : CONFIG.TRANSCODING.THREADS
+
+  if (threads > 0) {
+    // If we don't set any threads ffmpeg will chose automatically
+    command.outputOption('-threads ' + threads)
+  }
+
+  return command
+}
+
+function getFFmpegVersion () {
+  return new Promise<string>((res, rej) => {
+    (ffmpeg() as any)._getFfmpegPath((err, ffmpegPath) => {
+      if (err) return rej(err)
+      if (!ffmpegPath) return rej(new Error('Could not find ffmpeg path'))
+
+      return execPromise(`${ffmpegPath} -version`)
+        .then(stdout => {
+          const parsed = stdout.match(/ffmpeg version .?(\d+\.\d+(\.\d+)?)/)
+          if (!parsed || !parsed[1]) return rej(new Error(`Could not find ffmpeg version in ${stdout}`))
+
+          // Fix ffmpeg version that does not include patch version (4.4 for example)
+          let version = parsed[1]
+          if (version.match(/^\d+\.\d+$/)) {
+            version += '.0'
+          }
+
+          return res(version)
+        })
+        .catch(err => rej(err))
+    })
+  })
+}
+
+async function runCommand (options: {
+  command: FfmpegCommand
+  silent?: boolean // false by default
+  job?: Job
+}) {
+  const { command, silent = false, job } = options
+
+  return new Promise<void>((res, rej) => {
+    let shellCommand: string
+
+    command.on('start', cmdline => { shellCommand = cmdline })
+
+    command.on('error', (err, stdout, stderr) => {
+      if (silent !== true) logger.error('Error in ffmpeg.', { stdout, stderr, shellCommand, ...lTags() })
+
+      rej(err)
+    })
+
+    command.on('end', (stdout, stderr) => {
+      logger.debug('FFmpeg command ended.', { stdout, stderr, shellCommand, ...lTags() })
+
+      res()
+    })
+
+    if (job) {
+      command.on('progress', progress => {
+        if (!progress.percent) return
+
+        job.progress(Math.round(progress.percent))
+          .catch(err => logger.warn('Cannot set ffmpeg job progress.', { err, ...lTags() }))
+      })
+    }
+
+    command.run()
+  })
+}
+
+function buildStreamSuffix (base: string, streamNum?: number) {
+  if (streamNum !== undefined) {
+    return `${base}:${streamNum}`
+  }
+
+  return base
+}
+
+function getScaleFilter (options: EncoderOptions): string {
+  if (options.scaleFilter) return options.scaleFilter.name
+
+  return 'scale'
+}
+
+export {
+  getFFmpeg,
+  getFFmpegVersion,
+  runCommand,
+  StreamType,
+  buildStreamSuffix,
+  getScaleFilter
+}
diff --git a/server/helpers/ffmpeg/ffmpeg-edition.ts b/server/helpers/ffmpeg/ffmpeg-edition.ts
new file mode 100644
index 000000000..a5baa7ef1
--- /dev/null
+++ b/server/helpers/ffmpeg/ffmpeg-edition.ts
@@ -0,0 +1,242 @@
+import { FilterSpecification } from 'fluent-ffmpeg'
+import { VIDEO_FILTERS } from '@server/initializers/constants'
+import { AvailableEncoders } from '@shared/models'
+import { logger, loggerTagsFactory } from '../logger'
+import { getFFmpeg, runCommand } from './ffmpeg-commons'
+import { presetCopy, presetVOD } from './ffmpeg-presets'
+import { ffprobePromise, getVideoStreamDimensionsInfo, getVideoStreamDuration, getVideoStreamFPS, hasAudioStream } from './ffprobe-utils'
+
+const lTags = loggerTagsFactory('ffmpeg')
+
+async function cutVideo (options: {
+  inputPath: string
+  outputPath: string
+  start?: number
+  end?: number
+}) {
+  const { inputPath, outputPath } = options
+
+  logger.debug('Will cut the video.', { options, ...lTags() })
+
+  let command = getFFmpeg(inputPath, 'vod')
+    .output(outputPath)
+
+  command = presetCopy(command)
+
+  if (options.start) command.inputOption('-ss ' + options.start)
+
+  if (options.end) {
+    const endSeeking = options.end - (options.start || 0)
+
+    command.outputOption('-to ' + endSeeking)
+  }
+
+  await runCommand({ command })
+}
+
+async function addWatermark (options: {
+  inputPath: string
+  watermarkPath: string
+  outputPath: string
+
+  availableEncoders: AvailableEncoders
+  profile: string
+}) {
+  const { watermarkPath, inputPath, outputPath, availableEncoders, profile } = options
+
+  logger.debug('Will add watermark to the video.', { options, ...lTags() })
+
+  const videoProbe = await ffprobePromise(inputPath)
+  const fps = await getVideoStreamFPS(inputPath, videoProbe)
+  const { resolution } = await getVideoStreamDimensionsInfo(inputPath, videoProbe)
+
+  let command = getFFmpeg(inputPath, 'vod')
+    .output(outputPath)
+  command.input(watermarkPath)
+
+  command = await presetVOD({
+    command,
+    input: inputPath,
+    availableEncoders,
+    profile,
+    resolution,
+    fps,
+    canCopyAudio: true,
+    canCopyVideo: false
+  })
+
+  const complexFilter: FilterSpecification[] = [
+    // Scale watermark
+    {
+      inputs: [ '[1]', '[0]' ],
+      filter: 'scale2ref',
+      options: {
+        w: 'oh*mdar',
+        h: `ih*${VIDEO_FILTERS.WATERMARK.SIZE_RATIO}`
+      },
+      outputs: [ '[watermark]', '[video]' ]
+    },
+
+    {
+      inputs: [ '[video]', '[watermark]' ],
+      filter: 'overlay',
+      options: {
+        x: `main_w - overlay_w - (main_h * ${VIDEO_FILTERS.WATERMARK.HORIZONTAL_MARGIN_RATIO})`,
+        y: `main_h * ${VIDEO_FILTERS.WATERMARK.VERTICAL_MARGIN_RATIO}`
+      }
+    }
+  ]
+
+  command.complexFilter(complexFilter)
+
+  await runCommand({ command })
+}
+
+async function addIntroOutro (options: {
+  inputPath: string
+  introOutroPath: string
+  outputPath: string
+  type: 'intro' | 'outro'
+
+  availableEncoders: AvailableEncoders
+  profile: string
+}) {
+  const { introOutroPath, inputPath, outputPath, availableEncoders, profile, type } = options
+
+  logger.debug('Will add intro/outro to the video.', { options, ...lTags() })
+
+  const mainProbe = await ffprobePromise(inputPath)
+  const fps = await getVideoStreamFPS(inputPath, mainProbe)
+  const { resolution } = await getVideoStreamDimensionsInfo(inputPath, mainProbe)
+  const mainHasAudio = await hasAudioStream(inputPath, mainProbe)
+
+  const introOutroProbe = await ffprobePromise(introOutroPath)
+  const introOutroHasAudio = await hasAudioStream(introOutroPath, introOutroProbe)
+
+  let command = getFFmpeg(inputPath, 'vod')
+    .output(outputPath)
+
+  command.input(introOutroPath)
+
+  if (!introOutroHasAudio && mainHasAudio) {
+    const duration = await getVideoStreamDuration(introOutroPath, introOutroProbe)
+
+    command.input('anullsrc')
+    command.withInputFormat('lavfi')
+    command.withInputOption('-t ' + duration)
+  }
+
+  command = await presetVOD({
+    command,
+    input: inputPath,
+    availableEncoders,
+    profile,
+    resolution,
+    fps,
+    canCopyAudio: false,
+    canCopyVideo: false
+  })
+
+  // Add black background to correctly scale intro/outro with padding
+  const complexFilter: FilterSpecification[] = [
+    {
+      inputs: [ '1', '0' ],
+      filter: 'scale2ref',
+      options: {
+        w: 'iw',
+        h: `ih`
+      },
+      outputs: [ 'intro-outro', 'main' ]
+    },
+    {
+      inputs: [ 'intro-outro', 'main' ],
+      filter: 'scale2ref',
+      options: {
+        w: 'iw',
+        h: `ih`
+      },
+      outputs: [ 'to-scale', 'main' ]
+    },
+    {
+      inputs: 'to-scale',
+      filter: 'drawbox',
+      options: {
+        t: 'fill'
+      },
+      outputs: [ 'to-scale-bg' ]
+    },
+    {
+      inputs: [ '1', 'to-scale-bg' ],
+      filter: 'scale2ref',
+      options: {
+        w: 'iw',
+        h: 'ih',
+        force_original_aspect_ratio: 'decrease',
+        flags: 'spline'
+      },
+      outputs: [ 'to-scale', 'to-scale-bg' ]
+    },
+    {
+      inputs: [ 'to-scale-bg', 'to-scale' ],
+      filter: 'overlay',
+      options: {
+        x: '(main_w - overlay_w)/2',
+        y: '(main_h - overlay_h)/2'
+      },
+      outputs: 'intro-outro-resized'
+    }
+  ]
+
+  const concatFilter = {
+    inputs: [],
+    filter: 'concat',
+    options: {
+      n: 2,
+      v: 1,
+      unsafe: 1
+    },
+    outputs: [ 'v' ]
+  }
+
+  const introOutroFilterInputs = [ 'intro-outro-resized' ]
+  const mainFilterInputs = [ 'main' ]
+
+  if (mainHasAudio) {
+    mainFilterInputs.push('0:a')
+
+    if (introOutroHasAudio) {
+      introOutroFilterInputs.push('1:a')
+    } else {
+      // Silent input
+      introOutroFilterInputs.push('2:a')
+    }
+  }
+
+  if (type === 'intro') {
+    concatFilter.inputs = [ ...introOutroFilterInputs, ...mainFilterInputs ]
+  } else {
+    concatFilter.inputs = [ ...mainFilterInputs, ...introOutroFilterInputs ]
+  }
+
+  if (mainHasAudio) {
+    concatFilter.options['a'] = 1
+    concatFilter.outputs.push('a')
+
+    command.outputOption('-map [a]')
+  }
+
+  command.outputOption('-map [v]')
+
+  complexFilter.push(concatFilter)
+  command.complexFilter(complexFilter)
+
+  await runCommand({ command })
+}
+
+// ---------------------------------------------------------------------------
+
+export {
+  cutVideo,
+  addIntroOutro,
+  addWatermark
+}
diff --git a/server/helpers/ffmpeg/ffmpeg-encoders.ts b/server/helpers/ffmpeg/ffmpeg-encoders.ts
new file mode 100644
index 000000000..5bd80ba05
--- /dev/null
+++ b/server/helpers/ffmpeg/ffmpeg-encoders.ts
@@ -0,0 +1,116 @@
+import { getAvailableEncoders } from 'fluent-ffmpeg'
+import { pick } from '@shared/core-utils'
+import { AvailableEncoders, EncoderOptionsBuilder, EncoderOptionsBuilderParams, EncoderProfile } from '@shared/models'
+import { promisify0 } from '../core-utils'
+import { logger, loggerTagsFactory } from '../logger'
+
+const lTags = loggerTagsFactory('ffmpeg')
+
+// Detect supported encoders by ffmpeg
+let supportedEncoders: Map<string, boolean>
+async function checkFFmpegEncoders (peertubeAvailableEncoders: AvailableEncoders): Promise<Map<string, boolean>> {
+  if (supportedEncoders !== undefined) {
+    return supportedEncoders
+  }
+
+  const getAvailableEncodersPromise = promisify0(getAvailableEncoders)
+  const availableFFmpegEncoders = await getAvailableEncodersPromise()
+
+  const searchEncoders = new Set<string>()
+  for (const type of [ 'live', 'vod' ]) {
+    for (const streamType of [ 'audio', 'video' ]) {
+      for (const encoder of peertubeAvailableEncoders.encodersToTry[type][streamType]) {
+        searchEncoders.add(encoder)
+      }
+    }
+  }
+
+  supportedEncoders = new Map<string, boolean>()
+
+  for (const searchEncoder of searchEncoders) {
+    supportedEncoders.set(searchEncoder, availableFFmpegEncoders[searchEncoder] !== undefined)
+  }
+
+  logger.info('Built supported ffmpeg encoders.', { supportedEncoders, searchEncoders, ...lTags() })
+
+  return supportedEncoders
+}
+
+function resetSupportedEncoders () {
+  supportedEncoders = undefined
+}
+
+// Run encoder builder depending on available encoders
+// Try encoders by priority: if the encoder is available, run the chosen profile or fallback to the default one
+// If the default one does not exist, check the next encoder
+async function getEncoderBuilderResult (options: EncoderOptionsBuilderParams & {
+  streamType: 'video' | 'audio'
+  input: string
+
+  availableEncoders: AvailableEncoders
+  profile: string
+
+  videoType: 'vod' | 'live'
+}) {
+  const { availableEncoders, profile, streamType, videoType } = options
+
+  const encodersToTry = availableEncoders.encodersToTry[videoType][streamType]
+  const encoders = availableEncoders.available[videoType]
+
+  for (const encoder of encodersToTry) {
+    if (!(await checkFFmpegEncoders(availableEncoders)).get(encoder)) {
+      logger.debug('Encoder %s not available in ffmpeg, skipping.', encoder, lTags())
+      continue
+    }
+
+    if (!encoders[encoder]) {
+      logger.debug('Encoder %s not available in peertube encoders, skipping.', encoder, lTags())
+      continue
+    }
+
+    // An object containing available profiles for this encoder
+    const builderProfiles: EncoderProfile<EncoderOptionsBuilder> = encoders[encoder]
+    let builder = builderProfiles[profile]
+
+    if (!builder) {
+      logger.debug('Profile %s for encoder %s not available. Fallback to default.', profile, encoder, lTags())
+      builder = builderProfiles.default
+
+      if (!builder) {
+        logger.debug('Default profile for encoder %s not available. Try next available encoder.', encoder, lTags())
+        continue
+      }
+    }
+
+    const result = await builder(
+      pick(options, [
+        'input',
+        'canCopyAudio',
+        'canCopyVideo',
+        'resolution',
+        'inputBitrate',
+        'fps',
+        'inputRatio',
+        'streamNum'
+      ])
+    )
+
+    return {
+      result,
+
+      // If we don't have output options, then copy the input stream
+      encoder: result.copy === true
+        ? 'copy'
+        : encoder
+    }
+  }
+
+  return null
+}
+
+export {
+  checkFFmpegEncoders,
+  resetSupportedEncoders,
+
+  getEncoderBuilderResult
+}
diff --git a/server/helpers/ffmpeg/ffmpeg-images.ts b/server/helpers/ffmpeg/ffmpeg-images.ts
new file mode 100644
index 000000000..7f64c6d0a
--- /dev/null
+++ b/server/helpers/ffmpeg/ffmpeg-images.ts
@@ -0,0 +1,46 @@
+import ffmpeg from 'fluent-ffmpeg'
+import { FFMPEG_NICE } from '@server/initializers/constants'
+import { runCommand } from './ffmpeg-commons'
+
+function convertWebPToJPG (path: string, destination: string): Promise<void> {
+  const command = ffmpeg(path, { niceness: FFMPEG_NICE.THUMBNAIL })
+    .output(destination)
+
+  return runCommand({ command, silent: true })
+}
+
+function processGIF (
+  path: string,
+  destination: string,
+  newSize: { width: number, height: number }
+): Promise<void> {
+  const command = ffmpeg(path, { niceness: FFMPEG_NICE.THUMBNAIL })
+    .fps(20)
+    .size(`${newSize.width}x${newSize.height}`)
+    .output(destination)
+
+  return runCommand({ command })
+}
+
+async function generateThumbnailFromVideo (fromPath: string, folder: string, imageName: string) {
+  const pendingImageName = 'pending-' + imageName
+
+  const options = {
+    filename: pendingImageName,
+    count: 1,
+    folder
+  }
+
+  return new Promise<string>((res, rej) => {
+    ffmpeg(fromPath, { niceness: FFMPEG_NICE.THUMBNAIL })
+      .on('error', rej)
+      .on('end', () => res(imageName))
+      .thumbnail(options)
+  })
+}
+
+export {
+  convertWebPToJPG,
+  processGIF,
+  generateThumbnailFromVideo
+}
diff --git a/server/helpers/ffmpeg/ffmpeg-live.ts b/server/helpers/ffmpeg/ffmpeg-live.ts
new file mode 100644
index 000000000..ff571626c
--- /dev/null
+++ b/server/helpers/ffmpeg/ffmpeg-live.ts
@@ -0,0 +1,161 @@
+import { FfmpegCommand, FilterSpecification } from 'fluent-ffmpeg'
+import { join } from 'path'
+import { VIDEO_LIVE } from '@server/initializers/constants'
+import { AvailableEncoders } from '@shared/models'
+import { logger, loggerTagsFactory } from '../logger'
+import { buildStreamSuffix, getFFmpeg, getScaleFilter, StreamType } from './ffmpeg-commons'
+import { getEncoderBuilderResult } from './ffmpeg-encoders'
+import { addDefaultEncoderGlobalParams, addDefaultEncoderParams, applyEncoderOptions } from './ffmpeg-presets'
+import { computeFPS } from './ffprobe-utils'
+
+const lTags = loggerTagsFactory('ffmpeg')
+
+async function getLiveTranscodingCommand (options: {
+  inputUrl: string
+
+  outPath: string
+  masterPlaylistName: string
+
+  resolutions: number[]
+
+  // Input information
+  fps: number
+  bitrate: number
+  ratio: number
+
+  availableEncoders: AvailableEncoders
+  profile: string
+}) {
+  const { inputUrl, outPath, resolutions, fps, bitrate, availableEncoders, profile, masterPlaylistName, ratio } = options
+
+  const command = getFFmpeg(inputUrl, 'live')
+
+  const varStreamMap: string[] = []
+
+  const complexFilter: FilterSpecification[] = [
+    {
+      inputs: '[v:0]',
+      filter: 'split',
+      options: resolutions.length,
+      outputs: resolutions.map(r => `vtemp${r}`)
+    }
+  ]
+
+  command.outputOption('-sc_threshold 0')
+
+  addDefaultEncoderGlobalParams(command)
+
+  for (let i = 0; i < resolutions.length; i++) {
+    const resolution = resolutions[i]
+    const resolutionFPS = computeFPS(fps, resolution)
+
+    const baseEncoderBuilderParams = {
+      input: inputUrl,
+
+      availableEncoders,
+      profile,
+
+      canCopyAudio: true,
+      canCopyVideo: true,
+
+      inputBitrate: bitrate,
+      inputRatio: ratio,
+
+      resolution,
+      fps: resolutionFPS,
+
+      streamNum: i,
+      videoType: 'live' as 'live'
+    }
+
+    {
+      const streamType: StreamType = 'video'
+      const builderResult = await getEncoderBuilderResult({ ...baseEncoderBuilderParams, streamType })
+      if (!builderResult) {
+        throw new Error('No available live video encoder found')
+      }
+
+      command.outputOption(`-map [vout${resolution}]`)
+
+      addDefaultEncoderParams({ command, encoder: builderResult.encoder, fps: resolutionFPS, streamNum: i })
+
+      logger.debug(
+        'Apply ffmpeg live video params from %s using %s profile.', builderResult.encoder, profile,
+        { builderResult, fps: resolutionFPS, resolution, ...lTags() }
+      )
+
+      command.outputOption(`${buildStreamSuffix('-c:v', i)} ${builderResult.encoder}`)
+      applyEncoderOptions(command, builderResult.result)
+
+      complexFilter.push({
+        inputs: `vtemp${resolution}`,
+        filter: getScaleFilter(builderResult.result),
+        options: `w=-2:h=${resolution}`,
+        outputs: `vout${resolution}`
+      })
+    }
+
+    {
+      const streamType: StreamType = 'audio'
+      const builderResult = await getEncoderBuilderResult({ ...baseEncoderBuilderParams, streamType })
+      if (!builderResult) {
+        throw new Error('No available live audio encoder found')
+      }
+
+      command.outputOption('-map a:0')
+
+      addDefaultEncoderParams({ command, encoder: builderResult.encoder, fps: resolutionFPS, streamNum: i })
+
+      logger.debug(
+        'Apply ffmpeg live audio params from %s using %s profile.', builderResult.encoder, profile,
+        { builderResult, fps: resolutionFPS, resolution, ...lTags() }
+      )
+
+      command.outputOption(`${buildStreamSuffix('-c:a', i)} ${builderResult.encoder}`)
+      applyEncoderOptions(command, builderResult.result)
+    }
+
+    varStreamMap.push(`v:${i},a:${i}`)
+  }
+
+  command.complexFilter(complexFilter)
+
+  addDefaultLiveHLSParams(command, outPath, masterPlaylistName)
+
+  command.outputOption('-var_stream_map', varStreamMap.join(' '))
+
+  return command
+}
+
+function getLiveMuxingCommand (inputUrl: string, outPath: string, masterPlaylistName: string) {
+  const command = getFFmpeg(inputUrl, 'live')
+
+  command.outputOption('-c:v copy')
+  command.outputOption('-c:a copy')
+  command.outputOption('-map 0:a?')
+  command.outputOption('-map 0:v?')
+
+  addDefaultLiveHLSParams(command, outPath, masterPlaylistName)
+
+  return command
+}
+
+// ---------------------------------------------------------------------------
+
+export {
+  getLiveTranscodingCommand,
+  getLiveMuxingCommand
+}
+
+// ---------------------------------------------------------------------------
+
+function addDefaultLiveHLSParams (command: FfmpegCommand, outPath: string, masterPlaylistName: string) {
+  command.outputOption('-hls_time ' + VIDEO_LIVE.SEGMENT_TIME_SECONDS)
+  command.outputOption('-hls_list_size ' + VIDEO_LIVE.SEGMENTS_LIST_SIZE)
+  command.outputOption('-hls_flags delete_segments+independent_segments')
+  command.outputOption(`-hls_segment_filename ${join(outPath, '%v-%06d.ts')}`)
+  command.outputOption('-master_pl_name ' + masterPlaylistName)
+  command.outputOption(`-f hls`)
+
+  command.output(join(outPath, '%v.m3u8'))
+}
diff --git a/server/helpers/ffmpeg/ffmpeg-presets.ts b/server/helpers/ffmpeg/ffmpeg-presets.ts
new file mode 100644
index 000000000..99b39f79a
--- /dev/null
+++ b/server/helpers/ffmpeg/ffmpeg-presets.ts
@@ -0,0 +1,156 @@
+import { FfmpegCommand } from 'fluent-ffmpeg'
+import { pick } from 'lodash'
+import { logger, loggerTagsFactory } from '@server/helpers/logger'
+import { AvailableEncoders, EncoderOptions } from '@shared/models'
+import { buildStreamSuffix, getScaleFilter, StreamType } from './ffmpeg-commons'
+import { getEncoderBuilderResult } from './ffmpeg-encoders'
+import { ffprobePromise, getVideoStreamBitrate, getVideoStreamDimensionsInfo, hasAudioStream } from './ffprobe-utils'
+
+const lTags = loggerTagsFactory('ffmpeg')
+
+// ---------------------------------------------------------------------------
+
+function addDefaultEncoderGlobalParams (command: FfmpegCommand) {
+  // avoid issues when transcoding some files: https://trac.ffmpeg.org/ticket/6375
+  command.outputOption('-max_muxing_queue_size 1024')
+         // strip all metadata
+         .outputOption('-map_metadata -1')
+         // allows import of source material with incompatible pixel formats (e.g. MJPEG video)
+         .outputOption('-pix_fmt yuv420p')
+}
+
+function addDefaultEncoderParams (options: {
+  command: FfmpegCommand
+  encoder: 'libx264' | string
+  fps: number
+
+  streamNum?: number
+}) {
+  const { command, encoder, fps, streamNum } = options
+
+  if (encoder === 'libx264') {
+    // 3.1 is the minimal resource allocation for our highest supported resolution
+    command.outputOption(buildStreamSuffix('-level:v', streamNum) + ' 3.1')
+
+    if (fps) {
+      // 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
+      command.outputOption(buildStreamSuffix('-g:v', streamNum) + ' ' + (fps * 2))
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+
+async function presetVOD (options: {
+  command: FfmpegCommand
+  input: string
+
+  availableEncoders: AvailableEncoders
+  profile: string
+
+  canCopyAudio: boolean
+  canCopyVideo: boolean
+
+  resolution: number
+  fps: number
+
+  scaleFilterValue?: string
+}) {
+  const { command, input, profile, resolution, fps, scaleFilterValue } = options
+
+  let localCommand = command
+    .format('mp4')
+    .outputOption('-movflags faststart')
+
+  addDefaultEncoderGlobalParams(command)
+
+  const probe = await ffprobePromise(input)
+
+  // Audio encoder
+  const bitrate = await getVideoStreamBitrate(input, probe)
+  const videoStreamDimensions = await getVideoStreamDimensionsInfo(input, probe)
+
+  let streamsToProcess: StreamType[] = [ 'audio', 'video' ]
+
+  if (!await hasAudioStream(input, probe)) {
+    localCommand = localCommand.noAudio()
+    streamsToProcess = [ 'video' ]
+  }
+
+  for (const streamType of streamsToProcess) {
+    const builderResult = await getEncoderBuilderResult({
+      ...pick(options, [ 'availableEncoders', 'canCopyAudio', 'canCopyVideo' ]),
+
+      input,
+      inputBitrate: bitrate,
+      inputRatio: videoStreamDimensions?.ratio || 0,
+
+      profile,
+      resolution,
+      fps,
+      streamType,
+
+      videoType: 'vod' as 'vod'
+    })
+
+    if (!builderResult) {
+      throw new Error('No available encoder found for stream ' + streamType)
+    }
+
+    logger.debug(
+      'Apply ffmpeg params from %s for %s stream of input %s using %s profile.',
+      builderResult.encoder, streamType, input, profile,
+      { builderResult, resolution, fps, ...lTags() }
+    )
+
+    if (streamType === 'video') {
+      localCommand.videoCodec(builderResult.encoder)
+
+      if (scaleFilterValue) {
+        localCommand.outputOption(`-vf ${getScaleFilter(builderResult.result)}=${scaleFilterValue}`)
+      }
+    } else if (streamType === 'audio') {
+      localCommand.audioCodec(builderResult.encoder)
+    }
+
+    applyEncoderOptions(localCommand, builderResult.result)
+    addDefaultEncoderParams({ command: localCommand, encoder: builderResult.encoder, fps })
+  }
+
+  return localCommand
+}
+
+function presetCopy (command: FfmpegCommand): FfmpegCommand {
+  return command
+    .format('mp4')
+    .videoCodec('copy')
+    .audioCodec('copy')
+}
+
+function presetOnlyAudio (command: FfmpegCommand): FfmpegCommand {
+  return command
+    .format('mp4')
+    .audioCodec('copy')
+    .noVideo()
+}
+
+function applyEncoderOptions (command: FfmpegCommand, options: EncoderOptions): FfmpegCommand {
+  return command
+    .inputOptions(options.inputOptions ?? [])
+    .outputOptions(options.outputOptions ?? [])
+}
+
+// ---------------------------------------------------------------------------
+
+export {
+  presetVOD,
+  presetCopy,
+  presetOnlyAudio,
+
+  addDefaultEncoderGlobalParams,
+  addDefaultEncoderParams,
+
+  applyEncoderOptions
+}
diff --git a/server/helpers/ffmpeg/ffmpeg-vod.ts b/server/helpers/ffmpeg/ffmpeg-vod.ts
new file mode 100644
index 000000000..c3622ceb1
--- /dev/null
+++ b/server/helpers/ffmpeg/ffmpeg-vod.ts
@@ -0,0 +1,254 @@
+import { Job } from 'bull'
+import { FfmpegCommand } from 'fluent-ffmpeg'
+import { readFile, writeFile } from 'fs-extra'
+import { dirname } from 'path'
+import { pick } from '@shared/core-utils'
+import { AvailableEncoders, VideoResolution } from '@shared/models'
+import { logger, loggerTagsFactory } from '../logger'
+import { getFFmpeg, runCommand } from './ffmpeg-commons'
+import { presetCopy, presetOnlyAudio, presetVOD } from './ffmpeg-presets'
+import { computeFPS, getVideoStreamFPS } from './ffprobe-utils'
+import { VIDEO_TRANSCODING_FPS } from '@server/initializers/constants'
+
+const lTags = loggerTagsFactory('ffmpeg')
+
+// ---------------------------------------------------------------------------
+
+type TranscodeVODOptionsType = 'hls' | 'hls-from-ts' | 'quick-transcode' | 'video' | 'merge-audio' | 'only-audio'
+
+interface BaseTranscodeVODOptions {
+  type: TranscodeVODOptionsType
+
+  inputPath: string
+  outputPath: string
+
+  availableEncoders: AvailableEncoders
+  profile: string
+
+  resolution: number
+
+  isPortraitMode?: boolean
+
+  job?: Job
+}
+
+interface HLSTranscodeOptions extends BaseTranscodeVODOptions {
+  type: 'hls'
+  copyCodecs: boolean
+  hlsPlaylist: {
+    videoFilename: string
+  }
+}
+
+interface HLSFromTSTranscodeOptions extends BaseTranscodeVODOptions {
+  type: 'hls-from-ts'
+
+  isAAC: boolean
+
+  hlsPlaylist: {
+    videoFilename: string
+  }
+}
+
+interface QuickTranscodeOptions extends BaseTranscodeVODOptions {
+  type: 'quick-transcode'
+}
+
+interface VideoTranscodeOptions extends BaseTranscodeVODOptions {
+  type: 'video'
+}
+
+interface MergeAudioTranscodeOptions extends BaseTranscodeVODOptions {
+  type: 'merge-audio'
+  audioPath: string
+}
+
+interface OnlyAudioTranscodeOptions extends BaseTranscodeVODOptions {
+  type: 'only-audio'
+}
+
+type TranscodeVODOptions =
+  HLSTranscodeOptions
+  | HLSFromTSTranscodeOptions
+  | VideoTranscodeOptions
+  | MergeAudioTranscodeOptions
+  | OnlyAudioTranscodeOptions
+  | QuickTranscodeOptions
+
+// ---------------------------------------------------------------------------
+
+const builders: {
+  [ type in TranscodeVODOptionsType ]: (c: FfmpegCommand, o?: TranscodeVODOptions) => Promise<FfmpegCommand> | FfmpegCommand
+} = {
+  'quick-transcode': buildQuickTranscodeCommand,
+  'hls': buildHLSVODCommand,
+  'hls-from-ts': buildHLSVODFromTSCommand,
+  'merge-audio': buildAudioMergeCommand,
+  'only-audio': buildOnlyAudioCommand,
+  'video': buildVODCommand
+}
+
+async function transcodeVOD (options: TranscodeVODOptions) {
+  logger.debug('Will run transcode.', { options, ...lTags() })
+
+  let command = getFFmpeg(options.inputPath, 'vod')
+    .output(options.outputPath)
+
+  command = await builders[options.type](command, options)
+
+  await runCommand({ command, job: options.job })
+
+  await fixHLSPlaylistIfNeeded(options)
+}
+
+// ---------------------------------------------------------------------------
+
+export {
+  transcodeVOD,
+
+  buildVODCommand,
+
+  TranscodeVODOptions,
+  TranscodeVODOptionsType
+}
+
+// ---------------------------------------------------------------------------
+
+async function buildVODCommand (command: FfmpegCommand, options: TranscodeVODOptions) {
+  let fps = await getVideoStreamFPS(options.inputPath)
+  fps = computeFPS(fps, options.resolution)
+
+  let scaleFilterValue: string
+
+  if (options.resolution !== undefined) {
+    scaleFilterValue = options.isPortraitMode === true
+      ? `w=${options.resolution}:h=-2`
+      : `w=-2:h=${options.resolution}`
+  }
+
+  command = await presetVOD({
+    ...pick(options, [ 'resolution', 'availableEncoders', 'profile' ]),
+
+    command,
+    input: options.inputPath,
+    canCopyAudio: true,
+    canCopyVideo: true,
+    fps,
+    scaleFilterValue
+  })
+
+  return command
+}
+
+function buildQuickTranscodeCommand (command: FfmpegCommand) {
+  command = presetCopy(command)
+
+  command = command.outputOption('-map_metadata -1') // strip all metadata
+                   .outputOption('-movflags faststart')
+
+  return command
+}
+
+// ---------------------------------------------------------------------------
+// Audio transcoding
+// ---------------------------------------------------------------------------
+
+async function buildAudioMergeCommand (command: FfmpegCommand, options: MergeAudioTranscodeOptions) {
+  command = command.loop(undefined)
+
+  const scaleFilterValue = getMergeAudioScaleFilterValue()
+  command = await presetVOD({
+    ...pick(options, [ 'resolution', 'availableEncoders', 'profile' ]),
+
+    command,
+    input: options.audioPath,
+    canCopyAudio: true,
+    canCopyVideo: true,
+    fps: VIDEO_TRANSCODING_FPS.AUDIO_MERGE,
+    scaleFilterValue
+  })
+
+  command.outputOption('-preset:v veryfast')
+
+  command = command.input(options.audioPath)
+                   .outputOption('-tune stillimage')
+                   .outputOption('-shortest')
+
+  return command
+}
+
+function buildOnlyAudioCommand (command: FfmpegCommand, _options: OnlyAudioTranscodeOptions) {
+  command = presetOnlyAudio(command)
+
+  return command
+}
+
+// ---------------------------------------------------------------------------
+// HLS transcoding
+// ---------------------------------------------------------------------------
+
+async function buildHLSVODCommand (command: FfmpegCommand, options: HLSTranscodeOptions) {
+  const videoPath = getHLSVideoPath(options)
+
+  if (options.copyCodecs) command = presetCopy(command)
+  else if (options.resolution === VideoResolution.H_NOVIDEO) command = presetOnlyAudio(command)
+  else command = await buildVODCommand(command, options)
+
+  addCommonHLSVODCommandOptions(command, videoPath)
+
+  return command
+}
+
+function buildHLSVODFromTSCommand (command: FfmpegCommand, options: HLSFromTSTranscodeOptions) {
+  const videoPath = getHLSVideoPath(options)
+
+  command.outputOption('-c copy')
+
+  if (options.isAAC) {
+    // Required for example when copying an AAC stream from an MPEG-TS
+    // Since it's a bitstream filter, we don't need to reencode the audio
+    command.outputOption('-bsf:a aac_adtstoasc')
+  }
+
+  addCommonHLSVODCommandOptions(command, videoPath)
+
+  return command
+}
+
+function addCommonHLSVODCommandOptions (command: FfmpegCommand, outputPath: string) {
+  return command.outputOption('-hls_time 4')
+                .outputOption('-hls_list_size 0')
+                .outputOption('-hls_playlist_type vod')
+                .outputOption('-hls_segment_filename ' + outputPath)
+                .outputOption('-hls_segment_type fmp4')
+                .outputOption('-f hls')
+                .outputOption('-hls_flags single_file')
+}
+
+async function fixHLSPlaylistIfNeeded (options: TranscodeVODOptions) {
+  if (options.type !== 'hls' && options.type !== 'hls-from-ts') return
+
+  const fileContent = await readFile(options.outputPath)
+
+  const videoFileName = options.hlsPlaylist.videoFilename
+  const videoFilePath = getHLSVideoPath(options)
+
+  // Fix wrong mapping with some ffmpeg versions
+  const newContent = fileContent.toString()
+                                .replace(`#EXT-X-MAP:URI="${videoFilePath}",`, `#EXT-X-MAP:URI="${videoFileName}",`)
+
+  await writeFile(options.outputPath, newContent)
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function getHLSVideoPath (options: HLSTranscodeOptions | HLSFromTSTranscodeOptions) {
+  return `${dirname(options.outputPath)}/${options.hlsPlaylist.videoFilename}`
+}
+
+// Avoid "height not divisible by 2" error
+function getMergeAudioScaleFilterValue () {
+  return 'trunc(iw/2)*2:trunc(ih/2)*2'
+}
diff --git a/server/helpers/ffprobe-utils.ts b/server/helpers/ffmpeg/ffprobe-utils.ts
index 595112bce..07bcf01f4 100644
--- a/server/helpers/ffprobe-utils.ts
+++ b/server/helpers/ffmpeg/ffprobe-utils.ts
@@ -1,22 +1,21 @@
 import { FfprobeData } from 'fluent-ffmpeg'
 import { getMaxBitrate } from '@shared/core-utils'
-import { VideoResolution, VideoTranscodingFPS } from '../../shared/models/videos'
-import { CONFIG } from '../initializers/config'
-import { VIDEO_TRANSCODING_FPS } from '../initializers/constants'
-import { logger } from './logger'
 import {
-  canDoQuickAudioTranscode,
   ffprobePromise,
-  getDurationFromVideoFile,
   getAudioStream,
+  getVideoStreamDuration,
   getMaxAudioBitrate,
-  getMetadataFromFile,
-  getVideoFileBitrate,
-  getVideoFileFPS,
-  getVideoFileResolution,
-  getVideoStreamFromFile,
-  getVideoStreamSize
+  buildFileMetadata,
+  getVideoStreamBitrate,
+  getVideoStreamFPS,
+  getVideoStream,
+  getVideoStreamDimensionsInfo,
+  hasAudioStream
 } from '@shared/extra-utils/ffprobe'
+import { VideoResolution, VideoTranscodingFPS } from '@shared/models'
+import { CONFIG } from '../../initializers/config'
+import { VIDEO_TRANSCODING_FPS } from '../../initializers/constants'
+import { logger } from '../logger'
 
 /**
  *
@@ -24,9 +23,12 @@ import {
  *
  */
 
-async function getVideoStreamCodec (path: string) {
-  const videoStream = await getVideoStreamFromFile(path)
+// ---------------------------------------------------------------------------
+// Codecs
+// ---------------------------------------------------------------------------
 
+async function getVideoStreamCodec (path: string) {
+  const videoStream = await getVideoStream(path)
   if (!videoStream) return ''
 
   const videoCodec = videoStream.codec_tag_string
@@ -83,6 +85,10 @@ async function getAudioStreamCodec (path: string, existingProbe?: FfprobeData) {
   return 'mp4a.40.2' // Fallback
 }
 
+// ---------------------------------------------------------------------------
+// Resolutions
+// ---------------------------------------------------------------------------
+
 function computeLowerResolutionsToTranscode (videoFileResolution: number, type: 'vod' | 'live') {
   const configResolutions = type === 'vod'
     ? CONFIG.TRANSCODING.RESOLUTIONS
@@ -112,6 +118,10 @@ function computeLowerResolutionsToTranscode (videoFileResolution: number, type:
   return resolutionsEnabled
 }
 
+// ---------------------------------------------------------------------------
+// Can quick transcode
+// ---------------------------------------------------------------------------
+
 async function canDoQuickTranscode (path: string): Promise<boolean> {
   if (CONFIG.TRANSCODING.PROFILE !== 'default') return false
 
@@ -121,17 +131,37 @@ async function canDoQuickTranscode (path: string): Promise<boolean> {
          await canDoQuickAudioTranscode(path, probe)
 }
 
+async function canDoQuickAudioTranscode (path: string, probe?: FfprobeData): Promise<boolean> {
+  const parsedAudio = await getAudioStream(path, probe)
+
+  if (!parsedAudio.audioStream) return true
+
+  if (parsedAudio.audioStream['codec_name'] !== 'aac') return false
+
+  const audioBitrate = parsedAudio.bitrate
+  if (!audioBitrate) return false
+
+  const maxAudioBitrate = getMaxAudioBitrate('aac', audioBitrate)
+  if (maxAudioBitrate !== -1 && audioBitrate > maxAudioBitrate) return false
+
+  const channelLayout = parsedAudio.audioStream['channel_layout']
+  // Causes playback issues with Chrome
+  if (!channelLayout || channelLayout === 'unknown') return false
+
+  return true
+}
+
 async function canDoQuickVideoTranscode (path: string, probe?: FfprobeData): Promise<boolean> {
-  const videoStream = await getVideoStreamFromFile(path, probe)
-  const fps = await getVideoFileFPS(path, probe)
-  const bitRate = await getVideoFileBitrate(path, probe)
-  const resolutionData = await getVideoFileResolution(path, probe)
+  const videoStream = await getVideoStream(path, probe)
+  const fps = await getVideoStreamFPS(path, probe)
+  const bitRate = await getVideoStreamBitrate(path, probe)
+  const resolutionData = await getVideoStreamDimensionsInfo(path, probe)
 
   // If ffprobe did not manage to guess the bitrate
   if (!bitRate) return false
 
   // check video params
-  if (videoStream == null) return false
+  if (!videoStream) 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
@@ -140,6 +170,10 @@ async function canDoQuickVideoTranscode (path: string, probe?: FfprobeData): Pro
   return true
 }
 
+// ---------------------------------------------------------------------------
+// Framerate
+// ---------------------------------------------------------------------------
+
 function getClosestFramerateStandard <K extends keyof Pick<VideoTranscodingFPS, 'HD_STANDARD' | 'STANDARD'>> (fps: number, type: K) {
   return VIDEO_TRANSCODING_FPS[type].slice(0)
                                     .sort((a, b) => fps % a - fps % b)[0]
@@ -171,21 +205,26 @@ function computeFPS (fpsArg: number, resolution: VideoResolution) {
 // ---------------------------------------------------------------------------
 
 export {
-  getVideoStreamCodec,
-  getAudioStreamCodec,
-  getVideoStreamSize,
-  getVideoFileResolution,
-  getMetadataFromFile,
+  // Re export ffprobe utils
+  getVideoStreamDimensionsInfo,
+  buildFileMetadata,
   getMaxAudioBitrate,
-  getVideoStreamFromFile,
-  getDurationFromVideoFile,
+  getVideoStream,
+  getVideoStreamDuration,
   getAudioStream,
-  computeFPS,
-  getVideoFileFPS,
+  hasAudioStream,
+  getVideoStreamFPS,
   ffprobePromise,
+  getVideoStreamBitrate,
+
+  getVideoStreamCodec,
+  getAudioStreamCodec,
+
+  computeFPS,
   getClosestFramerateStandard,
+
   computeLowerResolutionsToTranscode,
-  getVideoFileBitrate,
+
   canDoQuickTranscode,
   canDoQuickVideoTranscode,
   canDoQuickAudioTranscode
diff --git a/server/helpers/ffmpeg/index.ts b/server/helpers/ffmpeg/index.ts
new file mode 100644
index 000000000..e3bb2013f
--- /dev/null
+++ b/server/helpers/ffmpeg/index.ts
@@ -0,0 +1,8 @@
+export * from './ffmpeg-commons'
+export * from './ffmpeg-edition'
+export * from './ffmpeg-encoders'
+export * from './ffmpeg-images'
+export * from './ffmpeg-live'
+export * from './ffmpeg-presets'
+export * from './ffmpeg-vod'
+export * from './ffprobe-utils'
diff --git a/server/helpers/image-utils.ts b/server/helpers/image-utils.ts
index b174ae436..9d0c09051 100644
--- a/server/helpers/image-utils.ts
+++ b/server/helpers/image-utils.ts
@@ -1,9 +1,12 @@
 import { copy, readFile, remove, rename } from 'fs-extra'
-import Jimp, { read } from 'jimp'
+import Jimp, { read as jimpRead } from 'jimp'
+import { join } from 'path'
 import { getLowercaseExtension } from '@shared/core-utils'
 import { buildUUID } from '@shared/extra-utils'
-import { convertWebPToJPG, processGIF } from './ffmpeg-utils'
-import { logger } from './logger'
+import { convertWebPToJPG, generateThumbnailFromVideo, processGIF } from './ffmpeg/ffmpeg-images'
+import { logger, loggerTagsFactory } from './logger'
+
+const lTags = loggerTagsFactory('image-utils')
 
 function generateImageFilename (extension = '.jpg') {
   return buildUUID() + extension
@@ -33,11 +36,46 @@ async function processImage (
   if (keepOriginal !== true) await remove(path)
 }
 
+async function generateImageFromVideoFile (fromPath: string, folder: string, imageName: string, size: { width: number, height: number }) {
+  const pendingImageName = 'pending-' + imageName
+  const pendingImagePath = join(folder, pendingImageName)
+
+  try {
+    await generateThumbnailFromVideo(fromPath, folder, imageName)
+
+    const destination = join(folder, imageName)
+    await processImage(pendingImagePath, destination, size)
+  } catch (err) {
+    logger.error('Cannot generate image from video %s.', fromPath, { err, ...lTags() })
+
+    try {
+      await remove(pendingImagePath)
+    } catch (err) {
+      logger.debug('Cannot remove pending image path after generation error.', { err, ...lTags() })
+    }
+  }
+}
+
+async function getImageSize (path: string) {
+  const inputBuffer = await readFile(path)
+
+  const image = await jimpRead(inputBuffer)
+
+  return {
+    width: image.getWidth(),
+    height: image.getHeight()
+  }
+}
+
 // ---------------------------------------------------------------------------
 
 export {
   generateImageFilename,
-  processImage
+  generateImageFromVideoFile,
+
+  processImage,
+
+  getImageSize
 }
 
 // ---------------------------------------------------------------------------
@@ -47,7 +85,7 @@ async function jimpProcessor (path: string, destination: string, newSize: { widt
   const inputBuffer = await readFile(path)
 
   try {
-    sourceImage = await read(inputBuffer)
+    sourceImage = await jimpRead(inputBuffer)
   } catch (err) {
     logger.debug('Cannot read %s with jimp. Try to convert the image using ffmpeg first.', path, { err })
 
@@ -55,7 +93,7 @@ async function jimpProcessor (path: string, destination: string, newSize: { widt
     await convertWebPToJPG(path, newName)
     await rename(newName, path)
 
-    sourceImage = await read(path)
+    sourceImage = await jimpRead(path)
   }
 
   await remove(destination)
diff --git a/server/helpers/markdown.ts b/server/helpers/markdown.ts
index 25685ec6d..41c1186ec 100644
--- a/server/helpers/markdown.ts
+++ b/server/helpers/markdown.ts
@@ -8,7 +8,7 @@ const markdownItEmoji = require('markdown-it-emoji/light')
 const MarkdownItClass = require('markdown-it')
 
 const markdownItWithHTML = new MarkdownItClass('default', { linkify: true, breaks: true, html: true })
-const markdownItWithoutHTML = new MarkdownItClass('default', { linkify: true, breaks: true, html: false })
+const markdownItWithoutHTML = new MarkdownItClass('default', { linkify: false, breaks: true, html: false })
 
 const toSafeHtml = (text: string) => {
   if (!text) return ''
@@ -66,7 +66,7 @@ function plainTextPlugin (markdownIt: any) {
 
       if (token.type === 'list_item_close') {
         lastSeparator = ', '
-      } else if (/[a-zA-Z]+_close/.test(token.type)) {
+      } else if (token.type.endsWith('_close')) {
         lastSeparator = ' '
       } else if (token.content) {
         text += lastSeparator
diff --git a/server/helpers/webtorrent.ts b/server/helpers/webtorrent.ts
index 68d532c48..88bdb16b6 100644
--- a/server/helpers/webtorrent.ts
+++ b/server/helpers/webtorrent.ts
@@ -91,6 +91,16 @@ async function downloadWebTorrentVideo (target: { uri: string, torrentName?: str
 }
 
 function createTorrentAndSetInfoHash (videoOrPlaylist: MVideo | MStreamingPlaylistVideo, videoFile: MVideoFile) {
+  return VideoPathManager.Instance.makeAvailableVideoFile(videoFile.withVideoOrPlaylist(videoOrPlaylist), videoPath => {
+    return createTorrentAndSetInfoHashFromPath(videoOrPlaylist, videoFile, videoPath)
+  })
+}
+
+async function createTorrentAndSetInfoHashFromPath (
+  videoOrPlaylist: MVideo | MStreamingPlaylistVideo,
+  videoFile: MVideoFile,
+  filePath: string
+) {
   const video = extractVideo(videoOrPlaylist)
 
   const options = {
@@ -101,24 +111,22 @@ function createTorrentAndSetInfoHash (videoOrPlaylist: MVideo | MStreamingPlayli
     urlList: buildUrlList(video, videoFile)
   }
 
-  return VideoPathManager.Instance.makeAvailableVideoFile(videoFile.withVideoOrPlaylist(videoOrPlaylist), async videoPath => {
-    const torrentContent = await createTorrentPromise(videoPath, options)
+  const torrentContent = await createTorrentPromise(filePath, options)
 
-    const torrentFilename = generateTorrentFileName(videoOrPlaylist, videoFile.resolution)
-    const torrentPath = join(CONFIG.STORAGE.TORRENTS_DIR, torrentFilename)
-    logger.info('Creating torrent %s.', torrentPath)
+  const torrentFilename = generateTorrentFileName(videoOrPlaylist, videoFile.resolution)
+  const torrentPath = join(CONFIG.STORAGE.TORRENTS_DIR, torrentFilename)
+  logger.info('Creating torrent %s.', torrentPath)
 
-    await writeFile(torrentPath, torrentContent)
+  await writeFile(torrentPath, torrentContent)
 
-    // Remove old torrent file if it existed
-    if (videoFile.hasTorrent()) {
-      await remove(join(CONFIG.STORAGE.TORRENTS_DIR, videoFile.torrentFilename))
-    }
+  // Remove old torrent file if it existed
+  if (videoFile.hasTorrent()) {
+    await remove(join(CONFIG.STORAGE.TORRENTS_DIR, videoFile.torrentFilename))
+  }
 
-    const parsedTorrent = parseTorrent(torrentContent)
-    videoFile.infoHash = parsedTorrent.infoHash
-    videoFile.torrentFilename = torrentFilename
-  })
+  const parsedTorrent = parseTorrent(torrentContent)
+  videoFile.infoHash = parsedTorrent.infoHash
+  videoFile.torrentFilename = torrentFilename
 }
 
 async function updateTorrentMetadata (videoOrPlaylist: MVideo | MStreamingPlaylistVideo, videoFile: MVideoFile) {
@@ -177,7 +185,10 @@ function generateMagnetUri (
 export {
   createTorrentPromise,
   updateTorrentMetadata,
+
   createTorrentAndSetInfoHash,
+  createTorrentAndSetInfoHashFromPath,
+
   generateMagnetUri,
   downloadWebTorrentVideo
 }
diff --git a/server/initializers/checker-after-init.ts b/server/initializers/checker-after-init.ts
index 57ef0d218..635a32010 100644
--- a/server/initializers/checker-after-init.ts
+++ b/server/initializers/checker-after-init.ts
@@ -1,7 +1,7 @@
 import config from 'config'
 import { uniq } from 'lodash'
 import { URL } from 'url'
-import { getFFmpegVersion } from '@server/helpers/ffmpeg-utils'
+import { getFFmpegVersion } from '@server/helpers/ffmpeg'
 import { VideoRedundancyConfigFilter } from '@shared/models/redundancy/video-redundancy-config-filter.type'
 import { RecentlyAddedStrategy } from '../../shared/models/redundancy'
 import { isProdInstance, isTestInstance, parseSemVersion } from '../helpers/core-utils'
@@ -31,8 +31,7 @@ async function checkActivityPubUrls () {
   }
 }
 
-// Some checks on configuration files
-// Return an error message, or null if everything is okay
+// Some checks on configuration files or throw if there is an error
 function checkConfig () {
 
   // Moved configuration keys
@@ -40,61 +39,124 @@ function checkConfig () {
     logger.warn('services.csp-logger configuration has been renamed to csp.report_uri. Please update your configuration file.')
   }
 
-  // Email verification
+  checkEmailConfig()
+  checkNSFWPolicyConfig()
+  checkLocalRedundancyConfig()
+  checkRemoteRedundancyConfig()
+  checkStorageConfig()
+  checkTranscodingConfig()
+  checkBroadcastMessageConfig()
+  checkSearchConfig()
+  checkLiveConfig()
+  checkObjectStorageConfig()
+  checkVideoEditorConfig()
+}
+
+// We get db by param to not import it in this file (import orders)
+async function clientsExist () {
+  const totalClients = await OAuthClientModel.countTotal()
+
+  return totalClients !== 0
+}
+
+// We get db by param to not import it in this file (import orders)
+async function usersExist () {
+  const totalUsers = await UserModel.countTotal()
+
+  return totalUsers !== 0
+}
+
+// We get db by param to not import it in this file (import orders)
+async function applicationExist () {
+  const totalApplication = await ApplicationModel.countTotal()
+
+  return totalApplication !== 0
+}
+
+async function checkFFmpegVersion () {
+  const version = await getFFmpegVersion()
+  const { major, minor } = parseSemVersion(version)
+
+  if (major < 4 || (major === 4 && minor < 1)) {
+    logger.warn('Your ffmpeg version (%s) is outdated. PeerTube supports ffmpeg >= 4.1. Please upgrade.', version)
+  }
+}
+
+// ---------------------------------------------------------------------------
+
+export {
+  checkConfig,
+  clientsExist,
+  checkFFmpegVersion,
+  usersExist,
+  applicationExist,
+  checkActivityPubUrls
+}
+
+// ---------------------------------------------------------------------------
+
+function checkEmailConfig () {
   if (!isEmailEnabled()) {
     if (CONFIG.SIGNUP.ENABLED && CONFIG.SIGNUP.REQUIRES_EMAIL_VERIFICATION) {
-      return 'Emailer is disabled but you require signup email verification.'
+      throw new Error('Emailer is disabled but you require signup email verification.')
     }
 
     if (CONFIG.CONTACT_FORM.ENABLED) {
       logger.warn('Emailer is disabled so the contact form will not work.')
     }
   }
+}
 
-  // NSFW policy
+function checkNSFWPolicyConfig () {
   const defaultNSFWPolicy = CONFIG.INSTANCE.DEFAULT_NSFW_POLICY
-  {
-    const available = [ 'do_not_list', 'blur', 'display' ]
-    if (available.includes(defaultNSFWPolicy) === false) {
-      return 'NSFW policy setting should be ' + available.join(' or ') + ' instead of ' + defaultNSFWPolicy
-    }
+
+  const available = [ 'do_not_list', 'blur', 'display' ]
+  if (available.includes(defaultNSFWPolicy) === false) {
+    throw new Error('NSFW policy setting should be ' + available.join(' or ') + ' instead of ' + defaultNSFWPolicy)
   }
+}
 
-  // Redundancies
+function checkLocalRedundancyConfig () {
   const redundancyVideos = CONFIG.REDUNDANCY.VIDEOS.STRATEGIES
+
   if (isArray(redundancyVideos)) {
     const available = [ 'most-views', 'trending', 'recently-added' ]
+
     for (const r of redundancyVideos) {
       if (available.includes(r.strategy) === false) {
-        return 'Videos redundancy should have ' + available.join(' or ') + ' strategy instead of ' + r.strategy
+        throw new Error('Videos redundancy should have ' + available.join(' or ') + ' strategy instead of ' + r.strategy)
       }
 
       // Lifetime should not be < 10 hours
       if (!isTestInstance() && r.minLifetime < 1000 * 3600 * 10) {
-        return 'Video redundancy minimum lifetime should be >= 10 hours for strategy ' + r.strategy
+        throw new Error('Video redundancy minimum lifetime should be >= 10 hours for strategy ' + r.strategy)
       }
     }
 
     const filtered = uniq(redundancyVideos.map(r => r.strategy))
     if (filtered.length !== redundancyVideos.length) {
-      return 'Redundancy video entries should have unique strategies'
+      throw new Error('Redundancy video entries should have unique strategies')
     }
 
     const recentlyAddedStrategy = redundancyVideos.find(r => r.strategy === 'recently-added') as RecentlyAddedStrategy
     if (recentlyAddedStrategy && isNaN(recentlyAddedStrategy.minViews)) {
-      return 'Min views in recently added strategy is not a number'
+      throw new Error('Min views in recently added strategy is not a number')
     }
   } else {
-    return 'Videos redundancy should be an array (you must uncomment lines containing - too)'
+    throw new Error('Videos redundancy should be an array (you must uncomment lines containing - too)')
   }
+}
 
-  // Remote redundancies
+function checkRemoteRedundancyConfig () {
   const acceptFrom = CONFIG.REMOTE_REDUNDANCY.VIDEOS.ACCEPT_FROM
   const acceptFromValues = new Set<VideoRedundancyConfigFilter>([ 'nobody', 'anybody', 'followings' ])
+
   if (acceptFromValues.has(acceptFrom) === false) {
-    return 'remote_redundancy.videos.accept_from has an incorrect value'
+    throw new Error('remote_redundancy.videos.accept_from has an incorrect value')
   }
+}
 
+function checkStorageConfig () {
   // Check storage directory locations
   if (isProdInstance()) {
     const configStorage = config.get('storage')
@@ -111,71 +173,76 @@ function checkConfig () {
   if (CONFIG.STORAGE.VIDEOS_DIR === CONFIG.STORAGE.REDUNDANCY_DIR) {
     logger.warn('Redundancy directory should be different than the videos folder.')
   }
+}
 
-  // Transcoding
+function checkTranscodingConfig () {
   if (CONFIG.TRANSCODING.ENABLED) {
     if (CONFIG.TRANSCODING.WEBTORRENT.ENABLED === false && CONFIG.TRANSCODING.HLS.ENABLED === false) {
-      return 'You need to enable at least WebTorrent transcoding or HLS transcoding.'
+      throw new Error('You need to enable at least WebTorrent transcoding or HLS transcoding.')
     }
 
     if (CONFIG.TRANSCODING.CONCURRENCY <= 0) {
-      return 'Transcoding concurrency should be > 0'
+      throw new Error('Transcoding concurrency should be > 0')
     }
   }
 
   if (CONFIG.IMPORT.VIDEOS.HTTP.ENABLED || CONFIG.IMPORT.VIDEOS.TORRENT.ENABLED) {
     if (CONFIG.IMPORT.VIDEOS.CONCURRENCY <= 0) {
-      return 'Video import concurrency should be > 0'
+      throw new Error('Video import concurrency should be > 0')
     }
   }
+}
 
-  // Broadcast message
+function checkBroadcastMessageConfig () {
   if (CONFIG.BROADCAST_MESSAGE.ENABLED) {
     const currentLevel = CONFIG.BROADCAST_MESSAGE.LEVEL
     const available = [ 'info', 'warning', 'error' ]
 
     if (available.includes(currentLevel) === false) {
-      return 'Broadcast message level should be ' + available.join(' or ') + ' instead of ' + currentLevel
+      throw new Error('Broadcast message level should be ' + available.join(' or ') + ' instead of ' + currentLevel)
     }
   }
+}
 
-  // Search index
+function checkSearchConfig () {
   if (CONFIG.SEARCH.SEARCH_INDEX.ENABLED === true) {
     if (CONFIG.SEARCH.REMOTE_URI.USERS === false) {
-      return 'You cannot enable search index without enabling remote URI search for users.'
+      throw new Error('You cannot enable search index without enabling remote URI search for users.')
     }
   }
+}
 
-  // Live
+function checkLiveConfig () {
   if (CONFIG.LIVE.ENABLED === true) {
     if (CONFIG.LIVE.ALLOW_REPLAY === true && CONFIG.TRANSCODING.ENABLED === false) {
-      return 'Live allow replay cannot be enabled if transcoding is not enabled.'
+      throw new Error('Live allow replay cannot be enabled if transcoding is not enabled.')
     }
 
     if (CONFIG.LIVE.RTMP.ENABLED === false && CONFIG.LIVE.RTMPS.ENABLED === false) {
-      return 'You must enable at least RTMP or RTMPS'
+      throw new Error('You must enable at least RTMP or RTMPS')
     }
 
     if (CONFIG.LIVE.RTMPS.ENABLED) {
       if (!CONFIG.LIVE.RTMPS.KEY_FILE) {
-        return 'You must specify a key file to enabled RTMPS'
+        throw new Error('You must specify a key file to enabled RTMPS')
       }
 
       if (!CONFIG.LIVE.RTMPS.CERT_FILE) {
-        return 'You must specify a cert file to enable RTMPS'
+        throw new Error('You must specify a cert file to enable RTMPS')
       }
     }
   }
+}
 
-  // Object storage
+function checkObjectStorageConfig () {
   if (CONFIG.OBJECT_STORAGE.ENABLED === true) {
 
     if (!CONFIG.OBJECT_STORAGE.VIDEOS.BUCKET_NAME) {
-      return 'videos_bucket should be set when object storage support is enabled.'
+      throw new Error('videos_bucket should be set when object storage support is enabled.')
     }
 
     if (!CONFIG.OBJECT_STORAGE.STREAMING_PLAYLISTS.BUCKET_NAME) {
-      return 'streaming_playlists_bucket should be set when object storage support is enabled.'
+      throw new Error('streaming_playlists_bucket should be set when object storage support is enabled.')
     }
 
     if (
@@ -183,53 +250,18 @@ function checkConfig () {
       CONFIG.OBJECT_STORAGE.VIDEOS.PREFIX === CONFIG.OBJECT_STORAGE.STREAMING_PLAYLISTS.PREFIX
     ) {
       if (CONFIG.OBJECT_STORAGE.VIDEOS.PREFIX === '') {
-        return 'Object storage bucket prefixes should be set when the same bucket is used for both types of video.'
-      } else {
-        return 'Object storage bucket prefixes should be set to different values when the same bucket is used for both types of video.'
+        throw new Error('Object storage bucket prefixes should be set when the same bucket is used for both types of video.')
       }
+
+      throw new Error(
+        'Object storage bucket prefixes should be set to different values when the same bucket is used for both types of video.'
+      )
     }
   }
-
-  return null
-}
-
-// We get db by param to not import it in this file (import orders)
-async function clientsExist () {
-  const totalClients = await OAuthClientModel.countTotal()
-
-  return totalClients !== 0
-}
-
-// We get db by param to not import it in this file (import orders)
-async function usersExist () {
-  const totalUsers = await UserModel.countTotal()
-
-  return totalUsers !== 0
 }
 
-// We get db by param to not import it in this file (import orders)
-async function applicationExist () {
-  const totalApplication = await ApplicationModel.countTotal()
-
-  return totalApplication !== 0
-}
-
-async function checkFFmpegVersion () {
-  const version = await getFFmpegVersion()
-  const { major, minor } = parseSemVersion(version)
-
-  if (major < 4 || (major === 4 && minor < 1)) {
-    logger.warn('Your ffmpeg version (%s) is outdated. PeerTube supports ffmpeg >= 4.1. Please upgrade.', version)
+function checkVideoEditorConfig () {
+  if (CONFIG.VIDEO_EDITOR.ENABLED === true && CONFIG.TRANSCODING.ENABLED === false) {
+    throw new Error('Video editor cannot be enabled if transcoding is disabled')
   }
 }
-
-// ---------------------------------------------------------------------------
-
-export {
-  checkConfig,
-  clientsExist,
-  checkFFmpegVersion,
-  usersExist,
-  applicationExist,
-  checkActivityPubUrls
-}
diff --git a/server/initializers/checker-before-init.ts b/server/initializers/checker-before-init.ts
index 458005b98..36401f95c 100644
--- a/server/initializers/checker-before-init.ts
+++ b/server/initializers/checker-before-init.ts
@@ -30,7 +30,7 @@ function checkMissedConfig () {
     'transcoding.profile', 'transcoding.concurrency',
     'transcoding.resolutions.0p', 'transcoding.resolutions.144p', 'transcoding.resolutions.240p', 'transcoding.resolutions.360p',
     'transcoding.resolutions.480p', 'transcoding.resolutions.720p', 'transcoding.resolutions.1080p', 'transcoding.resolutions.1440p',
-    'transcoding.resolutions.2160p',
+    'transcoding.resolutions.2160p', 'video_editor.enabled',
     'import.videos.http.enabled', 'import.videos.torrent.enabled', 'import.videos.concurrency', 'auto_blacklist.videos.of_users.enabled',
     'trending.videos.interval_days',
     'client.videos.miniature.prefer_author_display_name', 'client.menu.login.redirect_on_single_external_auth',
@@ -49,7 +49,8 @@ function checkMissedConfig () {
     'search.remote_uri.users', 'search.remote_uri.anonymous', 'search.search_index.enabled', 'search.search_index.url',
     'search.search_index.disable_local_search', 'search.search_index.is_default_search',
     'live.enabled', 'live.allow_replay', 'live.max_duration', 'live.max_user_lives', 'live.max_instance_lives',
-    'live.rtmp.enabled', 'live.rtmp.port', 'live.rtmps.enabled', 'live.rtmps.port', 'live.rtmps.key_file', 'live.rtmps.cert_file',
+    'live.rtmp.enabled', 'live.rtmp.port', 'live.rtmp.hostname',
+    'live.rtmps.enabled', 'live.rtmps.port', 'live.rtmps.hostname', 'live.rtmps.key_file', 'live.rtmps.cert_file',
     'live.transcoding.enabled', 'live.transcoding.threads', 'live.transcoding.profile',
     'live.transcoding.resolutions.144p', 'live.transcoding.resolutions.240p', 'live.transcoding.resolutions.360p',
     'live.transcoding.resolutions.480p', 'live.transcoding.resolutions.720p', 'live.transcoding.resolutions.1080p',
@@ -116,12 +117,8 @@ function checkNodeVersion () {
 
   logger.debug('Checking NodeJS version %s.', v)
 
-  if (major <= 10) {
-    throw new Error('Your NodeJS version ' + v + ' is not supported. Please upgrade.')
-  }
-
   if (major <= 12) {
-    logger.warn('Your NodeJS version ' + v + ' is deprecated. Please upgrade.')
+    throw new Error('Your NodeJS version ' + v + ' is not supported. Please upgrade.')
   }
 }
 
diff --git a/server/initializers/config.ts b/server/initializers/config.ts
index fb6f7ae62..63056b41d 100644
--- a/server/initializers/config.ts
+++ b/server/initializers/config.ts
@@ -297,12 +297,14 @@ const CONFIG = {
 
     RTMP: {
       get ENABLED () { return config.get<boolean>('live.rtmp.enabled') },
-      get PORT () { return config.get<number>('live.rtmp.port') }
+      get PORT () { return config.get<number>('live.rtmp.port') },
+      get HOSTNAME () { return config.get<number>('live.rtmp.hostname') }
     },
 
     RTMPS: {
       get ENABLED () { return config.get<boolean>('live.rtmps.enabled') },
       get PORT () { return config.get<number>('live.rtmps.port') },
+      get HOSTNAME () { return config.get<number>('live.rtmps.hostname') },
       get KEY_FILE () { return config.get<string>('live.rtmps.key_file') },
       get CERT_FILE () { return config.get<string>('live.rtmps.cert_file') }
     },
@@ -324,6 +326,9 @@ const CONFIG = {
       }
     }
   },
+  VIDEO_EDITOR: {
+    get ENABLED () { return config.get<boolean>('video_editor.enabled') }
+  },
   IMPORT: {
     VIDEOS: {
       get CONCURRENCY () { return config.get<number>('import.videos.concurrency') },
diff --git a/server/initializers/constants.ts b/server/initializers/constants.ts
index 1c47d43f0..3069e2353 100644
--- a/server/initializers/constants.ts
+++ b/server/initializers/constants.ts
@@ -14,7 +14,7 @@ import {
   VideoTranscodingFPS
 } from '../../shared/models'
 import { ActivityPubActorType } from '../../shared/models/activitypub'
-import { FollowState } from '../../shared/models/actors'
+import { ActorImageType, FollowState } from '../../shared/models/actors'
 import { NSFWPolicyType } from '../../shared/models/videos/nsfw-policy.type'
 import { VideoPlaylistPrivacy } from '../../shared/models/videos/playlist/video-playlist-privacy.model'
 import { VideoPlaylistType } from '../../shared/models/videos/playlist/video-playlist-type.model'
@@ -24,7 +24,7 @@ import { CONFIG, registerConfigChangedHandler } from './config'
 
 // ---------------------------------------------------------------------------
 
-const LAST_MIGRATION_VERSION = 680
+const LAST_MIGRATION_VERSION = 685
 
 // ---------------------------------------------------------------------------
 
@@ -152,6 +152,7 @@ const JOB_ATTEMPTS: { [id in JobType]: number } = {
   'activitypub-refresher': 1,
   'video-redundancy': 1,
   'video-live-ending': 1,
+  'video-edition': 1,
   'move-to-object-storage': 3
 }
 // Excluded keys are jobs that can be configured by admins
@@ -168,6 +169,7 @@ const JOB_CONCURRENCY: { [id in Exclude<JobType, 'video-transcoding' | 'video-im
   'activitypub-refresher': 1,
   'video-redundancy': 1,
   'video-live-ending': 10,
+  'video-edition': 1,
   'move-to-object-storage': 1
 }
 const JOB_TTL: { [id in JobType]: number } = {
@@ -178,6 +180,7 @@ const JOB_TTL: { [id in JobType]: number } = {
   'activitypub-cleaner': 1000 * 3600, // 1 hour
   'video-file-import': 1000 * 3600, // 1 hour
   'video-transcoding': 1000 * 3600 * 48, // 2 days, transcoding could be long
+  'video-edition': 1000 * 3600 * 10, // 10 hours
   'video-import': 1000 * 3600 * 2, // 2 hours
   'email': 60000 * 10, // 10 minutes
   'actor-keys': 60000 * 20, // 20 minutes
@@ -351,6 +354,10 @@ const CONSTRAINTS_FIELDS = {
   },
   COMMONS: {
     URL: { min: 5, max: 2000 } // Length
+  },
+  VIDEO_EDITOR: {
+    TASKS: { min: 1, max: 10 }, // Number of tasks
+    CUT_TIME: { min: 0 } // Value
   }
 }
 
@@ -365,6 +372,7 @@ const VIDEO_TRANSCODING_FPS: VideoTranscodingFPS = {
   MIN: 1,
   STANDARD: [ 24, 25, 30 ],
   HD_STANDARD: [ 50, 60 ],
+  AUDIO_MERGE: 25,
   AVERAGE: 30,
   MAX: 60,
   KEEP_ORIGIN_FPS_RESOLUTION_MIN: 720 // We keep the original FPS on high resolutions (720 minimum)
@@ -434,7 +442,8 @@ const VIDEO_STATES: { [ id in VideoState ]: string } = {
   [VideoState.LIVE_ENDED]: 'Livestream ended',
   [VideoState.TO_MOVE_TO_EXTERNAL_STORAGE]: 'To move to an external storage',
   [VideoState.TRANSCODING_FAILED]: 'Transcoding failed',
-  [VideoState.TO_MOVE_TO_EXTERNAL_STORAGE_FAILED]: 'External storage move failed'
+  [VideoState.TO_MOVE_TO_EXTERNAL_STORAGE_FAILED]: 'External storage move failed',
+  [VideoState.TO_EDIT]: 'To edit*'
 }
 
 const VIDEO_IMPORT_STATES: { [ id in VideoImportState ]: string } = {
@@ -633,15 +642,23 @@ const PREVIEWS_SIZE = {
   height: 480,
   minWidth: 400
 }
-const ACTOR_IMAGES_SIZE = {
-  AVATARS: {
-    width: 120,
-    height: 120
-  },
-  BANNERS: {
-    width: 1920,
-    height: 317 // 6/1 ratio
-  }
+const ACTOR_IMAGES_SIZE: { [key in ActorImageType]: { width: number, height: number }[]} = {
+  [ActorImageType.AVATAR]: [
+    {
+      width: 120,
+      height: 120
+    },
+    {
+      width: 48,
+      height: 48
+    }
+  ],
+  [ActorImageType.BANNER]: [
+    {
+      width: 1920,
+      height: 317 // 6/1 ratio
+    }
+  ]
 }
 
 const EMBED_SIZE = {
@@ -701,10 +718,12 @@ const MEMOIZE_TTL = {
   OVERVIEWS_SAMPLE: 1000 * 3600 * 4, // 4 hours
   INFO_HASH_EXISTS: 1000 * 3600 * 12, // 12 hours
   LIVE_ABLE_TO_UPLOAD: 1000 * 60, // 1 minute
-  LIVE_CHECK_SOCKET_HEALTH: 1000 * 60 // 1 minute
+  LIVE_CHECK_SOCKET_HEALTH: 1000 * 60, // 1 minute
+  MD_TO_PLAIN_TEXT_CLIENT_HTML: 1000 * 60 // 1 minute
 }
 
 const MEMOIZE_LENGTH = {
+  MD_TO_PLAIN_TEXT_CLIENT_HTML: 100,
   INFO_HASH_EXISTS: 200
 }
 
@@ -847,6 +866,16 @@ const FILES_CONTENT_HASH = {
 
 // ---------------------------------------------------------------------------
 
+const VIDEO_FILTERS = {
+  WATERMARK: {
+    SIZE_RATIO: 1 / 10,
+    HORIZONTAL_MARGIN_RATIO: 1 / 20,
+    VERTICAL_MARGIN_RATIO: 1 / 20
+  }
+}
+
+// ---------------------------------------------------------------------------
+
 export {
   WEBSERVER,
   API_VERSION,
@@ -885,6 +914,7 @@ export {
   PLUGIN_GLOBAL_CSS_FILE_NAME,
   PLUGIN_GLOBAL_CSS_PATH,
   PRIVATE_RSA_KEY_SIZE,
+  VIDEO_FILTERS,
   ROUTE_CACHE_LIFETIME,
   SORTABLE_COLUMNS,
   HLS_STREAMING_PLAYLIST_DIRECTORY,
@@ -1016,8 +1046,8 @@ function updateWebserverUrls () {
   WEBSERVER.HOSTNAME = CONFIG.WEBSERVER.HOSTNAME
   WEBSERVER.PORT = CONFIG.WEBSERVER.PORT
 
-  WEBSERVER.RTMP_URL = 'rtmp://' + CONFIG.WEBSERVER.HOSTNAME + ':' + CONFIG.LIVE.RTMP.PORT + '/' + VIDEO_LIVE.RTMP.BASE_PATH
-  WEBSERVER.RTMPS_URL = 'rtmps://' + CONFIG.WEBSERVER.HOSTNAME + ':' + CONFIG.LIVE.RTMPS.PORT + '/' + VIDEO_LIVE.RTMP.BASE_PATH
+  WEBSERVER.RTMP_URL = 'rtmp://' + CONFIG.LIVE.RTMP.HOSTNAME + ':' + CONFIG.LIVE.RTMP.PORT + '/' + VIDEO_LIVE.RTMP.BASE_PATH
+  WEBSERVER.RTMPS_URL = 'rtmps://' + CONFIG.LIVE.RTMPS.HOSTNAME + ':' + CONFIG.LIVE.RTMPS.PORT + '/' + VIDEO_LIVE.RTMP.BASE_PATH
 }
 
 function updateWebserverConfig () {
diff --git a/server/initializers/installer.ts b/server/initializers/installer.ts
index 7e321fb76..0517e0084 100644
--- a/server/initializers/installer.ts
+++ b/server/initializers/installer.ts
@@ -2,10 +2,9 @@ import { ensureDir, remove } from 'fs-extra'
 import passwordGenerator from 'password-generator'
 import { UserRole } from '@shared/models'
 import { logger } from '../helpers/logger'
-import { createApplicationActor, createUserAccountAndChannelAndPlaylist } from '../lib/user'
+import { buildUser, createApplicationActor, createUserAccountAndChannelAndPlaylist } from '../lib/user'
 import { ApplicationModel } from '../models/application/application'
 import { OAuthClientModel } from '../models/oauth/oauth-client'
-import { UserModel } from '../models/user/user'
 import { applicationExist, clientsExist, usersExist } from './checker-after-init'
 import { CONFIG } from './config'
 import { FILES_CACHE, HLS_STREAMING_PLAYLIST_DIRECTORY, LAST_MIGRATION_VERSION, RESUMABLE_UPLOAD_DIRECTORY } from './constants'
@@ -137,18 +136,15 @@ async function createOAuthAdminIfNotExist () {
     password = passwordGenerator(16, true)
   }
 
-  const userData = {
+  const user = buildUser({
     username,
     email,
     password,
     role,
-    verified: true,
-    nsfwPolicy: CONFIG.INSTANCE.DEFAULT_NSFW_POLICY,
-    p2pEnabled: CONFIG.DEFAULTS.P2P.WEBAPP.ENABLED,
+    emailVerified: true,
     videoQuota: -1,
     videoQuotaDaily: -1
-  }
-  const user = new UserModel(userData)
+  })
 
   await createUserAccountAndChannelAndPlaylist({ userToCreate: user, channelNames: undefined, validateUser: validatePassword })
   logger.info('Username: ' + username)
diff --git a/server/initializers/migrations/0075-video-resolutions.ts b/server/initializers/migrations/0075-video-resolutions.ts
index 6e8e47acb..8cd47496e 100644
--- a/server/initializers/migrations/0075-video-resolutions.ts
+++ b/server/initializers/migrations/0075-video-resolutions.ts
@@ -1,8 +1,8 @@
-import * as Sequelize from 'sequelize'
+import { readdir, rename } from 'fs-extra'
 import { join } from 'path'
+import * as Sequelize from 'sequelize'
+import { getVideoStreamDimensionsInfo } from '../../helpers/ffmpeg/ffprobe-utils'
 import { CONFIG } from '../../initializers/config'
-import { getVideoFileResolution } from '../../helpers/ffprobe-utils'
-import { readdir, rename } from 'fs-extra'
 
 function up (utils: {
   transaction: Sequelize.Transaction
@@ -26,7 +26,7 @@ function up (utils: {
         const uuid = matches[1]
         const ext = matches[2]
 
-        const p = getVideoFileResolution(join(videoFileDir, videoFile))
+        const p = getVideoStreamDimensionsInfo(join(videoFileDir, videoFile))
           .then(async ({ resolution }) => {
             const oldTorrentName = uuid + '.torrent'
             const newTorrentName = uuid + '-' + resolution + '.torrent'
diff --git a/server/initializers/migrations/0685-multiple-actor-images.ts b/server/initializers/migrations/0685-multiple-actor-images.ts
new file mode 100644
index 000000000..c656f7e28
--- /dev/null
+++ b/server/initializers/migrations/0685-multiple-actor-images.ts
@@ -0,0 +1,62 @@
+import * as Sequelize from 'sequelize'
+
+async function up (utils: {
+  transaction: Sequelize.Transaction
+  queryInterface: Sequelize.QueryInterface
+  sequelize: Sequelize.Sequelize
+  db: any
+}): Promise<void> {
+  {
+    await utils.queryInterface.addColumn('actorImage', 'actorId', {
+      type: Sequelize.INTEGER,
+      defaultValue: null,
+      allowNull: true,
+      references: {
+        model: 'actor',
+        key: 'id'
+      },
+      onDelete: 'CASCADE'
+    }, { transaction: utils.transaction })
+
+    // Avatars
+    {
+      const query = `UPDATE "actorImage" SET "actorId" = (SELECT "id" FROM "actor" WHERE "actor"."avatarId" = "actorImage"."id") ` +
+                    `WHERE "type" = 1`
+      await utils.sequelize.query(query, { type: Sequelize.QueryTypes.UPDATE, transaction: utils.transaction })
+    }
+
+    // Banners
+    {
+      const query = `UPDATE "actorImage" SET "actorId" = (SELECT "id" FROM "actor" WHERE "actor"."bannerId" = "actorImage"."id") ` +
+                    `WHERE "type" = 2`
+      await utils.sequelize.query(query, { type: Sequelize.QueryTypes.UPDATE, transaction: utils.transaction })
+    }
+
+    // Remove orphans
+    {
+      const query = `DELETE FROM "actorImage" WHERE id NOT IN (` +
+        `SELECT "bannerId" FROM actor WHERE "bannerId" IS NOT NULL ` +
+        `UNION select "avatarId" FROM actor WHERE "avatarId" IS NOT NULL` +
+      `);`
+
+      await utils.sequelize.query(query, { type: Sequelize.QueryTypes.DELETE, transaction: utils.transaction })
+    }
+
+    await utils.queryInterface.changeColumn('actorImage', 'actorId', {
+      type: Sequelize.INTEGER,
+      allowNull: false
+    }, { transaction: utils.transaction })
+
+    await utils.queryInterface.removeColumn('actor', 'avatarId', { transaction: utils.transaction })
+    await utils.queryInterface.removeColumn('actor', 'bannerId', { transaction: utils.transaction })
+  }
+}
+
+function down () {
+  throw new Error('Not implemented.')
+}
+
+export {
+  up,
+  down
+}
diff --git a/server/lib/activitypub/actors/image.ts b/server/lib/activitypub/actors/image.ts
index 443ad0a63..d17c2ef1a 100644
--- a/server/lib/activitypub/actors/image.ts
+++ b/server/lib/activitypub/actors/image.ts
@@ -12,53 +12,52 @@ type ImageInfo = {
   onDisk?: boolean
 }
 
-async function updateActorImageInstance (actor: MActorImages, type: ActorImageType, imageInfo: ImageInfo | null, t: Transaction) {
-  const oldImageModel = type === ActorImageType.AVATAR
-    ? actor.Avatar
-    : actor.Banner
+async function updateActorImages (actor: MActorImages, type: ActorImageType, imagesInfo: ImageInfo[], t: Transaction) {
+  const avatarsOrBanners = type === ActorImageType.AVATAR
+    ? actor.Avatars
+    : actor.Banners
 
-  if (oldImageModel) {
-    // Don't update the avatar if the file URL did not change
-    if (imageInfo?.fileUrl && oldImageModel.fileUrl === imageInfo.fileUrl) return actor
+  if (imagesInfo.length === 0) {
+    await deleteActorImages(actor, type, t)
+  }
+
+  for (const imageInfo of imagesInfo) {
+    const oldImageModel = (avatarsOrBanners || []).find(i => i.width === imageInfo.width)
 
-    try {
-      await oldImageModel.destroy({ transaction: t })
+    if (oldImageModel) {
+      // Don't update the avatar if the file URL did not change
+      if (imageInfo?.fileUrl && oldImageModel.fileUrl === imageInfo.fileUrl) {
+        continue
+      }
 
-      setActorImage(actor, type, null)
-    } catch (err) {
-      logger.error('Cannot remove old actor image of actor %s.', actor.url, { err })
+      await safeDeleteActorImage(actor, oldImageModel, type, t)
     }
-  }
 
-  if (imageInfo) {
     const imageModel = await ActorImageModel.create({
       filename: imageInfo.name,
       onDisk: imageInfo.onDisk ?? false,
       fileUrl: imageInfo.fileUrl,
       height: imageInfo.height,
       width: imageInfo.width,
-      type
+      type,
+      actorId: actor.id
     }, { transaction: t })
 
-    setActorImage(actor, type, imageModel)
+    addActorImage(actor, type, imageModel)
   }
 
   return actor
 }
 
-async function deleteActorImageInstance (actor: MActorImages, type: ActorImageType, t: Transaction) {
+async function deleteActorImages (actor: MActorImages, type: ActorImageType, t: Transaction) {
   try {
-    if (type === ActorImageType.AVATAR) {
-      await actor.Avatar.destroy({ transaction: t })
-
-      actor.avatarId = null
-      actor.Avatar = null
-    } else {
-      await actor.Banner.destroy({ transaction: t })
+    const association = buildAssociationName(type)
 
-      actor.bannerId = null
-      actor.Banner = null
+    for (const image of actor[association]) {
+      await image.destroy({ transaction: t })
     }
+
+    actor[association] = []
   } catch (err) {
     logger.error('Cannot remove old image of actor %s.', actor.url, { err })
   }
@@ -66,29 +65,37 @@ async function deleteActorImageInstance (actor: MActorImages, type: ActorImageTy
   return actor
 }
 
+async function safeDeleteActorImage (actor: MActorImages, toDelete: MActorImage, type: ActorImageType, t: Transaction) {
+  try {
+    await toDelete.destroy({ transaction: t })
+
+    const association = buildAssociationName(type)
+    actor[association] = actor[association].filter(image => image.id !== toDelete.id)
+  } catch (err) {
+    logger.error('Cannot remove old actor image of actor %s.', actor.url, { err })
+  }
+}
+
 // ---------------------------------------------------------------------------
 
 export {
   ImageInfo,
 
-  updateActorImageInstance,
-  deleteActorImageInstance
+  updateActorImages,
+  deleteActorImages
 }
 
 // ---------------------------------------------------------------------------
 
-function setActorImage (actorModel: MActorImages, type: ActorImageType, imageModel: MActorImage) {
-  const id = imageModel
-    ? imageModel.id
-    : null
-
-  if (type === ActorImageType.AVATAR) {
-    actorModel.avatarId = id
-    actorModel.Avatar = imageModel
-  } else {
-    actorModel.bannerId = id
-    actorModel.Banner = imageModel
-  }
+function addActorImage (actor: MActorImages, type: ActorImageType, imageModel: MActorImage) {
+  const association = buildAssociationName(type)
+  if (!actor[association]) actor[association] = []
+
+  actor[association].push(imageModel)
+}
 
-  return actorModel
+function buildAssociationName (type: ActorImageType) {
+  return type === ActorImageType.AVATAR
+    ? 'Avatars'
+    : 'Banners'
 }
diff --git a/server/lib/activitypub/actors/shared/creator.ts b/server/lib/activitypub/actors/shared/creator.ts
index 999aed97d..500bc9912 100644
--- a/server/lib/activitypub/actors/shared/creator.ts
+++ b/server/lib/activitypub/actors/shared/creator.ts
@@ -6,8 +6,8 @@ import { ServerModel } from '@server/models/server/server'
 import { VideoChannelModel } from '@server/models/video/video-channel'
 import { MAccount, MAccountDefault, MActor, MActorFullActor, MActorId, MActorImages, MChannel, MServer } from '@server/types/models'
 import { ActivityPubActor, ActorImageType } from '@shared/models'
-import { updateActorImageInstance } from '../image'
-import { getActorAttributesFromObject, getActorDisplayNameFromObject, getImageInfoFromObject } from './object-to-model-attributes'
+import { updateActorImages } from '../image'
+import { getActorAttributesFromObject, getActorDisplayNameFromObject, getImagesInfoFromObject } from './object-to-model-attributes'
 import { fetchActorFollowsCount } from './url-to-object'
 
 export class APActorCreator {
@@ -27,11 +27,11 @@ export class APActorCreator {
     return sequelizeTypescript.transaction(async t => {
       const server = await this.setServer(actorInstance, t)
 
-      await this.setImageIfNeeded(actorInstance, ActorImageType.AVATAR, t)
-      await this.setImageIfNeeded(actorInstance, ActorImageType.BANNER, t)
-
       const { actorCreated, created } = await this.saveActor(actorInstance, t)
 
+      await this.setImageIfNeeded(actorCreated, ActorImageType.AVATAR, t)
+      await this.setImageIfNeeded(actorCreated, ActorImageType.BANNER, t)
+
       await this.tryToFixActorUrlIfNeeded(actorCreated, actorInstance, created, t)
 
       if (actorCreated.type === 'Person' || actorCreated.type === 'Application') { // Account or PeerTube instance
@@ -71,10 +71,10 @@ export class APActorCreator {
   }
 
   private async setImageIfNeeded (actor: MActor, type: ActorImageType, t: Transaction) {
-    const imageInfo = getImageInfoFromObject(this.actorObject, type)
-    if (!imageInfo) return
+    const imagesInfo = getImagesInfoFromObject(this.actorObject, type)
+    if (imagesInfo.length === 0) return
 
-    return updateActorImageInstance(actor as MActorImages, type, imageInfo, t)
+    return updateActorImages(actor as MActorImages, type, imagesInfo, t)
   }
 
   private async saveActor (actor: MActor, t: Transaction) {
diff --git a/server/lib/activitypub/actors/shared/object-to-model-attributes.ts b/server/lib/activitypub/actors/shared/object-to-model-attributes.ts
index 23bc972e5..f6a78c457 100644
--- a/server/lib/activitypub/actors/shared/object-to-model-attributes.ts
+++ b/server/lib/activitypub/actors/shared/object-to-model-attributes.ts
@@ -4,7 +4,7 @@ import { ActorModel } from '@server/models/actor/actor'
 import { FilteredModelAttributes } from '@server/types'
 import { getLowercaseExtension } from '@shared/core-utils'
 import { buildUUID } from '@shared/extra-utils'
-import { ActivityPubActor, ActorImageType } from '@shared/models'
+import { ActivityIconObject, ActivityPubActor, ActorImageType } from '@shared/models'
 
 function getActorAttributesFromObject (
   actorObject: ActivityPubActor,
@@ -30,33 +30,36 @@ function getActorAttributesFromObject (
   }
 }
 
-function getImageInfoFromObject (actorObject: ActivityPubActor, type: ActorImageType) {
-  const mimetypes = MIMETYPES.IMAGE
-  const icon = type === ActorImageType.AVATAR
-    ? actorObject.icon
+function getImagesInfoFromObject (actorObject: ActivityPubActor, type: ActorImageType) {
+  const iconsOrImages = type === ActorImageType.AVATAR
+    ? actorObject.icons || actorObject.icon
     : actorObject.image
 
-  if (!icon || icon.type !== 'Image' || !isActivityPubUrlValid(icon.url)) return undefined
+  return normalizeIconOrImage(iconsOrImages).map(iconOrImage => {
+    const mimetypes = MIMETYPES.IMAGE
 
-  let extension: string
+    if (iconOrImage.type !== 'Image' || !isActivityPubUrlValid(iconOrImage.url)) return undefined
 
-  if (icon.mediaType) {
-    extension = mimetypes.MIMETYPE_EXT[icon.mediaType]
-  } else {
-    const tmp = getLowercaseExtension(icon.url)
+    let extension: string
 
-    if (mimetypes.EXT_MIMETYPE[tmp] !== undefined) extension = tmp
-  }
+    if (iconOrImage.mediaType) {
+      extension = mimetypes.MIMETYPE_EXT[iconOrImage.mediaType]
+    } else {
+      const tmp = getLowercaseExtension(iconOrImage.url)
 
-  if (!extension) return undefined
+      if (mimetypes.EXT_MIMETYPE[tmp] !== undefined) extension = tmp
+    }
 
-  return {
-    name: buildUUID() + extension,
-    fileUrl: icon.url,
-    height: icon.height,
-    width: icon.width,
-    type
-  }
+    if (!extension) return undefined
+
+    return {
+      name: buildUUID() + extension,
+      fileUrl: iconOrImage.url,
+      height: iconOrImage.height,
+      width: iconOrImage.width,
+      type
+    }
+  })
 }
 
 function getActorDisplayNameFromObject (actorObject: ActivityPubActor) {
@@ -65,6 +68,15 @@ function getActorDisplayNameFromObject (actorObject: ActivityPubActor) {
 
 export {
   getActorAttributesFromObject,
-  getImageInfoFromObject,
+  getImagesInfoFromObject,
   getActorDisplayNameFromObject
 }
+
+// ---------------------------------------------------------------------------
+
+function normalizeIconOrImage (icon: ActivityIconObject | ActivityIconObject[]): ActivityIconObject[] {
+  if (Array.isArray(icon)) return icon
+  if (icon) return [ icon ]
+
+  return []
+}
diff --git a/server/lib/activitypub/actors/updater.ts b/server/lib/activitypub/actors/updater.ts
index 042438d9c..fe94af9f1 100644
--- a/server/lib/activitypub/actors/updater.ts
+++ b/server/lib/activitypub/actors/updater.ts
@@ -5,9 +5,9 @@ import { VideoChannelModel } from '@server/models/video/video-channel'
 import { MAccount, MActor, MActorFull, MChannel } from '@server/types/models'
 import { ActivityPubActor, ActorImageType } from '@shared/models'
 import { getOrCreateAPOwner } from './get'
-import { updateActorImageInstance } from './image'
+import { updateActorImages } from './image'
 import { fetchActorFollowsCount } from './shared'
-import { getImageInfoFromObject } from './shared/object-to-model-attributes'
+import { getImagesInfoFromObject } from './shared/object-to-model-attributes'
 
 export class APActorUpdater {
 
@@ -29,8 +29,8 @@ export class APActorUpdater {
   }
 
   async update () {
-    const avatarInfo = getImageInfoFromObject(this.actorObject, ActorImageType.AVATAR)
-    const bannerInfo = getImageInfoFromObject(this.actorObject, ActorImageType.BANNER)
+    const avatarsInfo = getImagesInfoFromObject(this.actorObject, ActorImageType.AVATAR)
+    const bannersInfo = getImagesInfoFromObject(this.actorObject, ActorImageType.BANNER)
 
     try {
       await this.updateActorInstance(this.actor, this.actorObject)
@@ -47,8 +47,8 @@ export class APActorUpdater {
       }
 
       await runInReadCommittedTransaction(async t => {
-        await updateActorImageInstance(this.actor, ActorImageType.AVATAR, avatarInfo, t)
-        await updateActorImageInstance(this.actor, ActorImageType.BANNER, bannerInfo, t)
+        await updateActorImages(this.actor, ActorImageType.BANNER, bannersInfo, t)
+        await updateActorImages(this.actor, ActorImageType.AVATAR, avatarsInfo, t)
       })
 
       await runInReadCommittedTransaction(async t => {
diff --git a/server/lib/actor-image.ts b/server/lib/actor-image.ts
new file mode 100644
index 000000000..e9bd148f6
--- /dev/null
+++ b/server/lib/actor-image.ts
@@ -0,0 +1,14 @@
+import maxBy from 'lodash/maxBy'
+
+function getBiggestActorImage <T extends { width: number }> (images: T[]) {
+  const image = maxBy(images, 'width')
+
+  // If width is null, maxBy won't return a value
+  if (!image) return images[0]
+
+  return image
+}
+
+export {
+  getBiggestActorImage
+}
diff --git a/server/lib/auth/oauth-model.ts b/server/lib/auth/oauth-model.ts
index 5d68f44e9..910fdeec1 100644
--- a/server/lib/auth/oauth-model.ts
+++ b/server/lib/auth/oauth-model.ts
@@ -5,14 +5,14 @@ import { ActorModel } from '@server/models/actor/actor'
 import { MOAuthClient } from '@server/types/models'
 import { MOAuthTokenUser } from '@server/types/models/oauth/oauth-token'
 import { MUser } from '@server/types/models/user/user'
-import { UserAdminFlag } from '@shared/models/users/user-flag.model'
+import { pick } from '@shared/core-utils'
 import { UserRole } from '@shared/models/users/user-role'
 import { logger } from '../../helpers/logger'
 import { CONFIG } from '../../initializers/config'
 import { OAuthClientModel } from '../../models/oauth/oauth-client'
 import { OAuthTokenModel } from '../../models/oauth/oauth-token'
 import { UserModel } from '../../models/user/user'
-import { createUserAccountAndChannelAndPlaylist } from '../user'
+import { buildUser, createUserAccountAndChannelAndPlaylist } from '../user'
 import { TokensCache } from './tokens-cache'
 
 type TokenInfo = {
@@ -229,19 +229,13 @@ async function createUserFromExternal (pluginAuth: string, options: {
   const actor = await ActorModel.loadLocalByName(options.username)
   if (actor) return null
 
-  const userToCreate = new UserModel({
-    username: options.username,
+  const userToCreate = buildUser({
+    ...pick(options, [ 'username', 'email', 'role' ]),
+
+    emailVerified: null,
     password: null,
-    email: options.email,
-    nsfwPolicy: CONFIG.INSTANCE.DEFAULT_NSFW_POLICY,
-    p2pEnabled: CONFIG.DEFAULTS.P2P.WEBAPP.ENABLED,
-    autoPlayVideo: true,
-    role: options.role,
-    videoQuota: CONFIG.USER.VIDEO_QUOTA,
-    videoQuotaDaily: CONFIG.USER.VIDEO_QUOTA_DAILY,
-    adminFlags: UserAdminFlag.NONE,
     pluginAuth
-  }) as MUser
+  })
 
   const { user } = await createUserAccountAndChannelAndPlaylist({
     userToCreate,
diff --git a/server/lib/client-html.ts b/server/lib/client-html.ts
index 19354ab70..945bc712f 100644
--- a/server/lib/client-html.ts
+++ b/server/lib/client-html.ts
@@ -1,8 +1,10 @@
 import express from 'express'
 import { readFile } from 'fs-extra'
+import memoizee from 'memoizee'
 import { join } from 'path'
 import validator from 'validator'
 import { toCompleteUUID } from '@server/helpers/custom-validators/misc'
+import { ActorImageModel } from '@server/models/actor/actor-image'
 import { root } from '@shared/core-utils'
 import { escapeHTML } from '@shared/core-utils/renderer'
 import { sha256 } from '@shared/extra-utils'
@@ -16,10 +18,11 @@ import { mdToOneLinePlainText } from '../helpers/markdown'
 import { CONFIG } from '../initializers/config'
 import {
   ACCEPT_HEADERS,
-  ACTOR_IMAGES_SIZE,
   CUSTOM_HTML_TAG_COMMENTS,
   EMBED_SIZE,
   FILES_CONTENT_HASH,
+  MEMOIZE_LENGTH,
+  MEMOIZE_TTL,
   PLUGIN_GLOBAL_CSS_PATH,
   WEBSERVER
 } from '../initializers/constants'
@@ -29,8 +32,14 @@ import { VideoModel } from '../models/video/video'
 import { VideoChannelModel } from '../models/video/video-channel'
 import { VideoPlaylistModel } from '../models/video/video-playlist'
 import { MAccountActor, MChannelActor } from '../types/models'
+import { getBiggestActorImage } from './actor-image'
 import { ServerConfigManager } from './server-config-manager'
 
+const getPlainTextDescriptionCached = memoizee(mdToOneLinePlainText, {
+  maxAge: MEMOIZE_TTL.MD_TO_PLAIN_TEXT_CLIENT_HTML,
+  max: MEMOIZE_LENGTH.MD_TO_PLAIN_TEXT_CLIENT_HTML
+})
+
 type Tags = {
   ogType: string
   twitterCard: 'player' | 'summary' | 'summary_large_image'
@@ -103,7 +112,7 @@ class ClientHtml {
       res.status(HttpStatusCode.NOT_FOUND_404)
       return html
     }
-    const description = mdToOneLinePlainText(video.description)
+    const description = getPlainTextDescriptionCached(video.description)
 
     let customHtml = ClientHtml.addTitleTag(html, video.name)
     customHtml = ClientHtml.addDescriptionTag(customHtml, description)
@@ -164,7 +173,7 @@ class ClientHtml {
       return html
     }
 
-    const description = mdToOneLinePlainText(videoPlaylist.description)
+    const description = getPlainTextDescriptionCached(videoPlaylist.description)
 
     let customHtml = ClientHtml.addTitleTag(html, videoPlaylist.name)
     customHtml = ClientHtml.addDescriptionTag(customHtml, description)
@@ -263,7 +272,7 @@ class ClientHtml {
       return ClientHtml.getIndexHTML(req, res)
     }
 
-    const description = mdToOneLinePlainText(entity.description)
+    const description = getPlainTextDescriptionCached(entity.description)
 
     let customHtml = ClientHtml.addTitleTag(html, entity.getDisplayName())
     customHtml = ClientHtml.addDescriptionTag(customHtml, description)
@@ -273,10 +282,11 @@ class ClientHtml {
     const siteName = CONFIG.INSTANCE.NAME
     const title = entity.getDisplayName()
 
+    const avatar = getBiggestActorImage(entity.Actor.Avatars)
     const image = {
-      url: entity.Actor.getAvatarUrl(),
-      width: ACTOR_IMAGES_SIZE.AVATARS.width,
-      height: ACTOR_IMAGES_SIZE.AVATARS.height
+      url: ActorImageModel.getImageUrl(avatar),
+      width: avatar?.width,
+      height: avatar?.height
     }
 
     const ogType = 'website'
diff --git a/server/lib/hls.ts b/server/lib/hls.ts
index 985f50587..43043315b 100644
--- a/server/lib/hls.ts
+++ b/server/lib/hls.ts
@@ -4,7 +4,7 @@ import { basename, dirname, join } from 'path'
 import { MStreamingPlaylistFilesVideo, MVideo, MVideoUUID } from '@server/types/models'
 import { sha256 } from '@shared/extra-utils'
 import { VideoStorage } from '@shared/models'
-import { getAudioStreamCodec, getVideoStreamCodec, getVideoStreamSize } from '../helpers/ffprobe-utils'
+import { getAudioStreamCodec, getVideoStreamCodec, getVideoStreamDimensionsInfo } from '../helpers/ffmpeg'
 import { logger } from '../helpers/logger'
 import { doRequest, doRequestAndSaveToFile } from '../helpers/requests'
 import { generateRandomString } from '../helpers/utils'
@@ -40,10 +40,10 @@ async function updateMasterHLSPlaylist (video: MVideo, playlist: MStreamingPlayl
     const playlistFilename = getHlsResolutionPlaylistFilename(file.filename)
 
     await VideoPathManager.Instance.makeAvailableVideoFile(file.withVideoOrPlaylist(playlist), async videoFilePath => {
-      const size = await getVideoStreamSize(videoFilePath)
+      const size = await getVideoStreamDimensionsInfo(videoFilePath)
 
       const bandwidth = 'BANDWIDTH=' + video.getBandwidthBits(file)
-      const resolution = `RESOLUTION=${size.width}x${size.height}`
+      const resolution = `RESOLUTION=${size?.width || 0}x${size?.height || 0}`
 
       let line = `#EXT-X-STREAM-INF:${bandwidth},${resolution}`
       if (file.fps) line += ',FRAME-RATE=' + file.fps
diff --git a/server/lib/job-queue/handlers/video-edition.ts b/server/lib/job-queue/handlers/video-edition.ts
new file mode 100644
index 000000000..c5ba0452f
--- /dev/null
+++ b/server/lib/job-queue/handlers/video-edition.ts
@@ -0,0 +1,229 @@
+import { Job } from 'bull'
+import { move, remove } from 'fs-extra'
+import { join } from 'path'
+import { addIntroOutro, addWatermark, cutVideo } from '@server/helpers/ffmpeg'
+import { createTorrentAndSetInfoHashFromPath } from '@server/helpers/webtorrent'
+import { CONFIG } from '@server/initializers/config'
+import { federateVideoIfNeeded } from '@server/lib/activitypub/videos'
+import { generateWebTorrentVideoFilename } from '@server/lib/paths'
+import { VideoTranscodingProfilesManager } from '@server/lib/transcoding/default-transcoding-profiles'
+import { isAbleToUploadVideo } from '@server/lib/user'
+import { addMoveToObjectStorageJob, addOptimizeOrMergeAudioJob } from '@server/lib/video'
+import { approximateIntroOutroAdditionalSize } from '@server/lib/video-editor'
+import { VideoPathManager } from '@server/lib/video-path-manager'
+import { buildNextVideoState } from '@server/lib/video-state'
+import { UserModel } from '@server/models/user/user'
+import { VideoModel } from '@server/models/video/video'
+import { VideoFileModel } from '@server/models/video/video-file'
+import { MVideo, MVideoFile, MVideoFullLight, MVideoId, MVideoWithAllFiles } from '@server/types/models'
+import { getLowercaseExtension, pick } from '@shared/core-utils'
+import {
+  buildFileMetadata,
+  buildUUID,
+  ffprobePromise,
+  getFileSize,
+  getVideoStreamDimensionsInfo,
+  getVideoStreamDuration,
+  getVideoStreamFPS
+} from '@shared/extra-utils'
+import {
+  VideoEditionPayload,
+  VideoEditionTaskPayload,
+  VideoEditorTask,
+  VideoEditorTaskCutPayload,
+  VideoEditorTaskIntroPayload,
+  VideoEditorTaskOutroPayload,
+  VideoEditorTaskWatermarkPayload,
+  VideoState
+} from '@shared/models'
+import { logger, loggerTagsFactory } from '../../../helpers/logger'
+
+const lTagsBase = loggerTagsFactory('video-edition')
+
+async function processVideoEdition (job: Job) {
+  const payload = job.data as VideoEditionPayload
+
+  logger.info('Process video edition of %s in job %d.', payload.videoUUID, job.id)
+
+  const video = await VideoModel.loadAndPopulateAccountAndServerAndTags(payload.videoUUID)
+
+  // No video, maybe deleted?
+  if (!video) {
+    logger.info('Can\'t process job %d, video does not exist.', job.id, lTagsBase(payload.videoUUID))
+    return undefined
+  }
+
+  await checkUserQuotaOrThrow(video, payload)
+
+  const inputFile = video.getMaxQualityFile()
+
+  const editionResultPath = await VideoPathManager.Instance.makeAvailableVideoFile(inputFile, async originalFilePath => {
+    let tmpInputFilePath: string
+    let outputPath: string
+
+    for (const task of payload.tasks) {
+      const outputFilename = buildUUID() + inputFile.extname
+      outputPath = join(CONFIG.STORAGE.TMP_DIR, outputFilename)
+
+      await processTask({
+        inputPath: tmpInputFilePath ?? originalFilePath,
+        video,
+        outputPath,
+        task
+      })
+
+      if (tmpInputFilePath) await remove(tmpInputFilePath)
+
+      // For the next iteration
+      tmpInputFilePath = outputPath
+    }
+
+    return outputPath
+  })
+
+  logger.info('Video edition ended for video %s.', video.uuid)
+
+  const newFile = await buildNewFile(video, editionResultPath)
+
+  const outputPath = VideoPathManager.Instance.getFSVideoFileOutputPath(video, newFile)
+  await move(editionResultPath, outputPath)
+
+  await createTorrentAndSetInfoHashFromPath(video, newFile, outputPath)
+
+  await removeAllFiles(video, newFile)
+
+  await newFile.save()
+
+  video.state = buildNextVideoState()
+  video.duration = await getVideoStreamDuration(outputPath)
+  await video.save()
+
+  await federateVideoIfNeeded(video, false, undefined)
+
+  if (video.state === VideoState.TO_TRANSCODE) {
+    const user = await UserModel.loadByVideoId(video.id)
+
+    await addOptimizeOrMergeAudioJob(video, newFile, user, false)
+  } else if (video.state === VideoState.TO_MOVE_TO_EXTERNAL_STORAGE) {
+    await addMoveToObjectStorageJob(video, false)
+  }
+}
+
+// ---------------------------------------------------------------------------
+
+export {
+  processVideoEdition
+}
+
+// ---------------------------------------------------------------------------
+
+type TaskProcessorOptions <T extends VideoEditionTaskPayload = VideoEditionTaskPayload> = {
+  inputPath: string
+  outputPath: string
+  video: MVideo
+  task: T
+}
+
+const taskProcessors: { [id in VideoEditorTask['name']]: (options: TaskProcessorOptions) => Promise<any> } = {
+  'add-intro': processAddIntroOutro,
+  'add-outro': processAddIntroOutro,
+  'cut': processCut,
+  'add-watermark': processAddWatermark
+}
+
+async function processTask (options: TaskProcessorOptions) {
+  const { video, task } = options
+
+  logger.info('Processing %s task for video %s.', task.name, video.uuid, { task })
+
+  const processor = taskProcessors[options.task.name]
+  if (!process) throw new Error('Unknown task ' + task.name)
+
+  return processor(options)
+}
+
+function processAddIntroOutro (options: TaskProcessorOptions<VideoEditorTaskIntroPayload | VideoEditorTaskOutroPayload>) {
+  const { task } = options
+
+  return addIntroOutro({
+    ...pick(options, [ 'inputPath', 'outputPath' ]),
+
+    introOutroPath: task.options.file,
+    type: task.name === 'add-intro'
+      ? 'intro'
+      : 'outro',
+
+    availableEncoders: VideoTranscodingProfilesManager.Instance.getAvailableEncoders(),
+    profile: CONFIG.TRANSCODING.PROFILE
+  })
+}
+
+function processCut (options: TaskProcessorOptions<VideoEditorTaskCutPayload>) {
+  const { task } = options
+
+  return cutVideo({
+    ...pick(options, [ 'inputPath', 'outputPath' ]),
+
+    start: task.options.start,
+    end: task.options.end
+  })
+}
+
+function processAddWatermark (options: TaskProcessorOptions<VideoEditorTaskWatermarkPayload>) {
+  const { task } = options
+
+  return addWatermark({
+    ...pick(options, [ 'inputPath', 'outputPath' ]),
+
+    watermarkPath: task.options.file,
+
+    availableEncoders: VideoTranscodingProfilesManager.Instance.getAvailableEncoders(),
+    profile: CONFIG.TRANSCODING.PROFILE
+  })
+}
+
+async function buildNewFile (video: MVideoId, path: string) {
+  const videoFile = new VideoFileModel({
+    extname: getLowercaseExtension(path),
+    size: await getFileSize(path),
+    metadata: await buildFileMetadata(path),
+    videoStreamingPlaylistId: null,
+    videoId: video.id
+  })
+
+  const probe = await ffprobePromise(path)
+
+  videoFile.fps = await getVideoStreamFPS(path, probe)
+  videoFile.resolution = (await getVideoStreamDimensionsInfo(path, probe)).resolution
+
+  videoFile.filename = generateWebTorrentVideoFilename(videoFile.resolution, videoFile.extname)
+
+  return videoFile
+}
+
+async function removeAllFiles (video: MVideoWithAllFiles, webTorrentFileException: MVideoFile) {
+  const hls = video.getHLSPlaylist()
+
+  if (hls) {
+    await video.removeStreamingPlaylistFiles(hls)
+    await hls.destroy()
+  }
+
+  for (const file of video.VideoFiles) {
+    if (file.id === webTorrentFileException.id) continue
+
+    await video.removeWebTorrentFileAndTorrent(file)
+    await file.destroy()
+  }
+}
+
+async function checkUserQuotaOrThrow (video: MVideoFullLight, payload: VideoEditionPayload) {
+  const user = await UserModel.loadByVideoId(video.id)
+
+  const filePathFinder = (i: number) => (payload.tasks[i] as VideoEditorTaskIntroPayload | VideoEditorTaskOutroPayload).options.file
+
+  const additionalBytes = await approximateIntroOutroAdditionalSize(video, payload.tasks, filePathFinder)
+  if (await isAbleToUploadVideo(user.id, additionalBytes) === false) {
+    throw new Error('Quota exceeded for this user to edit the video')
+  }
+}
diff --git a/server/lib/job-queue/handlers/video-file-import.ts b/server/lib/job-queue/handlers/video-file-import.ts
index 0d9e80cb8..6b2d60317 100644
--- a/server/lib/job-queue/handlers/video-file-import.ts
+++ b/server/lib/job-queue/handlers/video-file-import.ts
@@ -1,18 +1,18 @@
 import { Job } from 'bull'
 import { copy, stat } from 'fs-extra'
-import { getLowercaseExtension } from '@shared/core-utils'
 import { createTorrentAndSetInfoHash } from '@server/helpers/webtorrent'
 import { CONFIG } from '@server/initializers/config'
 import { federateVideoIfNeeded } from '@server/lib/activitypub/videos'
 import { generateWebTorrentVideoFilename } from '@server/lib/paths'
 import { addMoveToObjectStorageJob } from '@server/lib/video'
 import { VideoPathManager } from '@server/lib/video-path-manager'
+import { VideoModel } from '@server/models/video/video'
+import { VideoFileModel } from '@server/models/video/video-file'
 import { MVideoFullLight } from '@server/types/models'
+import { getLowercaseExtension } from '@shared/core-utils'
 import { VideoFileImportPayload, VideoStorage } from '@shared/models'
-import { getVideoFileFPS, getVideoFileResolution } from '../../../helpers/ffprobe-utils'
+import { getVideoStreamFPS, getVideoStreamDimensionsInfo } from '../../../helpers/ffmpeg'
 import { logger } from '../../../helpers/logger'
-import { VideoModel } from '../../../models/video/video'
-import { VideoFileModel } from '../../../models/video/video-file'
 
 async function processVideoFileImport (job: Job) {
   const payload = job.data as VideoFileImportPayload
@@ -45,9 +45,9 @@ export {
 // ---------------------------------------------------------------------------
 
 async function updateVideoFile (video: MVideoFullLight, inputFilePath: string) {
-  const { resolution } = await getVideoFileResolution(inputFilePath)
+  const { resolution } = await getVideoStreamDimensionsInfo(inputFilePath)
   const { size } = await stat(inputFilePath)
-  const fps = await getVideoFileFPS(inputFilePath)
+  const fps = await getVideoStreamFPS(inputFilePath)
 
   const fileExt = getLowercaseExtension(inputFilePath)
 
diff --git a/server/lib/job-queue/handlers/video-import.ts b/server/lib/job-queue/handlers/video-import.ts
index b6e05d8f5..b3ca28c2f 100644
--- a/server/lib/job-queue/handlers/video-import.ts
+++ b/server/lib/job-queue/handlers/video-import.ts
@@ -25,7 +25,7 @@ import {
   VideoResolution,
   VideoState
 } from '@shared/models'
-import { ffprobePromise, getDurationFromVideoFile, getVideoFileFPS, getVideoFileResolution } from '../../../helpers/ffprobe-utils'
+import { ffprobePromise, getVideoStreamDuration, getVideoStreamFPS, getVideoStreamDimensionsInfo } from '../../../helpers/ffmpeg'
 import { logger } from '../../../helpers/logger'
 import { getSecureTorrentName } from '../../../helpers/utils'
 import { createTorrentAndSetInfoHash, downloadWebTorrentVideo } from '../../../helpers/webtorrent'
@@ -121,10 +121,10 @@ async function processFile (downloader: () => Promise<string>, videoImport: MVid
 
     const { resolution } = await isAudioFile(tempVideoPath, probe)
       ? { resolution: VideoResolution.H_NOVIDEO }
-      : await getVideoFileResolution(tempVideoPath)
+      : await getVideoStreamDimensionsInfo(tempVideoPath)
 
-    const fps = await getVideoFileFPS(tempVideoPath, probe)
-    const duration = await getDurationFromVideoFile(tempVideoPath, probe)
+    const fps = await getVideoStreamFPS(tempVideoPath, probe)
+    const duration = await getVideoStreamDuration(tempVideoPath, probe)
 
     // Prepare video file object for creation in database
     const fileExt = getLowercaseExtension(tempVideoPath)
diff --git a/server/lib/job-queue/handlers/video-live-ending.ts b/server/lib/job-queue/handlers/video-live-ending.ts
index a04cfa2c9..497f6612a 100644
--- a/server/lib/job-queue/handlers/video-live-ending.ts
+++ b/server/lib/job-queue/handlers/video-live-ending.ts
@@ -1,12 +1,12 @@
 import { Job } from 'bull'
 import { pathExists, readdir, remove } from 'fs-extra'
 import { join } from 'path'
-import { ffprobePromise, getAudioStream, getDurationFromVideoFile, getVideoFileResolution } from '@server/helpers/ffprobe-utils'
+import { ffprobePromise, getAudioStream, getVideoStreamDuration, getVideoStreamDimensionsInfo } from '@server/helpers/ffmpeg'
 import { VIDEO_LIVE } from '@server/initializers/constants'
 import { buildConcatenatedName, cleanupLive, LiveSegmentShaStore } from '@server/lib/live'
 import { generateHLSMasterPlaylistFilename, generateHlsSha256SegmentsFilename, getLiveDirectory } from '@server/lib/paths'
 import { generateVideoMiniature } from '@server/lib/thumbnail'
-import { generateHlsPlaylistResolutionFromTS } from '@server/lib/transcoding/video-transcoding'
+import { generateHlsPlaylistResolutionFromTS } from '@server/lib/transcoding/transcoding'
 import { VideoPathManager } from '@server/lib/video-path-manager'
 import { moveToNextState } from '@server/lib/video-state'
 import { VideoModel } from '@server/models/video/video'
@@ -96,7 +96,7 @@ async function saveLive (video: MVideo, live: MVideoLive, streamingPlaylist: MSt
     const probe = await ffprobePromise(concatenatedTsFilePath)
     const { audioStream } = await getAudioStream(concatenatedTsFilePath, probe)
 
-    const { resolution, isPortraitMode } = await getVideoFileResolution(concatenatedTsFilePath, probe)
+    const { resolution, isPortraitMode } = await getVideoStreamDimensionsInfo(concatenatedTsFilePath, probe)
 
     const { resolutionPlaylistPath: outputPath } = await generateHlsPlaylistResolutionFromTS({
       video: videoWithFiles,
@@ -107,7 +107,7 @@ async function saveLive (video: MVideo, live: MVideoLive, streamingPlaylist: MSt
     })
 
     if (!durationDone) {
-      videoWithFiles.duration = await getDurationFromVideoFile(outputPath)
+      videoWithFiles.duration = await getVideoStreamDuration(outputPath)
       await videoWithFiles.save()
 
       durationDone = true
diff --git a/server/lib/job-queue/handlers/video-transcoding.ts b/server/lib/job-queue/handlers/video-transcoding.ts
index 5540b791d..512979734 100644
--- a/server/lib/job-queue/handlers/video-transcoding.ts
+++ b/server/lib/job-queue/handlers/video-transcoding.ts
@@ -1,5 +1,5 @@
 import { Job } from 'bull'
-import { TranscodeOptionsType } from '@server/helpers/ffmpeg-utils'
+import { TranscodeVODOptionsType } from '@server/helpers/ffmpeg'
 import { addTranscodingJob, getTranscodingJobPriority } from '@server/lib/video'
 import { VideoPathManager } from '@server/lib/video-path-manager'
 import { moveToFailedTranscodingState, moveToNextState } from '@server/lib/video-state'
@@ -16,7 +16,7 @@ import {
   VideoTranscodingPayload
 } from '@shared/models'
 import { retryTransactionWrapper } from '../../../helpers/database-utils'
-import { computeLowerResolutionsToTranscode } from '../../../helpers/ffprobe-utils'
+import { computeLowerResolutionsToTranscode } from '../../../helpers/ffmpeg'
 import { logger, loggerTagsFactory } from '../../../helpers/logger'
 import { CONFIG } from '../../../initializers/config'
 import { VideoModel } from '../../../models/video/video'
@@ -25,7 +25,7 @@ import {
   mergeAudioVideofile,
   optimizeOriginalVideofile,
   transcodeNewWebTorrentResolution
-} from '../../transcoding/video-transcoding'
+} from '../../transcoding/transcoding'
 
 type HandlerFunction = (job: Job, payload: VideoTranscodingPayload, video: MVideoFullLight, user: MUser) => Promise<void>
 
@@ -174,10 +174,10 @@ async function onHlsPlaylistGeneration (video: MVideoFullLight, user: MUser, pay
 async function onVideoFirstWebTorrentTranscoding (
   videoArg: MVideoWithFile,
   payload: OptimizeTranscodingPayload | MergeAudioTranscodingPayload,
-  transcodeType: TranscodeOptionsType,
+  transcodeType: TranscodeVODOptionsType,
   user: MUserId
 ) {
-  const { resolution, isPortraitMode, audioStream } = await videoArg.getMaxQualityFileInfo()
+  const { resolution, isPortraitMode, audioStream } = await videoArg.probeMaxQualityFile()
 
   // Maybe the video changed in database, refresh it
   const videoDatabase = await VideoModel.loadAndPopulateAccountAndServerAndTags(videoArg.uuid)
diff --git a/server/lib/job-queue/job-queue.ts b/server/lib/job-queue/job-queue.ts
index 22bd1f5d2..e10a3bab5 100644
--- a/server/lib/job-queue/job-queue.ts
+++ b/server/lib/job-queue/job-queue.ts
@@ -14,6 +14,7 @@ import {
   JobType,
   MoveObjectStoragePayload,
   RefreshPayload,
+  VideoEditionPayload,
   VideoFileImportPayload,
   VideoImportPayload,
   VideoLiveEndingPayload,
@@ -31,6 +32,7 @@ import { refreshAPObject } from './handlers/activitypub-refresher'
 import { processActorKeys } from './handlers/actor-keys'
 import { processEmail } from './handlers/email'
 import { processMoveToObjectStorage } from './handlers/move-to-object-storage'
+import { processVideoEdition } from './handlers/video-edition'
 import { processVideoFileImport } from './handlers/video-file-import'
 import { processVideoImport } from './handlers/video-import'
 import { processVideoLiveEnding } from './handlers/video-live-ending'
@@ -53,6 +55,7 @@ type CreateJobArgument =
   { type: 'actor-keys', payload: ActorKeysPayload } |
   { type: 'video-redundancy', payload: VideoRedundancyPayload } |
   { type: 'delete-resumable-upload-meta-file', payload: DeleteResumableUploadMetaFilePayload } |
+  { type: 'video-edition', payload: VideoEditionPayload } |
   { type: 'move-to-object-storage', payload: MoveObjectStoragePayload }
 
 export type CreateJobOptions = {
@@ -75,7 +78,8 @@ const handlers: { [id in JobType]: (job: Job) => Promise<any> } = {
   'video-live-ending': processVideoLiveEnding,
   'actor-keys': processActorKeys,
   'video-redundancy': processVideoRedundancy,
-  'move-to-object-storage': processMoveToObjectStorage
+  'move-to-object-storage': processMoveToObjectStorage,
+  'video-edition': processVideoEdition
 }
 
 const jobTypes: JobType[] = [
@@ -93,7 +97,8 @@ const jobTypes: JobType[] = [
   'video-redundancy',
   'actor-keys',
   'video-live-ending',
-  'move-to-object-storage'
+  'move-to-object-storage',
+  'video-edition'
 ]
 
 class JobQueue {
diff --git a/server/lib/live/live-manager.ts b/server/lib/live/live-manager.ts
index 33e49acc1..21c34a9a4 100644
--- a/server/lib/live/live-manager.ts
+++ b/server/lib/live/live-manager.ts
@@ -5,10 +5,10 @@ import { createServer as createServerTLS, Server as ServerTLS } from 'tls'
 import {
   computeLowerResolutionsToTranscode,
   ffprobePromise,
-  getVideoFileBitrate,
-  getVideoFileFPS,
-  getVideoFileResolution
-} from '@server/helpers/ffprobe-utils'
+  getVideoStreamBitrate,
+  getVideoStreamFPS,
+  getVideoStreamDimensionsInfo
+} from '@server/helpers/ffmpeg'
 import { logger, loggerTagsFactory } from '@server/helpers/logger'
 import { CONFIG, registerConfigChangedHandler } from '@server/initializers/config'
 import { P2P_MEDIA_LOADER_PEER_VERSION, VIDEO_LIVE } from '@server/initializers/constants'
@@ -226,9 +226,9 @@ class LiveManager {
     const probe = await ffprobePromise(inputUrl)
 
     const [ { resolution, ratio }, fps, bitrate ] = await Promise.all([
-      getVideoFileResolution(inputUrl, probe),
-      getVideoFileFPS(inputUrl, probe),
-      getVideoFileBitrate(inputUrl, probe)
+      getVideoStreamDimensionsInfo(inputUrl, probe),
+      getVideoStreamFPS(inputUrl, probe),
+      getVideoStreamBitrate(inputUrl, probe)
     ])
 
     logger.info(
diff --git a/server/lib/live/shared/muxing-session.ts b/server/lib/live/shared/muxing-session.ts
index 22a47942a..f5f473039 100644
--- a/server/lib/live/shared/muxing-session.ts
+++ b/server/lib/live/shared/muxing-session.ts
@@ -5,14 +5,14 @@ import { FfmpegCommand } from 'fluent-ffmpeg'
 import { appendFile, ensureDir, readFile, stat } from 'fs-extra'
 import { basename, join } from 'path'
 import { EventEmitter } from 'stream'
-import { getLiveMuxingCommand, getLiveTranscodingCommand } from '@server/helpers/ffmpeg-utils'
+import { getLiveMuxingCommand, getLiveTranscodingCommand } from '@server/helpers/ffmpeg'
 import { logger, loggerTagsFactory, LoggerTagsFn } from '@server/helpers/logger'
 import { CONFIG } from '@server/initializers/config'
 import { MEMOIZE_TTL, VIDEO_LIVE } from '@server/initializers/constants'
 import { VideoFileModel } from '@server/models/video/video-file'
 import { MStreamingPlaylistVideo, MUserId, MVideoLiveVideo } from '@server/types/models'
 import { getLiveDirectory } from '../../paths'
-import { VideoTranscodingProfilesManager } from '../../transcoding/video-transcoding-profiles'
+import { VideoTranscodingProfilesManager } from '../../transcoding/default-transcoding-profiles'
 import { isAbleToUploadVideo } from '../../user'
 import { LiveQuotaStore } from '../live-quota-store'
 import { LiveSegmentShaStore } from '../live-segment-sha-store'
diff --git a/server/lib/local-actor.ts b/server/lib/local-actor.ts
index c6826759b..01046d017 100644
--- a/server/lib/local-actor.ts
+++ b/server/lib/local-actor.ts
@@ -1,5 +1,5 @@
-import 'multer'
 import { queue } from 'async'
+import { remove } from 'fs-extra'
 import LRUCache from 'lru-cache'
 import { join } from 'path'
 import { ActorModel } from '@server/models/actor/actor'
@@ -13,7 +13,7 @@ import { CONFIG } from '../initializers/config'
 import { ACTOR_IMAGES_SIZE, LRU_CACHE, QUEUE_CONCURRENCY, WEBSERVER } from '../initializers/constants'
 import { sequelizeTypescript } from '../initializers/database'
 import { MAccountDefault, MActor, MChannelDefault } from '../types/models'
-import { deleteActorImageInstance, updateActorImageInstance } from './activitypub/actors'
+import { deleteActorImages, updateActorImages } from './activitypub/actors'
 import { sendUpdateActor } from './activitypub/send'
 
 function buildActorInstance (type: ActivityPubActorType, url: string, preferredUsername: string) {
@@ -33,64 +33,69 @@ function buildActorInstance (type: ActivityPubActorType, url: string, preferredU
   }) as MActor
 }
 
-async function updateLocalActorImageFile (
+async function updateLocalActorImageFiles (
   accountOrChannel: MAccountDefault | MChannelDefault,
   imagePhysicalFile: Express.Multer.File,
   type: ActorImageType
 ) {
-  const imageSize = type === ActorImageType.AVATAR
-    ? ACTOR_IMAGES_SIZE.AVATARS
-    : ACTOR_IMAGES_SIZE.BANNERS
-
-  const extension = getLowercaseExtension(imagePhysicalFile.filename)
-
-  const imageName = buildUUID() + extension
-  const destination = join(CONFIG.STORAGE.ACTOR_IMAGES, imageName)
-  await processImage(imagePhysicalFile.path, destination, imageSize)
-
-  return retryTransactionWrapper(() => {
-    return sequelizeTypescript.transaction(async t => {
-      const actorImageInfo = {
-        name: imageName,
-        fileUrl: null,
-        height: imageSize.height,
-        width: imageSize.width,
-        onDisk: true
-      }
-
-      const updatedActor = await updateActorImageInstance(accountOrChannel.Actor, type, actorImageInfo, t)
-      await updatedActor.save({ transaction: t })
-
-      await sendUpdateActor(accountOrChannel, t)
-
-      return type === ActorImageType.AVATAR
-        ? updatedActor.Avatar
-        : updatedActor.Banner
-    })
-  })
+  const processImageSize = async (imageSize: { width: number, height: number }) => {
+    const extension = getLowercaseExtension(imagePhysicalFile.filename)
+
+    const imageName = buildUUID() + extension
+    const destination = join(CONFIG.STORAGE.ACTOR_IMAGES, imageName)
+    await processImage(imagePhysicalFile.path, destination, imageSize, true)
+
+    return {
+      imageName,
+      imageSize
+    }
+  }
+
+  const processedImages = await Promise.all(ACTOR_IMAGES_SIZE[type].map(processImageSize))
+  await remove(imagePhysicalFile.path)
+
+  return retryTransactionWrapper(() => sequelizeTypescript.transaction(async t => {
+    const actorImagesInfo = processedImages.map(({ imageName, imageSize }) => ({
+      name: imageName,
+      fileUrl: null,
+      height: imageSize.height,
+      width: imageSize.width,
+      onDisk: true
+    }))
+
+    const updatedActor = await updateActorImages(accountOrChannel.Actor, type, actorImagesInfo, t)
+    await updatedActor.save({ transaction: t })
+
+    await sendUpdateActor(accountOrChannel, t)
+
+    return type === ActorImageType.AVATAR
+      ? updatedActor.Avatars
+      : updatedActor.Banners
+  }))
 }
 
 async function deleteLocalActorImageFile (accountOrChannel: MAccountDefault | MChannelDefault, type: ActorImageType) {
   return retryTransactionWrapper(() => {
     return sequelizeTypescript.transaction(async t => {
-      const updatedActor = await deleteActorImageInstance(accountOrChannel.Actor, type, t)
+      const updatedActor = await deleteActorImages(accountOrChannel.Actor, type, t)
       await updatedActor.save({ transaction: t })
 
       await sendUpdateActor(accountOrChannel, t)
 
-      return updatedActor.Avatar
+      return updatedActor.Avatars
     })
   })
 }
 
-type DownloadImageQueueTask = { fileUrl: string, filename: string, type: ActorImageType }
+type DownloadImageQueueTask = {
+  fileUrl: string
+  filename: string
+  type: ActorImageType
+  size: typeof ACTOR_IMAGES_SIZE[ActorImageType][0]
+}
 
 const downloadImageQueue = queue<DownloadImageQueueTask, Error>((task, cb) => {
-  const size = task.type === ActorImageType.AVATAR
-    ? ACTOR_IMAGES_SIZE.AVATARS
-    : ACTOR_IMAGES_SIZE.BANNERS
-
-  downloadImage(task.fileUrl, CONFIG.STORAGE.ACTOR_IMAGES, task.filename, size)
+  downloadImage(task.fileUrl, CONFIG.STORAGE.ACTOR_IMAGES, task.filename, task.size)
     .then(() => cb())
     .catch(err => cb(err))
 }, QUEUE_CONCURRENCY.ACTOR_PROCESS_IMAGE)
@@ -110,7 +115,7 @@ const actorImagePathUnsafeCache = new LRUCache<string, string>({ max: LRU_CACHE.
 
 export {
   actorImagePathUnsafeCache,
-  updateLocalActorImageFile,
+  updateLocalActorImageFiles,
   deleteLocalActorImageFile,
   pushActorImageProcessInQueue,
   buildActorInstance
diff --git a/server/lib/notifier/shared/comment/comment-mention.ts b/server/lib/notifier/shared/comment/comment-mention.ts
index 765cbaad9..ecd1687b4 100644
--- a/server/lib/notifier/shared/comment/comment-mention.ts
+++ b/server/lib/notifier/shared/comment/comment-mention.ts
@@ -77,7 +77,7 @@ export class CommentMention extends AbstractNotification <MCommentOwnerVideo, MU
       userId: user.id,
       commentId: this.payload.id
     })
-    notification.Comment = this.payload
+    notification.VideoComment = this.payload
 
     return notification
   }
diff --git a/server/lib/notifier/shared/comment/new-comment-for-video-owner.ts b/server/lib/notifier/shared/comment/new-comment-for-video-owner.ts
index b76fc15bf..757502703 100644
--- a/server/lib/notifier/shared/comment/new-comment-for-video-owner.ts
+++ b/server/lib/notifier/shared/comment/new-comment-for-video-owner.ts
@@ -44,7 +44,7 @@ export class NewCommentForVideoOwner extends AbstractNotification <MCommentOwner
       userId: user.id,
       commentId: this.payload.id
     })
-    notification.Comment = this.payload
+    notification.VideoComment = this.payload
 
     return notification
   }
diff --git a/server/lib/plugins/plugin-helpers-builder.ts b/server/lib/plugins/plugin-helpers-builder.ts
index 78e4a28ad..897271c0b 100644
--- a/server/lib/plugins/plugin-helpers-builder.ts
+++ b/server/lib/plugins/plugin-helpers-builder.ts
@@ -1,6 +1,6 @@
 import express from 'express'
 import { join } from 'path'
-import { ffprobePromise } from '@server/helpers/ffprobe-utils'
+import { ffprobePromise } from '@server/helpers/ffmpeg/ffprobe-utils'
 import { buildLogger } from '@server/helpers/logger'
 import { CONFIG } from '@server/initializers/config'
 import { WEBSERVER } from '@server/initializers/constants'
diff --git a/server/lib/plugins/register-helpers.ts b/server/lib/plugins/register-helpers.ts
index d1756040a..f4d405676 100644
--- a/server/lib/plugins/register-helpers.ts
+++ b/server/lib/plugins/register-helpers.ts
@@ -21,7 +21,7 @@ import {
   VideoPlaylistPrivacy,
   VideoPrivacy
 } from '@shared/models'
-import { VideoTranscodingProfilesManager } from '../transcoding/video-transcoding-profiles'
+import { VideoTranscodingProfilesManager } from '../transcoding/default-transcoding-profiles'
 import { buildPluginHelpers } from './plugin-helpers-builder'
 
 export class RegisterHelpers {
diff --git a/server/lib/server-config-manager.ts b/server/lib/server-config-manager.ts
index d97f21eb7..38512f384 100644
--- a/server/lib/server-config-manager.ts
+++ b/server/lib/server-config-manager.ts
@@ -8,7 +8,7 @@ import { HTMLServerConfig, RegisteredExternalAuthConfig, RegisteredIdAndPassAuth
 import { Hooks } from './plugins/hooks'
 import { PluginManager } from './plugins/plugin-manager'
 import { getThemeOrDefault } from './plugins/theme-utils'
-import { VideoTranscodingProfilesManager } from './transcoding/video-transcoding-profiles'
+import { VideoTranscodingProfilesManager } from './transcoding/default-transcoding-profiles'
 
 /**
  *
@@ -151,6 +151,9 @@ class ServerConfigManager {
           port: CONFIG.LIVE.RTMP.PORT
         }
       },
+      videoEditor: {
+        enabled: CONFIG.VIDEO_EDITOR.ENABLED
+      },
       import: {
         videos: {
           http: {
diff --git a/server/lib/thumbnail.ts b/server/lib/thumbnail.ts
index 36270e5c1..aa2d7a813 100644
--- a/server/lib/thumbnail.ts
+++ b/server/lib/thumbnail.ts
@@ -1,7 +1,6 @@
 import { join } from 'path'
-import { ThumbnailType } from '../../shared/models/videos/thumbnail.type'
-import { generateImageFromVideoFile } from '../helpers/ffmpeg-utils'
-import { generateImageFilename, processImage } from '../helpers/image-utils'
+import { ThumbnailType } from '@shared/models'
+import { generateImageFilename, generateImageFromVideoFile, processImage } from '../helpers/image-utils'
 import { downloadImage } from '../helpers/requests'
 import { CONFIG } from '../initializers/config'
 import { ASSETS_PATH, PREVIEWS_SIZE, THUMBNAILS_SIZE } from '../initializers/constants'
diff --git a/server/lib/transcoding/video-transcoding-profiles.ts b/server/lib/transcoding/default-transcoding-profiles.ts
index dcc8d4c5c..ba98a11ca 100644
--- a/server/lib/transcoding/video-transcoding-profiles.ts
+++ b/server/lib/transcoding/default-transcoding-profiles.ts
@@ -2,8 +2,14 @@
 import { logger } from '@server/helpers/logger'
 import { getAverageBitrate, getMinLimitBitrate } from '@shared/core-utils'
 import { AvailableEncoders, EncoderOptionsBuilder, EncoderOptionsBuilderParams, VideoResolution } from '../../../shared/models/videos'
-import { buildStreamSuffix, resetSupportedEncoders } from '../../helpers/ffmpeg-utils'
-import { canDoQuickAudioTranscode, ffprobePromise, getAudioStream, getMaxAudioBitrate } from '../../helpers/ffprobe-utils'
+import {
+  buildStreamSuffix,
+  canDoQuickAudioTranscode,
+  ffprobePromise,
+  getAudioStream,
+  getMaxAudioBitrate,
+  resetSupportedEncoders
+} from '../../helpers/ffmpeg'
 
 /**
  *
@@ -15,8 +21,14 @@ import { canDoQuickAudioTranscode, ffprobePromise, getAudioStream, getMaxAudioBi
  *  * https://trac.ffmpeg.org/wiki/Limiting%20the%20output%20bitrate
  */
 
+// ---------------------------------------------------------------------------
+// Default builders
+// ---------------------------------------------------------------------------
+
 const defaultX264VODOptionsBuilder: EncoderOptionsBuilder = (options: EncoderOptionsBuilderParams) => {
   const { fps, inputRatio, inputBitrate, resolution } = options
+
+  // TODO: remove in 4.2, fps is not optional anymore
   if (!fps) return { outputOptions: [ ] }
 
   const targetBitrate = getTargetBitrate({ inputBitrate, ratio: inputRatio, fps, resolution })
@@ -45,10 +57,10 @@ const defaultX264LiveOptionsBuilder: EncoderOptionsBuilder = (options: EncoderOp
   }
 }
 
-const defaultAACOptionsBuilder: EncoderOptionsBuilder = async ({ input, streamNum }) => {
+const defaultAACOptionsBuilder: EncoderOptionsBuilder = async ({ input, streamNum, canCopyAudio }) => {
   const probe = await ffprobePromise(input)
 
-  if (await canDoQuickAudioTranscode(input, probe)) {
+  if (canCopyAudio && await canDoQuickAudioTranscode(input, probe)) {
     logger.debug('Copy audio stream %s by AAC encoder.', input)
     return { copy: true, outputOptions: [ ] }
   }
@@ -75,7 +87,10 @@ const defaultLibFDKAACVODOptionsBuilder: EncoderOptionsBuilder = ({ streamNum })
   return { outputOptions: [ buildStreamSuffix('-q:a', streamNum), '5' ] }
 }
 
-// Used to get and update available encoders
+// ---------------------------------------------------------------------------
+// Profile manager to get and change default profiles
+// ---------------------------------------------------------------------------
+
 class VideoTranscodingProfilesManager {
   private static instance: VideoTranscodingProfilesManager
 
diff --git a/server/lib/transcoding/video-transcoding.ts b/server/lib/transcoding/transcoding.ts
index 9942a067b..d55364e25 100644
--- a/server/lib/transcoding/video-transcoding.ts
+++ b/server/lib/transcoding/transcoding.ts
@@ -6,8 +6,15 @@ import { createTorrentAndSetInfoHash } from '@server/helpers/webtorrent'
 import { MStreamingPlaylistFilesVideo, MVideoFile, MVideoFullLight } from '@server/types/models'
 import { VideoResolution, VideoStorage } from '../../../shared/models/videos'
 import { VideoStreamingPlaylistType } from '../../../shared/models/videos/video-streaming-playlist.type'
-import { transcode, TranscodeOptions, TranscodeOptionsType } from '../../helpers/ffmpeg-utils'
-import { canDoQuickTranscode, getDurationFromVideoFile, getMetadataFromFile, getVideoFileFPS } from '../../helpers/ffprobe-utils'
+import {
+  canDoQuickTranscode,
+  getVideoStreamDuration,
+  buildFileMetadata,
+  getVideoStreamFPS,
+  transcodeVOD,
+  TranscodeVODOptions,
+  TranscodeVODOptionsType
+} from '../../helpers/ffmpeg'
 import { CONFIG } from '../../initializers/config'
 import { P2P_MEDIA_LOADER_PEER_VERSION } from '../../initializers/constants'
 import { VideoFileModel } from '../../models/video/video-file'
@@ -21,7 +28,7 @@ import {
   getHlsResolutionPlaylistFilename
 } from '../paths'
 import { VideoPathManager } from '../video-path-manager'
-import { VideoTranscodingProfilesManager } from './video-transcoding-profiles'
+import { VideoTranscodingProfilesManager } from './default-transcoding-profiles'
 
 /**
  *
@@ -38,13 +45,13 @@ function optimizeOriginalVideofile (video: MVideoFullLight, inputVideoFile: MVid
   return VideoPathManager.Instance.makeAvailableVideoFile(inputVideoFile.withVideoOrPlaylist(video), async videoInputPath => {
     const videoTranscodedPath = join(transcodeDirectory, video.id + '-transcoded' + newExtname)
 
-    const transcodeType: TranscodeOptionsType = await canDoQuickTranscode(videoInputPath)
+    const transcodeType: TranscodeVODOptionsType = await canDoQuickTranscode(videoInputPath)
       ? 'quick-transcode'
       : 'video'
 
     const resolution = toEven(inputVideoFile.resolution)
 
-    const transcodeOptions: TranscodeOptions = {
+    const transcodeOptions: TranscodeVODOptions = {
       type: transcodeType,
 
       inputPath: videoInputPath,
@@ -59,7 +66,7 @@ function optimizeOriginalVideofile (video: MVideoFullLight, inputVideoFile: MVid
     }
 
     // Could be very long!
-    await transcode(transcodeOptions)
+    await transcodeVOD(transcodeOptions)
 
     // Important to do this before getVideoFilename() to take in account the new filename
     inputVideoFile.extname = newExtname
@@ -121,7 +128,7 @@ function transcodeNewWebTorrentResolution (video: MVideoFullLight, resolution: V
         job
       }
 
-    await transcode(transcodeOptions)
+    await transcodeVOD(transcodeOptions)
 
     return onWebTorrentVideoFileTranscoding(video, newVideoFile, videoTranscodedPath, videoOutputPath)
   })
@@ -158,7 +165,7 @@ function mergeAudioVideofile (video: MVideoFullLight, resolution: VideoResolutio
     }
 
     try {
-      await transcode(transcodeOptions)
+      await transcodeVOD(transcodeOptions)
 
       await remove(audioInputPath)
       await remove(tmpPreviewPath)
@@ -175,7 +182,7 @@ function mergeAudioVideofile (video: MVideoFullLight, resolution: VideoResolutio
     const videoOutputPath = VideoPathManager.Instance.getFSVideoFileOutputPath(video, inputVideoFile)
     // ffmpeg generated a new video file, so update the video duration
     // See https://trac.ffmpeg.org/ticket/5456
-    video.duration = await getDurationFromVideoFile(videoTranscodedPath)
+    video.duration = await getVideoStreamDuration(videoTranscodedPath)
     await video.save()
 
     return onWebTorrentVideoFileTranscoding(video, inputVideoFile, videoTranscodedPath, videoOutputPath)
@@ -239,8 +246,8 @@ async function onWebTorrentVideoFileTranscoding (
   outputPath: string
 ) {
   const stats = await stat(transcodingPath)
-  const fps = await getVideoFileFPS(transcodingPath)
-  const metadata = await getMetadataFromFile(transcodingPath)
+  const fps = await getVideoStreamFPS(transcodingPath)
+  const metadata = await buildFileMetadata(transcodingPath)
 
   await move(transcodingPath, outputPath, { overwrite: true })
 
@@ -299,7 +306,7 @@ async function generateHlsPlaylistCommon (options: {
     job
   }
 
-  await transcode(transcodeOptions)
+  await transcodeVOD(transcodeOptions)
 
   // Create or update the playlist
   const playlist = await VideoStreamingPlaylistModel.loadOrGenerate(video)
@@ -344,8 +351,8 @@ async function generateHlsPlaylistCommon (options: {
   const stats = await stat(videoFilePath)
 
   newVideoFile.size = stats.size
-  newVideoFile.fps = await getVideoFileFPS(videoFilePath)
-  newVideoFile.metadata = await getMetadataFromFile(videoFilePath)
+  newVideoFile.fps = await getVideoStreamFPS(videoFilePath)
+  newVideoFile.metadata = await buildFileMetadata(videoFilePath)
 
   await createTorrentAndSetInfoHash(playlist, newVideoFile)
 
diff --git a/server/lib/user.ts b/server/lib/user.ts
index 0d292ac90..ea755f4be 100644
--- a/server/lib/user.ts
+++ b/server/lib/user.ts
@@ -1,9 +1,11 @@
 import { Transaction } from 'sequelize/types'
+import { logger } from '@server/helpers/logger'
+import { CONFIG } from '@server/initializers/config'
 import { UserModel } from '@server/models/user/user'
 import { MActorDefault } from '@server/types/models/actor'
 import { buildUUID } from '@shared/extra-utils'
 import { ActivityPubActorType } from '../../shared/models/activitypub'
-import { UserNotificationSetting, UserNotificationSettingValue } from '../../shared/models/users'
+import { UserAdminFlag, UserNotificationSetting, UserNotificationSettingValue, UserRole } from '../../shared/models/users'
 import { SERVER_ACTOR_NAME, WEBSERVER } from '../initializers/constants'
 import { sequelizeTypescript } from '../initializers/database'
 import { AccountModel } from '../models/account/account'
@@ -22,6 +24,53 @@ import { createWatchLaterPlaylist } from './video-playlist'
 
 type ChannelNames = { name: string, displayName: string }
 
+function buildUser (options: {
+  username: string
+  password: string
+  email: string
+
+  role?: UserRole // Default to UserRole.User
+  adminFlags?: UserAdminFlag // Default to UserAdminFlag.NONE
+
+  emailVerified: boolean | null
+
+  videoQuota?: number // Default to CONFIG.USER.VIDEO_QUOTA
+  videoQuotaDaily?: number // Default to CONFIG.USER.VIDEO_QUOTA_DAILY
+
+  pluginAuth?: string
+}): MUser {
+  const {
+    username,
+    password,
+    email,
+    role = UserRole.USER,
+    emailVerified,
+    videoQuota = CONFIG.USER.VIDEO_QUOTA,
+    videoQuotaDaily = CONFIG.USER.VIDEO_QUOTA_DAILY,
+    adminFlags = UserAdminFlag.NONE,
+    pluginAuth
+  } = options
+
+  return new UserModel({
+    username,
+    password,
+    email,
+
+    nsfwPolicy: CONFIG.INSTANCE.DEFAULT_NSFW_POLICY,
+    p2pEnabled: CONFIG.DEFAULTS.P2P.WEBAPP.ENABLED,
+    autoPlayVideo: true,
+
+    role,
+    emailVerified,
+    adminFlags,
+
+    videoQuota: videoQuota,
+    videoQuotaDaily: videoQuotaDaily,
+
+    pluginAuth
+  })
+}
+
 async function createUserAccountAndChannelAndPlaylist (parameters: {
   userToCreate: MUser
   userDisplayName?: string
@@ -117,7 +166,7 @@ async function sendVerifyUserEmail (user: MUser, isPendingEmail = false) {
   const email = isPendingEmail ? user.pendingEmail : user.email
   const username = user.username
 
-  await Emailer.Instance.addVerifyEmailJob(username, email, url)
+  Emailer.Instance.addVerifyEmailJob(username, email, url)
 }
 
 async function getOriginalVideoFileTotalFromUser (user: MUserId) {
@@ -159,6 +208,11 @@ async function isAbleToUploadVideo (userId: number, newVideoSize: number) {
   const uploadedTotal = newVideoSize + totalBytes
   const uploadedDaily = newVideoSize + totalBytesDaily
 
+  logger.debug(
+    'Check user %d quota to upload another video.', userId,
+    { totalBytes, totalBytesDaily, videoQuota: user.videoQuota, videoQuotaDaily: user.videoQuotaDaily, newVideoSize }
+  )
+
   if (user.videoQuotaDaily === -1) return uploadedTotal < user.videoQuota
   if (user.videoQuota === -1) return uploadedDaily < user.videoQuotaDaily
 
@@ -174,7 +228,8 @@ export {
   createUserAccountAndChannelAndPlaylist,
   createLocalAccountWithoutKeys,
   sendVerifyUserEmail,
-  isAbleToUploadVideo
+  isAbleToUploadVideo,
+  buildUser
 }
 
 // ---------------------------------------------------------------------------
diff --git a/server/lib/video-editor.ts b/server/lib/video-editor.ts
new file mode 100644
index 000000000..99b0bd949
--- /dev/null
+++ b/server/lib/video-editor.ts
@@ -0,0 +1,32 @@
+import { MVideoFullLight } from "@server/types/models"
+import { getVideoStreamDuration } from "@shared/extra-utils"
+import { VideoEditorTask } from "@shared/models"
+
+function buildTaskFileFieldname (indice: number, fieldName = 'file') {
+  return `tasks[${indice}][options][${fieldName}]`
+}
+
+function getTaskFile (files: Express.Multer.File[], indice: number, fieldName = 'file') {
+  return files.find(f => f.fieldname === buildTaskFileFieldname(indice, fieldName))
+}
+
+async function approximateIntroOutroAdditionalSize (video: MVideoFullLight, tasks: VideoEditorTask[], fileFinder: (i: number) => string) {
+  let additionalDuration = 0
+
+  for (let i = 0; i < tasks.length; i++) {
+    const task = tasks[i]
+
+    if (task.name !== 'add-intro' && task.name !== 'add-outro') continue
+
+    const filePath = fileFinder(i)
+    additionalDuration += await getVideoStreamDuration(filePath)
+  }
+
+  return (video.getMaxQualityFile().size / video.duration) * additionalDuration
+}
+
+export {
+  approximateIntroOutroAdditionalSize,
+  buildTaskFileFieldname,
+  getTaskFile
+}
diff --git a/server/lib/video.ts b/server/lib/video.ts
index 2690f953d..ec4256c1a 100644
--- a/server/lib/video.ts
+++ b/server/lib/video.ts
@@ -81,7 +81,7 @@ async function setVideoTags (options: {
   video.Tags = tagInstances
 }
 
-async function addOptimizeOrMergeAudioJob (video: MVideoUUID, videoFile: MVideoFile, user: MUserId) {
+async function addOptimizeOrMergeAudioJob (video: MVideoUUID, videoFile: MVideoFile, user: MUserId, isNewVideo = true) {
   let dataInput: VideoTranscodingPayload
 
   if (videoFile.isAudio()) {
@@ -90,13 +90,13 @@ async function addOptimizeOrMergeAudioJob (video: MVideoUUID, videoFile: MVideoF
       resolution: DEFAULT_AUDIO_RESOLUTION,
       videoUUID: video.uuid,
       createHLSIfNeeded: true,
-      isNewVideo: true
+      isNewVideo
     }
   } else {
     dataInput = {
       type: 'optimize-to-webtorrent',
       videoUUID: video.uuid,
-      isNewVideo: true
+      isNewVideo
     }
   }
 
diff --git a/server/middlewares/validators/config.ts b/server/middlewares/validators/config.ts
index 8b14feb3c..e87b2e39d 100644
--- a/server/middlewares/validators/config.ts
+++ b/server/middlewares/validators/config.ts
@@ -57,6 +57,8 @@ const customConfigUpdateValidator = [
   body('transcoding.webtorrent.enabled').isBoolean().withMessage('Should have a valid webtorrent transcoding enabled boolean'),
   body('transcoding.hls.enabled').isBoolean().withMessage('Should have a valid hls transcoding enabled boolean'),
 
+  body('videoEditor.enabled').isBoolean().withMessage('Should have a valid video editor enabled boolean'),
+
   body('import.videos.concurrency').isInt({ min: 0 }).withMessage('Should have a valid import concurrency number'),
   body('import.videos.http.enabled').isBoolean().withMessage('Should have a valid import video http enabled boolean'),
   body('import.videos.torrent.enabled').isBoolean().withMessage('Should have a valid import video torrent enabled boolean'),
@@ -104,6 +106,7 @@ const customConfigUpdateValidator = [
     if (!checkInvalidConfigIfEmailDisabled(req.body, res)) return
     if (!checkInvalidTranscodingConfig(req.body, res)) return
     if (!checkInvalidLiveConfig(req.body, res)) return
+    if (!checkInvalidVideoEditorConfig(req.body, res)) return
 
     return next()
   }
@@ -159,3 +162,14 @@ function checkInvalidLiveConfig (customConfig: CustomConfig, res: express.Respon
 
   return true
 }
+
+function checkInvalidVideoEditorConfig (customConfig: CustomConfig, res: express.Response) {
+  if (customConfig.videoEditor.enabled === false) return true
+
+  if (customConfig.videoEditor.enabled === true && customConfig.transcoding.enabled === false) {
+    res.fail({ message: 'You cannot enable video editor if transcoding is not enabled' })
+    return false
+  }
+
+  return true
+}
diff --git a/server/middlewares/validators/shared/utils.ts b/server/middlewares/validators/shared/utils.ts
index 104eace91..410de4d80 100644
--- a/server/middlewares/validators/shared/utils.ts
+++ b/server/middlewares/validators/shared/utils.ts
@@ -8,6 +8,7 @@ function areValidationErrors (req: express.Request, res: express.Response) {
 
   if (!errors.isEmpty()) {
     logger.warn('Incorrect request parameters', { path: req.originalUrl, err: errors.mapped() })
+
     res.fail({
       message: 'Incorrect request parameters: ' + Object.keys(errors.mapped()).join(', '),
       instance: req.originalUrl,
diff --git a/server/middlewares/validators/shared/videos.ts b/server/middlewares/validators/shared/videos.ts
index fc978b63a..8807435f6 100644
--- a/server/middlewares/validators/shared/videos.ts
+++ b/server/middlewares/validators/shared/videos.ts
@@ -1,5 +1,6 @@
 import { Request, Response } from 'express'
 import { loadVideo, VideoLoadType } from '@server/lib/model-loaders'
+import { isAbleToUploadVideo } from '@server/lib/user'
 import { authenticatePromiseIfNeeded } from '@server/middlewares/auth'
 import { VideoModel } from '@server/models/video/video'
 import { VideoChannelModel } from '@server/models/video/video-channel'
@@ -7,6 +8,7 @@ import { VideoFileModel } from '@server/models/video/video-file'
 import {
   MUser,
   MUserAccountId,
+  MUserId,
   MVideo,
   MVideoAccountLight,
   MVideoFormattableDetails,
@@ -16,7 +18,7 @@ import {
   MVideoThumbnail,
   MVideoWithRights
 } from '@server/types/models'
-import { HttpStatusCode, UserRight } from '@shared/models'
+import { HttpStatusCode, ServerErrorCode, UserRight } from '@shared/models'
 
 async function doesVideoExist (id: number | string, res: Response, fetchType: VideoLoadType = 'all') {
   const userId = res.locals.oauth ? res.locals.oauth.token.User.id : undefined
@@ -108,6 +110,11 @@ async function checkCanSeePrivateVideo (req: Request, res: Response, video: MVid
 
   // Only the owner or a user that have blocklist rights can see the video
   if (!user || !user.canGetVideo(video)) {
+    res.fail({
+      status: HttpStatusCode.FORBIDDEN_403,
+      message: 'Cannot fetch information of private/internal/blocklisted video'
+    })
+
     return false
   }
 
@@ -139,13 +146,28 @@ function checkUserCanManageVideo (user: MUser, video: MVideoAccountLight, right:
   return true
 }
 
+async function checkUserQuota (user: MUserId, videoFileSize: number, res: Response) {
+  if (await isAbleToUploadVideo(user.id, videoFileSize) === false) {
+    res.fail({
+      status: HttpStatusCode.PAYLOAD_TOO_LARGE_413,
+      message: 'The user video quota is exceeded with this video.',
+      type: ServerErrorCode.QUOTA_REACHED
+    })
+    return false
+  }
+
+  return true
+}
+
 // ---------------------------------------------------------------------------
 
 export {
   doesVideoChannelOfAccountExist,
   doesVideoExist,
   doesVideoFileOfVideoExist,
+
   checkUserCanManageVideo,
   checkCanSeeVideoIfPrivate,
-  checkCanSeePrivateVideo
+  checkCanSeePrivateVideo,
+  checkUserQuota
 }
diff --git a/server/middlewares/validators/videos/index.ts b/server/middlewares/validators/videos/index.ts
index f365d8ee1..faa082510 100644
--- a/server/middlewares/validators/videos/index.ts
+++ b/server/middlewares/validators/videos/index.ts
@@ -2,6 +2,7 @@ export * from './video-blacklist'
 export * from './video-captions'
 export * from './video-channels'
 export * from './video-comments'
+export * from './video-editor'
 export * from './video-files'
 export * from './video-imports'
 export * from './video-live'
diff --git a/server/middlewares/validators/videos/video-captions.ts b/server/middlewares/validators/videos/video-captions.ts
index a399871e1..441c6b4be 100644
--- a/server/middlewares/validators/videos/video-captions.ts
+++ b/server/middlewares/validators/videos/video-captions.ts
@@ -1,6 +1,6 @@
 import express from 'express'
 import { body, param } from 'express-validator'
-import { HttpStatusCode, UserRight } from '@shared/models'
+import { UserRight } from '@shared/models'
 import { isVideoCaptionFile, isVideoCaptionLanguageValid } from '../../../helpers/custom-validators/video-captions'
 import { cleanUpReqFiles } from '../../../helpers/express-utils'
 import { logger } from '../../../helpers/logger'
@@ -74,13 +74,7 @@ const listVideoCaptionsValidator = [
     if (!await doesVideoExist(req.params.videoId, res, 'only-video')) return
 
     const video = res.locals.onlyVideo
-
-    if (!await checkCanSeeVideoIfPrivate(req, res, video)) {
-      return res.fail({
-        status: HttpStatusCode.FORBIDDEN_403,
-        message: 'Cannot list captions of private/internal/blocklisted video'
-      })
-    }
+    if (!await checkCanSeeVideoIfPrivate(req, res, video)) return
 
     return next()
   }
diff --git a/server/middlewares/validators/videos/video-comments.ts b/server/middlewares/validators/videos/video-comments.ts
index 91e85711d..698afdbd1 100644
--- a/server/middlewares/validators/videos/video-comments.ts
+++ b/server/middlewares/validators/videos/video-comments.ts
@@ -54,12 +54,7 @@ const listVideoCommentThreadsValidator = [
     if (areValidationErrors(req, res)) return
     if (!await doesVideoExist(req.params.videoId, res, 'only-video')) return
 
-    if (!await checkCanSeeVideoIfPrivate(req, res, res.locals.onlyVideo)) {
-      return res.fail({
-        status: HttpStatusCode.FORBIDDEN_403,
-        message: 'Cannot list comments of private/internal/blocklisted video'
-      })
-    }
+    if (!await checkCanSeeVideoIfPrivate(req, res, res.locals.onlyVideo)) return
 
     return next()
   }
@@ -78,12 +73,7 @@ const listVideoThreadCommentsValidator = [
     if (!await doesVideoExist(req.params.videoId, res, 'only-video')) return
     if (!await doesVideoCommentThreadExist(req.params.threadId, res.locals.onlyVideo, res)) return
 
-    if (!await checkCanSeeVideoIfPrivate(req, res, res.locals.onlyVideo)) {
-      return res.fail({
-        status: HttpStatusCode.FORBIDDEN_403,
-        message: 'Cannot list threads of private/internal/blocklisted video'
-      })
-    }
+    if (!await checkCanSeeVideoIfPrivate(req, res, res.locals.onlyVideo)) return
 
     return next()
   }
@@ -101,12 +91,7 @@ const addVideoCommentThreadValidator = [
     if (areValidationErrors(req, res)) return
     if (!await doesVideoExist(req.params.videoId, res)) return
 
-    if (!await checkCanSeeVideoIfPrivate(req, res, res.locals.videoAll)) {
-      return res.fail({
-        status: HttpStatusCode.FORBIDDEN_403,
-        message: 'Cannot access to this ressource'
-      })
-    }
+    if (!await checkCanSeeVideoIfPrivate(req, res, res.locals.videoAll)) return
 
     if (!isVideoCommentsEnabled(res.locals.videoAll, res)) return
     if (!await isVideoCommentAccepted(req, res, res.locals.videoAll, false)) return
@@ -128,12 +113,7 @@ const addVideoCommentReplyValidator = [
     if (areValidationErrors(req, res)) return
     if (!await doesVideoExist(req.params.videoId, res)) return
 
-    if (!await checkCanSeeVideoIfPrivate(req, res, res.locals.videoAll)) {
-      return res.fail({
-        status: HttpStatusCode.FORBIDDEN_403,
-        message: 'Cannot access to this ressource'
-      })
-    }
+    if (!await checkCanSeeVideoIfPrivate(req, res, res.locals.videoAll)) return
 
     if (!isVideoCommentsEnabled(res.locals.videoAll, res)) return
     if (!await doesVideoCommentExist(req.params.commentId, res.locals.videoAll, res)) return
diff --git a/server/middlewares/validators/videos/video-editor.ts b/server/middlewares/validators/videos/video-editor.ts
new file mode 100644
index 000000000..9be97be93
--- /dev/null
+++ b/server/middlewares/validators/videos/video-editor.ts
@@ -0,0 +1,112 @@
+import express from 'express'
+import { body, param } from 'express-validator'
+import { isIdOrUUIDValid } from '@server/helpers/custom-validators/misc'
+import {
+  isEditorCutTaskValid,
+  isEditorTaskAddIntroOutroValid,
+  isEditorTaskAddWatermarkValid,
+  isValidEditorTasksArray
+} from '@server/helpers/custom-validators/video-editor'
+import { cleanUpReqFiles } from '@server/helpers/express-utils'
+import { CONFIG } from '@server/initializers/config'
+import { approximateIntroOutroAdditionalSize, getTaskFile } from '@server/lib/video-editor'
+import { isAudioFile } from '@shared/extra-utils'
+import { HttpStatusCode, UserRight, VideoEditorCreateEdition, VideoEditorTask, VideoState } from '@shared/models'
+import { logger } from '../../../helpers/logger'
+import { areValidationErrors, checkUserCanManageVideo, checkUserQuota, doesVideoExist } from '../shared'
+
+const videosEditorAddEditionValidator = [
+  param('videoId').custom(isIdOrUUIDValid).withMessage('Should have a valid video id/uuid'),
+
+  body('tasks').custom(isValidEditorTasksArray).withMessage('Should have a valid array of tasks'),
+
+  async (req: express.Request, res: express.Response, next: express.NextFunction) => {
+    logger.debug('Checking videosEditorAddEditionValidator parameters.', { parameters: req.params, body: req.body, files: req.files })
+
+    if (CONFIG.VIDEO_EDITOR.ENABLED !== true) {
+      res.fail({
+        status: HttpStatusCode.BAD_REQUEST_400,
+        message: 'Video editor is disabled on this instance'
+      })
+
+      return cleanUpReqFiles(req)
+    }
+
+    if (areValidationErrors(req, res)) return cleanUpReqFiles(req)
+
+    const body: VideoEditorCreateEdition = req.body
+    const files = req.files as Express.Multer.File[]
+
+    for (let i = 0; i < body.tasks.length; i++) {
+      const task = body.tasks[i]
+
+      if (!checkTask(req, task, i)) {
+        res.fail({
+          status: HttpStatusCode.BAD_REQUEST_400,
+          message: `Task ${task.name} is invalid`
+        })
+
+        return cleanUpReqFiles(req)
+      }
+
+      if (task.name === 'add-intro' || task.name === 'add-outro') {
+        const filePath = getTaskFile(files, i).path
+
+        // Our concat filter needs a video stream
+        if (await isAudioFile(filePath)) {
+          res.fail({
+            status: HttpStatusCode.BAD_REQUEST_400,
+            message: `Task ${task.name} is invalid: file does not contain a video stream`
+          })
+
+          return cleanUpReqFiles(req)
+        }
+      }
+    }
+
+    if (!await doesVideoExist(req.params.videoId, res)) return cleanUpReqFiles(req)
+
+    const video = res.locals.videoAll
+    if (video.state === VideoState.TO_TRANSCODE || video.state === VideoState.TO_EDIT) {
+      res.fail({
+        status: HttpStatusCode.CONFLICT_409,
+        message: 'Cannot edit video that is already waiting for transcoding/edition'
+      })
+
+      return cleanUpReqFiles(req)
+    }
+
+    const user = res.locals.oauth.token.User
+    if (!checkUserCanManageVideo(user, video, UserRight.UPDATE_ANY_VIDEO, res)) return cleanUpReqFiles(req)
+
+    // Try to make an approximation of bytes added by the intro/outro
+    const additionalBytes = await approximateIntroOutroAdditionalSize(video, body.tasks, i => getTaskFile(files, i).path)
+    if (await checkUserQuota(user, additionalBytes, res) === false) return cleanUpReqFiles(req)
+
+    return next()
+  }
+]
+
+// ---------------------------------------------------------------------------
+
+export {
+  videosEditorAddEditionValidator
+}
+
+// ---------------------------------------------------------------------------
+
+const taskCheckers: {
+  [id in VideoEditorTask['name']]: (task: VideoEditorTask, indice?: number, files?: Express.Multer.File[]) => boolean
+} = {
+  'cut': isEditorCutTaskValid,
+  'add-intro': isEditorTaskAddIntroOutroValid,
+  'add-outro': isEditorTaskAddIntroOutroValid,
+  'add-watermark': isEditorTaskAddWatermarkValid
+}
+
+function checkTask (req: express.Request, task: VideoEditorTask, indice?: number) {
+  const checker = taskCheckers[task.name]
+  if (!checker) return false
+
+  return checker(task, indice, req.files as Express.Multer.File[])
+}
diff --git a/server/middlewares/validators/videos/video-ownership-changes.ts b/server/middlewares/validators/videos/video-ownership-changes.ts
index 95e4cebce..6dcdc05f5 100644
--- a/server/middlewares/validators/videos/video-ownership-changes.ts
+++ b/server/middlewares/validators/videos/video-ownership-changes.ts
@@ -3,20 +3,13 @@ import { param } from 'express-validator'
 import { isIdValid } from '@server/helpers/custom-validators/misc'
 import { checkUserCanTerminateOwnershipChange } from '@server/helpers/custom-validators/video-ownership'
 import { logger } from '@server/helpers/logger'
-import { isAbleToUploadVideo } from '@server/lib/user'
 import { AccountModel } from '@server/models/account/account'
 import { MVideoWithAllFiles } from '@server/types/models'
-import {
-  HttpStatusCode,
-  ServerErrorCode,
-  UserRight,
-  VideoChangeOwnershipAccept,
-  VideoChangeOwnershipStatus,
-  VideoState
-} from '@shared/models'
+import { HttpStatusCode, UserRight, VideoChangeOwnershipAccept, VideoChangeOwnershipStatus, VideoState } from '@shared/models'
 import {
   areValidationErrors,
   checkUserCanManageVideo,
+  checkUserQuota,
   doesChangeVideoOwnershipExist,
   doesVideoChannelOfAccountExist,
   doesVideoExist,
@@ -113,15 +106,7 @@ async function checkCanAccept (video: MVideoWithAllFiles, res: express.Response)
 
   const user = res.locals.oauth.token.User
 
-  if (!await isAbleToUploadVideo(user.id, video.getMaxQualityFile().size)) {
-    res.fail({
-      status: HttpStatusCode.PAYLOAD_TOO_LARGE_413,
-      message: 'The user video quota is exceeded with this video.',
-      type: ServerErrorCode.QUOTA_REACHED
-    })
-
-    return false
-  }
+  if (!await checkUserQuota(user, video.getMaxQualityFile().size, res)) return false
 
   return true
 }
diff --git a/server/middlewares/validators/videos/video-playlists.ts b/server/middlewares/validators/videos/video-playlists.ts
index f5fee845e..241b9ed7b 100644
--- a/server/middlewares/validators/videos/video-playlists.ts
+++ b/server/middlewares/validators/videos/video-playlists.ts
@@ -27,7 +27,7 @@ import {
   isVideoPlaylistTimestampValid,
   isVideoPlaylistTypeValid
 } from '../../../helpers/custom-validators/video-playlists'
-import { isVideoImage } from '../../../helpers/custom-validators/videos'
+import { isVideoImageValid } from '../../../helpers/custom-validators/videos'
 import { cleanUpReqFiles } from '../../../helpers/express-utils'
 import { logger } from '../../../helpers/logger'
 import { CONSTRAINTS_FIELDS } from '../../../initializers/constants'
@@ -390,7 +390,7 @@ export {
 function getCommonPlaylistEditAttributes () {
   return [
     body('thumbnailfile')
-      .custom((value, { req }) => isVideoImage(req.files, 'thumbnailfile'))
+      .custom((value, { req }) => isVideoImageValid(req.files, 'thumbnailfile'))
       .withMessage(
         'This thumbnail file is not supported or too large. Please, make sure it is of the following type: ' +
         CONSTRAINTS_FIELDS.VIDEO_PLAYLISTS.IMAGE.EXTNAME.join(', ')
diff --git a/server/middlewares/validators/videos/video-rates.ts b/server/middlewares/validators/videos/video-rates.ts
index 923bf3eaf..1a9736034 100644
--- a/server/middlewares/validators/videos/video-rates.ts
+++ b/server/middlewares/validators/videos/video-rates.ts
@@ -21,12 +21,7 @@ const videoUpdateRateValidator = [
     if (areValidationErrors(req, res)) return
     if (!await doesVideoExist(req.params.id, res)) return
 
-    if (!await checkCanSeeVideoIfPrivate(req, res, res.locals.videoAll)) {
-      return res.fail({
-        status: HttpStatusCode.FORBIDDEN_403,
-        message: 'Cannot access to this ressource'
-      })
-    }
+    if (!await checkCanSeeVideoIfPrivate(req, res, res.locals.videoAll)) return
 
     return next()
   }
diff --git a/server/middlewares/validators/videos/videos.ts b/server/middlewares/validators/videos/videos.ts
index b3ffb7007..26597cf7b 100644
--- a/server/middlewares/validators/videos/videos.ts
+++ b/server/middlewares/validators/videos/videos.ts
@@ -3,7 +3,6 @@ import { body, header, param, query, ValidationChain } from 'express-validator'
 import { isTestInstance } from '@server/helpers/core-utils'
 import { getResumableUploadPath } from '@server/helpers/upload'
 import { Redis } from '@server/lib/redis'
-import { isAbleToUploadVideo } from '@server/lib/user'
 import { getServerActor } from '@server/models/application/application'
 import { ExpressPromiseHandler } from '@server/types/express-handler'
 import { MUserAccountId, MVideoFullLight } from '@server/types/models'
@@ -13,7 +12,7 @@ import {
   exists,
   isBooleanValid,
   isDateValid,
-  isFileFieldValid,
+  isFileValid,
   isIdValid,
   isUUIDValid,
   toArray,
@@ -23,24 +22,24 @@ import {
 } from '../../../helpers/custom-validators/misc'
 import { isBooleanBothQueryValid, isNumberArray, isStringArray } from '../../../helpers/custom-validators/search'
 import {
+  areVideoTagsValid,
   isScheduleVideoUpdatePrivacyValid,
   isVideoCategoryValid,
   isVideoDescriptionValid,
   isVideoFileMimeTypeValid,
   isVideoFileSizeValid,
   isVideoFilterValid,
-  isVideoImage,
+  isVideoImageValid,
   isVideoIncludeValid,
   isVideoLanguageValid,
   isVideoLicenceValid,
   isVideoNameValid,
   isVideoOriginallyPublishedAtValid,
   isVideoPrivacyValid,
-  isVideoSupportValid,
-  isVideoTagsValid
+  isVideoSupportValid
 } from '../../../helpers/custom-validators/videos'
 import { cleanUpReqFiles } from '../../../helpers/express-utils'
-import { getDurationFromVideoFile } from '../../../helpers/ffprobe-utils'
+import { getVideoStreamDuration } from '../../../helpers/ffmpeg'
 import { logger } from '../../../helpers/logger'
 import { deleteFileAndCatch } from '../../../helpers/utils'
 import { getVideoWithAttributes } from '../../../helpers/video'
@@ -53,6 +52,7 @@ import {
   areValidationErrors,
   checkCanSeePrivateVideo,
   checkUserCanManageVideo,
+  checkUserQuota,
   doesVideoChannelOfAccountExist,
   doesVideoExist,
   doesVideoFileOfVideoExist,
@@ -61,7 +61,7 @@ import {
 
 const videosAddLegacyValidator = getCommonVideoEditAttributes().concat([
   body('videofile')
-    .custom((value, { req }) => isFileFieldValid(req.files, 'videofile'))
+    .custom((_, { req }) => isFileValid({ files: req.files, field: 'videofile', mimeTypeRegex: null, maxSize: null }))
     .withMessage('Should have a file'),
   body('name')
     .trim()
@@ -299,12 +299,11 @@ const videosCustomGetValidator = (
 
       // Video private or blacklisted
       if (video.requiresAuth()) {
-        if (await checkCanSeePrivateVideo(req, res, video, authenticateInQuery)) return next()
+        if (await checkCanSeePrivateVideo(req, res, video, authenticateInQuery)) {
+          return next()
+        }
 
-        return res.fail({
-          status: HttpStatusCode.FORBIDDEN_403,
-          message: 'Cannot get this private/internal or blocklisted video'
-        })
+        return
       }
 
       // Video is public, anyone can access it
@@ -375,12 +374,12 @@ const videosOverviewValidator = [
 function getCommonVideoEditAttributes () {
   return [
     body('thumbnailfile')
-      .custom((value, { req }) => isVideoImage(req.files, 'thumbnailfile')).withMessage(
+      .custom((value, { req }) => isVideoImageValid(req.files, 'thumbnailfile')).withMessage(
         'This thumbnail file is not supported or too large. Please, make sure it is of the following type: ' +
         CONSTRAINTS_FIELDS.VIDEOS.IMAGE.EXTNAME.join(', ')
       ),
     body('previewfile')
-      .custom((value, { req }) => isVideoImage(req.files, 'previewfile')).withMessage(
+      .custom((value, { req }) => isVideoImageValid(req.files, 'previewfile')).withMessage(
         'This preview file is not supported or too large. Please, make sure it is of the following type: ' +
         CONSTRAINTS_FIELDS.VIDEOS.IMAGE.EXTNAME.join(', ')
       ),
@@ -420,7 +419,7 @@ function getCommonVideoEditAttributes () {
     body('tags')
       .optional()
       .customSanitizer(toValueOrNull)
-      .custom(isVideoTagsValid)
+      .custom(areVideoTagsValid)
       .withMessage(
         `Should have an array of up to ${CONSTRAINTS_FIELDS.VIDEOS.TAGS.max} tags between ` +
         `${CONSTRAINTS_FIELDS.VIDEOS.TAG.min} and ${CONSTRAINTS_FIELDS.VIDEOS.TAG.max} characters each`
@@ -612,14 +611,7 @@ async function commonVideoChecksPass (parameters: {
     return false
   }
 
-  if (await isAbleToUploadVideo(user.id, videoFileSize) === false) {
-    res.fail({
-      status: HttpStatusCode.PAYLOAD_TOO_LARGE_413,
-      message: 'The user video quota is exceeded with this video.',
-      type: ServerErrorCode.QUOTA_REACHED
-    })
-    return false
-  }
+  if (await checkUserQuota(user, videoFileSize, res) === false) return false
 
   return true
 }
@@ -654,7 +646,7 @@ export async function isVideoAccepted (
 }
 
 async function addDurationToVideo (videoFile: { path: string, duration?: number }) {
-  const duration: number = await getDurationFromVideoFile(videoFile.path)
+  const duration: number = await getVideoStreamDuration(videoFile.path)
 
   if (isNaN(duration)) throw new Error(`Couldn't get video duration`)
 
diff --git a/server/models/abuse/abuse-message.ts b/server/models/abuse/abuse-message.ts
index 6a441a210..d9eb25f0f 100644
--- a/server/models/abuse/abuse-message.ts
+++ b/server/models/abuse/abuse-message.ts
@@ -1,11 +1,12 @@
 import { AllowNull, BelongsTo, Column, CreatedAt, DataType, ForeignKey, Is, Model, Table, UpdatedAt } from 'sequelize-typescript'
 import { isAbuseMessageValid } from '@server/helpers/custom-validators/abuses'
 import { MAbuseMessage, MAbuseMessageFormattable } from '@server/types/models'
-import { AttributesOnly } from '@shared/typescript-utils'
 import { AbuseMessage } from '@shared/models'
+import { AttributesOnly } from '@shared/typescript-utils'
 import { AccountModel, ScopeNames as AccountScopeNames } from '../account/account'
 import { getSort, throwIfNotValid } from '../utils'
 import { AbuseModel } from './abuse'
+import { FindOptions } from 'sequelize/dist'
 
 @Table({
   tableName: 'abuseMessage',
@@ -62,21 +63,28 @@ export class AbuseMessageModel extends Model<Partial<AttributesOnly<AbuseMessage
   Abuse: AbuseModel
 
   static listForApi (abuseId: number) {
-    const options = {
-      where: { abuseId },
+    const getQuery = (forCount: boolean) => {
+      const query: FindOptions = {
+        where: { abuseId },
+        order: getSort('createdAt')
+      }
 
-      order: getSort('createdAt'),
+      if (forCount !== true) {
+        query.include = [
+          {
+            model: AccountModel.scope(AccountScopeNames.SUMMARY),
+            required: false
+          }
+        ]
+      }
 
-      include: [
-        {
-          model: AccountModel.scope(AccountScopeNames.SUMMARY),
-          required: false
-        }
-      ]
+      return query
     }
 
-    return AbuseMessageModel.findAndCountAll(options)
-      .then(({ rows, count }) => ({ data: rows, total: count }))
+    return Promise.all([
+      AbuseMessageModel.count(getQuery(true)),
+      AbuseMessageModel.findAll(getQuery(false))
+    ]).then(([ total, data ]) => ({ total, data }))
   }
 
   static loadByIdAndAbuseId (messageId: number, abuseId: number): Promise<MAbuseMessage> {
diff --git a/server/models/account/account-blocklist.ts b/server/models/account/account-blocklist.ts
index 1162962bf..a7b8db076 100644
--- a/server/models/account/account-blocklist.ts
+++ b/server/models/account/account-blocklist.ts
@@ -1,7 +1,7 @@
-import { Op, QueryTypes } from 'sequelize'
-import { BelongsTo, Column, CreatedAt, ForeignKey, Model, Scopes, Table, UpdatedAt } from 'sequelize-typescript'
+import { FindOptions, Op, QueryTypes } from 'sequelize'
+import { BelongsTo, Column, CreatedAt, ForeignKey, Model, Table, UpdatedAt } from 'sequelize-typescript'
 import { handlesToNameAndHost } from '@server/helpers/actors'
-import { MAccountBlocklist, MAccountBlocklistAccounts, MAccountBlocklistFormattable } from '@server/types/models'
+import { MAccountBlocklist, MAccountBlocklistFormattable } from '@server/types/models'
 import { AttributesOnly } from '@shared/typescript-utils'
 import { AccountBlock } from '../../../shared/models'
 import { ActorModel } from '../actor/actor'
@@ -9,27 +9,6 @@ import { ServerModel } from '../server/server'
 import { createSafeIn, getSort, searchAttribute } from '../utils'
 import { AccountModel } from './account'
 
-enum ScopeNames {
-  WITH_ACCOUNTS = 'WITH_ACCOUNTS'
-}
-
-@Scopes(() => ({
-  [ScopeNames.WITH_ACCOUNTS]: {
-    include: [
-      {
-        model: AccountModel,
-        required: true,
-        as: 'ByAccount'
-      },
-      {
-        model: AccountModel,
-        required: true,
-        as: 'BlockedAccount'
-      }
-    ]
-  }
-}))
-
 @Table({
   tableName: 'accountBlocklist',
   indexes: [
@@ -123,33 +102,45 @@ export class AccountBlocklistModel extends Model<Partial<AttributesOnly<AccountB
   }) {
     const { start, count, sort, search, accountId } = parameters
 
-    const query = {
-      offset: start,
-      limit: count,
-      order: getSort(sort)
-    }
+    const getQuery = (forCount: boolean) => {
+      const query: FindOptions = {
+        offset: start,
+        limit: count,
+        order: getSort(sort),
+        where: { accountId }
+      }
 
-    const where = {
-      accountId
-    }
+      if (search) {
+        Object.assign(query.where, {
+          [Op.or]: [
+            searchAttribute(search, '$BlockedAccount.name$'),
+            searchAttribute(search, '$BlockedAccount.Actor.url$')
+          ]
+        })
+      }
 
-    if (search) {
-      Object.assign(where, {
-        [Op.or]: [
-          searchAttribute(search, '$BlockedAccount.name$'),
-          searchAttribute(search, '$BlockedAccount.Actor.url$')
+      if (forCount !== true) {
+        query.include = [
+          {
+            model: AccountModel,
+            required: true,
+            as: 'ByAccount'
+          },
+          {
+            model: AccountModel,
+            required: true,
+            as: 'BlockedAccount'
+          }
         ]
-      })
-    }
+      }
 
-    Object.assign(query, { where })
+      return query
+    }
 
-    return AccountBlocklistModel
-      .scope([ ScopeNames.WITH_ACCOUNTS ])
-      .findAndCountAll<MAccountBlocklistAccounts>(query)
-      .then(({ rows, count }) => {
-        return { total: count, data: rows }
-      })
+    return Promise.all([
+      AccountBlocklistModel.count(getQuery(true)),
+      AccountBlocklistModel.findAll(getQuery(false))
+    ]).then(([ total, data ]) => ({ total, data }))
   }
 
   static listHandlesBlockedBy (accountIds: number[]): Promise<string[]> {
diff --git a/server/models/account/account-video-rate.ts b/server/models/account/account-video-rate.ts
index e89d31adf..7303651eb 100644
--- a/server/models/account/account-video-rate.ts
+++ b/server/models/account/account-video-rate.ts
@@ -121,29 +121,40 @@ export class AccountVideoRateModel extends Model<Partial<AttributesOnly<AccountV
     type?: string
     accountId: number
   }) {
-    const query: FindOptions = {
-      offset: options.start,
-      limit: options.count,
-      order: getSort(options.sort),
-      where: {
-        accountId: options.accountId
-      },
-      include: [
-        {
-          model: VideoModel,
-          required: true,
-          include: [
-            {
-              model: VideoChannelModel.scope({ method: [ VideoChannelScopeNames.SUMMARY, { withAccount: true } as SummaryOptions ] }),
-              required: true
-            }
-          ]
+    const getQuery = (forCount: boolean) => {
+      const query: FindOptions = {
+        offset: options.start,
+        limit: options.count,
+        order: getSort(options.sort),
+        where: {
+          accountId: options.accountId
         }
-      ]
+      }
+
+      if (options.type) query.where['type'] = options.type
+
+      if (forCount !== true) {
+        query.include = [
+          {
+            model: VideoModel,
+            required: true,
+            include: [
+              {
+                model: VideoChannelModel.scope({ method: [ VideoChannelScopeNames.SUMMARY, { withAccount: true } as SummaryOptions ] }),
+                required: true
+              }
+            ]
+          }
+        ]
+      }
+
+      return query
     }
-    if (options.type) query.where['type'] = options.type
 
-    return AccountVideoRateModel.findAndCountAll(query)
+    return Promise.all([
+      AccountVideoRateModel.count(getQuery(true)),
+      AccountVideoRateModel.findAll(getQuery(false))
+    ]).then(([ total, data ]) => ({ total, data }))
   }
 
   static listRemoteRateUrlsOfLocalVideos () {
@@ -232,7 +243,10 @@ export class AccountVideoRateModel extends Model<Partial<AttributesOnly<AccountV
       ]
     }
 
-    return AccountVideoRateModel.findAndCountAll<MAccountVideoRateAccountUrl>(query)
+    return Promise.all([
+      AccountVideoRateModel.count(query),
+      AccountVideoRateModel.findAll<MAccountVideoRateAccountUrl>(query)
+    ]).then(([ total, data ]) => ({ total, data }))
   }
 
   static cleanOldRatesOf (videoId: number, type: VideoRateType, beforeUpdatedAt: Date) {
diff --git a/server/models/account/account.ts b/server/models/account/account.ts
index 619a598dd..8a7dfba94 100644
--- a/server/models/account/account.ts
+++ b/server/models/account/account.ts
@@ -54,6 +54,7 @@ export type SummaryOptions = {
   whereActor?: WhereOptions
   whereServer?: WhereOptions
   withAccountBlockerIds?: number[]
+  forCount?: boolean
 }
 
 @DefaultScope(() => ({
@@ -73,22 +74,24 @@ export type SummaryOptions = {
       where: options.whereServer
     }
 
-    const queryInclude: Includeable[] = [
-      {
-        attributes: [ 'id', 'preferredUsername', 'url', 'serverId', 'avatarId' ],
-        model: ActorModel.unscoped(),
-        required: options.actorRequired ?? true,
-        where: options.whereActor,
-        include: [
-          serverInclude,
+    const actorInclude: Includeable = {
+      attributes: [ 'id', 'preferredUsername', 'url', 'serverId' ],
+      model: ActorModel.unscoped(),
+      required: options.actorRequired ?? true,
+      where: options.whereActor,
+      include: [ serverInclude ]
+    }
 
-          {
-            model: ActorImageModel.unscoped(),
-            as: 'Avatar',
-            required: false
-          }
-        ]
-      }
+    if (options.forCount !== true) {
+      actorInclude.include.push({
+        model: ActorImageModel,
+        as: 'Avatars',
+        required: false
+      })
+    }
+
+    const queryInclude: Includeable[] = [
+      actorInclude
     ]
 
     const query: FindOptions = {
@@ -349,13 +352,10 @@ export class AccountModel extends Model<Partial<AttributesOnly<AccountModel>>> {
       order: getSort(sort)
     }
 
-    return AccountModel.findAndCountAll(query)
-      .then(({ rows, count }) => {
-        return {
-          data: rows,
-          total: count
-        }
-      })
+    return Promise.all([
+      AccountModel.count(),
+      AccountModel.findAll(query)
+    ]).then(([ total, data ]) => ({ total, data }))
   }
 
   static loadAccountIdFromVideo (videoId: number): Promise<MAccount> {
@@ -407,16 +407,15 @@ export class AccountModel extends Model<Partial<AttributesOnly<AccountModel>>> {
   }
 
   toFormattedJSON (this: MAccountFormattable): Account {
-    const actor = this.Actor.toFormattedJSON()
-    const account = {
+    return {
+      ...this.Actor.toFormattedJSON(),
+
       id: this.id,
       displayName: this.getDisplayName(),
       description: this.description,
       updatedAt: this.updatedAt,
-      userId: this.userId ? this.userId : undefined
+      userId: this.userId ?? undefined
     }
-
-    return Object.assign(actor, account)
   }
 
   toFormattedSummaryJSON (this: MAccountSummaryFormattable): AccountSummary {
@@ -424,10 +423,14 @@ export class AccountModel extends Model<Partial<AttributesOnly<AccountModel>>> {
 
     return {
       id: this.id,
-      name: actor.name,
       displayName: this.getDisplayName(),
+
+      name: actor.name,
       url: actor.url,
       host: actor.host,
+      avatars: actor.avatars,
+
+      // TODO: remove, deprecated in 4.2
       avatar: actor.avatar
     }
   }
diff --git a/server/models/actor/actor-follow.ts b/server/models/actor/actor-follow.ts
index 006282530..0f4d3c0a6 100644
--- a/server/models/actor/actor-follow.ts
+++ b/server/models/actor/actor-follow.ts
@@ -1,5 +1,5 @@
 import { difference, values } from 'lodash'
-import { IncludeOptions, Op, QueryTypes, Transaction, WhereOptions } from 'sequelize'
+import { Includeable, IncludeOptions, literal, Op, QueryTypes, Transaction, WhereOptions } from 'sequelize'
 import {
   AfterCreate,
   AfterDestroy,
@@ -30,12 +30,12 @@ import {
   MActorFollowFormattable,
   MActorFollowSubscriptions
 } from '@server/types/models'
-import { AttributesOnly } from '@shared/typescript-utils'
 import { ActivityPubActorType } from '@shared/models'
+import { AttributesOnly } from '@shared/typescript-utils'
 import { FollowState } from '../../../shared/models/actors'
 import { ActorFollow } from '../../../shared/models/actors/follow.model'
 import { logger } from '../../helpers/logger'
-import { ACTOR_FOLLOW_SCORE, CONSTRAINTS_FIELDS, FOLLOW_STATES, SERVER_ACTOR_NAME } from '../../initializers/constants'
+import { ACTOR_FOLLOW_SCORE, CONSTRAINTS_FIELDS, FOLLOW_STATES, SERVER_ACTOR_NAME, SORTABLE_COLUMNS } from '../../initializers/constants'
 import { AccountModel } from '../account/account'
 import { ServerModel } from '../server/server'
 import { doesExist } from '../shared/query'
@@ -375,43 +375,46 @@ export class ActorFollowModel extends Model<Partial<AttributesOnly<ActorFollowMo
       Object.assign(followingWhere, { type: actorType })
     }
 
-    const query = {
-      distinct: true,
-      offset: start,
-      limit: count,
-      order: getFollowsSort(sort),
-      where: followWhere,
-      include: [
-        {
-          model: ActorModel,
-          required: true,
-          as: 'ActorFollower',
-          where: {
-            id
-          }
-        },
-        {
-          model: ActorModel,
-          as: 'ActorFollowing',
-          required: true,
-          where: followingWhere,
-          include: [
-            {
-              model: ServerModel,
-              required: true
+    const getQuery = (forCount: boolean) => {
+      const actorModel = forCount
+        ? ActorModel.unscoped()
+        : ActorModel
+
+      return {
+        distinct: true,
+        offset: start,
+        limit: count,
+        order: getFollowsSort(sort),
+        where: followWhere,
+        include: [
+          {
+            model: actorModel,
+            required: true,
+            as: 'ActorFollower',
+            where: {
+              id
             }
-          ]
-        }
-      ]
+          },
+          {
+            model: actorModel,
+            as: 'ActorFollowing',
+            required: true,
+            where: followingWhere,
+            include: [
+              {
+                model: ServerModel,
+                required: true
+              }
+            ]
+          }
+        ]
+      }
     }
 
-    return ActorFollowModel.findAndCountAll<MActorFollowActorsDefault>(query)
-      .then(({ rows, count }) => {
-        return {
-          data: rows,
-          total: count
-        }
-      })
+    return Promise.all([
+      ActorFollowModel.count(getQuery(true)),
+      ActorFollowModel.findAll<MActorFollowActorsDefault>(getQuery(false))
+    ]).then(([ total, data ]) => ({ total, data }))
   }
 
   static listFollowersForApi (options: {
@@ -429,11 +432,17 @@ export class ActorFollowModel extends Model<Partial<AttributesOnly<ActorFollowMo
     const followerWhere: WhereOptions = {}
 
     if (search) {
-      Object.assign(followWhere, {
-        [Op.or]: [
-          searchAttribute(search, '$ActorFollower.preferredUsername$'),
-          searchAttribute(search, '$ActorFollower.Server.host$')
-        ]
+      const escapedSearch = ActorFollowModel.sequelize.escape('%' + search + '%')
+
+      Object.assign(followerWhere, {
+        id: {
+          [Op.in]: literal(
+            `(` +
+              `SELECT "actor".id FROM actor LEFT JOIN server on server.id = actor."serverId" ` +
+              `WHERE "preferredUsername" ILIKE ${escapedSearch} OR "host" ILIKE ${escapedSearch}` +
+            `)`
+          )
+        }
       })
     }
 
@@ -441,39 +450,43 @@ export class ActorFollowModel extends Model<Partial<AttributesOnly<ActorFollowMo
       Object.assign(followerWhere, { type: actorType })
     }
 
-    const query = {
-      distinct: true,
-      offset: start,
-      limit: count,
-      order: getFollowsSort(sort),
-      where: followWhere,
-      include: [
-        {
-          model: ActorModel,
-          required: true,
-          as: 'ActorFollower',
-          where: followerWhere
-        },
-        {
-          model: ActorModel,
-          as: 'ActorFollowing',
-          required: true,
-          where: {
-            id: {
-              [Op.in]: actorIds
+    const getQuery = (forCount: boolean) => {
+      const actorModel = forCount
+        ? ActorModel.unscoped()
+        : ActorModel
+
+      return {
+        distinct: true,
+
+        offset: start,
+        limit: count,
+        order: getFollowsSort(sort),
+        where: followWhere,
+        include: [
+          {
+            model: actorModel,
+            required: true,
+            as: 'ActorFollower',
+            where: followerWhere
+          },
+          {
+            model: actorModel,
+            as: 'ActorFollowing',
+            required: true,
+            where: {
+              id: {
+                [Op.in]: actorIds
+              }
             }
           }
-        }
-      ]
+        ]
+      }
     }
 
-    return ActorFollowModel.findAndCountAll<MActorFollowActorsDefault>(query)
-                           .then(({ rows, count }) => {
-                             return {
-                               data: rows,
-                               total: count
-                             }
-                           })
+    return Promise.all([
+      ActorFollowModel.count(getQuery(true)),
+      ActorFollowModel.findAll<MActorFollowActorsDefault>(getQuery(false))
+    ]).then(([ total, data ]) => ({ total, data }))
   }
 
   static listSubscriptionsForApi (options: {
@@ -497,58 +510,68 @@ export class ActorFollowModel extends Model<Partial<AttributesOnly<ActorFollowMo
       })
     }
 
-    const query = {
-      attributes: [],
-      distinct: true,
-      offset: start,
-      limit: count,
-      order: getSort(sort),
-      where,
-      include: [
-        {
-          attributes: [ 'id' ],
-          model: ActorModel.unscoped(),
-          as: 'ActorFollowing',
-          required: true,
-          include: [
-            {
-              model: VideoChannelModel.unscoped(),
-              required: true,
-              include: [
-                {
-                  attributes: {
-                    exclude: unusedActorAttributesForAPI
-                  },
-                  model: ActorModel,
-                  required: true
+    const getQuery = (forCount: boolean) => {
+      let channelInclude: Includeable[] = []
+
+      if (forCount !== true) {
+        channelInclude = [
+          {
+            attributes: {
+              exclude: unusedActorAttributesForAPI
+            },
+            model: ActorModel,
+            required: true
+          },
+          {
+            model: AccountModel.unscoped(),
+            required: true,
+            include: [
+              {
+                attributes: {
+                  exclude: unusedActorAttributesForAPI
                 },
-                {
-                  model: AccountModel.unscoped(),
-                  required: true,
-                  include: [
-                    {
-                      attributes: {
-                        exclude: unusedActorAttributesForAPI
-                      },
-                      model: ActorModel,
-                      required: true
-                    }
-                  ]
-                }
-              ]
-            }
-          ]
-        }
-      ]
+                model: ActorModel,
+                required: true
+              }
+            ]
+          }
+        ]
+      }
+
+      return {
+        attributes: forCount === true
+          ? []
+          : SORTABLE_COLUMNS.USER_SUBSCRIPTIONS,
+        distinct: true,
+        offset: start,
+        limit: count,
+        order: getSort(sort),
+        where,
+        include: [
+          {
+            attributes: [ 'id' ],
+            model: ActorModel.unscoped(),
+            as: 'ActorFollowing',
+            required: true,
+            include: [
+              {
+                model: VideoChannelModel.unscoped(),
+                required: true,
+                include: channelInclude
+              }
+            ]
+          }
+        ]
+      }
     }
 
-    return ActorFollowModel.findAndCountAll<MActorFollowSubscriptions>(query)
-                           .then(({ rows, count }) => {
-                             return {
-                               data: rows.map(r => r.ActorFollowing.VideoChannel),
-                               total: count
-                             }
-                           })
+    return Promise.all([
+      ActorFollowModel.count(getQuery(true)),
+      ActorFollowModel.findAll<MActorFollowSubscriptions>(getQuery(false))
+    ]).then(([ total, rows ]) => ({
+      total,
+      data: rows.map(r => r.ActorFollowing.VideoChannel)
+    }))
   }
 
   static async keepUnfollowedInstance (hosts: string[]) {
diff --git a/server/models/actor/actor-image.ts b/server/models/actor/actor-image.ts
index 8edff5ab4..f74ab735e 100644
--- a/server/models/actor/actor-image.ts
+++ b/server/models/actor/actor-image.ts
@@ -1,15 +1,29 @@
 import { remove } from 'fs-extra'
 import { join } from 'path'
-import { AfterDestroy, AllowNull, Column, CreatedAt, Default, Is, Model, Table, UpdatedAt } from 'sequelize-typescript'
-import { MActorImageFormattable } from '@server/types/models'
+import {
+  AfterDestroy,
+  AllowNull,
+  BelongsTo,
+  Column,
+  CreatedAt,
+  Default,
+  ForeignKey,
+  Is,
+  Model,
+  Table,
+  UpdatedAt
+} from 'sequelize-typescript'
+import { MActorImage, MActorImageFormattable } from '@server/types/models'
+import { getLowercaseExtension } from '@shared/core-utils'
+import { ActivityIconObject, ActorImageType } from '@shared/models'
 import { AttributesOnly } from '@shared/typescript-utils'
-import { ActorImageType } from '@shared/models'
 import { ActorImage } from '../../../shared/models/actors/actor-image.model'
 import { isActivityPubUrlValid } from '../../helpers/custom-validators/activitypub/misc'
 import { logger } from '../../helpers/logger'
 import { CONFIG } from '../../initializers/config'
-import { LAZY_STATIC_PATHS } from '../../initializers/constants'
+import { LAZY_STATIC_PATHS, MIMETYPES, WEBSERVER } from '../../initializers/constants'
 import { throwIfNotValid } from '../utils'
+import { ActorModel } from './actor'
 
 @Table({
   tableName: 'actorImage',
@@ -17,6 +31,10 @@ import { throwIfNotValid } from '../utils'
     {
       fields: [ 'filename' ],
       unique: true
+    },
+    {
+      fields: [ 'actorId', 'type', 'width' ],
+      unique: true
     }
   ]
 })
@@ -55,6 +73,18 @@ export class ActorImageModel extends Model<Partial<AttributesOnly<ActorImageMode
   @UpdatedAt
   updatedAt: Date
 
+  @ForeignKey(() => ActorModel)
+  @Column
+  actorId: number
+
+  @BelongsTo(() => ActorModel, {
+    foreignKey: {
+      allowNull: false
+    },
+    onDelete: 'CASCADE'
+  })
+  Actor: ActorModel
+
   @AfterDestroy
   static removeFilesAndSendDelete (instance: ActorImageModel) {
     logger.info('Removing actor image file %s.', instance.filename)
@@ -74,20 +104,41 @@ export class ActorImageModel extends Model<Partial<AttributesOnly<ActorImageMode
     return ActorImageModel.findOne(query)
   }
 
+  static getImageUrl (image: MActorImage) {
+    if (!image) return undefined
+
+    return WEBSERVER.URL + image.getStaticPath()
+  }
+
   toFormattedJSON (this: MActorImageFormattable): ActorImage {
     return {
+      width: this.width,
       path: this.getStaticPath(),
       createdAt: this.createdAt,
       updatedAt: this.updatedAt
     }
   }
 
-  getStaticPath () {
-    if (this.type === ActorImageType.AVATAR) {
-      return join(LAZY_STATIC_PATHS.AVATARS, this.filename)
+  toActivityPubObject (): ActivityIconObject {
+    const extension = getLowercaseExtension(this.filename)
+
+    return {
+      type: 'Image',
+      mediaType: MIMETYPES.IMAGE.EXT_MIMETYPE[extension],
+      height: this.height,
+      width: this.width,
+      url: ActorImageModel.getImageUrl(this)
     }
+  }
 
-    return join(LAZY_STATIC_PATHS.BANNERS, this.filename)
+  getStaticPath () {
+    switch (this.type) {
+      case ActorImageType.AVATAR:
+        return join(LAZY_STATIC_PATHS.AVATARS, this.filename)
+
+      case ActorImageType.BANNER:
+        return join(LAZY_STATIC_PATHS.BANNERS, this.filename)
+    }
   }
 
   getPath () {
diff --git a/server/models/actor/actor.ts b/server/models/actor/actor.ts
index c12dcf634..08cb2fd24 100644
--- a/server/models/actor/actor.ts
+++ b/server/models/actor/actor.ts
@@ -16,11 +16,11 @@ import {
   Table,
   UpdatedAt
 } from 'sequelize-typescript'
+import { getBiggestActorImage } from '@server/lib/actor-image'
 import { ModelCache } from '@server/models/model-cache'
 import { getLowercaseExtension } from '@shared/core-utils'
+import { ActivityIconObject, ActivityPubActorType, ActorImageType } from '@shared/models'
 import { AttributesOnly } from '@shared/typescript-utils'
-import { ActivityIconObject, ActivityPubActorType } from '../../../shared/models/activitypub'
-import { ActorImage } from '../../../shared/models/actors/actor-image.model'
 import { activityPubContextify } from '../../helpers/activitypub'
 import {
   isActorFollowersCountValid,
@@ -81,7 +81,7 @@ export const unusedActorAttributesForAPI = [
     },
     {
       model: ActorImageModel,
-      as: 'Avatar',
+      as: 'Avatars',
       required: false
     }
   ]
@@ -109,12 +109,12 @@ export const unusedActorAttributesForAPI = [
       },
       {
         model: ActorImageModel,
-        as: 'Avatar',
+        as: 'Avatars',
         required: false
       },
       {
         model: ActorImageModel,
-        as: 'Banner',
+        as: 'Banners',
         required: false
       }
     ]
@@ -153,9 +153,6 @@ export const unusedActorAttributesForAPI = [
       fields: [ 'serverId' ]
     },
     {
-      fields: [ 'avatarId' ]
-    },
-    {
       fields: [ 'followersUrl' ]
     }
   ]
@@ -231,35 +228,31 @@ export class ActorModel extends Model<Partial<AttributesOnly<ActorModel>>> {
   @UpdatedAt
   updatedAt: Date
 
-  @ForeignKey(() => ActorImageModel)
-  @Column
-  avatarId: number
-
-  @ForeignKey(() => ActorImageModel)
-  @Column
-  bannerId: number
-
-  @BelongsTo(() => ActorImageModel, {
+  @HasMany(() => ActorImageModel, {
+    as: 'Avatars',
+    onDelete: 'cascade',
+    hooks: true,
     foreignKey: {
-      name: 'avatarId',
-      allowNull: true
+      allowNull: false
     },
-    as: 'Avatar',
-    onDelete: 'set null',
-    hooks: true
+    scope: {
+      type: ActorImageType.AVATAR
+    }
   })
-  Avatar: ActorImageModel
+  Avatars: ActorImageModel[]
 
-  @BelongsTo(() => ActorImageModel, {
+  @HasMany(() => ActorImageModel, {
+    as: 'Banners',
+    onDelete: 'cascade',
+    hooks: true,
     foreignKey: {
-      name: 'bannerId',
-      allowNull: true
+      allowNull: false
     },
-    as: 'Banner',
-    onDelete: 'set null',
-    hooks: true
+    scope: {
+      type: ActorImageType.BANNER
+    }
   })
-  Banner: ActorImageModel
+  Banners: ActorImageModel[]
 
   @HasMany(() => ActorFollowModel, {
     foreignKey: {
@@ -386,8 +379,7 @@ export class ActorModel extends Model<Partial<AttributesOnly<ActorModel>>> {
         transaction
       }
 
-      return ActorModel.scope(ScopeNames.FULL)
-                       .findOne(query)
+      return ActorModel.scope(ScopeNames.FULL).findOne(query)
     }
 
     return ModelCache.Instance.doCache({
@@ -410,8 +402,7 @@ export class ActorModel extends Model<Partial<AttributesOnly<ActorModel>>> {
         transaction
       }
 
-      return ActorModel.unscoped()
-                       .findOne(query)
+      return ActorModel.unscoped().findOne(query)
     }
 
     return ModelCache.Instance.doCache({
@@ -532,55 +523,50 @@ export class ActorModel extends Model<Partial<AttributesOnly<ActorModel>>> {
   }
 
   toFormattedSummaryJSON (this: MActorSummaryFormattable) {
-    let avatar: ActorImage = null
-    if (this.Avatar) {
-      avatar = this.Avatar.toFormattedJSON()
-    }
-
     return {
       url: this.url,
       name: this.preferredUsername,
       host: this.getHost(),
-      avatar
+      avatars: (this.Avatars || []).map(a => a.toFormattedJSON()),
+
+      // TODO: remove, deprecated in 4.2
+      avatar: this.hasImage(ActorImageType.AVATAR)
+        ? this.Avatars[0].toFormattedJSON()
+        : undefined
     }
   }
 
   toFormattedJSON (this: MActorFormattable) {
-    const base = this.toFormattedSummaryJSON()
-
-    let banner: ActorImage = null
-    if (this.Banner) {
-      banner = this.Banner.toFormattedJSON()
-    }
+    return {
+      ...this.toFormattedSummaryJSON(),
 
-    return Object.assign(base, {
       id: this.id,
       hostRedundancyAllowed: this.getRedundancyAllowed(),
       followingCount: this.followingCount,
       followersCount: this.followersCount,
-      banner,
-      createdAt: this.getCreatedAt()
-    })
+      createdAt: this.getCreatedAt(),
+
+      banners: (this.Banners || []).map(b => b.toFormattedJSON()),
+
+      // TODO: remove, deprecated in 4.2
+      banner: this.hasImage(ActorImageType.BANNER)
+        ? this.Banners[0].toFormattedJSON()
+        : undefined
+    }
   }
 
   toActivityPubObject (this: MActorAPChannel | MActorAPAccount, name: string) {
     let icon: ActivityIconObject
+    let icons: ActivityIconObject[]
     let image: ActivityIconObject
 
-    if (this.avatarId) {
-      const extension = getLowercaseExtension(this.Avatar.filename)
-
-      icon = {
-        type: 'Image',
-        mediaType: MIMETYPES.IMAGE.EXT_MIMETYPE[extension],
-        height: this.Avatar.height,
-        width: this.Avatar.width,
-        url: this.getAvatarUrl()
-      }
+    if (this.hasImage(ActorImageType.AVATAR)) {
+      icon = getBiggestActorImage(this.Avatars).toActivityPubObject()
+      icons = this.Avatars.map(a => a.toActivityPubObject())
     }
 
-    if (this.bannerId) {
-      const banner = (this as MActorAPChannel).Banner
+    if (this.hasImage(ActorImageType.BANNER)) {
+      const banner = getBiggestActorImage((this as MActorAPChannel).Banners)
       const extension = getLowercaseExtension(banner.filename)
 
       image = {
@@ -588,7 +574,7 @@ export class ActorModel extends Model<Partial<AttributesOnly<ActorModel>>> {
         mediaType: MIMETYPES.IMAGE.EXT_MIMETYPE[extension],
         height: banner.height,
         width: banner.width,
-        url: this.getBannerUrl()
+        url: ActorImageModel.getImageUrl(banner)
       }
     }
 
@@ -612,7 +598,10 @@ export class ActorModel extends Model<Partial<AttributesOnly<ActorModel>>> {
         publicKeyPem: this.publicKey
       },
       published: this.getCreatedAt().toISOString(),
+
       icon,
+      icons,
+
       image
     }
 
@@ -677,16 +666,12 @@ export class ActorModel extends Model<Partial<AttributesOnly<ActorModel>>> {
     return this.Server ? this.Server.redundancyAllowed : false
   }
 
-  getAvatarUrl () {
-    if (!this.avatarId) return undefined
-
-    return WEBSERVER.URL + this.Avatar.getStaticPath()
-  }
-
-  getBannerUrl () {
-    if (!this.bannerId) return undefined
+  hasImage (type: ActorImageType) {
+    const images = type === ActorImageType.AVATAR
+      ? this.Avatars
+      : this.Banners
 
-    return WEBSERVER.URL + this.Banner.getStaticPath()
+    return Array.isArray(images) && images.length !== 0
   }
 
   isOutdated () {
diff --git a/server/models/server/plugin.ts b/server/models/server/plugin.ts
index 05083e3f7..fa5b4cc4b 100644
--- a/server/models/server/plugin.ts
+++ b/server/models/server/plugin.ts
@@ -239,11 +239,10 @@ export class PluginModel extends Model<Partial<AttributesOnly<PluginModel>>> {
 
     if (options.pluginType) query.where['type'] = options.pluginType
 
-    return PluginModel
-      .findAndCountAll<MPlugin>(query)
-      .then(({ rows, count }) => {
-        return { total: count, data: rows }
-      })
+    return Promise.all([
+      PluginModel.count(query),
+      PluginModel.findAll<MPlugin>(query)
+    ]).then(([ total, data ]) => ({ total, data }))
   }
 
   static listInstalled (): Promise<MPlugin[]> {
diff --git a/server/models/server/server-blocklist.ts b/server/models/server/server-blocklist.ts
index 9f64eeb7f..9752dfbc3 100644
--- a/server/models/server/server-blocklist.ts
+++ b/server/models/server/server-blocklist.ts
@@ -1,8 +1,8 @@
 import { Op, QueryTypes } from 'sequelize'
 import { BelongsTo, Column, CreatedAt, ForeignKey, Model, Scopes, Table, UpdatedAt } from 'sequelize-typescript'
 import { MServerBlocklist, MServerBlocklistAccountServer, MServerBlocklistFormattable } from '@server/types/models'
-import { AttributesOnly } from '@shared/typescript-utils'
 import { ServerBlock } from '@shared/models'
+import { AttributesOnly } from '@shared/typescript-utils'
 import { AccountModel } from '../account/account'
 import { createSafeIn, getSort, searchAttribute } from '../utils'
 import { ServerModel } from './server'
@@ -169,16 +169,15 @@ export class ServerBlocklistModel extends Model<Partial<AttributesOnly<ServerBlo
       order: getSort(sort),
       where: {
         accountId,
+
         ...searchAttribute(search, '$BlockedServer.host$')
       }
     }
 
-    return ServerBlocklistModel
-      .scope([ ScopeNames.WITH_ACCOUNT, ScopeNames.WITH_SERVER ])
-      .findAndCountAll<MServerBlocklistAccountServer>(query)
-      .then(({ rows, count }) => {
-        return { total: count, data: rows }
-      })
+    return Promise.all([
+      ServerBlocklistModel.scope(ScopeNames.WITH_SERVER).count(query),
+      ServerBlocklistModel.scope([ ScopeNames.WITH_ACCOUNT, ScopeNames.WITH_SERVER ]).findAll<MServerBlocklistAccountServer>(query)
+    ]).then(([ total, data ]) => ({ total, data }))
   }
 
   toFormattedJSON (this: MServerBlocklistFormattable): ServerBlock {
diff --git a/server/models/video/sql/shared/abstract-run-query.ts b/server/models/shared/abstract-run-query.ts
index 8e7a7642d..c39b7bcfe 100644
--- a/server/models/video/sql/shared/abstract-run-query.ts
+++ b/server/models/shared/abstract-run-query.ts
@@ -7,18 +7,20 @@ import { QueryTypes, Sequelize, Transaction } from 'sequelize'
  */
 
 export class AbstractRunQuery {
-  protected sequelize: Sequelize
-
   protected query: string
   protected replacements: any = {}
 
-  protected runQuery (options: { transaction?: Transaction, logging?: boolean } = {}) {
+  constructor (protected readonly sequelize: Sequelize) {
+
+  }
+
+  protected runQuery (options: { nest?: boolean, transaction?: Transaction, logging?: boolean } = {}) {
     const queryOptions = {
       transaction: options.transaction,
       logging: options.logging,
       replacements: this.replacements,
       type: QueryTypes.SELECT as QueryTypes.SELECT,
-      nest: false
+      nest: options.nest ?? false
     }
 
     return this.sequelize.query<any>(this.query, queryOptions)
diff --git a/server/models/shared/index.ts b/server/models/shared/index.ts
index 5b97510e0..04528929c 100644
--- a/server/models/shared/index.ts
+++ b/server/models/shared/index.ts
@@ -1,2 +1,4 @@
+export * from './abstract-run-query'
+export * from './model-builder'
 export * from './query'
 export * from './update'
diff --git a/server/models/shared/model-builder.ts b/server/models/shared/model-builder.ts
new file mode 100644
index 000000000..c015ca4f5
--- /dev/null
+++ b/server/models/shared/model-builder.ts
@@ -0,0 +1,101 @@
+import { isPlainObject } from 'lodash'
+import { Model as SequelizeModel, Sequelize } from 'sequelize'
+import { logger } from '@server/helpers/logger'
+
+export class ModelBuilder <T extends SequelizeModel> {
+  private readonly modelRegistry = new Map<string, T>()
+
+  constructor (private readonly sequelize: Sequelize) {
+
+  }
+
+  createModels (jsonArray: any[], baseModelName: string): T[] {
+    const result: T[] = []
+
+    for (const json of jsonArray) {
+      const { created, model } = this.createModel(json, baseModelName, json.id + '.' + baseModelName)
+
+      if (created) result.push(model)
+    }
+
+    return result
+  }
+
+  private createModel (json: any, modelName: string, keyPath: string) {
+    if (!json.id) return { created: false, model: null }
+
+    const { created, model } = this.createOrFindModel(json, modelName, keyPath)
+
+    for (const key of Object.keys(json)) {
+      const value = json[key]
+      if (!value) continue
+
+      // Child model
+      if (isPlainObject(value)) {
+        const { created, model: subModel } = this.createModel(value, key, keyPath + '.' + json.id + '.' + key)
+        if (!created || !subModel) continue
+
+        const Model = this.findModelBuilder(modelName)
+        const association = Model.associations[key]
+
+        if (!association) {
+          logger.error('Cannot find association %s of model %s', key, modelName, { associations: Object.keys(Model.associations) })
+          continue
+        }
+
+        if (association.isMultiAssociation) {
+          if (!Array.isArray(model[key])) model[key] = []
+
+          model[key].push(subModel)
+        } else {
+          model[key] = subModel
+        }
+      }
+    }
+
+    return { created, model }
+  }
+
+  private createOrFindModel (json: any, modelName: string, keyPath: string) {
+    const registryKey = this.getModelRegistryKey(json, keyPath)
+    if (this.modelRegistry.has(registryKey)) {
+      return {
+        created: false,
+        model: this.modelRegistry.get(registryKey)
+      }
+    }
+
+    const Model = this.findModelBuilder(modelName)
+
+    if (!Model) {
+      logger.error(
+        'Cannot build model %s that does not exist', this.buildSequelizeModelName(modelName),
+        { existing: this.sequelize.modelManager.all.map(m => m.name) }
+      )
+      return undefined
+    }
+
+    // FIXME: typings
+    const model = new (Model as any)(json)
+    this.modelRegistry.set(registryKey, model)
+
+    return { created: true, model }
+  }
+
+  private findModelBuilder (modelName: string) {
+    return this.sequelize.modelManager.getModel(this.buildSequelizeModelName(modelName))
+  }
+
+  private buildSequelizeModelName (modelName: string) {
+    if (modelName === 'Avatars') return 'ActorImageModel'
+    if (modelName === 'ActorFollowing') return 'ActorModel'
+    if (modelName === 'ActorFollower') return 'ActorModel'
+    if (modelName === 'FlaggedAccount') return 'AccountModel'
+
+    return modelName + 'Model'
+  }
+
+  private getModelRegistryKey (json: any, keyPath: string) {
+    return keyPath + json.id
+  }
+}
diff --git a/server/models/user/sql/user-notitication-list-query-builder.ts b/server/models/user/sql/user-notitication-list-query-builder.ts
new file mode 100644
index 000000000..6a6a71e3a
--- /dev/null
+++ b/server/models/user/sql/user-notitication-list-query-builder.ts
@@ -0,0 +1,264 @@
+import { Sequelize } from 'sequelize'
+import { AbstractRunQuery, ModelBuilder } from '@server/models/shared'
+import { getSort } from '@server/models/utils'
+import { UserNotificationModelForApi } from '@server/types/models'
+import { ActorImageType } from '@shared/models'
+
+export interface ListNotificationsOptions {
+  userId: number
+  unread?: boolean
+  sort: string
+  offset: number
+  limit: number
+}
+
+export class UserNotificationListQueryBuilder extends AbstractRunQuery {
+  private innerQuery: string
+
+  constructor (
+    protected readonly sequelize: Sequelize,
+    private readonly options: ListNotificationsOptions
+  ) {
+    super(sequelize)
+  }
+
+  async listNotifications () {
+    this.buildQuery()
+
+    const results = await this.runQuery({ nest: true })
+    const modelBuilder = new ModelBuilder<UserNotificationModelForApi>(this.sequelize)
+
+    return modelBuilder.createModels(results, 'UserNotification')
+  }
+
+  private buildInnerQuery () {
+    this.innerQuery = `SELECT * FROM "userNotification" AS "UserNotificationModel" ` +
+      `${this.getWhere()} ` +
+      `${this.getOrder()} ` +
+      `LIMIT :limit OFFSET :offset `
+
+    this.replacements.limit = this.options.limit
+    this.replacements.offset = this.options.offset
+  }
+
+  private buildQuery () {
+    this.buildInnerQuery()
+
+    this.query = `
+      ${this.getSelect()}
+      FROM (${this.innerQuery}) "UserNotificationModel"
+      ${this.getJoins()}
+      ${this.getOrder()}`
+  }
+
+  private getWhere () {
+    let base = '"UserNotificationModel"."userId" = :userId '
+    this.replacements.userId = this.options.userId
+
+    if (this.options.unread === true) {
+      base += 'AND "UserNotificationModel"."read" IS FALSE '
+    } else if (this.options.unread === false) {
+      base += 'AND "UserNotificationModel"."read" IS TRUE '
+    }
+
+    return `WHERE ${base}`
+  }
+
+  private getOrder () {
+    const orders = getSort(this.options.sort)
+
+    return 'ORDER BY ' + orders.map(o => `"UserNotificationModel"."${o[0]}" ${o[1]}`).join(', ')
+  }
+
+  private getSelect () {
+    return `SELECT
+      "UserNotificationModel"."id",
+      "UserNotificationModel"."type",
+      "UserNotificationModel"."read",
+      "UserNotificationModel"."createdAt",
+      "UserNotificationModel"."updatedAt",
+      "Video"."id" AS "Video.id",
+      "Video"."uuid" AS "Video.uuid",
+      "Video"."name" AS "Video.name",
+      "Video->VideoChannel"."id" AS "Video.VideoChannel.id",
+      "Video->VideoChannel"."name" AS "Video.VideoChannel.name",
+      "Video->VideoChannel->Actor"."id" AS "Video.VideoChannel.Actor.id",
+      "Video->VideoChannel->Actor"."preferredUsername" AS "Video.VideoChannel.Actor.preferredUsername",
+      "Video->VideoChannel->Actor->Avatars"."id" AS "Video.VideoChannel.Actor.Avatars.id",
+      "Video->VideoChannel->Actor->Avatars"."width" AS "Video.VideoChannel.Actor.Avatars.width",
+      "Video->VideoChannel->Actor->Avatars"."filename" AS "Video.VideoChannel.Actor.Avatars.filename",
+      "Video->VideoChannel->Actor->Server"."id" AS "Video.VideoChannel.Actor.Server.id",
+      "Video->VideoChannel->Actor->Server"."host" AS "Video.VideoChannel.Actor.Server.host",
+      "VideoComment"."id" AS "VideoComment.id",
+      "VideoComment"."originCommentId" AS "VideoComment.originCommentId",
+      "VideoComment->Account"."id" AS "VideoComment.Account.id",
+      "VideoComment->Account"."name" AS "VideoComment.Account.name",
+      "VideoComment->Account->Actor"."id" AS "VideoComment.Account.Actor.id",
+      "VideoComment->Account->Actor"."preferredUsername" AS "VideoComment.Account.Actor.preferredUsername",
+      "VideoComment->Account->Actor->Avatars"."id" AS "VideoComment.Account.Actor.Avatars.id",
+      "VideoComment->Account->Actor->Avatars"."width" AS "VideoComment.Account.Actor.Avatars.width",
+      "VideoComment->Account->Actor->Avatars"."filename" AS "VideoComment.Account.Actor.Avatars.filename",
+      "VideoComment->Account->Actor->Server"."id" AS "VideoComment.Account.Actor.Server.id",
+      "VideoComment->Account->Actor->Server"."host" AS "VideoComment.Account.Actor.Server.host",
+      "VideoComment->Video"."id" AS "VideoComment.Video.id",
+      "VideoComment->Video"."uuid" AS "VideoComment.Video.uuid",
+      "VideoComment->Video"."name" AS "VideoComment.Video.name",
+      "Abuse"."id" AS "Abuse.id",
+      "Abuse"."state" AS "Abuse.state",
+      "Abuse->VideoAbuse"."id" AS "Abuse.VideoAbuse.id",
+      "Abuse->VideoAbuse->Video"."id" AS "Abuse.VideoAbuse.Video.id",
+      "Abuse->VideoAbuse->Video"."uuid" AS "Abuse.VideoAbuse.Video.uuid",
+      "Abuse->VideoAbuse->Video"."name" AS "Abuse.VideoAbuse.Video.name",
+      "Abuse->VideoCommentAbuse"."id" AS "Abuse.VideoCommentAbuse.id",
+      "Abuse->VideoCommentAbuse->VideoComment"."id" AS "Abuse.VideoCommentAbuse.VideoComment.id",
+      "Abuse->VideoCommentAbuse->VideoComment"."originCommentId" AS "Abuse.VideoCommentAbuse.VideoComment.originCommentId",
+      "Abuse->VideoCommentAbuse->VideoComment->Video"."id" AS "Abuse.VideoCommentAbuse.VideoComment.Video.id",
+      "Abuse->VideoCommentAbuse->VideoComment->Video"."name" AS "Abuse.VideoCommentAbuse.VideoComment.Video.name",
+      "Abuse->VideoCommentAbuse->VideoComment->Video"."uuid" AS "Abuse.VideoCommentAbuse.VideoComment.Video.uuid",
+      "Abuse->FlaggedAccount"."id" AS "Abuse.FlaggedAccount.id",
+      "Abuse->FlaggedAccount"."name" AS "Abuse.FlaggedAccount.name",
+      "Abuse->FlaggedAccount"."description" AS "Abuse.FlaggedAccount.description",
+      "Abuse->FlaggedAccount"."actorId" AS "Abuse.FlaggedAccount.actorId",
+      "Abuse->FlaggedAccount"."userId" AS "Abuse.FlaggedAccount.userId",
+      "Abuse->FlaggedAccount"."applicationId" AS "Abuse.FlaggedAccount.applicationId",
+      "Abuse->FlaggedAccount"."createdAt" AS "Abuse.FlaggedAccount.createdAt",
+      "Abuse->FlaggedAccount"."updatedAt" AS "Abuse.FlaggedAccount.updatedAt",
+      "Abuse->FlaggedAccount->Actor"."id" AS "Abuse.FlaggedAccount.Actor.id",
+      "Abuse->FlaggedAccount->Actor"."preferredUsername" AS "Abuse.FlaggedAccount.Actor.preferredUsername",
+      "Abuse->FlaggedAccount->Actor->Avatars"."id" AS "Abuse.FlaggedAccount.Actor.Avatars.id",
+      "Abuse->FlaggedAccount->Actor->Avatars"."width" AS "Abuse.FlaggedAccount.Actor.Avatars.width",
+      "Abuse->FlaggedAccount->Actor->Avatars"."filename" AS "Abuse.FlaggedAccount.Actor.Avatars.filename",
+      "Abuse->FlaggedAccount->Actor->Server"."id" AS "Abuse.FlaggedAccount.Actor.Server.id",
+      "Abuse->FlaggedAccount->Actor->Server"."host" AS "Abuse.FlaggedAccount.Actor.Server.host",
+      "VideoBlacklist"."id" AS "VideoBlacklist.id",
+      "VideoBlacklist->Video"."id" AS "VideoBlacklist.Video.id",
+      "VideoBlacklist->Video"."uuid" AS "VideoBlacklist.Video.uuid",
+      "VideoBlacklist->Video"."name" AS "VideoBlacklist.Video.name",
+      "VideoImport"."id" AS "VideoImport.id",
+      "VideoImport"."magnetUri" AS "VideoImport.magnetUri",
+      "VideoImport"."targetUrl" AS "VideoImport.targetUrl",
+      "VideoImport"."torrentName" AS "VideoImport.torrentName",
+      "VideoImport->Video"."id" AS "VideoImport.Video.id",
+      "VideoImport->Video"."uuid" AS "VideoImport.Video.uuid",
+      "VideoImport->Video"."name" AS "VideoImport.Video.name",
+      "Plugin"."id" AS "Plugin.id",
+      "Plugin"."name" AS "Plugin.name",
+      "Plugin"."type" AS "Plugin.type",
+      "Plugin"."latestVersion" AS "Plugin.latestVersion",
+      "Application"."id" AS "Application.id",
+      "Application"."latestPeerTubeVersion" AS "Application.latestPeerTubeVersion",
+      "ActorFollow"."id" AS "ActorFollow.id",
+      "ActorFollow"."state" AS "ActorFollow.state",
+      "ActorFollow->ActorFollower"."id" AS "ActorFollow.ActorFollower.id",
+      "ActorFollow->ActorFollower"."preferredUsername" AS "ActorFollow.ActorFollower.preferredUsername",
+      "ActorFollow->ActorFollower->Account"."id" AS "ActorFollow.ActorFollower.Account.id",
+      "ActorFollow->ActorFollower->Account"."name" AS "ActorFollow.ActorFollower.Account.name",
+      "ActorFollow->ActorFollower->Avatars"."id" AS "ActorFollow.ActorFollower.Avatars.id",
+      "ActorFollow->ActorFollower->Avatars"."width" AS "ActorFollow.ActorFollower.Avatars.width",
+      "ActorFollow->ActorFollower->Avatars"."filename" AS "ActorFollow.ActorFollower.Avatars.filename",
+      "ActorFollow->ActorFollower->Server"."id" AS "ActorFollow.ActorFollower.Server.id",
+      "ActorFollow->ActorFollower->Server"."host" AS "ActorFollow.ActorFollower.Server.host",
+      "ActorFollow->ActorFollowing"."id" AS "ActorFollow.ActorFollowing.id",
+      "ActorFollow->ActorFollowing"."preferredUsername" AS "ActorFollow.ActorFollowing.preferredUsername",
+      "ActorFollow->ActorFollowing"."type" AS "ActorFollow.ActorFollowing.type",
+      "ActorFollow->ActorFollowing->VideoChannel"."id" AS "ActorFollow.ActorFollowing.VideoChannel.id",
+      "ActorFollow->ActorFollowing->VideoChannel"."name" AS "ActorFollow.ActorFollowing.VideoChannel.name",
+      "ActorFollow->ActorFollowing->Account"."id" AS "ActorFollow.ActorFollowing.Account.id",
+      "ActorFollow->ActorFollowing->Account"."name" AS "ActorFollow.ActorFollowing.Account.name",
+      "ActorFollow->ActorFollowing->Server"."id" AS "ActorFollow.ActorFollowing.Server.id",
+      "ActorFollow->ActorFollowing->Server"."host" AS "ActorFollow.ActorFollowing.Server.host",
+      "Account"."id" AS "Account.id",
+      "Account"."name" AS "Account.name",
+      "Account->Actor"."id" AS "Account.Actor.id",
+      "Account->Actor"."preferredUsername" AS "Account.Actor.preferredUsername",
+      "Account->Actor->Avatars"."id" AS "Account.Actor.Avatars.id",
+      "Account->Actor->Avatars"."width" AS "Account.Actor.Avatars.width",
+      "Account->Actor->Avatars"."filename" AS "Account.Actor.Avatars.filename",
+      "Account->Actor->Server"."id" AS "Account.Actor.Server.id",
+      "Account->Actor->Server"."host" AS "Account.Actor.Server.host"`
+  }
+
+  private getJoins () {
+    return `
+    LEFT JOIN (
+      "video" AS "Video"
+      INNER JOIN "videoChannel" AS "Video->VideoChannel" ON "Video"."channelId" = "Video->VideoChannel"."id"
+      INNER JOIN "actor" AS "Video->VideoChannel->Actor" ON "Video->VideoChannel"."actorId" = "Video->VideoChannel->Actor"."id"
+      LEFT JOIN "actorImage" AS "Video->VideoChannel->Actor->Avatars"
+        ON "Video->VideoChannel->Actor"."id" = "Video->VideoChannel->Actor->Avatars"."actorId"
+        AND "Video->VideoChannel->Actor->Avatars"."type" = ${ActorImageType.AVATAR}
+      LEFT JOIN "server" AS "Video->VideoChannel->Actor->Server"
+        ON "Video->VideoChannel->Actor"."serverId" = "Video->VideoChannel->Actor->Server"."id"
+    ) ON "UserNotificationModel"."videoId" = "Video"."id"
+
+  LEFT JOIN (
+    "videoComment" AS "VideoComment"
+    INNER JOIN "account" AS "VideoComment->Account" ON "VideoComment"."accountId" = "VideoComment->Account"."id"
+    INNER JOIN "actor" AS "VideoComment->Account->Actor" ON "VideoComment->Account"."actorId" = "VideoComment->Account->Actor"."id"
+    LEFT JOIN "actorImage" AS "VideoComment->Account->Actor->Avatars"
+      ON "VideoComment->Account->Actor"."id" = "VideoComment->Account->Actor->Avatars"."actorId"
+      AND "VideoComment->Account->Actor->Avatars"."type" = ${ActorImageType.AVATAR}
+    LEFT JOIN "server" AS "VideoComment->Account->Actor->Server"
+      ON "VideoComment->Account->Actor"."serverId" = "VideoComment->Account->Actor->Server"."id"
+    INNER JOIN "video" AS "VideoComment->Video" ON "VideoComment"."videoId" = "VideoComment->Video"."id"
+  ) ON "UserNotificationModel"."commentId" = "VideoComment"."id"
+
+  LEFT JOIN "abuse" AS "Abuse" ON "UserNotificationModel"."abuseId" = "Abuse"."id"
+  LEFT JOIN "videoAbuse" AS "Abuse->VideoAbuse" ON "Abuse"."id" = "Abuse->VideoAbuse"."abuseId"
+  LEFT JOIN "video" AS "Abuse->VideoAbuse->Video" ON "Abuse->VideoAbuse"."videoId" = "Abuse->VideoAbuse->Video"."id"
+  LEFT JOIN "commentAbuse" AS "Abuse->VideoCommentAbuse" ON "Abuse"."id" = "Abuse->VideoCommentAbuse"."abuseId"
+  LEFT JOIN "videoComment" AS "Abuse->VideoCommentAbuse->VideoComment"
+    ON "Abuse->VideoCommentAbuse"."videoCommentId" = "Abuse->VideoCommentAbuse->VideoComment"."id"
+  LEFT JOIN "video" AS "Abuse->VideoCommentAbuse->VideoComment->Video"
+    ON "Abuse->VideoCommentAbuse->VideoComment"."videoId" = "Abuse->VideoCommentAbuse->VideoComment->Video"."id"
+  LEFT JOIN (
+    "account" AS "Abuse->FlaggedAccount"
+    INNER JOIN "actor" AS "Abuse->FlaggedAccount->Actor" ON "Abuse->FlaggedAccount"."actorId" = "Abuse->FlaggedAccount->Actor"."id"
+    LEFT JOIN "actorImage" AS "Abuse->FlaggedAccount->Actor->Avatars"
+      ON "Abuse->FlaggedAccount->Actor"."id" = "Abuse->FlaggedAccount->Actor->Avatars"."actorId"
+      AND "Abuse->FlaggedAccount->Actor->Avatars"."type" = ${ActorImageType.AVATAR}
+    LEFT JOIN "server" AS "Abuse->FlaggedAccount->Actor->Server"
+      ON "Abuse->FlaggedAccount->Actor"."serverId" = "Abuse->FlaggedAccount->Actor->Server"."id"
+  ) ON "Abuse"."flaggedAccountId" = "Abuse->FlaggedAccount"."id"
+
+  LEFT JOIN (
+    "videoBlacklist" AS "VideoBlacklist"
+    INNER JOIN "video" AS "VideoBlacklist->Video" ON "VideoBlacklist"."videoId" = "VideoBlacklist->Video"."id"
+  ) ON "UserNotificationModel"."videoBlacklistId" = "VideoBlacklist"."id"
+
+  LEFT JOIN "videoImport" AS "VideoImport" ON "UserNotificationModel"."videoImportId" = "VideoImport"."id"
+  LEFT JOIN "video" AS "VideoImport->Video" ON "VideoImport"."videoId" = "VideoImport->Video"."id"
+
+  LEFT JOIN "plugin" AS "Plugin" ON "UserNotificationModel"."pluginId" = "Plugin"."id"
+
+  LEFT JOIN "application" AS "Application" ON "UserNotificationModel"."applicationId" = "Application"."id"
+
+  LEFT JOIN (
+    "actorFollow" AS "ActorFollow"
+    INNER JOIN "actor" AS "ActorFollow->ActorFollower" ON "ActorFollow"."actorId" = "ActorFollow->ActorFollower"."id"
+    INNER JOIN "account" AS "ActorFollow->ActorFollower->Account"
+      ON "ActorFollow->ActorFollower"."id" = "ActorFollow->ActorFollower->Account"."actorId"
+    LEFT JOIN "actorImage" AS "ActorFollow->ActorFollower->Avatars"
+      ON "ActorFollow->ActorFollower"."id" = "ActorFollow->ActorFollower->Avatars"."actorId"
+      AND "ActorFollow->ActorFollower->Avatars"."type" = ${ActorImageType.AVATAR}
+    LEFT JOIN "server" AS "ActorFollow->ActorFollower->Server"
+      ON "ActorFollow->ActorFollower"."serverId" = "ActorFollow->ActorFollower->Server"."id"
+    INNER JOIN "actor" AS "ActorFollow->ActorFollowing" ON "ActorFollow"."targetActorId" = "ActorFollow->ActorFollowing"."id"
+    LEFT JOIN "videoChannel" AS "ActorFollow->ActorFollowing->VideoChannel"
+      ON "ActorFollow->ActorFollowing"."id" = "ActorFollow->ActorFollowing->VideoChannel"."actorId"
+    LEFT JOIN "account" AS "ActorFollow->ActorFollowing->Account"
+      ON "ActorFollow->ActorFollowing"."id" = "ActorFollow->ActorFollowing->Account"."actorId"
+    LEFT JOIN "server" AS "ActorFollow->ActorFollowing->Server"
+      ON "ActorFollow->ActorFollowing"."serverId" = "ActorFollow->ActorFollowing->Server"."id"
+  ) ON "UserNotificationModel"."actorFollowId" = "ActorFollow"."id"
+
+  LEFT JOIN (
+    "account" AS "Account"
+    INNER JOIN "actor" AS "Account->Actor" ON "Account"."actorId" = "Account->Actor"."id"
+    LEFT JOIN "actorImage" AS "Account->Actor->Avatars"
+      ON "Account->Actor"."id" = "Account->Actor->Avatars"."actorId"
+      AND "Account->Actor->Avatars"."type" = ${ActorImageType.AVATAR}
+    LEFT JOIN "server" AS "Account->Actor->Server" ON "Account->Actor"."serverId" = "Account->Actor->Server"."id"
+  ) ON "UserNotificationModel"."accountId" = "Account"."id"`
+  }
+}
diff --git a/server/models/user/user-notification.ts b/server/models/user/user-notification.ts
index edad10a55..6209cb4bf 100644
--- a/server/models/user/user-notification.ts
+++ b/server/models/user/user-notification.ts
@@ -1,5 +1,6 @@
-import { FindOptions, ModelIndexesOptions, Op, WhereOptions } from 'sequelize'
-import { AllowNull, BelongsTo, Column, CreatedAt, Default, ForeignKey, Is, Model, Scopes, Table, UpdatedAt } from 'sequelize-typescript'
+import { ModelIndexesOptions, Op, WhereOptions } from 'sequelize'
+import { AllowNull, BelongsTo, Column, CreatedAt, Default, ForeignKey, Is, Model, Table, UpdatedAt } from 'sequelize-typescript'
+import { getBiggestActorImage } from '@server/lib/actor-image'
 import { UserNotificationIncludes, UserNotificationModelForApi } from '@server/types/models/user'
 import { uuidToShort } from '@shared/extra-utils'
 import { UserNotification, UserNotificationType } from '@shared/models'
@@ -7,207 +8,18 @@ import { AttributesOnly } from '@shared/typescript-utils'
 import { isBooleanValid } from '../../helpers/custom-validators/misc'
 import { isUserNotificationTypeValid } from '../../helpers/custom-validators/user-notifications'
 import { AbuseModel } from '../abuse/abuse'
-import { VideoAbuseModel } from '../abuse/video-abuse'
-import { VideoCommentAbuseModel } from '../abuse/video-comment-abuse'
 import { AccountModel } from '../account/account'
-import { ActorModel } from '../actor/actor'
 import { ActorFollowModel } from '../actor/actor-follow'
-import { ActorImageModel } from '../actor/actor-image'
 import { ApplicationModel } from '../application/application'
 import { PluginModel } from '../server/plugin'
-import { ServerModel } from '../server/server'
-import { getSort, throwIfNotValid } from '../utils'
+import { throwIfNotValid } from '../utils'
 import { VideoModel } from '../video/video'
 import { VideoBlacklistModel } from '../video/video-blacklist'
-import { VideoChannelModel } from '../video/video-channel'
 import { VideoCommentModel } from '../video/video-comment'
 import { VideoImportModel } from '../video/video-import'
+import { UserNotificationListQueryBuilder } from './sql/user-notitication-list-query-builder'
 import { UserModel } from './user'
 
-enum ScopeNames {
-  WITH_ALL = 'WITH_ALL'
-}
-
-function buildActorWithAvatarInclude () {
-  return {
-    attributes: [ 'preferredUsername' ],
-    model: ActorModel.unscoped(),
-    required: true,
-    include: [
-      {
-        attributes: [ 'filename' ],
-        as: 'Avatar',
-        model: ActorImageModel.unscoped(),
-        required: false
-      },
-      {
-        attributes: [ 'host' ],
-        model: ServerModel.unscoped(),
-        required: false
-      }
-    ]
-  }
-}
-
-function buildVideoInclude (required: boolean) {
-  return {
-    attributes: [ 'id', 'uuid', 'name' ],
-    model: VideoModel.unscoped(),
-    required
-  }
-}
-
-function buildChannelInclude (required: boolean, withActor = false) {
-  return {
-    required,
-    attributes: [ 'id', 'name' ],
-    model: VideoChannelModel.unscoped(),
-    include: withActor === true ? [ buildActorWithAvatarInclude() ] : []
-  }
-}
-
-function buildAccountInclude (required: boolean, withActor = false) {
-  return {
-    required,
-    attributes: [ 'id', 'name' ],
-    model: AccountModel.unscoped(),
-    include: withActor === true ? [ buildActorWithAvatarInclude() ] : []
-  }
-}
-
-@Scopes(() => ({
-  [ScopeNames.WITH_ALL]: {
-    include: [
-      Object.assign(buildVideoInclude(false), {
-        include: [ buildChannelInclude(true, true) ]
-      }),
-
-      {
-        attributes: [ 'id', 'originCommentId' ],
-        model: VideoCommentModel.unscoped(),
-        required: false,
-        include: [
-          buildAccountInclude(true, true),
-          buildVideoInclude(true)
-        ]
-      },
-
-      {
-        attributes: [ 'id', 'state' ],
-        model: AbuseModel.unscoped(),
-        required: false,
-        include: [
-          {
-            attributes: [ 'id' ],
-            model: VideoAbuseModel.unscoped(),
-            required: false,
-            include: [ buildVideoInclude(false) ]
-          },
-          {
-            attributes: [ 'id' ],
-            model: VideoCommentAbuseModel.unscoped(),
-            required: false,
-            include: [
-              {
-                attributes: [ 'id', 'originCommentId' ],
-                model: VideoCommentModel.unscoped(),
-                required: false,
-                include: [
-                  {
-                    attributes: [ 'id', 'name', 'uuid' ],
-                    model: VideoModel.unscoped(),
-                    required: false
-                  }
-                ]
-              }
-            ]
-          },
-          {
-            model: AccountModel,
-            as: 'FlaggedAccount',
-            required: false,
-            include: [ buildActorWithAvatarInclude() ]
-          }
-        ]
-      },
-
-      {
-        attributes: [ 'id' ],
-        model: VideoBlacklistModel.unscoped(),
-        required: false,
-        include: [ buildVideoInclude(true) ]
-      },
-
-      {
-        attributes: [ 'id', 'magnetUri', 'targetUrl', 'torrentName' ],
-        model: VideoImportModel.unscoped(),
-        required: false,
-        include: [ buildVideoInclude(false) ]
-      },
-
-      {
-        attributes: [ 'id', 'name', 'type', 'latestVersion' ],
-        model: PluginModel.unscoped(),
-        required: false
-      },
-
-      {
-        attributes: [ 'id', 'latestPeerTubeVersion' ],
-        model: ApplicationModel.unscoped(),
-        required: false
-      },
-
-      {
-        attributes: [ 'id', 'state' ],
-        model: ActorFollowModel.unscoped(),
-        required: false,
-        include: [
-          {
-            attributes: [ 'preferredUsername' ],
-            model: ActorModel.unscoped(),
-            required: true,
-            as: 'ActorFollower',
-            include: [
-              {
-                attributes: [ 'id', 'name' ],
-                model: AccountModel.unscoped(),
-                required: true
-              },
-              {
-                attributes: [ 'filename' ],
-                as: 'Avatar',
-                model: ActorImageModel.unscoped(),
-                required: false
-              },
-              {
-                attributes: [ 'host' ],
-                model: ServerModel.unscoped(),
-                required: false
-              }
-            ]
-          },
-          {
-            attributes: [ 'preferredUsername', 'type' ],
-            model: ActorModel.unscoped(),
-            required: true,
-            as: 'ActorFollowing',
-            include: [
-              buildChannelInclude(false),
-              buildAccountInclude(false),
-              {
-                attributes: [ 'host' ],
-                model: ServerModel.unscoped(),
-                required: false
-              }
-            ]
-          }
-        ]
-      },
-
-      buildAccountInclude(false, true)
-    ]
-  }
-}))
 @Table({
   tableName: 'userNotification',
   indexes: [
@@ -342,7 +154,7 @@ export class UserNotificationModel extends Model<Partial<AttributesOnly<UserNoti
     },
     onDelete: 'cascade'
   })
-  Comment: VideoCommentModel
+  VideoComment: VideoCommentModel
 
   @ForeignKey(() => AbuseModel)
   @Column
@@ -431,10 +243,12 @@ export class UserNotificationModel extends Model<Partial<AttributesOnly<UserNoti
   static listForApi (userId: number, start: number, count: number, sort: string, unread?: boolean) {
     const where = { userId }
 
-    const query: FindOptions = {
+    const query = {
+      userId,
+      unread,
       offset: start,
       limit: count,
-      order: getSort(sort),
+      sort,
       where
     }
 
@@ -445,8 +259,8 @@ export class UserNotificationModel extends Model<Partial<AttributesOnly<UserNoti
         .then(count => count || 0),
 
       count === 0
-        ? []
-        : UserNotificationModel.scope(ScopeNames.WITH_ALL).findAll(query)
+        ? [] as UserNotificationModelForApi[]
+        : new UserNotificationListQueryBuilder(this.sequelize, query).listNotifications()
     ]).then(([ total, data ]) => ({ total, data }))
   }
 
@@ -524,25 +338,31 @@ export class UserNotificationModel extends Model<Partial<AttributesOnly<UserNoti
 
   toFormattedJSON (this: UserNotificationModelForApi): UserNotification {
     const video = this.Video
-      ? Object.assign(this.formatVideo(this.Video), { channel: this.formatActor(this.Video.VideoChannel) })
+      ? {
+        ...this.formatVideo(this.Video),
+
+        channel: this.formatActor(this.Video.VideoChannel)
+      }
       : undefined
 
     const videoImport = this.VideoImport
       ? {
         id: this.VideoImport.id,
-        video: this.VideoImport.Video ? this.formatVideo(this.VideoImport.Video) : undefined,
+        video: this.VideoImport.Video
+          ? this.formatVideo(this.VideoImport.Video)
+          : undefined,
         torrentName: this.VideoImport.torrentName,
         magnetUri: this.VideoImport.magnetUri,
         targetUrl: this.VideoImport.targetUrl
       }
       : undefined
 
-    const comment = this.Comment
+    const comment = this.VideoComment
       ? {
-        id: this.Comment.id,
-        threadId: this.Comment.getThreadId(),
-        account: this.formatActor(this.Comment.Account),
-        video: this.formatVideo(this.Comment.Video)
+        id: this.VideoComment.id,
+        threadId: this.VideoComment.getThreadId(),
+        account: this.formatActor(this.VideoComment.Account),
+        video: this.formatVideo(this.VideoComment.Video)
       }
       : undefined
 
@@ -570,8 +390,9 @@ export class UserNotificationModel extends Model<Partial<AttributesOnly<UserNoti
           id: this.ActorFollow.ActorFollower.Account.id,
           displayName: this.ActorFollow.ActorFollower.Account.getDisplayName(),
           name: this.ActorFollow.ActorFollower.preferredUsername,
-          avatar: this.ActorFollow.ActorFollower.Avatar ? { path: this.ActorFollow.ActorFollower.Avatar.getStaticPath() } : undefined,
-          host: this.ActorFollow.ActorFollower.getHost()
+          host: this.ActorFollow.ActorFollower.getHost(),
+
+          ...this.formatAvatars(this.ActorFollow.ActorFollower.Avatars)
         },
         following: {
           type: actorFollowingType[this.ActorFollow.ActorFollowing.type],
@@ -612,7 +433,7 @@ export class UserNotificationModel extends Model<Partial<AttributesOnly<UserNoti
     }
   }
 
-  formatVideo (this: UserNotificationModelForApi, video: UserNotificationIncludes.VideoInclude) {
+  formatVideo (video: UserNotificationIncludes.VideoInclude) {
     return {
       id: video.id,
       uuid: video.uuid,
@@ -621,7 +442,7 @@ export class UserNotificationModel extends Model<Partial<AttributesOnly<UserNoti
     }
   }
 
-  formatAbuse (this: UserNotificationModelForApi, abuse: UserNotificationIncludes.AbuseInclude) {
+  formatAbuse (abuse: UserNotificationIncludes.AbuseInclude) {
     const commentAbuse = abuse.VideoCommentAbuse?.VideoComment
       ? {
         threadId: abuse.VideoCommentAbuse.VideoComment.getThreadId(),
@@ -637,9 +458,13 @@ export class UserNotificationModel extends Model<Partial<AttributesOnly<UserNoti
       }
       : undefined
 
-    const videoAbuse = abuse.VideoAbuse?.Video ? this.formatVideo(abuse.VideoAbuse.Video) : undefined
+    const videoAbuse = abuse.VideoAbuse?.Video
+      ? this.formatVideo(abuse.VideoAbuse.Video)
+      : undefined
 
-    const accountAbuse = (!commentAbuse && !videoAbuse && abuse.FlaggedAccount) ? this.formatActor(abuse.FlaggedAccount) : undefined
+    const accountAbuse = (!commentAbuse && !videoAbuse && abuse.FlaggedAccount)
+      ? this.formatActor(abuse.FlaggedAccount)
+      : undefined
 
     return {
       id: abuse.id,
@@ -651,19 +476,32 @@ export class UserNotificationModel extends Model<Partial<AttributesOnly<UserNoti
   }
 
   formatActor (
-    this: UserNotificationModelForApi,
     accountOrChannel: UserNotificationIncludes.AccountIncludeActor | UserNotificationIncludes.VideoChannelIncludeActor
   ) {
-    const avatar = accountOrChannel.Actor.Avatar
-      ? { path: accountOrChannel.Actor.Avatar.getStaticPath() }
-      : undefined
-
     return {
       id: accountOrChannel.id,
       displayName: accountOrChannel.getDisplayName(),
       name: accountOrChannel.Actor.preferredUsername,
       host: accountOrChannel.Actor.getHost(),
-      avatar
+
+      ...this.formatAvatars(accountOrChannel.Actor.Avatars)
+    }
+  }
+
+  formatAvatars (avatars: UserNotificationIncludes.ActorImageInclude[]) {
+    if (!avatars || avatars.length === 0) return { avatar: undefined, avatars: [] }
+
+    return {
+      avatar: this.formatAvatar(getBiggestActorImage(avatars)),
+
+      avatars: avatars.map(a => this.formatAvatar(a))
+    }
+  }
+
+  formatAvatar (a: UserNotificationIncludes.ActorImageInclude) {
+    return {
+      path: a.getStaticPath(),
+      width: a.width
     }
   }
 }
diff --git a/server/models/user/user.ts b/server/models/user/user.ts
index ad8ce08cb..bcf56dfa1 100644
--- a/server/models/user/user.ts
+++ b/server/models/user/user.ts
@@ -106,7 +106,7 @@ enum ScopeNames {
                 include: [
                   {
                     model: ActorImageModel,
-                    as: 'Banner',
+                    as: 'Banners',
                     required: false
                   }
                 ]
@@ -495,13 +495,10 @@ export class UserModel extends Model<Partial<AttributesOnly<UserModel>>> {
       where
     }
 
-    return UserModel.findAndCountAll(query)
-                    .then(({ rows, count }) => {
-                      return {
-                        data: rows,
-                        total: count
-                      }
-                    })
+    return Promise.all([
+      UserModel.unscoped().count(query),
+      UserModel.findAll(query)
+    ]).then(([ total, data ]) => ({ total, data }))
   }
 
   static listWithRight (right: UserRight): Promise<MUserDefault[]> {
diff --git a/server/models/utils.ts b/server/models/utils.ts
index 66b653e3d..70bfbdb8b 100644
--- a/server/models/utils.ts
+++ b/server/models/utils.ts
@@ -181,7 +181,7 @@ function buildServerIdsFollowedBy (actorId: any) {
     'SELECT "actor"."serverId" FROM "actorFollow" ' +
     'INNER JOIN "actor" ON actor.id = "actorFollow"."targetActorId" ' +
     'WHERE "actorFollow"."actorId" = ' + actorIdNumber +
-    ')'
+  ')'
 }
 
 function buildWhereIdOrUUID (id: number | string) {
diff --git a/server/models/video/sql/video/index.ts b/server/models/video/sql/video/index.ts
new file mode 100644
index 000000000..e9132d5e1
--- /dev/null
+++ b/server/models/video/sql/video/index.ts
@@ -0,0 +1,3 @@
+export * from './video-model-get-query-builder'
+export * from './videos-id-list-query-builder'
+export * from './videos-model-list-query-builder'
diff --git a/server/models/video/sql/shared/abstract-video-query-builder.ts b/server/models/video/sql/video/shared/abstract-video-query-builder.ts
index a6afb04e4..b79d20ade 100644
--- a/server/models/video/sql/shared/abstract-video-query-builder.ts
+++ b/server/models/video/sql/video/shared/abstract-video-query-builder.ts
@@ -1,7 +1,9 @@
+import { Sequelize } from 'sequelize'
+import validator from 'validator'
 import { createSafeIn } from '@server/models/utils'
 import { MUserAccountId } from '@server/types/models'
-import validator from 'validator'
-import { AbstractRunQuery } from './abstract-run-query'
+import { ActorImageType } from '@shared/models'
+import { AbstractRunQuery } from '../../../../shared/abstract-run-query'
 import { VideoTableAttributes } from './video-table-attributes'
 
 /**
@@ -18,8 +20,11 @@ export class AbstractVideoQueryBuilder extends AbstractRunQuery {
 
   protected tables: VideoTableAttributes
 
-  constructor (protected readonly mode: 'list' | 'get') {
-    super()
+  constructor (
+    protected readonly sequelize: Sequelize,
+    protected readonly mode: 'list' | 'get'
+  ) {
+    super(sequelize)
 
     this.tables = new VideoTableAttributes(this.mode)
   }
@@ -42,8 +47,9 @@ export class AbstractVideoQueryBuilder extends AbstractRunQuery {
     )
 
     this.addJoin(
-      'LEFT OUTER JOIN "actorImage" AS "VideoChannel->Actor->Avatar" ' +
-        'ON "VideoChannel->Actor"."avatarId" = "VideoChannel->Actor->Avatar"."id"'
+      'LEFT OUTER JOIN "actorImage" AS "VideoChannel->Actor->Avatars" ' +
+        'ON "VideoChannel->Actor"."id" = "VideoChannel->Actor->Avatars"."actorId" ' +
+        `AND "VideoChannel->Actor->Avatars"."type" = ${ActorImageType.AVATAR}`
     )
 
     this.attributes = {
@@ -51,7 +57,7 @@ export class AbstractVideoQueryBuilder extends AbstractRunQuery {
 
       ...this.buildAttributesObject('VideoChannel', this.tables.getChannelAttributes()),
       ...this.buildActorInclude('VideoChannel->Actor'),
-      ...this.buildAvatarInclude('VideoChannel->Actor->Avatar'),
+      ...this.buildAvatarInclude('VideoChannel->Actor->Avatars'),
       ...this.buildServerInclude('VideoChannel->Actor->Server')
     }
   }
@@ -68,8 +74,9 @@ export class AbstractVideoQueryBuilder extends AbstractRunQuery {
     )
 
     this.addJoin(
-      'LEFT OUTER JOIN "actorImage" AS "VideoChannel->Account->Actor->Avatar" ' +
-        'ON "VideoChannel->Account->Actor"."avatarId" = "VideoChannel->Account->Actor->Avatar"."id"'
+      'LEFT OUTER JOIN "actorImage" AS "VideoChannel->Account->Actor->Avatars" ' +
+        'ON "VideoChannel->Account"."actorId"= "VideoChannel->Account->Actor->Avatars"."actorId" ' +
+        `AND "VideoChannel->Account->Actor->Avatars"."type" = ${ActorImageType.AVATAR}`
     )
 
     this.attributes = {
@@ -77,7 +84,7 @@ export class AbstractVideoQueryBuilder extends AbstractRunQuery {
 
       ...this.buildAttributesObject('VideoChannel->Account', this.tables.getAccountAttributes()),
       ...this.buildActorInclude('VideoChannel->Account->Actor'),
-      ...this.buildAvatarInclude('VideoChannel->Account->Actor->Avatar'),
+      ...this.buildAvatarInclude('VideoChannel->Account->Actor->Avatars'),
       ...this.buildServerInclude('VideoChannel->Account->Actor->Server')
     }
   }
diff --git a/server/models/video/sql/shared/video-file-query-builder.ts b/server/models/video/sql/video/shared/video-file-query-builder.ts
index 3eb3dc07d..50c12f627 100644
--- a/server/models/video/sql/shared/video-file-query-builder.ts
+++ b/server/models/video/sql/video/shared/video-file-query-builder.ts
@@ -12,7 +12,7 @@ export class VideoFileQueryBuilder extends AbstractVideoQueryBuilder {
   protected attributes: { [key: string]: string }
 
   constructor (protected readonly sequelize: Sequelize) {
-    super('get')
+    super(sequelize, 'get')
   }
 
   queryWebTorrentVideos (options: BuildVideoGetQueryOptions) {
diff --git a/server/models/video/sql/shared/video-model-builder.ts b/server/models/video/sql/video/shared/video-model-builder.ts
index 7751d8e68..0a2beb7db 100644
--- a/server/models/video/sql/shared/video-model-builder.ts
+++ b/server/models/video/sql/video/shared/video-model-builder.ts
@@ -9,15 +9,15 @@ import { ServerBlocklistModel } from '@server/models/server/server-blocklist'
 import { TrackerModel } from '@server/models/server/tracker'
 import { UserVideoHistoryModel } from '@server/models/user/user-video-history'
 import { VideoInclude } from '@shared/models'
-import { ScheduleVideoUpdateModel } from '../../schedule-video-update'
-import { TagModel } from '../../tag'
-import { ThumbnailModel } from '../../thumbnail'
-import { VideoModel } from '../../video'
-import { VideoBlacklistModel } from '../../video-blacklist'
-import { VideoChannelModel } from '../../video-channel'
-import { VideoFileModel } from '../../video-file'
-import { VideoLiveModel } from '../../video-live'
-import { VideoStreamingPlaylistModel } from '../../video-streaming-playlist'
+import { ScheduleVideoUpdateModel } from '../../../schedule-video-update'
+import { TagModel } from '../../../tag'
+import { ThumbnailModel } from '../../../thumbnail'
+import { VideoModel } from '../../../video'
+import { VideoBlacklistModel } from '../../../video-blacklist'
+import { VideoChannelModel } from '../../../video-channel'
+import { VideoFileModel } from '../../../video-file'
+import { VideoLiveModel } from '../../../video-live'
+import { VideoStreamingPlaylistModel } from '../../../video-streaming-playlist'
 import { VideoTableAttributes } from './video-table-attributes'
 
 type SQLRow = { [id: string]: string | number }
@@ -34,6 +34,7 @@ export class VideoModelBuilder {
   private videoFileMemo: { [ id: number ]: VideoFileModel }
 
   private thumbnailsDone: Set<any>
+  private actorImagesDone: Set<any>
   private historyDone: Set<any>
   private blacklistDone: Set<any>
   private accountBlocklistDone: Set<any>
@@ -50,8 +51,8 @@ export class VideoModelBuilder {
   private readonly buildOpts = { raw: true, isNewRecord: false }
 
   constructor (
-    readonly mode: 'get' | 'list',
-    readonly tables: VideoTableAttributes
+    private readonly mode: 'get' | 'list',
+    private readonly tables: VideoTableAttributes
   ) {
 
   }
@@ -69,11 +70,21 @@ export class VideoModelBuilder {
     for (const row of rows) {
       this.buildVideoAndAccount(row)
 
-      const videoModel = this.videosMemo[row.id]
+      const videoModel = this.videosMemo[row.id as number]
 
       this.setUserHistory(row, videoModel)
       this.addThumbnail(row, videoModel)
 
+      const channelActor = videoModel.VideoChannel?.Actor
+      if (channelActor) {
+        this.addActorAvatar(row, 'VideoChannel.Actor', channelActor)
+      }
+
+      const accountActor = videoModel.VideoChannel?.Account?.Actor
+      if (accountActor) {
+        this.addActorAvatar(row, 'VideoChannel.Account.Actor', accountActor)
+      }
+
       if (!rowsWebTorrentFiles) {
         this.addWebTorrentFile(row, videoModel)
       }
@@ -113,6 +124,7 @@ export class VideoModelBuilder {
     this.videoFileMemo = {}
 
     this.thumbnailsDone = new Set()
+    this.actorImagesDone = new Set()
     this.historyDone = new Set()
     this.blacklistDone = new Set()
     this.liveDone = new Set()
@@ -195,13 +207,8 @@ export class VideoModelBuilder {
 
   private buildActor (row: SQLRow, prefix: string) {
     const actorPrefix = `${prefix}.Actor`
-    const avatarPrefix = `${actorPrefix}.Avatar`
     const serverPrefix = `${actorPrefix}.Server`
 
-    const avatarModel = row[`${avatarPrefix}.id`] !== null
-      ? new ActorImageModel(this.grab(row, this.tables.getAvatarAttributes(), avatarPrefix), this.buildOpts)
-      : null
-
     const serverModel = row[`${serverPrefix}.id`] !== null
       ? new ServerModel(this.grab(row, this.tables.getServerAttributes(), serverPrefix), this.buildOpts)
       : null
@@ -209,8 +216,8 @@ export class VideoModelBuilder {
     if (serverModel) serverModel.BlockedBy = []
 
     const actorModel = new ActorModel(this.grab(row, this.tables.getActorAttributes(), actorPrefix), this.buildOpts)
-    actorModel.Avatar = avatarModel
     actorModel.Server = serverModel
+    actorModel.Avatars = []
 
     return actorModel
   }
@@ -226,6 +233,20 @@ export class VideoModelBuilder {
     this.historyDone.add(id)
   }
 
+  private addActorAvatar (row: SQLRow, actorPrefix: string, actor: ActorModel) {
+    const avatarPrefix = `${actorPrefix}.Avatars`
+    const id = row[`${avatarPrefix}.id`]
+    const key = `${row.id}${id}`
+
+    if (!id || this.actorImagesDone.has(key)) return
+
+    const attributes = this.grab(row, this.tables.getAvatarAttributes(), avatarPrefix)
+    const avatarModel = new ActorImageModel(attributes, this.buildOpts)
+    actor.Avatars.push(avatarModel)
+
+    this.actorImagesDone.add(key)
+  }
+
   private addThumbnail (row: SQLRow, videoModel: VideoModel) {
     const id = row['Thumbnails.id']
     if (!id || this.thumbnailsDone.has(id)) return
diff --git a/server/models/video/sql/shared/video-table-attributes.ts b/server/models/video/sql/video/shared/video-table-attributes.ts
index 8a8d2073a..f4d9e99fd 100644
--- a/server/models/video/sql/shared/video-table-attributes.ts
+++ b/server/models/video/sql/video/shared/video-table-attributes.ts
@@ -6,7 +6,7 @@
  */
 export class VideoTableAttributes {
 
-  constructor (readonly mode: 'get' | 'list') {
+  constructor (private readonly mode: 'get' | 'list') {
 
   }
 
@@ -186,8 +186,7 @@ export class VideoTableAttributes {
       'id',
       'preferredUsername',
       'url',
-      'serverId',
-      'avatarId'
+      'serverId'
     ]
 
     if (this.mode === 'get') {
@@ -212,6 +211,7 @@ export class VideoTableAttributes {
   getAvatarAttributes () {
     let attributeKeys = [
       'id',
+      'width',
       'filename',
       'type',
       'fileUrl',
diff --git a/server/models/video/sql/video-model-get-query-builder.ts b/server/models/video/sql/video/video-model-get-query-builder.ts
index a65c96097..b0879c9ac 100644
--- a/server/models/video/sql/video-model-get-query-builder.ts
+++ b/server/models/video/sql/video/video-model-get-query-builder.ts
@@ -110,7 +110,7 @@ export class VideosModelGetQuerySubBuilder extends AbstractVideoQueryBuilder {
   ])
 
   constructor (protected readonly sequelize: Sequelize) {
-    super('get')
+    super(sequelize, 'get')
   }
 
   queryVideos (options: BuildVideoGetQueryOptions) {
diff --git a/server/models/video/sql/videos-id-list-query-builder.ts b/server/models/video/sql/video/videos-id-list-query-builder.ts
index 098e15359..19aff631d 100644
--- a/server/models/video/sql/videos-id-list-query-builder.ts
+++ b/server/models/video/sql/video/videos-id-list-query-builder.ts
@@ -5,7 +5,7 @@ import { WEBSERVER } from '@server/initializers/constants'
 import { buildDirectionAndField, createSafeIn } from '@server/models/utils'
 import { MUserAccountId, MUserId } from '@server/types/models'
 import { VideoInclude, VideoPrivacy, VideoState } from '@shared/models'
-import { AbstractRunQuery } from './shared/abstract-run-query'
+import { AbstractRunQuery } from '../../../shared/abstract-run-query'
 
 /**
  *
@@ -93,7 +93,7 @@ export class VideosIdListQueryBuilder extends AbstractRunQuery {
   private offset = ''
 
   constructor (protected readonly sequelize: Sequelize) {
-    super()
+    super(sequelize)
   }
 
   queryVideoIds (options: BuildVideosListQueryOptions) {
diff --git a/server/models/video/sql/videos-model-list-query-builder.ts b/server/models/video/sql/video/videos-model-list-query-builder.ts
index b15b29ec3..2a4afc389 100644
--- a/server/models/video/sql/videos-model-list-query-builder.ts
+++ b/server/models/video/sql/video/videos-model-list-query-builder.ts
@@ -19,7 +19,7 @@ export class VideosModelListQueryBuilder extends AbstractVideoQueryBuilder {
   private readonly videoModelBuilder: VideoModelBuilder
 
   constructor (protected readonly sequelize: Sequelize) {
-    super('list')
+    super(sequelize, 'list')
 
     this.videoModelBuilder = new VideoModelBuilder(this.mode, this.tables)
   }
diff --git a/server/models/video/video-channel.ts b/server/models/video/video-channel.ts
index 2c6669bcb..410fd6d3f 100644
--- a/server/models/video/video-channel.ts
+++ b/server/models/video/video-channel.ts
@@ -31,6 +31,7 @@ import {
 import { CONSTRAINTS_FIELDS, WEBSERVER } from '../../initializers/constants'
 import { sendDeleteActor } from '../../lib/activitypub/send'
 import {
+  MChannel,
   MChannelActor,
   MChannelAP,
   MChannelBannerAccountDefault,
@@ -62,6 +63,7 @@ type AvailableForListOptions = {
   search?: string
   host?: string
   handles?: string[]
+  forCount?: boolean
 }
 
 type AvailableWithStatsOptions = {
@@ -116,70 +118,91 @@ export type SummaryOptions = {
       })
     }
 
-    let rootWhere: WhereOptions
-    if (options.handles) {
-      const or: WhereOptions[] = []
+    if (Array.isArray(options.handles) && options.handles.length !== 0) {
+      const or: string[] = []
 
       for (const handle of options.handles || []) {
         const [ preferredUsername, host ] = handle.split('@')
 
         if (!host || host === WEBSERVER.HOST) {
-          or.push({
-            '$Actor.preferredUsername$': preferredUsername,
-            '$Actor.serverId$': null
-          })
+          or.push(`("preferredUsername" = ${VideoChannelModel.sequelize.escape(preferredUsername)} AND "serverId" IS NULL)`)
         } else {
-          or.push({
-            '$Actor.preferredUsername$': preferredUsername,
-            '$Actor.Server.host$': host
-          })
+          or.push(
+            `(` +
+              `"preferredUsername" = ${VideoChannelModel.sequelize.escape(preferredUsername)} ` +
+              `AND "host" = ${VideoChannelModel.sequelize.escape(host)}` +
+            `)`
+          )
         }
       }
 
-      rootWhere = {
-        [Op.or]: or
-      }
+      whereActorAnd.push({
+        id: {
+          [Op.in]: literal(`(SELECT "actor".id FROM actor LEFT JOIN server on server.id = actor."serverId" WHERE ${or.join(' OR ')})`)
+        }
+      })
+    }
+
+    const channelInclude: Includeable[] = []
+    const accountInclude: Includeable[] = []
+
+    if (options.forCount !== true) {
+      accountInclude.push({
+        model: ServerModel,
+        required: false
+      })
+
+      accountInclude.push({
+        model: ActorImageModel,
+        as: 'Avatars',
+        required: false
+      })
+
+      channelInclude.push({
+        model: ActorImageModel,
+        as: 'Avatars',
+        required: false
+      })
+
+      channelInclude.push({
+        model: ActorImageModel,
+        as: 'Banners',
+        required: false
+      })
+    }
+
+    if (options.forCount !== true || serverRequired) {
+      channelInclude.push({
+        model: ServerModel,
+        duplicating: false,
+        required: serverRequired,
+        where: whereServer
+      })
     }
 
     return {
-      where: rootWhere,
       include: [
         {
           attributes: {
             exclude: unusedActorAttributesForAPI
           },
-          model: ActorModel,
+          model: ActorModel.unscoped(),
           where: {
             [Op.and]: whereActorAnd
           },
-          include: [
-            {
-              model: ServerModel,
-              required: serverRequired,
-              where: whereServer
-            },
-            {
-              model: ActorImageModel,
-              as: 'Avatar',
-              required: false
-            },
-            {
-              model: ActorImageModel,
-              as: 'Banner',
-              required: false
-            }
-          ]
+          include: channelInclude
         },
         {
-          model: AccountModel,
+          model: AccountModel.unscoped(),
           required: true,
           include: [
             {
               attributes: {
                 exclude: unusedActorAttributesForAPI
               },
-              model: ActorModel, // Default scope includes avatar and server
-              required: true
+              model: ActorModel.unscoped(),
+              required: true,
+              include: accountInclude
             }
           ]
         }
@@ -189,7 +212,7 @@ export type SummaryOptions = {
   [ScopeNames.SUMMARY]: (options: SummaryOptions = {}) => {
     const include: Includeable[] = [
       {
-        attributes: [ 'id', 'preferredUsername', 'url', 'serverId', 'avatarId' ],
+        attributes: [ 'id', 'preferredUsername', 'url', 'serverId' ],
         model: ActorModel.unscoped(),
         required: options.actorRequired ?? true,
         include: [
@@ -199,8 +222,8 @@ export type SummaryOptions = {
             required: false
           },
           {
-            model: ActorImageModel.unscoped(),
-            as: 'Avatar',
+            model: ActorImageModel,
+            as: 'Avatars',
             required: false
           }
         ]
@@ -245,7 +268,7 @@ export type SummaryOptions = {
           {
             model: ActorImageModel,
             required: false,
-            as: 'Banner'
+            as: 'Banners'
           }
         ]
       }
@@ -474,14 +497,14 @@ ON              "Account->Actor"."serverId" = "Account->Actor->Server"."id"`
       order: getSort(parameters.sort)
     }
 
-    return VideoChannelModel
-      .scope({
-        method: [ ScopeNames.FOR_API, { actorId } as AvailableForListOptions ]
-      })
-      .findAndCountAll(query)
-      .then(({ rows, count }) => {
-        return { total: count, data: rows }
-      })
+    const getScope = (forCount: boolean) => {
+      return { method: [ ScopeNames.FOR_API, { actorId, forCount } as AvailableForListOptions ] }
+    }
+
+    return Promise.all([
+      VideoChannelModel.scope(getScope(true)).count(),
+      VideoChannelModel.scope(getScope(false)).findAll(query)
+    ]).then(([ total, data ]) => ({ total, data }))
   }
 
   static searchForApi (options: Pick<AvailableForListOptions, 'actorId' | 'search' | 'host' | 'handles'> & {
@@ -519,14 +542,22 @@ ON              "Account->Actor"."serverId" = "Account->Actor->Server"."id"`
       where
     }
 
-    return VideoChannelModel
-      .scope({
-        method: [ ScopeNames.FOR_API, pick(options, [ 'actorId', 'host', 'handles' ]) as AvailableForListOptions ]
-      })
-      .findAndCountAll(query)
-      .then(({ rows, count }) => {
-        return { total: count, data: rows }
-      })
+    const getScope = (forCount: boolean) => {
+      return {
+        method: [
+          ScopeNames.FOR_API, {
+            ...pick(options, [ 'actorId', 'host', 'handles' ]),
+
+            forCount
+          } as AvailableForListOptions
+        ]
+      }
+    }
+
+    return Promise.all([
+      VideoChannelModel.scope(getScope(true)).count(query),
+      VideoChannelModel.scope(getScope(false)).findAll(query)
+    ]).then(([ total, data ]) => ({ total, data }))
   }
 
   static listByAccountForAPI (options: {
@@ -552,20 +583,26 @@ ON              "Account->Actor"."serverId" = "Account->Actor->Server"."id"`
       }
       : null
 
-    const query = {
-      offset: options.start,
-      limit: options.count,
-      order: getSort(options.sort),
-      include: [
-        {
-          model: AccountModel,
-          where: {
-            id: options.accountId
-          },
-          required: true
-        }
-      ],
-      where
+    const getQuery = (forCount: boolean) => {
+      const accountModel = forCount
+        ? AccountModel.unscoped()
+        : AccountModel
+
+      return {
+        offset: options.start,
+        limit: options.count,
+        order: getSort(options.sort),
+        include: [
+          {
+            model: accountModel,
+            where: {
+              id: options.accountId
+            },
+            required: true
+          }
+        ],
+        where
+      }
     }
 
     const scopes: string | ScopeOptions | (string | ScopeOptions)[] = [ ScopeNames.WITH_ACTOR_BANNER ]
@@ -576,21 +613,19 @@ ON              "Account->Actor"."serverId" = "Account->Actor->Server"."id"`
       })
     }
 
-    return VideoChannelModel
-      .scope(scopes)
-      .findAndCountAll(query)
-      .then(({ rows, count }) => {
-        return { total: count, data: rows }
-      })
+    return Promise.all([
+      VideoChannelModel.scope(scopes).count(getQuery(true)),
+      VideoChannelModel.scope(scopes).findAll(getQuery(false))
+    ]).then(([ total, data ]) => ({ total, data }))
   }
 
-  static listAllByAccount (accountId: number) {
+  static listAllByAccount (accountId: number): Promise<MChannel[]> {
     const query = {
       limit: CONFIG.VIDEO_CHANNELS.MAX_PER_USER,
       include: [
         {
           attributes: [],
-          model: AccountModel,
+          model: AccountModel.unscoped(),
           where: {
             id: accountId
           },
@@ -621,7 +656,7 @@ ON              "Account->Actor"."serverId" = "Account->Actor->Server"."id"`
             {
               model: ActorImageModel,
               required: false,
-              as: 'Banner'
+              as: 'Banners'
             }
           ]
         }
@@ -655,7 +690,7 @@ ON              "Account->Actor"."serverId" = "Account->Actor->Server"."id"`
             {
               model: ActorImageModel,
               required: false,
-              as: 'Banner'
+              as: 'Banners'
             }
           ]
         }
@@ -685,7 +720,7 @@ ON              "Account->Actor"."serverId" = "Account->Actor->Server"."id"`
             {
               model: ActorImageModel,
               required: false,
-              as: 'Banner'
+              as: 'Banners'
             }
           ]
         }
@@ -706,6 +741,9 @@ ON              "Account->Actor"."serverId" = "Account->Actor->Server"."id"`
       displayName: this.getDisplayName(),
       url: actor.url,
       host: actor.host,
+      avatars: actor.avatars,
+
+      // TODO: remove, deprecated in 4.2
       avatar: actor.avatar
     }
   }
@@ -736,9 +774,16 @@ ON              "Account->Actor"."serverId" = "Account->Actor->Server"."id"`
       support: this.support,
       isLocal: this.Actor.isOwned(),
       updatedAt: this.updatedAt,
+
       ownerAccount: undefined,
+
       videosCount,
-      viewsPerDay
+      viewsPerDay,
+
+      avatars: actor.avatars,
+
+      // TODO: remove, deprecated in 4.2
+      avatar: actor.avatar
     }
 
     if (this.Account) videoChannel.ownerAccount = this.Account.toFormattedJSON()
diff --git a/server/models/video/video-comment.ts b/server/models/video/video-comment.ts
index fa77455bc..2d60c6a30 100644
--- a/server/models/video/video-comment.ts
+++ b/server/models/video/video-comment.ts
@@ -1,5 +1,5 @@
 import { uniq } from 'lodash'
-import { FindAndCountOptions, FindOptions, Op, Order, QueryTypes, ScopeOptions, Sequelize, Transaction, WhereOptions } from 'sequelize'
+import { FindOptions, Op, Order, QueryTypes, ScopeOptions, Sequelize, Transaction, WhereOptions } from 'sequelize'
 import {
   AllowNull,
   BelongsTo,
@@ -16,8 +16,8 @@ import {
 } from 'sequelize-typescript'
 import { getServerActor } from '@server/models/application/application'
 import { MAccount, MAccountId, MUserAccountId } from '@server/types/models'
-import { AttributesOnly } from '@shared/typescript-utils'
 import { VideoPrivacy } from '@shared/models'
+import { AttributesOnly } from '@shared/typescript-utils'
 import { ActivityTagObject, ActivityTombstoneObject } from '../../../shared/models/activitypub/objects/common-objects'
 import { VideoCommentObject } from '../../../shared/models/activitypub/objects/video-comment-object'
 import { VideoComment, VideoCommentAdmin } from '../../../shared/models/videos/comment/video-comment.model'
@@ -363,40 +363,43 @@ export class VideoCommentModel extends Model<Partial<AttributesOnly<VideoComment
       Object.assign(whereVideo, searchAttribute(searchVideo, 'name'))
     }
 
-    const query: FindAndCountOptions = {
-      offset: start,
-      limit: count,
-      order: getCommentSort(sort),
-      where,
-      include: [
-        {
-          model: AccountModel.unscoped(),
-          required: true,
-          where: whereAccount,
-          include: [
-            {
-              attributes: {
-                exclude: unusedActorAttributesForAPI
-              },
-              model: ActorModel, // Default scope includes avatar and server
-              required: true,
-              where: whereActor
-            }
-          ]
-        },
-        {
-          model: VideoModel.unscoped(),
-          required: true,
-          where: whereVideo
-        }
-      ]
+    const getQuery = (forCount: boolean) => {
+      return {
+        offset: start,
+        limit: count,
+        order: getCommentSort(sort),
+        where,
+        include: [
+          {
+            model: AccountModel.unscoped(),
+            required: true,
+            where: whereAccount,
+            include: [
+              {
+                attributes: {
+                  exclude: unusedActorAttributesForAPI
+                },
+                model: forCount === true
+                  ? ActorModel.unscoped() // Default scope includes avatar and server
+                  : ActorModel,
+                required: true,
+                where: whereActor
+              }
+            ]
+          },
+          {
+            model: VideoModel.unscoped(),
+            required: true,
+            where: whereVideo
+          }
+        ]
+      }
     }
 
-    return VideoCommentModel
-      .findAndCountAll(query)
-      .then(({ rows, count }) => {
-        return { total: count, data: rows }
-      })
+    return Promise.all([
+      VideoCommentModel.count(getQuery(true)),
+      VideoCommentModel.findAll(getQuery(false))
+    ]).then(([ total, data ]) => ({ total, data }))
   }
 
   static async listThreadsForApi (parameters: {
@@ -443,14 +446,20 @@ export class VideoCommentModel extends Model<Partial<AttributesOnly<VideoComment
       }
     }
 
-    const scopesList: (string | ScopeOptions)[] = [
+    const findScopesList: (string | ScopeOptions)[] = [
       ScopeNames.WITH_ACCOUNT_FOR_API,
       {
         method: [ ScopeNames.ATTRIBUTES_FOR_API, blockerAccountIds ]
       }
     ]
 
-    const queryCount = {
+    const countScopesList: ScopeOptions[] = [
+      {
+        method: [ ScopeNames.ATTRIBUTES_FOR_API, blockerAccountIds ]
+      }
+    ]
+
+    const notDeletedQueryCount = {
       where: {
         videoId,
         deletedAt: null,
@@ -459,9 +468,10 @@ export class VideoCommentModel extends Model<Partial<AttributesOnly<VideoComment
     }
 
     return Promise.all([
-      VideoCommentModel.scope(scopesList).findAndCountAll(queryList),
-      VideoCommentModel.count(queryCount)
-    ]).then(([ { rows, count }, totalNotDeletedComments ]) => {
+      VideoCommentModel.scope(findScopesList).findAll(queryList),
+      VideoCommentModel.scope(countScopesList).count(queryList),
+      VideoCommentModel.count(notDeletedQueryCount)
+    ]).then(([ rows, count, totalNotDeletedComments ]) => {
       return { total: count, data: rows, totalNotDeletedComments }
     })
   }
@@ -512,11 +522,10 @@ export class VideoCommentModel extends Model<Partial<AttributesOnly<VideoComment
       }
     ]
 
-    return VideoCommentModel.scope(scopes)
-      .findAndCountAll(query)
-      .then(({ rows, count }) => {
-        return { total: count, data: rows }
-      })
+    return Promise.all([
+      VideoCommentModel.count(query),
+      VideoCommentModel.scope(scopes).findAll(query)
+    ]).then(([ total, data ]) => ({ total, data }))
   }
 
   static listThreadParentComments (comment: MCommentId, t: Transaction, order: 'ASC' | 'DESC' = 'ASC'): Promise<MCommentOwner[]> {
@@ -565,7 +574,10 @@ export class VideoCommentModel extends Model<Partial<AttributesOnly<VideoComment
       transaction: t
     }
 
-    return VideoCommentModel.findAndCountAll<MComment>(query)
+    return Promise.all([
+      VideoCommentModel.count(query),
+      VideoCommentModel.findAll<MComment>(query)
+    ]).then(([ total, data ]) => ({ total, data }))
   }
 
   static async listForFeed (parameters: {
diff --git a/server/models/video/video-import.ts b/server/models/video/video-import.ts
index 5d2b230e8..1d8296060 100644
--- a/server/models/video/video-import.ts
+++ b/server/models/video/video-import.ts
@@ -155,13 +155,10 @@ export class VideoImportModel extends Model<Partial<AttributesOnly<VideoImportMo
       where
     }
 
-    return VideoImportModel.findAndCountAll<MVideoImportDefault>(query)
-                           .then(({ rows, count }) => {
-                             return {
-                               data: rows,
-                               total: count
-                             }
-                           })
+    return Promise.all([
+      VideoImportModel.unscoped().count(query),
+      VideoImportModel.findAll<MVideoImportDefault>(query)
+    ]).then(([ total, data ]) => ({ total, data }))
   }
 
   getTargetIdentifier () {
diff --git a/server/models/video/video-playlist-element.ts b/server/models/video/video-playlist-element.ts
index e20e32f8b..4e4160818 100644
--- a/server/models/video/video-playlist-element.ts
+++ b/server/models/video/video-playlist-element.ts
@@ -23,6 +23,7 @@ import {
   MVideoPlaylistElementVideoUrlPlaylistPrivacy,
   MVideoPlaylistVideoThumbnail
 } from '@server/types/models/video/video-playlist-element'
+import { AttributesOnly } from '@shared/typescript-utils'
 import { PlaylistElementObject } from '../../../shared/models/activitypub/objects/playlist-element-object'
 import { VideoPrivacy } from '../../../shared/models/videos'
 import { VideoPlaylistElement, VideoPlaylistElementType } from '../../../shared/models/videos/playlist/video-playlist-element.model'
@@ -32,7 +33,6 @@ import { AccountModel } from '../account/account'
 import { getSort, throwIfNotValid } from '../utils'
 import { ForAPIOptions, ScopeNames as VideoScopeNames, VideoModel } from './video'
 import { VideoPlaylistModel } from './video-playlist'
-import { AttributesOnly } from '@shared/typescript-utils'
 
 @Table({
   tableName: 'videoPlaylistElement',
@@ -208,22 +208,28 @@ export class VideoPlaylistElementModel extends Model<Partial<AttributesOnly<Vide
   }
 
   static listUrlsOfForAP (videoPlaylistId: number, start: number, count: number, t?: Transaction) {
-    const query = {
-      attributes: [ 'url' ],
-      offset: start,
-      limit: count,
-      order: getSort('position'),
-      where: {
-        videoPlaylistId
-      },
-      transaction: t
+    const getQuery = (forCount: boolean) => {
+      return {
+        attributes: forCount
+          ? []
+          : [ 'url' ],
+        offset: start,
+        limit: count,
+        order: getSort('position'),
+        where: {
+          videoPlaylistId
+        },
+        transaction: t
+      }
     }
 
-    return VideoPlaylistElementModel
-      .findAndCountAll(query)
-      .then(({ rows, count }) => {
-        return { total: count, data: rows.map(e => e.url) }
-      })
+    return Promise.all([
+      VideoPlaylistElementModel.count(getQuery(true)),
+      VideoPlaylistElementModel.findAll(getQuery(false))
+    ]).then(([ total, rows ]) => ({
+      total,
+      data: rows.map(e => e.url)
+    }))
   }
 
   static loadFirstElementWithVideoThumbnail (videoPlaylistId: number): Promise<MVideoPlaylistVideoThumbnail> {
diff --git a/server/models/video/video-playlist.ts b/server/models/video/video-playlist.ts
index c125db3ff..ae5e237ec 100644
--- a/server/models/video/video-playlist.ts
+++ b/server/models/video/video-playlist.ts
@@ -1,5 +1,5 @@
 import { join } from 'path'
-import { FindOptions, literal, Op, ScopeOptions, Sequelize, Transaction, WhereOptions } from 'sequelize'
+import { FindOptions, Includeable, literal, Op, ScopeOptions, Sequelize, Transaction, WhereOptions } from 'sequelize'
 import {
   AllowNull,
   BelongsTo,
@@ -86,6 +86,7 @@ type AvailableForListOptions = {
   host?: string
   uuids?: string[]
   withVideos?: boolean
+  forCount?: boolean
 }
 
 function getVideoLengthSelect () {
@@ -239,23 +240,28 @@ function getVideoLengthSelect () {
       [Op.and]: whereAnd
     }
 
+    const include: Includeable[] = [
+      {
+        model: AccountModel.scope({
+          method: [ AccountScopeNames.SUMMARY, { whereActor, whereServer, forCount: options.forCount } as SummaryOptions ]
+        }),
+        required: true
+      }
+    ]
+
+    if (options.forCount !== true) {
+      include.push({
+        model: VideoChannelModel.scope(VideoChannelScopeNames.SUMMARY),
+        required: false
+      })
+    }
+
     return {
       attributes: {
         include: attributesInclude
       },
       where,
-      include: [
-        {
-          model: AccountModel.scope({
-            method: [ AccountScopeNames.SUMMARY, { whereActor, whereServer } as SummaryOptions ]
-          }),
-          required: true
-        },
-        {
-          model: VideoChannelModel.scope(VideoChannelScopeNames.SUMMARY),
-          required: false
-        }
-      ]
+      include
     } as FindOptions
   }
 }))
@@ -369,12 +375,23 @@ export class VideoPlaylistModel extends Model<Partial<AttributesOnly<VideoPlayli
       order: getPlaylistSort(options.sort)
     }
 
-    const scopes: (string | ScopeOptions)[] = [
+    const commonAvailableForListOptions = pick(options, [
+      'type',
+      'followerActorId',
+      'accountId',
+      'videoChannelId',
+      'listMyPlaylists',
+      'search',
+      'host',
+      'uuids'
+    ])
+
+    const scopesFind: (string | ScopeOptions)[] = [
       {
         method: [
           ScopeNames.AVAILABLE_FOR_LIST,
           {
-            ...pick(options, [ 'type', 'followerActorId', 'accountId', 'videoChannelId', 'listMyPlaylists', 'search', 'host', 'uuids' ]),
+            ...commonAvailableForListOptions,
 
             withVideos: options.withVideos || false
           } as AvailableForListOptions
@@ -384,12 +401,26 @@ export class VideoPlaylistModel extends Model<Partial<AttributesOnly<VideoPlayli
       ScopeNames.WITH_THUMBNAIL
     ]
 
-    return VideoPlaylistModel
-      .scope(scopes)
-      .findAndCountAll(query)
-      .then(({ rows, count }) => {
-        return { total: count, data: rows }
-      })
+    const scopesCount: (string | ScopeOptions)[] = [
+      {
+        method: [
+          ScopeNames.AVAILABLE_FOR_LIST,
+
+          {
+            ...commonAvailableForListOptions,
+
+            withVideos: options.withVideos || false,
+            forCount: true
+          } as AvailableForListOptions
+        ]
+      },
+      ScopeNames.WITH_VIDEOS_LENGTH
+    ]
+
+    return Promise.all([
+      VideoPlaylistModel.scope(scopesCount).count(),
+      VideoPlaylistModel.scope(scopesFind).findAll(query)
+    ]).then(([ count, rows ]) => ({ total: count, data: rows }))
   }
 
   static searchForApi (options: Pick<AvailableForListOptions, 'followerActorId' | 'search'| 'host'| 'uuids'> & {
@@ -419,17 +450,24 @@ export class VideoPlaylistModel extends Model<Partial<AttributesOnly<VideoPlayli
       Object.assign(where, { videoChannelId: options.channel.id })
     }
 
-    const query = {
-      attributes: [ 'url' ],
-      offset: start,
-      limit: count,
-      where
+    const getQuery = (forCount: boolean) => {
+      return {
+        attributes: forCount === true
+          ? []
+          : [ 'url' ],
+        offset: start,
+        limit: count,
+        where
+      }
     }
 
-    return VideoPlaylistModel.findAndCountAll(query)
-                             .then(({ rows, count }) => {
-                               return { total: count, data: rows.map(p => p.url) }
-                             })
+    return Promise.all([
+      VideoPlaylistModel.count(getQuery(true)),
+      VideoPlaylistModel.findAll(getQuery(false))
+    ]).then(([ total, rows ]) => ({
+      total,
+      data: rows.map(p => p.url)
+    }))
   }
 
   static listPlaylistIdsOf (accountId: number, videoIds: number[]): Promise<MVideoPlaylistIdWithElements[]> {
diff --git a/server/models/video/video-share.ts b/server/models/video/video-share.ts
index f6659b992..ad95dec6e 100644
--- a/server/models/video/video-share.ts
+++ b/server/models/video/video-share.ts
@@ -183,7 +183,10 @@ export class VideoShareModel extends Model<Partial<AttributesOnly<VideoShareMode
       transaction: t
     }
 
-    return VideoShareModel.findAndCountAll(query)
+    return Promise.all([
+      VideoShareModel.count(query),
+      VideoShareModel.findAll(query)
+    ]).then(([ total, data ]) => ({ total, data }))
   }
 
   static listRemoteShareUrlsOfLocalVideos () {
diff --git a/server/models/video/video.ts b/server/models/video/video.ts
index 9111c71b0..a4093ce3b 100644
--- a/server/models/video/video.ts
+++ b/server/models/video/video.ts
@@ -61,7 +61,7 @@ import {
   isVideoStateValid,
   isVideoSupportValid
 } from '../../helpers/custom-validators/videos'
-import { getVideoFileResolution } from '../../helpers/ffprobe-utils'
+import { getVideoStreamDimensionsInfo } from '../../helpers/ffmpeg'
 import { logger } from '../../helpers/logger'
 import { CONFIG } from '../../initializers/config'
 import { ACTIVITY_PUB, API_VERSION, CONSTRAINTS_FIELDS, LAZY_STATIC_PATHS, STATIC_PATHS, WEBSERVER } from '../../initializers/constants'
@@ -114,9 +114,13 @@ import {
   videoModelToFormattedJSON
 } from './formatter/video-format-utils'
 import { ScheduleVideoUpdateModel } from './schedule-video-update'
-import { VideoModelGetQueryBuilder } from './sql/video-model-get-query-builder'
-import { BuildVideosListQueryOptions, DisplayOnlyForFollowerOptions, VideosIdListQueryBuilder } from './sql/videos-id-list-query-builder'
-import { VideosModelListQueryBuilder } from './sql/videos-model-list-query-builder'
+import {
+  BuildVideosListQueryOptions,
+  DisplayOnlyForFollowerOptions,
+  VideoModelGetQueryBuilder,
+  VideosIdListQueryBuilder,
+  VideosModelListQueryBuilder
+} from './sql/video'
 import { TagModel } from './tag'
 import { ThumbnailModel } from './thumbnail'
 import { VideoBlacklistModel } from './video-blacklist'
@@ -229,8 +233,8 @@ export type ForAPIOptions = {
                 required: false
               },
               {
-                model: ActorImageModel.unscoped(),
-                as: 'Avatar',
+                model: ActorImageModel,
+                as: 'Avatars',
                 required: false
               }
             ]
@@ -252,8 +256,8 @@ export type ForAPIOptions = {
                     required: false
                   },
                   {
-                    model: ActorImageModel.unscoped(),
-                    as: 'Avatar',
+                    model: ActorImageModel,
+                    as: 'Avatars',
                     required: false
                   }
                 ]
@@ -1679,7 +1683,7 @@ export class VideoModel extends Model<Partial<AttributesOnly<VideoModel>>> {
     return peertubeTruncate(this.description, { length: maxLength })
   }
 
-  getMaxQualityFileInfo () {
+  probeMaxQualityFile () {
     const file = this.getMaxQualityFile()
     const videoOrPlaylist = file.getVideoOrStreamingPlaylist()
 
@@ -1691,7 +1695,7 @@ export class VideoModel extends Model<Partial<AttributesOnly<VideoModel>>> {
       return {
         audioStream,
 
-        ...await getVideoFileResolution(originalFilePath, probe)
+        ...await getVideoStreamDimensionsInfo(originalFilePath, probe)
       }
     })
   }
diff --git a/server/tests/api/activitypub/refresher.ts b/server/tests/api/activitypub/refresher.ts
index 71e1c40ba..bb81d4565 100644
--- a/server/tests/api/activitypub/refresher.ts
+++ b/server/tests/api/activitypub/refresher.ts
@@ -25,12 +25,16 @@ describe('Test AP refresher', function () {
   before(async function () {
     this.timeout(60000)
 
-    servers = await createMultipleServers(2, { transcoding: { enabled: false } })
+    servers = await createMultipleServers(2)
 
     // Get the access tokens
     await setAccessTokensToServers(servers)
     await setDefaultVideoChannel(servers)
 
+    for (const server of servers) {
+      await server.config.disableTranscoding()
+    }
+
     {
       videoUUID1 = (await servers[1].videos.quickUpload({ name: 'video1' })).uuid
       videoUUID2 = (await servers[1].videos.quickUpload({ name: 'video2' })).uuid
diff --git a/server/tests/api/check-params/config.ts b/server/tests/api/check-params/config.ts
index 3cccb612a..ce067a892 100644
--- a/server/tests/api/check-params/config.ts
+++ b/server/tests/api/check-params/config.ts
@@ -145,6 +145,9 @@ describe('Test config API validators', function () {
         }
       }
     },
+    videoEditor: {
+      enabled: true
+    },
     import: {
       videos: {
         concurrency: 1,
diff --git a/server/tests/api/check-params/index.ts b/server/tests/api/check-params/index.ts
index e052296db..c088b52cd 100644
--- a/server/tests/api/check-params/index.ts
+++ b/server/tests/api/check-params/index.ts
@@ -25,6 +25,7 @@ import './video-blacklist'
 import './video-captions'
 import './video-channels'
 import './video-comments'
+import './video-editor'
 import './video-imports'
 import './video-playlists'
 import './videos'
diff --git a/server/tests/api/check-params/video-channels.ts b/server/tests/api/check-params/video-channels.ts
index 1e9732fe9..5c2650fac 100644
--- a/server/tests/api/check-params/video-channels.ts
+++ b/server/tests/api/check-params/video-channels.ts
@@ -228,7 +228,7 @@ describe('Test video channels API validator', function () {
     })
   })
 
-  describe('When updating video channel avatar/banner', function () {
+  describe('When updating video channel avatars/banners', function () {
     const types = [ 'avatar', 'banner' ]
     let path: string
 
diff --git a/server/tests/api/check-params/video-editor.ts b/server/tests/api/check-params/video-editor.ts
new file mode 100644
index 000000000..db284a3cc
--- /dev/null
+++ b/server/tests/api/check-params/video-editor.ts
@@ -0,0 +1,385 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
+
+import 'mocha'
+import { HttpStatusCode, VideoEditorTask } from '@shared/models'
+import {
+  cleanupTests,
+  createSingleServer,
+  PeerTubeServer,
+  setAccessTokensToServers,
+  VideoEditorCommand,
+  waitJobs
+} from '@shared/server-commands'
+
+describe('Test video editor API validator', function () {
+  let server: PeerTubeServer
+  let command: VideoEditorCommand
+  let userAccessToken: string
+  let videoUUID: string
+
+  // ---------------------------------------------------------------
+
+  before(async function () {
+    this.timeout(120_000)
+
+    server = await createSingleServer(1)
+
+    await setAccessTokensToServers([ server ])
+    userAccessToken = await server.users.generateUserAndToken('user1')
+
+    await server.config.enableMinimumTranscoding()
+
+    const { uuid } = await server.videos.quickUpload({ name: 'video' })
+    videoUUID = uuid
+
+    command = server.videoEditor
+
+    await waitJobs([ server ])
+  })
+
+  describe('Task creation', function () {
+
+    describe('Config settings', function () {
+
+      it('Should fail if editor is disabled', async function () {
+        await server.config.updateExistingSubConfig({
+          newConfig: {
+            videoEditor: {
+              enabled: false
+            }
+          }
+        })
+
+        await command.createEditionTasks({
+          videoId: videoUUID,
+          tasks: VideoEditorCommand.getComplexTask(),
+          expectedStatus: HttpStatusCode.BAD_REQUEST_400
+        })
+      })
+
+      it('Should fail to enable editor if transcoding is disabled', async function () {
+        await server.config.updateExistingSubConfig({
+          newConfig: {
+            videoEditor: {
+              enabled: true
+            },
+            transcoding: {
+              enabled: false
+            }
+          },
+          expectedStatus: HttpStatusCode.BAD_REQUEST_400
+        })
+      })
+
+      it('Should succeed to enable video editor', async function () {
+        await server.config.updateExistingSubConfig({
+          newConfig: {
+            videoEditor: {
+              enabled: true
+            },
+            transcoding: {
+              enabled: true
+            }
+          }
+        })
+      })
+    })
+
+    describe('Common tasks', function () {
+
+      it('Should fail without token', async function () {
+        await command.createEditionTasks({
+          token: null,
+          videoId: videoUUID,
+          tasks: VideoEditorCommand.getComplexTask(),
+          expectedStatus: HttpStatusCode.UNAUTHORIZED_401
+        })
+      })
+
+      it('Should fail with another user token', async function () {
+        await command.createEditionTasks({
+          token: userAccessToken,
+          videoId: videoUUID,
+          tasks: VideoEditorCommand.getComplexTask(),
+          expectedStatus: HttpStatusCode.FORBIDDEN_403
+        })
+      })
+
+      it('Should fail with an invalid video', async function () {
+        await command.createEditionTasks({
+          videoId: 'tintin',
+          tasks: VideoEditorCommand.getComplexTask(),
+          expectedStatus: HttpStatusCode.BAD_REQUEST_400
+        })
+      })
+
+      it('Should fail with an unknown video', async function () {
+        await command.createEditionTasks({
+          videoId: 42,
+          tasks: VideoEditorCommand.getComplexTask(),
+          expectedStatus: HttpStatusCode.NOT_FOUND_404
+        })
+      })
+
+      it('Should fail with an already in transcoding state video', async function () {
+        await server.jobs.pauseJobQueue()
+
+        const { uuid } = await server.videos.quickUpload({ name: 'transcoded video' })
+
+        await command.createEditionTasks({
+          videoId: uuid,
+          tasks: VideoEditorCommand.getComplexTask(),
+          expectedStatus: HttpStatusCode.CONFLICT_409
+        })
+
+        await server.jobs.resumeJobQueue()
+      })
+
+      it('Should fail with a bad complex task', async function () {
+        await command.createEditionTasks({
+          videoId: videoUUID,
+          tasks: [
+            {
+              name: 'cut',
+              options: {
+                start: 1,
+                end: 2
+              }
+            },
+            {
+              name: 'hadock',
+              options: {
+                start: 1,
+                end: 2
+              }
+            }
+          ] as any,
+          expectedStatus: HttpStatusCode.BAD_REQUEST_400
+        })
+      })
+
+      it('Should fail without task', async function () {
+        await command.createEditionTasks({
+          videoId: videoUUID,
+          tasks: [],
+          expectedStatus: HttpStatusCode.BAD_REQUEST_400
+        })
+      })
+
+      it('Should fail with too many tasks', async function () {
+        const tasks: VideoEditorTask[] = []
+
+        for (let i = 0; i < 110; i++) {
+          tasks.push({
+            name: 'cut',
+            options: {
+              start: 1
+            }
+          })
+        }
+
+        await command.createEditionTasks({
+          videoId: videoUUID,
+          tasks,
+          expectedStatus: HttpStatusCode.BAD_REQUEST_400
+        })
+      })
+
+      it('Should succeed with correct parameters', async function () {
+        await server.jobs.pauseJobQueue()
+
+        await command.createEditionTasks({
+          videoId: videoUUID,
+          tasks: VideoEditorCommand.getComplexTask(),
+          expectedStatus: HttpStatusCode.NO_CONTENT_204
+        })
+      })
+
+      it('Should fail with a video that is already waiting for edition', async function () {
+        this.timeout(120000)
+
+        await command.createEditionTasks({
+          videoId: videoUUID,
+          tasks: VideoEditorCommand.getComplexTask(),
+          expectedStatus: HttpStatusCode.CONFLICT_409
+        })
+
+        await server.jobs.resumeJobQueue()
+
+        await waitJobs([ server ])
+      })
+    })
+
+    describe('Cut task', function () {
+
+      async function cut (start: number, end: number, expectedStatus = HttpStatusCode.BAD_REQUEST_400) {
+        await command.createEditionTasks({
+          videoId: videoUUID,
+          tasks: [
+            {
+              name: 'cut',
+              options: {
+                start,
+                end
+              }
+            }
+          ],
+          expectedStatus
+        })
+      }
+
+      it('Should fail with bad start/end', async function () {
+        const invalid = [
+          'tintin',
+          -1,
+          undefined
+        ]
+
+        for (const value of invalid) {
+          await cut(value as any, undefined)
+          await cut(undefined, value as any)
+        }
+      })
+
+      it('Should fail with the same start/end', async function () {
+        await cut(2, 2)
+      })
+
+      it('Should fail with inconsistents start/end', async function () {
+        await cut(2, 1)
+      })
+
+      it('Should fail without start and end', async function () {
+        await cut(undefined, undefined)
+      })
+
+      it('Should succeed with the correct params', async function () {
+        this.timeout(120000)
+
+        await cut(0, 2, HttpStatusCode.NO_CONTENT_204)
+
+        await waitJobs([ server ])
+      })
+    })
+
+    describe('Watermark task', function () {
+
+      async function addWatermark (file: string, expectedStatus = HttpStatusCode.BAD_REQUEST_400) {
+        await command.createEditionTasks({
+          videoId: videoUUID,
+          tasks: [
+            {
+              name: 'add-watermark',
+              options: {
+                file
+              }
+            }
+          ],
+          expectedStatus
+        })
+      }
+
+      it('Should fail without waterkmark', async function () {
+        await addWatermark(undefined)
+      })
+
+      it('Should fail with an invalid watermark', async function () {
+        await addWatermark('video_short.mp4')
+      })
+
+      it('Should succeed with the correct params', async function () {
+        this.timeout(120000)
+
+        await addWatermark('thumbnail.jpg', HttpStatusCode.NO_CONTENT_204)
+
+        await waitJobs([ server ])
+      })
+    })
+
+    describe('Intro/Outro task', function () {
+
+      async function addIntroOutro (type: 'add-intro' | 'add-outro', file: string, expectedStatus = HttpStatusCode.BAD_REQUEST_400) {
+        await command.createEditionTasks({
+          videoId: videoUUID,
+          tasks: [
+            {
+              name: type,
+              options: {
+                file
+              }
+            }
+          ],
+          expectedStatus
+        })
+      }
+
+      it('Should fail without file', async function () {
+        await addIntroOutro('add-intro', undefined)
+        await addIntroOutro('add-outro', undefined)
+      })
+
+      it('Should fail with an invalid file', async function () {
+        await addIntroOutro('add-intro', 'thumbnail.jpg')
+        await addIntroOutro('add-outro', 'thumbnail.jpg')
+      })
+
+      it('Should fail with a file that does not contain video stream', async function () {
+        await addIntroOutro('add-intro', 'sample.ogg')
+        await addIntroOutro('add-outro', 'sample.ogg')
+
+      })
+
+      it('Should succeed with the correct params', async function () {
+        this.timeout(120000)
+
+        await addIntroOutro('add-intro', 'video_very_short_240p.mp4', HttpStatusCode.NO_CONTENT_204)
+        await waitJobs([ server ])
+
+        await addIntroOutro('add-outro', 'video_very_short_240p.mp4', HttpStatusCode.NO_CONTENT_204)
+        await waitJobs([ server ])
+      })
+
+      it('Should check total quota when creating the task', async function () {
+        this.timeout(120000)
+
+        const user = await server.users.create({ username: 'user_quota_1' })
+        const token = await server.login.getAccessToken('user_quota_1')
+        const { uuid } = await server.videos.quickUpload({ token, name: 'video_quota_1', fixture: 'video_short.mp4' })
+
+        const addIntroOutroByUser = (type: 'add-intro' | 'add-outro', expectedStatus: HttpStatusCode) => {
+          return command.createEditionTasks({
+            token,
+            videoId: uuid,
+            tasks: [
+              {
+                name: type,
+                options: {
+                  file: 'video_short.mp4'
+                }
+              }
+            ],
+            expectedStatus
+          })
+        }
+
+        await waitJobs([ server ])
+
+        const { videoQuotaUsed } = await server.users.getMyQuotaUsed({ token })
+        await server.users.update({ userId: user.id, videoQuota: Math.round(videoQuotaUsed * 2.5) })
+
+        // Still valid
+        await addIntroOutroByUser('add-intro', HttpStatusCode.NO_CONTENT_204)
+
+        await waitJobs([ server ])
+
+        // Too much quota
+        await addIntroOutroByUser('add-intro', HttpStatusCode.PAYLOAD_TOO_LARGE_413)
+        await addIntroOutroByUser('add-outro', HttpStatusCode.PAYLOAD_TOO_LARGE_413)
+      })
+    })
+  })
+
+  after(async function () {
+    await cleanupTests([ server ])
+  })
+})
diff --git a/server/tests/api/index.ts b/server/tests/api/index.ts
index 19301c0b9..61352a134 100644
--- a/server/tests/api/index.ts
+++ b/server/tests/api/index.ts
@@ -7,5 +7,6 @@ import './notifications'
 import './redundancy'
 import './search'
 import './server'
+import './transcoding'
 import './users'
 import './videos'
diff --git a/server/tests/api/live/live.ts b/server/tests/api/live/live.ts
index 3f9355d2d..d756a02c1 100644
--- a/server/tests/api/live/live.ts
+++ b/server/tests/api/live/live.ts
@@ -3,7 +3,7 @@
 import 'mocha'
 import * as chai from 'chai'
 import { basename, join } from 'path'
-import { ffprobePromise, getVideoStreamFromFile } from '@server/helpers/ffprobe-utils'
+import { ffprobePromise, getVideoStream } from '@server/helpers/ffmpeg'
 import { checkLiveCleanupAfterSave, checkLiveSegmentHash, checkResolutionsInMasterPlaylist, testImage } from '@server/tests/shared'
 import { wait } from '@shared/core-utils'
 import {
@@ -562,7 +562,7 @@ describe('Test live', function () {
           const segmentPath = servers[0].servers.buildDirectory(join('streaming-playlists', 'hls', video.uuid, filename))
 
           const probe = await ffprobePromise(segmentPath)
-          const videoStream = await getVideoStreamFromFile(segmentPath, probe)
+          const videoStream = await getVideoStream(segmentPath, probe)
 
           expect(probe.format.bit_rate).to.be.below(maxBitrateLimits[videoStream.height])
           expect(probe.format.bit_rate).to.be.at.least(minBitrateLimits[videoStream.height])
diff --git a/server/tests/api/moderation/abuses.ts b/server/tests/api/moderation/abuses.ts
index 0c3bed3e7..7bf49c7ec 100644
--- a/server/tests/api/moderation/abuses.ts
+++ b/server/tests/api/moderation/abuses.ts
@@ -2,6 +2,7 @@
 
 import 'mocha'
 import * as chai from 'chai'
+import { AbuseMessage, AbusePredefinedReasonsString, AbuseState, AdminAbuse, UserAbuse } from '@shared/models'
 import {
   AbusesCommand,
   cleanupTests,
@@ -9,9 +10,10 @@ import {
   doubleFollow,
   PeerTubeServer,
   setAccessTokensToServers,
+  setDefaultAccountAvatar,
+  setDefaultChannelAvatar,
   waitJobs
 } from '@shared/server-commands'
-import { AbuseMessage, AbusePredefinedReasonsString, AbuseState, AdminAbuse, UserAbuse } from '@shared/models'
 
 const expect = chai.expect
 
@@ -27,8 +29,9 @@ describe('Test abuses', function () {
     // Run servers
     servers = await createMultipleServers(2)
 
-    // Get the access tokens
     await setAccessTokensToServers(servers)
+    await setDefaultChannelAvatar(servers)
+    await setDefaultAccountAvatar(servers)
 
     // Server 1 and server 2 follow each other
     await doubleFollow(servers[0], servers[1])
diff --git a/server/tests/api/moderation/blocklist.ts b/server/tests/api/moderation/blocklist.ts
index b45460bb4..e1344a245 100644
--- a/server/tests/api/moderation/blocklist.ts
+++ b/server/tests/api/moderation/blocklist.ts
@@ -2,6 +2,7 @@
 
 import 'mocha'
 import * as chai from 'chai'
+import { UserNotificationType } from '@shared/models'
 import {
   BlocklistCommand,
   cleanupTests,
@@ -10,9 +11,9 @@ import {
   doubleFollow,
   PeerTubeServer,
   setAccessTokensToServers,
+  setDefaultAccountAvatar,
   waitJobs
 } from '@shared/server-commands'
-import { UserNotificationType } from '@shared/models'
 
 const expect = chai.expect
 
@@ -79,6 +80,7 @@ describe('Test blocklist', function () {
 
     servers = await createMultipleServers(3)
     await setAccessTokensToServers(servers)
+    await setDefaultAccountAvatar(servers)
 
     command = servers[0].blocklist
     commentsCommand = servers.map(s => s.comments)
diff --git a/server/tests/api/moderation/video-blacklist.ts b/server/tests/api/moderation/video-blacklist.ts
index 3e7f2ba33..1790210ff 100644
--- a/server/tests/api/moderation/video-blacklist.ts
+++ b/server/tests/api/moderation/video-blacklist.ts
@@ -13,6 +13,7 @@ import {
   killallServers,
   PeerTubeServer,
   setAccessTokensToServers,
+  setDefaultChannelAvatar,
   waitJobs
 } from '@shared/server-commands'
 
@@ -42,6 +43,7 @@ describe('Test video blacklist', function () {
 
     // Server 1 and server 2 follow each other
     await doubleFollow(servers[0], servers[1])
+    await setDefaultChannelAvatar(servers[0])
 
     // Upload 2 videos on server 2
     await servers[1].videos.upload({ attributes: { name: 'My 1st video', description: 'A video on server 2' } })
diff --git a/server/tests/api/notifications/notifications-api.ts b/server/tests/api/notifications/notifications-api.ts
index ac08449f8..78864c8a0 100644
--- a/server/tests/api/notifications/notifications-api.ts
+++ b/server/tests/api/notifications/notifications-api.ts
@@ -38,6 +38,16 @@ describe('Test notifications API', function () {
     await waitJobs([ server ])
   })
 
+  describe('Notification list & count', function () {
+
+    it('Should correctly list notifications', async function () {
+      const { data, total } = await server.notifications.list({ token: userToken, start: 0, count: 2 })
+
+      expect(data).to.have.lengthOf(2)
+      expect(total).to.equal(10)
+    })
+  })
+
   describe('Mark as read', function () {
 
     it('Should mark as read some notifications', async function () {
diff --git a/server/tests/api/search/search-activitypub-video-channels.ts b/server/tests/api/search/search-activitypub-video-channels.ts
index 2e0abc6ba..5f5322d03 100644
--- a/server/tests/api/search/search-activitypub-video-channels.ts
+++ b/server/tests/api/search/search-activitypub-video-channels.ts
@@ -10,6 +10,8 @@ import {
   PeerTubeServer,
   SearchCommand,
   setAccessTokensToServers,
+  setDefaultAccountAvatar,
+  setDefaultVideoChannel,
   waitJobs
 } from '@shared/server-commands'
 
@@ -28,6 +30,8 @@ describe('Test ActivityPub video channels search', function () {
     servers = await createMultipleServers(2)
 
     await setAccessTokensToServers(servers)
+    await setDefaultVideoChannel(servers)
+    await setDefaultAccountAvatar(servers)
 
     {
       await servers[0].users.create({ username: 'user1_server1', password: 'password' })
diff --git a/server/tests/api/search/search-activitypub-video-playlists.ts b/server/tests/api/search/search-activitypub-video-playlists.ts
index d9243ac53..b9a424292 100644
--- a/server/tests/api/search/search-activitypub-video-playlists.ts
+++ b/server/tests/api/search/search-activitypub-video-playlists.ts
@@ -10,6 +10,7 @@ import {
   PeerTubeServer,
   SearchCommand,
   setAccessTokensToServers,
+  setDefaultAccountAvatar,
   setDefaultVideoChannel,
   waitJobs
 } from '@shared/server-commands'
@@ -31,6 +32,7 @@ describe('Test ActivityPub playlists search', function () {
 
     await setAccessTokensToServers(servers)
     await setDefaultVideoChannel(servers)
+    await setDefaultAccountAvatar(servers)
 
     {
       const video1 = (await servers[0].videos.quickUpload({ name: 'video 1' })).uuid
diff --git a/server/tests/api/search/search-activitypub-videos.ts b/server/tests/api/search/search-activitypub-videos.ts
index 60b95ae4c..20249b1f1 100644
--- a/server/tests/api/search/search-activitypub-videos.ts
+++ b/server/tests/api/search/search-activitypub-videos.ts
@@ -10,6 +10,8 @@ import {
   PeerTubeServer,
   SearchCommand,
   setAccessTokensToServers,
+  setDefaultAccountAvatar,
+  setDefaultVideoChannel,
   waitJobs
 } from '@shared/server-commands'
 
@@ -28,6 +30,8 @@ describe('Test ActivityPub videos search', function () {
     servers = await createMultipleServers(2)
 
     await setAccessTokensToServers(servers)
+    await setDefaultVideoChannel(servers)
+    await setDefaultAccountAvatar(servers)
 
     {
       const { uuid } = await servers[0].videos.upload({ attributes: { name: 'video 1 on server 1' } })
diff --git a/server/tests/api/search/search-channels.ts b/server/tests/api/search/search-channels.ts
index 8a92def61..cd4c053d2 100644
--- a/server/tests/api/search/search-channels.ts
+++ b/server/tests/api/search/search-channels.ts
@@ -2,15 +2,17 @@
 
 import 'mocha'
 import * as chai from 'chai'
+import { VideoChannel } from '@shared/models'
 import {
   cleanupTests,
   createSingleServer,
   doubleFollow,
   PeerTubeServer,
   SearchCommand,
-  setAccessTokensToServers
+  setAccessTokensToServers,
+  setDefaultAccountAvatar,
+  setDefaultChannelAvatar
 } from '@shared/server-commands'
-import { VideoChannel } from '@shared/models'
 
 const expect = chai.expect
 
@@ -24,12 +26,16 @@ describe('Test channels search', function () {
 
     const servers = await Promise.all([
       createSingleServer(1),
-      createSingleServer(2, { transcoding: { enabled: false } })
+      createSingleServer(2)
     ])
     server = servers[0]
     remoteServer = servers[1]
 
     await setAccessTokensToServers([ server, remoteServer ])
+    await setDefaultChannelAvatar(server)
+    await setDefaultAccountAvatar(server)
+
+    await servers[1].config.disableTranscoding()
 
     {
       await server.users.create({ username: 'user1' })
diff --git a/server/tests/api/search/search-index.ts b/server/tests/api/search/search-index.ts
index f84d03345..b18d40b2a 100644
--- a/server/tests/api/search/search-index.ts
+++ b/server/tests/api/search/search-index.ts
@@ -14,7 +14,7 @@ import {
 
 const expect = chai.expect
 
-describe('Test videos search', function () {
+describe('Test index search', function () {
   const localVideoName = 'local video' + new Date().toISOString()
 
   let server: PeerTubeServer = null
@@ -134,12 +134,16 @@ describe('Test videos search', function () {
       expect(video.account.host).to.equal('framatube.org')
       expect(video.account.name).to.equal('framasoft')
       expect(video.account.url).to.equal('https://framatube.org/accounts/framasoft')
+      // TODO: remove, deprecated in 4.2
       expect(video.account.avatar).to.exist
+      expect(video.account.avatars.length).to.equal(1, 'Account should have one avatar image')
 
       expect(video.channel.host).to.equal('framatube.org')
       expect(video.channel.name).to.equal('joinpeertube')
       expect(video.channel.url).to.equal('https://framatube.org/video-channels/joinpeertube')
+      // TODO: remove, deprecated in 4.2
       expect(video.channel.avatar).to.exist
+      expect(video.channel.avatars.length).to.equal(1, 'Channel should have one avatar image')
     }
 
     const baseSearch: VideosSearchQuery = {
@@ -316,13 +320,17 @@ describe('Test videos search', function () {
       const videoChannel = body.data[0]
       expect(videoChannel.url).to.equal('https://framatube.org/video-channels/bf54d359-cfad-4935-9d45-9d6be93f63e8')
       expect(videoChannel.host).to.equal('framatube.org')
+      // TODO: remove, deprecated in 4.2
       expect(videoChannel.avatar).to.exist
+      expect(videoChannel.avatars.length).to.equal(1, 'Channel should have two avatar images')
       expect(videoChannel.displayName).to.exist
 
       expect(videoChannel.ownerAccount.url).to.equal('https://framatube.org/accounts/framasoft')
       expect(videoChannel.ownerAccount.name).to.equal('framasoft')
       expect(videoChannel.ownerAccount.host).to.equal('framatube.org')
+      // TODO: remove, deprecated in 4.2
       expect(videoChannel.ownerAccount.avatar).to.exist
+      expect(videoChannel.ownerAccount.avatars.length).to.equal(1, 'Account should have two avatar images')
     }
 
     it('Should make a simple search and not have results', async function () {
@@ -388,12 +396,16 @@ describe('Test videos search', function () {
       expect(videoPlaylist.ownerAccount.url).to.equal('https://peertube2.cpy.re/accounts/chocobozzz')
       expect(videoPlaylist.ownerAccount.name).to.equal('chocobozzz')
       expect(videoPlaylist.ownerAccount.host).to.equal('peertube2.cpy.re')
+      // TODO: remove, deprecated in 4.2
       expect(videoPlaylist.ownerAccount.avatar).to.exist
+      expect(videoPlaylist.ownerAccount.avatars.length).to.equal(2, 'Account should have two avatar images')
 
       expect(videoPlaylist.videoChannel.url).to.equal('https://peertube2.cpy.re/video-channels/chocobozzz_channel')
       expect(videoPlaylist.videoChannel.name).to.equal('chocobozzz_channel')
       expect(videoPlaylist.videoChannel.host).to.equal('peertube2.cpy.re')
+      // TODO: remove, deprecated in 4.2
       expect(videoPlaylist.videoChannel.avatar).to.exist
+      expect(videoPlaylist.videoChannel.avatars.length).to.equal(2, 'Channel should have two avatar images')
     }
 
     it('Should make a simple search and not have results', async function () {
diff --git a/server/tests/api/search/search-playlists.ts b/server/tests/api/search/search-playlists.ts
index 1e9c8d4bb..d9f12d316 100644
--- a/server/tests/api/search/search-playlists.ts
+++ b/server/tests/api/search/search-playlists.ts
@@ -2,6 +2,7 @@
 
 import 'mocha'
 import * as chai from 'chai'
+import { VideoPlaylistPrivacy } from '@shared/models'
 import {
   cleanupTests,
   createSingleServer,
@@ -9,9 +10,10 @@ import {
   PeerTubeServer,
   SearchCommand,
   setAccessTokensToServers,
+  setDefaultAccountAvatar,
+  setDefaultChannelAvatar,
   setDefaultVideoChannel
 } from '@shared/server-commands'
-import { VideoPlaylistPrivacy } from '@shared/models'
 
 const expect = chai.expect
 
@@ -27,13 +29,17 @@ describe('Test playlists search', function () {
 
     const servers = await Promise.all([
       createSingleServer(1),
-      createSingleServer(2, { transcoding: { enabled: false } })
+      createSingleServer(2)
     ])
     server = servers[0]
     remoteServer = servers[1]
 
     await setAccessTokensToServers([ remoteServer, server ])
     await setDefaultVideoChannel([ remoteServer, server ])
+    await setDefaultChannelAvatar([ remoteServer, server ])
+    await setDefaultAccountAvatar([ remoteServer, server ])
+
+    await servers[1].config.disableTranscoding()
 
     {
       const videoId = (await server.videos.upload()).uuid
diff --git a/server/tests/api/search/search-videos.ts b/server/tests/api/search/search-videos.ts
index c544705d3..ff4c3c161 100644
--- a/server/tests/api/search/search-videos.ts
+++ b/server/tests/api/search/search-videos.ts
@@ -2,6 +2,8 @@
 
 import 'mocha'
 import * as chai from 'chai'
+import { wait } from '@shared/core-utils'
+import { VideoPrivacy } from '@shared/models'
 import {
   cleanupTests,
   createSingleServer,
@@ -9,11 +11,11 @@ import {
   PeerTubeServer,
   SearchCommand,
   setAccessTokensToServers,
+  setDefaultAccountAvatar,
+  setDefaultChannelAvatar,
   setDefaultVideoChannel,
   stopFfmpeg
 } from '@shared/server-commands'
-import { VideoPrivacy } from '@shared/models'
-import { wait } from '@shared/core-utils'
 
 const expect = chai.expect
 
@@ -38,6 +40,8 @@ describe('Test videos search', function () {
 
     await setAccessTokensToServers([ server, remoteServer ])
     await setDefaultVideoChannel([ server, remoteServer ])
+    await setDefaultChannelAvatar(server)
+    await setDefaultAccountAvatar(servers)
 
     {
       const attributes1 = {
diff --git a/server/tests/api/server/config.ts b/server/tests/api/server/config.ts
index 2356f701c..565b2953a 100644
--- a/server/tests/api/server/config.ts
+++ b/server/tests/api/server/config.ts
@@ -97,6 +97,8 @@ function checkInitialConfig (server: PeerTubeServer, data: CustomConfig) {
   expect(data.live.transcoding.resolutions['1440p']).to.be.false
   expect(data.live.transcoding.resolutions['2160p']).to.be.false
 
+  expect(data.videoEditor.enabled).to.be.false
+
   expect(data.import.videos.concurrency).to.equal(2)
   expect(data.import.videos.http.enabled).to.be.true
   expect(data.import.videos.torrent.enabled).to.be.true
@@ -197,6 +199,8 @@ function checkUpdatedConfig (data: CustomConfig) {
   expect(data.live.transcoding.resolutions['1080p']).to.be.true
   expect(data.live.transcoding.resolutions['2160p']).to.be.true
 
+  expect(data.videoEditor.enabled).to.be.true
+
   expect(data.import.videos.concurrency).to.equal(4)
   expect(data.import.videos.http.enabled).to.be.false
   expect(data.import.videos.torrent.enabled).to.be.false
@@ -341,6 +345,9 @@ const newCustomConfig: CustomConfig = {
       }
     }
   },
+  videoEditor: {
+    enabled: true
+  },
   import: {
     videos: {
       concurrency: 4,
diff --git a/server/tests/api/server/homepage.ts b/server/tests/api/server/homepage.ts
index 552ee98cf..e7de6bfee 100644
--- a/server/tests/api/server/homepage.ts
+++ b/server/tests/api/server/homepage.ts
@@ -9,7 +9,9 @@ import {
   CustomPagesCommand,
   killallServers,
   PeerTubeServer,
-  setAccessTokensToServers
+  setAccessTokensToServers,
+  setDefaultAccountAvatar,
+  setDefaultChannelAvatar
 } from '../../../../shared/server-commands/index'
 
 const expect = chai.expect
@@ -29,6 +31,8 @@ describe('Test instance homepage actions', function () {
 
     server = await createSingleServer(1)
     await setAccessTokensToServers([ server ])
+    await setDefaultChannelAvatar(server)
+    await setDefaultAccountAvatar(server)
 
     command = server.customPage
   })
diff --git a/server/tests/api/server/stats.ts b/server/tests/api/server/stats.ts
index f0334532b..2296c0cb9 100644
--- a/server/tests/api/server/stats.ts
+++ b/server/tests/api/server/stats.ts
@@ -230,13 +230,7 @@ describe('Test stats (excluding redundancy)', function () {
   it('Should have the correct AP stats', async function () {
     this.timeout(60000)
 
-    await servers[0].config.updateCustomSubConfig({
-      newConfig: {
-        transcoding: {
-          enabled: false
-        }
-      }
-    })
+    await servers[0].config.disableTranscoding()
 
     const first = await servers[1].stats.get()
 
diff --git a/server/tests/api/videos/audio-only.ts b/server/tests/api/transcoding/audio-only.ts
index e58360ffe..e7e73d382 100644
--- a/server/tests/api/videos/audio-only.ts
+++ b/server/tests/api/transcoding/audio-only.ts
@@ -2,7 +2,7 @@
 
 import 'mocha'
 import * as chai from 'chai'
-import { getAudioStream, getVideoStreamSize } from '@server/helpers/ffprobe-utils'
+import { getAudioStream, getVideoStreamDimensionsInfo } from '@server/helpers/ffmpeg'
 import {
   cleanupTests,
   createMultipleServers,
@@ -91,9 +91,8 @@ describe('Test audio only video transcoding', function () {
       expect(audioStream['codec_name']).to.be.equal('aac')
       expect(audioStream['bit_rate']).to.be.at.most(384 * 8000)
 
-      const size = await getVideoStreamSize(path)
-      expect(size.height).to.equal(0)
-      expect(size.width).to.equal(0)
+      const size = await getVideoStreamDimensionsInfo(path)
+      expect(size).to.not.exist
     }
   })
 
diff --git a/server/tests/api/videos/video-create-transcoding.ts b/server/tests/api/transcoding/create-transcoding.ts
index a4defdf51..a4defdf51 100644
--- a/server/tests/api/videos/video-create-transcoding.ts
+++ b/server/tests/api/transcoding/create-transcoding.ts
diff --git a/server/tests/api/videos/video-hls.ts b/server/tests/api/transcoding/hls.ts
index 218ec08ae..218ec08ae 100644
--- a/server/tests/api/videos/video-hls.ts
+++ b/server/tests/api/transcoding/hls.ts
diff --git a/server/tests/api/transcoding/index.ts b/server/tests/api/transcoding/index.ts
new file mode 100644
index 000000000..8a0a1d787
--- /dev/null
+++ b/server/tests/api/transcoding/index.ts
@@ -0,0 +1,5 @@
+export * from './audio-only'
+export * from './create-transcoding'
+export * from './hls'
+export * from './transcoder'
+export * from './video-editor'
diff --git a/server/tests/api/videos/video-transcoder.ts b/server/tests/api/transcoding/transcoder.ts
index d24a8f4e1..245c4c012 100644
--- a/server/tests/api/videos/video-transcoder.ts
+++ b/server/tests/api/transcoding/transcoder.ts
@@ -3,10 +3,17 @@
 import 'mocha'
 import * as chai from 'chai'
 import { omit } from 'lodash'
-import { canDoQuickTranscode } from '@server/helpers/ffprobe-utils'
-import { generateHighBitrateVideo, generateVideoWithFramerate } from '@server/tests/shared'
+import { canDoQuickTranscode } from '@server/helpers/ffmpeg'
+import { generateHighBitrateVideo, generateVideoWithFramerate, getAllFiles } from '@server/tests/shared'
 import { buildAbsoluteFixturePath, getMaxBitrate, getMinLimitBitrate } from '@shared/core-utils'
-import { getAudioStream, getMetadataFromFile, getVideoFileBitrate, getVideoFileFPS, getVideoFileResolution } from '@shared/extra-utils'
+import {
+  getAudioStream,
+  buildFileMetadata,
+  getVideoStreamBitrate,
+  getVideoStreamFPS,
+  getVideoStreamDimensionsInfo,
+  hasAudioStream
+} from '@shared/extra-utils'
 import { HttpStatusCode, VideoState } from '@shared/models'
 import {
   cleanupTests,
@@ -287,8 +294,7 @@ describe('Test video transcoding', function () {
         const file = videoDetails.files.find(f => f.resolution.id === 240)
         const path = servers[1].servers.buildWebTorrentFilePath(file.fileUrl)
 
-        const probe = await getAudioStream(path)
-        expect(probe).to.not.have.property('audioStream')
+        expect(await hasAudioStream(path)).to.be.false
       }
     })
 
@@ -478,14 +484,14 @@ describe('Test video transcoding', function () {
         for (const resolution of [ 144, 240, 360, 480 ]) {
           const file = videoDetails.files.find(f => f.resolution.id === resolution)
           const path = servers[1].servers.buildWebTorrentFilePath(file.fileUrl)
-          const fps = await getVideoFileFPS(path)
+          const fps = await getVideoStreamFPS(path)
 
           expect(fps).to.be.below(31)
         }
 
         const file = videoDetails.files.find(f => f.resolution.id === 720)
         const path = servers[1].servers.buildWebTorrentFilePath(file.fileUrl)
-        const fps = await getVideoFileFPS(path)
+        const fps = await getVideoStreamFPS(path)
 
         expect(fps).to.be.above(58).and.below(62)
       }
@@ -499,7 +505,7 @@ describe('Test video transcoding', function () {
       {
         tempFixturePath = await generateVideoWithFramerate(59)
 
-        const fps = await getVideoFileFPS(tempFixturePath)
+        const fps = await getVideoStreamFPS(tempFixturePath)
         expect(fps).to.be.equal(59)
       }
 
@@ -522,14 +528,14 @@ describe('Test video transcoding', function () {
         {
           const file = video.files.find(f => f.resolution.id === 240)
           const path = servers[1].servers.buildWebTorrentFilePath(file.fileUrl)
-          const fps = await getVideoFileFPS(path)
+          const fps = await getVideoStreamFPS(path)
           expect(fps).to.be.equal(25)
         }
 
         {
           const file = video.files.find(f => f.resolution.id === 720)
           const path = servers[1].servers.buildWebTorrentFilePath(file.fileUrl)
-          const fps = await getVideoFileFPS(path)
+          const fps = await getVideoStreamFPS(path)
           expect(fps).to.be.equal(59)
         }
       }
@@ -563,9 +569,9 @@ describe('Test video transcoding', function () {
           const file = video.files.find(f => f.resolution.id === resolution)
           const path = servers[1].servers.buildWebTorrentFilePath(file.fileUrl)
 
-          const bitrate = await getVideoFileBitrate(path)
-          const fps = await getVideoFileFPS(path)
-          const dataResolution = await getVideoFileResolution(path)
+          const bitrate = await getVideoStreamBitrate(path)
+          const fps = await getVideoStreamFPS(path)
+          const dataResolution = await getVideoStreamDimensionsInfo(path)
 
           expect(resolution).to.equal(resolution)
 
@@ -613,7 +619,7 @@ describe('Test video transcoding', function () {
         const file = video.files.find(f => f.resolution.id === r)
 
         const path = servers[1].servers.buildWebTorrentFilePath(file.fileUrl)
-        const bitrate = await getVideoFileBitrate(path)
+        const bitrate = await getVideoStreamBitrate(path)
 
         const inputBitrate = 60_000
         const limit = getMinLimitBitrate({ fps: 10, ratio: 1, resolution: r })
@@ -637,7 +643,7 @@ describe('Test video transcoding', function () {
         const video = await servers[1].videos.get({ id: videoUUID })
         const file = video.files.find(f => f.resolution.id === 240)
         const path = servers[1].servers.buildWebTorrentFilePath(file.fileUrl)
-        const metadata = await getMetadataFromFile(path)
+        const metadata = await buildFileMetadata(path)
 
         // expected format properties
         for (const p of [
@@ -668,8 +674,7 @@ describe('Test video transcoding', function () {
       for (const server of servers) {
         const videoDetails = await server.videos.get({ id: videoUUID })
 
-        const videoFiles = videoDetails.files
-                                      .concat(videoDetails.streamingPlaylists[0].files)
+        const videoFiles = getAllFiles(videoDetails)
         expect(videoFiles).to.have.lengthOf(10)
 
         for (const file of videoFiles) {
diff --git a/server/tests/api/transcoding/video-editor.ts b/server/tests/api/transcoding/video-editor.ts
new file mode 100644
index 000000000..a9b6950cc
--- /dev/null
+++ b/server/tests/api/transcoding/video-editor.ts
@@ -0,0 +1,368 @@
+import { expect } from 'chai'
+import { expectStartWith, getAllFiles } from '@server/tests/shared'
+import { areObjectStorageTestsDisabled } from '@shared/core-utils'
+import { VideoEditorTask } from '@shared/models'
+import {
+  cleanupTests,
+  createMultipleServers,
+  doubleFollow,
+  ObjectStorageCommand,
+  PeerTubeServer,
+  setAccessTokensToServers,
+  setDefaultVideoChannel,
+  VideoEditorCommand,
+  waitJobs
+} from '@shared/server-commands'
+
+describe('Test video editor', function () {
+  let servers: PeerTubeServer[] = []
+  let videoUUID: string
+
+  async function checkDuration (server: PeerTubeServer, duration: number) {
+    const video = await server.videos.get({ id: videoUUID })
+
+    expect(video.duration).to.be.approximately(duration, 1)
+
+    for (const file of video.files) {
+      const metadata = await server.videos.getFileMetadata({ url: file.metadataUrl })
+
+      for (const stream of metadata.streams) {
+        expect(Math.round(stream.duration)).to.be.approximately(duration, 1)
+      }
+    }
+  }
+
+  async function renewVideo (fixture = 'video_short.webm') {
+    const video = await servers[0].videos.quickUpload({ name: 'video', fixture })
+    videoUUID = video.uuid
+
+    await waitJobs(servers)
+  }
+
+  async function createTasks (tasks: VideoEditorTask[]) {
+    await servers[0].videoEditor.createEditionTasks({ videoId: videoUUID, tasks })
+    await waitJobs(servers)
+  }
+
+  before(async function () {
+    this.timeout(120_000)
+
+    servers = await createMultipleServers(2)
+
+    await setAccessTokensToServers(servers)
+    await setDefaultVideoChannel(servers)
+
+    await doubleFollow(servers[0], servers[1])
+
+    await servers[0].config.enableMinimumTranscoding()
+
+    await servers[0].config.updateExistingSubConfig({
+      newConfig: {
+        videoEditor: {
+          enabled: true
+        }
+      }
+    })
+  })
+
+  describe('Cutting', function () {
+
+    it('Should cut the beginning of the video', async function () {
+      this.timeout(120_000)
+
+      await renewVideo()
+      await waitJobs(servers)
+
+      const beforeTasks = new Date()
+
+      await createTasks([
+        {
+          name: 'cut',
+          options: {
+            start: 2
+          }
+        }
+      ])
+
+      for (const server of servers) {
+        await checkDuration(server, 3)
+
+        const video = await server.videos.get({ id: videoUUID })
+        expect(new Date(video.publishedAt)).to.be.below(beforeTasks)
+      }
+    })
+
+    it('Should cut the end of the video', async function () {
+      this.timeout(120_000)
+      await renewVideo()
+
+      await createTasks([
+        {
+          name: 'cut',
+          options: {
+            end: 2
+          }
+        }
+      ])
+
+      for (const server of servers) {
+        await checkDuration(server, 2)
+      }
+    })
+
+    it('Should cut start/end of the video', async function () {
+      this.timeout(120_000)
+      await renewVideo('video_short1.webm') // 10 seconds video duration
+
+      await createTasks([
+        {
+          name: 'cut',
+          options: {
+            start: 2,
+            end: 6
+          }
+        }
+      ])
+
+      for (const server of servers) {
+        await checkDuration(server, 4)
+      }
+    })
+  })
+
+  describe('Intro/Outro', function () {
+
+    it('Should add an intro', async function () {
+      this.timeout(120_000)
+      await renewVideo()
+
+      await createTasks([
+        {
+          name: 'add-intro',
+          options: {
+            file: 'video_short.webm'
+          }
+        }
+      ])
+
+      for (const server of servers) {
+        await checkDuration(server, 10)
+      }
+    })
+
+    it('Should add an outro', async function () {
+      this.timeout(120_000)
+      await renewVideo()
+
+      await createTasks([
+        {
+          name: 'add-outro',
+          options: {
+            file: 'video_very_short_240p.mp4'
+          }
+        }
+      ])
+
+      for (const server of servers) {
+        await checkDuration(server, 7)
+      }
+    })
+
+    it('Should add an intro/outro', async function () {
+      this.timeout(120_000)
+      await renewVideo()
+
+      await createTasks([
+        {
+          name: 'add-intro',
+          options: {
+            file: 'video_very_short_240p.mp4'
+          }
+        },
+        {
+          name: 'add-outro',
+          options: {
+            // Different frame rate
+            file: 'video_short2.webm'
+          }
+        }
+      ])
+
+      for (const server of servers) {
+        await checkDuration(server, 12)
+      }
+    })
+
+    it('Should add an intro to a video without audio', async function () {
+      this.timeout(120_000)
+      await renewVideo('video_short_no_audio.mp4')
+
+      await createTasks([
+        {
+          name: 'add-intro',
+          options: {
+            file: 'video_very_short_240p.mp4'
+          }
+        }
+      ])
+
+      for (const server of servers) {
+        await checkDuration(server, 7)
+      }
+    })
+
+    it('Should add an outro without audio to a video with audio', async function () {
+      this.timeout(120_000)
+      await renewVideo()
+
+      await createTasks([
+        {
+          name: 'add-outro',
+          options: {
+            file: 'video_short_no_audio.mp4'
+          }
+        }
+      ])
+
+      for (const server of servers) {
+        await checkDuration(server, 10)
+      }
+    })
+
+    it('Should add an outro without audio to a video with audio', async function () {
+      this.timeout(120_000)
+      await renewVideo('video_short_no_audio.mp4')
+
+      await createTasks([
+        {
+          name: 'add-outro',
+          options: {
+            file: 'video_short_no_audio.mp4'
+          }
+        }
+      ])
+
+      for (const server of servers) {
+        await checkDuration(server, 10)
+      }
+    })
+  })
+
+  describe('Watermark', function () {
+
+    it('Should add a watermark to the video', async function () {
+      this.timeout(120_000)
+      await renewVideo()
+
+      const video = await servers[0].videos.get({ id: videoUUID })
+      const oldFileUrls = getAllFiles(video).map(f => f.fileUrl)
+
+      await createTasks([
+        {
+          name: 'add-watermark',
+          options: {
+            file: 'thumbnail.png'
+          }
+        }
+      ])
+
+      for (const server of servers) {
+        const video = await server.videos.get({ id: videoUUID })
+        const fileUrls = getAllFiles(video).map(f => f.fileUrl)
+
+        for (const oldUrl of oldFileUrls) {
+          expect(fileUrls).to.not.include(oldUrl)
+        }
+      }
+    })
+  })
+
+  describe('Complex tasks', function () {
+    it('Should run a complex task', async function () {
+      this.timeout(240_000)
+      await renewVideo()
+
+      await createTasks(VideoEditorCommand.getComplexTask())
+
+      for (const server of servers) {
+        await checkDuration(server, 9)
+      }
+    })
+  })
+
+  describe('HLS only video edition', function () {
+
+    before(async function () {
+      // Disable webtorrent
+      await servers[0].config.updateExistingSubConfig({
+        newConfig: {
+          transcoding: {
+            webtorrent: {
+              enabled: false
+            }
+          }
+        }
+      })
+    })
+
+    it('Should run a complex task on HLS only video', async function () {
+      this.timeout(240_000)
+      await renewVideo()
+
+      await createTasks(VideoEditorCommand.getComplexTask())
+
+      for (const server of servers) {
+        const video = await server.videos.get({ id: videoUUID })
+        expect(video.files).to.have.lengthOf(0)
+
+        await checkDuration(server, 9)
+      }
+    })
+  })
+
+  describe('Object storage video edition', function () {
+    if (areObjectStorageTestsDisabled()) return
+
+    before(async function () {
+      await ObjectStorageCommand.prepareDefaultBuckets()
+
+      await servers[0].kill()
+      await servers[0].run(ObjectStorageCommand.getDefaultConfig())
+
+      await servers[0].config.enableMinimumTranscoding()
+    })
+
+    it('Should run a complex task on a video in object storage', async function () {
+      this.timeout(240_000)
+      await renewVideo()
+
+      const video = await servers[0].videos.get({ id: videoUUID })
+      const oldFileUrls = getAllFiles(video).map(f => f.fileUrl)
+
+      await createTasks(VideoEditorCommand.getComplexTask())
+
+      for (const server of servers) {
+        const video = await server.videos.get({ id: videoUUID })
+        const files = getAllFiles(video)
+
+        for (const f of files) {
+          expect(oldFileUrls).to.not.include(f.fileUrl)
+        }
+
+        for (const webtorrentFile of video.files) {
+          expectStartWith(webtorrentFile.fileUrl, ObjectStorageCommand.getWebTorrentBaseUrl())
+        }
+
+        for (const hlsFile of video.streamingPlaylists[0].files) {
+          expectStartWith(hlsFile.fileUrl, ObjectStorageCommand.getPlaylistBaseUrl())
+        }
+
+        await checkDuration(server, 9)
+      }
+    })
+  })
+
+  after(async function () {
+    await cleanupTests(servers)
+  })
+})
diff --git a/server/tests/api/users/user-subscriptions.ts b/server/tests/api/users/user-subscriptions.ts
index 57cca6ad4..9553a69bb 100644
--- a/server/tests/api/users/user-subscriptions.ts
+++ b/server/tests/api/users/user-subscriptions.ts
@@ -9,6 +9,8 @@ import {
   doubleFollow,
   PeerTubeServer,
   setAccessTokensToServers,
+  setDefaultAccountAvatar,
+  setDefaultChannelAvatar,
   SubscriptionsCommand,
   waitJobs
 } from '@shared/server-commands'
@@ -29,6 +31,8 @@ describe('Test users subscriptions', function () {
 
     // Get the access tokens
     await setAccessTokensToServers(servers)
+    await setDefaultChannelAvatar(servers)
+    await setDefaultAccountAvatar(servers)
 
     // Server 1 and server 2 follow each other
     await doubleFollow(servers[0], servers[1])
diff --git a/server/tests/api/users/users-multiple-servers.ts b/server/tests/api/users/users-multiple-servers.ts
index 5b2bbc520..3e8b932c0 100644
--- a/server/tests/api/users/users-multiple-servers.ts
+++ b/server/tests/api/users/users-multiple-servers.ts
@@ -16,6 +16,7 @@ import {
   doubleFollow,
   PeerTubeServer,
   setAccessTokensToServers,
+  setDefaultChannelAvatar,
   waitJobs
 } from '@shared/server-commands'
 
@@ -29,7 +30,7 @@ describe('Test users with multiple servers', function () {
 
   let videoUUID: string
   let userAccessToken: string
-  let userAvatarFilename: string
+  let userAvatarFilenames: string[]
 
   before(async function () {
     this.timeout(120_000)
@@ -38,6 +39,7 @@ describe('Test users with multiple servers', function () {
 
     // Get the access tokens
     await setAccessTokensToServers(servers)
+    await setDefaultChannelAvatar(servers)
 
     // Server 1 and server 2 follow each other
     await doubleFollow(servers[0], servers[1])
@@ -97,9 +99,11 @@ describe('Test users with multiple servers', function () {
     await servers[0].users.updateMyAvatar({ fixture })
 
     user = await servers[0].users.getMyInfo()
-    userAvatarFilename = user.account.avatar.path
+    userAvatarFilenames = user.account.avatars.map(({ path }) => path)
 
-    await testImage(servers[0].url, 'avatar2-resized', userAvatarFilename, '.png')
+    for (const avatar of user.account.avatars) {
+      await testImage(servers[0].url, `avatar2-resized-${avatar.width}x${avatar.width}`, avatar.path, '.png')
+    }
 
     await waitJobs(servers)
   })
@@ -129,7 +133,9 @@ describe('Test users with multiple servers', function () {
         expect(account.userId).to.be.undefined
       }
 
-      await testImage(server.url, 'avatar2-resized', account.avatar.path, '.png')
+      for (const avatar of account.avatars) {
+        await testImage(server.url, `avatar2-resized-${avatar.width}x${avatar.width}`, avatar.path, '.png')
+      }
     }
   })
 
@@ -193,7 +199,9 @@ describe('Test users with multiple servers', function () {
 
   it('Should not have actor files', async () => {
     for (const server of servers) {
-      await checkActorFilesWereRemoved(userAvatarFilename, server.internalServerNumber)
+      for (const userAvatarFilename of userAvatarFilenames) {
+        await checkActorFilesWereRemoved(userAvatarFilename, server.internalServerNumber)
+      }
     }
   })
 
diff --git a/server/tests/api/users/users.ts b/server/tests/api/users/users.ts
index 7023b3f08..a47713bf0 100644
--- a/server/tests/api/users/users.ts
+++ b/server/tests/api/users/users.ts
@@ -604,7 +604,9 @@ describe('Test users', function () {
       await server.users.updateMyAvatar({ token: userToken, fixture })
 
       const user = await server.users.getMyInfo({ token: userToken })
-      await testImage(server.url, 'avatar-resized', user.account.avatar.path, '.gif')
+      for (const avatar of user.account.avatars) {
+        await testImage(server.url, `avatar-resized-${avatar.width}x${avatar.width}`, avatar.path, '.gif')
+      }
     })
 
     it('Should be able to update my avatar with a gif, and then a png', async function () {
@@ -614,7 +616,9 @@ describe('Test users', function () {
         await server.users.updateMyAvatar({ token: userToken, fixture })
 
         const user = await server.users.getMyInfo({ token: userToken })
-        await testImage(server.url, 'avatar-resized', user.account.avatar.path, extension)
+        for (const avatar of user.account.avatars) {
+          await testImage(server.url, `avatar-resized-${avatar.width}x${avatar.width}`, avatar.path, extension)
+        }
       }
     })
 
diff --git a/server/tests/api/videos/index.ts b/server/tests/api/videos/index.ts
index bedb9b8b6..7dc826353 100644
--- a/server/tests/api/videos/index.ts
+++ b/server/tests/api/videos/index.ts
@@ -1,4 +1,3 @@
-import './audio-only'
 import './multiple-servers'
 import './resumable-upload'
 import './single-server'
@@ -6,17 +5,14 @@ import './video-captions'
 import './video-change-ownership'
 import './video-channels'
 import './video-comments'
-import './video-create-transcoding'
 import './video-description'
 import './video-files'
-import './video-hls'
 import './video-imports'
 import './video-nsfw'
 import './video-playlists'
 import './video-playlist-thumbnails'
 import './video-privacy'
 import './video-schedule-update'
-import './video-transcoder'
 import './videos-common-filters'
 import './videos-history'
 import './videos-overview'
diff --git a/server/tests/api/videos/multiple-servers.ts b/server/tests/api/videos/multiple-servers.ts
index ecdd36613..05ccee8ad 100644
--- a/server/tests/api/videos/multiple-servers.ts
+++ b/server/tests/api/videos/multiple-servers.ts
@@ -17,8 +17,11 @@ import {
   cleanupTests,
   createMultipleServers,
   doubleFollow,
+  makeGetRequest,
   PeerTubeServer,
   setAccessTokensToServers,
+  setDefaultAccountAvatar,
+  setDefaultChannelAvatar,
   waitJobs,
   webtorrentAdd
 } from '@shared/server-commands'
@@ -46,6 +49,9 @@ describe('Test multiple servers', function () {
         description: 'super channel'
       }
       await servers[0].channels.create({ attributes: videoChannel })
+      await setDefaultChannelAvatar(servers[0], videoChannel.name)
+      await setDefaultAccountAvatar(servers)
+
       const { data } = await servers[0].channels.list({ start: 0, count: 1 })
       videoChannelId = data[0].id
     }
@@ -133,6 +139,22 @@ describe('Test multiple servers', function () {
 
         await completeVideoCheck(server, video, checkAttributes)
         publishedAt = video.publishedAt as string
+
+        expect(video.channel.avatars).to.have.lengthOf(2)
+        expect(video.account.avatars).to.have.lengthOf(2)
+
+        for (const image of [ ...video.channel.avatars, ...video.account.avatars ]) {
+          expect(image.createdAt).to.exist
+          expect(image.updatedAt).to.exist
+          expect(image.width).to.be.above(20).and.below(1000)
+          expect(image.path).to.exist
+
+          await makeGetRequest({
+            url: server.url,
+            path: image.path,
+            expectedStatus: HttpStatusCode.OK_200
+          })
+        }
       }
     })
 
@@ -207,7 +229,7 @@ describe('Test multiple servers', function () {
             },
             {
               resolution: 720,
-              size: 788000
+              size: 750000
             }
           ],
           thumbnailfile: 'thumbnail',
diff --git a/server/tests/api/videos/single-server.ts b/server/tests/api/videos/single-server.ts
index 28bf018c5..d37043aef 100644
--- a/server/tests/api/videos/single-server.ts
+++ b/server/tests/api/videos/single-server.ts
@@ -5,7 +5,14 @@ import * as chai from 'chai'
 import { checkVideoFilesWereRemoved, completeVideoCheck, testImage } from '@server/tests/shared'
 import { wait } from '@shared/core-utils'
 import { Video, VideoPrivacy } from '@shared/models'
-import { cleanupTests, createSingleServer, PeerTubeServer, setAccessTokensToServers } from '@shared/server-commands'
+import {
+  cleanupTests,
+  createSingleServer,
+  PeerTubeServer,
+  setAccessTokensToServers,
+  setDefaultAccountAvatar,
+  setDefaultChannelAvatar
+} from '@shared/server-commands'
 
 const expect = chai.expect
 
@@ -90,6 +97,8 @@ describe('Test a single server', function () {
       server = await createSingleServer(1)
 
       await setAccessTokensToServers([ server ])
+      await setDefaultChannelAvatar(server)
+      await setDefaultAccountAvatar(server)
     })
 
     it('Should list video categories', async function () {
diff --git a/server/tests/api/videos/video-channels.ts b/server/tests/api/videos/video-channels.ts
index d435f3682..0f8227fd3 100644
--- a/server/tests/api/videos/video-channels.ts
+++ b/server/tests/api/videos/video-channels.ts
@@ -6,13 +6,14 @@ import { basename } from 'path'
 import { ACTOR_IMAGES_SIZE } from '@server/initializers/constants'
 import { testFileExistsOrNot, testImage } from '@server/tests/shared'
 import { wait } from '@shared/core-utils'
-import { User, VideoChannel } from '@shared/models'
+import { ActorImageType, User, VideoChannel } from '@shared/models'
 import {
   cleanupTests,
   createMultipleServers,
   doubleFollow,
   PeerTubeServer,
   setAccessTokensToServers,
+  setDefaultAccountAvatar,
   setDefaultVideoChannel,
   waitJobs
 } from '@shared/server-commands'
@@ -44,6 +45,7 @@ describe('Test video channels', function () {
 
     await setAccessTokensToServers(servers)
     await setDefaultVideoChannel(servers)
+    await setDefaultAccountAvatar(servers)
 
     await doubleFollow(servers[0], servers[1])
   })
@@ -281,14 +283,19 @@ describe('Test video channels', function () {
 
     for (const server of servers) {
       const videoChannel = await findChannel(server, secondVideoChannelId)
+      const expectedSizes = ACTOR_IMAGES_SIZE[ActorImageType.AVATAR]
 
-      avatarPaths[server.port] = videoChannel.avatar.path
-      await testImage(server.url, 'avatar-resized', avatarPaths[server.port], '.png')
-      await testFileExistsOrNot(server, 'avatars', basename(avatarPaths[server.port]), true)
+      expect(videoChannel.avatars.length).to.equal(expectedSizes.length, 'Expected avatars to be generated in all sizes')
 
-      const row = await server.sql.getActorImage(basename(avatarPaths[server.port]))
-      expect(row.height).to.equal(ACTOR_IMAGES_SIZE.AVATARS.height)
-      expect(row.width).to.equal(ACTOR_IMAGES_SIZE.AVATARS.width)
+      for (const avatar of videoChannel.avatars) {
+        avatarPaths[server.port] = avatar.path
+        await testImage(server.url, `avatar-resized-${avatar.width}x${avatar.width}`, avatarPaths[server.port], '.png')
+        await testFileExistsOrNot(server, 'avatars', basename(avatarPaths[server.port]), true)
+
+        const row = await server.sql.getActorImage(basename(avatarPaths[server.port]))
+
+        expect(expectedSizes.some(({ height, width }) => row.height === height && row.width === width)).to.equal(true)
+      }
     }
   })
 
@@ -308,19 +315,18 @@ describe('Test video channels', function () {
     for (const server of servers) {
       const videoChannel = await server.channels.get({ channelName: 'second_video_channel@' + servers[0].host })
 
-      bannerPaths[server.port] = videoChannel.banner.path
+      bannerPaths[server.port] = videoChannel.banners[0].path
       await testImage(server.url, 'banner-resized', bannerPaths[server.port])
       await testFileExistsOrNot(server, 'avatars', basename(bannerPaths[server.port]), true)
 
       const row = await server.sql.getActorImage(basename(bannerPaths[server.port]))
-      expect(row.height).to.equal(ACTOR_IMAGES_SIZE.BANNERS.height)
-      expect(row.width).to.equal(ACTOR_IMAGES_SIZE.BANNERS.width)
+      expect(row.height).to.equal(ACTOR_IMAGES_SIZE[ActorImageType.BANNER][0].height)
+      expect(row.width).to.equal(ACTOR_IMAGES_SIZE[ActorImageType.BANNER][0].width)
     }
   })
 
   it('Should delete the video channel avatar', async function () {
     this.timeout(15000)
-
     await servers[0].channels.deleteImage({ channelName: 'second_video_channel', type: 'avatar' })
 
     await waitJobs(servers)
@@ -329,7 +335,7 @@ describe('Test video channels', function () {
       const videoChannel = await findChannel(server, secondVideoChannelId)
       await testFileExistsOrNot(server, 'avatars', basename(avatarPaths[server.port]), false)
 
-      expect(videoChannel.avatar).to.be.null
+      expect(videoChannel.avatars).to.be.empty
     }
   })
 
@@ -344,7 +350,7 @@ describe('Test video channels', function () {
       const videoChannel = await findChannel(server, secondVideoChannelId)
       await testFileExistsOrNot(server, 'avatars', basename(bannerPaths[server.port]), false)
 
-      expect(videoChannel.banner).to.be.null
+      expect(videoChannel.banners).to.be.empty
     }
   })
 
diff --git a/server/tests/api/videos/video-comments.ts b/server/tests/api/videos/video-comments.ts
index 2ae523970..1488ce2b5 100644
--- a/server/tests/api/videos/video-comments.ts
+++ b/server/tests/api/videos/video-comments.ts
@@ -3,7 +3,15 @@
 import 'mocha'
 import * as chai from 'chai'
 import { dateIsValid, testImage } from '@server/tests/shared'
-import { cleanupTests, CommentsCommand, createSingleServer, PeerTubeServer, setAccessTokensToServers } from '@shared/server-commands'
+import {
+  cleanupTests,
+  CommentsCommand,
+  createSingleServer,
+  PeerTubeServer,
+  setAccessTokensToServers,
+  setDefaultAccountAvatar,
+  setDefaultChannelAvatar
+} from '@shared/server-commands'
 
 const expect = chai.expect
 
@@ -29,7 +37,8 @@ describe('Test video comments', function () {
     videoUUID = uuid
     videoId = id
 
-    await server.users.updateMyAvatar({ fixture: 'avatar.png' })
+    await setDefaultChannelAvatar(server)
+    await setDefaultAccountAvatar(server)
 
     userAccessTokenServer1 = await server.users.generateUserAndToken('user1')
 
@@ -81,7 +90,9 @@ describe('Test video comments', function () {
       expect(comment.account.name).to.equal('root')
       expect(comment.account.host).to.equal('localhost:' + server.port)
 
-      await testImage(server.url, 'avatar-resized', comment.account.avatar.path, '.png')
+      for (const avatar of comment.account.avatars) {
+        await testImage(server.url, `avatar-resized-${avatar.width}x${avatar.width}`, avatar.path, '.png')
+      }
 
       expect(comment.totalReplies).to.equal(0)
       expect(comment.totalRepliesFromVideoAuthor).to.equal(0)
diff --git a/server/tests/api/videos/video-playlist-thumbnails.ts b/server/tests/api/videos/video-playlist-thumbnails.ts
index 5fdb0fc03..3944dc344 100644
--- a/server/tests/api/videos/video-playlist-thumbnails.ts
+++ b/server/tests/api/videos/video-playlist-thumbnails.ts
@@ -45,12 +45,16 @@ describe('Playlist thumbnail', function () {
   before(async function () {
     this.timeout(120000)
 
-    servers = await createMultipleServers(2, { transcoding: { enabled: false } })
+    servers = await createMultipleServers(2)
 
     // Get the access tokens
     await setAccessTokensToServers(servers)
     await setDefaultVideoChannel(servers)
 
+    for (const server of servers) {
+      await server.config.disableTranscoding()
+    }
+
     // Server 1 and server 2 follow each other
     await doubleFollow(servers[0], servers[1])
 
diff --git a/server/tests/api/videos/video-playlists.ts b/server/tests/api/videos/video-playlists.ts
index 34327334f..c33a63df0 100644
--- a/server/tests/api/videos/video-playlists.ts
+++ b/server/tests/api/videos/video-playlists.ts
@@ -20,6 +20,7 @@ import {
   PeerTubeServer,
   PlaylistsCommand,
   setAccessTokensToServers,
+  setDefaultAccountAvatar,
   setDefaultVideoChannel,
   waitJobs
 } from '@shared/server-commands'
@@ -74,11 +75,16 @@ describe('Test video playlists', function () {
   before(async function () {
     this.timeout(120000)
 
-    servers = await createMultipleServers(3, { transcoding: { enabled: false } })
+    servers = await createMultipleServers(3)
 
     // Get the access tokens
     await setAccessTokensToServers(servers)
     await setDefaultVideoChannel(servers)
+    await setDefaultAccountAvatar(servers)
+
+    for (const server of servers) {
+      await server.config.disableTranscoding()
+    }
 
     // Server 1 and server 2 follow each other
     await doubleFollow(servers[0], servers[1])
diff --git a/server/tests/api/videos/videos-common-filters.ts b/server/tests/api/videos/videos-common-filters.ts
index 0254662c5..317de90a9 100644
--- a/server/tests/api/videos/videos-common-filters.ts
+++ b/server/tests/api/videos/videos-common-filters.ts
@@ -3,6 +3,7 @@
 import 'mocha'
 import { expect } from 'chai'
 import { pick } from '@shared/core-utils'
+import { HttpStatusCode, UserRole, Video, VideoDetails, VideoInclude, VideoPrivacy } from '@shared/models'
 import {
   cleanupTests,
   createMultipleServers,
@@ -10,10 +11,10 @@ import {
   makeGetRequest,
   PeerTubeServer,
   setAccessTokensToServers,
+  setDefaultAccountAvatar,
   setDefaultVideoChannel,
   waitJobs
 } from '@shared/server-commands'
-import { HttpStatusCode, UserRole, Video, VideoDetails, VideoInclude, VideoPrivacy } from '@shared/models'
 
 describe('Test videos filter', function () {
   let servers: PeerTubeServer[]
@@ -29,6 +30,7 @@ describe('Test videos filter', function () {
 
     await setAccessTokensToServers(servers)
     await setDefaultVideoChannel(servers)
+    await setDefaultAccountAvatar(servers)
 
     for (const server of servers) {
       const moderator = { username: 'moderator', password: 'my super password' }
diff --git a/server/tests/cli/prune-storage.ts b/server/tests/cli/prune-storage.ts
index a723ed8b4..3ca7c19ea 100644
--- a/server/tests/cli/prune-storage.ts
+++ b/server/tests/cli/prune-storage.ts
@@ -51,7 +51,7 @@ async function assertCountAreOkay (servers: PeerTubeServer[]) {
     expect(thumbnailsCount).to.equal(6)
 
     const avatarsCount = await countFiles(server, 'avatars')
-    expect(avatarsCount).to.equal(2)
+    expect(avatarsCount).to.equal(4)
 
     const hlsRootCount = await countFiles(server, 'streaming-playlists/hls')
     expect(hlsRootCount).to.equal(2)
@@ -87,23 +87,28 @@ describe('Test prune storage scripts', function () {
 
     await doubleFollow(servers[0], servers[1])
 
-    // Lazy load the remote avatar
+    // Lazy load the remote avatars
     {
       const account = await servers[0].accounts.get({ accountName: 'root@localhost:' + servers[1].port })
-      await makeGetRequest({
-        url: servers[0].url,
-        path: account.avatar.path,
-        expectedStatus: HttpStatusCode.OK_200
-      })
+
+      for (const avatar of account.avatars) {
+        await makeGetRequest({
+          url: servers[0].url,
+          path: avatar.path,
+          expectedStatus: HttpStatusCode.OK_200
+        })
+      }
     }
 
     {
       const account = await servers[1].accounts.get({ accountName: 'root@localhost:' + servers[0].port })
-      await makeGetRequest({
-        url: servers[1].url,
-        path: account.avatar.path,
-        expectedStatus: HttpStatusCode.OK_200
-      })
+      for (const avatar of account.avatars) {
+        await makeGetRequest({
+          url: servers[1].url,
+          path: avatar.path,
+          expectedStatus: HttpStatusCode.OK_200
+        })
+      }
     }
 
     await wait(1000)
diff --git a/server/tests/cli/update-host.ts b/server/tests/cli/update-host.ts
index da89ff153..7c49efd20 100644
--- a/server/tests/cli/update-host.ts
+++ b/server/tests/cli/update-host.ts
@@ -12,6 +12,7 @@ import {
   setAccessTokensToServers,
   waitJobs
 } from '@shared/server-commands'
+import { getAllFiles } from '../shared'
 
 describe('Test update host scripts', function () {
   let server: PeerTubeServer
@@ -108,7 +109,7 @@ describe('Test update host scripts', function () {
 
     for (const video of data) {
       const videoDetails = await server.videos.get({ id: video.id })
-      const files = videoDetails.files.concat(videoDetails.streamingPlaylists[0].files)
+      const files = getAllFiles(videoDetails)
 
       expect(files).to.have.lengthOf(8)
 
diff --git a/server/tests/feeds/feeds.ts b/server/tests/feeds/feeds.ts
index 4dcd77cca..320dc3333 100644
--- a/server/tests/feeds/feeds.ts
+++ b/server/tests/feeds/feeds.ts
@@ -3,6 +3,7 @@
 import 'mocha'
 import * as chai from 'chai'
 import { XMLParser, XMLValidator } from 'fast-xml-parser'
+import { HttpStatusCode, VideoPrivacy } from '@shared/models'
 import {
   cleanupTests,
   createMultipleServers,
@@ -11,9 +12,9 @@ import {
   makeGetRequest,
   PeerTubeServer,
   setAccessTokensToServers,
+  setDefaultChannelAvatar,
   waitJobs
 } from '@shared/server-commands'
-import { HttpStatusCode, VideoPrivacy } from '@shared/models'
 
 chai.use(require('chai-xml'))
 chai.use(require('chai-json-schema'))
@@ -44,6 +45,7 @@ describe('Test syndication feeds', () => {
     })
 
     await setAccessTokensToServers([ ...servers, serverHLSOnly ])
+    await setDefaultChannelAvatar(servers[0])
     await doubleFollow(servers[0], servers[1])
 
     {
diff --git a/server/tests/fixtures/avatar-resized.gif b/server/tests/fixtures/avatar-resized-120x120.gif
index 81a82189e..81a82189e 100644
--- a/server/tests/fixtures/avatar-resized.gif
+++ b/server/tests/fixtures/avatar-resized-120x120.gif
diff --git a/server/tests/fixtures/avatar-resized.png b/server/tests/fixtures/avatar-resized-120x120.png
index 9d84151f8..9d84151f8 100644
--- a/server/tests/fixtures/avatar-resized.png
+++ b/server/tests/fixtures/avatar-resized-120x120.png
diff --git a/server/tests/fixtures/avatar-resized-48x48.gif b/server/tests/fixtures/avatar-resized-48x48.gif
new file mode 100644
index 000000000..5900ff12e
--- /dev/null
+++ b/server/tests/fixtures/avatar-resized-48x48.gif
diff --git a/server/tests/fixtures/avatar-resized-48x48.png b/server/tests/fixtures/avatar-resized-48x48.png
new file mode 100644
index 000000000..9e5f3b490
--- /dev/null
+++ b/server/tests/fixtures/avatar-resized-48x48.png
diff --git a/server/tests/fixtures/avatar2-resized.png b/server/tests/fixtures/avatar2-resized-120x120.png
index 44149facb..44149facb 100644
--- a/server/tests/fixtures/avatar2-resized.png
+++ b/server/tests/fixtures/avatar2-resized-120x120.png
diff --git a/server/tests/fixtures/avatar2-resized-48x48.png b/server/tests/fixtures/avatar2-resized-48x48.png
new file mode 100644
index 000000000..bb3939b1a
--- /dev/null
+++ b/server/tests/fixtures/avatar2-resized-48x48.png
diff --git a/server/tests/fixtures/peertube-plugin-test/main.js b/server/tests/fixtures/peertube-plugin-test/main.js
index 90951d611..7715ab6e8 100644
--- a/server/tests/fixtures/peertube-plugin-test/main.js
+++ b/server/tests/fixtures/peertube-plugin-test/main.js
@@ -45,6 +45,16 @@ async function register ({ registerHook, registerSetting, settingsManager, stora
   })
 
   registerHook({
+    target: 'filter:api.video-playlist.videos.list.params',
+    handler: obj => addToCount(obj)
+  })
+
+  registerHook({
+    target: 'filter:api.video-playlist.videos.list.result',
+    handler: obj => addToTotal(obj)
+  })
+
+  registerHook({
     target: 'filter:api.accounts.videos.list.params',
     handler: obj => addToCount(obj)
   })
diff --git a/server/tests/plugins/filter-hooks.ts b/server/tests/plugins/filter-hooks.ts
index 52ba396e5..e0f25ca26 100644
--- a/server/tests/plugins/filter-hooks.ts
+++ b/server/tests/plugins/filter-hooks.ts
@@ -22,6 +22,7 @@ describe('Test plugin filter hooks', function () {
   let servers: PeerTubeServer[]
   let videoUUID: string
   let threadId: number
+  let videoPlaylistUUID: string
 
   before(async function () {
     this.timeout(60000)
@@ -33,9 +34,20 @@ describe('Test plugin filter hooks', function () {
 
     await servers[0].plugins.install({ path: PluginsCommand.getPluginTestPath() })
     await servers[0].plugins.install({ path: PluginsCommand.getPluginTestPath('-filter-translations') })
+    {
+      ({ uuid: videoPlaylistUUID } = await servers[0].playlists.create({
+        attributes: {
+          displayName: 'my super playlist',
+          privacy: VideoPlaylistPrivacy.PUBLIC,
+          description: 'my super description',
+          videoChannelId: servers[0].store.channel.id
+        }
+      }))
+    }
 
     for (let i = 0; i < 10; i++) {
-      await servers[0].videos.upload({ attributes: { name: 'default video ' + i } })
+      const video = await servers[0].videos.upload({ attributes: { name: 'default video ' + i } })
+      await servers[0].playlists.addElement({ playlistId: videoPlaylistUUID, attributes: { videoId: video.id } })
     }
 
     const { data } = await servers[0].videos.list()
@@ -69,6 +81,26 @@ describe('Test plugin filter hooks', function () {
     expect(total).to.equal(11)
   })
 
+  it('Should run filter:api.video-playlist.videos.list.params', async function () {
+    const { data } = await servers[0].playlists.listVideos({
+      count: 2,
+      playlistId: videoPlaylistUUID
+    })
+
+    // 1 plugin do +1 to the count parameter
+    expect(data).to.have.lengthOf(3)
+  })
+
+  it('Should run filter:api.video-playlist.videos.list.result', async function () {
+    const { total } = await servers[0].playlists.listVideos({
+      count: 0,
+      playlistId: videoPlaylistUUID
+    })
+
+    // Plugin do +1 to the total result
+    expect(total).to.equal(11)
+  })
+
   it('Should run filter:api.accounts.videos.list.params', async function () {
     const { data } = await servers[0].videos.listByAccount({ handle: 'root', start: 0, count: 2 })
 
@@ -410,13 +442,7 @@ describe('Test plugin filter hooks', function () {
     before(async function () {
       this.timeout(60000)
 
-      await servers[0].config.updateCustomSubConfig({
-        newConfig: {
-          transcoding: {
-            enabled: false
-          }
-        }
-      })
+      await servers[0].config.disableTranscoding()
 
       for (const name of [ 'bad embed', 'good embed' ]) {
         {
diff --git a/server/tests/plugins/plugin-transcoding.ts b/server/tests/plugins/plugin-transcoding.ts
index 5ab686472..49569f1fa 100644
--- a/server/tests/plugins/plugin-transcoding.ts
+++ b/server/tests/plugins/plugin-transcoding.ts
@@ -2,7 +2,8 @@
 
 import 'mocha'
 import { expect } from 'chai'
-import { getAudioStream, getVideoFileFPS, getVideoStreamFromFile } from '@server/helpers/ffprobe-utils'
+import { getAudioStream, getVideoStreamFPS, getVideoStream } from '@server/helpers/ffmpeg'
+import { VideoPrivacy } from '@shared/models'
 import {
   cleanupTests,
   createSingleServer,
@@ -13,7 +14,6 @@ import {
   testFfmpegStreamError,
   waitJobs
 } from '@shared/server-commands'
-import { VideoPrivacy } from '@shared/models'
 
 async function createLiveWrapper (server: PeerTubeServer) {
   const liveAttributes = {
@@ -92,7 +92,7 @@ describe('Test transcoding plugins', function () {
 
     async function checkLiveFPS (uuid: string, type: 'above' | 'below', fps: number) {
       const playlistUrl = `${server.url}/static/streaming-playlists/hls/${uuid}/0.m3u8`
-      const videoFPS = await getVideoFileFPS(playlistUrl)
+      const videoFPS = await getVideoStreamFPS(playlistUrl)
 
       if (type === 'above') {
         expect(videoFPS).to.be.above(fps)
@@ -252,7 +252,7 @@ describe('Test transcoding plugins', function () {
       const audioProbe = await getAudioStream(path)
       expect(audioProbe.audioStream.codec_name).to.equal('opus')
 
-      const videoProbe = await getVideoStreamFromFile(path)
+      const videoProbe = await getVideoStream(path)
       expect(videoProbe.codec_name).to.equal('vp9')
     })
 
@@ -269,7 +269,7 @@ describe('Test transcoding plugins', function () {
       const audioProbe = await getAudioStream(playlistUrl)
       expect(audioProbe.audioStream.codec_name).to.equal('opus')
 
-      const videoProbe = await getVideoStreamFromFile(playlistUrl)
+      const videoProbe = await getVideoStream(playlistUrl)
       expect(videoProbe.codec_name).to.equal('h264')
     })
   })
diff --git a/server/tests/shared/generate.ts b/server/tests/shared/generate.ts
index f806df2f5..9a57084e4 100644
--- a/server/tests/shared/generate.ts
+++ b/server/tests/shared/generate.ts
@@ -3,12 +3,12 @@ import ffmpeg from 'fluent-ffmpeg'
 import { ensureDir, pathExists } from 'fs-extra'
 import { dirname } from 'path'
 import { buildAbsoluteFixturePath, getMaxBitrate } from '@shared/core-utils'
-import { getVideoFileBitrate, getVideoFileFPS, getVideoFileResolution } from '@shared/extra-utils'
+import { getVideoStreamBitrate, getVideoStreamFPS, getVideoStreamDimensionsInfo } from '@shared/extra-utils'
 
 async function ensureHasTooBigBitrate (fixturePath: string) {
-  const bitrate = await getVideoFileBitrate(fixturePath)
-  const dataResolution = await getVideoFileResolution(fixturePath)
-  const fps = await getVideoFileFPS(fixturePath)
+  const bitrate = await getVideoStreamBitrate(fixturePath)
+  const dataResolution = await getVideoStreamDimensionsInfo(fixturePath)
+  const fps = await getVideoStreamFPS(fixturePath)
 
   const maxBitrate = getMaxBitrate({ ...dataResolution, fps })
   expect(bitrate).to.be.above(maxBitrate)
diff --git a/server/tests/shared/notifications.ts b/server/tests/shared/notifications.ts
index cdc21fdc8..78d3787f0 100644
--- a/server/tests/shared/notifications.ts
+++ b/server/tests/shared/notifications.ts
@@ -10,7 +10,14 @@ import {
   UserNotificationSettingValue,
   UserNotificationType
 } from '@shared/models'
-import { createMultipleServers, doubleFollow, PeerTubeServer, setAccessTokensToServers } from '@shared/server-commands'
+import {
+  createMultipleServers,
+  doubleFollow,
+  PeerTubeServer,
+  setAccessTokensToServers,
+  setDefaultAccountAvatar,
+  setDefaultChannelAvatar
+} from '@shared/server-commands'
 import { MockSmtpServer } from './mock-servers'
 
 type CheckerBaseParams = {
@@ -646,6 +653,8 @@ async function prepareNotificationsTest (serversCount = 3, overrideConfigArg: an
   const servers = await createMultipleServers(serversCount, Object.assign(overrideConfig, overrideConfigArg))
 
   await setAccessTokensToServers(servers)
+  await setDefaultChannelAvatar(servers)
+  await setDefaultAccountAvatar(servers)
 
   if (serversCount > 1) {
     await doubleFollow(servers[0], servers[1])
diff --git a/server/tests/shared/videos.ts b/server/tests/shared/videos.ts
index 6be094f2b..989865a49 100644
--- a/server/tests/shared/videos.ts
+++ b/server/tests/shared/videos.ts
@@ -240,6 +240,16 @@ async function uploadRandomVideoOnServers (
   return res
 }
 
+function getAllFiles (video: VideoDetails) {
+  const files = video.files
+
+  if (video.streamingPlaylists[0]) {
+    return files.concat(video.streamingPlaylists[0].files)
+  }
+
+  return files
+}
+
 // ---------------------------------------------------------------------------
 
 export {
@@ -247,5 +257,6 @@ export {
   checkUploadVideoParam,
   uploadRandomVideoOnServers,
   checkVideoFilesWereRemoved,
-  saveVideoInServers
+  saveVideoInServers,
+  getAllFiles
 }
diff --git a/server/types/express.d.ts b/server/types/express.d.ts
index 1a99b598a..91a8cf3d8 100644
--- a/server/types/express.d.ts
+++ b/server/types/express.d.ts
@@ -40,7 +40,7 @@ import {
   MVideoRedundancyVideo,
   MVideoShareActor,
   MVideoThumbnail
-} from '../../types/models'
+} from './models'
 import { Writable } from 'stream'
 
 declare module 'express' {
@@ -60,6 +60,7 @@ declare module 'express' {
   export type UploadFileForCheck = {
     originalname: string
     mimetype: string
+    size: number
   }
 
   export type UploadFilesForCheck = {
diff --git a/server/types/models/actor/actor-image.ts b/server/types/models/actor/actor-image.ts
index 521b4cc59..e8f32b71e 100644
--- a/server/types/models/actor/actor-image.ts
+++ b/server/types/models/actor/actor-image.ts
@@ -9,4 +9,4 @@ export type MActorImage = ActorImageModel
 
 export type MActorImageFormattable =
   FunctionProperties<MActorImage> &
-  Pick<MActorImage, 'filename' | 'createdAt' | 'updatedAt'>
+  Pick<MActorImage, 'width' | 'filename' | 'createdAt' | 'updatedAt'>
diff --git a/server/types/models/actor/actor.ts b/server/types/models/actor/actor.ts
index 9ce97094f..280256bab 100644
--- a/server/types/models/actor/actor.ts
+++ b/server/types/models/actor/actor.ts
@@ -10,7 +10,7 @@ type UseOpt<K extends keyof ActorModel, M> = PickWithOpt<ActorModel, K, M>
 
 // ############################################################################
 
-export type MActor = Omit<ActorModel, 'Account' | 'VideoChannel' | 'ActorFollowing' | 'Avatar' | 'ActorFollowers' | 'Server' | 'Banner'>
+export type MActor = Omit<ActorModel, 'Account' | 'VideoChannel' | 'ActorFollowing' | 'ActorFollowers' | 'Server' | 'Banners'>
 
 // ############################################################################
 
@@ -35,7 +35,7 @@ export type MActorRedundancyAllowedOpt = PickWithOpt<ActorModel, 'Server', MServ
 export type MActorDefaultLight =
   MActorLight &
   Use<'Server', MServerHost> &
-  Use<'Avatar', MActorImage>
+  Use<'Avatars', MActorImage[]>
 
 export type MActorAccountId =
   MActor &
@@ -78,13 +78,13 @@ export type MActorServer =
 
 export type MActorImages =
   MActor &
-  Use<'Avatar', MActorImage> &
-  UseOpt<'Banner', MActorImage>
+  Use<'Avatars', MActorImage[]> &
+  UseOpt<'Banners', MActorImage[]>
 
 export type MActorDefault =
   MActor &
   Use<'Server', MServer> &
-  Use<'Avatar', MActorImage>
+  Use<'Avatars', MActorImage[]>
 
 export type MActorDefaultChannelId =
   MActorDefault &
@@ -93,8 +93,8 @@ export type MActorDefaultChannelId =
 export type MActorDefaultBanner =
   MActor &
   Use<'Server', MServer> &
-  Use<'Avatar', MActorImage> &
-  Use<'Banner', MActorImage>
+  Use<'Avatars', MActorImage[]> &
+  Use<'Banners', MActorImage[]>
 
 // Actor with channel that is associated to an account and its actor
 // Actor -> VideoChannel -> Account -> Actor
@@ -105,8 +105,8 @@ export type MActorChannelAccountActor =
 export type MActorFull =
   MActor &
   Use<'Server', MServer> &
-  Use<'Avatar', MActorImage> &
-  Use<'Banner', MActorImage> &
+  Use<'Avatars', MActorImage[]> &
+  Use<'Banners', MActorImage[]> &
   Use<'Account', MAccount> &
   Use<'VideoChannel', MChannelAccountActor>
 
@@ -114,8 +114,8 @@ export type MActorFull =
 export type MActorFullActor =
   MActor &
   Use<'Server', MServer> &
-  Use<'Avatar', MActorImage> &
-  Use<'Banner', MActorImage> &
+  Use<'Avatars', MActorImage[]> &
+  Use<'Banners', MActorImage[]> &
   Use<'Account', MAccountDefault> &
   Use<'VideoChannel', MChannelAccountDefault>
 
@@ -125,9 +125,9 @@ export type MActorFullActor =
 
 export type MActorSummary =
   FunctionProperties<MActor> &
-  Pick<MActor, 'id' | 'preferredUsername' | 'url' | 'serverId' | 'avatarId'> &
+  Pick<MActor, 'id' | 'preferredUsername' | 'url' | 'serverId'> &
   Use<'Server', MServerHost> &
-  Use<'Avatar', MActorImage>
+  Use<'Avatars', MActorImage[]>
 
 export type MActorSummaryBlocks =
   MActorSummary &
@@ -145,21 +145,22 @@ export type MActorSummaryFormattable =
   FunctionProperties<MActor> &
   Pick<MActor, 'url' | 'preferredUsername'> &
   Use<'Server', MServerHost> &
-  Use<'Avatar', MActorImageFormattable>
+  Use<'Avatars', MActorImageFormattable[]>
 
 export type MActorFormattable =
   MActorSummaryFormattable &
-  Pick<MActor, 'id' | 'followingCount' | 'followersCount' | 'createdAt' | 'updatedAt' | 'remoteCreatedAt' | 'bannerId' | 'avatarId'> &
+  Pick<MActor, 'id' | 'followingCount' | 'followersCount' | 'createdAt' | 'updatedAt' | 'remoteCreatedAt'> &
   Use<'Server', MServerHost & Partial<Pick<MServer, 'redundancyAllowed'>>> &
-  UseOpt<'Banner', MActorImageFormattable>
+  UseOpt<'Banners', MActorImageFormattable[]> &
+  UseOpt<'Avatars', MActorImageFormattable[]>
 
 type MActorAPBase =
   MActor &
-  Use<'Avatar', MActorImage>
+  Use<'Avatars', MActorImage[]>
 
 export type MActorAPAccount =
   MActorAPBase
 
 export type MActorAPChannel =
   MActorAPBase &
-  Use<'Banner', MActorImage>
+  Use<'Banners', MActorImage[]>
diff --git a/server/types/models/user/user-notification.ts b/server/types/models/user/user-notification.ts
index db9ec0400..d4715a0b6 100644
--- a/server/types/models/user/user-notification.ts
+++ b/server/types/models/user/user-notification.ts
@@ -21,6 +21,7 @@ type Use<K extends keyof UserNotificationModel, M> = PickWith<UserNotificationMo
 // ############################################################################
 
 export module UserNotificationIncludes {
+  export type ActorImageInclude = Pick<ActorImageModel, 'createdAt' | 'filename' | 'getStaticPath' | 'width' | 'updatedAt'>
 
   export type VideoInclude = Pick<VideoModel, 'id' | 'uuid' | 'name'>
   export type VideoIncludeChannel =
@@ -29,7 +30,7 @@ export module UserNotificationIncludes {
 
   export type ActorInclude =
     Pick<ActorModel, 'preferredUsername' | 'getHost'> &
-    PickWith<ActorModel, 'Avatar', Pick<ActorImageModel, 'filename' | 'getStaticPath'>> &
+    PickWith<ActorModel, 'Avatars', ActorImageInclude[]> &
     PickWith<ActorModel, 'Server', Pick<ServerModel, 'host'>>
 
   export type VideoChannelInclude = Pick<VideoChannelModel, 'id' | 'name' | 'getDisplayName'>
@@ -75,7 +76,7 @@ export module UserNotificationIncludes {
     Pick<ActorModel, 'preferredUsername' | 'getHost'> &
     PickWith<ActorModel, 'Account', AccountInclude> &
     PickWith<ActorModel, 'Server', Pick<ServerModel, 'host'>> &
-    PickWithOpt<ActorModel, 'Avatar', Pick<ActorImageModel, 'filename' | 'getStaticPath'>>
+    PickWithOpt<ActorModel, 'Avatars', ActorImageInclude[]>
 
   export type ActorFollowing =
     Pick<ActorModel, 'preferredUsername' | 'type' | 'getHost'> &
@@ -98,7 +99,7 @@ export module UserNotificationIncludes {
 // ############################################################################
 
 export type MUserNotification =
-  Omit<UserNotificationModel, 'User' | 'Video' | 'Comment' | 'Abuse' | 'VideoBlacklist' |
+  Omit<UserNotificationModel, 'User' | 'Video' | 'VideoComment' | 'Abuse' | 'VideoBlacklist' |
   'VideoImport' | 'Account' | 'ActorFollow' | 'Plugin' | 'Application'>
 
 // ############################################################################
@@ -106,7 +107,7 @@ export type MUserNotification =
 export type UserNotificationModelForApi =
   MUserNotification &
   Use<'Video', UserNotificationIncludes.VideoIncludeChannel> &
-  Use<'Comment', UserNotificationIncludes.VideoCommentInclude> &
+  Use<'VideoComment', UserNotificationIncludes.VideoCommentInclude> &
   Use<'Abuse', UserNotificationIncludes.AbuseInclude> &
   Use<'VideoBlacklist', UserNotificationIncludes.VideoBlacklistInclude> &
   Use<'VideoImport', UserNotificationIncludes.VideoImportInclude> &