using System.Diagnostics; using System.Globalization; using AquaSynth.Dsl; namespace AquaSynth.Faust; public enum FaustTargetLanguage { C, Cpp, CSharp, Rust, WebAssembly, WebAssemblyText } public sealed record FaustCompileOptions(FaustTargetLanguage Language, string OutputPath); public sealed record FaustValidation(string Command, bool Success, int? StatusCode, string Stdout, string Stderr); public sealed record FaustWebAssemblyCompileOptions( string OutputDirectory, string BaseName = "aquasynth_patch", bool Stereo = false); public sealed record FaustWebAssemblyManifest( string Name, string DspPath, string WasmPath, string JsonPath, string FaustPath, bool Success, int? StatusCode, string Stdout, string Stderr); public sealed record FaustRenderOptions(int SampleRate = 44100, float DurationSeconds = 1); public sealed record FaustRender(float[] Samples, int SampleRate, string Command, string Stdout, string Stderr); public static class FaustCompiler { public static string? FindFaust() { var path = Environment.GetEnvironmentVariable("PATH") ?? ""; var names = OperatingSystem.IsWindows() ? new[] { "faust.exe", "faust" } : ["faust"]; foreach (var dir in path.Split(Path.PathSeparator)) { foreach (var name in names) { var candidate = Path.Combine(dir, name); if (File.Exists(candidate)) return candidate; } } var windowsDefault = @"C:\Program Files\Faust\bin\faust.exe"; return File.Exists(windowsDefault) ? windowsDefault : null; } public static async Task CompileAsync( string source, FaustCompileOptions options, string? faustPath = null, CancellationToken cancellationToken = default) { faustPath ??= FindFaust(); if (faustPath is null) return null; var sourcePath = Path.Combine(Path.GetTempPath(), $"aquasynth-{Guid.NewGuid():N}.dsp"); await File.WriteAllTextAsync(sourcePath, source, cancellationToken); try { var result = await RunAsync( faustPath, ["-lang", Language(options.Language), "-o", options.OutputPath, sourcePath], cancellationToken); return new FaustValidation(faustPath, result.ExitCode == 0, result.ExitCode, result.Stdout, result.Stderr); } finally { File.Delete(sourcePath); } } public static async Task CompileWebAssemblyAsync( SynthPatch patch, FaustWebAssemblyCompileOptions options, string? faustPath = null, CancellationToken cancellationToken = default) { var export = FaustEmitter.Emit(patch, new FaustExportOptions(options.BaseName, options.Stereo)); return await CompileWebAssemblySourceAsync(export.Source, options, faustPath, cancellationToken); } public static async Task CompileWebAssemblyScriptAsync( string script, FaustWebAssemblyCompileOptions options, string? faustPath = null, CancellationToken cancellationToken = default) { var export = FaustEmitter.EmitScript(script, new FaustExportOptions(options.BaseName, options.Stereo)); return await CompileWebAssemblySourceAsync(export.Source, options, faustPath, cancellationToken); } public static async Task CompileWebAssemblySourceAsync( string source, FaustWebAssemblyCompileOptions options, string? faustPath = null, CancellationToken cancellationToken = default) { faustPath ??= FindFaust(); if (faustPath is null) return null; Directory.CreateDirectory(options.OutputDirectory); var baseName = SafeArtifactName(options.BaseName); var dspPath = Path.Combine(options.OutputDirectory, $"{baseName}.dsp"); var wasmPath = Path.Combine(options.OutputDirectory, $"{baseName}.wasm"); var jsonPath = Path.Combine(options.OutputDirectory, $"{baseName}.json"); await File.WriteAllTextAsync(dspPath, source, cancellationToken); var result = await RunAsync( faustPath, [ "-lang", Language(FaustTargetLanguage.WebAssembly), "-json", "-o", wasmPath, dspPath ], cancellationToken); return new FaustWebAssemblyManifest( options.BaseName, dspPath, wasmPath, jsonPath, faustPath, result.ExitCode == 0 && File.Exists(wasmPath), result.ExitCode, result.Stdout, result.Stderr); } public static async Task ValidateAsync( string source, string? faustPath = null, CancellationToken cancellationToken = default) { var output = OperatingSystem.IsWindows() ? "NUL" : "/dev/null"; return await CompileAsync(source, new FaustCompileOptions(FaustTargetLanguage.Cpp, output), faustPath, cancellationToken); } public static async Task RenderAsync( string source, FaustRenderOptions? options = null, string? faustPath = null, CancellationToken cancellationToken = default) { options ??= new FaustRenderOptions(); faustPath ??= FindFaust(); if (faustPath is null) return null; var frames = Math.Max(1, (int)MathF.Round(options.SampleRate * Math.Max(options.DurationSeconds, 1f / options.SampleRate))); var tempDir = Path.Combine(Path.GetTempPath(), $"aquasynth-render-{Guid.NewGuid():N}"); Directory.CreateDirectory(tempDir); try { var sourcePath = Path.Combine(tempDir, "render.dsp"); var generatedPath = Path.Combine(tempDir, "RenderDsp.cs"); var outputPath = Path.Combine(tempDir, "render.f32"); await File.WriteAllTextAsync(sourcePath, source, cancellationToken); var faust = await RunAsync( faustPath, ["-lang", "csharp", "-double", "-cn", "RenderDsp", "-o", generatedPath, sourcePath], cancellationToken); if (faust.ExitCode != 0) { return new FaustRender([], options.SampleRate, faustPath, faust.Stdout, faust.Stderr); } var archDir = await FaustArchDirAsync(faustPath, cancellationToken); var basePath = archDir is null ? null : Path.Combine(archDir, "CSharpFaustBase.cs"); if (basePath is null || !File.Exists(basePath)) { return new FaustRender([], options.SampleRate, faustPath, faust.Stdout, $"could not find CSharpFaustBase.cs under Faust archdir `{archDir}`"); } File.Copy(basePath, Path.Combine(tempDir, "CSharpFaustBase.cs")); await File.WriteAllTextAsync(Path.Combine(tempDir, "Render.csproj"), RenderProjectSource(), cancellationToken); await File.WriteAllTextAsync(Path.Combine(tempDir, "Program.cs"), RenderProgramSource(), cancellationToken); var dotnet = await RunAsync( "dotnet", ["run", "--project", Path.Combine(tempDir, "Render.csproj"), "--", outputPath, options.SampleRate.ToString(CultureInfo.InvariantCulture), frames.ToString(CultureInfo.InvariantCulture)], cancellationToken); if (dotnet.ExitCode != 0 || !File.Exists(outputPath)) { return new FaustRender([], options.SampleRate, "dotnet", dotnet.Stdout, dotnet.Stderr); } var bytes = await File.ReadAllBytesAsync(outputPath, cancellationToken); var samples = new float[bytes.Length / sizeof(float)]; Buffer.BlockCopy(bytes, 0, samples, 0, samples.Length * sizeof(float)); return new FaustRender(samples, options.SampleRate, "dotnet", dotnet.Stdout, dotnet.Stderr); } finally { Directory.Delete(tempDir, recursive: true); } } private static string Language(FaustTargetLanguage language) => language switch { FaustTargetLanguage.C => "c", FaustTargetLanguage.Cpp => "cpp", FaustTargetLanguage.CSharp => "csharp", FaustTargetLanguage.Rust => "rust", FaustTargetLanguage.WebAssembly => "wasm", FaustTargetLanguage.WebAssemblyText => "wast", _ => throw new ArgumentOutOfRangeException(nameof(language), language, null) }; private static string SafeArtifactName(string value) { var sanitized = new string(value.Select(character => char.IsAsciiLetterOrDigit(character) || character is '-' or '_' ? character : '_').ToArray()); return string.IsNullOrWhiteSpace(sanitized) ? "aquasynth_patch" : sanitized; } private static async Task FaustArchDirAsync(string faustPath, CancellationToken cancellationToken) { var result = await RunAsync(faustPath, ["-archdir"], cancellationToken); return result.ExitCode == 0 ? result.Stdout.Trim() : null; } private static string RenderProjectSource() => """ Exe net10.0 enable enable """; private static string RenderProgramSource() => """ using System.Globalization; var outputPath = args[0]; var sampleRate = int.Parse(args[1], CultureInfo.InvariantCulture); var frames = int.Parse(args[2], CultureInfo.InvariantCulture); var dsp = new RenderDsp(); dsp.Init(sampleRate); var inputs = new double[dsp.GetNumInputs()][]; for (var i = 0; i < inputs.Length; i++) inputs[i] = new double[frames]; var outputs = new double[dsp.GetNumOutputs()][]; for (var i = 0; i < outputs.Length; i++) outputs[i] = new double[frames]; dsp.Compute(frames, inputs, outputs); await using var stream = File.Create(outputPath); await using var writer = new BinaryWriter(stream); var output = outputs.Length == 0 ? Array.Empty() : outputs[0]; for (var i = 0; i < frames; i++) writer.Write((float)output[i]); """; private static async Task<(int ExitCode, string Stdout, string Stderr)> RunAsync( string fileName, IReadOnlyList arguments, CancellationToken cancellationToken) { var start = new ProcessStartInfo(fileName) { RedirectStandardOutput = true, RedirectStandardError = true, UseShellExecute = false }; foreach (var argument in arguments) start.ArgumentList.Add(argument); using var process = Process.Start(start) ?? throw new InvalidOperationException($"failed to start `{fileName}`"); var stdout = process.StandardOutput.ReadToEndAsync(); var stderr = process.StandardError.ReadToEndAsync(); try { await process.WaitForExitAsync(cancellationToken); } catch (OperationCanceledException) when (!process.HasExited) { process.Kill(entireProcessTree: true); await process.WaitForExitAsync(CancellationToken.None); throw; } return (process.ExitCode, await stdout, await stderr); } }