server/lib/transcoding/shared/job-builders/transcoding-job-queue-builder.ts

   1 import Bluebird from 'bluebird'
   2 import { computeOutputFPS } from '@server/helpers/ffmpeg'
   3 import { logger } from '@server/helpers/logger'
   4 import { CONFIG } from '@server/initializers/config'
   5 import { DEFAULT_AUDIO_RESOLUTION, VIDEO_TRANSCODING_FPS } from '@server/initializers/constants'
   6 import { CreateJobArgument, JobQueue } from '@server/lib/job-queue'
   7 import { Hooks } from '@server/lib/plugins/hooks'
   8 import { VideoPathManager } from '@server/lib/video-path-manager'
   9 import { VideoJobInfoModel } from '@server/models/video/video-job-info'
  10 import { MUserId, MVideoFile, MVideoFullLight, MVideoWithFileThumbnail } from '@server/types/models'
  11 import { ffprobePromise, getVideoStreamDimensionsInfo, getVideoStreamFPS, hasAudioStream, isAudioFile } from '@shared/ffmpeg'
  12 import {
  13   HLSTranscodingPayload,
  14   MergeAudioTranscodingPayload,
  15   NewWebTorrentResolutionTranscodingPayload,
  16   OptimizeTranscodingPayload,
  17   VideoTranscodingPayload
  18 } from '@shared/models'
  19 import { canDoQuickTranscode } from '../../transcoding-quick-transcode'
  20 import { computeResolutionsToTranscode } from '../../transcoding-resolutions'
  21 import { AbstractJobBuilder } from './abstract-job-builder'
  22
  23 export class TranscodingJobQueueBuilder extends AbstractJobBuilder {
  24
  25   async createOptimizeOrMergeAudioJobs (options: {
  26     video: MVideoFullLight
  27     videoFile: MVideoFile
  28     isNewVideo: boolean
  29     user: MUserId
  30     videoFileAlreadyLocked: boolean
  31   }) {
  32     const { video, videoFile, isNewVideo, user, videoFileAlreadyLocked } = options
  33
  34     let mergeOrOptimizePayload: MergeAudioTranscodingPayload | OptimizeTranscodingPayload
  35     let nextTranscodingSequentialJobPayloads: (NewWebTorrentResolutionTranscodingPayload | HLSTranscodingPayload)[][] = []
  36
  37     const mutexReleaser = videoFileAlreadyLocked
  38       ? () => {}
  39       : await VideoPathManager.Instance.lockFiles(video.uuid)
  40
  41     try {
  42       await VideoPathManager.Instance.makeAvailableVideoFile(videoFile.withVideoOrPlaylist(video), async videoFilePath => {
  43         const probe = await ffprobePromise(videoFilePath)
  44
  45         const { resolution } = await getVideoStreamDimensionsInfo(videoFilePath, probe)
  46         const hasAudio = await hasAudioStream(videoFilePath, probe)
  47         const quickTranscode = await canDoQuickTranscode(videoFilePath, probe)
  48         const inputFPS = videoFile.isAudio()
  49           ? VIDEO_TRANSCODING_FPS.AUDIO_MERGE // The first transcoding job will transcode to this FPS value
  50           : await getVideoStreamFPS(videoFilePath, probe)
  51
  52         const maxResolution = await isAudioFile(videoFilePath, probe)
  53           ? DEFAULT_AUDIO_RESOLUTION
  54           : resolution
  55
  56         if (CONFIG.TRANSCODING.HLS.ENABLED === true) {
  57           nextTranscodingSequentialJobPayloads.push([
  58             this.buildHLSJobPayload({
  59               deleteWebTorrentFiles: CONFIG.TRANSCODING.WEBTORRENT.ENABLED === false,
  60
  61               // We had some issues with a web video quick transcoded while producing a HLS version of it
  62               copyCodecs: !quickTranscode,
  63
  64               resolution: maxResolution,
  65               fps: computeOutputFPS({ inputFPS, resolution: maxResolution }),
  66               videoUUID: video.uuid,
  67               isNewVideo
  68             })
  69           ])
  70         }
  71
  72         const lowerResolutionJobPayloads = await this.buildLowerResolutionJobPayloads({
  73           video,
  74           inputVideoResolution: maxResolution,
  75           inputVideoFPS: inputFPS,
  76           hasAudio,
  77           isNewVideo
  78         })
  79
  80         nextTranscodingSequentialJobPayloads = [ ...nextTranscodingSequentialJobPayloads, ...lowerResolutionJobPayloads ]
  81
  82         const hasChildren = nextTranscodingSequentialJobPayloads.length !== 0
  83         mergeOrOptimizePayload = videoFile.isAudio()
  84           ? this.buildMergeAudioPayload({ videoUUID: video.uuid, isNewVideo, hasChildren })
  85           : this.buildOptimizePayload({ videoUUID: video.uuid, isNewVideo, quickTranscode, hasChildren })
  86       })
  87     } finally {
  88       mutexReleaser()
  89     }
  90
  91     const nextTranscodingSequentialJobs = await Bluebird.mapSeries(nextTranscodingSequentialJobPayloads, payloads => {
  92       return Bluebird.mapSeries(payloads, payload => {
  93         return this.buildTranscodingJob({ payload, user })
  94       })
  95     })
  96
  97     const transcodingJobBuilderJob: CreateJobArgument = {
  98       type: 'transcoding-job-builder',
  99       payload: {
 100         videoUUID: video.uuid,
 101         sequentialJobs: nextTranscodingSequentialJobs
 102       }
 103     }
 104
 105     const mergeOrOptimizeJob = await this.buildTranscodingJob({ payload: mergeOrOptimizePayload, user })
 106
 107     await JobQueue.Instance.createSequentialJobFlow(...[ mergeOrOptimizeJob, transcodingJobBuilderJob ])
 108
 109     await VideoJobInfoModel.increaseOrCreate(video.uuid, 'pendingTranscode')
 110   }
 111
 112   // ---------------------------------------------------------------------------
 113
 114   async createTranscodingJobs (options: {
 115     transcodingType: 'hls' | 'webtorrent'
 116     video: MVideoFullLight
 117     resolutions: number[]
 118     isNewVideo: boolean
 119     user: MUserId | null
 120   }) {
 121     const { video, transcodingType, resolutions, isNewVideo } = options
 122
 123     const maxResolution = Math.max(...resolutions)
 124     const childrenResolutions = resolutions.filter(r => r !== maxResolution)
 125
 126     logger.info('Manually creating transcoding jobs for %s.', transcodingType, { childrenResolutions, maxResolution })
 127
 128     const { fps: inputFPS } = await video.probeMaxQualityFile()
 129
 130     const children = childrenResolutions.map(resolution => {
 131       const fps = computeOutputFPS({ inputFPS, resolution })
 132
 133       if (transcodingType === 'hls') {
 134         return this.buildHLSJobPayload({ videoUUID: video.uuid, resolution, fps, isNewVideo })
 135       }
 136
 137       if (transcodingType === 'webtorrent') {
 138         return this.buildWebTorrentJobPayload({ videoUUID: video.uuid, resolution, fps, isNewVideo })
 139       }
 140
 141       throw new Error('Unknown transcoding type')
 142     })
 143
 144     const fps = computeOutputFPS({ inputFPS, resolution: maxResolution })
 145
 146     const parent = transcodingType === 'hls'
 147       ? this.buildHLSJobPayload({ videoUUID: video.uuid, resolution: maxResolution, fps, isNewVideo })
 148       : this.buildWebTorrentJobPayload({ videoUUID: video.uuid, resolution: maxResolution, fps, isNewVideo })
 149
 150     // Process the last resolution after the other ones to prevent concurrency issue
 151     // Because low resolutions use the biggest one as ffmpeg input
 152     await this.createTranscodingJobsWithChildren({ videoUUID: video.uuid, parent, children, user: null })
 153   }
 154
 155   // ---------------------------------------------------------------------------
 156
 157   private async createTranscodingJobsWithChildren (options: {
 158     videoUUID: string
 159     parent: (HLSTranscodingPayload | NewWebTorrentResolutionTranscodingPayload)
 160     children: (HLSTranscodingPayload | NewWebTorrentResolutionTranscodingPayload)[]
 161     user: MUserId | null
 162   }) {
 163     const { videoUUID, parent, children, user } = options
 164
 165     const parentJob = await this.buildTranscodingJob({ payload: parent, user })
 166     const childrenJobs = await Bluebird.mapSeries(children, c => this.buildTranscodingJob({ payload: c, user }))
 167
 168     await JobQueue.Instance.createJobWithChildren(parentJob, childrenJobs)
 169
 170     await VideoJobInfoModel.increaseOrCreate(videoUUID, 'pendingTranscode', 1 + children.length)
 171   }
 172
 173   private async buildTranscodingJob (options: {
 174     payload: VideoTranscodingPayload
 175     user: MUserId | null // null means we don't want priority
 176   }) {
 177     const { user, payload } = options
 178
 179     return {
 180       type: 'video-transcoding' as 'video-transcoding',
 181       priority: await this.getTranscodingJobPriority({ user, fallback: undefined }),
 182       payload
 183     }
 184   }
 185
 186   private async buildLowerResolutionJobPayloads (options: {
 187     video: MVideoWithFileThumbnail
 188     inputVideoResolution: number
 189     inputVideoFPS: number
 190     hasAudio: boolean
 191     isNewVideo: boolean
 192   }) {
 193     const { video, inputVideoResolution, inputVideoFPS, isNewVideo, hasAudio } = options
 194
 195     // Create transcoding jobs if there are enabled resolutions
 196     const resolutionsEnabled = await Hooks.wrapObject(
 197       computeResolutionsToTranscode({ input: inputVideoResolution, type: 'vod', includeInput: false, strictLower: true, hasAudio }),
 198       'filter:transcoding.auto.resolutions-to-transcode.result',
 199       options
 200     )
 201
 202     const sequentialPayloads: (NewWebTorrentResolutionTranscodingPayload | HLSTranscodingPayload)[][] = []
 203
 204     for (const resolution of resolutionsEnabled) {
 205       const fps = computeOutputFPS({ inputFPS: inputVideoFPS, resolution })
 206
 207       if (CONFIG.TRANSCODING.WEBTORRENT.ENABLED) {
 208         const payloads: (NewWebTorrentResolutionTranscodingPayload | HLSTranscodingPayload)[] = [
 209           this.buildWebTorrentJobPayload({
 210             videoUUID: video.uuid,
 211             resolution,
 212             fps,
 213             isNewVideo
 214           })
 215         ]
 216
 217         // Create a subsequent job to create HLS resolution that will just copy web video codecs
 218         if (CONFIG.TRANSCODING.HLS.ENABLED) {
 219           payloads.push(
 220             this.buildHLSJobPayload({
 221               videoUUID: video.uuid,
 222               resolution,
 223               fps,
 224               isNewVideo,
 225               copyCodecs: true
 226             })
 227           )
 228         }
 229
 230         sequentialPayloads.push(payloads)
 231       } else if (CONFIG.TRANSCODING.HLS.ENABLED) {
 232         sequentialPayloads.push([
 233           this.buildHLSJobPayload({
 234             videoUUID: video.uuid,
 235             resolution,
 236             fps,
 237             copyCodecs: false,
 238             isNewVideo
 239           })
 240         ])
 241       }
 242     }
 243
 244     return sequentialPayloads
 245   }
 246
 247   private buildHLSJobPayload (options: {
 248     videoUUID: string
 249     resolution: number
 250     fps: number
 251     isNewVideo: boolean
 252     deleteWebTorrentFiles?: boolean // default false
 253     copyCodecs?: boolean // default false
 254   }): HLSTranscodingPayload {
 255     const { videoUUID, resolution, fps, isNewVideo, deleteWebTorrentFiles = false, copyCodecs = false } = options
 256
 257     return {
 258       type: 'new-resolution-to-hls',
 259       videoUUID,
 260       resolution,
 261       fps,
 262       copyCodecs,
 263       isNewVideo,
 264       deleteWebTorrentFiles
 265     }
 266   }
 267
 268   private buildWebTorrentJobPayload (options: {
 269     videoUUID: string
 270     resolution: number
 271     fps: number
 272     isNewVideo: boolean
 273   }): NewWebTorrentResolutionTranscodingPayload {
 274     const { videoUUID, resolution, fps, isNewVideo } = options
 275
 276     return {
 277       type: 'new-resolution-to-webtorrent',
 278       videoUUID,
 279       isNewVideo,
 280       resolution,
 281       fps
 282     }
 283   }
 284
 285   private buildMergeAudioPayload (options: {
 286     videoUUID: string
 287     isNewVideo: boolean
 288     hasChildren: boolean
 289   }): MergeAudioTranscodingPayload {
 290     const { videoUUID, isNewVideo, hasChildren } = options
 291
 292     return {
 293       type: 'merge-audio-to-webtorrent',
 294       resolution: DEFAULT_AUDIO_RESOLUTION,
 295       fps: VIDEO_TRANSCODING_FPS.AUDIO_MERGE,
 296       videoUUID,
 297       isNewVideo,
 298       hasChildren
 299     }
 300   }
 301
 302   private buildOptimizePayload (options: {
 303     videoUUID: string
 304     quickTranscode: boolean
 305     isNewVideo: boolean
 306     hasChildren: boolean
 307   }): OptimizeTranscodingPayload {
 308     const { videoUUID, quickTranscode, isNewVideo, hasChildren } = options
 309
 310     return {
 311       type: 'optimize-to-webtorrent',
 312       videoUUID,
 313       isNewVideo,
 314       hasChildren,
 315       quickTranscode
 316     }
 317   }
 318 }