Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-audio

Source of release 0.4.2

0.4.2 / tools / probe / main.lucb

## Plays a quiet 440 Hz tone on the default output for a few seconds and
## reports what the device gave: its rate, buffer, latency, the callbacks
## and the longest time one took. `probe 32` asks for 32-frame buffers.
import time
import thread
import strings
from luce_audio import device
from luce_audio.device import Device, Block

struct Tone:
    var phase: f64
    var step: f64
    var calls: @u64
    var frames_seen: @u64
    var longest: @u64
    var smallest: @u64
    var largest: @u64

func render(context: void*?, block: Block*):
    let started = time.now()
    let tone = (Tone*)(context else return)
    let left = block.output(0)
    var phase = tone.phase
    for i in 0..<block.frames:
        left[i] = (f32)(0.02 * fsin(phase))
        phase += tone.step
        if phase > 6.283185307179586: phase -= 6.283185307179586
    tone.phase = phase
    for channel in 1..<block.channels:
        let out = block.output(channel)
        for i in 0..<block.frames: out[i] = left[i]
    tone.calls += 1
    tone.frames_seen += (u64)block.frames
    _ = tone.smallest.min((u64)block.frames, .relaxed)
    _ = tone.largest.max((u64)block.frames, .relaxed)
    _ = tone.longest.max(time.since(started), .relaxed)

extern func sin(x: f64) -> f64
func fsin(x: f64) -> f64:
    return sin(x)

pub func main(arguments: str[]) -> i32!:
    var frames: u32 = 64
    if arguments.length > 1:
        frames = (u32)(strings.parse_i64(arguments[1]) else 64)
    var tone = Tone(phase = 0.0, step = 0.0, calls = 0, frames_seen = 0, longest = 0, smallest = 1000000, largest = 0)
    var output = try Device.open(render, &tone, frames = frames)
    defer output.close()
    tone.step = 6.283185307179586 * 440.0 / output.sample_rate
    print(f"device {output.device_id}: {output.sample_rate} Hz, {output.buffer_frames} frames a buffer ({f64(output.buffer_frames) / output.sample_rate * 1000.0:.2f} ms), device latency {output.output_latency} frames")
    try output.start()
    thread.sleep(3000)
    output.stop()
    let calls = tone.calls.load(.acquire)
    print(f"{calls} callbacks, {tone.frames_seen.load(.relaxed)} frames, buffers {tone.smallest.load(.relaxed)}..{tone.largest.load(.relaxed)} frames, longest callback {f64(tone.longest.load(.relaxed)) / 1000.0:.1f} us")
    let total = f64(output.buffer_frames + output.output_latency) / output.sample_rate * 1000.0
    print(f"output latency: {total:.2f} ms (buffer + device)")
    return 0