Export encoders options in a dedicated struct

2 files changed, 115 insertions, 7 deletions

diff --git a/server/lib/live-manager.ts b/server/lib/live-manager.ts
index 4d2e9b1b3..b9e5d4561 100644
--- a/server/lib/live-manager.ts
+++ b/server/lib/live-manager.ts
@@ -4,7 +4,7 @@ import { FfmpegCommand } from 'fluent-ffmpeg'
 import { ensureDir, stat } from 'fs-extra'
 import { basename } from 'path'
 import { isTestInstance } from '@server/helpers/core-utils'
-import { runLiveMuxing, runLiveTranscoding } from '@server/helpers/ffmpeg-utils'
+import { getLiveMuxingCommand, getLiveTranscodingCommand } from '@server/helpers/ffmpeg-utils'
 import { computeResolutionsToTranscode, getVideoFileFPS, getVideoFileResolution } from '@server/helpers/ffprobe-utils'
 import { logger } from '@server/helpers/logger'
 import { CONFIG, registerConfigChangedHandler } from '@server/initializers/config'
@@ -264,8 +264,8 @@ class LiveManager {
     const deleteSegments = videoLive.saveReplay === false
 
     const ffmpegExec = CONFIG.LIVE.TRANSCODING.ENABLED
-      ? runLiveTranscoding(rtmpUrl, outPath, allResolutions, fps, deleteSegments)
-      : runLiveMuxing(rtmpUrl, outPath, deleteSegments)
+      ? getLiveTranscodingCommand(rtmpUrl, outPath, allResolutions, fps, deleteSegments)
+      : getLiveMuxingCommand(rtmpUrl, outPath, deleteSegments)
 
     logger.info('Running live muxing/transcoding for %s.', videoUUID)
     this.transSessions.set(sessionId, ffmpegExec)
@@ -382,6 +382,8 @@ class LiveManager {
     })
 
     ffmpegExec.on('end', () => onFFmpegEnded())
