tiny.sys.audio

1const std = @import("std");2const builtin = @import("builtin");3const capabilities = @import("capabilities.zig");4const coreaudio = @import("coreaudio.zig");5const pulse = @import("pulse.zig");67const backend = if (builtin.os.tag == .macos) coreaudio else pulse;89pub const required_capabilities = capabilities.host(&.{.audio});1011pub const Error = error{12    UnsupportedPlatform,13    OpenFailed,14    ConfigureFailed,15    Underrun,16    WriteFailed,17    OutOfMemory,18};1920pub const channels: u8 = 2;21pub const PlaybackLimits = backend.Playback.Limits;22pub const PlaybackCapacity = backend.Playback.Capacity;23pub const PlaybackStorage = backend.Playback.Storage;2425pub const default_playback_supported = backend.supported and builtin.cpu.arch.endian() == .little;2627pub const PlaybackDevice = struct {28    playback: backend.Playback,2930    pub fn openDefault(31        allocator: std.mem.Allocator,32        limits: PlaybackLimits,33        sample_rate: u32,34        frames_per_buffer: usize,35        name: []const u8,36    ) Error!PlaybackDevice {37        if (comptime !default_playback_supported) return error.UnsupportedPlatform;38        const playback = try openBackend(39            allocator,40            limits,41            sample_rate,42            frames_per_buffer,43            name,44        );45        return .{ .playback = playback };46    }4748    pub fn drain(self: *PlaybackDevice) void {49        self.playback.drain() catch {};50    }5152    pub fn close(self: *PlaybackDevice, allocator: std.mem.Allocator) void {53        self.playback.close(allocator);54    }5556    pub fn writeInterleaved(57        self: *PlaybackDevice,58        samples: [*]const i16,59        frames: usize,60    ) Error!usize {61        const writable_frames = if (comptime builtin.os.tag == .macos)62            @min(frames, self.playback.storage.capacity.frames_per_buffer)63        else64            frames;65        const sample_count = std.math.mul(66            usize,67            writable_frames,68            channels,69        ) catch return error.WriteFailed;70        const bytes = std.mem.sliceAsBytes(samples[0..sample_count]);71        if (comptime builtin.os.tag == .macos) {72            self.playback.writeFrames(bytes) catch return error.WriteFailed;73        } else {74            self.playback.writeFrames(bytes) catch |err| return switch (err) {75                error.OutOfMemory => error.OutOfMemory,76                else => error.WriteFailed,77            };78        }79        return writable_frames;80    }8182    pub fn prepare(_: *PlaybackDevice) void {}8384    pub fn capacity(self: *const PlaybackDevice) PlaybackCapacity {85        return self.playback.storage.capacity;86    }87};8889pub fn defaultPlaybackSupported() bool {90    return default_playback_supported and backend.available();91}9293fn openBackend(94    allocator: std.mem.Allocator,95    limits: PlaybackLimits,96    sample_rate: u32,97    frames_per_buffer: usize,98    name: []const u8,99) Error!backend.Playback {100    if (comptime builtin.os.tag == .macos) {101        return coreaudio.Playback.open(102            allocator,103            limits,104            .{105                .format = coreaudio.sample_format_s16_native,106                .channels = channels,107                .rate = sample_rate,108                .frames_per_buffer = frames_per_buffer,109            },110            name,111        ) catch |err| return switch (err) {112            error.OutOfMemory => error.OutOfMemory,113            error.UnsupportedPlatform => error.UnsupportedPlatform,114            error.QueueCreationFailed => error.OpenFailed,115            else => error.ConfigureFailed,116        };117    }118119    return pulse.Playback.open(120        allocator,121        limits,122        .{123            .format = pulse.sample_format_s16le,124            .channels = channels,125            .rate = sample_rate,126        },127        name,128    ) catch |err| return switch (err) {129        error.OutOfMemory => error.OutOfMemory,130        error.UnsupportedPlatform => error.UnsupportedPlatform,131        error.CapacityOverflow,132        error.ChannelLimitExceeded,133        error.ClientNameLimitExceeded,134        error.ControlPayloadCapacityExceeded,135        error.StreamRejected,136        error.ServerError,137        => error.ConfigureFailed,138        else => error.OpenFailed,139    };140}141142pub fn openDefaultPlayback(143    allocator: std.mem.Allocator,144    limits: PlaybackLimits,145    sample_rate: u32,146    frames_per_buffer: usize,147    name: []const u8,148) Error!PlaybackDevice {149    return PlaybackDevice.openDefault(allocator, limits, sample_rate, frames_per_buffer, name);150}151152test "playback support follows native backend availability" {153    if (comptime !default_playback_supported) {154        try std.testing.expect(!defaultPlaybackSupported());155        return;156    }157    _ = defaultPlaybackSupported();158}159160test "live device playback writes interleaved frames" {161    if (comptime !default_playback_supported) return error.SkipZigTest;162    if (!backend.available()) return error.SkipZigTest;163164    const allocator = std.testing.allocator;165    var device = openDefaultPlayback(166        allocator,167        .{ .client_name_bytes = "sys-test".len, .channels = channels },168        48_000,169        256,170        "sys-test",171    ) catch return error.SkipZigTest;172    defer device.close(allocator);173174    const samples = @as([(256 * @as(usize, channels))]i16, @splat(0));175    for (0..8) |_| {176        const written = try device.writeInterleaved(&samples, 256);177        try std.testing.expectEqual(@as(usize, 256), written);178    }179    device.drain();180}

1pub const audio = @import("audio.zig");