Alex/FFMpegCore
1
0
Fork 0
mirror of https://github.com/rosenbjerg/FFMpegCore.git synced 2024-11-10 08:34:12 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

Remove ArgumentStringifier + cleanup

Browse source 
No reason to split the responsibility
This commit is contained in:
Malte Rosenbjerg 2020-02-27 20:16:17 +01:00
parent 461f99d6f4
commit 0e2c788796
33 changed files with 142 additions and 520 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

27
FFMpegCore/FFMPEG/Argument/Argument.cs
View file

@ -22,12 +22,10 @@ public override string ToString()
/// </summary>
public abstract class Argument<T> : Argument
{
private T _value;
/// <summary>
/// Value type of <see cref="T"/>
/// </summary>
public T Value { get => _value; set { CheckValue(value); _value = value; } }
public T Value { get; protected set; }
public Argument() { }
@ -35,11 +33,6 @@ public Argument(T value)
{
Value = value;
}
protected virtual void CheckValue(T value)
{
}
}
/// <summary>
@ -47,19 +40,15 @@ protected virtual void CheckValue(T value)
/// </summary>
public abstract class Argument<T1, T2> : Argument
{
private T1 _first;
private T2 _second;
/// <summary>
/// First value type of <see cref="T"/>
/// </summary>
public T1 First { get => _first; set { CheckFirst(_first); _first = value; } }
public T1 First { get; set; }
/// <summary>
/// Second value type of <see cref="T"/>
/// </summary>
public T2 Second { get => _second; set { CheckSecond(_second); _second = value; } }
public T2 Second { get; set; }
public Argument() { }
@ -68,15 +57,5 @@ public Argument(T1 first, T2 second)
First = first;
Second = second;
}
protected virtual void CheckFirst(T1 value)
{
}
protected virtual void CheckSecond(T2 value)
{
}
}
}

179
FFMpegCore/FFMPEG/Argument/ArgumentStringifier.cs
View file

@ -1,179 +0,0 @@
using FFMpegCore.FFMPEG.Enums;
using System;
using System.Collections.Generic;
using System.Drawing;
namespace FFMpegCore.FFMPEG.Argument
{
internal static class ArgumentStringifier
{
internal static string Speed(Speed speed)
{
return $"-preset {speed.ToString().ToLower()} ";
}
internal static string Speed(int cpu)
{
return $"-quality good -cpu-used {cpu} -deadline realtime ";
}
internal static string Audio(AudioCodec codec, int bitrate)
{
return Audio(codec) + Audio(bitrate);
}
internal static string Audio(AudioCodec codec)
{
return $"-c:a {codec.ToString().ToLower()} ";
}
internal static string Audio(AudioQuality bitrate)
{
return Audio((int)bitrate);
}
internal static string Audio(int bitrate)
{
return $"-b:a {bitrate}k ";
}
internal static string Video(VideoCodec codec, int bitrate = 0)
{
var video = $"-c:v {codec.ToString().ToLower()} -pix_fmt yuv420p ";
if (bitrate > 0)
{
video += $"-b:v {bitrate}k ";
}
return video;
}
internal static string Threads(bool multiThread)
{
var threadCount = multiThread
? Environment.ProcessorCount
: 1;
return Threads(threadCount);
}
internal static string Threads(int threads)
{
return $"-threads {threads} ";
}
internal static string Disable(Channel type)
{
switch (type)
{
case Channel.Video:
return "-vn ";
case Channel.Audio:
return "-an ";
default:
return string.Empty;
}
}
internal static string Output(string output)
{
return $"\"{output}\"";
}
internal static string Input(string template)
{
return $"-i \"{template}\" ";
}
internal static string Scale(VideoSize size, int width =-1)
{
return size == VideoSize.Original ? string.Empty : Scale(width, (int)size);
}
internal static string Scale(int width, int height)
{
return $"-vf scale={width}:{height} ";
}
internal static string Size(Size? size)
{
if (!size.HasValue) return string.Empty;
var formatedSize = $"{size.Value.Width}x{size.Value.Height}";
return $"-s {formatedSize} ";
}
internal static string ForceFormat(VideoCodec codec)
{
return $"-f {codec.ToString().ToLower()} ";
}
internal static string BitStreamFilter(Channel type, Filter filter)
{
switch (type)
{
case Channel.Audio:
return $"-bsf:a {filter.ToString().ToLower()} ";
case Channel.Video:
return $"-bsf:v {filter.ToString().ToLower()} ";
default:
return string.Empty;
}
}
internal static string Copy(Channel type = Channel.Both)
{
switch (type)
{
case Channel.Audio:
return "-c:a copy ";
case Channel.Video:
return "-c:v copy ";
default:
return "-c copy ";
}
}
internal static string Seek(TimeSpan? seek)
{
return !seek.HasValue ? string.Empty : $"-ss {seek} ";
}
internal static string FrameOutputCount(int number)
{
return $"-vframes {number} ";
}
internal static string Loop(int count)
{
return $"-loop {count} ";
}
internal static string FinalizeAtShortestInput(bool applicable)
{
return applicable ? "-shortest " : string.Empty;
}
internal static string InputConcat(IEnumerable<string> paths)
{
return $"-i \"concat:{string.Join(@"|", paths)}\" ";
}
internal static string FrameRate(double frameRate)
{
return $"-r {frameRate} ";
}
internal static string StartNumber(int v)
{
return $"-start_number {v} ";
}
internal static string Duration(TimeSpan? duration)
{
return !duration.HasValue ? string.Empty : $"-t {duration} ";
}
}
}