+
+    ffmpegExec.run()
   }
 
   private async onEndTransmuxing (videoId: number, cleanupNow = false) {
diff --git a/server/lib/video-transcoding.ts b/server/lib/video-transcoding.ts
index ca969b235..0e6a0e984 100644
--- a/server/lib/video-transcoding.ts
+++ b/server/lib/video-transcoding.ts
@@ -2,13 +2,26 @@ import { copyFile, ensureDir, move, remove, stat } from 'fs-extra'
 import { basename, extname as extnameUtil, join } from 'path'
 import { createTorrentAndSetInfoHash } from '@server/helpers/webtorrent'
 import { MStreamingPlaylistFilesVideo, MVideoFile, MVideoWithAllFiles, MVideoWithFile } from '@server/types/models'
-import { VideoResolution } from '../../shared/models/videos'
+import { getTargetBitrate, VideoResolution } from '../../shared/models/videos'
 import { VideoStreamingPlaylistType } from '../../shared/models/videos/video-streaming-playlist.type'
-import { transcode, TranscodeOptions, TranscodeOptionsType } from '../helpers/ffmpeg-utils'
-import { canDoQuickTranscode, getDurationFromVideoFile, getMetadataFromFile, getVideoFileFPS } from '../helpers/ffprobe-utils'
+import { AvailableEncoders, EncoderOptionsBuilder, transcode, TranscodeOptions, TranscodeOptionsType } from '../helpers/ffmpeg-utils'
+import {
+  canDoQuickTranscode,
+  getAudioStream,
+  getDurationFromVideoFile,
+  getMaxAudioBitrate,
+  getMetadataFromFile,
+  getVideoFileBitrate,
+  getVideoFileFPS
+} from '../helpers/ffprobe-utils'
 import { logger } from '../helpers/logger'
 import { CONFIG } from '../initializers/config'
-import { HLS_STREAMING_PLAYLIST_DIRECTORY, P2P_MEDIA_LOADER_PEER_VERSION, WEBSERVER } from '../initializers/constants'
+import {
+  HLS_STREAMING_PLAYLIST_DIRECTORY,
+  P2P_MEDIA_LOADER_PEER_VERSION,
+  VIDEO_TRANSCODING_FPS,
+  WEBSERVER
+} from '../initializers/constants'
 import { VideoFileModel } from '../models/video/video-file'
 import { VideoStreamingPlaylistModel } from '../models/video/video-streaming-playlist'
 import { updateMasterHLSPlaylist, updateSha256VODSegments } from './hls'
@@ -31,8 +44,13 @@ async function optimizeOriginalVideofile (video: MVideoWithFile, inputVideoFileA
 
   const transcodeOptions: TranscodeOptions = {
     type: transcodeType,
+
     inputPath: videoInputPath,
     outputPath: videoTranscodedPath,
+
+    availableEncoders,
+    profile: 'default',
+
     resolution: inputVideoFile.resolution
   }
 
@@ -78,14 +96,23 @@ async function transcodeNewResolution (video: MVideoWithFile, resolution: VideoR
   const transcodeOptions = resolution === VideoResolution.H_NOVIDEO
     ? {
       type: 'only-audio' as 'only-audio',
+
       inputPath: videoInputPath,
       outputPath: videoTranscodedPath,
+
+      availableEncoders,
+      profile: 'default',
+
       resolution
     }
     : {
       type: 'video' as 'video',
       inputPath: videoInputPath,
       outputPath: videoTranscodedPath,
+
+      availableEncoders,
+      profile: 'default',
+
       resolution,
       isPortraitMode: isPortrait
     }
@@ -111,8 +138,13 @@ async function mergeAudioVideofile (video: MVideoWithAllFiles, resolution: Video
 
   const transcodeOptions = {
     type: 'merge-audio' as 'merge-audio',
+
     inputPath: tmpPreviewPath,
     outputPath: videoTranscodedPath,
+
+    availableEncoders,
+    profile: 'default',
+
     audioPath: audioInputPath,
     resolution
   }
@@ -156,8 +188,13 @@ async function generateHlsPlaylist (options: {
 
   const transcodeOptions = {
     type: 'hls' as 'hls',
+
     inputPath: videoInputPath,
     outputPath,
+
+    availableEncoders,
+    profile: 'default',
+
     resolution,
     copyCodecs,
     isPortraitMode,
@@ -216,6 +253,75 @@ async function generateHlsPlaylist (options: {
 }
 
 // ---------------------------------------------------------------------------
+// Available encoders profiles
+// ---------------------------------------------------------------------------
+
+const defaultX264OptionsBuilder: EncoderOptionsBuilder = async ({ input, resolution, fps }) => {
+  if (!fps) return { outputOptions: [] }
+
+  let targetBitrate = getTargetBitrate(resolution, fps, VIDEO_TRANSCODING_FPS)
+
+  // Don't transcode to an higher bitrate than the original file
+  const fileBitrate = await getVideoFileBitrate(input)
+  targetBitrate = Math.min(targetBitrate, fileBitrate)
+
+  return {
+    outputOptions: [
+      // Constrained Encoding (VBV)
+      // https://slhck.info/video/2017/03/01/rate-control.html
+      // https://trac.ffmpeg.org/wiki/Limiting%20the%20output%20bitrate
+      `-maxrate ${targetBitrate}`, `-bufsize ${targetBitrate * 2}`
+    ]
+  }
+}
+
+const defaultAACOptionsBuilder: EncoderOptionsBuilder = async ({ input }) => {
+  const parsedAudio = await getAudioStream(input)
+
+  // we try to reduce the ceiling bitrate by making rough matches of bitrates
+  // of course this is far from perfect, but it might save some space in the end
+
+  const audioCodecName = parsedAudio.audioStream['codec_name']
+
+  const bitrate = getMaxAudioBitrate(audioCodecName, parsedAudio.bitrate)
+
+  if (bitrate !== undefined && bitrate !== -1) {
+    return { outputOptions: [ '-b:a', bitrate + 'k' ] }
+  }
+
+  return { outputOptions: [] }
+}
+
+const defaultLibFDKAACOptionsBuilder: EncoderOptionsBuilder = () => {
+  return { outputOptions: [ '-aq', '5' ] }
+}
+
+const availableEncoders: AvailableEncoders = {
+  vod: {
+    libx264: {
+      default: defaultX264OptionsBuilder
+    },
+    aac: {
+      default: defaultAACOptionsBuilder
+    },
+    libfdkAAC: {
+      default: defaultLibFDKAACOptionsBuilder
+    }
+  },
+  live: {
+    libx264: {
+      default: defaultX264OptionsBuilder
+    },
+    aac: {
+      default: defaultAACOptionsBuilder
+    },
+    libfdkAAC: {
+      default: defaultLibFDKAACOptionsBuilder
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
 
 export {
   generateHlsPlaylist,