server/lib/video-transcoding.ts

   1 import { copyFile, ensureDir, move, remove, stat } 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   concatenatedTsFilePath: string
 170   resolution: VideoResolution
 171   isPortraitMode: boolean
 172   isAAC: boolean
 173 }) {
 174   return generateHlsPlaylistCommon({
 175     video: options.video,
 176     resolution: options.resolution,
 177     isPortraitMode: options.isPortraitMode,
 178     inputPath: options.concatenatedTsFilePath,
 179     type: 'hls-from-ts' as 'hls-from-ts',
 180     isAAC: options.isAAC
 181   })
 182 }
 183
 184 // Generate an HLS playlist from an input file, and update the master playlist
 185 function generateHlsPlaylist (options: {
 186   video: MVideoWithFile
 187   videoInputPath: string
 188   resolution: VideoResolution
 189   copyCodecs: boolean
 190   isPortraitMode: boolean
 191 }) {
 192   return generateHlsPlaylistCommon({
 193     video: options.video,
 194     resolution: options.resolution,
 195     copyCodecs: options.copyCodecs,
 196     isPortraitMode: options.isPortraitMode,
 197     inputPath: options.videoInputPath,
 198     type: 'hls' as 'hls'
 199   })
 200 }
 201
 202 // ---------------------------------------------------------------------------
 203
 204 export {
 205   generateHlsPlaylist,
 206   generateHlsPlaylistFromTS,
 207   optimizeOriginalVideofile,
 208   transcodeNewResolution,
 209   mergeAudioVideofile
 210 }
 211
 212 // ---------------------------------------------------------------------------
 213
 214 async function onVideoFileTranscoding (video: MVideoWithFile, videoFile: MVideoFile, transcodingPath: string, outputPath: string) {
 215   const stats = await stat(transcodingPath)
 216   const fps = await getVideoFileFPS(transcodingPath)
 217   const metadata = await getMetadataFromFile(transcodingPath)
 218
 219   await move(transcodingPath, outputPath, { overwrite: true })
 220
 221   videoFile.size = stats.size
 222   videoFile.fps = fps
 223   videoFile.metadata = metadata
 224
 225   await createTorrentAndSetInfoHash(video, videoFile)
 226
 227   await VideoFileModel.customUpsert(videoFile, 'video', undefined)
 228   video.VideoFiles = await video.$get('VideoFiles')
 229
 230   return video
 231 }
 232
 233 async function generateHlsPlaylistCommon (options: {
 234   type: 'hls' | 'hls-from-ts'
 235   video: MVideoWithFile
 236   inputPath: string
 237   resolution: VideoResolution
 238   copyCodecs?: boolean
 239   isAAC?: boolean
 240   isPortraitMode: boolean
 241 }) {
 242   const { type, video, inputPath, resolution, copyCodecs, isPortraitMode, isAAC } = options
 243
 244   const baseHlsDirectory = join(HLS_STREAMING_PLAYLIST_DIRECTORY, video.uuid)
 245   await ensureDir(join(HLS_STREAMING_PLAYLIST_DIRECTORY, video.uuid))
 246
 247   const outputPath = join(baseHlsDirectory, VideoStreamingPlaylistModel.getHlsPlaylistFilename(resolution))
 248   const videoFilename = generateVideoStreamingPlaylistName(video.uuid, resolution)
 249
 250   const transcodeOptions = {
 251     type,
 252
 253     inputPath,
 254     outputPath,
 255
 256     availableEncoders,
 257     profile: 'default',
 258
 259     resolution,
 260     copyCodecs,
 261     isPortraitMode,
 262
 263     isAAC,
 264
 265     hlsPlaylist: {
 266       videoFilename
 267     }
 268   }
 269
 270   await transcode(transcodeOptions)
 271
 272   const playlistUrl = WEBSERVER.URL + VideoStreamingPlaylistModel.getHlsMasterPlaylistStaticPath(video.uuid)
 273
 274   const [ videoStreamingPlaylist ] = await VideoStreamingPlaylistModel.upsert({
 275     videoId: video.id,
 276     playlistUrl,
 277     segmentsSha256Url: WEBSERVER.URL + VideoStreamingPlaylistModel.getHlsSha256SegmentsStaticPath(video.uuid, video.isLive),
 278     p2pMediaLoaderInfohashes: [],
 279     p2pMediaLoaderPeerVersion: P2P_MEDIA_LOADER_PEER_VERSION,
 280
 281     type: VideoStreamingPlaylistType.HLS
 282   }, { returning: true }) as [ MStreamingPlaylistFilesVideo, boolean ]
 283   videoStreamingPlaylist.Video = video
 284
 285   const newVideoFile = new VideoFileModel({
 286     resolution,
 287     extname: extnameUtil(videoFilename),
 288     size: 0,
 289     fps: -1,
 290     videoStreamingPlaylistId: videoStreamingPlaylist.id
 291   })
 292
 293   const videoFilePath = getVideoFilePath(videoStreamingPlaylist, newVideoFile)
 294   const stats = await stat(videoFilePath)
 295
 296   newVideoFile.size = stats.size
 297   newVideoFile.fps = await getVideoFileFPS(videoFilePath)
 298   newVideoFile.metadata = await getMetadataFromFile(videoFilePath)
 299
 300   await createTorrentAndSetInfoHash(videoStreamingPlaylist, newVideoFile)
 301
 302   await VideoFileModel.customUpsert(newVideoFile, 'streaming-playlist', undefined)
 303   videoStreamingPlaylist.VideoFiles = await videoStreamingPlaylist.$get('VideoFiles')
 304
 305   videoStreamingPlaylist.p2pMediaLoaderInfohashes = VideoStreamingPlaylistModel.buildP2PMediaLoaderInfoHashes(
 306     playlistUrl, videoStreamingPlaylist.VideoFiles
 307   )
 308   await videoStreamingPlaylist.save()
 309
 310   video.setHLSPlaylist(videoStreamingPlaylist)
 311
 312   await updateMasterHLSPlaylist(video)
 313   await updateSha256VODSegments(video)
 314
 315   return outputPath
 316 }