22
FFMpegCore/FFMPEG/Argument/Atoms/AudioCodecArgument.cs
View file

@ -10,33 +10,23 @@ public class AudioCodecArgument : Argument<AudioCodec>
/// <summary>
/// Bitrate of audio channel
/// </summary>
public int Bitrate { get; protected set; } = (int)AudioQuality.Normal;
public int Bitrate { get; } = (int)AudioQuality.Normal;
public AudioCodecArgument()
{
}
public AudioCodecArgument() { }
public AudioCodecArgument(AudioCodec value) : base(value)
{
}
public AudioCodecArgument(AudioCodec value) : base(value) { }
public AudioCodecArgument(AudioCodec value, AudioQuality bitrate) : base(value)
{
Bitrate = (int)bitrate;
}
public AudioCodecArgument(AudioCodec value, AudioQuality bitrate) : this(value, (int) bitrate) { }
public AudioCodecArgument(AudioCodec value, int bitrate) : base(value)
{
Bitrate = bitrate;
}
/// <summary>
/// String representation of the argument
/// </summary>
/// <returns>String representation of the argument</returns>
/// <inheritdoc/>
public override string GetStringValue()
{
return ArgumentStringifier.Audio(Value, Bitrate);
return $"-c:a {Value.ToString().ToLower()} -b:a {Bitrate}k";
}
}
}

23
FFMpegCore/FFMPEG/Argument/Atoms/BitStreamFilterArgument.cs
View file

@ -1,4 +1,5 @@
using FFMpegCore.FFMPEG.Enums;
using System;
using FFMpegCore.FFMPEG.Enums;
namespace FFMpegCore.FFMPEG.Argument
{
@ -7,21 +8,19 @@ namespace FFMpegCore.FFMPEG.Argument
/// </summary>
public class BitStreamFilterArgument : Argument<Channel, Filter>
{
public BitStreamFilterArgument()
{
}
public BitStreamFilterArgument() { }
public BitStreamFilterArgument(Channel first, Filter second) : base(first, second)
{
}
public BitStreamFilterArgument(Channel first, Filter second) : base(first, second) { }
/// <summary>
/// String representation of the argument
/// </summary>
/// <returns>String representation of the argument</returns>
/// <inheritdoc/>
public override string GetStringValue()
{
return ArgumentStringifier.BitStreamFilter(First, Second);
return First switch
{
Channel.Audio => $"-bsf:a {Second.ToString().ToLower()}",
Channel.Video => $"-bsf:v {Second.ToString().ToLower()}",
_ => string.Empty
};
}
}
}

16
FFMpegCore/FFMPEG/Argument/Atoms/ConcatArgument.cs
View file

