zig/mach
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

sysaudio: rewrite in zig

Browse source 
removes libsoundio dependency
This commit is contained in:
Ali Chraghi 2022-12-16 14:55:46 +03:30 • committed by Stephen Gutekanst
parent 8aa2c97079
commit 0f3e28bc2a
27 changed files with 4714 additions and 1344 deletions
Download patch file Download diff file Expand all files Collapse all files

60
libs/sysaudio/examples/sine-wave.zig Normal file
View file

@ -0,0 +1,60 @@
const std = @import("std");
const sysaudio = @import("sysaudio");
pub fn main() !void {
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
defer _ = gpa.deinit();
const allocator = gpa.allocator();
var a = try sysaudio.Context.init(null, allocator, .{ .deviceChangeFn = deviceChange });
defer a.deinit();
try a.refresh();
const device = a.defaultDevice(.playback) orelse return error.NoDevice;
var p = try a.createPlayer(device, writeCallback, .{});
defer p.deinit();
try p.start();
try p.setVolume(0.85);
var buf: [16]u8 = undefined;
while (true) {
std.debug.print("( paused = {}, volume = {d} )\n> ", .{ p.paused(), try p.volume() });
const line = (try std.io.getStdIn().reader().readUntilDelimiterOrEof(&buf, '\n')) orelse break;
var iter = std.mem.split(u8, line, ":");
const cmd = std.mem.trimRight(u8, iter.first(), &std.ascii.whitespace);
if (std.mem.eql(u8, cmd, "vol")) {
var vol = try std.fmt.parseFloat(f32, std.mem.trim(u8, iter.next().?, &std.ascii.whitespace));
try p.setVolume(vol);
} else if (std.mem.eql(u8, cmd, "pause")) {
try p.pause();
try std.testing.expect(p.paused());
} else if (std.mem.eql(u8, cmd, "play")) {
try p.play();
try std.testing.expect(!p.paused());
} else if (std.mem.eql(u8, cmd, "exit")) {
break;
}
}
}
const pitch = 440.0;
const radians_per_second = pitch * 2.0 * std.math.pi;
var seconds_offset: f32 = 0.0;
fn writeCallback(self_opaque: *anyopaque, n_frame: usize) void {
var self = @ptrCast(*sysaudio.Player, @alignCast(@alignOf(sysaudio.Player), self_opaque));
const seconds_per_frame = 1.0 / @intToFloat(f32, self.sampleRate());
var frame: usize = 0;
while (frame < n_frame) : (frame += 1) {
const sample = std.math.sin((seconds_offset + @intToFloat(f32, frame) * seconds_per_frame) * radians_per_second);
self.writeAll(frame, sample);
}
seconds_offset = @mod(seconds_offset + seconds_per_frame * @intToFloat(f32, n_frame), 1.0);
}
fn deviceChange(self: ?*anyopaque) void {
_ = self;
std.debug.print("Device change detected!\n", .{});
}

76
libs/sysaudio/examples/soundio-sine-wave.zig
View file

@ -1,76 +0,0 @@
const std = @import("std");
const soundio = @import("soundio");
const c = soundio.c;
const SoundIo = soundio.SoundIo;
const OutStream = soundio.OutStream;
var seconds_offset: f32 = 0;
fn write_callback(
maybe_outstream: ?[*]c.SoundIoOutStream,
frame_count_min: c_int,
frame_count_max: c_int,
) callconv(.C) void {
_ = frame_count_min;
const outstream = OutStream{ .handle = @ptrCast(*c.SoundIoOutStream, maybe_outstream) };
const layout = outstream.layout();
const float_sample_rate = outstream.sampleRate();
const seconds_per_frame = 1.0 / @intToFloat(f32, float_sample_rate);
var frames_left = frame_count_max;
while (frames_left > 0) {
var frame_count = frames_left;
var areas: [*]c.SoundIoChannelArea = undefined;
outstream.beginWrite(
@ptrCast([*]?[*]c.SoundIoChannelArea, &areas),
&frame_count,
) catch |err| std.debug.panic("write failed: {s}", .{@errorName(err)});
if (frame_count == 0) break;
const pitch = 440.0;
const radians_per_second = pitch * 2.0 * std.math.pi;
var frame: c_int = 0;
while (frame < frame_count) : (frame += 1) {
const sample = std.math.sin((seconds_offset + @intToFloat(f32, frame) *
seconds_per_frame) * radians_per_second);
{
var channel: usize = 0;
while (channel < @intCast(usize, layout.channelCount())) : (channel += 1) {
const channel_ptr = areas[channel].ptr;
const sample_ptr = &channel_ptr[@intCast(usize, areas[channel].step * frame)];
@ptrCast(*f32, @alignCast(@alignOf(f32), sample_ptr)).* = sample;
}
}
}
seconds_offset += seconds_per_frame * @intToFloat(f32, frame_count);
outstream.endWrite() catch |err| std.debug.panic("end write failed: {s}", .{@errorName(err)});
frames_left -= frame_count;
}
}
pub fn main() !void {
const sio = try SoundIo.init();
defer sio.deinit();
try sio.connect();
sio.flushEvents();
const default_output_index = sio.defaultOutputDeviceIndex() orelse return error.NoOutputDeviceFound;
const device = sio.getOutputDevice(default_output_index) orelse return error.OutOfMemory;
defer device.unref();
std.debug.print("Output device: {s}\n", .{device.name()});
const outstream = try device.createOutStream();
defer outstream.deinit();
outstream.setFormat(.float32LE);
outstream.setWriteCallback(write_callback);
try outstream.open();
try outstream.start();
while (true) sio.waitEvents();
}