server/lib/video-transcoding.ts

   1 import { copyFile, ensureDir, move, remove, stat, writeFile } from 'fs-extra'
   2 import { basename, extname as extnameUtil, join } from 'path'
   3 import { createTorrentAndSetInfoHash } from '@server/helpers/webtorrent'
   4 import { MStreamingPlaylistFilesVideo, MVideoFile, MVideoWithAllFiles, MVideoWithFile } from '@server/types/models'
   5 import { VideoResolution } from '../../shared/models/videos'
   6 import { VideoStreamingPlaylistType } from '../../shared/models/videos/video-streaming-playlist.type'
   7 import { transcode, TranscodeOptions, TranscodeOptionsType } from '../helpers/ffmpeg-utils'
   8 import { canDoQuickTranscode, getDurationFromVideoFile, getMetadataFromFile, getVideoFileFPS } from '../helpers/ffprobe-utils'
   9 import { logger } from '../helpers/logger'
  10 import { CONFIG } from '../initializers/config'
  11 import { HLS_STREAMING_PLAYLIST_DIRECTORY, P2P_MEDIA_LOADER_PEER_VERSION, WEBSERVER } from '../initializers/constants'
  12 import { VideoFileModel } from '../models/video/video-file'
  13 import { VideoStreamingPlaylistModel } from '../models/video/video-streaming-playlist'
  14 import { updateMasterHLSPlaylist, updateSha256VODSegments } from './hls'
  15 import { generateVideoStreamingPlaylistName, getVideoFilename, getVideoFilePath } from './video-paths'
  16 import { availableEncoders } from './video-transcoding-profiles'
  17
  18 /**
  19  *
  20  * Functions that run transcoding functions, update the database, cleanup files, create torrent files...
  21  * Mainly called by the job queue
  22  *
  23  */
  24
  25 // Optimize the original video file and replace it. The resolution is not changed.
  26 async function optimizeOriginalVideofile (video: MVideoWithFile, inputVideoFileArg?: MVideoFile) {
  27   const transcodeDirectory = CONFIG.STORAGE.TMP_DIR
  28   const newExtname = '.mp4'
  29
  30   const inputVideoFile = inputVideoFileArg || video.getMaxQualityFile()
  31   const videoInputPath = getVideoFilePath(video, inputVideoFile)
  32   const videoTranscodedPath = join(transcodeDirectory, video.id + '-transcoded' + newExtname)
  33
  34   const transcodeType: TranscodeOptionsType = await canDoQuickTranscode(videoInputPath)
  35     ? 'quick-transcode'
  36     : 'video'
  37
  38   const transcodeOptions: TranscodeOptions = {
  39     type: transcodeType,
  40
  41     inputPath: videoInputPath,
  42     outputPath: videoTranscodedPath,
  43
  44     availableEncoders,
  45     profile: 'default',
  46
  47     resolution: inputVideoFile.resolution
  48   }
  49
  50   // Could be very long!
  51   await transcode(transcodeOptions)
  52
  53   try {
  54     await remove(videoInputPath)
  55
  56     // Important to do this before getVideoFilename() to take in account the new file extension
  57     inputVideoFile.extname = newExtname
  58
  59     const videoOutputPath = getVideoFilePath(video, inputVideoFile)
  60
  61     await onVideoFileTranscoding(video, inputVideoFile, videoTranscodedPath, videoOutputPath)
  62   } catch (err) {
  63     // Auto destruction...
  64     video.destroy().catch(err => logger.error('Cannot destruct video after transcoding failure.', { err }))
  65
  66     throw err
  67   }
  68 }
  69
  70 // Transcode the original video file to a lower resolution.
  71 async function transcodeNewResolution (video: MVideoWithFile, resolution: VideoResolution, isPortrait: boolean) {
  72   const transcodeDirectory = CONFIG.STORAGE.TMP_DIR
  73   const extname = '.mp4'
  74
  75   // We are sure it's x264 in mp4 because optimizeOriginalVideofile was already executed
  76   const videoInputPath = getVideoFilePath(video, video.getMaxQualityFile())
  77
  78   const newVideoFile = new VideoFileModel({
  79     resolution,
  80     extname,
  81     size: 0,
  82     videoId: video.id
  83   })
  84   const videoOutputPath = getVideoFilePath(video, newVideoFile)
  85   const videoTranscodedPath = join(transcodeDirectory, getVideoFilename(video, newVideoFile))
  86
  87   const transcodeOptions = resolution === VideoResolution.H_NOVIDEO
  88     ? {
  89       type: 'only-audio' as 'only-audio',
  90
  91       inputPath: videoInputPath,
  92       outputPath: videoTranscodedPath,
  93
  94       availableEncoders,
  95       profile: 'default',
  96
  97       resolution
  98     }
  99     : {
 100       type: 'video' as 'video',
 101       inputPath: videoInputPath,
 102       outputPath: videoTranscodedPath,
 103
 104       availableEncoders,
 105       profile: 'default',
 106
 107       resolution,
 108       isPortraitMode: isPortrait
 109     }
 110
 111   await transcode(transcodeOptions)
 112
 113   return onVideoFileTranscoding(video, newVideoFile, videoTranscodedPath, videoOutputPath)
 114 }
 115
 116 // Merge an image with an audio file to create a video
 117 async function mergeAudioVideofile (video: MVideoWithAllFiles, resolution: VideoResolution) {
 118   const transcodeDirectory = CONFIG.STORAGE.TMP_DIR
 119   const newExtname = '.mp4'
 120
 121   const inputVideoFile = video.getMinQualityFile()
 122
 123   const audioInputPath = getVideoFilePath(video, inputVideoFile)
 124   const videoTranscodedPath = join(transcodeDirectory, video.id + '-transcoded' + newExtname)
 125
 126   // If the user updates the video preview during transcoding
 127   const previewPath = video.getPreview().getPath()
 128   const tmpPreviewPath = join(CONFIG.STORAGE.TMP_DIR, basename(previewPath))
 129   await copyFile(previewPath, tmpPreviewPath)
 130
 131   const transcodeOptions = {
 132     type: 'merge-audio' as 'merge-audio',
 133
 134     inputPath: tmpPreviewPath,
 135     outputPath: videoTranscodedPath,
 136
 137     availableEncoders,
 138     profile: 'default',
 139
 140     audioPath: audioInputPath,
 141     resolution
 142   }
 143
 144   try {
 145     await transcode(transcodeOptions)
 146
 147     await remove(audioInputPath)
 148     await remove(tmpPreviewPath)
 149   } catch (err) {
 150     await remove(tmpPreviewPath)
 151     throw err
 152   }
 153
 154   // Important to do this before getVideoFilename() to take in account the new file extension
 155   inputVideoFile.extname = newExtname
 156
 157   const videoOutputPath = getVideoFilePath(video, inputVideoFile)
 158   // ffmpeg generated a new video file, so update the video duration
 159   // See https://trac.ffmpeg.org/ticket/5456
 160   video.duration = await getDurationFromVideoFile(videoTranscodedPath)
 161   await video.save()
 162
 163   return onVideoFileTranscoding(video, inputVideoFile, videoTranscodedPath, videoOutputPath)
 164 }
 165
 166 // Concat TS segments from a live video to a fragmented mp4 HLS playlist
 167 async function generateHlsPlaylistFromTS (options: {
 168   video: MVideoWithFile
 169   replayDirectory: string
 170   segmentFiles: string[]
 171   resolution: VideoResolution
 172   isPortraitMode: boolean
 173 }) {
 174   const concatFilePath = join(options.replayDirectory, 'concat.txt')
 175
 176   function cleaner () {
 177     remove(concatFilePath)
 178       .catch(err => logger.error('Cannot remove concat file in %s.', options.replayDirectory, { err }))
 179   }
 180
 181   // First concat the ts files to a mp4 file
 182   const content = options.segmentFiles.map(f => 'file ' + f)
 183                                       .join('\n')
 184
 185   await writeFile(concatFilePath, content + '\n')
 186
 187   try {
 188     const outputPath = await generateHlsPlaylistCommon({
 189       video: options.video,
 190       resolution: options.resolution,
 191       isPortraitMode: options.isPortraitMode,
 192       inputPath: concatFilePath,
 193       type: 'hls-from-ts' as 'hls-from-ts'
 194     })
 195
 196     cleaner()
 197
 198     return outputPath
 199   } catch (err) {
 200     cleaner()
 201
 202     throw err
 203   }
 204 }
 205
 206 // Generate an HLS playlist from an input file, and update the master playlist
 207 function generateHlsPlaylist (options: {
 208   video: MVideoWithFile
 209   videoInputPath: string
 210   resolution: VideoResolution
 211   copyCodecs: boolean
 212   isPortraitMode: boolean
 213 }) {
 214   return generateHlsPlaylistCommon({
 215     video: options.video,
 216     resolution: options.resolution,
 217     copyCodecs: options.copyCodecs,
 218     isPortraitMode: options.isPortraitMode,
 219     inputPath: options.videoInputPath,
 220     type: 'hls' as 'hls'
 221   })
 222 }
 223
 224 // ---------------------------------------------------------------------------
 225
 226 export {
 227   generateHlsPlaylist,
 228   generateHlsPlaylistFromTS,
 229   optimizeOriginalVideofile,
 230   transcodeNewResolution,
 231   mergeAudioVideofile
 232 }
 233
 234 // ---------------------------------------------------------------------------
 235
 236 async function onVideoFileTranscoding (video: MVideoWithFile, videoFile: MVideoFile, transcodingPath: string, outputPath: string) {
 237   const stats = await stat(transcodingPath)
 238   const fps = await getVideoFileFPS(transcodingPath)
 239   const metadata = await getMetadataFromFile(transcodingPath)
 240
 241   await move(transcodingPath, outputPath, { overwrite: true })
 242
 243   videoFile.size = stats.size
 244   videoFile.fps = fps
 245   videoFile.metadata = metadata
 246
 247   await createTorrentAndSetInfoHash(video, videoFile)
 248
 249   await VideoFileModel.customUpsert(videoFile, 'video', undefined)
 250   video.VideoFiles = await video.$get('VideoFiles')
 251
 252   return video
 253 }
 254
 255 async function generateHlsPlaylistCommon (options: {
 256   type: 'hls' | 'hls-from-ts'
 257   video: MVideoWithFile
 258   inputPath: string
 259   resolution: VideoResolution
 260   copyCodecs?: boolean
 261   isPortraitMode: boolean
 262 }) {
 263   const { type, video, inputPath, resolution, copyCodecs, isPortraitMode } = options
 264
 265   const baseHlsDirectory = join(HLS_STREAMING_PLAYLIST_DIRECTORY, video.uuid)
 266   await ensureDir(join(HLS_STREAMING_PLAYLIST_DIRECTORY, video.uuid))
 267
 268   const outputPath = join(baseHlsDirectory, VideoStreamingPlaylistModel.getHlsPlaylistFilename(resolution))
 269   const videoFilename = generateVideoStreamingPlaylistName(video.uuid, resolution)
 270
 271   const transcodeOptions = {
 272     type,
 273
 274     inputPath,
 275     outputPath,
 276
 277     availableEncoders,
 278     profile: 'default',
 279
 280     resolution,
 281     copyCodecs,
 282     isPortraitMode,
 283
 284     hlsPlaylist: {
 285       videoFilename
 286     }
 287   }
 288
 289   await transcode(transcodeOptions)
 290
 291   const playlistUrl = WEBSERVER.URL + VideoStreamingPlaylistModel.getHlsMasterPlaylistStaticPath(video.uuid)
 292
 293   const [ videoStreamingPlaylist ] = await VideoStreamingPlaylistModel.upsert({
 294     videoId: video.id,
 295     playlistUrl,
 296     segmentsSha256Url: WEBSERVER.URL + VideoStreamingPlaylistModel.getHlsSha256SegmentsStaticPath(video.uuid, video.isLive),
 297     p2pMediaLoaderInfohashes: [],
 298     p2pMediaLoaderPeerVersion: P2P_MEDIA_LOADER_PEER_VERSION,
 299
 300     type: VideoStreamingPlaylistType.HLS
 301   }, { returning: true }) as [ MStreamingPlaylistFilesVideo, boolean ]
 302   videoStreamingPlaylist.Video = video
 303
 304   const newVideoFile = new VideoFileModel({
 305     resolution,
 306     extname: extnameUtil(videoFilename),
 307     size: 0,
 308     fps: -1,
 309     videoStreamingPlaylistId: videoStreamingPlaylist.id
 310   })
 311
 312   const videoFilePath = getVideoFilePath(videoStreamingPlaylist, newVideoFile)
 313   const stats = await stat(videoFilePath)
 314
 315   newVideoFile.size = stats.size
 316   newVideoFile.fps = await getVideoFileFPS(videoFilePath)
 317   newVideoFile.metadata = await getMetadataFromFile(videoFilePath)
 318
 319   await createTorrentAndSetInfoHash(videoStreamingPlaylist, newVideoFile)
 320
 321   await VideoFileModel.customUpsert(newVideoFile, 'streaming-playlist', undefined)
 322   videoStreamingPlaylist.VideoFiles = await videoStreamingPlaylist.$get('VideoFiles')
 323
 324   videoStreamingPlaylist.p2pMediaLoaderInfohashes = VideoStreamingPlaylistModel.buildP2PMediaLoaderInfoHashes(
 325     playlistUrl, videoStreamingPlaylist.VideoFiles
 326   )
 327   await videoStreamingPlaylist.save()
 328
 329   video.setHLSPlaylist(videoStreamingPlaylist)
 330
 331   await updateMasterHLSPlaylist(video)
 332   await updateSha256VODSegments(video)
 333
 334   return outputPath
 335 }