@ -10,27 +10,19 @@ namespace FFMpegCore.FFMPEG.Argument
/// </summary>
public class ConcatArgument : Argument<IEnumerable<string>>, IEnumerable<string>
{
public ConcatArgument()
{
Value = new List<string>();
}
public ConcatArgument() : base(new List<string>()) { }
public ConcatArgument(IEnumerable<string> value) : base(value)
{
}
public ConcatArgument(IEnumerable<string> value) : base(value) { }
public IEnumerator<string> GetEnumerator()
{
return Value.GetEnumerator();
}
/// <summary>
/// String representation of the argument
/// </summary>
/// <returns>String representation of the argument</returns>
/// <inheritdoc/>
public override string GetStringValue()
{
return ArgumentStringifier.InputConcat(Value);
return $"-i \"concat:{string.Join(@"|", Value)}\"";
}
IEnumerator IEnumerable.GetEnumerator()

1
FFMpegCore/FFMPEG/Argument/Atoms/ConstantRateFactorArgument.cs
View file

@ -15,6 +15,7 @@ public ConstantRateFactorArgument(int crf) : base(crf)
}
}
/// <inheritdoc/>
public override string GetStringValue()
{
return $"-crf {Value}";

22
FFMpegCore/FFMPEG/Argument/Atoms/CopyArgument.cs
View file

@ -8,22 +8,18 @@ namespace FFMpegCore.FFMPEG.Argument
/// </summary>
public class CopyArgument : Argument<Channel>
{
public CopyArgument()
{
Value = Channel.Both;
}
public CopyArgument() : base(Channel.Both) { }
public CopyArgument(Channel value = Channel.Both) : base(value) { }
public CopyArgument(Channel value = Channel.Both) : base(value)
{
}
/// <summary>
/// String representation of the argument
/// </summary>
/// <returns>String representation of the argument</returns>
/// <inheritdoc/>
public override string GetStringValue()
{
return ArgumentStringifier.Copy(Value);
return Value switch
{
Channel.Audio => "-c:a copy",
Channel.Video => "-c:v copy",
Channel.Both => "-c copy"
};
}
}
}

15
FFMpegCore/FFMPEG/Argument/Atoms/CpuSpeedArgument.cs
View file

@ -5,21 +5,14 @@
/// </summary>
public class CpuSpeedArgument : Argument<int>
{
public CpuSpeedArgument()
{
}
public CpuSpeedArgument() { }
public CpuSpeedArgument(int value) : base(value)
{
}
public CpuSpeedArgument(int value) : base(value) { }
/// <summary>
/// String representation of the argument
/// </summary>
/// <returns>String representation of the argument</returns>
/// <inheritdoc/>
public override string GetStringValue()
{
return ArgumentStringifier.Speed(Value);
return $"-quality good -cpu-used {Value} -deadline realtime";
}
}
}

20
FFMpegCore/FFMPEG/Argument/Atoms/DisableChannelArgument.cs
View file

@ -7,21 +7,19 @@ namespace FFMpegCore.FFMPEG.Argument
/// </summary>
public class DisableChannelArgument : Argument<Channel>
{
public DisableChannelArgument()
{
}
public DisableChannelArgument() { }
public DisableChannelArgument(Channel value) : base(value)
{
}
public DisableChannelArgument(Channel value) : base(value) { }
/// <summary>
/// String representation of the argument
/// </summary>
/// <returns>String representation of the argument</returns>
/// <inheritdoc/>
public override string GetStringValue()
{
return ArgumentStringifier.Disable(Value);
return Value switch
{
Channel.Video => "-vn",
Channel.Audio => "-an",
_ => string.Empty
};
}
}
}

5
FFMpegCore/FFMPEG/Argument/Atoms/DrawTextArgument.cs
View file

