mirror of https://github.com/ErsatzTV/ErsatzTV.git
Browse Source
* remove unused pipeline * spike vaapi hardware capabilities * more vaapi capabilities * use proper vaapi driver * update readme * update dependenciespull/1015/head
Jason Dove
3 years ago
committed by
GitHub
38 changed files with 470 additions and 1166 deletions
@ -0,0 +1,7 @@
@@ -0,0 +1,7 @@
|
||||
namespace ErsatzTV.FFmpeg.Capabilities.Vaapi; |
||||
|
||||
public class VaapiEntrypoint |
||||
{ |
||||
public const string Decode = "VAEntrypointVLD"; |
||||
public const string Encode = "VAEntrypointEncSlice"; |
||||
} |
||||
@ -0,0 +1,17 @@
@@ -0,0 +1,17 @@
|
||||
namespace ErsatzTV.FFmpeg.Capabilities.Vaapi; |
||||
|
||||
public class VaapiProfile |
||||
{ |
||||
public const string Mpeg2Simple = "VAProfileMPEG2Simple"; |
||||
public const string Mpeg2Main = "VAProfileMPEG2Main"; |
||||
public const string H264ConstrainedBaseline = "VAProfileH264ConstrainedBaseline"; |
||||
public const string H264Main = "VAProfileH264Main"; |
||||
public const string H264High = "VAProfileH264High"; |
||||
public const string H264MultiviewHigh = "VAProfileH264MultiviewHigh"; |
||||
public const string H264StereoHigh = "VAProfileH264StereoHigh"; |
||||
public const string Vc1Simple = "VAProfileVC1Simple"; |
||||
public const string Vc1Main = "VAProfileVC1Main"; |
||||
public const string Vc1Advanced = "VAProfileVC1Advanced"; |
||||
public const string HevcMain = "VAProfileHEVCMain"; |
||||
public const string HevcMain10 = "VAProfileHEVCMain10"; |
||||
} |
||||
@ -0,0 +1,3 @@
@@ -0,0 +1,3 @@
|
||||
namespace ErsatzTV.FFmpeg.Capabilities.Vaapi; |
||||
|
||||
public record VaapiProfileEntrypoint(string VaapiProfile, string VaapiEntrypoint); |
||||
@ -0,0 +1,123 @@
@@ -0,0 +1,123 @@
|
||||
using ErsatzTV.FFmpeg.Capabilities.Vaapi; |
||||
using ErsatzTV.FFmpeg.Format; |
||||
using Microsoft.Extensions.Logging; |
||||
|
||||
namespace ErsatzTV.FFmpeg.Capabilities; |
||||
|
||||
public class VaapiHardwareCapabilities : IHardwareCapabilities |
||||
{ |
||||
private readonly List<VaapiProfileEntrypoint> _profileEntrypoints; |
||||
private readonly ILogger _logger; |
||||
|
||||
public VaapiHardwareCapabilities(List<VaapiProfileEntrypoint> profileEntrypoints, ILogger logger) |
||||
{ |
||||
_profileEntrypoints = profileEntrypoints; |
||||
_logger = logger; |
||||
} |
||||
|
||||
public bool CanDecode(string videoFormat, string videoProfile, Option<IPixelFormat> maybePixelFormat) |
||||
{ |
||||
int bitDepth = maybePixelFormat.Map(pf => pf.BitDepth).IfNone(8); |
||||
|
||||
bool result = (videoFormat, videoProfile.ToLowerInvariant()) switch |
||||
{ |
||||
// no hardware decoding of 10-bit h264
|
||||
(VideoFormat.H264, _) when bitDepth == 10 => false, |
||||
|
||||
// no hardware decoding of h264 baseline profile
|
||||
(VideoFormat.H264, "baseline" or "66") => false, |
||||
|
||||
(VideoFormat.H264, "main" or "77") => |
||||
_profileEntrypoints.Contains( |
||||
new VaapiProfileEntrypoint(VaapiProfile.H264Main, VaapiEntrypoint.Decode)), |
||||
|
||||
(VideoFormat.H264, "high" or "100") => |
||||
_profileEntrypoints.Contains( |
||||
new VaapiProfileEntrypoint(VaapiProfile.H264High, VaapiEntrypoint.Decode)), |
||||
|
||||
(VideoFormat.H264, "high 10" or "110") => |
||||
_profileEntrypoints.Contains( |
||||
new VaapiProfileEntrypoint(VaapiProfile.H264High, VaapiEntrypoint.Decode)), |
||||
|
||||
(VideoFormat.H264, "baseline constrained" or "578") => |
||||
_profileEntrypoints.Contains( |
||||
new VaapiProfileEntrypoint(VaapiProfile.H264ConstrainedBaseline, VaapiEntrypoint.Decode)), |
||||
|
||||
(VideoFormat.Mpeg2Video, "main" or "4") => |
||||
_profileEntrypoints.Contains( |
||||
new VaapiProfileEntrypoint(VaapiProfile.Mpeg2Main, VaapiEntrypoint.Decode)), |
||||
|
||||
(VideoFormat.Mpeg2Video, "simple" or "5") => |
||||
_profileEntrypoints.Contains( |
||||
new VaapiProfileEntrypoint(VaapiProfile.Mpeg2Simple, VaapiEntrypoint.Decode)), |
||||
|
||||
(VideoFormat.Vc1, "simple" or "0") => |
||||
_profileEntrypoints.Contains( |
||||
new VaapiProfileEntrypoint(VaapiProfile.Vc1Simple, VaapiEntrypoint.Decode)), |
||||
|
||||
(VideoFormat.Vc1, "main" or "1") => |
||||
_profileEntrypoints.Contains( |
||||
new VaapiProfileEntrypoint(VaapiProfile.Vc1Main, VaapiEntrypoint.Decode)), |
||||
|
||||
(VideoFormat.Vc1, "advanced" or "3") => |
||||
_profileEntrypoints.Contains( |
||||
new VaapiProfileEntrypoint(VaapiProfile.Vc1Advanced, VaapiEntrypoint.Decode)), |
||||
|
||||
(VideoFormat.Hevc, "main" or "1") => |
||||
_profileEntrypoints.Contains( |
||||
new VaapiProfileEntrypoint(VaapiProfile.HevcMain, VaapiEntrypoint.Decode)), |
||||
|
||||
(VideoFormat.Hevc, "main 10" or "2") => |
||||
_profileEntrypoints.Contains( |
||||
new VaapiProfileEntrypoint(VaapiProfile.HevcMain10, VaapiEntrypoint.Decode)), |
||||
|
||||
// fall back to software decoder
|
||||
_ => false |
||||
}; |
||||
|
||||
if (!result) |
||||
{ |
||||
_logger.LogDebug( |
||||
"VAAPI does not support decoding {Format}/{Profile}, will use software decoder", |
||||
videoFormat, |
||||
videoProfile); |
||||
} |
||||
|
||||
return result; |
||||
} |
||||
|
||||
public bool CanEncode(string videoFormat, string videoProfile, Option<IPixelFormat> maybePixelFormat) |
||||
{ |
||||
int bitDepth = maybePixelFormat.Map(pf => pf.BitDepth).IfNone(8); |
||||
|
||||
bool result = videoFormat switch |
||||
{ |
||||
// vaapi cannot encode 10-bit h264
|
||||
VideoFormat.H264 when bitDepth == 10 => false, |
||||
|
||||
VideoFormat.H264 => |
||||
_profileEntrypoints.Contains( |
||||
new VaapiProfileEntrypoint(VaapiProfile.H264Main, VaapiEntrypoint.Encode)), |
||||
|
||||
VideoFormat.Hevc when bitDepth == 10 => |
||||
_profileEntrypoints.Contains( |
||||
new VaapiProfileEntrypoint(VaapiProfile.HevcMain10, VaapiEntrypoint.Encode)), |
||||
|
||||
VideoFormat.Hevc => |
||||
_profileEntrypoints.Contains( |
||||
new VaapiProfileEntrypoint(VaapiProfile.HevcMain, VaapiEntrypoint.Encode)), |
||||
|
||||
_ => false |
||||
}; |
||||
|
||||
if (!result) |
||||
{ |
||||
_logger.LogDebug( |
||||
"VAAPI does not support encoding {Format} with bit depth {BitDepth}, will use software encoder", |
||||
videoFormat, |
||||
bitDepth); |
||||
} |
||||
|
||||
return result; |
||||
} |
||||
} |
||||
@ -1,103 +0,0 @@
@@ -1,103 +0,0 @@
|
||||
using ErsatzTV.FFmpeg.Capabilities; |
||||
using ErsatzTV.FFmpeg.Decoder.Cuvid; |
||||
using ErsatzTV.FFmpeg.Decoder.Qsv; |
||||
using ErsatzTV.FFmpeg.Format; |
||||
using Microsoft.Extensions.Logging; |
||||
|
||||
namespace ErsatzTV.FFmpeg.Decoder; |
||||
|
||||
public static class AvailableDecoders |
||||
{ |
||||
public static Option<IDecoder> ForVideoFormat( |
||||
IHardwareCapabilities hardwareCapabilities, |
||||
FFmpegState ffmpegState, |
||||
FrameState currentState, |
||||
FrameState desiredState, |
||||
Option<WatermarkInputFile> watermarkInputFile, |
||||
Option<SubtitleInputFile> subtitleInputFile, |
||||
ILogger logger) => |
||||
(ffmpegState.DecoderHardwareAccelerationMode, currentState.VideoFormat, |
||||
currentState.PixelFormat.Match(pf => pf.Name, () => string.Empty)) switch |
||||
{ |
||||
(HardwareAccelerationMode.Nvenc, VideoFormat.Hevc, _) |
||||
when hardwareCapabilities.CanDecode(VideoFormat.Hevc, currentState.PixelFormat) => |
||||
new DecoderHevcCuvid(ffmpegState.EncoderHardwareAccelerationMode), |
||||
|
||||
// nvenc doesn't support hardware decoding of 10-bit content
|
||||
(HardwareAccelerationMode.Nvenc, VideoFormat.H264, PixelFormat.YUV420P10LE or PixelFormat.YUV444P10LE) |
||||
=> new DecoderH264(), |
||||
|
||||
// mpeg2_cuvid seems to have issues when yadif_cuda is used, so just use software decoding
|
||||
(HardwareAccelerationMode.Nvenc, VideoFormat.Mpeg2Video, _) when desiredState.Deinterlaced => |
||||
new DecoderMpeg2Video(), |
||||
|
||||
(HardwareAccelerationMode.Nvenc, VideoFormat.H264, _) |
||||
when hardwareCapabilities.CanDecode(VideoFormat.H264, currentState.PixelFormat) => |
||||
new DecoderH264Cuvid(ffmpegState.EncoderHardwareAccelerationMode), |
||||
(HardwareAccelerationMode.Nvenc, VideoFormat.Mpeg2Video, _) => new DecoderMpeg2Cuvid( |
||||
ffmpegState.EncoderHardwareAccelerationMode, |
||||
desiredState.Deinterlaced), |
||||
(HardwareAccelerationMode.Nvenc, VideoFormat.Vc1, _) => new DecoderVc1Cuvid(ffmpegState.EncoderHardwareAccelerationMode), |
||||
(HardwareAccelerationMode.Nvenc, VideoFormat.Vp9, _) |
||||
when hardwareCapabilities.CanDecode(VideoFormat.Vp9, currentState.PixelFormat) => |
||||
new DecoderVp9Cuvid(ffmpegState.EncoderHardwareAccelerationMode), |
||||
(HardwareAccelerationMode.Nvenc, VideoFormat.Mpeg4, _) => new DecoderMpeg4Cuvid(ffmpegState.EncoderHardwareAccelerationMode), |
||||
|
||||
// hevc_qsv decoder sometimes causes green lines with 10-bit content
|
||||
(HardwareAccelerationMode.Qsv, VideoFormat.Hevc, PixelFormat.YUV420P10LE) => new DecoderHevc(), |
||||
|
||||
// h264_qsv does not support decoding 10-bit content
|
||||
(HardwareAccelerationMode.Qsv, VideoFormat.H264, PixelFormat.YUV420P10LE or PixelFormat.YUV444P10LE) => |
||||
new DecoderH264(), |
||||
|
||||
// qsv uses software deinterlace filter, so decode in software
|
||||
(HardwareAccelerationMode.Qsv, VideoFormat.H264, _) when desiredState.Deinterlaced => new DecoderH264(), |
||||
(HardwareAccelerationMode.Qsv, VideoFormat.Mpeg2Video, _) when desiredState.Deinterlaced => |
||||
new DecoderMpeg2Video(), |
||||
|
||||
(HardwareAccelerationMode.Qsv, VideoFormat.Hevc, _) => new DecoderHevcQsv(), |
||||
(HardwareAccelerationMode.Qsv, VideoFormat.H264, _) => new DecoderH264Qsv(), |
||||
(HardwareAccelerationMode.Qsv, VideoFormat.Mpeg2Video, _) => new DecoderMpeg2Qsv(), |
||||
(HardwareAccelerationMode.Qsv, VideoFormat.Vc1, _) => new DecoderVc1Qsv(), |
||||
(HardwareAccelerationMode.Qsv, VideoFormat.Vp9, _) => new DecoderVp9Qsv(), |
||||
|
||||
// vaapi should use implicit decoders when scaling or no watermark/subtitles
|
||||
// otherwise, fall back to software decoders
|
||||
(HardwareAccelerationMode.Vaapi, _, _) when watermarkInputFile.IsNone && subtitleInputFile.IsNone || |
||||
currentState.ScaledSize != desiredState.ScaledSize => |
||||
new DecoderVaapi(), |
||||
|
||||
// videotoolbox should use implicit decoders
|
||||
(HardwareAccelerationMode.VideoToolbox, _, _) => new DecoderVideoToolbox(), |
||||
|
||||
(_, VideoFormat.Hevc, _) => new DecoderHevc(), |
||||
(_, VideoFormat.H264, _) => new DecoderH264(), |
||||
(_, VideoFormat.Mpeg1Video, _) => new DecoderMpeg1Video(), |
||||
(_, VideoFormat.Mpeg2Video, _) => new DecoderMpeg2Video(), |
||||
(_, VideoFormat.Vc1, _) => new DecoderVc1(), |
||||
(_, VideoFormat.MsMpeg4V2, _) => new DecoderMsMpeg4V2(), |
||||
(_, VideoFormat.MsMpeg4V3, _) => new DecoderMsMpeg4V3(), |
||||
(_, VideoFormat.Mpeg4, _) => new DecoderMpeg4(), |
||||
(_, VideoFormat.Vp9, _) => new DecoderVp9(), |
||||
|
||||
(_, VideoFormat.Undetermined, _) => new DecoderImplicit(), |
||||
(_, VideoFormat.Copy, _) => new DecoderImplicit(), |
||||
(_, VideoFormat.GeneratedImage, _) => new DecoderImplicit(), |
||||
|
||||
var (accel, videoFormat, pixelFormat) => LogUnknownDecoder(accel, videoFormat, pixelFormat, logger) |
||||
}; |
||||
|
||||
private static Option<IDecoder> LogUnknownDecoder( |
||||
HardwareAccelerationMode hardwareAccelerationMode, |
||||
string videoFormat, |
||||
string pixelFormat, |
||||
ILogger logger) |
||||
{ |
||||
logger.LogWarning( |
||||
"Unable to determine decoder for {AccelMode} - {VideoFormat} - {PixelFormat}; may have playback issues", |
||||
hardwareAccelerationMode, |
||||
videoFormat, |
||||
pixelFormat); |
||||
return Option<IDecoder>.None; |
||||
} |
||||
} |
||||
@ -0,0 +1,6 @@
@@ -0,0 +1,6 @@
|
||||
namespace ErsatzTV.FFmpeg.Format; |
||||
|
||||
public static class VideoProfile |
||||
{ |
||||
public const string Main = "main"; |
||||
} |
||||
@ -1,38 +0,0 @@
@@ -1,38 +0,0 @@
|
||||
using Microsoft.Extensions.Logging; |
||||
|
||||
namespace ErsatzTV.FFmpeg.Option.HardwareAcceleration; |
||||
|
||||
public static class AvailableHardwareAccelerationOptions |
||||
{ |
||||
public static Option<IPipelineStep> ForMode( |
||||
HardwareAccelerationMode mode, |
||||
Option<string> gpuDevice, |
||||
ILogger logger) => |
||||
mode switch |
||||
{ |
||||
HardwareAccelerationMode.Nvenc => new CudaHardwareAccelerationOption(), |
||||
HardwareAccelerationMode.Qsv => new QsvHardwareAccelerationOption(gpuDevice), |
||||
HardwareAccelerationMode.Vaapi => GetVaapiAcceleration(gpuDevice, logger), |
||||
HardwareAccelerationMode.VideoToolbox => new VideoToolboxHardwareAccelerationOption(), |
||||
HardwareAccelerationMode.Amf => new AmfHardwareAccelerationOption(), |
||||
HardwareAccelerationMode.None => Option<IPipelineStep>.None, |
||||
_ => LogUnknownMode(mode, logger) |
||||
}; |
||||
|
||||
private static Option<IPipelineStep> GetVaapiAcceleration(Option<string> vaapiDevice, ILogger logger) |
||||
{ |
||||
foreach (string device in vaapiDevice) |
||||
{ |
||||
return new VaapiHardwareAccelerationOption(device); |
||||
} |
||||
|
||||
logger.LogWarning("VAAPI device name is missing; falling back to software mode"); |
||||
return Option<IPipelineStep>.None; |
||||
} |
||||
|
||||
private static Option<IPipelineStep> LogUnknownMode(HardwareAccelerationMode mode, ILogger logger) |
||||
{ |
||||
logger.LogWarning("Unexpected hardware acceleration mode {AccelMode}; may have playback issues", mode); |
||||
return Option<IPipelineStep>.None; |
||||
} |
||||
} |
||||
@ -1,812 +0,0 @@
@@ -1,812 +0,0 @@
|
||||
using ErsatzTV.FFmpeg.Capabilities; |
||||
using ErsatzTV.FFmpeg.Decoder; |
||||
using ErsatzTV.FFmpeg.Encoder; |
||||
using ErsatzTV.FFmpeg.Environment; |
||||
using ErsatzTV.FFmpeg.Filter; |
||||
using ErsatzTV.FFmpeg.Filter.Cuda; |
||||
using ErsatzTV.FFmpeg.Format; |
||||
using ErsatzTV.FFmpeg.Option; |
||||
using ErsatzTV.FFmpeg.Option.HardwareAcceleration; |
||||
using ErsatzTV.FFmpeg.Option.Metadata; |
||||
using ErsatzTV.FFmpeg.OutputFormat; |
||||
using ErsatzTV.FFmpeg.Pipeline; |
||||
using ErsatzTV.FFmpeg.Protocol; |
||||
using ErsatzTV.FFmpeg.Runtime; |
||||
using ErsatzTV.FFmpeg.State; |
||||
using Microsoft.Extensions.Logging; |
||||
|
||||
namespace ErsatzTV.FFmpeg; |
||||
|
||||
public class PipelineBuilder : IPipelineBuilder |
||||
{ |
||||
private readonly Option<AudioInputFile> _audioInputFile; |
||||
private readonly string _fontsFolder; |
||||
private readonly IRuntimeInfo _runtimeInfo; |
||||
private readonly IHardwareCapabilities _hardwareCapabilities; |
||||
private readonly ILogger _logger; |
||||
private readonly List<IPipelineStep> _pipelineSteps; |
||||
private readonly string _reportsFolder; |
||||
private readonly Option<SubtitleInputFile> _subtitleInputFile; |
||||
private readonly Option<VideoInputFile> _videoInputFile; |
||||
private readonly Option<WatermarkInputFile> _watermarkInputFile; |
||||
|
||||
public PipelineBuilder( |
||||
IRuntimeInfo runtimeInfo, |
||||
IHardwareCapabilities hardwareCapabilities, |
||||
Option<VideoInputFile> videoInputFile, |
||||
Option<AudioInputFile> audioInputFile, |
||||
Option<WatermarkInputFile> watermarkInputFile, |
||||
Option<SubtitleInputFile> subtitleInputFile, |
||||
string reportsFolder, |
||||
string fontsFolder, |
||||
ILogger logger) |
||||
{ |
||||
_pipelineSteps = new List<IPipelineStep> |
||||
{ |
||||
new NoStandardInputOption(), |
||||
new HideBannerOption(), |
||||
new NoStatsOption(), |
||||
new LoglevelErrorOption(), |
||||
new StandardFormatFlags(), |
||||
new NoDemuxDecodeDelayOutputOption(), |
||||
new FastStartOutputOption(), |
||||
new ClosedGopOutputOption() |
||||
}; |
||||
|
||||
_runtimeInfo = runtimeInfo; |
||||
_hardwareCapabilities = hardwareCapabilities; |
||||
_videoInputFile = videoInputFile; |
||||
_audioInputFile = audioInputFile; |
||||
_watermarkInputFile = watermarkInputFile; |
||||
_subtitleInputFile = subtitleInputFile; |
||||
_reportsFolder = reportsFolder; |
||||
_fontsFolder = fontsFolder; |
||||
_logger = logger; |
||||
} |
||||
|
||||
public FFmpegPipeline Resize(string outputFile, FrameSize scaledSize) |
||||
{ |
||||
_pipelineSteps.Clear(); |
||||
_pipelineSteps.Add(new NoStandardInputOption()); |
||||
_pipelineSteps.Add(new HideBannerOption()); |
||||
_pipelineSteps.Add(new NoStatsOption()); |
||||
_pipelineSteps.Add(new LoglevelErrorOption()); |
||||
|
||||
IPipelineFilterStep scaleStep = new ScaleImageFilter(scaledSize); |
||||
_videoInputFile.Iter(f => f.FilterSteps.Add(scaleStep)); |
||||
|
||||
_pipelineSteps.Add(new VideoFilter(new[] { scaleStep })); |
||||
_pipelineSteps.Add(scaleStep); |
||||
_pipelineSteps.Add(new FileNameOutputOption(outputFile)); |
||||
|
||||
return new FFmpegPipeline(_pipelineSteps); |
||||
} |
||||
|
||||
public FFmpegPipeline Concat(ConcatInputFile concatInputFile, FFmpegState ffmpegState) |
||||
{ |
||||
concatInputFile.AddOption(new ConcatInputFormat()); |
||||
concatInputFile.AddOption(new RealtimeInputOption()); |
||||
concatInputFile.AddOption(new InfiniteLoopInputOption(HardwareAccelerationMode.None)); |
||||
|
||||
foreach (int threadCount in ffmpegState.ThreadCount) |
||||
{ |
||||
_pipelineSteps.Insert(0, new ThreadCountOption(threadCount)); |
||||
} |
||||
|
||||
_pipelineSteps.Add(new NoSceneDetectOutputOption(0)); |
||||
_pipelineSteps.Add(new EncoderCopyAll()); |
||||
|
||||
if (ffmpegState.DoNotMapMetadata) |
||||
{ |
||||
_pipelineSteps.Add(new DoNotMapMetadataOutputOption()); |
||||
} |
||||
|
||||
foreach (string desiredServiceProvider in ffmpegState.MetadataServiceProvider) |
||||
{ |
||||
_pipelineSteps.Add(new MetadataServiceProviderOutputOption(desiredServiceProvider)); |
||||
} |
||||
|
||||
foreach (string desiredServiceName in ffmpegState.MetadataServiceName) |
||||
{ |
||||
_pipelineSteps.Add(new MetadataServiceNameOutputOption(desiredServiceName)); |
||||
} |
||||
|
||||
_pipelineSteps.Add(new OutputFormatMpegTs()); |
||||
_pipelineSteps.Add(new PipeProtocol()); |
||||
|
||||
if (ffmpegState.SaveReport) |
||||
{ |
||||
_pipelineSteps.Add(new FFReportVariable(_reportsFolder, concatInputFile)); |
||||
} |
||||
|
||||
return new FFmpegPipeline(_pipelineSteps); |
||||
} |
||||
|
||||
public virtual FFmpegPipeline Build(FFmpegState ffmpegState, FrameState desiredState) |
||||
{ |
||||
Option<IPixelFormat> originalDesiredPixelFormat = desiredState.PixelFormat; |
||||
bool is10BitOutput = desiredState.PixelFormat.Map(pf => pf.BitDepth).IfNone(8) == 10; |
||||
|
||||
if (ffmpegState.Start.Exists(s => s > TimeSpan.Zero) && desiredState.Realtime) |
||||
{ |
||||
_logger.LogInformation( |
||||
"Forcing {Threads} ffmpeg thread due to buggy combination of stream seek and realtime output", |
||||
1); |
||||
|
||||
_pipelineSteps.Insert(0, new ThreadCountOption(1)); |
||||
} |
||||
else |
||||
{ |
||||
foreach (int threadCount in ffmpegState.ThreadCount) |
||||
{ |
||||
_pipelineSteps.Insert(0, new ThreadCountOption(threadCount)); |
||||
} |
||||
} |
||||
|
||||
var allVideoStreams = _videoInputFile.SelectMany(f => f.VideoStreams).ToList(); |
||||
|
||||
// -sc_threshold 0 is unsupported with mpeg2video
|
||||
_pipelineSteps.Add( |
||||
allVideoStreams.All(s => s.Codec != VideoFormat.Mpeg2Video) && |
||||
desiredState.VideoFormat != VideoFormat.Mpeg2Video |
||||
? new NoSceneDetectOutputOption(0) |
||||
: new NoSceneDetectOutputOption(1_000_000_000)); |
||||
|
||||
if (ffmpegState.SaveReport) |
||||
{ |
||||
_pipelineSteps.Add(new FFReportVariable(_reportsFolder, None)); |
||||
} |
||||
|
||||
foreach (TimeSpan desiredStart in ffmpegState.Start.Filter(s => s > TimeSpan.Zero)) |
||||
{ |
||||
var option = new StreamSeekInputOption(desiredStart); |
||||
_audioInputFile.Iter(f => f.AddOption(option)); |
||||
_videoInputFile.Iter(f => f.AddOption(option)); |
||||
|
||||
// need to seek text subtitle files
|
||||
if (_subtitleInputFile.Map(s => !s.IsImageBased).IfNone(false)) |
||||
{ |
||||
_pipelineSteps.Add(new StreamSeekFilterOption(desiredStart)); |
||||
} |
||||
} |
||||
|
||||
foreach (TimeSpan desiredFinish in ffmpegState.Finish) |
||||
{ |
||||
_pipelineSteps.Add(new TimeLimitOutputOption(desiredFinish)); |
||||
} |
||||
|
||||
foreach (VideoStream videoStream in allVideoStreams) |
||||
{ |
||||
bool hasOverlay = _watermarkInputFile.IsSome || |
||||
_subtitleInputFile.Map(s => s.IsImageBased && !s.Copy).IfNone(false); |
||||
|
||||
Option<int> initialFrameRate = Option<int>.None; |
||||
foreach (string frameRateString in videoStream.FrameRate) |
||||
{ |
||||
if (int.TryParse(frameRateString, out int parsedFrameRate)) |
||||
{ |
||||
initialFrameRate = parsedFrameRate; |
||||
} |
||||
} |
||||
|
||||
var currentState = new FrameState( |
||||
false, // realtime
|
||||
false, // infinite loop
|
||||
videoStream.Codec, |
||||
videoStream.PixelFormat, |
||||
videoStream.FrameSize, |
||||
videoStream.FrameSize, |
||||
videoStream.IsAnamorphic, |
||||
initialFrameRate, |
||||
Option<int>.None, |
||||
Option<int>.None, |
||||
Option<int>.None, |
||||
false); // deinterlace
|
||||
|
||||
IEncoder encoder; |
||||
|
||||
if (IsDesiredVideoState(currentState, desiredState)) |
||||
{ |
||||
encoder = new EncoderCopyVideo(); |
||||
_pipelineSteps.Add(encoder); |
||||
} |
||||
else |
||||
{ |
||||
Option<IPipelineStep> maybeAccel = AvailableHardwareAccelerationOptions.ForMode( |
||||
ffmpegState.EncoderHardwareAccelerationMode, |
||||
ffmpegState.VaapiDevice, |
||||
_logger); |
||||
|
||||
if (maybeAccel.IsNone) |
||||
{ |
||||
ffmpegState = ffmpegState with |
||||
{ |
||||
// disable hw accel if we don't match anything
|
||||
DecoderHardwareAccelerationMode = HardwareAccelerationMode.None, |
||||
EncoderHardwareAccelerationMode = HardwareAccelerationMode.None |
||||
}; |
||||
} |
||||
|
||||
foreach (IPipelineStep accel in maybeAccel) |
||||
{ |
||||
bool canDecode = _hardwareCapabilities.CanDecode(currentState.VideoFormat, videoStream.PixelFormat); |
||||
bool canEncode = _hardwareCapabilities.CanEncode( |
||||
desiredState.VideoFormat, |
||||
desiredState.PixelFormat); |
||||
|
||||
// disable hw accel if decoder/encoder isn't supported
|
||||
if (!canDecode || !canEncode) |
||||
{ |
||||
ffmpegState = ffmpegState with |
||||
{ |
||||
DecoderHardwareAccelerationMode = canDecode |
||||
? ffmpegState.DecoderHardwareAccelerationMode |
||||
: HardwareAccelerationMode.None, |
||||
EncoderHardwareAccelerationMode = canEncode |
||||
? ffmpegState.EncoderHardwareAccelerationMode |
||||
: HardwareAccelerationMode.None |
||||
}; |
||||
} |
||||
|
||||
if (canDecode || canEncode) |
||||
{ |
||||
currentState = accel.NextState(currentState); |
||||
_pipelineSteps.Add(accel); |
||||
} |
||||
} |
||||
|
||||
if (ffmpegState.EncoderHardwareAccelerationMode == HardwareAccelerationMode.Nvenc && hasOverlay && |
||||
is10BitOutput) |
||||
{ |
||||
IPixelFormat pixelFormat = desiredState.PixelFormat.IfNone(new PixelFormatYuv420P10Le()); |
||||
desiredState = desiredState with { PixelFormat = new PixelFormatNv12(pixelFormat.Name) }; |
||||
} |
||||
|
||||
//
|
||||
// // qsv should stay nv12
|
||||
// if (ffmpegState.EncoderHardwareAccelerationMode == HardwareAccelerationMode.Qsv && hasOverlay)
|
||||
// {
|
||||
// IPixelFormat pixelFormat = desiredState.PixelFormat.IfNone(new PixelFormatYuv420P());
|
||||
// desiredState = desiredState with { PixelFormat = new PixelFormatNv12(pixelFormat.Name) };
|
||||
// }
|
||||
|
||||
foreach (string desiredVaapiDriver in ffmpegState.VaapiDriver) |
||||
{ |
||||
IPipelineStep step = new LibvaDriverNameVariable(desiredVaapiDriver); |
||||
currentState = step.NextState(currentState); |
||||
_pipelineSteps.Add(step); |
||||
} |
||||
|
||||
foreach (IDecoder decoder in AvailableDecoders.ForVideoFormat( |
||||
_hardwareCapabilities, |
||||
ffmpegState, |
||||
currentState, |
||||
desiredState, |
||||
_watermarkInputFile, |
||||
_subtitleInputFile, |
||||
_logger)) |
||||
{ |
||||
foreach (VideoInputFile videoInputFile in _videoInputFile) |
||||
{ |
||||
videoInputFile.AddOption(decoder); |
||||
currentState = decoder.NextState(currentState); |
||||
} |
||||
} |
||||
} |
||||
|
||||
if (_subtitleInputFile.Map(s => s.Copy) == Some(true)) |
||||
{ |
||||
_pipelineSteps.Add(new EncoderCopySubtitle()); |
||||
} |
||||
|
||||
if (videoStream.StillImage) |
||||
{ |
||||
var option = new InfiniteLoopInputOption(ffmpegState.EncoderHardwareAccelerationMode); |
||||
_videoInputFile.Iter(f => f.AddOption(option)); |
||||
} |
||||
|
||||
if (!IsDesiredVideoState(currentState, desiredState)) |
||||
{ |
||||
if (desiredState.Realtime) |
||||
{ |
||||
var option = new RealtimeInputOption(); |
||||
_audioInputFile.Iter(f => f.AddOption(option)); |
||||
_videoInputFile.Iter(f => f.AddOption(option)); |
||||
} |
||||
|
||||
if (desiredState.InfiniteLoop) |
||||
{ |
||||
var option = new InfiniteLoopInputOption(ffmpegState.EncoderHardwareAccelerationMode); |
||||
_audioInputFile.Iter(f => f.AddOption(option)); |
||||
_videoInputFile.Iter(f => f.AddOption(option)); |
||||
} |
||||
|
||||
foreach (int desiredFrameRate in desiredState.FrameRate) |
||||
{ |
||||
if (currentState.FrameRate != desiredFrameRate) |
||||
{ |
||||
IPipelineStep step = new FrameRateOutputOption(desiredFrameRate); |
||||
currentState = step.NextState(currentState); |
||||
_pipelineSteps.Add(step); |
||||
} |
||||
} |
||||
|
||||
foreach (int desiredTimeScale in desiredState.VideoTrackTimeScale) |
||||
{ |
||||
if (currentState.VideoTrackTimeScale != desiredTimeScale) |
||||
{ |
||||
IPipelineStep step = new VideoTrackTimescaleOutputOption(desiredTimeScale); |
||||
currentState = step.NextState(currentState); |
||||
_pipelineSteps.Add(step); |
||||
} |
||||
} |
||||
|
||||
foreach (int desiredBitrate in desiredState.VideoBitrate) |
||||
{ |
||||
if (currentState.VideoBitrate != desiredBitrate) |
||||
{ |
||||
IPipelineStep step = new VideoBitrateOutputOption(desiredBitrate); |
||||
currentState = step.NextState(currentState); |
||||
_pipelineSteps.Add(step); |
||||
} |
||||
} |
||||
|
||||
foreach (int desiredBufferSize in desiredState.VideoBufferSize) |
||||
{ |
||||
if (currentState.VideoBufferSize != desiredBufferSize) |
||||
{ |
||||
IPipelineStep step = new VideoBufferSizeOutputOption(desiredBufferSize); |
||||
currentState = step.NextState(currentState); |
||||
_pipelineSteps.Add(step); |
||||
} |
||||
} |
||||
|
||||
if (desiredState.Deinterlaced && !currentState.Deinterlaced) |
||||
{ |
||||
IPipelineFilterStep step = AvailableDeinterlaceFilters.ForAcceleration( |
||||
ffmpegState.EncoderHardwareAccelerationMode, |
||||
currentState, |
||||
desiredState, |
||||
_watermarkInputFile, |
||||
_subtitleInputFile); |
||||
currentState = step.NextState(currentState); |
||||
_videoInputFile.Iter(f => f.FilterSteps.Add(step)); |
||||
} |
||||
|
||||
// TODO: this is a software-only flow, will need to be different for hardware accel
|
||||
if (ffmpegState.EncoderHardwareAccelerationMode == HardwareAccelerationMode.None) |
||||
{ |
||||
if (currentState.ScaledSize != desiredState.ScaledSize || |
||||
currentState.PaddedSize != desiredState.PaddedSize) |
||||
{ |
||||
IPipelineFilterStep scaleStep = new ScaleFilter( |
||||
currentState, |
||||
desiredState.ScaledSize, |
||||
desiredState.PaddedSize, |
||||
videoStream.IsAnamorphicEdgeCase); |
||||
currentState = scaleStep.NextState(currentState); |
||||
_videoInputFile.Iter(f => f.FilterSteps.Add(scaleStep)); |
||||
|
||||
// TODO: padding might not be needed, can we optimize this out?
|
||||
IPipelineFilterStep padStep = new PadFilter(currentState, desiredState.PaddedSize); |
||||
currentState = padStep.NextState(currentState); |
||||
_videoInputFile.Iter(f => f.FilterSteps.Add(padStep)); |
||||
} |
||||
} |
||||
else if (currentState.ScaledSize != desiredState.ScaledSize) |
||||
{ |
||||
IPipelineFilterStep scaleFilter = AvailableScaleFilters.ForAcceleration( |
||||
_runtimeInfo, |
||||
ffmpegState.EncoderHardwareAccelerationMode, |
||||
currentState, |
||||
desiredState.ScaledSize, |
||||
desiredState.PaddedSize, |
||||
ffmpegState.QsvExtraHardwareFrames, |
||||
videoStream.IsAnamorphicEdgeCase, |
||||
videoStream.SampleAspectRatio); |
||||
currentState = scaleFilter.NextState(currentState); |
||||
_videoInputFile.Iter(f => f.FilterSteps.Add(scaleFilter)); |
||||
|
||||
// TODO: padding might not be needed, can we optimize this out?
|
||||
if (currentState.PaddedSize != desiredState.PaddedSize) |
||||
{ |
||||
IPipelineFilterStep padStep = new PadFilter(currentState, desiredState.PaddedSize); |
||||
currentState = padStep.NextState(currentState); |
||||
_videoInputFile.Iter(f => f.FilterSteps.Add(padStep)); |
||||
} |
||||
} |
||||
else if (currentState.PaddedSize != desiredState.PaddedSize) |
||||
{ |
||||
IPipelineFilterStep scaleFilter = AvailableScaleFilters.ForAcceleration( |
||||
_runtimeInfo, |
||||
ffmpegState.EncoderHardwareAccelerationMode, |
||||
currentState, |
||||
desiredState.ScaledSize, |
||||
desiredState.PaddedSize, |
||||
ffmpegState.QsvExtraHardwareFrames, |
||||
videoStream.IsAnamorphicEdgeCase, |
||||
videoStream.SampleAspectRatio); |
||||
currentState = scaleFilter.NextState(currentState); |
||||
_videoInputFile.Iter(f => f.FilterSteps.Add(scaleFilter)); |
||||
|
||||
if (currentState.PaddedSize != desiredState.PaddedSize) |
||||
{ |
||||
IPipelineFilterStep padStep = new PadFilter(currentState, desiredState.PaddedSize); |
||||
currentState = padStep.NextState(currentState); |
||||
_videoInputFile.Iter(f => f.FilterSteps.Add(padStep)); |
||||
} |
||||
} |
||||
|
||||
if (hasOverlay && currentState.PixelFormat.Map(pf => pf.FFmpegName) != |
||||
desiredState.PixelFormat.Map(pf => pf.FFmpegName)) |
||||
{ |
||||
// this should only happen with nvenc?
|
||||
// use scale filter to fix pixel format
|
||||
|
||||
foreach (IPixelFormat pixelFormat in desiredState.PixelFormat) |
||||
{ |
||||
if (currentState.FrameDataLocation == FrameDataLocation.Software) |
||||
{ |
||||
IPipelineFilterStep formatFilter = new PixelFormatFilter(pixelFormat); |
||||
currentState = formatFilter.NextState(currentState); |
||||
_videoInputFile.Iter(f => f.FilterSteps.Add(formatFilter)); |
||||
|
||||
switch (ffmpegState.EncoderHardwareAccelerationMode) |
||||
{ |
||||
case HardwareAccelerationMode.Nvenc: |
||||
var uploadFilter = new HardwareUploadFilter(ffmpegState); |
||||
currentState = uploadFilter.NextState(currentState); |
||||
_videoInputFile.Iter(f => f.FilterSteps.Add(uploadFilter)); |
||||
break; |
||||
} |
||||
} |
||||
else |
||||
{ |
||||
if (ffmpegState.EncoderHardwareAccelerationMode != HardwareAccelerationMode.Qsv) |
||||
{ |
||||
// the filter re-applies the current pixel format, so we have to set it first
|
||||
currentState = currentState with { PixelFormat = desiredState.PixelFormat }; |
||||
|
||||
IPipelineFilterStep scaleFilter = AvailableScaleFilters.ForAcceleration( |
||||
_runtimeInfo, |
||||
ffmpegState.EncoderHardwareAccelerationMode, |
||||
currentState, |
||||
desiredState.ScaledSize, |
||||
desiredState.PaddedSize, |
||||
ffmpegState.QsvExtraHardwareFrames, |
||||
videoStream.IsAnamorphicEdgeCase, |
||||
videoStream.SampleAspectRatio); |
||||
currentState = scaleFilter.NextState(currentState); |
||||
_videoInputFile.Iter(f => f.FilterSteps.Add(scaleFilter)); |
||||
} |
||||
} |
||||
} |
||||
} |
||||
|
||||
// nvenc custom logic
|
||||
if (ffmpegState.EncoderHardwareAccelerationMode == HardwareAccelerationMode.Nvenc) |
||||
{ |
||||
foreach (VideoInputFile videoInputFile in _videoInputFile) |
||||
{ |
||||
// if we only deinterlace, we need to set pixel format again (using scale_cuda)
|
||||
bool onlyYadif = videoInputFile.FilterSteps.Count == 1 && |
||||
videoInputFile.FilterSteps.Any(fs => fs is YadifCudaFilter); |
||||
|
||||
// if we have no filters and an overlay, we need to set pixel format
|
||||
bool unfilteredWithOverlay = videoInputFile.FilterSteps.Count == 0 && hasOverlay; |
||||
|
||||
if (onlyYadif || unfilteredWithOverlay) |
||||
{ |
||||
// the filter re-applies the current pixel format, so we have to set it first
|
||||
currentState = currentState with { PixelFormat = desiredState.PixelFormat }; |
||||
|
||||
IPipelineFilterStep scaleFilter = AvailableScaleFilters.ForAcceleration( |
||||
_runtimeInfo, |
||||
ffmpegState.EncoderHardwareAccelerationMode, |
||||
currentState, |
||||
desiredState.ScaledSize, |
||||
desiredState.PaddedSize, |
||||
ffmpegState.QsvExtraHardwareFrames, |
||||
videoStream.IsAnamorphicEdgeCase, |
||||
videoStream.SampleAspectRatio); |
||||
currentState = scaleFilter.NextState(currentState); |
||||
videoInputFile.FilterSteps.Add(scaleFilter); |
||||
} |
||||
} |
||||
} |
||||
|
||||
if (ffmpegState.PtsOffset > 0) |
||||
{ |
||||
foreach (int videoTrackTimeScale in desiredState.VideoTrackTimeScale) |
||||
{ |
||||
IPipelineStep step = new OutputTsOffsetOption( |
||||
ffmpegState.PtsOffset, |
||||
videoTrackTimeScale); |
||||
currentState = step.NextState(currentState); |
||||
_pipelineSteps.Add(step); |
||||
} |
||||
} |
||||
} |
||||
|
||||
// TODO: if all video filters are software, use software pixel format for hwaccel output
|
||||
// might be able to skip scale_cuda=format=whatever,hwdownload,format=whatever
|
||||
|
||||
if (_audioInputFile.IsNone) |
||||
{ |
||||
// always need to specify audio codec so ffmpeg doesn't default to a codec we don't want
|
||||
foreach (IEncoder step in AvailableEncoders.ForAudioFormat(AudioState.Copy, _logger)) |
||||
{ |
||||
currentState = step.NextState(currentState); |
||||
_pipelineSteps.Add(step); |
||||
} |
||||
} |
||||
|
||||
foreach (AudioInputFile audioInputFile in _audioInputFile) |
||||
{ |
||||
// always need to specify audio codec so ffmpeg doesn't default to a codec we don't want
|
||||
foreach (IEncoder step in AvailableEncoders.ForAudioFormat(audioInputFile.DesiredState, _logger)) |
||||
{ |
||||
currentState = step.NextState(currentState); |
||||
_pipelineSteps.Add(step); |
||||
} |
||||
|
||||
foreach (AudioStream audioStream in audioInputFile.AudioStreams.HeadOrNone()) |
||||
{ |
||||
foreach (int desiredAudioChannels in audioInputFile.DesiredState.AudioChannels) |
||||
{ |
||||
_pipelineSteps.Add( |
||||
new AudioChannelsOutputOption( |
||||
audioInputFile.DesiredState.AudioFormat, |
||||
audioStream.Channels, |
||||
desiredAudioChannels)); |
||||
} |
||||
} |
||||
|
||||
foreach (int desiredBitrate in audioInputFile.DesiredState.AudioBitrate) |
||||
{ |
||||
_pipelineSteps.Add(new AudioBitrateOutputOption(desiredBitrate)); |
||||
} |
||||
|
||||
foreach (int desiredBufferSize in audioInputFile.DesiredState.AudioBufferSize) |
||||
{ |
||||
_pipelineSteps.Add(new AudioBufferSizeOutputOption(desiredBufferSize)); |
||||
} |
||||
|
||||
foreach (int desiredSampleRate in audioInputFile.DesiredState.AudioSampleRate) |
||||
{ |
||||
_pipelineSteps.Add(new AudioSampleRateOutputOption(desiredSampleRate)); |
||||
} |
||||
|
||||
if (audioInputFile.DesiredState.NormalizeLoudness) |
||||
{ |
||||
_audioInputFile.Iter(f => f.FilterSteps.Add(new NormalizeLoudnessFilter())); |
||||
} |
||||
|
||||
foreach (TimeSpan desiredDuration in audioInputFile.DesiredState.AudioDuration) |
||||
{ |
||||
_audioInputFile.Iter(f => f.FilterSteps.Add(new AudioPadFilter(desiredDuration))); |
||||
} |
||||
} |
||||
|
||||
foreach (SubtitleInputFile subtitleInputFile in _subtitleInputFile) |
||||
{ |
||||
if (subtitleInputFile.IsImageBased) |
||||
{ |
||||
// vaapi and videotoolbox use a software overlay, so we need to ensure the background is already in software
|
||||
// though videotoolbox uses software decoders, so no need to download for that
|
||||
if (ffmpegState.EncoderHardwareAccelerationMode == HardwareAccelerationMode.Vaapi) |
||||
{ |
||||
var downloadFilter = new HardwareDownloadFilter(currentState); |
||||
currentState = downloadFilter.NextState(currentState); |
||||
_videoInputFile.Iter(f => f.FilterSteps.Add(downloadFilter)); |
||||
} |
||||
|
||||
var pixelFormatFilter = new SubtitlePixelFormatFilter(ffmpegState, is10BitOutput); |
||||
subtitleInputFile.FilterSteps.Add(pixelFormatFilter); |
||||
|
||||
subtitleInputFile.FilterSteps.Add(new SubtitleHardwareUploadFilter(currentState, ffmpegState)); |
||||
|
||||
FrameState fakeState = currentState; |
||||
foreach (string format in pixelFormatFilter.MaybeFormat) |
||||
{ |
||||
fakeState = fakeState with |
||||
{ |
||||
PixelFormat = AvailablePixelFormats.ForPixelFormat(format, _logger) |
||||
}; |
||||
} |
||||
|
||||
// hacky check for actual scaling or padding
|
||||
if (_videoInputFile.Exists( |
||||
v => v.FilterSteps.Any(s => s.Filter.Contains(currentState.PaddedSize.Height.ToString())))) |
||||
{ |
||||
// enable scaling the subtitle stream
|
||||
fakeState = fakeState with { ScaledSize = new FrameSize(1, 1) }; |
||||
} |
||||
|
||||
IPipelineFilterStep scaleFilter = AvailableSubtitleScaleFilters.ForAcceleration( |
||||
ffmpegState.EncoderHardwareAccelerationMode, |
||||
fakeState, |
||||
desiredState.ScaledSize, |
||||
desiredState.PaddedSize, |
||||
ffmpegState.QsvExtraHardwareFrames); |
||||
subtitleInputFile.FilterSteps.Add(scaleFilter); |
||||
} |
||||
else |
||||
{ |
||||
_videoInputFile.Iter(f => f.AddOption(new CopyTimestampInputOption())); |
||||
|
||||
// text-based subtitles are always added in software, so always try to download the background
|
||||
|
||||
// nvidia needs some extra format help if the only filter will be the download filter
|
||||
if (ffmpegState.EncoderHardwareAccelerationMode == HardwareAccelerationMode.Nvenc && |
||||
currentState.FrameDataLocation == FrameDataLocation.Hardware && |
||||
_videoInputFile.Map(f => f.FilterSteps.Count).IfNone(1) == 0) |
||||
{ |
||||
IPipelineFilterStep scaleFilter = AvailableScaleFilters.ForAcceleration( |
||||
_runtimeInfo, |
||||
ffmpegState.EncoderHardwareAccelerationMode, |
||||
currentState, |
||||
desiredState.ScaledSize, |
||||
desiredState.PaddedSize, |
||||
ffmpegState.QsvExtraHardwareFrames, |
||||
videoStream.IsAnamorphicEdgeCase, |
||||
videoStream.SampleAspectRatio); |
||||
currentState = scaleFilter.NextState(currentState); |
||||
_videoInputFile.Iter(f => f.FilterSteps.Add(scaleFilter)); |
||||
} |
||||
|
||||
var downloadFilter = new HardwareDownloadFilter(currentState); |
||||
currentState = downloadFilter.NextState(currentState); |
||||
_videoInputFile.Iter(f => f.FilterSteps.Add(downloadFilter)); |
||||
} |
||||
} |
||||
|
||||
foreach (WatermarkInputFile watermarkInputFile in _watermarkInputFile) |
||||
{ |
||||
// vaapi and videotoolbox use a software overlay, so we need to ensure the background is already in software
|
||||
// though videotoolbox uses software decoders, so no need to download for that
|
||||
if (ffmpegState.EncoderHardwareAccelerationMode == HardwareAccelerationMode.Vaapi) |
||||
{ |
||||
var downloadFilter = new HardwareDownloadFilter(currentState); |
||||
currentState = downloadFilter.NextState(currentState); |
||||
_videoInputFile.Iter(f => f.FilterSteps.Add(downloadFilter)); |
||||
} |
||||
|
||||
watermarkInputFile.FilterSteps.Add( |
||||
new WatermarkPixelFormatFilter(ffmpegState, watermarkInputFile.DesiredState, is10BitOutput)); |
||||
|
||||
foreach (VideoStream watermarkStream in watermarkInputFile.VideoStreams) |
||||
{ |
||||
if (watermarkStream.StillImage == false) |
||||
{ |
||||
watermarkInputFile.AddOption(new DoNotIgnoreLoopInputOption()); |
||||
} |
||||
else if (watermarkInputFile.DesiredState.MaybeFadePoints.Map(fp => fp.Count > 0).IfNone(false)) |
||||
{ |
||||
// looping is required to fade a static image in and out
|
||||
watermarkInputFile.AddOption( |
||||
new InfiniteLoopInputOption(ffmpegState.EncoderHardwareAccelerationMode)); |
||||
} |
||||
} |
||||
|
||||
if (watermarkInputFile.DesiredState.Size == WatermarkSize.Scaled) |
||||
{ |
||||
watermarkInputFile.FilterSteps.Add( |
||||
new WatermarkScaleFilter(watermarkInputFile.DesiredState, currentState.PaddedSize)); |
||||
} |
||||
|
||||
if (watermarkInputFile.DesiredState.Opacity != 100) |
||||
{ |
||||
watermarkInputFile.FilterSteps.Add(new WatermarkOpacityFilter(watermarkInputFile.DesiredState)); |
||||
} |
||||
|
||||
foreach (List<WatermarkFadePoint> fadePoints in watermarkInputFile.DesiredState.MaybeFadePoints) |
||||
{ |
||||
watermarkInputFile.FilterSteps.AddRange(fadePoints.Map(fp => new WatermarkFadeFilter(fp))); |
||||
} |
||||
|
||||
watermarkInputFile.FilterSteps.Add(new WatermarkHardwareUploadFilter(currentState, ffmpegState)); |
||||
} |
||||
|
||||
// after everything else is done, apply the encoder
|
||||
if (_pipelineSteps.OfType<IEncoder>().All(e => e.Kind != StreamKind.Video)) |
||||
{ |
||||
foreach (IEncoder e in AvailableEncoders.ForVideoFormat( |
||||
_hardwareCapabilities, |
||||
ffmpegState, |
||||
currentState, |
||||
desiredState, |
||||
_watermarkInputFile, |
||||
_subtitleInputFile, |
||||
_logger)) |
||||
{ |
||||
encoder = e; |
||||
_pipelineSteps.Add(encoder); |
||||
_videoInputFile.Iter(f => f.FilterSteps.Add(encoder)); |
||||
currentState = encoder.NextState(currentState); |
||||
} |
||||
} |
||||
|
||||
if (ffmpegState.DoNotMapMetadata) |
||||
{ |
||||
_pipelineSteps.Add(new DoNotMapMetadataOutputOption()); |
||||
} |
||||
|
||||
foreach (string desiredServiceProvider in ffmpegState.MetadataServiceProvider) |
||||
{ |
||||
_pipelineSteps.Add(new MetadataServiceProviderOutputOption(desiredServiceProvider)); |
||||
} |
||||
|
||||
foreach (string desiredServiceName in ffmpegState.MetadataServiceName) |
||||
{ |
||||
_pipelineSteps.Add(new MetadataServiceNameOutputOption(desiredServiceName)); |
||||
} |
||||
|
||||
foreach (string desiredAudioLanguage in ffmpegState.MetadataAudioLanguage) |
||||
{ |
||||
_pipelineSteps.Add(new MetadataAudioLanguageOutputOption(desiredAudioLanguage)); |
||||
} |
||||
|
||||
switch (ffmpegState.OutputFormat) |
||||
{ |
||||
case OutputFormatKind.MpegTs: |
||||
_pipelineSteps.Add(new OutputFormatMpegTs()); |
||||
_pipelineSteps.Add(new PipeProtocol()); |
||||
// currentState = currentState with { OutputFormat = OutputFormatKind.MpegTs };
|
||||
break; |
||||
case OutputFormatKind.Hls: |
||||
foreach (string playlistPath in ffmpegState.HlsPlaylistPath) |
||||
{ |
||||
foreach (string segmentTemplate in ffmpegState.HlsSegmentTemplate) |
||||
{ |
||||
var step = new OutputFormatHls( |
||||
desiredState, |
||||
videoStream.FrameRate, |
||||
segmentTemplate, |
||||
playlistPath); |
||||
currentState = step.NextState(currentState); |
||||
_pipelineSteps.Add(step); |
||||
} |
||||
} |
||||
|
||||
break; |
||||
} |
||||
|
||||
var complexFilter = new ComplexFilter( |
||||
currentState, |
||||
ffmpegState, |
||||
_videoInputFile, |
||||
_audioInputFile, |
||||
_watermarkInputFile, |
||||
_subtitleInputFile, |
||||
originalDesiredPixelFormat, |
||||
currentState.PaddedSize, |
||||
_fontsFolder, |
||||
_logger); |
||||
|
||||
_pipelineSteps.Add(complexFilter); |
||||
} |
||||
|
||||
return new FFmpegPipeline(_pipelineSteps); |
||||
} |
||||
|
||||
private static bool IsDesiredVideoState(FrameState currentState, FrameState desiredState) |
||||
{ |
||||
if (desiredState.VideoFormat == VideoFormat.Copy) |
||||
{ |
||||
return true; |
||||
} |
||||
|
||||
return currentState.VideoFormat == desiredState.VideoFormat && |
||||
currentState.PixelFormat.Match(pf => pf.Name, () => string.Empty) == |
||||
desiredState.PixelFormat.Match(pf => pf.Name, string.Empty) && |
||||
(desiredState.VideoBitrate.IsNone || currentState.VideoBitrate == desiredState.VideoBitrate) && |
||||
(desiredState.VideoBufferSize.IsNone || currentState.VideoBufferSize == desiredState.VideoBufferSize) && |
||||
currentState.Realtime == desiredState.Realtime && |
||||
(desiredState.VideoTrackTimeScale.IsNone || |
||||
currentState.VideoTrackTimeScale == desiredState.VideoTrackTimeScale) && |
||||
currentState.ScaledSize == desiredState.ScaledSize && |
||||
currentState.PaddedSize == desiredState.PaddedSize && |
||||
(desiredState.FrameRate.IsNone || currentState.FrameRate == desiredState.FrameRate); |
||||
} |
||||
} |
||||
Loading…
Reference in new issue