Alex/FFMpegCore
1
0
Fork 0
mirror of https://github.com/rosenbjerg/FFMpegCore.git synced 2024-09-20 13:32:23 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

Added option to use the segment muxer allowing output to file to be segmented. There's a SegmentCustomArgument for the arguments I did not implement.

Browse source
This commit is contained in:
Yan Gauthier 2024-08-15 15:26:03 -04:00
parent a6e90e2078
commit f71e172f66
9 changed files with 294 additions and 2 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

106
FFMpegCore.Test/VideoTest.cs
View file

@ -16,6 +16,22 @@ namespace FFMpegCore.Test
public class VideoTest
{
private const int BaseTimeoutMilliseconds = 15_000;
private string _segmentPathSource = "";
[TestInitialize]
public void Setup()
{
_segmentPathSource = Path.Combine(Path.GetTempPath(), $"{Guid.NewGuid()}-");
}
[TestCleanup]
public void Cleanup()
{
foreach (var file in Directory.EnumerateFiles(Path.GetDirectoryName(_segmentPathSource), Path.GetFileName(_segmentPathSource) + "*"))
{
File.Delete(file);
}
}
[TestMethod, Timeout(BaseTimeoutMilliseconds)]
public void Video_ToOGV()
@ -895,5 +911,95 @@ public async Task Video_Cancel_CancellationToken_Async_With_Timeout()
Assert.AreEqual("h264", outputInfo.PrimaryVideoStream.CodecName);
Assert.AreEqual("aac", outputInfo.PrimaryAudioStream!.CodecName);
}
[TestMethod, Timeout(BaseTimeoutMilliseconds)]
public void Video_Segmented_File_Output()
{
using var input = File.OpenRead(TestResources.WebmVideo);
var success = FFMpegArguments
.FromPipeInput(new StreamPipeSource(input))
.OutPutToSegmentedFiles(
new SegmentArgument($"{_segmentPathSource}%Y-%m-%d_%H-%M-%S.mkv", true, segmentOptions => segmentOptions
.Strftime(true)
.Wrap(-1)
.Time(60)
.ResetTimeStamps(true)),
options => options
.CopyChannel()
.WithVideoCodec("h264")
.ForceFormat("matroska")
.WithConstantRateFactor(21)
.WithVideoBitrate(3000)
.WithFastStart()
.WithVideoFilters(filterOptions => filterOptions
.Scale(VideoSize.Hd)
.DrawText(DrawTextOptions.Create(@"'%{localtime}.%{eif\:1M*t-1K*trunc(t*1K)\:d\:3}'", @"C:/Users/yan.gauthier/AppData/Local/Microsoft/Windows/Fonts/Roboto-Regular.ttf")
.WithParameter("fontcolor", "yellow")
.WithParameter("fontsize", "40")
.WithParameter("x", "(w-text_w)")
.WithParameter("y", "(h - text_h)")
.WithParameter("rate", "19")
)
)
)
.CancellableThrough(new CancellationTokenSource().Token, 8000)
.ProcessSynchronously(false);
Assert.IsTrue(success);
}
[TestMethod, Timeout(BaseTimeoutMilliseconds)]
public void Video_MultiOutput_With_Segmented_File_Output()
{
using var input = File.OpenRead(TestResources.WebmVideo);
var success = FFMpegArguments
.FromPipeInput(new StreamPipeSource(input))
.MultiOutput(args => args
.OutputToFile($"{_segmentPathSource}2", true, options => options
.CopyChannel()
.WithVideoCodec("mjpeg")
.ForceFormat("matroska")
.WithConstantRateFactor(21)
.WithVideoBitrate(4000)
.WithFastStart()
.WithVideoFilters(filterOptions => filterOptions
.Scale(VideoSize.Hd)
.DrawText(DrawTextOptions.Create(@"'%{localtime}.%{eif\:1M*t-1K*trunc(t*1K)\:d\:3}'", @"C:/Users/yan.gauthier/AppData/Local/Microsoft/Windows/Fonts/Roboto-Regular.ttf")
.WithParameter("fontcolor", "yellow")
.WithParameter("fontsize", "40")
.WithParameter("x", "(w-text_w)")
.WithParameter("y", "(h - text_h)")
.WithParameter("rate", "19")
)
)
)
.OutPutToSegmentedFiles(
new SegmentArgument($"{_segmentPathSource}%Y-%m-%d_%H-%M-%S.mkv", true, segmentOptions => segmentOptions
.Strftime(true)
.Wrap(-1)
.Time(60)
.ResetTimeStamps(true)),
options => options
.CopyChannel()
.WithVideoCodec("h264")
.ForceFormat("matroska")
.WithConstantRateFactor(21)
.WithVideoBitrate(3000)
.WithFastStart()
.WithVideoFilters(filterOptions => filterOptions
.Scale(VideoSize.Hd)
.DrawText(DrawTextOptions.Create(@"'%{localtime}.%{eif\:1M*t-1K*trunc(t*1K)\:d\:3}'", @"C:/Users/yan.gauthier/AppData/Local/Microsoft/Windows/Fonts/Roboto-Regular.ttf")
.WithParameter("fontcolor", "yellow")
.WithParameter("fontsize", "40")
.WithParameter("x", "(w-text_w)")
.WithParameter("y", "(h - text_h)")
.WithParameter("rate", "19")
)
)
)
)
.CancellableThrough(new CancellationTokenSource().Token, 8000)
.ProcessSynchronously(false);
Assert.IsTrue(success);
}
}
}