@ -9,10 +9,9 @@ namespace FFMpegCore.FFMPEG.Argument
public class DrawTextArgument : Argument<IEnumerable<(string key, string value)>>
{
public DrawTextArgument(string text, string fontPath, params (string, string)[] optionalArguments)
: base(new[] {("text", text), ("fontfile", fontPath)}.Concat(optionalArguments))
{
}
: base(new[] {("text", text), ("fontfile", fontPath)}.Concat(optionalArguments)) { }
/// <inheritdoc/>
public override string GetStringValue()
{
return $"-vf drawtext=\"{string.Join(": ", Value.Select(FormatArgumentPair))}\"";

15
FFMpegCore/FFMPEG/Argument/Atoms/DurationArgument.cs
View file

@ -7,21 +7,14 @@ namespace FFMpegCore.FFMPEG.Argument
/// </summary>
public class DurationArgument : Argument<TimeSpan?>
{
public DurationArgument()
{
}
public DurationArgument() { }
public DurationArgument(TimeSpan? value) : base(value)
{
}
public DurationArgument(TimeSpan? value) : base(value) { }
/// <summary>
/// String representation of the argument
/// </summary>
/// <returns>String representation of the argument</returns>
/// <inheritdoc/>
public override string GetStringValue()
{
return ArgumentStringifier.Duration(Value);
return !Value.HasValue ? string.Empty : $"-t {Value}";
}
}
}

5
FFMpegCore/FFMPEG/Argument/Atoms/FaststartArgument.cs
View file

@ -5,10 +5,9 @@
/// </summary>
public class FaststartArgument : Argument
{
public FaststartArgument()
{
}
public FaststartArgument() { }
/// <inheritdoc/>
public override string GetStringValue()
{
return "-movflags faststart";

15
FFMpegCore/FFMPEG/Argument/Atoms/ForceFormatArgument.cs
View file

@ -7,21 +7,14 @@ namespace FFMpegCore.FFMPEG.Argument
/// </summary>
public class ForceFormatArgument : Argument<VideoCodec>
{
public ForceFormatArgument()
{
}
public ForceFormatArgument() { }
public ForceFormatArgument(VideoCodec value) : base(value)
{
}
public ForceFormatArgument(VideoCodec value) : base(value) { }
/// <summary>
/// String representation of the argument
/// </summary>
/// <returns>String representation of the argument</returns>
/// <inheritdoc/>
public override string GetStringValue()
{
return ArgumentStringifier.ForceFormat(Value);
return $"-f {Value.ToString().ToLower()}";
}
}
}

15
FFMpegCore/FFMPEG/Argument/Atoms/FrameOutputCountArgument.cs
View file

@ -5,21 +5,14 @@
/// </summary>
public class FrameOutputCountArgument : Argument<int>
{
public FrameOutputCountArgument()
{
}
public FrameOutputCountArgument() { }
public FrameOutputCountArgument(int value) : base(value)
{
}
public FrameOutputCountArgument(int value) : base(value) { }
/// <summary>
/// String representation of the argument
/// </summary>
/// <returns>String representation of the argument</returns>
/// <inheritdoc/>
public override string GetStringValue()
{
return ArgumentStringifier.FrameOutputCount(Value);
return $"-vframes {Value}";
}
}
}

15
FFMpegCore/FFMPEG/Argument/Atoms/FrameRateArgument.cs
View file

@ -5,21 +5,14 @@
/// </summary>
public class FrameRateArgument : Argument<double>
{
public FrameRateArgument()
{
}
public FrameRateArgument() { }
public FrameRateArgument(double value) : base(value)
{
}
public FrameRateArgument(double value) : base(value) { }
/// <summary>
/// String representation of the argument
/// </summary>
/// <returns>String representation of the argument</returns>
/// <inheritdoc/>
public override string GetStringValue()
{
return ArgumentStringifier.FrameRate(Value);
return $"-r {Value}";
}
}
}

27
FFMpegCore/FFMPEG/Argument/Atoms/InputArgument.cs
View file

