feat: enable processing of large video files over 2GB

Update audio extraction to use file-based streaming
instead of in-memory buffers to support processing
video files larger than 2GB.

**Changes:**
- Modified `IAudioExtractor.ExtractMp3FromMp4Async()`
  to accept an output audio stream parameter instead
  of creating a MemoryStream internally
- Updated `AudioExtractor` to write directly to the
  provided audio stream, eliminating the need to load
  entire video into memory
- Enhanced `FFMpegService` to detect FileStream inputs
  and use direct file-to-file processing when possible,
  falling back to pipe-based streaming for other stream types
- Refactored `DefaultCommand` to create output directory
  and audio file stream before extraction, enabling direct
  file-based audio extraction
- Updated all unit and integration tests to accommodate the
  new audio stream parameter

This change prevents `OutOfMemoryException` errors when processing
large video files by streaming data directly to disk rather than
buffering in memory. Additionally, it removes the possibility of
overflowing the 2GB size limit that `MemoryStream` has, which
would result in `IOException` errors when trying to write or
copy to it.

src/StreamShorts.Console/Commands/DefaultCommand.cs

@@ -69,13 +69,28 @@ internal sealed class DefaultCommand(
   public override async Task<int> ExecuteAsync(CommandContext context, Settings settings)
   {
     _console.MarkupLine($"[blue]Processing stream:[/] {settings.Stream.EscapeMarkup()}");
-    var videoStream = _fileSystem.File.OpenRead(settings.Stream);
+    var videoStream = (FileStream)_fileSystem.File.OpenRead(settings.Stream);
 
-    Stream? audioStream = null;
+    var now = _timeProvider.GetUtcNow();
+    var inputFileName = _fileSystem.Path.GetFileNameWithoutExtension(settings.Stream);
+    var baseDirectory = ValidateAndGetBaseOutputDirectory();
+    var artifactsOutputDirectory = $"{now:yyyy_MM_dd_HH_mm_ss}_{inputFileName}";
+    var outputDirectoryPath = _fileSystem.Path.Combine(baseDirectory, artifactsOutputDirectory);
+
+    _fileSystem.Directory.CreateDirectory(outputDirectoryPath);
+
+    using var audioStream = new FileStream(
+      _fileSystem.Path.Combine(outputDirectoryPath, "audio.mp3"),
+      FileMode.Create,
+      FileAccess.ReadWrite,
+      FileShare.ReadWrite,
+      4096,
+      FileOptions.Asynchronous
+    );
 
     await _console.Status()
       .Spinner(Spinner.Known.Dots)
-      .StartAsync("Extracting audio...", async _ => audioStream = await _audioExtractor.ExtractMp3FromMp4Async(videoStream));
+      .StartAsync("Extracting audio...", async _ => await _audioExtractor.ExtractMp3FromMp4Async(videoStream, audioStream));
 
     if (audioStream is null)
     {
@@ -101,14 +116,6 @@ internal sealed class DefaultCommand(
 
     _console.MarkupLine($"[blue]Transcription completed[/] [green]successfully![/]");
 
-    var now = _timeProvider.GetUtcNow();
-    var inputFileName = _fileSystem.Path.GetFileNameWithoutExtension(settings.Stream);
-    var baseDirectory = ValidateAndGetBaseOutputDirectory();
-    var artifactsOutputDirectory = $"{now:yyyy_MM_dd_HH_mm_ss}_{inputFileName}";
-    var outputDirectoryPath = _fileSystem.Path.Combine(baseDirectory, artifactsOutputDirectory);
-
-    _fileSystem.Directory.CreateDirectory(outputDirectoryPath);
-
     await _fileSystem.File.WriteAllTextAsync(
       _fileSystem.Path.Combine(outputDirectoryPath, "transcription.txt"),
       string.Join(Environment.NewLine, transcriptionSegments)

src/StreamShorts.Library/Media/Audio/AudioExtractor.cs

@@ -25,7 +25,7 @@ public sealed class AudioExtractor : IAudioExtractor
     _videoService = videoService ?? throw new ArgumentNullException(nameof(videoService), $"{nameof(videoService)} cannot be null");
   }
 
-  public async Task<Stream> ExtractMp3FromMp4Async(Stream video)
+  public async Task<Stream> ExtractMp3FromMp4Async(Stream video, Stream audio)
   {
     if (video is null)
     {
@@ -42,25 +42,29 @@ public sealed class AudioExtractor : IAudioExtractor
       throw new ArgumentException("Video stream must be seekable", nameof(video));
     }
 
+    if (audio is null)
+    {
+      throw new ArgumentNullException(nameof(audio), "Audio stream cannot be null");
+    }
+
+    if (audio.CanWrite is false)
+    {
+      throw new ArgumentException("Audio stream must be writable", nameof(audio));
+    }
+
     var originalPosition = video.Position;
 
     try
     {
-      var mp3Stream = new MemoryStream();
+      var wasExtracted = await _videoService.ExtractAudioFromVideoAsync(video, audio).ConfigureAwait(false);
-      using var mp4Stream = new MemoryStream();
-
-      await video.CopyToAsync(mp4Stream).ConfigureAwait(false);
-      mp4Stream.Position = 0;
-
-      var wasExtracted = await _videoService.ExtractAudioFromVideoAsync(mp4Stream, mp3Stream).ConfigureAwait(false);
 
       if (wasExtracted is false)
       {
         throw new FailedAudioExtractionException("Failed to extract audio from the video stream.");
       }
 
-      mp3Stream.Position = 0;
+      audio.Position = 0;
-      return mp3Stream;
+      return audio;
     }
     catch (Exception e) when (e is not FailedAudioExtractionException)
     {

src/StreamShorts.Library/Media/Audio/IAudioExtractor.cs

@@ -9,11 +9,14 @@ public interface IAudioExtractor
   /// Extracts MP3 audio from an MP4 video stream.
   /// </summary>
   /// <param name="video">The input video stream.</param>
+  /// <param name="audio">The output audio stream where the extracted MP3 will be written.</param>
   /// <returns>A stream containing the extracted MP3 audio.</returns>
   /// <exception cref="ArgumentNullException">Thrown when the video stream is null.</exception>
   /// <exception cref="ArgumentException">Thrown when the video stream is not readable.</exception>
   /// <exception cref="ArgumentException">Thrown when the video stream is not seekable.</exception>
+  /// <exception cref="ArgumentNullException">Thrown when the audio stream is null.</exception>
+  /// <exception cref="ArgumentException">Thrown when the audio stream is not writable.</exception>
   /// <exception cref="FailedAudioExtractionException">Thrown when the audio extraction fails.</exception>
   /// <remarks>The method will preserve the passed video stream's data and position.</remarks>
-  Task<Stream> ExtractMp3FromMp4Async(Stream video);
+  Task<Stream> ExtractMp3FromMp4Async(Stream video, Stream audio);
 }

src/StreamShorts.Library/Media/FFMpegService.cs

@@ -12,14 +12,17 @@ internal sealed class FFMpegService : IVideoService
 {
   public async Task<bool> ExtractAudioFromVideoAsync(Stream video, Stream audio)
   {
-    return await FFMpegArguments
+    var inputArguments = video is FileStream videoFileStream
-      .FromPipeInput(new StreamPipeSource(video))
+      ? FFMpegArguments.FromFileInput(videoFileStream.Name)
-      .OutputToPipe(
+      : FFMpegArguments.FromPipeInput(new StreamPipeSource(video));
-        new StreamPipeSink(audio),
+
-        static o => o.DisableChannel(Channel.Video).ForceFormat("mp3")
+    Action<FFMpegArgumentOptions> arguments = static o => o.DisableChannel(Channel.Video).ForceFormat("mp3");
-      )
+
-      .ProcessAsynchronously()
+    var processor = audio is FileStream audioFileStream
-      .ConfigureAwait(false);
+      ? inputArguments.OutputToFile(audioFileStream.Name, addArguments: arguments)
+      : inputArguments.OutputToPipe(new StreamPipeSink(audio), addArguments: arguments);
+    
+    return await processor.ProcessAsynchronously().ConfigureAwait(false);
   }
 
   public async Task CreateClipFromVideoAsync(

tests/StreamShorts.Library.Tests/Integration/Media/Audio/AudioExtractorTests.cs

@@ -9,13 +9,15 @@ public class AudioExtractorTests
   {
     using var testVideo = TestData.GetTestVideo();
     using var extractedAudio = TestData.GetExtractedAudio();
+    using var audioStream = new MemoryStream();
 
-    var result = await _sut.ExtractMp3FromMp4Async(testVideo);
+    var result = await _sut.ExtractMp3FromMp4Async(testVideo, audioStream);
 
     var audioBytes = await ConvertStreamToBytesAsync(extractedAudio);
     var resultBytes = await ConvertStreamToBytesAsync(result);
 
     resultBytes.Should().Equal(audioBytes);
+    result.Should().BeSameAs(audioStream);
   }
 
   private static async Task<byte[]> ConvertStreamToBytesAsync(Stream stream)

tests/StreamShorts.Library.Tests/Unit/Media/Audio/AudioExtractorTests.cs

@@ -25,7 +25,7 @@ public class AudioExtractorTests
   [Fact]
   public async Task ExtractMp3FromMp4Async_WhenVideoIsNull_ItShouldThrow()
   {
-    var action = async () => await _sut.ExtractMp3FromMp4Async(null!);
+    var action = async () => await _sut.ExtractMp3FromMp4Async(null!, new MemoryStream());
 
     await action.Should().ThrowAsync<ArgumentNullException>();
   }
@@ -36,7 +36,7 @@ public class AudioExtractorTests
     var mockStream = new Mock<Stream>();
     mockStream.Setup(s => s.CanRead).Returns(false);
 
-    var action = async () => await _sut.ExtractMp3FromMp4Async(mockStream.Object);
+    var action = async () => await _sut.ExtractMp3FromMp4Async(mockStream.Object, new MemoryStream());
 
     await action.Should().ThrowAsync<ArgumentException>();
   }
@@ -48,7 +48,7 @@ public class AudioExtractorTests
     mockStream.Setup(s => s.CanRead).Returns(true);
     mockStream.Setup(s => s.CanSeek).Returns(false);
 
-    var action = async () => await _sut.ExtractMp3FromMp4Async(mockStream.Object);
+    var action = async () => await _sut.ExtractMp3FromMp4Async(mockStream.Object, new MemoryStream());
 
     await action.Should().ThrowAsync<ArgumentException>();
   }
@@ -69,7 +69,7 @@ public class AudioExtractorTests
       )
       .ThrowsAsync(new Exception());
 
-    var action = async () => await _sut.ExtractMp3FromMp4Async(mockStream.Object);
+    var action = async () => await _sut.ExtractMp3FromMp4Async(mockStream.Object, new MemoryStream());
 
     await action.Should().ThrowAsync<FailedAudioExtractionException>();
   }
@@ -90,7 +90,7 @@ public class AudioExtractorTests
       )
       .ReturnsAsync(false);
 
-    var action = async () => await _sut.ExtractMp3FromMp4Async(mockStream.Object);
+    var action = async () => await _sut.ExtractMp3FromMp4Async(mockStream.Object, new MemoryStream());
 
     await action.Should().ThrowAsync<FailedAudioExtractionException>();
   }
@@ -111,7 +111,7 @@ public class AudioExtractorTests
       )
       .ReturnsAsync(true);
 
-    var result = await _sut.ExtractMp3FromMp4Async(mockStream.Object);
+    var result = await _sut.ExtractMp3FromMp4Async(mockStream.Object, new MemoryStream());
 
     result.Should().BeAssignableTo<Stream>();
     result.Should().BeOfType<MemoryStream>();
@@ -137,7 +137,7 @@ public class AudioExtractorTests
       )
       .ReturnsAsync(true);
 
-    await _sut.ExtractMp3FromMp4Async(stream);
+    await _sut.ExtractMp3FromMp4Async(stream, new MemoryStream());
 
     stream.Position.Should().Be(positionToRead);
   }