]>
Commit | Line | Data |
---|---|---|
1 | import { Job } from 'bullmq' | |
2 | import { remove } from 'fs-extra' | |
3 | import { join } from 'path' | |
4 | import { getFFmpegCommandWrapperOptions } from '@server/helpers/ffmpeg' | |
5 | import { CONFIG } from '@server/initializers/config' | |
6 | import { VideoTranscodingProfilesManager } from '@server/lib/transcoding/default-transcoding-profiles' | |
7 | import { isAbleToUploadVideo } from '@server/lib/user' | |
8 | import { VideoPathManager } from '@server/lib/video-path-manager' | |
9 | import { approximateIntroOutroAdditionalSize, onVideoStudioEnded, safeCleanupStudioTMPFiles } from '@server/lib/video-studio' | |
10 | import { UserModel } from '@server/models/user/user' | |
11 | import { VideoModel } from '@server/models/video/video' | |
12 | import { MVideo, MVideoFullLight } from '@server/types/models' | |
13 | import { pick } from '@shared/core-utils' | |
14 | import { buildUUID } from '@shared/extra-utils' | |
15 | import { FFmpegEdition } from '@shared/ffmpeg' | |
16 | import { | |
17 | VideoStudioEditionPayload, | |
18 | VideoStudioTask, | |
19 | VideoStudioTaskCutPayload, | |
20 | VideoStudioTaskIntroPayload, | |
21 | VideoStudioTaskOutroPayload, | |
22 | VideoStudioTaskPayload, | |
23 | VideoStudioTaskWatermarkPayload | |
24 | } from '@shared/models' | |
25 | import { logger, loggerTagsFactory } from '../../../helpers/logger' | |
26 | ||
27 | const lTagsBase = loggerTagsFactory('video-studio') | |
28 | ||
29 | async function processVideoStudioEdition (job: Job) { | |
30 | const payload = job.data as VideoStudioEditionPayload | |
31 | const lTags = lTagsBase(payload.videoUUID) | |
32 | ||
33 | logger.info('Process video studio edition of %s in job %s.', payload.videoUUID, job.id, lTags) | |
34 | ||
35 | try { | |
36 | const video = await VideoModel.loadFull(payload.videoUUID) | |
37 | ||
38 | // No video, maybe deleted? | |
39 | if (!video) { | |
40 | logger.info('Can\'t process job %d, video does not exist.', job.id, lTags) | |
41 | ||
42 | await safeCleanupStudioTMPFiles(payload.tasks) | |
43 | return undefined | |
44 | } | |
45 | ||
46 | await checkUserQuotaOrThrow(video, payload) | |
47 | ||
48 | const inputFile = video.getMaxQualityFile() | |
49 | ||
50 | const editionResultPath = await VideoPathManager.Instance.makeAvailableVideoFile(inputFile, async originalFilePath => { | |
51 | let tmpInputFilePath: string | |
52 | let outputPath: string | |
53 | ||
54 | for (const task of payload.tasks) { | |
55 | const outputFilename = buildUUID() + inputFile.extname | |
56 | outputPath = join(CONFIG.STORAGE.TMP_DIR, outputFilename) | |
57 | ||
58 | await processTask({ | |
59 | inputPath: tmpInputFilePath ?? originalFilePath, | |
60 | video, | |
61 | outputPath, | |
62 | task, | |
63 | lTags | |
64 | }) | |
65 | ||
66 | if (tmpInputFilePath) await remove(tmpInputFilePath) | |
67 | ||
68 | // For the next iteration | |
69 | tmpInputFilePath = outputPath | |
70 | } | |
71 | ||
72 | return outputPath | |
73 | }) | |
74 | ||
75 | logger.info('Video edition ended for video %s.', video.uuid, lTags) | |
76 | ||
77 | await onVideoStudioEnded({ video, editionResultPath, tasks: payload.tasks }) | |
78 | } catch (err) { | |
79 | await safeCleanupStudioTMPFiles(payload.tasks) | |
80 | ||
81 | throw err | |
82 | } | |
83 | } | |
84 | ||
85 | // --------------------------------------------------------------------------- | |
86 | ||
87 | export { | |
88 | processVideoStudioEdition | |
89 | } | |
90 | ||
91 | // --------------------------------------------------------------------------- | |
92 | ||
93 | type TaskProcessorOptions <T extends VideoStudioTaskPayload = VideoStudioTaskPayload> = { | |
94 | inputPath: string | |
95 | outputPath: string | |
96 | video: MVideo | |
97 | task: T | |
98 | lTags: { tags: string[] } | |
99 | } | |
100 | ||
101 | const taskProcessors: { [id in VideoStudioTask['name']]: (options: TaskProcessorOptions) => Promise<any> } = { | |
102 | 'add-intro': processAddIntroOutro, | |
103 | 'add-outro': processAddIntroOutro, | |
104 | 'cut': processCut, | |
105 | 'add-watermark': processAddWatermark | |
106 | } | |
107 | ||
108 | async function processTask (options: TaskProcessorOptions) { | |
109 | const { video, task, lTags } = options | |
110 | ||
111 | logger.info('Processing %s task for video %s.', task.name, video.uuid, { task, ...lTags }) | |
112 | ||
113 | const processor = taskProcessors[options.task.name] | |
114 | if (!process) throw new Error('Unknown task ' + task.name) | |
115 | ||
116 | return processor(options) | |
117 | } | |
118 | ||
119 | function processAddIntroOutro (options: TaskProcessorOptions<VideoStudioTaskIntroPayload | VideoStudioTaskOutroPayload>) { | |
120 | const { task, lTags } = options | |
121 | ||
122 | logger.debug('Will add intro/outro to the video.', { options, ...lTags }) | |
123 | ||
124 | return buildFFmpegEdition().addIntroOutro({ | |
125 | ...pick(options, [ 'inputPath', 'outputPath' ]), | |
126 | ||
127 | introOutroPath: task.options.file, | |
128 | type: task.name === 'add-intro' | |
129 | ? 'intro' | |
130 | : 'outro' | |
131 | }) | |
132 | } | |
133 | ||
134 | function processCut (options: TaskProcessorOptions<VideoStudioTaskCutPayload>) { | |
135 | const { task, lTags } = options | |
136 | ||
137 | logger.debug('Will cut the video.', { options, ...lTags }) | |
138 | ||
139 | return buildFFmpegEdition().cutVideo({ | |
140 | ...pick(options, [ 'inputPath', 'outputPath' ]), | |
141 | ||
142 | start: task.options.start, | |
143 | end: task.options.end | |
144 | }) | |
145 | } | |
146 | ||
147 | function processAddWatermark (options: TaskProcessorOptions<VideoStudioTaskWatermarkPayload>) { | |
148 | const { task, lTags } = options | |
149 | ||
150 | logger.debug('Will add watermark to the video.', { options, ...lTags }) | |
151 | ||
152 | return buildFFmpegEdition().addWatermark({ | |
153 | ...pick(options, [ 'inputPath', 'outputPath' ]), | |
154 | ||
155 | watermarkPath: task.options.file, | |
156 | ||
157 | videoFilters: { | |
158 | watermarkSizeRatio: task.options.watermarkSizeRatio, | |
159 | horitonzalMarginRatio: task.options.horitonzalMarginRatio, | |
160 | verticalMarginRatio: task.options.verticalMarginRatio | |
161 | } | |
162 | }) | |
163 | } | |
164 | ||
165 | // --------------------------------------------------------------------------- | |
166 | ||
167 | async function checkUserQuotaOrThrow (video: MVideoFullLight, payload: VideoStudioEditionPayload) { | |
168 | const user = await UserModel.loadByVideoId(video.id) | |
169 | ||
170 | const filePathFinder = (i: number) => (payload.tasks[i] as VideoStudioTaskIntroPayload | VideoStudioTaskOutroPayload).options.file | |
171 | ||
172 | const additionalBytes = await approximateIntroOutroAdditionalSize(video, payload.tasks, filePathFinder) | |
173 | if (await isAbleToUploadVideo(user.id, additionalBytes) === false) { | |
174 | throw new Error('Quota exceeded for this user to edit the video') | |
175 | } | |
176 | } | |
177 | ||
178 | function buildFFmpegEdition () { | |
179 | return new FFmpegEdition(getFFmpegCommandWrapperOptions('vod', VideoTranscodingProfilesManager.Instance.getAvailableEncoders())) | |
180 | } |