OptimizeTranscodingPayload,
VideoTranscodingPayload
} from '@shared/models'
+import { getTranscodingJobPriority } from '../../transcoding-priority'
import { canDoQuickTranscode } from '../../transcoding-quick-transcode'
import { computeResolutionsToTranscode } from '../../transcoding-resolutions'
import { AbstractJobBuilder } from './abstract-job-builder'
videoFile: MVideoFile
isNewVideo: boolean
user: MUserId
+ videoFileAlreadyLocked: boolean
}) {
- const { video, videoFile, isNewVideo, user } = options
+ const { video, videoFile, isNewVideo, user, videoFileAlreadyLocked } = options
let mergeOrOptimizePayload: MergeAudioTranscodingPayload | OptimizeTranscodingPayload
let nextTranscodingSequentialJobPayloads: (NewWebTorrentResolutionTranscodingPayload | HLSTranscodingPayload)[][] = []
- const mutexReleaser = await VideoPathManager.Instance.lockFiles(video.uuid)
+ const mutexReleaser = videoFileAlreadyLocked
+ ? () => {}
+ : await VideoPathManager.Instance.lockFiles(video.uuid)
try {
+ await video.reload()
+ await videoFile.reload()
+
await VideoPathManager.Instance.makeAvailableVideoFile(videoFile.withVideoOrPlaylist(video), async videoFilePath => {
const probe = await ffprobePromise(videoFilePath)
nextTranscodingSequentialJobPayloads = [ ...nextTranscodingSequentialJobPayloads, ...lowerResolutionJobPayloads ]
+ const hasChildren = nextTranscodingSequentialJobPayloads.length !== 0
mergeOrOptimizePayload = videoFile.isAudio()
- ? this.buildMergeAudioPayload({ videoUUID: video.uuid, isNewVideo })
- : this.buildOptimizePayload({ videoUUID: video.uuid, isNewVideo, quickTranscode })
+ ? this.buildMergeAudioPayload({ videoUUID: video.uuid, isNewVideo, hasChildren })
+ : this.buildOptimizePayload({ videoUUID: video.uuid, isNewVideo, quickTranscode, hasChildren })
})
} finally {
mutexReleaser()
const mergeOrOptimizeJob = await this.buildTranscodingJob({ payload: mergeOrOptimizePayload, user })
- return JobQueue.Instance.createSequentialJobFlow(...[ mergeOrOptimizeJob, transcodingJobBuilderJob ])
+ await JobQueue.Instance.createSequentialJobFlow(...[ mergeOrOptimizeJob, transcodingJobBuilderJob ])
+
+ await VideoJobInfoModel.increaseOrCreate(video.uuid, 'pendingTranscode')
}
// ---------------------------------------------------------------------------
return {
type: 'video-transcoding' as 'video-transcoding',
- priority: await this.getTranscodingJobPriority({ user, fallback: undefined }),
+ priority: await getTranscodingJobPriority({ user, type: 'vod', fallback: undefined }),
payload
}
}
private buildMergeAudioPayload (options: {
videoUUID: string
isNewVideo: boolean
+ hasChildren: boolean
}): MergeAudioTranscodingPayload {
- const { videoUUID, isNewVideo } = options
+ const { videoUUID, isNewVideo, hasChildren } = options
return {
type: 'merge-audio-to-webtorrent',
resolution: DEFAULT_AUDIO_RESOLUTION,
fps: VIDEO_TRANSCODING_FPS.AUDIO_MERGE,
videoUUID,
- isNewVideo
+ isNewVideo,
+ hasChildren
}
}
videoUUID: string
quickTranscode: boolean
isNewVideo: boolean
+ hasChildren: boolean
}): OptimizeTranscodingPayload {
- const { videoUUID, quickTranscode, isNewVideo } = options
+ const { videoUUID, quickTranscode, isNewVideo, hasChildren } = options
return {
type: 'optimize-to-webtorrent',
videoUUID,
isNewVideo,
+ hasChildren,
quickTranscode
}
}