@ -9,33 +9,20 @@ namespace FFMpegCore.FFMPEG.Argument
/// </summary>
public class InputArgument : Argument<string[]>
{
public InputArgument()
{
}
public InputArgument() { }
public InputArgument(params string[] values) : base(values)
{
}
public InputArgument(params string[] values) : base(values) { }
public InputArgument(params VideoInfo[] values) : base(values.Select(v => v.FullName).ToArray())
{
}
public InputArgument(params VideoInfo[] values) : base(values.Select(v => v.FullName).ToArray()) { }
public InputArgument(params FileInfo[] values) : base(values.Select(v => v.FullName).ToArray())
{
}
public InputArgument(params FileInfo[] values) : base(values.Select(v => v.FullName).ToArray()) { }
public InputArgument(params Uri[] values) : base(values.Select(v => v.AbsoluteUri).ToArray())
{
}
public InputArgument(params Uri[] values) : base(values.Select(v => v.AbsoluteUri).ToArray()) { }
/// <summary>
/// String representation of the argument
/// </summary>
/// <returns>String representation of the argument</returns>
/// <inheritdoc/>
public override string GetStringValue()
{
return string.Join(" ", Value.Select(v => ArgumentStringifier.Input(v)));
return string.Join(" ", Value.Select(v => $"-i \"{v}\""));
}
public VideoInfo[] GetAsVideoInfo()
{

15
FFMpegCore/FFMPEG/Argument/Atoms/LoopArgument.cs
View file

@ -5,21 +5,14 @@
/// </summary>
public class LoopArgument : Argument<int>
{
public LoopArgument()
{
}
public LoopArgument() { }
public LoopArgument(int value) : base(value)
{
}
public LoopArgument(int value) : base(value) { }
/// <summary>
/// String representation of the argument
/// </summary>
/// <returns>String representation of the argument</returns>
/// <inheritdoc/>
public override string GetStringValue()
{
return ArgumentStringifier.Loop(Value);
return $"-loop {Value}";
}
}
}

27
FFMpegCore/FFMPEG/Argument/Atoms/OutputArgument.cs
View file

@ -8,33 +8,20 @@ namespace FFMpegCore.FFMPEG.Argument
/// </summary>
public class OutputArgument : Argument<string>
{
public OutputArgument()
{
}
public OutputArgument() { }
public OutputArgument(string value) : base(value)
{
}
public OutputArgument(string value) : base(value) { }
public OutputArgument(VideoInfo value) : base(value.FullName)
{
}
public OutputArgument(VideoInfo value) : base(value.FullName) { }
public OutputArgument(FileInfo value) : base(value.FullName)
{
}
public OutputArgument(FileInfo value) : base(value.FullName) { }
public OutputArgument(Uri value) : base(value.AbsolutePath)
{
}
public OutputArgument(Uri value) : base(value.AbsolutePath) { }
/// <summary>
/// String representation of the argument
/// </summary>
/// <returns>String representation of the argument</returns>
/// <inheritdoc/>
public override string GetStringValue()
{
return ArgumentStringifier.Output(Value);
return $"\"{Value}\"";
}
public FileInfo GetAsFileInfo()

9
FFMpegCore/FFMPEG/Argument/Atoms/OverrideArgument.cs
View file

@ -6,14 +6,9 @@
/// </summary>
public class OverrideArgument : Argument
{
public OverrideArgument()
{
}
public OverrideArgument() { }
/// <summary>
/// String representation of the argument
/// </summary>
/// <returns>String representation of the argument</returns>
/// <inheritdoc/>
public override string GetStringValue()
{
return "-y";

5
FFMpegCore/FFMPEG/Argument/Atoms/RemoveMetadataArgument.cs
View file

@ -5,10 +5,9 @@
/// </summary>
public class RemoveMetadataArgument : Argument
{
public RemoveMetadataArgument()
{
}
public RemoveMetadataArgument() { }
/// <inheritdoc/>
public override string GetStringValue()
{
return $"-map_metadata -1";

19
FFMpegCore/FFMPEG/Argument/Atoms/ScaleArgument.cs
View file

@ -8,30 +8,21 @@ namespace FFMpegCore.FFMPEG.Argument
/// </summary>
public class ScaleArgument : Argument<Size>
{
public ScaleArgument()
{
}
public ScaleArgument() { }
public ScaleArgument(Size value) : base(value)
{
}
public ScaleArgument(Size value) : base(value) { }
public ScaleArgument(int width, int heignt) : base(new Size(width, heignt))
{
}
public ScaleArgument(int width, int height) : base(new Size(width, height)) { }
public ScaleArgument(VideoSize videosize)
{
Value = videosize == VideoSize.Original ? new Size(-1, -1) : new Size(-1, (int)videosize);
}
/// <summary>
/// String representation of the argument
/// </summary>
/// <returns>String representation of the argument</returns>
/// <inheritdoc/>
public override string GetStringValue()
{
return ArgumentStringifier.Scale(Value.Width, Value.Height);
return $"-vf scale={Value.Width}:{Value.Height}";
}
}
}

15
FFMpegCore/FFMPEG/Argument/Atoms/SeekArgument.cs
View file

@ -7,21 +7,14 @@ namespace FFMpegCore.FFMPEG.Argument
/// </summary>
public class SeekArgument : Argument<TimeSpan?>
{
public SeekArgument()
{
}
public SeekArgument() { }
public SeekArgument(TimeSpan? value) : base(value)
{
}
public SeekArgument(TimeSpan? value) : base(value) { }
/// <summary>
/// String representation of the argument
/// </summary>
/// <returns>String representation of the argument</returns>
/// <inheritdoc/>
public override string GetStringValue()
{
return ArgumentStringifier.Seek(Value);
return !Value.HasValue ? string.Empty : $"-ss {Value}";
}
}
}

15
FFMpegCore/FFMPEG/Argument/Atoms/ShortestArgument.cs
View file

@ -5,21 +5,14 @@
/// </summary>
public class ShortestArgument : Argument<bool>
{
public ShortestArgument()
{
}
public ShortestArgument() { }
public ShortestArgument(bool value) : base(value)
{
}
public ShortestArgument(bool value) : base(value) { }
/// <summary>
/// String representation of the argument
/// </summary>
/// <returns>String representation of the argument</returns>
/// <inheritdoc/>
public override string GetStringValue()
{
return ArgumentStringifier.FinalizeAtShortestInput(Value);
return Value ? "-shortest" : string.Empty;
}
}
}

23
FFMpegCore/FFMPEG/Argument/Atoms/SizeArgument.cs
View file

@ -8,29 +8,18 @@ namespace FFMpegCore.FFMPEG.Argument
/// </summary>
public class SizeArgument : ScaleArgument
{
public SizeArgument()
{
}
public SizeArgument() { }
public SizeArgument(Size? value) : base(value ?? new Size())
{
}
public SizeArgument(Size? value) : base(value ?? default) { }
public SizeArgument(VideoSize videosize) : base(videosize)
{
}
public SizeArgument(VideoSize videosize) : base(videosize) { }
public SizeArgument(int width, int heignt) : base(width, heignt)
{
}
public SizeArgument(int width, int height) : base(width, height) { }
/// <summary>
/// String representation of the argument
/// </summary>
/// <returns>String representation of the argument</returns>
/// <inheritdoc/>
public override string GetStringValue()
{
return ArgumentStringifier.Size(Value);
return Value == default ? string.Empty : $"-s {Value.Width}x{Value.Height}";
}
}
}

11
FFMpegCore/FFMPEG/Argument/Atoms/SpeedArgument.cs
View file

@ -11,17 +11,12 @@ public SpeedArgument()
{
}
public SpeedArgument(Speed value) : base(value)
{
}
public SpeedArgument(Speed value) : base(value) { }
/// <summary>
/// String representation of the argument
/// </summary>
/// <returns>String representation of the argument</returns>
/// <inheritdoc/>
public override string GetStringValue()
{
return ArgumentStringifier.Speed(Value);
return $"-preset {Value.ToString().ToLower()}";
}
}
}

