X-Git-Url: https://git.immae.eu/?a=blobdiff_plain;ds=sidebyside;f=server%2Fhelpers%2Fffmpeg-utils.ts;h=78ee5fa7f9a12f5f03f52cab8def28c9daab3731;hb=75b7117f078461d2507572ba9da6527894e1b734;hp=df3926658d54594b60056936e6a75717c9e9889c;hpb=daf6e4801052d3ca6be2fafd20bae2323b1ce175;p=github%2FChocobozzz%2FPeerTube.git diff --git a/server/helpers/ffmpeg-utils.ts b/server/helpers/ffmpeg-utils.ts index df3926658..78ee5fa7f 100644 --- a/server/helpers/ffmpeg-utils.ts +++ b/server/helpers/ffmpeg-utils.ts @@ -1,13 +1,99 @@ -import * as ffmpeg from 'fluent-ffmpeg' +import { Job } from 'bull' +import ffmpeg, { FfmpegCommand, FilterSpecification, getAvailableEncoders } from 'fluent-ffmpeg' import { readFile, remove, writeFile } from 'fs-extra' import { dirname, join } from 'path' -import { getTargetBitrate, VideoResolution } from '../../shared/models/videos' -import { checkFFmpegEncoders } from '../initializers/checker-before-init' +import { FFMPEG_NICE, VIDEO_LIVE } from '@server/initializers/constants' +import { pick } from '@shared/core-utils' +import { + AvailableEncoders, + EncoderOptions, + EncoderOptionsBuilder, + EncoderOptionsBuilderParams, + EncoderProfile, + VideoResolution +} from '../../shared/models/videos' import { CONFIG } from '../initializers/config' -import { FFMPEG_NICE, VIDEO_LIVE, VIDEO_TRANSCODING_FPS } from '../initializers/constants' -import { getAudioStream, getClosestFramerateStandard, getMaxAudioBitrate, getVideoFileFPS } from './ffprobe-utils' +import { execPromise, promisify0 } from './core-utils' +import { computeFPS, ffprobePromise, getAudioStream, getVideoFileBitrate, getVideoFileFPS, getVideoFileResolution } from './ffprobe-utils' import { processImage } from './image-utils' -import { logger } from './logger' +import { logger, loggerTagsFactory } from './logger' + +const lTags = loggerTagsFactory('ffmpeg') + +/** + * + * Functions that run transcoding/muxing ffmpeg processes + * Mainly called by lib/video-transcoding.ts and lib/live-manager.ts + * + */ + +// --------------------------------------------------------------------------- +// Encoder options +// --------------------------------------------------------------------------- + +type StreamType = 'audio' | 'video' + +// --------------------------------------------------------------------------- +// Encoders support +// --------------------------------------------------------------------------- + +// Detect supported encoders by ffmpeg +let supportedEncoders: Map +async function checkFFmpegEncoders (peertubeAvailableEncoders: AvailableEncoders): Promise> { + if (supportedEncoders !== undefined) { + return supportedEncoders + } + + const getAvailableEncodersPromise = promisify0(getAvailableEncoders) + const availableFFmpegEncoders = await getAvailableEncodersPromise() + + const searchEncoders = new Set() + for (const type of [ 'live', 'vod' ]) { + for (const streamType of [ 'audio', 'video' ]) { + for (const encoder of peertubeAvailableEncoders.encodersToTry[type][streamType]) { + searchEncoders.add(encoder) + } + } + } + + supportedEncoders = new Map() + + for (const searchEncoder of searchEncoders) { + supportedEncoders.set(searchEncoder, availableFFmpegEncoders[searchEncoder] !== undefined) + } + + logger.info('Built supported ffmpeg encoders.', { supportedEncoders, searchEncoders, ...lTags() }) + + return supportedEncoders +} + +function resetSupportedEncoders () { + supportedEncoders = undefined +} + +// --------------------------------------------------------------------------- +// Image manipulation +// --------------------------------------------------------------------------- + +function convertWebPToJPG (path: string, destination: string): Promise { + const command = ffmpeg(path, { niceness: FFMPEG_NICE.THUMBNAIL }) + .output(destination) + + return runCommand({ command, silent: true }) +} + +function processGIF ( + path: string, + destination: string, + newSize: { width: number, height: number } +): Promise { + const command = ffmpeg(path, { niceness: FFMPEG_NICE.THUMBNAIL }) + .fps(20) + .size(`${newSize.width}x${newSize.height}`) + .output(destination) + + return runCommand({ command }) +} async function generateImageFromVideoFile (fromPath: string, folder: string, imageName: string, size: { width: number, height: number }) { const pendingImageName = 'pending-' + imageName @@ -31,12 +117,12 @@ async function generateImageFromVideoFile (fromPath: string, folder: string, ima const destination = join(folder, imageName) await processImage(pendingImagePath, destination, size) } catch (err) { - logger.error('Cannot generate image from video %s.', fromPath, { err }) + logger.error('Cannot generate image from video %s.', fromPath, { err, ...lTags() }) try { await remove(pendingImagePath) } catch (err) { - logger.debug('Cannot remove pending image path after generation error.', { err }) + logger.debug('Cannot remove pending image path after generation error.', { err, ...lTags() }) } } } @@ -45,14 +131,22 @@ async function generateImageFromVideoFile (fromPath: string, folder: string, ima // Transcode meta function // --------------------------------------------------------------------------- -type TranscodeOptionsType = 'hls' | 'quick-transcode' | 'video' | 'merge-audio' | 'only-audio' +type TranscodeOptionsType = 'hls' | 'hls-from-ts' | 'quick-transcode' | 'video' | 'merge-audio' | 'only-audio' interface BaseTranscodeOptions { type: TranscodeOptionsType + inputPath: string outputPath: string - resolution: VideoResolution + + availableEncoders: AvailableEncoders + profile: string + + resolution: number + isPortraitMode?: boolean + + job?: Job } interface HLSTranscodeOptions extends BaseTranscodeOptions { @@ -63,6 +157,16 @@ interface HLSTranscodeOptions extends BaseTranscodeOptions { } } +interface HLSFromTSTranscodeOptions extends BaseTranscodeOptions { + type: 'hls-from-ts' + + isAAC: boolean + + hlsPlaylist: { + videoFilename: string + } +} + interface QuickTranscodeOptions extends BaseTranscodeOptions { type: 'quick-transcode' } @@ -82,288 +186,267 @@ interface OnlyAudioTranscodeOptions extends BaseTranscodeOptions { type TranscodeOptions = HLSTranscodeOptions + | HLSFromTSTranscodeOptions | VideoTranscodeOptions | MergeAudioTranscodeOptions | OnlyAudioTranscodeOptions | QuickTranscodeOptions const builders: { - [ type in TranscodeOptionsType ]: (c: ffmpeg.FfmpegCommand, o?: TranscodeOptions) => Promise | ffmpeg.FfmpegCommand + [ type in TranscodeOptionsType ]: (c: FfmpegCommand, o?: TranscodeOptions) => Promise | FfmpegCommand } = { 'quick-transcode': buildQuickTranscodeCommand, 'hls': buildHLSVODCommand, + 'hls-from-ts': buildHLSVODFromTSCommand, 'merge-audio': buildAudioMergeCommand, 'only-audio': buildOnlyAudioCommand, - 'video': buildx264Command + 'video': buildx264VODCommand } async function transcode (options: TranscodeOptions) { - logger.debug('Will run transcode.', { options }) + logger.debug('Will run transcode.', { options, ...lTags() }) - let command = getFFmpeg(options.inputPath) + let command = getFFmpeg(options.inputPath, 'vod') .output(options.outputPath) command = await builders[options.type](command, options) - await runCommand(command) + await runCommand({ command, job: options.job }) await fixHLSPlaylistIfNeeded(options) } -function convertWebPToJPG (path: string, destination: string): Promise { - return new Promise(async (res, rej) => { - try { - const command = ffmpeg(path).output(destination) +// --------------------------------------------------------------------------- +// Live muxing/transcoding functions +// --------------------------------------------------------------------------- - command.on('error', (err, stdout, stderr) => { - logger.error('Error in ffmpeg webp convert process.', { stdout, stderr }) - return rej(err) - }) - .on('end', () => res()) - .run() - } catch (err) { - return rej(err) - } - }) -} +async function getLiveTranscodingCommand (options: { + inputUrl: string -function processGIF ( - path: string, - destination: string, - newSize: { width: number, height: number }, - keepOriginal = false -): Promise { - return new Promise(async (res, rej) => { - if (path === destination) { - throw new Error('FFmpeg needs an input path different that the output path.') - } + outPath: string + masterPlaylistName: string - logger.debug('Processing gif %s to %s.', path, destination) + resolutions: number[] - try { - const command = ffmpeg(path) - .fps(20) - .size(`${newSize.width}x${newSize.height}`) - .output(destination) - - command.on('error', (err, stdout, stderr) => { - logger.error('Error in ffmpeg gif resizing process.', { stdout, stderr }) - return rej(err) - }) - .on('end', async () => { - if (keepOriginal !== true) await remove(path) - res() - }) - .run() - } catch (err) { - return rej(err) - } - }) -} + // Input information + fps: number + bitrate: number + ratio: number + + availableEncoders: AvailableEncoders + profile: string +}) { + const { inputUrl, outPath, resolutions, fps, bitrate, availableEncoders, profile, masterPlaylistName, ratio } = options -function runLiveTranscoding (rtmpUrl: string, outPath: string, resolutions: number[], fps, deleteSegments: boolean) { - const command = getFFmpeg(rtmpUrl) - command.inputOption('-fflags nobuffer') + const command = getFFmpeg(inputUrl, 'live') const varStreamMap: string[] = [] - command.complexFilter([ + const complexFilter: FilterSpecification[] = [ { inputs: '[v:0]', filter: 'split', options: resolutions.length, outputs: resolutions.map(r => `vtemp${r}`) - }, - - ...resolutions.map(r => ({ - inputs: `vtemp${r}`, - filter: 'scale', - options: `w=-2:h=${r}`, - outputs: `vout${r}` - })) - ]) - - command.outputOption('-b_strategy 1') - command.outputOption('-bf 16') - command.outputOption('-preset superfast') - command.outputOption('-level 3.1') - command.outputOption('-map_metadata -1') - command.outputOption('-pix_fmt yuv420p') - command.outputOption('-max_muxing_queue_size 1024') - command.outputOption('-g ' + (fps * 2)) + } + ] + + command.outputOption('-sc_threshold 0') + + addDefaultEncoderGlobalParams({ command }) for (let i = 0; i < resolutions.length; i++) { const resolution = resolutions[i] + const resolutionFPS = computeFPS(fps, resolution) - command.outputOption(`-map [vout${resolution}]`) - command.outputOption(`-c:v:${i} libx264`) - command.outputOption(`-b:v:${i} ${getTargetBitrate(resolution, fps, VIDEO_TRANSCODING_FPS)}`) + const baseEncoderBuilderParams = { + input: inputUrl, - command.outputOption(`-map a:0`) - command.outputOption(`-c:a:${i} aac`) + availableEncoders, + profile, - varStreamMap.push(`v:${i},a:${i}`) - } + inputBitrate: bitrate, + inputRatio: ratio, - addDefaultLiveHLSParams(command, outPath, deleteSegments) + resolution, + fps: resolutionFPS, - command.outputOption('-var_stream_map', varStreamMap.join(' ')) + streamNum: i, + videoType: 'live' as 'live' + } - command.run() + { + const streamType: StreamType = 'video' + const builderResult = await getEncoderBuilderResult({ ...baseEncoderBuilderParams, streamType }) + if (!builderResult) { + throw new Error('No available live video encoder found') + } - return command -} + command.outputOption(`-map [vout${resolution}]`) -function runLiveMuxing (rtmpUrl: string, outPath: string, deleteSegments: boolean) { - const command = getFFmpeg(rtmpUrl) - command.inputOption('-fflags nobuffer') + addDefaultEncoderParams({ command, encoder: builderResult.encoder, fps: resolutionFPS, streamNum: i }) - command.outputOption('-c:v copy') - command.outputOption('-c:a copy') - command.outputOption('-map 0:a?') - command.outputOption('-map 0:v?') + logger.debug( + 'Apply ffmpeg live video params from %s using %s profile.', builderResult.encoder, profile, + { builderResult, fps: resolutionFPS, resolution, ...lTags() } + ) + + command.outputOption(`${buildStreamSuffix('-c:v', i)} ${builderResult.encoder}`) + applyEncoderOptions(command, builderResult.result) - addDefaultLiveHLSParams(command, outPath, deleteSegments) + complexFilter.push({ + inputs: `vtemp${resolution}`, + filter: getScaleFilter(builderResult.result), + options: `w=-2:h=${resolution}`, + outputs: `vout${resolution}` + }) + } - command.run() + { + const streamType: StreamType = 'audio' + const builderResult = await getEncoderBuilderResult({ ...baseEncoderBuilderParams, streamType }) + if (!builderResult) { + throw new Error('No available live audio encoder found') + } - return command -} + command.outputOption('-map a:0') -async function hlsPlaylistToFragmentedMP4 (hlsDirectory: string, segmentFiles: string[], outputPath: string) { - const concatFilePath = join(hlsDirectory, 'concat.txt') + addDefaultEncoderParams({ command, encoder: builderResult.encoder, fps: resolutionFPS, streamNum: i }) - function cleaner () { - remove(concatFilePath) - .catch(err => logger.error('Cannot remove concat file in %s.', hlsDirectory, { err })) - } + logger.debug( + 'Apply ffmpeg live audio params from %s using %s profile.', builderResult.encoder, profile, + { builderResult, fps: resolutionFPS, resolution, ...lTags() } + ) - // First concat the ts files to a mp4 file - const content = segmentFiles.map(f => 'file ' + f) - .join('\n') + command.outputOption(`${buildStreamSuffix('-c:a', i)} ${builderResult.encoder}`) + applyEncoderOptions(command, builderResult.result) + } - await writeFile(concatFilePath, content + '\n') + varStreamMap.push(`v:${i},a:${i}`) + } - const command = getFFmpeg(concatFilePath) - command.inputOption('-safe 0') - command.inputOption('-f concat') + command.complexFilter(complexFilter) - command.outputOption('-c:v copy') - command.audioFilter('aresample=async=1:first_pts=0') - command.output(outputPath) + addDefaultLiveHLSParams(command, outPath, masterPlaylistName) - return runCommand(command, cleaner) -} + command.outputOption('-var_stream_map', varStreamMap.join(' ')) -async function runCommand (command: ffmpeg.FfmpegCommand, onEnd?: Function) { - return new Promise((res, rej) => { - command.on('error', (err, stdout, stderr) => { - if (onEnd) onEnd() + return command +} - logger.error('Error in transcoding job.', { stdout, stderr }) - rej(err) - }) +function getLiveMuxingCommand (inputUrl: string, outPath: string, masterPlaylistName: string) { + const command = getFFmpeg(inputUrl, 'live') - command.on('end', () => { - if (onEnd) onEnd() + command.outputOption('-c:v copy') + command.outputOption('-c:a copy') + command.outputOption('-map 0:a?') + command.outputOption('-map 0:v?') - res() - }) + addDefaultLiveHLSParams(command, outPath, masterPlaylistName) - command.run() - }) + return command } -// --------------------------------------------------------------------------- +function buildStreamSuffix (base: string, streamNum?: number) { + if (streamNum !== undefined) { + return `${base}:${streamNum}` + } -export { - runLiveMuxing, - convertWebPToJPG, - processGIF, - runLiveTranscoding, - generateImageFromVideoFile, - TranscodeOptions, - TranscodeOptionsType, - transcode, - hlsPlaylistToFragmentedMP4 + return base } +// --------------------------------------------------------------------------- +// Default options // --------------------------------------------------------------------------- -function addDefaultX264Params (command: ffmpeg.FfmpegCommand) { - command.outputOption('-level 3.1') // 3.1 is the minimal resource allocation for our highest supported resolution - .outputOption('-b_strategy 1') // NOTE: b-strategy 1 - heuristic algorithm, 16 is optimal B-frames for it - .outputOption('-bf 16') // NOTE: Why 16: https://github.com/Chocobozzz/PeerTube/pull/774. b-strategy 2 -> B-frames<16 - .outputOption('-pix_fmt yuv420p') // allows import of source material with incompatible pixel formats (e.g. MJPEG video) - .outputOption('-map_metadata -1') // strip all metadata -} +function addDefaultEncoderGlobalParams (options: { + command: FfmpegCommand +}) { + const { command } = options -function addDefaultLiveHLSParams (command: ffmpeg.FfmpegCommand, outPath: string, deleteSegments: boolean) { - command.outputOption('-hls_time ' + VIDEO_LIVE.SEGMENT_TIME_SECONDS) - command.outputOption('-hls_list_size ' + VIDEO_LIVE.SEGMENTS_LIST_SIZE) + // avoid issues when transcoding some files: https://trac.ffmpeg.org/ticket/6375 + command.outputOption('-max_muxing_queue_size 1024') + // strip all metadata + .outputOption('-map_metadata -1') + // allows import of source material with incompatible pixel formats (e.g. MJPEG video) + .outputOption('-pix_fmt yuv420p') +} - if (deleteSegments === true) { - command.outputOption('-hls_flags delete_segments') +function addDefaultEncoderParams (options: { + command: FfmpegCommand + encoder: 'libx264' | string + streamNum?: number + fps?: number +}) { + const { command, encoder, fps, streamNum } = options + + if (encoder === 'libx264') { + // 3.1 is the minimal resource allocation for our highest supported resolution + command.outputOption(buildStreamSuffix('-level:v', streamNum) + ' 3.1') + + if (fps) { + // Keyframe interval of 2 seconds for faster seeking and resolution switching. + // https://streaminglearningcenter.com/blogs/whats-the-right-keyframe-interval.html + // https://superuser.com/a/908325 + command.outputOption(buildStreamSuffix('-g:v', streamNum) + ' ' + (fps * 2)) + } } +} +function addDefaultLiveHLSParams (command: FfmpegCommand, outPath: string, masterPlaylistName: string) { + command.outputOption('-hls_time ' + VIDEO_LIVE.SEGMENT_TIME_SECONDS) + command.outputOption('-hls_list_size ' + VIDEO_LIVE.SEGMENTS_LIST_SIZE) + command.outputOption('-hls_flags delete_segments+independent_segments') command.outputOption(`-hls_segment_filename ${join(outPath, '%v-%06d.ts')}`) - command.outputOption('-master_pl_name master.m3u8') + command.outputOption('-master_pl_name ' + masterPlaylistName) command.outputOption(`-f hls`) command.output(join(outPath, '%v.m3u8')) } -async function buildx264Command (command: ffmpeg.FfmpegCommand, options: TranscodeOptions) { +// --------------------------------------------------------------------------- +// Transcode VOD command builders +// --------------------------------------------------------------------------- + +async function buildx264VODCommand (command: FfmpegCommand, options: TranscodeOptions) { let fps = await getVideoFileFPS(options.inputPath) - if ( - // On small/medium resolutions, limit FPS - options.resolution !== undefined && - options.resolution < VIDEO_TRANSCODING_FPS.KEEP_ORIGIN_FPS_RESOLUTION_MIN && - fps > VIDEO_TRANSCODING_FPS.AVERAGE - ) { - // Get closest standard framerate by modulo: downsampling has to be done to a divisor of the nominal fps value - fps = getClosestFramerateStandard(fps, 'STANDARD') - } + fps = computeFPS(fps, options.resolution) - command = await presetH264(command, options.inputPath, options.resolution, fps) + let scaleFilterValue: string if (options.resolution !== undefined) { - // '?x720' or '720x?' for example - const size = options.isPortraitMode === true ? `${options.resolution}x?` : `?x${options.resolution}` - command = command.size(size) + scaleFilterValue = options.isPortraitMode === true + ? `w=${options.resolution}:h=-2` + : `w=-2:h=${options.resolution}` } - if (fps) { - // Hard FPS limits - if (fps > VIDEO_TRANSCODING_FPS.MAX) fps = getClosestFramerateStandard(fps, 'HD_STANDARD') - else if (fps < VIDEO_TRANSCODING_FPS.MIN) fps = VIDEO_TRANSCODING_FPS.MIN - - command = command.withFPS(fps) - } + command = await presetVideo({ command, input: options.inputPath, transcodeOptions: options, fps, scaleFilterValue }) return command } -async function buildAudioMergeCommand (command: ffmpeg.FfmpegCommand, options: MergeAudioTranscodeOptions) { +async function buildAudioMergeCommand (command: FfmpegCommand, options: MergeAudioTranscodeOptions) { command = command.loop(undefined) - command = await presetH264VeryFast(command, options.audioPath, options.resolution) + const scaleFilterValue = getScaleCleanerValue() + command = await presetVideo({ command, input: options.audioPath, transcodeOptions: options, scaleFilterValue }) + + command.outputOption('-preset:v veryfast') command = command.input(options.audioPath) - .videoFilter('scale=trunc(iw/2)*2:trunc(ih/2)*2') // Avoid "height not divisible by 2" error .outputOption('-tune stillimage') .outputOption('-shortest') return command } -function buildOnlyAudioCommand (command: ffmpeg.FfmpegCommand, _options: OnlyAudioTranscodeOptions) { +function buildOnlyAudioCommand (command: FfmpegCommand, _options: OnlyAudioTranscodeOptions) { command = presetOnlyAudio(command) return command } -function buildQuickTranscodeCommand (command: ffmpeg.FfmpegCommand) { +function buildQuickTranscodeCommand (command: FfmpegCommand) { command = presetCopy(command) command = command.outputOption('-map_metadata -1') // strip all metadata @@ -372,30 +455,46 @@ function buildQuickTranscodeCommand (command: ffmpeg.FfmpegCommand) { return command } -async function buildHLSVODCommand (command: ffmpeg.FfmpegCommand, options: HLSTranscodeOptions) { +function addCommonHLSVODCommandOptions (command: FfmpegCommand, outputPath: string) { + return command.outputOption('-hls_time 4') + .outputOption('-hls_list_size 0') + .outputOption('-hls_playlist_type vod') + .outputOption('-hls_segment_filename ' + outputPath) + .outputOption('-hls_segment_type fmp4') + .outputOption('-f hls') + .outputOption('-hls_flags single_file') +} + +async function buildHLSVODCommand (command: FfmpegCommand, options: HLSTranscodeOptions) { const videoPath = getHLSVideoPath(options) if (options.copyCodecs) command = presetCopy(command) else if (options.resolution === VideoResolution.H_NOVIDEO) command = presetOnlyAudio(command) - else command = await buildx264Command(command, options) + else command = await buildx264VODCommand(command, options) - command = command.outputOption('-hls_time 4') - .outputOption('-hls_list_size 0') - .outputOption('-hls_playlist_type vod') - .outputOption('-hls_segment_filename ' + videoPath) - .outputOption('-hls_segment_type fmp4') - .outputOption('-f hls') - .outputOption('-hls_flags single_file') + addCommonHLSVODCommandOptions(command, videoPath) return command } -function getHLSVideoPath (options: HLSTranscodeOptions) { - return `${dirname(options.outputPath)}/${options.hlsPlaylist.videoFilename}` +function buildHLSVODFromTSCommand (command: FfmpegCommand, options: HLSFromTSTranscodeOptions) { + const videoPath = getHLSVideoPath(options) + + command.outputOption('-c copy') + + if (options.isAAC) { + // Required for example when copying an AAC stream from an MPEG-TS + // Since it's a bitstream filter, we don't need to reencode the audio + command.outputOption('-bsf:a aac_adtstoasc') + } + + addCommonHLSVODCommandOptions(command, videoPath) + + return command } async function fixHLSPlaylistIfNeeded (options: TranscodeOptions) { - if (options.type !== 'hls') return + if (options.type !== 'hls' && options.type !== 'hls-from-ts') return const fileContent = await readFile(options.outputPath) @@ -409,101 +508,274 @@ async function fixHLSPlaylistIfNeeded (options: TranscodeOptions) { await writeFile(options.outputPath, newContent) } -/** - * A slightly customised version of the 'veryfast' x264 preset - * - * The veryfast preset is right in the sweet spot of performance - * and quality. Superfast and ultrafast will give you better - * performance, but then quality is noticeably worse. - */ -async function presetH264VeryFast (command: ffmpeg.FfmpegCommand, input: string, resolution: VideoResolution, fps?: number) { - let localCommand = await presetH264(command, input, resolution, fps) +function getHLSVideoPath (options: HLSTranscodeOptions | HLSFromTSTranscodeOptions) { + return `${dirname(options.outputPath)}/${options.hlsPlaylist.videoFilename}` +} - localCommand = localCommand.outputOption('-preset:v veryfast') +// --------------------------------------------------------------------------- +// Transcoding presets +// --------------------------------------------------------------------------- - /* - MAIN reference: https://slhck.info/video/2017/03/01/rate-control.html - Our target situation is closer to a livestream than a stream, - since we want to reduce as much a possible the encoding burden, - although not to the point of a livestream where there is a hard - constraint on the frames per second to be encoded. - */ +// Run encoder builder depending on available encoders +// Try encoders by priority: if the encoder is available, run the chosen profile or fallback to the default one +// If the default one does not exist, check the next encoder +async function getEncoderBuilderResult (options: EncoderOptionsBuilderParams & { + streamType: 'video' | 'audio' + input: string - return localCommand + availableEncoders: AvailableEncoders + profile: string + + videoType: 'vod' | 'live' +}) { + const { availableEncoders, profile, streamType, videoType } = options + + const encodersToTry = availableEncoders.encodersToTry[videoType][streamType] + const encoders = availableEncoders.available[videoType] + + for (const encoder of encodersToTry) { + if (!(await checkFFmpegEncoders(availableEncoders)).get(encoder)) { + logger.debug('Encoder %s not available in ffmpeg, skipping.', encoder, lTags()) + continue + } + + if (!encoders[encoder]) { + logger.debug('Encoder %s not available in peertube encoders, skipping.', encoder, lTags()) + continue + } + + // An object containing available profiles for this encoder + const builderProfiles: EncoderProfile = encoders[encoder] + let builder = builderProfiles[profile] + + if (!builder) { + logger.debug('Profile %s for encoder %s not available. Fallback to default.', profile, encoder, lTags()) + builder = builderProfiles.default + + if (!builder) { + logger.debug('Default profile for encoder %s not available. Try next available encoder.', encoder, lTags()) + continue + } + } + + const result = await builder(pick(options, [ 'input', 'resolution', 'inputBitrate', 'fps', 'inputRatio', 'streamNum' ])) + + return { + result, + + // If we don't have output options, then copy the input stream + encoder: result.copy === true + ? 'copy' + : encoder + } + } + + return null } -/** - * Standard profile, with variable bitrate audio and faststart. - * - * As for the audio, quality '5' is the highest and ensures 96-112kbps/channel - * See https://trac.ffmpeg.org/wiki/Encode/AAC#fdk_vbr - */ -async function presetH264 (command: ffmpeg.FfmpegCommand, input: string, resolution: VideoResolution, fps?: number) { +async function presetVideo (options: { + command: FfmpegCommand + input: string + transcodeOptions: TranscodeOptions + fps?: number + scaleFilterValue?: string +}) { + const { command, input, transcodeOptions, fps, scaleFilterValue } = options + let localCommand = command .format('mp4') - .videoCodec('libx264') .outputOption('-movflags faststart') - addDefaultX264Params(localCommand) + addDefaultEncoderGlobalParams({ command }) - const parsedAudio = await getAudioStream(input) + const probe = await ffprobePromise(input) + + // Audio encoder + const parsedAudio = await getAudioStream(input, probe) + const bitrate = await getVideoFileBitrate(input, probe) + const { ratio } = await getVideoFileResolution(input, probe) + + let streamsToProcess: StreamType[] = [ 'audio', 'video' ] if (!parsedAudio.audioStream) { localCommand = localCommand.noAudio() - } else if ((await checkFFmpegEncoders()).get('libfdk_aac')) { // we favor VBR, if a good AAC encoder is available - localCommand = localCommand - .audioCodec('libfdk_aac') - .audioQuality(5) - } else { - // 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 - localCommand = localCommand.audioCodec('aac') + streamsToProcess = [ 'video' ] + } + + for (const streamType of streamsToProcess) { + const { profile, resolution, availableEncoders } = transcodeOptions + + const builderResult = await getEncoderBuilderResult({ + streamType, + input, + resolution, + availableEncoders, + profile, + fps, + inputBitrate: bitrate, + inputRatio: ratio, + videoType: 'vod' as 'vod' + }) - const audioCodecName = parsedAudio.audioStream['codec_name'] + if (!builderResult) { + throw new Error('No available encoder found for stream ' + streamType) + } - const bitrate = getMaxAudioBitrate(audioCodecName, parsedAudio.bitrate) + logger.debug( + 'Apply ffmpeg params from %s for %s stream of input %s using %s profile.', + builderResult.encoder, streamType, input, profile, + { builderResult, resolution, fps, ...lTags() } + ) - if (bitrate !== undefined && bitrate !== -1) localCommand = localCommand.audioBitrate(bitrate) - } + if (streamType === 'video') { + localCommand.videoCodec(builderResult.encoder) - if (fps) { - // Constrained Encoding (VBV) - // https://slhck.info/video/2017/03/01/rate-control.html - // https://trac.ffmpeg.org/wiki/Limiting%20the%20output%20bitrate - const targetBitrate = getTargetBitrate(resolution, fps, VIDEO_TRANSCODING_FPS) - localCommand = localCommand.outputOptions([ `-maxrate ${targetBitrate}`, `-bufsize ${targetBitrate * 2}` ]) - - // Keyframe interval of 2 seconds for faster seeking and resolution switching. - // https://streaminglearningcenter.com/blogs/whats-the-right-keyframe-interval.html - // https://superuser.com/a/908325 - localCommand = localCommand.outputOption(`-g ${fps * 2}`) + if (scaleFilterValue) { + localCommand.outputOption(`-vf ${getScaleFilter(builderResult.result)}=${scaleFilterValue}`) + } + } else if (streamType === 'audio') { + localCommand.audioCodec(builderResult.encoder) + } + + applyEncoderOptions(localCommand, builderResult.result) + addDefaultEncoderParams({ command: localCommand, encoder: builderResult.encoder, fps }) } return localCommand } -function presetCopy (command: ffmpeg.FfmpegCommand): ffmpeg.FfmpegCommand { +function presetCopy (command: FfmpegCommand): FfmpegCommand { return command .format('mp4') .videoCodec('copy') .audioCodec('copy') } -function presetOnlyAudio (command: ffmpeg.FfmpegCommand): ffmpeg.FfmpegCommand { +function presetOnlyAudio (command: FfmpegCommand): FfmpegCommand { return command .format('mp4') .audioCodec('copy') .noVideo() } -function getFFmpeg (input: string) { +function applyEncoderOptions (command: FfmpegCommand, options: EncoderOptions): FfmpegCommand { + return command + .inputOptions(options.inputOptions ?? []) + .outputOptions(options.outputOptions ?? []) +} + +function getScaleFilter (options: EncoderOptions): string { + if (options.scaleFilter) return options.scaleFilter.name + + return 'scale' +} + +// --------------------------------------------------------------------------- +// Utils +// --------------------------------------------------------------------------- + +function getFFmpeg (input: string, type: 'live' | 'vod') { // We set cwd explicitly because ffmpeg appears to create temporary files when trancoding which fails in read-only file systems - const command = ffmpeg(input, { niceness: FFMPEG_NICE.TRANSCODING, cwd: CONFIG.STORAGE.TMP_DIR }) + const command = ffmpeg(input, { + niceness: type === 'live' ? FFMPEG_NICE.LIVE : FFMPEG_NICE.VOD, + cwd: CONFIG.STORAGE.TMP_DIR + }) - if (CONFIG.TRANSCODING.THREADS > 0) { + const threads = type === 'live' + ? CONFIG.LIVE.TRANSCODING.THREADS + : CONFIG.TRANSCODING.THREADS + + if (threads > 0) { // If we don't set any threads ffmpeg will chose automatically - command.outputOption('-threads ' + CONFIG.TRANSCODING.THREADS) + command.outputOption('-threads ' + threads) } return command } + +function getFFmpegVersion () { + return new Promise((res, rej) => { + (ffmpeg() as any)._getFfmpegPath((err, ffmpegPath) => { + if (err) return rej(err) + if (!ffmpegPath) return rej(new Error('Could not find ffmpeg path')) + + return execPromise(`${ffmpegPath} -version`) + .then(stdout => { + const parsed = stdout.match(/ffmpeg version .?(\d+\.\d+(\.\d+)?)/) + if (!parsed || !parsed[1]) return rej(new Error(`Could not find ffmpeg version in ${stdout}`)) + + // Fix ffmpeg version that does not include patch version (4.4 for example) + let version = parsed[1] + if (version.match(/^\d+\.\d+$/)) { + version += '.0' + } + + return res(version) + }) + .catch(err => rej(err)) + }) + }) +} + +async function runCommand (options: { + command: FfmpegCommand + silent?: boolean // false + job?: Job +}) { + const { command, silent = false, job } = options + + return new Promise((res, rej) => { + let shellCommand: string + + command.on('start', cmdline => { shellCommand = cmdline }) + + command.on('error', (err, stdout, stderr) => { + if (silent !== true) logger.error('Error in ffmpeg.', { stdout, stderr, shellCommand, ...lTags() }) + + rej(err) + }) + + command.on('end', (stdout, stderr) => { + logger.debug('FFmpeg command ended.', { stdout, stderr, shellCommand, ...lTags() }) + + res() + }) + + if (job) { + command.on('progress', progress => { + if (!progress.percent) return + + job.progress(Math.round(progress.percent)) + .catch(err => logger.warn('Cannot set ffmpeg job progress.', { err, ...lTags() })) + }) + } + + command.run() + }) +} + +// Avoid "height not divisible by 2" error +function getScaleCleanerValue () { + return 'trunc(iw/2)*2:trunc(ih/2)*2' +} + +// --------------------------------------------------------------------------- + +export { + getLiveTranscodingCommand, + getLiveMuxingCommand, + buildStreamSuffix, + convertWebPToJPG, + processGIF, + generateImageFromVideoFile, + TranscodeOptions, + TranscodeOptionsType, + transcode, + runCommand, + getFFmpegVersion, + + resetSupportedEncoders, + + // builders + buildx264VODCommand +}