92
FFMpegCore/FFMpeg/Arguments/OutputSegmentArgument.cs Normal file
View file

@ -0,0 +1,92 @@
using FFMpegCore.Exceptions;
namespace FFMpegCore.Arguments
{
/// <summary>
/// Represents output parameter
/// </summary>
public class OutputSegmentArgument : IOutputArgument
{
public readonly string SegmentPattern;
public readonly bool Overwrite;
public readonly SegmentArgumentOptions Options;
public OutputSegmentArgument(SegmentArgument segmentArgument)
{
SegmentPattern = segmentArgument.SegmentPattern;
Overwrite = segmentArgument.Overwrite;
var segmentArgumentobj = new SegmentArgumentOptions();
segmentArgument.Options?.Invoke(segmentArgumentobj);
Options = segmentArgumentobj;
}
public void Pre()
{
if (int.TryParse(Options.Arguments.FirstOrDefault(x => x.Key == "segment_time").Value, out var result) && result < 1)
{
throw new FFMpegException(FFMpegExceptionType.Process, "Parameter SegmentTime cannot be negative or equal to zero");
}
if (Options.Arguments.FirstOrDefault(x => x.Key == "segment_time").Value == "0")
{
throw new FFMpegException(FFMpegExceptionType.Process, "Parameter SegmentWrap cannot equal to zero");
}
}
public Task During(CancellationToken cancellationToken = default) => Task.CompletedTask;
public void Post()
{
}
public string Text => GetText();
private string GetText()
{
var arguments = Options.Arguments
.Where(arg => !string.IsNullOrWhiteSpace(arg.Value) && !string.IsNullOrWhiteSpace(arg.Key))
.Select(arg =>
{
return arg.Value;
});
return $"-f segment {string.Join(" ", arguments)} \"{SegmentPattern}\"{(Overwrite ? " -y" : string.Empty)}";
}
}
public interface ISegmentArgument
{
public string Key { get; }
public string Value { get; }
}
public class SegmentArgumentOptions
{
public List<ISegmentArgument> Arguments { get; } = new();
public SegmentArgumentOptions ResetTimeStamps(bool resetTimestamps = true) => WithArgument(new SegmentResetTimeStampsArgument(resetTimestamps));
public SegmentArgumentOptions Strftime(bool enable = false) => WithArgument(new SegmentStrftimeArgument(enable));
public SegmentArgumentOptions Time(int time = 60) => WithArgument(new SegmentTimeArgument(time));
public SegmentArgumentOptions Wrap(int limit = -1) => WithArgument(new SegmentWrapArgument(limit));
public SegmentArgumentOptions WithCustomArgument(string argument) => WithArgument(new SegmentCustomArgument(argument));
private SegmentArgumentOptions WithArgument(ISegmentArgument argument)
{
Arguments.Add(argument);
return this;
}
}
public class SegmentArgument
{
public readonly string SegmentPattern;
public readonly bool Overwrite;
public readonly Action<SegmentArgumentOptions> Options;
public SegmentArgument(string segmentPattern, bool overwrite, Action<SegmentArgumentOptions> options)
{
SegmentPattern = segmentPattern;
Overwrite = overwrite;
Options = options;
}
}
}

14
FFMpegCore/FFMpeg/Arguments/SegmentCustomArgument.cs Normal file
View file

@ -0,0 +1,14 @@
namespace FFMpegCore.Arguments
{
public class SegmentCustomArgument : ISegmentArgument
{
public readonly string Argument;
public SegmentCustomArgument(string argument)
{
Argument = argument;
}
public string Key => "custom";
public string Value => Argument ?? string.Empty;
}
}

20
FFMpegCore/FFMpeg/Arguments/SegmentResetTimestampsArgument.cs Normal file
View file

@ -0,0 +1,20 @@
namespace FFMpegCore.Arguments
{
/// <summary>
/// Represents reset_timestamps parameter
/// </summary>
public class SegmentResetTimeStampsArgument : ISegmentArgument
{
public readonly bool ResetTimestamps;
/// <summary>
/// Represents reset_timestamps parameter
/// </summary>
/// <param name="resetTimestamps">true if files timestamps are to be reset</param>
public SegmentResetTimeStampsArgument(bool resetTimestamps)
{
ResetTimestamps = resetTimestamps;
}
public string Key { get; } = "reset_timestamps";
public string Value => ResetTimestamps ? $"-reset_timestamps 1" : string.Empty;
}
}