15
FFMpegCore/FFMPEG/Argument/Atoms/StartNumberArgument.cs
View file

@ -5,21 +5,14 @@
/// </summary>
public class StartNumberArgument : Argument<int>
{
public StartNumberArgument()
{
}
public StartNumberArgument() { }
public StartNumberArgument(int value) : base(value)
{
}
public StartNumberArgument(int value) : base(value) { }
/// <summary>
/// String representation of the argument
/// </summary>
/// <returns>String representation of the argument</returns>
/// <inheritdoc/>
public override string GetStringValue()
{
return ArgumentStringifier.StartNumber(Value);
return $"-start_number {Value}";
}
}
}

19
FFMpegCore/FFMPEG/Argument/Atoms/ThreadsArgument.cs
View file

@ -8,28 +8,19 @@ namespace FFMpegCore.FFMPEG.Argument
/// </summary>
public class ThreadsArgument : Argument<int>
{
public ThreadsArgument()
{
}
public ThreadsArgument() { }
public ThreadsArgument(int value) : base(value)
{
}
public ThreadsArgument(int value) : base(value) { }
public ThreadsArgument(bool isMultiThreaded) :
base(isMultiThreaded
? Environment.ProcessorCount
: 1)
{
}
: 1) { }
/// <summary>
/// String representation of the argument
/// </summary>
/// <returns>String representation of the argument</returns>
/// <inheritdoc/>
public override string GetStringValue()
{
return ArgumentStringifier.Threads(Value);
return $"-threads {Value}";
}
}
}

