1 import { FfprobeData } from 'fluent-ffmpeg'
2 import { getAverageTheoreticalBitrate, getMaxTheoreticalBitrate, getMinTheoreticalBitrate } from '@shared/core-utils'
10 getVideoStreamDimensionsInfo,
12 } from '@shared/ffmpeg'
13 import { EncoderOptionsBuilder, EncoderOptionsBuilderParams, VideoResolution } from '@shared/models'
15 const defaultX264VODOptionsBuilder: EncoderOptionsBuilder = (options: EncoderOptionsBuilderParams) => {
16 const { fps, inputRatio, inputBitrate, resolution } = options
18 const targetBitrate = getTargetBitrate({ inputBitrate, ratio: inputRatio, fps, resolution })
22 ...getCommonOutputOptions(targetBitrate),
29 const defaultX264LiveOptionsBuilder: EncoderOptionsBuilder = (options: EncoderOptionsBuilderParams) => {
30 const { streamNum, fps, inputBitrate, inputRatio, resolution } = options
32 const targetBitrate = getTargetBitrate({ inputBitrate, ratio: inputRatio, fps, resolution })
36 ...getCommonOutputOptions(targetBitrate, streamNum),
38 `${buildStreamSuffix('-r:v', streamNum)} ${fps}`,
39 `${buildStreamSuffix('-b:v', streamNum)} ${targetBitrate}`
44 const defaultAACOptionsBuilder: EncoderOptionsBuilder = async ({ input, streamNum, canCopyAudio }) => {
45 const probe = await ffprobePromise(input)
47 if (canCopyAudio && await canDoQuickAudioTranscode(input, probe)) {
48 return { copy: true, outputOptions: [ ] }
51 const parsedAudio = await getAudioStream(input, probe)
53 // We try to reduce the ceiling bitrate by making rough matches of bitrates
54 // Of course this is far from perfect, but it might save some space in the end
56 const audioCodecName = parsedAudio.audioStream['codec_name']
58 const bitrate = getMaxAudioBitrate(audioCodecName, parsedAudio.bitrate)
60 // Force stereo as it causes some issues with HLS playback in Chrome
61 const base = [ '-channel_layout', 'stereo' ]
64 return { outputOptions: base.concat([ buildStreamSuffix('-b:a', streamNum), bitrate + 'k' ]) }
67 return { outputOptions: base }
70 const defaultLibFDKAACVODOptionsBuilder: EncoderOptionsBuilder = ({ streamNum }) => {
71 return { outputOptions: [ buildStreamSuffix('-q:a', streamNum), '5' ] }
74 export function getDefaultAvailableEncoders () {
78 default: defaultX264VODOptionsBuilder
81 default: defaultAACOptionsBuilder
84 default: defaultLibFDKAACVODOptionsBuilder
89 default: defaultX264LiveOptionsBuilder
92 default: defaultAACOptionsBuilder
98 export function getDefaultEncodersToTry () {
101 video: [ 'libx264' ],
102 audio: [ 'libfdk_aac', 'aac' ]
106 video: [ 'libx264' ],
107 audio: [ 'libfdk_aac', 'aac' ]
112 export async function canDoQuickAudioTranscode (path: string, probe?: FfprobeData): Promise<boolean> {
113 const parsedAudio = await getAudioStream(path, probe)
115 if (!parsedAudio.audioStream) return true
117 if (parsedAudio.audioStream['codec_name'] !== 'aac') return false
119 const audioBitrate = parsedAudio.bitrate
120 if (!audioBitrate) return false
122 const maxAudioBitrate = getMaxAudioBitrate('aac', audioBitrate)
123 if (maxAudioBitrate !== -1 && audioBitrate > maxAudioBitrate) return false
125 const channelLayout = parsedAudio.audioStream['channel_layout']
126 // Causes playback issues with Chrome
127 if (!channelLayout || channelLayout === 'unknown' || channelLayout === 'quad') return false
132 export async function canDoQuickVideoTranscode (path: string, probe?: FfprobeData): Promise<boolean> {
133 const videoStream = await getVideoStream(path, probe)
134 const fps = await getVideoStreamFPS(path, probe)
135 const bitRate = await getVideoStreamBitrate(path, probe)
136 const resolutionData = await getVideoStreamDimensionsInfo(path, probe)
138 // If ffprobe did not manage to guess the bitrate
139 if (!bitRate) return false
141 // check video params
142 if (!videoStream) return false
143 if (videoStream['codec_name'] !== 'h264') return false
144 if (videoStream['pix_fmt'] !== 'yuv420p') return false
145 if (fps < 2 || fps > 65) return false
146 if (bitRate > getMaxTheoreticalBitrate({ ...resolutionData, fps })) return false
151 // ---------------------------------------------------------------------------
153 function getTargetBitrate (options: {
155 resolution: VideoResolution
159 const { inputBitrate, resolution, ratio, fps } = options
161 const capped = capBitrate(inputBitrate, getAverageTheoreticalBitrate({ resolution, fps, ratio }))
162 const limit = getMinTheoreticalBitrate({ resolution, fps, ratio })
164 return Math.max(limit, capped)
167 function capBitrate (inputBitrate: number, targetBitrate: number) {
168 if (!inputBitrate) return targetBitrate
170 // Add 30% margin to input bitrate
171 const inputBitrateWithMargin = inputBitrate + (inputBitrate * 0.3)
173 return Math.min(targetBitrate, inputBitrateWithMargin)
176 function getCommonOutputOptions (targetBitrate: number, streamNum?: number) {
179 `${buildStreamSuffix('-maxrate:v', streamNum)} ${targetBitrate}`,
180 `${buildStreamSuffix('-bufsize:v', streamNum)} ${targetBitrate * 2}`,
182 // NOTE: b-strategy 1 - heuristic algorithm, 16 is optimal B-frames for it
184 // NOTE: Why 16: https://github.com/Chocobozzz/PeerTube/pull/774. b-strategy 2 -> B-frames<16