Skip to content

ActivityPub-federated video streaming platform using P2P directly in your web browser

Fix filter graph with studio

Chocobozzz7fcc9a00d6d1
diff --git a/packages/ffmpeg/src/ffmpeg-edition.ts b/packages/ffmpeg/src/ffmpeg-edition.ts
index c31cb00436..0a9d37f644 100644
--- a/packages/ffmpeg/src/ffmpeg-edition.ts
+++ b/packages/ffmpeg/src/ffmpeg-edition.ts
@@ -47,7 +47,9 @@ export class FFmpegEdition {
videoStreamOnly: false,
fps,
canCopyAudio: false,
- canCopyVideo: false
+ canCopyVideo: false,
+
+ chainComplexFilters: null
})
if (options.start) {
@@ -78,50 +80,54 @@ export class FFmpegEdition {
const fps = await getVideoStreamFPS(videoInputPath, videoProbe)
const { resolution, height } = await getVideoStreamDimensionsInfo(videoInputPath, videoProbe)
- const command = this.commandWrapper.buildCommand([ ...this.buildInputs(options), watermarkPath ], inputFileMutexReleaser)
+ this.commandWrapper.buildCommand([ ...this.buildInputs(options), watermarkPath ], inputFileMutexReleaser)
.output(outputPath)
- await presetVOD({
- commandWrapper: this.commandWrapper,
-
- videoInputPath,
- separatedAudioInputPath,
-
- resolution,
- videoStreamOnly: false,
- fps,
- canCopyAudio: true,
- canCopyVideo: false
- })
-
const videoInput = 0
const imageInput = separatedAudioInputPath
? 2
: 1
- const complexFilter: FilterSpecification[] = [
+ const complexFilters: FilterSpecification[] = [
// Scale watermark
{
- inputs: [ `[${imageInput}]` ],
+ inputs: [ `${imageInput}` ],
filter: 'scale',
options: {
w: '-1',
h: `${height * videoFilters.watermarkSizeRatio}`
},
- outputs: [ '[watermark]' ]
+ outputs: [ 'v_watermark' ]
},
{
- inputs: [ `[${videoInput}]`, '[watermark]' ],
+ inputs: [ `${videoInput}`, 'v_watermark' ],
filter: 'overlay',
options: {
x: `main_w - overlay_w - (main_h * ${videoFilters.horizontalMarginRatio})`,
y: `main_h * ${videoFilters.verticalMarginRatio}`
- }
+ },
+ outputs: [ 'v_overlay' ]
}
]
- command.complexFilter(complexFilter)
+ await presetVOD({
+ commandWrapper: this.commandWrapper,
+
+ videoInputPath,
+ separatedAudioInputPath,
+
+ resolution,
+ videoStreamOnly: false,
+ fps,
+ canCopyAudio: true,
+ canCopyVideo: false,
+
+ chainComplexFilters: {
+ complexFilters,
+ lastVideoInput: 'v_overlay'
+ }
+ })
await this.commandWrapper.runCommand()
}
@@ -166,21 +172,8 @@ export class FFmpegEdition {
introAudio++
}
- await presetVOD({
- commandWrapper: this.commandWrapper,
-
- videoInputPath,
- separatedAudioInputPath,
-
- resolution,
- videoStreamOnly: false,
- fps,
- canCopyAudio: false,
- canCopyVideo: false
- })
-
// Add black background to correctly scale intro/outro with padding
- const complexFilter: FilterSpecification[] = [
+ const complexFilters: FilterSpecification[] = [
{
inputs: [ `${introInput}`, `${videoInput}` ],
filter: 'scale2ref',
@@ -230,14 +223,14 @@ export class FFmpegEdition {
]
const concatFilter = {
- inputs: [],
+ inputs: [], // Defined later as it depends on the presence of audio and the type (intro or outro)
filter: 'concat',
options: {
n: 2,
v: 1,
unsafe: 1
},
- outputs: [ 'v' ]
+ outputs: [ 'concat' ]
}
const introOutroFilterInputs = [ 'intro-outro-resized' ]
@@ -257,15 +250,33 @@ export class FFmpegEdition {
if (mainHasAudio) {
concatFilter.options['a'] = 1
- concatFilter.outputs.push('a')
+ concatFilter.outputs.push('a_out')
- command.outputOption('-map [a]')
+ command.outputOption('-map [a_out]')
}
- command.outputOption('-map [v]')
+ command.outputOption('-map [v_out]')
- complexFilter.push(concatFilter)
- command.complexFilter(complexFilter)
+ complexFilters.push(concatFilter)
+
+ await presetVOD({
+ commandWrapper: this.commandWrapper,
+
+ videoInputPath,
+ separatedAudioInputPath,
+
+ resolution,
+ videoStreamOnly: false,
+ fps,
+ canCopyAudio: false,
+ canCopyVideo: false,
+
+ chainComplexFilters: {
+ complexFilters,
+ lastVideoInput: 'concat',
+ videoOutput: 'v_out'
+ }
+ })
await this.commandWrapper.runCommand()
}
@@ -303,50 +314,36 @@ export class FFmpegEdition {
const command = this.commandWrapper.buildCommand(this.buildInputs(options), inputFileMutexReleaser)
.output(outputPath)
- await presetVOD({
- commandWrapper: this.commandWrapper,
-
- videoInputPath,
- separatedAudioInputPath,
-
- resolution,
- videoStreamOnly: false,
- fps,
- canCopyAudio: false,
- canCopyVideo: false
- })
-
- const N = keepIntervals.length
- const complexFilter: FilterSpecification[] = []
+ const complexFilters: FilterSpecification[] = []
// Split input streams so each keep interval gets its own copy
- complexFilter.push({
+ complexFilters.push({
inputs: [ `${videoInput}:v` ],
filter: 'split',
- options: N,
+ options: keepIntervals.length,
outputs: keepIntervals.map((_, i) => `vsrc${i}`)
})
if (mainHasAudio) {
- complexFilter.push({
+ complexFilters.push({
inputs: [ `${audioInput}:a` ],
filter: 'asplit',
- options: N,
+ options: keepIntervals.length,
outputs: keepIntervals.map((_, i) => `asrc${i}`)
})
}
// Trim each keep interval and reset timestamps
- for (let i = 0; i < N; i++) {
+ for (let i = 0; i < keepIntervals.length; i++) {
const { start, end } = keepIntervals[i]
- complexFilter.push(
+ complexFilters.push(
{ inputs: [ `vsrc${i}` ], filter: 'trim', options: { start, end }, outputs: [ `vtrimmed${i}` ] },
{ inputs: [ `vtrimmed${i}` ], filter: 'setpts', options: 'PTS-STARTPTS', outputs: [ `v${i}` ] }
)
if (mainHasAudio) {
- complexFilter.push(
+ complexFilters.push(
{ inputs: [ `asrc${i}` ], filter: 'atrim', options: { start, end }, outputs: [ `atrimmed${i}` ] },
{ inputs: [ `atrimmed${i}` ], filter: 'asetpts', options: 'PTS-STARTPTS', outputs: [ `a${i}` ] }
)
@@ -355,29 +352,47 @@ export class FFmpegEdition {
// Concatenate all keep intervals
const concatInputs: string[] = []
- for (let i = 0; i < N; i++) {
+ for (let i = 0; i < keepIntervals.length; i++) {
concatInputs.push(`v${i}`)
if (mainHasAudio) concatInputs.push(`a${i}`)
}
- const concatOptions: Record<string, number> = { n: N, v: 1 }
- const concatOutputs = [ 'vout' ]
+ const concatOptions: Record<string, number> = { n: keepIntervals.length, v: 1 }
+ const concatOutputs = [ 'v_concat' ]
if (mainHasAudio) {
concatOptions.a = 1
- concatOutputs.push('aout')
+ concatOutputs.push('a_out')
}
- complexFilter.push({
+ complexFilters.push({
inputs: concatInputs,
filter: 'concat',
options: concatOptions,
outputs: concatOutputs
})
- command.complexFilter(complexFilter)
- command.outputOption('-map [vout]')
- if (mainHasAudio) command.outputOption('-map [aout]')
+ await presetVOD({
+ commandWrapper: this.commandWrapper,
+
+ videoInputPath,
+ separatedAudioInputPath,
+
+ resolution,
+ videoStreamOnly: false,
+ fps,
+ canCopyAudio: false,
+ canCopyVideo: false,
+
+ chainComplexFilters: {
+ complexFilters,
+ lastVideoInput: 'v_concat',
+ videoOutput: 'v_out'
+ }
+ })
+
+ command.outputOption('-map [v_out]')
+ if (mainHasAudio) command.outputOption('-map [a_out]')
await this.commandWrapper.runCommand()
}
diff --git a/packages/ffmpeg/src/ffmpeg-vod.ts b/packages/ffmpeg/src/ffmpeg-vod.ts
index 0c7cbc340d..ac7516be3e 100644
--- a/packages/ffmpeg/src/ffmpeg-vod.ts
+++ b/packages/ffmpeg/src/ffmpeg-vod.ts
@@ -146,7 +146,9 @@ export class FFmpegVOD {
canCopyAudio,
canCopyVideo,
fps,
- scaleFilterValue
+ scaleFilterValue,
+
+ chainComplexFilters: null
})
}
@@ -177,7 +179,9 @@ export class FFmpegVOD {
canCopyVideo: true,
videoStreamOnly: false,
fps: options.fps,
- scaleFilterValue: this.getScaleFilterValue({ resolution: options.resolution, portraitMode: false })
+ scaleFilterValue: this.getScaleFilterValue({ resolution: options.resolution, portraitMode: false }),
+
+ chainComplexFilters: null
})
command.outputOption('-preset:v veryfast')
diff --git a/packages/ffmpeg/src/shared/presets.ts b/packages/ffmpeg/src/shared/presets.ts
index 030b89b4ce..39796ae304 100644
--- a/packages/ffmpeg/src/shared/presets.ts
+++ b/packages/ffmpeg/src/shared/presets.ts
@@ -1,4 +1,5 @@
import { pick } from '@peertube/peertube-core-utils'
+import { FilterSpecification } from 'fluent-ffmpeg'
import { FFmpegCommandWrapper } from '../ffmpeg-command-wrapper.js'
import { getScaleFilter, StreamType } from '../ffmpeg-utils.js'
import { ffprobePromise, getVideoStreamBitrate, getVideoStreamDimensionsInfo, hasAudioStream } from '../ffprobe.js'
@@ -18,9 +19,24 @@ export async function presetVOD (options: {
videoStreamOnly: boolean
+ chainComplexFilters: {
+ complexFilters: FilterSpecification[]
+ lastVideoInput: string
+ videoOutput?: string
+ } | null
+
scaleFilterValue?: string
}) {
- const { commandWrapper, videoInputPath, separatedAudioInputPath, resolution, fps, videoStreamOnly, scaleFilterValue } = options
+ const {
+ commandWrapper,
+ videoInputPath,
+ separatedAudioInputPath,
+ resolution,
+ fps,
+ videoStreamOnly,
+ scaleFilterValue,
+ chainComplexFilters
+ } = options
if (videoStreamOnly && !resolution) {
throw new Error('Cannot generate video stream only without valid resolution')
@@ -88,23 +104,24 @@ export async function presetVOD (options: {
if (streamType === 'video') {
command.videoCodec(builderResult.encoder)
- const videoFilters: string[] = []
+ const videoFilters: { name: string, rawOptions?: string }[] = []
if (scaleFilterValue) {
- videoFilters.push(`${getScaleFilter(builderResult.result)}=${scaleFilterValue}`)
+ videoFilters.push({
+ name: getScaleFilter(builderResult.result),
+ rawOptions: scaleFilterValue
+ })
}
for (const builderVideoFilter of builderResult.result.videoFilters || []) {
- videoFilters.push(
- builderVideoFilter.rawOptions
- ? `${builderVideoFilter.name}=${builderVideoFilter.rawOptions}`
- : builderVideoFilter.name
- )
+ videoFilters.push(builderVideoFilter)
}
- if (videoFilters.length > 0) {
- command.outputOption(`-vf ${videoFilters.join(',')}`)
- }
+ applyVideoFilters({
+ commandWrapper,
+ videoFilters,
+ chainComplexFilters
+ })
} else if (streamType === 'audio') {
command.audioCodec(builderResult.encoder)
}
@@ -128,3 +145,65 @@ export function presetCopy (commandWrapper: FFmpegCommandWrapper, options: {
if (options.withVideo === false) command.noVideo()
else command.videoCodec('copy')
}
+
+// ---------------------------------------------------------------------------
+// Private
+// ---------------------------------------------------------------------------
+
+function applyVideoFilters (options: {
+ commandWrapper: FFmpegCommandWrapper
+
+ videoFilters: { name: string, rawOptions?: string }[]
+
+ chainComplexFilters: {
+ complexFilters: FilterSpecification[]
+ lastVideoInput: string
+ videoOutput?: string
+ } | null
+}) {
+ const { commandWrapper, videoFilters, chainComplexFilters } = options
+
+ const command = commandWrapper.getCommand()
+
+ if (videoFilters.length === 0) return
+
+ // We can't use `-vf` option if we have complex filters
+ if (chainComplexFilters) {
+ const complexFilters = [ ...chainComplexFilters.complexFilters ]
+
+ for (let i = 0; i < videoFilters.length; i++) {
+ const videoFilter = videoFilters[i]
+
+ const outputName = i === videoFilters.length - 1
+ ? chainComplexFilters.videoOutput
+ : `vf_${i}`
+
+ const inputName = i === 0
+ ? chainComplexFilters.lastVideoInput
+ : `vf_${i - 1}`
+
+ complexFilters.push({
+ filter: videoFilter.name,
+ inputs: [ inputName ],
+
+ outputs: outputName
+ ? [ outputName ]
+ : undefined,
+
+ options: videoFilter.rawOptions
+ })
+ }
+
+ command.complexFilter(complexFilters)
+ } else {
+ const filterString = videoFilters
+ .map(f => {
+ if (f.rawOptions) return `${f.name}=${f.rawOptions}`
+
+ return f.name
+ })
+ .join(',')
+
+ command.outputOption(`-vf ${filterString}`)
+ }
+}