1
FFMpegCore/FFMPEG/Argument/Atoms/VariableBitRateArgument.cs
View file

@ -15,6 +15,7 @@ public VariableBitRateArgument(int vbr) : base(vbr)
}
}
/// <inheritdoc/>
public override string GetStringValue()
{
return $"-vbr {Value}";

22
FFMpegCore/FFMPEG/Argument/Atoms/VideoCodecArgument.cs
View file

@ -9,26 +9,26 @@ public class VideoCodecArgument : Argument<VideoCodec>
{
public int Bitrate { get; protected set; } = 0;
public VideoCodecArgument()
{
}
public VideoCodecArgument() { }
public VideoCodecArgument(VideoCodec value) : base(value)
{
}
public VideoCodecArgument(VideoCodec value) : base(value) { }
public VideoCodecArgument(VideoCodec value, int bitrate) : base(value)
{
Bitrate = bitrate;
}
/// <summary>
/// String representation of the argument
/// </summary>
/// <returns>String representation of the argument</returns>
/// <inheritdoc/>
public override string GetStringValue()
{
return ArgumentStringifier.Video(Value, Bitrate);
var video = $"-c:v {Value.ToString().ToLower()} -pix_fmt yuv420p";
if (Bitrate != default)
{
video += $" -b:v {Bitrate}k";
}
return video;
}
}
}

22
FFMpegCore/FFMPEG/Argument/FFArgumentBuilder.cs
View file

@ -21,27 +21,7 @@ public string BuildArguments(ArgumentContainer container)
if (!container.ContainsInputOutput())
throw new ArgumentException("No input or output parameter found", nameof(container));
return string.Join(" ", container.Select(argument => argument.Value.GetStringValue().Trim()));
}
private void CheckExtensionOfOutputExtension(ArgumentContainer container, FileInfo output)
{
if(container.ContainsKey(typeof(VideoCodecArgument)))
{
var codec = (VideoCodecArgument)container[typeof(VideoCodecArgument)];
FFMpegHelper.ExtensionExceptionCheck(output, FileExtension.ForCodec(codec.Value));
}
}
private Argument GetInput(ArgumentContainer container)
{
if (container.ContainsKey(typeof(InputArgument)))
return container[typeof(InputArgument)];
else if (container.ContainsKey(typeof(ConcatArgument)))
return container[typeof(ConcatArgument)];
else
throw new ArgumentException("No inputs found");
return string.Join(" ", container.Select(argument => argument.Value.GetStringValue()));
}
}
}

4
FFMpegCore/FFMPEG/Enums/VideoSize.cs
View file

@ -2,10 +2,10 @@
{
public enum VideoSize
{
Hd = 720,
FullHd = 1080,
Hd = 720,
Ed = 480,
Ld = 360,
Original
Original = -1
}
}

4
FFMpegCore/ImageInfo.cs
View file

@ -46,9 +46,7 @@ public ImageInfo(FileInfo fileInfo)
/// Create a image information object from a target path.
/// </summary>
/// <param name="path">Path to image.</param>
public ImageInfo(string path) : this(new FileInfo(path))
{
}
public ImageInfo(string path) : this(new FileInfo(path)) { }
/// <summary>
/// Aspect ratio.

4
FFMpegCore/VideoInfo.cs
View file

@ -28,9 +28,7 @@ public VideoInfo(FileInfo fileInfo)
/// Create a video information object from a target path.
/// </summary>
/// <param name="path">Path to video.</param>
public VideoInfo(string path) : this(new FileInfo(path))
{
}
public VideoInfo(string path) : this(new FileInfo(path)) { }
/// <summary>
/// Duration of the video file.