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 { pick } from '@shared/core-utils'
11 HLSTranscodingPayload,
12 MergeAudioTranscodingPayload,
13 NewWebTorrentResolutionTranscodingPayload,
14 OptimizeTranscodingPayload,
16 VideoTranscodingPayload
17 } from '@shared/models'
18 import { retryTransactionWrapper } from '../../../helpers/database-utils'
19 import { computeLowerResolutionsToTranscode } from '../../../helpers/ffprobe-utils'
20 import { logger, loggerTagsFactory } from '../../../helpers/logger'
21 import { CONFIG } from '../../../initializers/config'
22 import { VideoModel } from '../../../models/video/video'
24 generateHlsPlaylistResolution,
26 optimizeOriginalVideofile,
27 transcodeNewWebTorrentResolution
28 } from '../../transcoding/video-transcoding'
30 type HandlerFunction = (job: Job, payload: VideoTranscodingPayload, video: MVideoFullLight, user: MUser) => Promise<void>
32 const handlers: { [ id in VideoTranscodingPayload['type'] ]: HandlerFunction } = {
33 'new-resolution-to-hls': handleHLSJob,
34 'new-resolution-to-webtorrent': handleNewWebTorrentResolutionJob,
35 'merge-audio-to-webtorrent': handleWebTorrentMergeAudioJob,
36 'optimize-to-webtorrent': handleWebTorrentOptimizeJob
39 const lTags = loggerTagsFactory('transcoding')
41 async function processVideoTranscoding (job: Job) {
42 const payload = job.data as VideoTranscodingPayload
43 logger.info('Processing transcoding job %d.', job.id, lTags(payload.videoUUID))
45 const video = await VideoModel.loadAndPopulateAccountAndServerAndTags(payload.videoUUID)
46 // No video, maybe deleted?
48 logger.info('Do not process job %d, video does not exist.', job.id, lTags(payload.videoUUID))
52 const user = await UserModel.loadByChannelActorId(video.VideoChannel.actorId)
54 const handler = handlers[payload.type]
57 await moveToFailedTranscodingState(video)
58 await VideoJobInfoModel.decrease(video.uuid, 'pendingTranscode')
60 throw new Error('Cannot find transcoding handler for ' + payload.type)
64 await handler(job, payload, video, user)
66 await moveToFailedTranscodingState(video)
68 await VideoJobInfoModel.decrease(video.uuid, 'pendingTranscode')
76 // ---------------------------------------------------------------------------
79 processVideoTranscoding
82 // ---------------------------------------------------------------------------
84 // ---------------------------------------------------------------------------
86 async function handleHLSJob (job: Job, payload: HLSTranscodingPayload, video: MVideoFullLight, user: MUser) {
87 logger.info('Handling HLS transcoding job for %s.', video.uuid, lTags(video.uuid))
89 const videoFileInput = payload.copyCodecs
90 ? video.getWebTorrentFile(payload.resolution)
91 : video.getMaxQualityFile()
93 const videoOrStreamingPlaylist = videoFileInput.getVideoOrStreamingPlaylist()
95 await VideoPathManager.Instance.makeAvailableVideoFile(videoFileInput.withVideoOrPlaylist(videoOrStreamingPlaylist), videoInputPath => {
96 return generateHlsPlaylistResolution({
99 resolution: payload.resolution,
100 copyCodecs: payload.copyCodecs,
101 isPortraitMode: payload.isPortraitMode || false,
106 logger.info('HLS transcoding job for %s ended.', video.uuid, lTags(video.uuid))
108 await onHlsPlaylistGeneration(video, user, payload)
111 async function handleNewWebTorrentResolutionJob (
113 payload: NewWebTorrentResolutionTranscodingPayload,
114 video: MVideoFullLight,
117 logger.info('Handling WebTorrent transcoding job for %s.', video.uuid, lTags(video.uuid))
119 await transcodeNewWebTorrentResolution(video, payload.resolution, payload.isPortraitMode || false, job)
121 logger.info('WebTorrent transcoding job for %s ended.', video.uuid, lTags(video.uuid))
123 await onNewWebTorrentFileResolution(video, user, payload)
126 async function handleWebTorrentMergeAudioJob (job: Job, payload: MergeAudioTranscodingPayload, video: MVideoFullLight, user: MUserId) {
127 logger.info('Handling merge audio transcoding job for %s.', video.uuid, lTags(video.uuid))
129 await mergeAudioVideofile(video, payload.resolution, job)
131 logger.info('Merge audio transcoding job for %s ended.', video.uuid, lTags(video.uuid))
133 await onVideoFirstWebTorrentTranscoding(video, payload, 'video', user)
136 async function handleWebTorrentOptimizeJob (job: Job, payload: OptimizeTranscodingPayload, video: MVideoFullLight, user: MUserId) {
137 logger.info('Handling optimize transcoding job for %s.', video.uuid, lTags(video.uuid))
139 const { transcodeType } = await optimizeOriginalVideofile(video, video.getMaxQualityFile(), job)
141 logger.info('Optimize transcoding job for %s ended.', video.uuid, lTags(video.uuid))
143 await onVideoFirstWebTorrentTranscoding(video, payload, transcodeType, user)
146 // ---------------------------------------------------------------------------
148 async function onHlsPlaylistGeneration (video: MVideoFullLight, user: MUser, payload: HLSTranscodingPayload) {
149 if (payload.isMaxQuality && payload.autoDeleteWebTorrentIfNeeded && CONFIG.TRANSCODING.WEBTORRENT.ENABLED === false) {
150 // Remove webtorrent files if not enabled
151 for (const file of video.VideoFiles) {
152 await video.removeWebTorrentFileAndTorrent(file)
156 video.VideoFiles = []
158 // Create HLS new resolution jobs
159 await createLowerResolutionsJobs({
162 videoFileResolution: payload.resolution,
163 isPortraitMode: payload.isPortraitMode,
164 hasAudio: payload.hasAudio,
165 isNewVideo: payload.isNewVideo ?? true,
170 await VideoJobInfoModel.decrease(video.uuid, 'pendingTranscode')
171 await retryTransactionWrapper(moveToNextState, video, payload.isNewVideo)
174 async function onVideoFirstWebTorrentTranscoding (
175 videoArg: MVideoWithFile,
176 payload: OptimizeTranscodingPayload | MergeAudioTranscodingPayload,
177 transcodeType: TranscodeOptionsType,
180 const { resolution, isPortraitMode, audioStream } = await videoArg.getMaxQualityFileInfo()
182 // Maybe the video changed in database, refresh it
183 const videoDatabase = await VideoModel.loadAndPopulateAccountAndServerAndTags(videoArg.uuid)
184 // Video does not exist anymore
185 if (!videoDatabase) return undefined
187 // Generate HLS version of the original file
188 const originalFileHLSPayload = {
192 hasAudio: !!audioStream,
193 resolution: videoDatabase.getMaxQualityFile().resolution,
194 // If we quick transcoded original file, force transcoding for HLS to avoid some weird playback issues
195 copyCodecs: transcodeType !== 'quick-transcode',
198 const hasHls = await createHlsJobIfEnabled(user, originalFileHLSPayload)
199 const hasNewResolutions = await createLowerResolutionsJobs({
200 video: videoDatabase,
202 videoFileResolution: resolution,
203 hasAudio: !!audioStream,
206 isNewVideo: payload.isNewVideo ?? true
209 await VideoJobInfoModel.decrease(videoDatabase.uuid, 'pendingTranscode')
211 // Move to next state if there are no other resolutions to generate
212 if (!hasHls && !hasNewResolutions) {
213 await retryTransactionWrapper(moveToNextState, videoDatabase, payload.isNewVideo)
217 async function onNewWebTorrentFileResolution (
220 payload: NewWebTorrentResolutionTranscodingPayload | MergeAudioTranscodingPayload
222 if (payload.createHLSIfNeeded) {
223 await createHlsJobIfEnabled(user, { hasAudio: true, copyCodecs: true, isMaxQuality: false, ...payload })
226 await VideoJobInfoModel.decrease(video.uuid, 'pendingTranscode')
228 await retryTransactionWrapper(moveToNextState, video, payload.isNewVideo)
231 // ---------------------------------------------------------------------------
233 async function createHlsJobIfEnabled (user: MUserId, payload: {
237 isPortraitMode?: boolean
239 isMaxQuality: boolean
242 if (!payload || CONFIG.TRANSCODING.ENABLED !== true || CONFIG.TRANSCODING.HLS.ENABLED !== true) return false
245 priority: await getTranscodingJobPriority(user)
248 const hlsTranscodingPayload: HLSTranscodingPayload = {
249 type: 'new-resolution-to-hls',
250 autoDeleteWebTorrentIfNeeded: true,
252 ...pick(payload, [ 'videoUUID', 'resolution', 'isPortraitMode', 'copyCodecs', 'isMaxQuality', 'isNewVideo', 'hasAudio' ])
255 await addTranscodingJob(hlsTranscodingPayload, jobOptions)
260 async function createLowerResolutionsJobs (options: {
261 video: MVideoFullLight
263 videoFileResolution: number
264 isPortraitMode: boolean
267 type: 'hls' | 'webtorrent'
269 const { video, user, videoFileResolution, isPortraitMode, isNewVideo, hasAudio, type } = options
271 // Create transcoding jobs if there are enabled resolutions
272 const resolutionsEnabled = computeLowerResolutionsToTranscode(videoFileResolution, 'vod')
273 const resolutionCreated: string[] = []
275 for (const resolution of resolutionsEnabled) {
276 if (resolution === VideoResolution.H_NOVIDEO && hasAudio === false) continue
278 let dataInput: VideoTranscodingPayload
280 if (CONFIG.TRANSCODING.WEBTORRENT.ENABLED && type === 'webtorrent') {
281 // WebTorrent will create subsequent HLS job
283 type: 'new-resolution-to-webtorrent',
284 videoUUID: video.uuid,
288 createHLSIfNeeded: true,
292 resolutionCreated.push('webtorrent-' + resolution)
295 if (CONFIG.TRANSCODING.HLS.ENABLED && type === 'hls') {
297 type: 'new-resolution-to-hls',
298 videoUUID: video.uuid,
304 autoDeleteWebTorrentIfNeeded: true,
308 resolutionCreated.push('hls-' + resolution)
311 if (!dataInput) continue
314 priority: await getTranscodingJobPriority(user)
317 await addTranscodingJob(dataInput, jobOptions)
320 if (resolutionCreated.length === 0) {
321 logger.info('No transcoding jobs created for video %s (no resolutions).', video.uuid, lTags(video.uuid))
327 'New resolutions %s transcoding jobs created for video %s and origin file resolution of %d.', type, video.uuid, videoFileResolution,
328 { resolutionCreated, ...lTags(video.uuid) }