21 files changed, 204 insertions, 69 deletions

diff --git a/server/lib/activitypub/process/process-create.ts b/server/lib/activitypub/process/process-create.ts
index 3e7931bb2..76ed37aae 100644
--- a/server/lib/activitypub/process/process-create.ts
+++ b/server/lib/activitypub/process/process-create.ts
@@ -124,7 +124,7 @@ async function processCreateVideoComment (activity: ActivityCreate, byActor: MAc
     return
   }
 
-  // Try to not forward unwanted commments on our videos
+  // Try to not forward unwanted comments on our videos
   if (video.isOwned()) {
     if (await isBlockedByServerOrAccount(comment.Account, video.VideoChannel.Account)) {
       logger.info('Skip comment forward from blocked account or server %s.', comment.Account.Actor.url)
diff --git a/server/lib/activitypub/videos/shared/creator.ts b/server/lib/activitypub/videos/shared/creator.ts
index 688bcbb53..07252fea2 100644
--- a/server/lib/activitypub/videos/shared/creator.ts
+++ b/server/lib/activitypub/videos/shared/creator.ts
@@ -24,7 +24,7 @@ export class APVideoCreator extends APVideoAbstractBuilder {
     const channel = channelActor.VideoChannel
 
     const videoData = getVideoAttributesFromObject(channel, this.videoObject, this.videoObject.to)
-    const video = VideoModel.build(videoData) as MVideoThumbnail
+    const video = VideoModel.build({ ...videoData, likes: 0, dislikes: 0 }) as MVideoThumbnail
 
     const promiseThumbnail = this.tryToGenerateThumbnail(video)
 
diff --git a/server/lib/activitypub/videos/shared/object-to-model-attributes.ts b/server/lib/activitypub/videos/shared/object-to-model-attributes.ts
index f02b9cba6..86699c5b8 100644
--- a/server/lib/activitypub/videos/shared/object-to-model-attributes.ts
+++ b/server/lib/activitypub/videos/shared/object-to-model-attributes.ts
@@ -210,8 +210,6 @@ function getVideoAttributesFromObject (videoChannel: MChannelId, videoObject: Vi
 
     updatedAt: new Date(videoObject.updated),
     views: videoObject.views,
-    likes: 0,
-    dislikes: 0,
     remote: true,
     privacy
   }
diff --git a/server/lib/client-html.ts b/server/lib/client-html.ts
index 337364ac9..1e8d03023 100644
--- a/server/lib/client-html.ts
+++ b/server/lib/client-html.ts
@@ -30,6 +30,7 @@ import { MAccountActor, MChannelActor } from '../types/models'
 import { getActivityStreamDuration } from './activitypub/activity'
 import { getBiggestActorImage } from './actor-image'
 import { ServerConfigManager } from './server-config-manager'
+import { isTestInstance } from '@server/helpers/core-utils'
 
 type Tags = {
   ogType: string
@@ -232,7 +233,10 @@ class ClientHtml {
   static async getEmbedHTML () {
     const path = ClientHtml.getEmbedPath()
 
-    if (ClientHtml.htmlCache[path]) return ClientHtml.htmlCache[path]
+    // Disable HTML cache in dev mode because webpack can regenerate JS files
+    if (!isTestInstance() && ClientHtml.htmlCache[path]) {
+      return ClientHtml.htmlCache[path]
+    }
 
     const buffer = await readFile(path)
     const serverConfig = await ServerConfigManager.Instance.getHTMLServerConfig()
diff --git a/server/lib/emailer.ts b/server/lib/emailer.ts
index aebca04fe..edc99057c 100644
--- a/server/lib/emailer.ts
+++ b/server/lib/emailer.ts
@@ -179,7 +179,7 @@ class Emailer {
         }
       }
 
-      // overriden/new variables given for a specific template in the payload
+      // overridden/new variables given for a specific template in the payload
       const sendOptions = merge(baseOptions, options)
 
       await email.send(sendOptions)
diff --git a/server/lib/job-queue/handlers/move-to-object-storage.ts b/server/lib/job-queue/handlers/move-to-object-storage.ts
index f480b32cd..49064052c 100644
--- a/server/lib/job-queue/handlers/move-to-object-storage.ts
+++ b/server/lib/job-queue/handlers/move-to-object-storage.ts
@@ -48,15 +48,24 @@ export async function processMoveToObjectStorage (job: Job) {
       await doAfterLastJob({ video, previousVideoState: payload.previousVideoState, isNewVideo: payload.isNewVideo })
     }
   } catch (err) {
-    logger.error('Cannot move video %s to object storage.', video.url, { err, ...lTags })
-
-    await moveToFailedMoveToObjectStorageState(video)
-    await VideoJobInfoModel.abortAllTasks(video.uuid, 'pendingMove')
+    await onMoveToObjectStorageFailure(job, err)
   }
 
   return payload.videoUUID
 }
 
+export async function onMoveToObjectStorageFailure (job: Job, err: any) {
+  const payload = job.data as MoveObjectStoragePayload
+
+  const video = await VideoModel.loadWithFiles(payload.videoUUID)
+  if (!video) return
+
+  logger.error('Cannot move video %s to object storage.', video.url, { err, ...lTagsBase(video.uuid, video.url) })
+
+  await moveToFailedMoveToObjectStorageState(video)
+  await VideoJobInfoModel.abortAllTasks(video.uuid, 'pendingMove')
+}
+
 // ---------------------------------------------------------------------------
 
 async function moveWebTorrentFiles (video: MVideoWithAllFiles) {
diff --git a/server/lib/job-queue/job-queue.ts b/server/lib/job-queue/job-queue.ts
index f339e9135..ce24763f1 100644
--- a/server/lib/job-queue/job-queue.ts
+++ b/server/lib/job-queue/job-queue.ts
@@ -33,7 +33,7 @@ import { refreshAPObject } from './handlers/activitypub-refresher'
 import { processActorKeys } from './handlers/actor-keys'
 import { processEmail } from './handlers/email'
 import { processManageVideoTorrent } from './handlers/manage-video-torrent'
-import { processMoveToObjectStorage } from './handlers/move-to-object-storage'
+import { onMoveToObjectStorageFailure, processMoveToObjectStorage } from './handlers/move-to-object-storage'
 import { processVideoFileImport } from './handlers/video-file-import'
 import { processVideoImport } from './handlers/video-import'
 import { processVideoLiveEnding } from './handlers/video-live-ending'
@@ -88,6 +88,10 @@ const handlers: { [id in JobType]: (job: Job) => Promise<any> } = {
   'video-studio-edition': processVideoStudioEdition
 }
 
+const errorHandlers: { [id in JobType]?: (job: Job, err: any) => Promise<any> } = {
+  'move-to-object-storage': onMoveToObjectStorageFailure
+}
+
 const jobTypes: JobType[] = [
   'activitypub-follow',
   'activitypub-http-broadcast',
@@ -162,6 +166,11 @@ class JobQueue {
           : 'error'
 
         logger.log(logLevel, 'Cannot execute job %d in queue %s.', job.id, handlerName, { payload: job.data, err })
+
+        if (errorHandlers[job.name]) {
+          errorHandlers[job.name](job, err)
+            .catch(err => logger.error('Cannot run error handler for job failure %d in queue %s.', job.id, handlerName, { err }))
+        }
       })
 
       queue.on('error', err => {
diff --git a/server/lib/local-actor.ts b/server/lib/local-actor.ts
index 01046d017..1d9be76e2 100644
--- a/server/lib/local-actor.ts
+++ b/server/lib/local-actor.ts
@@ -1,4 +1,3 @@
-import { queue } from 'async'
 import { remove } from 'fs-extra'
 import LRUCache from 'lru-cache'
 import { join } from 'path'
@@ -7,14 +6,13 @@ import { getLowercaseExtension } from '@shared/core-utils'
 import { buildUUID } from '@shared/extra-utils'
 import { ActivityPubActorType, ActorImageType } from '@shared/models'
 import { retryTransactionWrapper } from '../helpers/database-utils'
-import { processImage } from '../helpers/image-utils'
-import { downloadImage } from '../helpers/requests'
 import { CONFIG } from '../initializers/config'
-import { ACTOR_IMAGES_SIZE, LRU_CACHE, QUEUE_CONCURRENCY, WEBSERVER } from '../initializers/constants'
+import { ACTOR_IMAGES_SIZE, LRU_CACHE, WEBSERVER } from '../initializers/constants'
 import { sequelizeTypescript } from '../initializers/database'
 import { MAccountDefault, MActor, MChannelDefault } from '../types/models'
 import { deleteActorImages, updateActorImages } from './activitypub/actors'
 import { sendUpdateActor } from './activitypub/send'
+import { downloadImageFromWorker, processImageFromWorker } from './worker/parent-process'
 
 function buildActorInstance (type: ActivityPubActorType, url: string, preferredUsername: string) {
   return new ActorModel({
@@ -43,7 +41,7 @@ async function updateLocalActorImageFiles (
 
     const imageName = buildUUID() + extension
     const destination = join(CONFIG.STORAGE.ACTOR_IMAGES, imageName)
-    await processImage(imagePhysicalFile.path, destination, imageSize, true)
+    await processImageFromWorker({ path: imagePhysicalFile.path, destination, newSize: imageSize, keepOriginal: true })
 
     return {
       imageName,
@@ -87,27 +85,22 @@ async function deleteLocalActorImageFile (accountOrChannel: MAccountDefault | MC
   })
 }
 
-type DownloadImageQueueTask = {
+// ---------------------------------------------------------------------------
+
+function downloadActorImageFromWorker (options: {
   fileUrl: string
   filename: string
   type: ActorImageType
   size: typeof ACTOR_IMAGES_SIZE[ActorImageType][0]
-}
-
-const downloadImageQueue = queue<DownloadImageQueueTask, Error>((task, cb) => {
-  downloadImage(task.fileUrl, CONFIG.STORAGE.ACTOR_IMAGES, task.filename, task.size)
-    .then(() => cb())
-    .catch(err => cb(err))
-}, QUEUE_CONCURRENCY.ACTOR_PROCESS_IMAGE)
-
-function pushActorImageProcessInQueue (task: DownloadImageQueueTask) {
-  return new Promise<void>((res, rej) => {
-    downloadImageQueue.push(task, err => {
-      if (err) return rej(err)
+}) {
+  const downloaderOptions = {
+    url: options.fileUrl,
+    destDir: CONFIG.STORAGE.ACTOR_IMAGES,
+    destName: options.filename,
+    size: options.size
+  }
 
-      return res()
-    })
-  })
+  return downloadImageFromWorker(downloaderOptions)
 }
 
 // Unsafe so could returns paths that does not exist anymore
@@ -116,7 +109,8 @@ const actorImagePathUnsafeCache = new LRUCache<string, string>({ max: LRU_CACHE.
 export {
   actorImagePathUnsafeCache,
   updateLocalActorImageFiles,
+  downloadActorImageFromWorker,
   deleteLocalActorImageFile,
-  pushActorImageProcessInQueue,
+  downloadImageFromWorker,
   buildActorInstance
 }
diff --git a/server/lib/notifier/shared/abuse/abstract-new-abuse-message.ts b/server/lib/notifier/shared/abuse/abstract-new-abuse-message.ts
index daefa25bd..a7292de69 100644
--- a/server/lib/notifier/shared/abuse/abstract-new-abuse-message.ts
+++ b/server/lib/notifier/shared/abuse/abstract-new-abuse-message.ts
@@ -5,7 +5,7 @@ import { MAbuseFull, MAbuseMessage, MAccountDefault, MUserWithNotificationSettin
 import { UserNotificationType } from '@shared/models'
 import { AbstractNotification } from '../common/abstract-notification'
 
-export type NewAbuseMessagePayload = {
+type NewAbuseMessagePayload = {
   abuse: MAbuseFull
   message: MAbuseMessage
 }
diff --git a/server/lib/redis.ts b/server/lib/redis.ts
index d052de786..d6d053d2f 100644
--- a/server/lib/redis.ts
+++ b/server/lib/redis.ts
@@ -1,4 +1,4 @@
-import { createClient, RedisClientOptions, RedisModules, RedisScripts } from 'redis'
+import { createClient, RedisClientOptions, RedisModules } from 'redis'
 import { exists } from '@server/helpers/custom-validators/misc'
 import { sha256 } from '@shared/extra-utils'
 import { logger } from '../helpers/logger'
@@ -16,16 +16,12 @@ import {
   WEBSERVER
 } from '../initializers/constants'
 
-// Only used for typings
-// TODO: remove when https://github.com/microsoft/TypeScript/issues/37181 is fixed
-const redisClientWrapperForType = () => createClient<{}, RedisScripts>()
-
 class Redis {
 
   private static instance: Redis
   private initialized = false
   private connected = false
-  private client: ReturnType<typeof redisClientWrapperForType>
+  private client: ReturnType<typeof createClient>
   private prefix: string
 
   private constructor () {
@@ -308,7 +304,7 @@ class Redis {
     return this.deleteKey('resumable-upload-' + uploadId)
   }
 
-  /* ************ AP ressource unavailability ************ */
+  /* ************ AP resource unavailability ************ */
 
   async addAPUnavailability (url: string) {
     const key = this.generateAPUnavailabilityKey(url)
diff --git a/server/lib/schedulers/geo-ip-update-scheduler.ts b/server/lib/schedulers/geo-ip-update-scheduler.ts
index 9dda6d76c..b06f5a9b5 100644
--- a/server/lib/schedulers/geo-ip-update-scheduler.ts
+++ b/server/lib/schedulers/geo-ip-update-scheduler.ts
@@ -6,7 +6,7 @@ export class GeoIPUpdateScheduler extends AbstractScheduler {
 
   private static instance: AbstractScheduler
 
-  protected schedulerIntervalMs = SCHEDULER_INTERVALS_MS.YOUTUBE_DL_UPDATE
+  protected schedulerIntervalMs = SCHEDULER_INTERVALS_MS.GEO_IP_UPDATE
 
   private constructor () {
     super()
diff --git a/server/lib/signup.ts b/server/lib/signup.ts
index 3c1397a12..f094531eb 100644
--- a/server/lib/signup.ts
+++ b/server/lib/signup.ts
@@ -26,7 +26,7 @@ function isSignupAllowedForCurrentIP (ip: string) {
   const excludeList = [ 'blacklist' ]
   let matched = ''
 
-  // if there is a valid, non-empty whitelist, we exclude all unknown adresses too
+  // if there is a valid, non-empty whitelist, we exclude all unknown addresses too
   if (CONFIG.SIGNUP.FILTERS.CIDR.WHITELIST.filter(cidr => isCidr(cidr)).length > 0) {
     excludeList.push('unknown')
   }
diff --git a/server/lib/thumbnail.ts b/server/lib/thumbnail.ts
index aa2d7a813..02b867a91 100644
--- a/server/lib/thumbnail.ts
+++ b/server/lib/thumbnail.ts
@@ -1,14 +1,15 @@
 import { join } from 'path'
 import { ThumbnailType } from '@shared/models'
-import { generateImageFilename, generateImageFromVideoFile, processImage } from '../helpers/image-utils'
-import { downloadImage } from '../helpers/requests'
+import { generateImageFilename, generateImageFromVideoFile } from '../helpers/image-utils'
 import { CONFIG } from '../initializers/config'
 import { ASSETS_PATH, PREVIEWS_SIZE, THUMBNAILS_SIZE } from '../initializers/constants'
 import { ThumbnailModel } from '../models/video/thumbnail'
 import { MVideoFile, MVideoThumbnail, MVideoUUID } from '../types/models'
 import { MThumbnail } from '../types/models/video/thumbnail'
 import { MVideoPlaylistThumbnail } from '../types/models/video/video-playlist'
+import { downloadImageFromWorker } from './local-actor'
 import { VideoPathManager } from './video-path-manager'
+import { processImageFromWorker } from './worker/parent-process'
 
 type ImageSize = { height?: number, width?: number }
 
@@ -23,7 +24,10 @@ function updatePlaylistMiniatureFromExisting (options: {
   const { filename, outputPath, height, width, existingThumbnail } = buildMetadataFromPlaylist(playlist, size)
   const type = ThumbnailType.MINIATURE
 
-  const thumbnailCreator = () => processImage(inputPath, outputPath, { width, height }, keepOriginal)
+  const thumbnailCreator = () => {
+    return processImageFromWorker({ path: inputPath, destination: outputPath, newSize: { width, height }, keepOriginal })
+  }
+
   return updateThumbnailFromFunction({
     thumbnailCreator,
     filename,
@@ -49,7 +53,10 @@ function updatePlaylistMiniatureFromUrl (options: {
     ? null
     : downloadUrl
 
-  const thumbnailCreator = () => downloadImage(downloadUrl, basePath, filename, { width, height })
+  const thumbnailCreator = () => {
+    return downloadImageFromWorker({ url: downloadUrl, destDir: basePath, destName: filename, size: { width, height } })
+  }
+
   return updateThumbnailFromFunction({ thumbnailCreator, filename, height, width, type, existingThumbnail, fileUrl })
 }
 
@@ -75,7 +82,9 @@ function updateVideoMiniatureFromUrl (options: {
     : existingThumbnail.filename
 
   const thumbnailCreator = () => {
-    if (thumbnailUrlChanged) return downloadImage(downloadUrl, basePath, filename, { width, height })
+    if (thumbnailUrlChanged) {
+      return downloadImageFromWorker({ url: downloadUrl, destDir: basePath, destName: filename, size: { width, height } })
+    }
 
     return Promise.resolve()
   }
@@ -94,7 +103,10 @@ function updateVideoMiniatureFromExisting (options: {
   const { inputPath, video, type, automaticallyGenerated, size, keepOriginal = false } = options
 
   const { filename, outputPath, height, width, existingThumbnail } = buildMetadataFromVideo(video, type, size)
-  const thumbnailCreator = () => processImage(inputPath, outputPath, { width, height }, keepOriginal)
+
+  const thumbnailCreator = () => {
+    return processImageFromWorker({ path: inputPath, destination: outputPath, newSize: { width, height }, keepOriginal })
+  }
 
   return updateThumbnailFromFunction({
     thumbnailCreator,
@@ -118,8 +130,18 @@ function generateVideoMiniature (options: {
     const { filename, basePath, height, width, existingThumbnail, outputPath } = buildMetadataFromVideo(video, type)
 
     const thumbnailCreator = videoFile.isAudio()
-      ? () => processImage(ASSETS_PATH.DEFAULT_AUDIO_BACKGROUND, outputPath, { width, height }, true)
-      : () => generateImageFromVideoFile(input, basePath, filename, { height, width })
+      ? () => processImageFromWorker({
+        path: ASSETS_PATH.DEFAULT_AUDIO_BACKGROUND,
+        destination: outputPath,
+        newSize: { width, height },
+        keepOriginal: true
+      })
+      : () => generateImageFromVideoFile({
+        fromPath: input,
+        folder: basePath,
+        imageName: filename,
+        size: { height, width }
+      })
 
     return updateThumbnailFromFunction({
       thumbnailCreator,
diff --git a/server/lib/video.ts b/server/lib/video.ts
index a98e45c60..86718abbe 100644
--- a/server/lib/video.ts
+++ b/server/lib/video.ts
@@ -1,6 +1,6 @@
 import { UploadFiles } from 'express'
 import { Transaction } from 'sequelize/types'
-import { DEFAULT_AUDIO_RESOLUTION, JOB_PRIORITY } from '@server/initializers/constants'
+import { DEFAULT_AUDIO_RESOLUTION, JOB_PRIORITY, MEMOIZE_LENGTH, MEMOIZE_TTL } from '@server/initializers/constants'
 import { TagModel } from '@server/models/video/tag'
 import { VideoModel } from '@server/models/video/video'
 import { VideoJobInfoModel } from '@server/models/video/video-job-info'
@@ -10,6 +10,7 @@ import { ThumbnailType, VideoCreate, VideoPrivacy, VideoState, VideoTranscodingP
 import { CreateJobOptions, JobQueue } from './job-queue/job-queue'
 import { updateVideoMiniatureFromExisting } from './thumbnail'
 import { CONFIG } from '@server/initializers/config'
+import memoizee from 'memoizee'
 
 function buildLocalVideoFromReq (videoInfo: VideoCreate, channelId: number): FilteredModelAttributes<VideoModel> {
   return {
@@ -150,6 +151,24 @@ async function addMoveToObjectStorageJob (options: {
 
 // ---------------------------------------------------------------------------
 
+async function getVideoDuration (videoId: number | string) {
+  const video = await VideoModel.load(videoId)
+
+  const duration = video.isLive
+    ? undefined
+    : video.duration
+
+  return { duration, isLive: video.isLive }
+}
+
+const getCachedVideoDuration = memoizee(getVideoDuration, {
+  promise: true,
+  max: MEMOIZE_LENGTH.VIDEO_DURATION,
+  maxAge: MEMOIZE_TTL.VIDEO_DURATION
+})
+
+// ---------------------------------------------------------------------------
+
 export {
   buildLocalVideoFromReq,
   buildVideoThumbnailsFromReq,
@@ -157,5 +176,6 @@ export {
   addOptimizeOrMergeAudioJob,
   addTranscodingJob,
   addMoveToObjectStorageJob,
-  getTranscodingJobPriority
+  getTranscodingJobPriority,
+  getCachedVideoDuration
 }
diff --git a/server/lib/views/shared/video-viewer-counters.ts b/server/lib/views/shared/video-viewer-counters.ts
index 5158f8f93..cf3fa5882 100644
--- a/server/lib/views/shared/video-viewer-counters.ts
+++ b/server/lib/views/shared/video-viewer-counters.ts
@@ -5,7 +5,7 @@ import { sendView } from '@server/lib/activitypub/send/send-view'
 import { PeerTubeSocket } from '@server/lib/peertube-socket'
 import { getServerActor } from '@server/models/application/application'
 import { VideoModel } from '@server/models/video/video'
-import { MVideo } from '@server/types/models'
+import { MVideo, MVideoImmutable } from '@server/types/models'
 import { buildUUID, sha256 } from '@shared/extra-utils'
 
 const lTags = loggerTagsFactory('views')
@@ -33,7 +33,7 @@ export class VideoViewerCounters {
   // ---------------------------------------------------------------------------
 
   async addLocalViewer (options: {
-    video: MVideo
+    video: MVideoImmutable
     ip: string
   }) {
     const { video, ip } = options
@@ -86,7 +86,7 @@ export class VideoViewerCounters {
   // ---------------------------------------------------------------------------
 
   private async addViewerToVideo (options: {
-    video: MVideo
+    video: MVideoImmutable
     viewerId: string
     viewerExpires?: Date
   }) {
@@ -162,7 +162,7 @@ export class VideoViewerCounters {
     return sha256(this.salt + '-' + ip + '-' + videoUUID)
   }
 
-  private async federateViewerIfNeeded (video: MVideo, viewer: Viewer) {
+  private async federateViewerIfNeeded (video: MVideoImmutable, viewer: Viewer) {
     // Federate the viewer if it's been a "long" time we did not
     const now = new Date().getTime()
     const federationLimit = now - (VIEW_LIFETIME.VIEWER_COUNTER * 0.75)
diff --git a/server/lib/views/shared/video-viewer-stats.ts b/server/lib/views/shared/video-viewer-stats.ts
index a9ba25b47..a56c20559 100644
--- a/server/lib/views/shared/video-viewer-stats.ts
+++ b/server/lib/views/shared/video-viewer-stats.ts
@@ -10,7 +10,7 @@ import { Redis } from '@server/lib/redis'
 import { VideoModel } from '@server/models/video/video'
 import { LocalVideoViewerModel } from '@server/models/view/local-video-viewer'
 import { LocalVideoViewerWatchSectionModel } from '@server/models/view/local-video-viewer-watch-section'
-import { MVideo } from '@server/types/models'
+import { MVideo, MVideoImmutable } from '@server/types/models'
 import { VideoViewEvent } from '@shared/models'
 
 const lTags = loggerTagsFactory('views')
@@ -41,7 +41,7 @@ export class VideoViewerStats {
   // ---------------------------------------------------------------------------
 
   async addLocalViewer (options: {
-    video: MVideo
+    video: MVideoImmutable
     currentTime: number
     ip: string
     viewEvent?: VideoViewEvent
@@ -64,7 +64,7 @@ export class VideoViewerStats {
   // ---------------------------------------------------------------------------
 
   private async updateLocalViewerStats (options: {
-    video: MVideo
+    video: MVideoImmutable
     ip: string
     currentTime: number
     viewEvent?: VideoViewEvent
diff --git a/server/lib/views/shared/video-views.ts b/server/lib/views/shared/video-views.ts
index 275f7a014..e563287e1 100644
--- a/server/lib/views/shared/video-views.ts
+++ b/server/lib/views/shared/video-views.ts
@@ -1,7 +1,8 @@
 import { logger, loggerTagsFactory } from '@server/helpers/logger'
 import { sendView } from '@server/lib/activitypub/send/send-view'
+import { getCachedVideoDuration } from '@server/lib/video'
 import { getServerActor } from '@server/models/application/application'
-import { MVideo } from '@server/types/models'
+import { MVideo, MVideoImmutable } from '@server/types/models'
 import { buildUUID } from '@shared/extra-utils'
 import { Redis } from '../../redis'
 
@@ -10,7 +11,7 @@ const lTags = loggerTagsFactory('views')
 export class VideoViews {
 
   async addLocalView (options: {
-    video: MVideo
+    video: MVideoImmutable
     ip: string
     watchTime: number
   }) {
@@ -18,7 +19,7 @@ export class VideoViews {
 
     logger.debug('Adding local view to video %s.', video.uuid, { watchTime, ...lTags(video.uuid) })
 
-    if (!this.hasEnoughWatchTime(video, watchTime)) return false
+    if (!await this.hasEnoughWatchTime(video, watchTime)) return false
 
     const viewExists = await Redis.Instance.doesVideoIPViewExist(ip, video.uuid)
     if (viewExists) return false
@@ -46,7 +47,7 @@ export class VideoViews {
 
   // ---------------------------------------------------------------------------
 
-  private async addView (video: MVideo) {
+  private async addView (video: MVideoImmutable) {
     const promises: Promise<any>[] = []
 
     if (video.isOwned()) {
@@ -58,10 +59,12 @@ export class VideoViews {
     await Promise.all(promises)
   }
 
-  private hasEnoughWatchTime (video: MVideo, watchTime: number) {
-    if (video.isLive || video.duration >= 30) return watchTime >= 30
+  private async hasEnoughWatchTime (video: MVideoImmutable, watchTime: number) {
+    const { duration, isLive } = await getCachedVideoDuration(video.id)
+
+    if (isLive || duration >= 30) return watchTime >= 30
 
     // Check more than 50% of the video is watched
-    return video.duration / watchTime < 2
+    return duration / watchTime < 2
   }
 }
diff --git a/server/lib/views/video-views-manager.ts b/server/lib/views/video-views-manager.ts
index ea3b35c6c..86758e8d8 100644
--- a/server/lib/views/video-views-manager.ts
+++ b/server/lib/views/video-views-manager.ts
@@ -1,5 +1,5 @@
 import { logger, loggerTagsFactory } from '@server/helpers/logger'
-import { MVideo } from '@server/types/models'
+import { MVideo, MVideoImmutable } from '@server/types/models'
 import { VideoViewEvent } from '@shared/models'
 import { VideoViewerCounters, VideoViewerStats, VideoViews } from './shared'
 
@@ -41,7 +41,7 @@ export class VideoViewsManager {
   }
 
   async processLocalView (options: {
-    video: MVideo
+    video: MVideoImmutable
     currentTime: number
     ip: string | null
     viewEvent?: VideoViewEvent
diff --git a/server/lib/worker/parent-process.ts b/server/lib/worker/parent-process.ts
new file mode 100644
index 000000000..4bc7f2620
--- /dev/null
+++ b/server/lib/worker/parent-process.ts
@@ -0,0 +1,40 @@
+import { join } from 'path'
+import Piscina from 'piscina'
+import { processImage } from '@server/helpers/image-utils'
+import { WORKER_THREADS } from '@server/initializers/constants'
+import { downloadImage } from './workers/image-downloader'
+
+let downloadImageWorker: Piscina
+
+function downloadImageFromWorker (options: Parameters<typeof downloadImage>[0]): Promise<ReturnType<typeof downloadImage>> {
+  if (!downloadImageWorker) {
+    downloadImageWorker = new Piscina({
+      filename: join(__dirname, 'workers', 'image-downloader.js'),
+      concurrentTasksPerWorker: WORKER_THREADS.DOWNLOAD_IMAGE.CONCURRENCY,
+      maxThreads: WORKER_THREADS.DOWNLOAD_IMAGE.MAX_THREADS
+    })
+  }
+
+  return downloadImageWorker.run(options)
+}
+
+// ---------------------------------------------------------------------------
+
+let processImageWorker: Piscina
+
+function processImageFromWorker (options: Parameters<typeof processImage>[0]): Promise<ReturnType<typeof processImage>> {
+  if (!processImageWorker) {
+    processImageWorker = new Piscina({
+      filename: join(__dirname, 'workers', 'image-processor.js'),
+      concurrentTasksPerWorker: WORKER_THREADS.PROCESS_IMAGE.CONCURRENCY,
+      maxThreads: WORKER_THREADS.PROCESS_IMAGE.MAX_THREADS
+    })
+  }
+
+  return processImageWorker.run(options)
+}
+
+export {
+  downloadImageFromWorker,
+  processImageFromWorker
+}
diff --git a/server/lib/worker/workers/image-downloader.ts b/server/lib/worker/workers/image-downloader.ts
new file mode 100644
index 000000000..4b32f723e
--- /dev/null
+++ b/server/lib/worker/workers/image-downloader.ts
@@ -0,0 +1,33 @@
+import { remove } from 'fs-extra'
+import { join } from 'path'
+import { processImage } from '@server/helpers/image-utils'
+import { doRequestAndSaveToFile } from '@server/helpers/requests'
+import { CONFIG } from '@server/initializers/config'
+
+async function downloadImage (options: {
+  url: string
+  destDir: string
+  destName: string
+  size: { width: number, height: number }
+}) {
+  const { url, destDir, destName, size } = options
+
+  const tmpPath = join(CONFIG.STORAGE.TMP_DIR, 'pending-' + destName)
+  await doRequestAndSaveToFile(url, tmpPath)
+
+  const destPath = join(destDir, destName)
+
+  try {
+    await processImage({ path: tmpPath, destination: destPath, newSize: size })
+  } catch (err) {
+    await remove(tmpPath)
+
+    throw err
+  }
+}
+
+module.exports = downloadImage
+
+export {
+  downloadImage
+}
diff --git a/server/lib/worker/workers/image-processor.ts b/server/lib/worker/workers/image-processor.ts
new file mode 100644
index 000000000..0ab41a5a0
--- /dev/null
+++ b/server/lib/worker/workers/image-processor.ts
@@ -0,0 +1,7 @@
+import { processImage } from '@server/helpers/image-utils'
+
+module.exports = processImage
+
+export {
+  processImage
+}