server/lib/job-queue/handlers/video-transcoding.ts

   1 import { Job } from 'bull'
   2 import { TranscodeOptionsType } from '@server/helpers/ffmpeg-utils'
   3 import { addTranscodingJob, getTranscodingJobPriority } from '@server/lib/video'
   4 import { VideoPathManager } from '@server/lib/video-path-manager'
   5 import { moveToFailedTranscodingState, moveToNextState } from '@server/lib/video-state'
   6 import { UserModel } from '@server/models/user/user'
   7 import { VideoJobInfoModel } from '@server/models/video/video-job-info'
   8 import { MUser, MUserId, MVideo, MVideoFullLight, MVideoWithFile } from '@server/types/models'
   9 import {
  10   HLSTranscodingPayload,
  11   MergeAudioTranscodingPayload,
  12   NewResolutionTranscodingPayload,
  13   OptimizeTranscodingPayload,
  14   VideoTranscodingPayload
  15 } from '../../../../shared'
  16 import { retryTransactionWrapper } from '../../../helpers/database-utils'
  17 import { computeResolutionsToTranscode } from '../../../helpers/ffprobe-utils'
  18 import { logger, loggerTagsFactory } from '../../../helpers/logger'
  19 import { CONFIG } from '../../../initializers/config'
  20 import { VideoModel } from '../../../models/video/video'
  21 import {
  22   generateHlsPlaylistResolution,
  23   mergeAudioVideofile,
  24   optimizeOriginalVideofile,
  25   transcodeNewWebTorrentResolution
  26 } from '../../transcoding/video-transcoding'
  27
  28 type HandlerFunction = (job: Job, payload: VideoTranscodingPayload, video: MVideoFullLight, user: MUser) => Promise<void>
  29
  30 const handlers: { [ id in VideoTranscodingPayload['type'] ]: HandlerFunction } = {
  31   'new-resolution-to-hls': handleHLSJob,
  32   'new-resolution-to-webtorrent': handleNewWebTorrentResolutionJob,
  33   'merge-audio-to-webtorrent': handleWebTorrentMergeAudioJob,
  34   'optimize-to-webtorrent': handleWebTorrentOptimizeJob
  35 }
  36
  37 const lTags = loggerTagsFactory('transcoding')
  38
  39 async function processVideoTranscoding (job: Job) {
  40   const payload = job.data as VideoTranscodingPayload
  41   logger.info('Processing transcoding job %d.', job.id, lTags(payload.videoUUID))
  42
  43   const video = await VideoModel.loadAndPopulateAccountAndServerAndTags(payload.videoUUID)
  44   // No video, maybe deleted?
  45   if (!video) {
  46     logger.info('Do not process job %d, video does not exist.', job.id, lTags(payload.videoUUID))
  47     return undefined
  48   }
  49
  50   const user = await UserModel.loadByChannelActorId(video.VideoChannel.actorId)
  51
  52   const handler = handlers[payload.type]
  53
  54   if (!handler) {
  55     await moveToFailedTranscodingState(video)
  56
  57     throw new Error('Cannot find transcoding handler for ' + payload.type)
  58   }
  59
  60   try {
  61     await handler(job, payload, video, user)
  62   } catch (error) {
  63     await moveToFailedTranscodingState(video)
  64
  65     throw error
  66   }
  67
  68   return video
  69 }
  70
  71 // ---------------------------------------------------------------------------
  72 // Job handlers
  73 // ---------------------------------------------------------------------------
  74
  75 async function handleHLSJob (job: Job, payload: HLSTranscodingPayload, video: MVideoFullLight, user: MUser) {
  76   logger.info('Handling HLS transcoding job for %s.', video.uuid, lTags(video.uuid))
  77
  78   const videoFileInput = payload.copyCodecs
  79     ? video.getWebTorrentFile(payload.resolution)
  80     : video.getMaxQualityFile()
  81
  82   const videoOrStreamingPlaylist = videoFileInput.getVideoOrStreamingPlaylist()
  83
  84   await VideoPathManager.Instance.makeAvailableVideoFile(videoOrStreamingPlaylist, videoFileInput, videoInputPath => {
  85     return generateHlsPlaylistResolution({
  86       video,
  87       videoInputPath,
  88       resolution: payload.resolution,
  89       copyCodecs: payload.copyCodecs,
  90       isPortraitMode: payload.isPortraitMode || false,
  91       job
  92     })
  93   })
  94
  95   logger.info('HLS transcoding job for %s ended.', video.uuid, lTags(video.uuid))
  96
  97   await retryTransactionWrapper(onHlsPlaylistGeneration, video, user, payload)
  98 }
  99
 100 async function handleNewWebTorrentResolutionJob (
 101   job: Job,
 102   payload: NewResolutionTranscodingPayload,
 103   video: MVideoFullLight,
 104   user: MUserId
 105 ) {
 106   logger.info('Handling WebTorrent transcoding job for %s.', video.uuid, lTags(video.uuid))
 107
 108   await transcodeNewWebTorrentResolution(video, payload.resolution, payload.isPortraitMode || false, job)
 109
 110   logger.info('WebTorrent transcoding job for %s ended.', video.uuid, lTags(video.uuid))
 111
 112   await retryTransactionWrapper(onNewWebTorrentFileResolution, video, user, payload)
 113 }
 114
 115 async function handleWebTorrentMergeAudioJob (job: Job, payload: MergeAudioTranscodingPayload, video: MVideoFullLight, user: MUserId) {
 116   logger.info('Handling merge audio transcoding job for %s.', video.uuid, lTags(video.uuid))
 117
 118   await mergeAudioVideofile(video, payload.resolution, job)
 119
 120   logger.info('Merge audio transcoding job for %s ended.', video.uuid, lTags(video.uuid))
 121
 122   await retryTransactionWrapper(onVideoFileOptimizer, video, payload, 'video', user)
 123 }
 124
 125 async function handleWebTorrentOptimizeJob (job: Job, payload: OptimizeTranscodingPayload, video: MVideoFullLight, user: MUserId) {
 126   logger.info('Handling optimize transcoding job for %s.', video.uuid, lTags(video.uuid))
 127
 128   const { transcodeType } = await optimizeOriginalVideofile(video, video.getMaxQualityFile(), job)
 129
 130   logger.info('Optimize transcoding job for %s ended.', video.uuid, lTags(video.uuid))
 131
 132   await retryTransactionWrapper(onVideoFileOptimizer, video, payload, transcodeType, user)
 133 }
 134
 135 // ---------------------------------------------------------------------------
 136
 137 async function onHlsPlaylistGeneration (video: MVideoFullLight, user: MUser, payload: HLSTranscodingPayload) {
 138   if (payload.isMaxQuality && CONFIG.TRANSCODING.WEBTORRENT.ENABLED === false) {
 139     // Remove webtorrent files if not enabled
 140     for (const file of video.VideoFiles) {
 141       await video.removeWebTorrentFileAndTorrent(file)
 142       await file.destroy()
 143     }
 144
 145     video.VideoFiles = []
 146
 147     // Create HLS new resolution jobs
 148     await createLowerResolutionsJobs({
 149       video,
 150       user,
 151       videoFileResolution: payload.resolution,
 152       isPortraitMode: payload.isPortraitMode,
 153       isNewVideo: payload.isNewVideo ?? true,
 154       type: 'hls'
 155     })
 156   }
 157
 158   await VideoJobInfoModel.decrease(video.uuid, 'pendingTranscode')
 159   await moveToNextState(video, payload.isNewVideo)
 160 }
 161
 162 async function onVideoFileOptimizer (
 163   videoArg: MVideoWithFile,
 164   payload: OptimizeTranscodingPayload | MergeAudioTranscodingPayload,
 165   transcodeType: TranscodeOptionsType,
 166   user: MUserId
 167 ) {
 168   const { resolution, isPortraitMode } = await videoArg.getMaxQualityResolution()
 169
 170   // Maybe the video changed in database, refresh it
 171   const videoDatabase = await VideoModel.loadAndPopulateAccountAndServerAndTags(videoArg.uuid)
 172   // Video does not exist anymore
 173   if (!videoDatabase) return undefined
 174
 175   // Generate HLS version of the original file
 176   const originalFileHLSPayload = {
 177     ...payload,
 178
 179     isPortraitMode,
 180     resolution: videoDatabase.getMaxQualityFile().resolution,
 181     // If we quick transcoded original file, force transcoding for HLS to avoid some weird playback issues
 182     copyCodecs: transcodeType !== 'quick-transcode',
 183     isMaxQuality: true
 184   }
 185   const hasHls = await createHlsJobIfEnabled(user, originalFileHLSPayload)
 186   const hasNewResolutions = await createLowerResolutionsJobs({
 187     video: videoDatabase,
 188     user,
 189     videoFileResolution: resolution,
 190     isPortraitMode,
 191     type: 'webtorrent',
 192     isNewVideo: payload.isNewVideo ?? true
 193   })
 194
 195   await VideoJobInfoModel.decrease(videoDatabase.uuid, 'pendingTranscode')
 196
 197   // Move to next state if there are no other resolutions to generate
 198   if (!hasHls && !hasNewResolutions) {
 199     await moveToNextState(videoDatabase, payload.isNewVideo)
 200   }
 201 }
 202
 203 async function onNewWebTorrentFileResolution (
 204   video: MVideo,
 205   user: MUserId,
 206   payload: NewResolutionTranscodingPayload | MergeAudioTranscodingPayload
 207 ) {
 208   await createHlsJobIfEnabled(user, { ...payload, copyCodecs: true, isMaxQuality: false })
 209   await VideoJobInfoModel.decrease(video.uuid, 'pendingTranscode')
 210
 211   await moveToNextState(video, payload.isNewVideo)
 212 }
 213
 214 async function createHlsJobIfEnabled (user: MUserId, payload: {
 215   videoUUID: string
 216   resolution: number
 217   isPortraitMode?: boolean
 218   copyCodecs: boolean
 219   isMaxQuality: boolean
 220   isNewVideo?: boolean
 221 }) {
 222   if (!payload || CONFIG.TRANSCODING.ENABLED !== true || CONFIG.TRANSCODING.HLS.ENABLED !== true) return false
 223
 224   const jobOptions = {
 225     priority: await getTranscodingJobPriority(user)
 226   }
 227
 228   const hlsTranscodingPayload: HLSTranscodingPayload = {
 229     type: 'new-resolution-to-hls',
 230     videoUUID: payload.videoUUID,
 231     resolution: payload.resolution,
 232     isPortraitMode: payload.isPortraitMode,
 233     copyCodecs: payload.copyCodecs,
 234     isMaxQuality: payload.isMaxQuality,
 235     isNewVideo: payload.isNewVideo
 236   }
 237
 238   await addTranscodingJob(hlsTranscodingPayload, jobOptions)
 239
 240   return true
 241 }
 242
 243 // ---------------------------------------------------------------------------
 244
 245 export {
 246   processVideoTranscoding,
 247   createHlsJobIfEnabled,
 248   onNewWebTorrentFileResolution
 249 }
 250
 251 // ---------------------------------------------------------------------------
 252
 253 async function createLowerResolutionsJobs (options: {
 254   video: MVideoFullLight
 255   user: MUserId
 256   videoFileResolution: number
 257   isPortraitMode: boolean
 258   isNewVideo: boolean
 259   type: 'hls' | 'webtorrent'
 260 }) {
 261   const { video, user, videoFileResolution, isPortraitMode, isNewVideo, type } = options
 262
 263   // Create transcoding jobs if there are enabled resolutions
 264   const resolutionsEnabled = computeResolutionsToTranscode(videoFileResolution, 'vod')
 265   const resolutionCreated: string[] = []
 266
 267   for (const resolution of resolutionsEnabled) {
 268     let dataInput: VideoTranscodingPayload
 269
 270     if (CONFIG.TRANSCODING.WEBTORRENT.ENABLED && type === 'webtorrent') {
 271       // WebTorrent will create subsequent HLS job
 272       dataInput = {
 273         type: 'new-resolution-to-webtorrent',
 274         videoUUID: video.uuid,
 275         resolution,
 276         isPortraitMode,
 277         isNewVideo
 278       }
 279
 280       resolutionCreated.push('webtorrent-' + resolution)
 281     }
 282
 283     if (CONFIG.TRANSCODING.HLS.ENABLED && type === 'hls') {
 284       dataInput = {
 285         type: 'new-resolution-to-hls',
 286         videoUUID: video.uuid,
 287         resolution,
 288         isPortraitMode,
 289         copyCodecs: false,
 290         isMaxQuality: false,
 291         isNewVideo
 292       }
 293
 294       resolutionCreated.push('hls-' + resolution)
 295     }
 296
 297     if (!dataInput) continue
 298
 299     const jobOptions = {
 300       priority: await getTranscodingJobPriority(user)
 301     }
 302
 303     await addTranscodingJob(dataInput, jobOptions)
 304   }
 305
 306   if (resolutionCreated.length === 0) {
 307     logger.info('No transcoding jobs created for video %s (no resolutions).', video.uuid, lTags(video.uuid))
 308
 309     return false
 310   }
 311
 312   logger.info(
 313     'New resolutions %s transcoding jobs created for video %s and origin file resolution of %d.', type, video.uuid, videoFileResolution,
 314     { resolutionCreated, ...lTags(video.uuid) }
 315   )
 316
 317   return true
 318 }