voice-cat/clients/apple/VoiceCat.iOS/BroadcastAudioPump.cs

using System.IO.MemoryMappedFiles;
using VoiceCat.Core;
using Voicecat.V1;

namespace VoiceCat.iOS;

internal sealed class BroadcastAudioPump : IAsyncDisposable
{
    private const uint Magic = 0x56434252, Version = 1;
    private const int Header = 64, Capacity = 96_000, Frame = 960;
    private readonly CancellationTokenSource stop = new();
    private readonly short[] scratch = new short[Frame * 2];
    private Thread? worker;
    private VoiceCatClient? client;
    private MemoryMappedFile? map;
    private MemoryMappedViewAccessor? view;
    private string? path;
    private uint streamId;
    private bool active;
    private int generation;

    internal event Action? Changed;
    internal bool IsActive => active;

    internal void Start(VoiceCatClient owner)
    {
        client = owner;
        worker = new Thread(Run) { IsBackground = true, Name = "VoiceCat iOS screen audio", Priority = ThreadPriority.AboveNormal };
        worker.Start();
    }

    private void Run()
    {
        CancellationToken token = stop.Token;
        try
        {
            while (!token.IsCancellationRequested)
            {
                try { DrainAsync(token).GetAwaiter().GetResult(); }
                catch (Exception exception) when (exception is IOException or UnauthorizedAccessException or InvalidDataException or OperationCanceledException) { CloseMapping(); }
                if (!token.IsCancellationRequested) Thread.Sleep(5);
            }
        }
        finally { CloseMapping(); }
    }

    private async Task DrainAsync(CancellationToken token)
    {
        if (!OpenMapping()) return;
        MemoryMappedViewAccessor pages = view!;
        bool active = pages.ReadUInt32(16) != 0;
        if (!active) { StopStream(); SetActive(false); return; }
        VoiceCatClient owner = client ?? throw new IOException("Client disconnected.");
        if (streamId == 0)
        {
            int startGeneration = Volatile.Read(ref generation);
            StreamInfo stream = await owner.StartStreamAsync(StreamKind.StreamScreenAudio, "Screen audio", 2, token).ConfigureAwait(false);
            if (startGeneration != Volatile.Read(ref generation) || pages.ReadUInt32(16) == 0 || !ReferenceEquals(client, owner))
            {
                try { owner.StopStream(stream.StreamId); } catch (Exception exception) when (exception is IOException or InvalidOperationException) { }
                return;
            }
            streamId = stream.StreamId; pages.Write(32, pages.ReadUInt64(24)); SetActive(true);
        }
        ulong write = pages.ReadUInt64(24), read = pages.ReadUInt64(32);
        if (write - read > Capacity) read = write - Capacity;
        while (write - read >= Frame * 2)
        {
            for (int sample = 0; sample < scratch.Length; sample++)
            {
                ulong index = (read + (ulong)sample) % Capacity;
                scratch[sample] = pages.ReadInt16(Header + checked((long)index * sizeof(short)));
            }
            if (!owner.Audio.FeedPcm(streamId, scratch, 2)) break;
            read += (ulong)scratch.Length;
            pages.Write(32, read);
        }
    }

    // The producer opens the ring with O_CREAT and never replaces it, so one mapping covers the
    // pump's whole life. Creating and disposing a mapping (plus its container lookup and path
    // strings) every 5 ms tick allocated steadily at 200 Hz and churned the GC under long calls;
    // the mapping is now built on the ring's transitions and reused until the file disappears or
    // a drain fails.
    private bool OpenMapping()
    {
        path ??= ResolvePath();
        if (path is null) return false;
        bool present = File.Exists(path);
        if (view is not null)
        {
            if (present) return true;
            CloseMapping(); return false;
        }
        if (!present) return false;
        MemoryMappedFile candidate = MemoryMappedFile.CreateFromFile(path, FileMode.Open, null, Header + Capacity * sizeof(short), MemoryMappedFileAccess.ReadWrite);
        try
        {
            MemoryMappedViewAccessor pages = candidate.CreateViewAccessor(0, Header + Capacity * sizeof(short), MemoryMappedFileAccess.ReadWrite);
            if (pages.ReadUInt32(0) != Magic || pages.ReadUInt32(4) != Version)
            {
                pages.Dispose(); throw new InvalidDataException("Unsupported broadcast ring.");
            }
            map = candidate; view = pages; return true;
        }
        catch { candidate.Dispose(); throw; }
    }

    private static string? ResolvePath()
    {
        NSUrl? root = NSFileManager.DefaultManager.GetContainerUrl(IosConstants.AppGroup);
        return root?.Path is null ? null : Path.Combine(root.Path, "voicecat", "broadcast_audio.ring");
    }

    private void CloseMapping()
    {
        view?.Dispose(); view = null;
        map?.Dispose(); map = null;
    }

    private void StopStream()
    {
        uint id = streamId; streamId = 0; if (id == 0 || client?.State != ClientConnectionState.Connected) return;
        try { client.StopStream(id); } catch (Exception exception) when (exception is IOException or InvalidOperationException) { }
    }

    internal void RequestStop() { Interlocked.Increment(ref generation); SetActive(false); }

    private void SetActive(bool value) { if (active == value) return; active = value; Changed?.Invoke(); }

    public ValueTask DisposeAsync()
    {
        stop.Cancel(); Interlocked.Increment(ref generation); worker?.Join(); worker = null;
        StopStream(); SetActive(false); stop.Dispose(); return ValueTask.CompletedTask;
    }
}