140 lines
4.2 KiB
Zig
140 lines
4.2 KiB
Zig
const std = @import("std");
|
|
const builtin = @import("builtin");
|
|
const mach = @import("main.zig");
|
|
const sysaudio = mach.sysaudio;
|
|
|
|
pub const name = .mach_audio;
|
|
pub const Mod = mach.Mod(@This());
|
|
pub const components = .{
|
|
.samples = .{ .type = []const f32 },
|
|
.playing = .{ .type = bool },
|
|
.index = .{ .type = usize },
|
|
};
|
|
pub const local_events = .{
|
|
.render = .{ .handler = render },
|
|
};
|
|
|
|
allocator: std.mem.Allocator,
|
|
ctx: sysaudio.Context = undefined,
|
|
player: sysaudio.Player = undefined,
|
|
buffer: SampleBuffer = SampleBuffer.init(),
|
|
mutex: std.Thread.Mutex = .{},
|
|
cond: std.Thread.Condition = .{},
|
|
|
|
pub const SampleBuffer = std.fifo.LinearFifo(f32, .{ .Static = 4096 });
|
|
|
|
pub fn init(audio: *@This()) !void {
|
|
audio.ctx = try sysaudio.Context.init(null, audio.allocator, .{});
|
|
try audio.ctx.refresh();
|
|
|
|
const device = audio.ctx.defaultDevice(.playback) orelse return error.NoDeviceFound;
|
|
audio.player = try audio.ctx.createPlayer(device, writeFn, .{ .user_data = audio });
|
|
try audio.player.start();
|
|
}
|
|
|
|
pub fn deinit(audio: *Mod) void {
|
|
audio.state().player.deinit();
|
|
audio.state().ctx.deinit();
|
|
|
|
var iter = audio.entities.entities.valueIterator();
|
|
while (iter.next()) |*entity| {
|
|
entity.samples.deinit(audio.state().allocator);
|
|
}
|
|
}
|
|
|
|
pub fn render(audio: *Mod) !void {
|
|
// Prepare the next 30ms of audio by querying entities and mixing the samples they want to play.
|
|
// 48_000 * 0.03 = 1440 = 30ms
|
|
var mixing_buffer: [1440]f32 = undefined;
|
|
var max_samples: usize = 0;
|
|
|
|
var iter = audio.entities.query(.{ .all = &.{.{ .mach_audio = &.{ .samples, .playing, .index } }} });
|
|
while (iter.next()) |archetype| for (
|
|
archetype.slice(.entity, .id),
|
|
archetype.slice(.mach_audio, .samples),
|
|
archetype.slice(.mach_audio, .playing),
|
|
archetype.slice(.mach_audio, .index),
|
|
) |id, samples, playing, index| {
|
|
if (!playing) continue;
|
|
|
|
const to_read = @min(samples.len - index, mixing_buffer.len);
|
|
mixSamples(mixing_buffer[0..to_read], samples[index..][0..to_read]);
|
|
max_samples = @max(max_samples, to_read);
|
|
|
|
if (index + to_read >= samples.len) {
|
|
try audio.set(id, .playing, false);
|
|
try audio.set(id, .index, 0);
|
|
continue;
|
|
}
|
|
|
|
try audio.set(id, .index, index + to_read);
|
|
};
|
|
|
|
audio.state().mutex.lock();
|
|
defer audio.state().mutex.unlock();
|
|
while (audio.state().buffer.writableLength() < max_samples) {
|
|
audio.state().cond.wait(&audio.state().mutex);
|
|
}
|
|
audio.state().buffer.writeAssumeCapacity(mixing_buffer[0..max_samples]);
|
|
}
|
|
|
|
fn writeFn(audio_opaque: ?*anyopaque, output: []u8) void {
|
|
const audio: *@This() = @ptrCast(@alignCast(audio_opaque));
|
|
|
|
// Clear buffer from previous samples
|
|
@memset(output, 0);
|
|
|
|
const total_samples = @divExact(output.len, audio.player.format().size());
|
|
|
|
var i: usize = 0;
|
|
while (i < total_samples) {
|
|
audio.mutex.lock();
|
|
defer audio.mutex.unlock();
|
|
|
|
const read_slice = audio.buffer.readableSlice(0);
|
|
const read_len = @min(read_slice.len, total_samples - i);
|
|
|
|
if (read_len == 0) return;
|
|
|
|
sysaudio.convertTo(
|
|
f32,
|
|
read_slice[0..read_len],
|
|
audio.player.format(),
|
|
output[i * @sizeOf(f32) ..][0 .. read_len * @sizeOf(f32)],
|
|
);
|
|
|
|
i += read_len;
|
|
audio.buffer.discard(read_len);
|
|
|
|
audio.cond.signal();
|
|
}
|
|
}
|
|
|
|
// TODO: what's this weird behavior in ReleaseFast/Small?
|
|
const vector_length = switch (builtin.mode) {
|
|
.Debug, .ReleaseSafe => std.simd.suggestVectorLength(f32),
|
|
else => null,
|
|
};
|
|
|
|
inline fn mixSamples(a: []f32, b: []const f32) void {
|
|
std.debug.assert(a.len >= b.len);
|
|
|
|
var i: usize = 0;
|
|
|
|
// use SIMD when available
|
|
if (vector_length) |vec_len| {
|
|
const Vec = @Vector(vec_len, f32);
|
|
const vec_blocks_len = b.len - (b.len % vec_len);
|
|
|
|
while (i < vec_blocks_len) : (i += vec_len) {
|
|
const b_vec: Vec = b[i..][0..vec_len].*;
|
|
a[i..][0..vec_len].* += b_vec;
|
|
}
|
|
}
|
|
|
|
if (i < b.len) {
|
|
for (a[i..b.len], b[i..]) |*a_sample, b_sample| {
|
|
a_sample.* += b_sample;
|
|
}
|
|
}
|
|
}
|