0.1.0

.github/workflows/dotnet.yml

@@ -2,38 +2,113 @@ name: .NET
 
 on:
   push:
-    branches: ["*"]
+    branches: ["main"]
     tags: ["*"]
+    paths-ignore:
+      - "**.md"
   pull_request:
     branches: ["*"]
+    paths-ignore:
+      - "**.md"
+
+permissions:
+  contents: write
 
 jobs:
-  build:
-    runs-on: ubuntu-latest
+  test:
+    strategy:
+      matrix:
+        rid:
+          - win-x64
+          - linux-x64
+          - osx-arm64
+
+    runs-on: ${{ startsWith(matrix.rid, 'win-') && 'windows-latest' || startsWith(matrix.rid, 'osx-') && 'macos-latest' || 'ubuntu-latest' }}
+    timeout-minutes: 10
+
     steps:
     - uses: actions/checkout@v4
+
     - name: Setup .NET
       uses: actions/setup-dotnet@v4
       with:
         dotnet-version: 8.0.x
-    - name: Set up PulseAudio
+
+    - name: Install dependencies
+      run: |
+        dotnet restore
+
+    - name: Build Release
+      run: dotnet build --configuration Release --no-restore
+
+    # Platform-specific custom steps
+    - name: Set up PulseAudio (Linux only)
+      if: matrix.rid == 'linux-x64'
       run: |
         sudo apt-get update
         sudo apt-get install -y pulseaudio
-    - name: Restore dependencies
-      run: dotnet restore
-    - name: Build
-      run: dotnet build --no-restore
-    - name: Test
-      run: |
         pulseaudio --start
         pactl load-module module-null-sink sink_name=VirtualSink sink_properties=device.description=Virtual_Sink
         pactl set-default-sink VirtualSink
-        dotnet test --no-build --verbosity normal
+
+    - name: Test
+      run: dotnet test --verbosity normal --configuration Release
+  pack:
+    strategy:
+      matrix:
+        rid:
+          - win-arm64
+          - win-x86
+          - win-x64
+          - linux-arm64
+          - linux-x64
+          - osx-arm64
+          - osx-x64
+
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+
+    permissions:
+      actions: write
+      contents: write
+
+    steps:
+    - uses: actions/checkout@v4
+    - name: Setup .NET
+      uses: actions/setup-dotnet@v4
+      with:
+        dotnet-version: 8.0.x
+
     - name: Publish
-      run: cd Console && dotnet publish -c Release -o ./output
+      run: cd Console && dotnet publish -c Release --runtime ${{ matrix.rid }} -o ./output
+
+    - name: Set execution permission
+      if: ${{ !startsWith(matrix.rid, 'win-') }}
+      run: chmod +x  ./Console/output/Console
+
+    - name: Rename file
+      run: |
+        FILE=$(find ./Console/output -type f -name 'Console*')
+        if [ -f "$FILE" ]; then
+          FILENAME=$(basename -- "$FILE")                    # Extract the file name
+          EXTENSION="${FILENAME##*.}"                        # Extract the file extension
+          if [ "$EXTENSION" != "$FILENAME" ]; then           # Check if an extension exists
+            mv "$FILE" "./Console/output/Console-${{ matrix.rid }}.$EXTENSION"  # Rename with extension
+          else
+            mv "$FILE" "./Console/output/Console-${{ matrix.rid }}"            # Rename without extension
+          fi
+        fi
     - name: Upload Artifact
       uses: actions/upload-artifact@v4
       with:
-        name: YoutubeConsole
+        name: YoutubeConsole.${{ matrix.rid }}
         path: ./Console/output
+        if-no-files-found: error
+
+    - name: Create Release
+      uses: softprops/action-gh-release@v2
+      if: startsWith(github.ref, 'refs/tags/')
+      with:
+        files: ./Console/output/Console*
+
+

.gitignore

@@ -36,6 +36,15 @@ bld/
 [Ll]og/
 [Ll]ogs/
 
+## sqlite
+*.db
+
+## libs
+*.so
+*.dll
+*.dylib
+*.a
+
 # Visual Studio 2015/2017 cache/options directory
 .vs/
 # Uncomment if you have tasks that create the project's static files in wwwroot
@@ -48,6 +57,9 @@ Generated\ Files/
 [Tt]est[Rr]esult*/
 [Bb]uild[Ll]og.*
 