20
FFMpegCore/FFMpeg/Arguments/SegmentStrftimeArgument.cs Normal file
View file

@ -0,0 +1,20 @@
namespace FFMpegCore.Arguments
{
/// <summary>
/// Use the strftime function to define the name of the new segments to write. If this is selected, the output segment name must contain a strftime function template. Default value is 0.
/// </summary>
public class SegmentStrftimeArgument : ISegmentArgument
{
public readonly bool Enable;
/// <summary>
/// Use the strftime function to define the name of the new segments to write. If this is selected, the output segment name must contain a strftime function template. Default value is 0.
/// </summary>
/// <param name="enable">true to enable strftime</param>
public SegmentStrftimeArgument(bool enable)
{
Enable = enable;
}
public string Key { get; } = "strftime";
public string Value => Enable ? $"-strftime 1" : string.Empty;
}
}

20
FFMpegCore/FFMpeg/Arguments/SegmentTimeArgument.cs Normal file
View file

@ -0,0 +1,20 @@
namespace FFMpegCore.Arguments
{
/// <summary>
/// Represents segment_time parameter
/// </summary>
public class SegmentTimeArgument : ISegmentArgument
{
public readonly int Time;
/// <summary>
/// Represents segment_time parameter
/// </summary>
/// <param name="time">time in seconds of the segment</param>
public SegmentTimeArgument(int time)
{
Time = time;
}
public string Key { get; } = "segment_time";
public string Value => Time <= 0 ? string.Empty : $"-segment_time {Time}";
}
}

20
FFMpegCore/FFMpeg/Arguments/SegmentWrapArgument.cs Normal file
View file

@ -0,0 +1,20 @@
namespace FFMpegCore.Arguments
{
/// <summary>
/// Represents segment_wrap parameter
/// </summary>
public class SegmentWrapArgument : ISegmentArgument
{
public readonly int Limit;
/// <summary>
/// Represents segment_wrap parameter
/// </summary>
/// <param name="limit">limit value after which segment index will wrap around</param>
public SegmentWrapArgument(int limit)
{
Limit = limit;
}
public string Key { get; } = "segment_wrap";
public string Value => Limit <= 0 ? string.Empty : $"-segment_wrap {Limit}";
}
}

2
FFMpegCore/FFMpeg/FFMpegArguments.cs
View file

@ -61,7 +61,7 @@ private FFMpegArguments WithInput(IInputArgument inputArgument, Action<FFMpegArg
public FFMpegArgumentProcessor OutputToUrl(string uri, Action<FFMpegArgumentOptions>? addArguments = null) => ToProcessor(new OutputUrlArgument(uri), addArguments);
public FFMpegArgumentProcessor OutputToUrl(Uri uri, Action<FFMpegArgumentOptions>? addArguments = null) => ToProcessor(new OutputUrlArgument(uri.ToString()), addArguments);
public FFMpegArgumentProcessor OutputToPipe(IPipeSink reader, Action<FFMpegArgumentOptions>? addArguments = null) => ToProcessor(new OutputPipeArgument(reader), addArguments);
public FFMpegArgumentProcessor OutPutToSegmentedFiles(SegmentArgument segmentArgument, Action<FFMpegArgumentOptions>? addArguments = null) => ToProcessor(new OutputSegmentArgument(segmentArgument), addArguments);
private FFMpegArgumentProcessor ToProcessor(IOutputArgument argument, Action<FFMpegArgumentOptions>? addArguments)
{
var args = new FFMpegArgumentOptions();

2
FFMpegCore/FFMpeg/FFMpegMultiOutputOptions.cs
View file

@ -16,7 +16,7 @@ public class FFMpegMultiOutputOptions
public FFMpegMultiOutputOptions OutputToUrl(Uri uri, Action<FFMpegArgumentOptions>? addArguments = null) => AddOutput(new OutputUrlArgument(uri.ToString()), addArguments);
public FFMpegMultiOutputOptions OutputToPipe(IPipeSink reader, Action<FFMpegArgumentOptions>? addArguments = null) => AddOutput(new OutputPipeArgument(reader), addArguments);
public FFMpegMultiOutputOptions OutPutToSegmentedFiles(SegmentArgument segmentArgument, Action<FFMpegArgumentOptions>? addArguments = null) => AddOutput(new OutputSegmentArgument(segmentArgument), addArguments);
public FFMpegMultiOutputOptions AddOutput(IOutputArgument argument, Action<FFMpegArgumentOptions>? addArguments)
{
var args = new FFMpegArgumentOptions();