1 import { Job } from 'bull'
2 import { copyFile, ensureDir, move, remove, stat } from 'fs-extra'
3 import { basename, extname as extnameUtil, join } from 'path'
4 import { toEven } from '@server/helpers/core-utils'
5 import { createTorrentAndSetInfoHash } from '@server/helpers/webtorrent'
6 import { MStreamingPlaylistFilesVideo, MVideo, MVideoFile, MVideoFullLight } from '@server/types/models'
7 import { VideoResolution, VideoStorage } from '../../../shared/models/videos'
8 import { VideoStreamingPlaylistType } from '../../../shared/models/videos/video-streaming-playlist.type'
12 getVideoStreamDuration,
16 TranscodeVODOptionsType
17 } from '../../helpers/ffmpeg'
18 import { CONFIG } from '../../initializers/config'
19 import { P2P_MEDIA_LOADER_PEER_VERSION } from '../../initializers/constants'
20 import { VideoFileModel } from '../../models/video/video-file'
21 import { VideoStreamingPlaylistModel } from '../../models/video/video-streaming-playlist'
22 import { updateMasterHLSPlaylist, updateSha256VODSegments } from '../hls'
24 generateHLSMasterPlaylistFilename,
25 generateHlsSha256SegmentsFilename,
26 generateHLSVideoFilename,
27 generateWebTorrentVideoFilename,
28 getHlsResolutionPlaylistFilename
30 import { VideoPathManager } from '../video-path-manager'
31 import { VideoTranscodingProfilesManager } from './default-transcoding-profiles'
32 import { retryTransactionWrapper } from '@server/helpers/database-utils'
33 import { sequelizeTypescript } from '@server/initializers/database'
37 * Functions that run transcoding functions, update the database, cleanup files, create torrent files...
38 * Mainly called by the job queue
42 // Optimize the original video file and replace it. The resolution is not changed.
43 function optimizeOriginalVideofile (video: MVideoFullLight, inputVideoFile: MVideoFile, job?: Job) {
44 const transcodeDirectory = CONFIG.STORAGE.TMP_DIR
45 const newExtname = '.mp4'
47 return VideoPathManager.Instance.makeAvailableVideoFile(inputVideoFile.withVideoOrPlaylist(video), async videoInputPath => {
48 const videoTranscodedPath = join(transcodeDirectory, video.id + '-transcoded' + newExtname)
50 const transcodeType: TranscodeVODOptionsType = await canDoQuickTranscode(videoInputPath)
54 const resolution = toEven(inputVideoFile.resolution)
56 const transcodeOptions: TranscodeVODOptions = {
59 inputPath: videoInputPath,
60 outputPath: videoTranscodedPath,
62 availableEncoders: VideoTranscodingProfilesManager.Instance.getAvailableEncoders(),
63 profile: CONFIG.TRANSCODING.PROFILE,
70 // Could be very long!
71 await transcodeVOD(transcodeOptions)
73 // Important to do this before getVideoFilename() to take in account the new filename
74 inputVideoFile.extname = newExtname
75 inputVideoFile.filename = generateWebTorrentVideoFilename(resolution, newExtname)
76 inputVideoFile.storage = VideoStorage.FILE_SYSTEM
78 const videoOutputPath = VideoPathManager.Instance.getFSVideoFileOutputPath(video, inputVideoFile)
80 const { videoFile } = await onWebTorrentVideoFileTranscoding(video, inputVideoFile, videoTranscodedPath, videoOutputPath)
81 await remove(videoInputPath)
83 return { transcodeType, videoFile }
87 // Transcode the original video file to a lower resolution
88 // We are sure it's x264 in mp4 because optimizeOriginalVideofile was already executed
89 function transcodeNewWebTorrentResolution (video: MVideoFullLight, resolution: VideoResolution, isPortrait: boolean, job: Job) {
90 const transcodeDirectory = CONFIG.STORAGE.TMP_DIR
91 const extname = '.mp4'
93 return VideoPathManager.Instance.makeAvailableVideoFile(video.getMaxQualityFile().withVideoOrPlaylist(video), async videoInputPath => {
94 const newVideoFile = new VideoFileModel({
97 filename: generateWebTorrentVideoFilename(resolution, extname),
102 const videoOutputPath = VideoPathManager.Instance.getFSVideoFileOutputPath(video, newVideoFile)
103 const videoTranscodedPath = join(transcodeDirectory, newVideoFile.filename)
105 const transcodeOptions = resolution === VideoResolution.H_NOVIDEO
107 type: 'only-audio' as 'only-audio',
109 inputPath: videoInputPath,
110 outputPath: videoTranscodedPath,
112 availableEncoders: VideoTranscodingProfilesManager.Instance.getAvailableEncoders(),
113 profile: CONFIG.TRANSCODING.PROFILE,
120 type: 'video' as 'video',
121 inputPath: videoInputPath,
122 outputPath: videoTranscodedPath,
124 availableEncoders: VideoTranscodingProfilesManager.Instance.getAvailableEncoders(),
125 profile: CONFIG.TRANSCODING.PROFILE,
128 isPortraitMode: isPortrait,
133 await transcodeVOD(transcodeOptions)
135 return onWebTorrentVideoFileTranscoding(video, newVideoFile, videoTranscodedPath, videoOutputPath)
139 // Merge an image with an audio file to create a video
140 function mergeAudioVideofile (video: MVideoFullLight, resolution: VideoResolution, job: Job) {
141 const transcodeDirectory = CONFIG.STORAGE.TMP_DIR
142 const newExtname = '.mp4'
144 const inputVideoFile = video.getMinQualityFile()
146 return VideoPathManager.Instance.makeAvailableVideoFile(inputVideoFile.withVideoOrPlaylist(video), async audioInputPath => {
147 const videoTranscodedPath = join(transcodeDirectory, video.id + '-transcoded' + newExtname)
149 // If the user updates the video preview during transcoding
150 const previewPath = video.getPreview().getPath()
151 const tmpPreviewPath = join(CONFIG.STORAGE.TMP_DIR, basename(previewPath))
152 await copyFile(previewPath, tmpPreviewPath)
154 const transcodeOptions = {
155 type: 'merge-audio' as 'merge-audio',
157 inputPath: tmpPreviewPath,
158 outputPath: videoTranscodedPath,
160 availableEncoders: VideoTranscodingProfilesManager.Instance.getAvailableEncoders(),
161 profile: CONFIG.TRANSCODING.PROFILE,
163 audioPath: audioInputPath,
170 await transcodeVOD(transcodeOptions)
172 await remove(audioInputPath)
173 await remove(tmpPreviewPath)
175 await remove(tmpPreviewPath)
179 // Important to do this before getVideoFilename() to take in account the new file extension
180 inputVideoFile.extname = newExtname
181 inputVideoFile.resolution = resolution
182 inputVideoFile.filename = generateWebTorrentVideoFilename(inputVideoFile.resolution, newExtname)
184 const videoOutputPath = VideoPathManager.Instance.getFSVideoFileOutputPath(video, inputVideoFile)
185 // ffmpeg generated a new video file, so update the video duration
186 // See https://trac.ffmpeg.org/ticket/5456
187 video.duration = await getVideoStreamDuration(videoTranscodedPath)
190 return onWebTorrentVideoFileTranscoding(video, inputVideoFile, videoTranscodedPath, videoOutputPath)
194 // Concat TS segments from a live video to a fragmented mp4 HLS playlist
195 async function generateHlsPlaylistResolutionFromTS (options: {
197 concatenatedTsFilePath: string
198 resolution: VideoResolution
199 isPortraitMode: boolean
202 return generateHlsPlaylistCommon({
203 video: options.video,
204 resolution: options.resolution,
205 isPortraitMode: options.isPortraitMode,
206 inputPath: options.concatenatedTsFilePath,
207 type: 'hls-from-ts' as 'hls-from-ts',
212 // Generate an HLS playlist from an input file, and update the master playlist
213 function generateHlsPlaylistResolution (options: {
215 videoInputPath: string
216 resolution: VideoResolution
218 isPortraitMode: boolean
221 return generateHlsPlaylistCommon({
222 video: options.video,
223 resolution: options.resolution,
224 copyCodecs: options.copyCodecs,
225 isPortraitMode: options.isPortraitMode,
226 inputPath: options.videoInputPath,
227 type: 'hls' as 'hls',
232 // ---------------------------------------------------------------------------
235 generateHlsPlaylistResolution,
236 generateHlsPlaylistResolutionFromTS,
237 optimizeOriginalVideofile,
238 transcodeNewWebTorrentResolution,
242 // ---------------------------------------------------------------------------
244 async function onWebTorrentVideoFileTranscoding (
245 video: MVideoFullLight,
246 videoFile: MVideoFile,
247 transcodingPath: string,
250 const stats = await stat(transcodingPath)
251 const fps = await getVideoStreamFPS(transcodingPath)
252 const metadata = await buildFileMetadata(transcodingPath)
254 await move(transcodingPath, outputPath, { overwrite: true })
256 videoFile.size = stats.size
258 videoFile.metadata = metadata
260 await createTorrentAndSetInfoHash(video, videoFile)
262 await VideoFileModel.customUpsert(videoFile, 'video', undefined)
263 video.VideoFiles = await video.$get('VideoFiles')
265 return { video, videoFile }
268 async function generateHlsPlaylistCommon (options: {
269 type: 'hls' | 'hls-from-ts'
272 resolution: VideoResolution
275 isPortraitMode: boolean
279 const { type, video, inputPath, resolution, copyCodecs, isPortraitMode, isAAC, job } = options
280 const transcodeDirectory = CONFIG.STORAGE.TMP_DIR
282 const videoTranscodedBasePath = join(transcodeDirectory, type)
283 await ensureDir(videoTranscodedBasePath)
285 const videoFilename = generateHLSVideoFilename(resolution)
286 const resolutionPlaylistFilename = getHlsResolutionPlaylistFilename(videoFilename)
287 const resolutionPlaylistFileTranscodePath = join(videoTranscodedBasePath, resolutionPlaylistFilename)
289 const transcodeOptions = {
293 outputPath: resolutionPlaylistFileTranscodePath,
295 availableEncoders: VideoTranscodingProfilesManager.Instance.getAvailableEncoders(),
296 profile: CONFIG.TRANSCODING.PROFILE,
311 await transcodeVOD(transcodeOptions)
313 // Create or update the playlist
314 const playlist = await retryTransactionWrapper(() => {
315 return sequelizeTypescript.transaction(async transaction => {
316 const playlist = await VideoStreamingPlaylistModel.loadOrGenerate(video, transaction)
318 if (!playlist.playlistFilename) {
319 playlist.playlistFilename = generateHLSMasterPlaylistFilename(video.isLive)
322 if (!playlist.segmentsSha256Filename) {
323 playlist.segmentsSha256Filename = generateHlsSha256SegmentsFilename(video.isLive)
326 playlist.p2pMediaLoaderInfohashes = []
327 playlist.p2pMediaLoaderPeerVersion = P2P_MEDIA_LOADER_PEER_VERSION
329 playlist.type = VideoStreamingPlaylistType.HLS
331 await playlist.save({ transaction })
337 // Build the new playlist file
338 const extname = extnameUtil(videoFilename)
339 const newVideoFile = new VideoFileModel({
343 filename: videoFilename,
345 videoStreamingPlaylistId: playlist.id
348 const videoFilePath = VideoPathManager.Instance.getFSVideoFileOutputPath(playlist, newVideoFile)
350 // Move files from tmp transcoded directory to the appropriate place
351 await ensureDir(VideoPathManager.Instance.getFSHLSOutputPath(video))
353 // Move playlist file
354 const resolutionPlaylistPath = VideoPathManager.Instance.getFSHLSOutputPath(video, resolutionPlaylistFilename)
355 await move(resolutionPlaylistFileTranscodePath, resolutionPlaylistPath, { overwrite: true })
357 await move(join(videoTranscodedBasePath, videoFilename), videoFilePath, { overwrite: true })
359 const stats = await stat(videoFilePath)
361 newVideoFile.size = stats.size
362 newVideoFile.fps = await getVideoStreamFPS(videoFilePath)
363 newVideoFile.metadata = await buildFileMetadata(videoFilePath)
365 await createTorrentAndSetInfoHash(playlist, newVideoFile)
367 const savedVideoFile = await VideoFileModel.customUpsert(newVideoFile, 'streaming-playlist', undefined)
369 const playlistWithFiles = playlist as MStreamingPlaylistFilesVideo
370 playlistWithFiles.VideoFiles = await playlist.$get('VideoFiles')
371 playlist.assignP2PMediaLoaderInfoHashes(video, playlistWithFiles.VideoFiles)
373 await playlist.save()
375 video.setHLSPlaylist(playlist)
377 await updateMasterHLSPlaylist(video, playlistWithFiles)
378 await updateSha256VODSegments(video, playlistWithFiles)
380 return { resolutionPlaylistPath, videoFile: savedVideoFile }