+# Specific settings
+launchSettings.json
+
 # NUnit
 *.VisualState.xml
 TestResult.xml

Console/Audio/AudioSender.cs

@@ -1,134 +1,114 @@
 using System.Threading.Channels;
-using OpenTK.Audio.OpenAL;
+using PortAudioSharp;
 
 namespace Console.Audio;
 
-internal class AudioSender(int sourceId, ALFormat targetFormat) : IAsyncDisposable
+internal class AudioSender(float volume, PlayState initialState) : IAsyncDisposable
 {
-    private readonly Channel<PcmPacket> _queue = Channel.CreateBounded<PcmPacket>(50);
+    private readonly Channel<PcmPacket<short>> _queue = Channel.CreateBounded<PcmPacket<short>>(
+        500
+    );
     public readonly int SampleRate = 48000;
     public readonly int Channels = 2;
-    private readonly int[] _buffers = AL.GenBuffers(50);
-    private bool _clearBuffer = false;
+    public PlayState State { get; set; } = initialState;
+    public float Volume { get; set; } = volume;
+    public TimeSpan CurrentTime { get; private set; } = default;
+    public TaskCompletionSource WaitForEmptyBuffer { get; set; } = new();
+    private PortAudioSharp.Stream? _stream;
 
     public void ClearBuffer()
     {
-        _clearBuffer = true;
         while (_queue.Reader.TryRead(out var next))
         {
             next.Dispose();
         }
     }
 
-    public async ValueTask Add(PcmPacket data) => await _queue.Writer.WriteAsync(data);
+    public async ValueTask Add(PcmPacket<short> data) => await _queue.Writer.WriteAsync(data);
 
-    private async ValueTask ClearBufferAL(CancellationToken token)
+    public unsafe void StartSending(CancellationToken token = default)
     {
-        AL.GetSource(sourceId, ALGetSourcei.SourceState, out int initialState);
+        // Define a callback delegate for audio processing
+        StreamCallbackResult callback(
+            IntPtr input,
+            IntPtr output,
+            UInt32 frameCount,
+            ref StreamCallbackTimeInfo timeInfo,
+            StreamCallbackFlags statusFlags,
+            IntPtr userData
+        )
+        {
+            var sizeInBytes = (int)frameCount * 2;
 
-        AL.SourceStop(sourceId);
-        AL.GetSource(sourceId, ALGetSourcei.BuffersQueued, out int queuedCount);
+            if (token.IsCancellationRequested)
+                return StreamCallbackResult.Abort;
 
-        if (queuedCount > 0)
-        {
-            int[] bufferIds = new int[queuedCount];
-            AL.SourceUnqueueBuffers(sourceId, queuedCount, bufferIds);
-            foreach (var buffer in bufferIds)
+            if (State == PlayState.Paused)
             {
-                using var next = await _queue.Reader.ReadAsync(token);
-                AL.BufferData(buffer, targetFormat, next.Data, SampleRate);
-                AL.SourceQueueBuffer(sourceId, buffer);
+                var spanUnmanagedBuffer = new Span<short>(output.ToPointer(), sizeInBytes);
+                spanUnmanagedBuffer.Clear();
+                return StreamCallbackResult.Continue;
             }
-        }
-
-        _clearBuffer = false;
 
-        if ((ALSourceState)initialState == ALSourceState.Playing)
-        {
-            AL.SourcePlay(sourceId);
-        }
-
-        if ((ALSourceState)initialState == ALSourceState.Paused)
-        {
-            AL.SourcePlay(sourceId);
-            AL.SourcePause(sourceId);
-        }
-    }
-
-    public async Task StartSending(CancellationToken token = default)
-    {
-        var fillBuffers = await _queue
-            .Reader.ReadAllAsync(token)
-            .Take(10)
-            .ToListAsync(cancellationToken: token);
-
-        for (int i = 0; i < fillBuffers.Count; i++)
-        {
-            using var item = fillBuffers[i];
-            AL.BufferData(_buffers[i], targetFormat, item.Data, SampleRate);
-            AL.SourceQueueBuffer(sourceId, _buffers[i]);
-        }
+            if (State == PlayState.Stopped)
+                return StreamCallbackResult.Abort;
 
-        var _ = Task.Run(
-            async () =>
+            if (_queue.Reader.TryRead(out var nextBuffer))
             {
-                try
-                {
-                    while (!token.IsCancellationRequested)
-                    {
-                        if (_clearBuffer)
-                        {
-                            await ClearBufferAL(token);
-                            continue;
-                        }
-
-                        AL.GetSource(
-                            sourceId,
-                            ALGetSourcei.BuffersProcessed,
-                            out int releasedCount
-                        );
-
-                        if (releasedCount > 0)
-                        {
-                            int[] bufferIds = new int[releasedCount];
-                            AL.SourceUnqueueBuffers(sourceId, releasedCount, bufferIds);
-                            foreach (var buffer in bufferIds)
-                            {
-                                using var next = await _queue.Reader.ReadAsync(token);
-                                AL.BufferData(buffer, targetFormat, next.Data, SampleRate);
-                                AL.SourceQueueBuffer(sourceId, buffer);
-                            }
-                        }
-
-                        AL.GetSource(sourceId, ALGetSourcei.SourceState, out int stateInt);
+                using var buffer = nextBuffer;
+                var spanUnmanagedBuffer = new Span<short>(output.ToPointer(), sizeInBytes);
+                var source = buffer.Data[..sizeInBytes];
 
-                        if ((ALSourceState)stateInt == ALSourceState.Stopped)
-                        {
-                            AL.SourcePlay(sourceId);
-                        }
-
-                        await Task.Delay(100);
-                    }
-                }
-                finally
+                for (var i = 0; i < source.Length; i++)
                 {
-                    await ClearBufferAL(token);
+                    source[i] = (short)(source[i] * Volume);
                 }
-            },
-            token
+
+                source.CopyTo(spanUnmanagedBuffer);
+                CurrentTime = buffer.Time;
+                return StreamCallbackResult.Continue;
+            }
+            else
+            {
+                WaitForEmptyBuffer.TrySetResult();
+                var spanUnmanagedBuffer = new Span<short>(output.ToPointer(), sizeInBytes);
+                spanUnmanagedBuffer.Clear();
+                return StreamCallbackResult.Continue;
+            }
+        }
+
+        StreamParameters param = new();
+        var deviceIndex = PortAudio.DefaultOutputDevice;
+        var info = PortAudio.GetDeviceInfo(deviceIndex);
+        param.device = PortAudio.DefaultOutputDevice;
+        param.channelCount = Channels;
+        param.sampleFormat = SampleFormat.Int16;
+        param.suggestedLatency = info.defaultHighOutputLatency;
+        param.hostApiSpecificStreamInfo = IntPtr.Zero;
+
+        _stream = new PortAudioSharp.Stream(
+            inParams: null,
+            outParams: param,
+            streamFlags: StreamFlags.ClipOff,
+            sampleRate: SampleRate,
+            framesPerBuffer: 960, //TODO This should not be hardcoded maybe?
+            callback: callback,
+            userData: IntPtr.Zero
         );
 
-        AL.SourcePlay(sourceId);
+        _stream.Start();
     }
 
     public ValueTask DisposeAsync()
     {
         ClearBuffer();
-        AL.SourceStop(sourceId);
-        AL.GetSource(sourceId, ALGetSourcei.BuffersProcessed, out int releasedCount);
-        int[] bufferIds = new int[releasedCount];
-        AL.SourceUnqueueBuffers(sourceId, releasedCount, bufferIds);
-        AL.DeleteBuffers(bufferIds);
+        State = PlayState.Stopped;
+        try
+        {
+            _stream?.Stop();
+            _stream?.Dispose();
+        }
+        catch { }
         return ValueTask.CompletedTask;
     }
 }

Console/Audio/Containers/Matroska/HttpSegmentedStream.cs

@@ -47,14 +47,17 @@ protected override void Dispose(bool disposing)
         base.Dispose(disposing);
     }
 
-    public static ValueTask<HttpSegmentedStream> Create(
+    public static async ValueTask<HttpSegmentedStream> Create(
         IDownloadUrlHandler downloadUrlHandler,
         long initialPos = 0
     )
     {
         var httpClient = new HttpClient();
-        return ValueTask.FromResult(
-            new HttpSegmentedStream(downloadUrlHandler, httpClient, initialPos, 3_000_000)
+        return new HttpSegmentedStream(
+            downloadUrlHandler,
+            httpClient,
+            initialPos,
+            (int)Math.Min((await downloadUrlHandler.GetSize()) / 3, 3_000_00)
         );
     }