132 lines
4.8 KiB
Zig
132 lines
4.8 KiB
Zig
const std = @import("std");
|
|
|
|
pub fn build(b: *std.Build) void {
|
|
const target = b.standardTargetOptions(.{});
|
|
const optimize = b.standardOptimizeOption(.{});
|
|
|
|
const vosk_dep = b.dependency("vosk", .{});
|
|
|
|
const zlib_dep = b.dependency("zlib", .{
|
|
.target = target,
|
|
.optimize = optimize,
|
|
});
|
|
// We need to use curl for this as the domain doesn't work with zig TLS
|
|
const model_step = ModelDownloadStep.create(b);
|
|
|
|
// Install the model to the output directory
|
|
const install_model = b.addInstallDirectory(.{
|
|
.source_dir = model_step.getOutputPath(),
|
|
.install_dir = .bin,
|
|
.install_subdir = "vosk-model-small-en-us-0.15",
|
|
});
|
|
install_model.step.dependOn(&model_step.step);
|
|
b.getInstallStep().dependOn(&install_model.step);
|
|
|
|
const exe = b.addExecutable(.{
|
|
.name = "stt",
|
|
.root_module = b.createModule(.{
|
|
.root_source_file = b.path("src/main.zig"),
|
|
.target = target,
|
|
.optimize = optimize,
|
|
}),
|
|
});
|
|
|
|
exe.linkLibC();
|
|
exe.addIncludePath(vosk_dep.path(""));
|
|
exe.addLibraryPath(vosk_dep.path(""));
|
|
exe.linkLibrary(zlib_dep.artifact("z"));
|
|
exe.linkSystemLibrary("vosk");
|
|
exe.linkSystemLibrary("asound");
|
|
|
|
b.installArtifact(exe);
|
|
|
|
const run_step = b.step("run", "Run the app");
|
|
const run_cmd = b.addRunArtifact(exe);
|
|
run_step.dependOn(&run_cmd.step);
|
|
run_cmd.step.dependOn(b.getInstallStep());
|
|
|
|
if (b.args) |args| {
|
|
run_cmd.addArgs(args);
|
|
}
|
|
}
|
|
|
|
const ModelDownloadStep = struct {
|
|
step: std.Build.Step,
|
|
builder: *std.Build,
|
|
|
|
pub fn create(builder: *std.Build) *ModelDownloadStep {
|
|
const self = builder.allocator.create(ModelDownloadStep) catch @panic("OOM");
|
|
self.* = .{
|
|
.step = std.Build.Step.init(.{
|
|
.id = .custom,
|
|
.name = "download-model",
|
|
.owner = builder,
|
|
.makeFn = make,
|
|
}),
|
|
.builder = builder,
|
|
};
|
|
return self;
|
|
}
|
|
|
|
pub fn getOutputPath(self: *ModelDownloadStep) std.Build.LazyPath {
|
|
var hasher = std.hash.Wyhash.init(0);
|
|
hasher.update("https://alphacephei.com/vosk/models/vosk-model-small-en-us-0.15.zip");
|
|
const cache_hash = hasher.final();
|
|
|
|
var cache_dir_buf: [std.fs.max_path_bytes]u8 = undefined;
|
|
const cache_dir = std.fmt.bufPrint(&cache_dir_buf, "{s}/o/{x}/vosk-model-small-en-us-0.15", .{ self.builder.cache_root.path.?, cache_hash }) catch @panic("path too long");
|
|
|
|
return .{ .cwd_relative = self.builder.allocator.dupe(u8, cache_dir) catch @panic("OOM") };
|
|
}
|
|
|
|
fn make(step: *std.Build.Step, options: std.Build.Step.MakeOptions) anyerror!void {
|
|
_ = options;
|
|
const self: *ModelDownloadStep = @fieldParentPtr("step", step);
|
|
|
|
const model_dir = "vosk-model-small-en-us-0.15";
|
|
|
|
// Create a cache hash based on the URL
|
|
var hasher = std.hash.Wyhash.init(0);
|
|
hasher.update("https://alphacephei.com/vosk/models/vosk-model-small-en-us-0.15.zip");
|
|
const cache_hash = hasher.final();
|
|
|
|
var cache_dir_buf: [std.fs.max_path_bytes]u8 = undefined;
|
|
const cache_dir = std.fmt.bufPrint(&cache_dir_buf, "{s}/o/{x}", .{ self.builder.cache_root.path.?, cache_hash }) catch @panic("path too long");
|
|
|
|
const cached_model_dir = std.fmt.allocPrint(self.builder.allocator, "{s}/{s}", .{ cache_dir, model_dir }) catch @panic("OOM");
|
|
defer self.builder.allocator.free(cached_model_dir);
|
|
|
|
// Check if already cached
|
|
if (std.fs.cwd().access(cached_model_dir, .{})) |_| {
|
|
step.result_cached = true;
|
|
return;
|
|
} else |_| {}
|
|
|
|
// Not cached, need to download
|
|
std.fs.cwd().makePath(cache_dir) catch {};
|
|
|
|
const model_zip = std.fmt.allocPrint(self.builder.allocator, "{s}/model.zip", .{cache_dir}) catch @panic("OOM");
|
|
defer self.builder.allocator.free(model_zip);
|
|
|
|
// Download
|
|
const download_result = std.process.Child.run(.{
|
|
.allocator = self.builder.allocator,
|
|
.argv = &.{ "curl", "-s", "-o", model_zip, "https://alphacephei.com/vosk/models/vosk-model-small-en-us-0.15.zip" },
|
|
}) catch return error.DownloadFailed;
|
|
if (download_result.term.Exited != 0) return error.DownloadFailed;
|
|
|
|
// Extract to cache using stdlib
|
|
var zip_file = std.fs.cwd().openFile(model_zip, .{}) catch return error.UnzipFailed;
|
|
defer zip_file.close();
|
|
|
|
var cache_dir_handle = std.fs.cwd().openDir(cache_dir, .{}) catch return error.UnzipFailed;
|
|
defer cache_dir_handle.close();
|
|
|
|
var zip_file_buffer: [4096]u8 = undefined;
|
|
var zip_file_reader = zip_file.reader(&zip_file_buffer);
|
|
|
|
std.zip.extract(cache_dir_handle, &zip_file_reader, .{}) catch return error.UnzipFailed;
|
|
|
|
step.result_cached = false;
|
|
}
|
|
};
|