Script 'mail_helper' called by obssrc Hello community, here is the log from the commit of package lv2-airwindows for openSUSE:Factory checked in at 2026-06-11 17:27:27 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/lv2-airwindows (Old) and /work/SRC/openSUSE:Factory/.lv2-airwindows.new.1981 (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "lv2-airwindows" Thu Jun 11 17:27:27 2026 rev:11 rq:1358615 version:38.0 Changes: -------- --- /work/SRC/openSUSE:Factory/lv2-airwindows/lv2-airwindows.changes 2026-03-27 06:44:12.376850489 +0100 +++ /work/SRC/openSUSE:Factory/.lv2-airwindows.new.1981/lv2-airwindows.changes 2026-06-11 17:29:13.951039038 +0200 @@ -1,0 +2,6 @@ +Wed Jun 10 20:38:42 UTC 2026 - Hannes Braun <[email protected]> + +- Update to new upstream release 38.0 + * New plugins: Balanced, YHighpass, YNotch + +------------------------------------------------------------------- Old: ---- lv2-airwindows-36.0.tar.gz New: ---- lv2-airwindows-38.0.tar.gz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ lv2-airwindows.spec ++++++ --- /var/tmp/diff_new_pack.aSDV76/_old 2026-06-11 17:29:14.551064200 +0200 +++ /var/tmp/diff_new_pack.aSDV76/_new 2026-06-11 17:29:14.551064200 +0200 @@ -18,7 +18,7 @@ Name: lv2-airwindows -Version: 36.0 +Version: 38.0 Release: 0 Summary: LV2 port of the Airwindows plugins License: MIT @@ -34,7 +34,7 @@ This is an LV2 port (by Hannes Braun) of the Airwindows plugins originally developed by Chris Johnson. -Right now, only 174 plugins (out of 420) have been ported to LV2. +Right now, only 177 plugins (out of 420) have been ported to LV2. %prep %setup -q ++++++ lv2-airwindows-36.0.tar.gz -> lv2-airwindows-38.0.tar.gz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lv2-airwindows-36.0/Makefile new/lv2-airwindows-38.0/Makefile --- old/lv2-airwindows-36.0/Makefile 2026-03-24 17:39:38.000000000 +0100 +++ new/lv2-airwindows-38.0/Makefile 2026-06-10 22:27:01.000000000 +0200 @@ -13,7 +13,7 @@ fi install: - muon install -C build + muon -C build install clean: rm -rf build diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lv2-airwindows-36.0/build.zig new/lv2-airwindows-38.0/build.zig --- old/lv2-airwindows-36.0/build.zig 2026-03-24 17:39:38.000000000 +0100 +++ new/lv2-airwindows-38.0/build.zig 2026-06-10 22:27:01.000000000 +0200 @@ -50,10 +50,11 @@ std.debug.print("Warning: tar not found\n", .{}); }; - var src_dir = try b.build_root.handle.openDir("src", .{ .iterate = true }); - defer src_dir.close(); + const io = std.Io.Threaded.global_single_threaded.io(); + var src_dir = try b.build_root.handle.openDir(io, "src", .{ .iterate = true }); + defer src_dir.close(io); var it = src_dir.iterate(); - while (try it.next()) |file| { + while (try it.next(io)) |file| { if (file.kind != .directory) { continue; } @@ -116,7 +117,7 @@ const configure_manifest = b.addRunArtifact(subst_exe); configure_manifest.addFileArg(b.path("src/manifest.ttl.in")); configure_manifest.addArgs(&.{ "@CMAKE_SHARED_LIBRARY_SUFFIX@", target.result.dynamicLibSuffix() }); - b.getInstallStep().dependOn(&b.addInstallFileWithDir(configure_manifest.captureStdOut(), .{ .custom = dest_dir }, "Airwindows.lv2/manifest.ttl").step); + b.getInstallStep().dependOn(&b.addInstallFileWithDir(configure_manifest.captureStdOut(.{}), .{ .custom = dest_dir }, "Airwindows.lv2/manifest.ttl").step); // Cross build for (targets) |cross_target| { @@ -126,9 +127,9 @@ const configure_manifest_cross = b.addRunArtifact(subst_exe); configure_manifest_cross.addFileArg(b.path("src/manifest.ttl.in")); configure_manifest_cross.addArgs(&.{ "@CMAKE_SHARED_LIBRARY_SUFFIX@", resolved_cross_target.result.dynamicLibSuffix() }); - all.dependOn(&b.addInstallFileWithDir(configure_manifest_cross.captureStdOut(), .{ .custom = cross_dest_dir }, "Airwindows.lv2/manifest.ttl").step); + all.dependOn(&b.addInstallFileWithDir(configure_manifest_cross.captureStdOut(.{}), .{ .custom = cross_dest_dir }, "Airwindows.lv2/manifest.ttl").step); - const install_license = b.addInstallFile(b.path("LICENSE"), b.pathJoin(&.{cross_dest_dir, "LICENSE"})); + const install_license = b.addInstallFile(b.path("LICENSE"), b.pathJoin(&.{ cross_dest_dir, "LICENSE" })); switch (resolved_cross_target.result.os.tag) { .macos => { @@ -203,7 +204,7 @@ } fn extractVersion(b: *std.Build, output: *std.ArrayList(u8)) !void { - var buffer = try std.fs.cwd().readFileAlloc(b.allocator, "meson.build", 100000000); + var buffer = try std.Io.Dir.cwd().readFileAlloc(std.Io.Threaded.global_single_threaded.io(), "meson.build", b.allocator, .unlimited); defer b.allocator.free(buffer); const idx = std.mem.indexOf(u8, buffer, "version : '").?; diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lv2-airwindows-36.0/meson.build new/lv2-airwindows-38.0/meson.build --- old/lv2-airwindows-36.0/meson.build 2026-03-24 17:39:38.000000000 +0100 +++ new/lv2-airwindows-38.0/meson.build 2026-06-10 22:27:01.000000000 +0200 @@ -7,7 +7,7 @@ 'optimization=3' ], license : 'MIT', - version : '36.0' + version : '38.0' ) bundle_name = 'Airwindows.lv2' @@ -26,6 +26,7 @@ 'Air2', 'Air3', 'Air4', + 'Balanced', 'BassAmp', 'BassDrive', 'BassKit', @@ -189,7 +190,9 @@ 'XNotch', 'XRegion', 'YBandpass', + 'YHighpass', 'YLowpass', + 'YNotch', 'ZOutputStage', ] diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lv2-airwindows-36.0/src/Balanced/Balanced.c new/lv2-airwindows-38.0/src/Balanced/Balanced.c --- old/lv2-airwindows-36.0/src/Balanced/Balanced.c 1970-01-01 01:00:00.000000000 +0100 +++ new/lv2-airwindows-38.0/src/Balanced/Balanced.c 2026-06-10 22:27:01.000000000 +0200 @@ -0,0 +1,173 @@ +#include <lv2/core/lv2.h> + +#include <math.h> +#include <stdint.h> +#include <stdlib.h> + +#define BALANCED_URI "https://hannesbraun.net/ns/lv2/airwindows/balanced"; + +typedef enum { + INPUT_L = 0, + INPUT_R = 1, + OUTPUT_L = 2, + OUTPUT_R = 3, + BIT_SHIFT = 4 +} PortIndex; + +typedef struct { + const float* input[2]; + float* output[2]; + const float* bitShift; + + uint32_t fpdL; + uint32_t fpdR; +} Balanced; + +static LV2_Handle instantiate( + const LV2_Descriptor* descriptor, + double rate, + const char* bundle_path, + const LV2_Feature* const* features) +{ + Balanced* balanced = (Balanced*) calloc(1, sizeof(Balanced)); + return (LV2_Handle) balanced; +} + +static void connect_port(LV2_Handle instance, uint32_t port, void* data) +{ + Balanced* balanced = (Balanced*) instance; + + switch ((PortIndex) port) { + case INPUT_L: + balanced->input[0] = (const float*) data; + break; + case INPUT_R: + balanced->input[1] = (const float*) data; + break; + case OUTPUT_L: + balanced->output[0] = (float*) data; + break; + case OUTPUT_R: + balanced->output[1] = (float*) data; + break; + case BIT_SHIFT: + balanced->bitShift = (const float*) data; + break; + } +} + +static void activate(LV2_Handle instance) +{ + Balanced* balanced = (Balanced*) instance; + balanced->fpdL = 1.0; + while (balanced->fpdL < 16386) balanced->fpdL = rand() * UINT32_MAX; + balanced->fpdR = 1.0; + while (balanced->fpdR < 16386) balanced->fpdR = rand() * UINT32_MAX; +} + +static void run(LV2_Handle instance, uint32_t sampleFrames) +{ + Balanced* balanced = (Balanced*) instance; + + const float* in1 = balanced->input[0]; + const float* in2 = balanced->input[1]; + float* out1 = balanced->output[0]; + float* out2 = balanced->output[1]; + + int bitshiftBalanced = (int) *balanced->bitShift; + double gain = 1.0; + switch (bitshiftBalanced) { + case 0: + gain = 0.5; + break; + case 1: + gain = 1.0; + break; + case 2: + gain = 2.0; + break; + case 3: + gain = 4.0; + break; + case 4: + gain = 8.0; + break; + case 5: + gain = 16.0; + break; + case 6: + gain = 32.0; + break; + case 7: + gain = 64.0; + break; + case 8: + gain = 128.0; + break; + } + // we are directly punching in the gain values rather than calculating them + + while (sampleFrames-- > 0) { + double inputSampleL = *in1; + double inputSampleR = *in2; + if (fabs(inputSampleL) < 1.18e-23) inputSampleL = balanced->fpdL * 1.18e-17; + if (fabs(inputSampleR) < 1.18e-23) inputSampleR = balanced->fpdR * 1.18e-17; + + double side = inputSampleL - inputSampleR; + // tip is left, to add negative ring (right) to combine 'em is the same as subtracting them + // end result is, mono output is made up of half of each balanced input combined. Note that we don't just + // flip the ring input, because we need to combine them to cancel out interference. + inputSampleL = side * gain; + inputSampleR = side * gain; + // assign mono as result of balancing of channels + + // begin 32 bit stereo floating point dither + int expon; + frexpf((float) inputSampleL, &expon); + balanced->fpdL ^= balanced->fpdL << 13; + balanced->fpdL ^= balanced->fpdL >> 17; + balanced->fpdL ^= balanced->fpdL << 5; + inputSampleL += (((double) balanced->fpdL - (uint32_t) 0x7fffffff) * 5.5e-36l * pow(2, expon + 62)); + frexpf((float) inputSampleR, &expon); + balanced->fpdR ^= balanced->fpdR << 13; + balanced->fpdR ^= balanced->fpdR >> 17; + balanced->fpdR ^= balanced->fpdR << 5; + inputSampleR += (((double) balanced->fpdR - (uint32_t) 0x7fffffff) * 5.5e-36l * pow(2, expon + 62)); + // end 32 bit stereo floating point dither + + *out1 = (float) inputSampleL; + *out2 = (float) inputSampleR; + + in1++; + in2++; + out1++; + out2++; + } +} + +static void deactivate(LV2_Handle instance) {} + +static void cleanup(LV2_Handle instance) +{ + free(instance); +} + +static const void* extension_data(const char* uri) +{ + return NULL; +} + +static const LV2_Descriptor descriptor = { + BALANCED_URI, + instantiate, + connect_port, + activate, + run, + deactivate, + cleanup, + extension_data}; + +LV2_SYMBOL_EXPORT const LV2_Descriptor* lv2_descriptor(uint32_t index) +{ + return index == 0 ? &descriptor : NULL; +} diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lv2-airwindows-36.0/src/Balanced/Balanced.ttl new/lv2-airwindows-38.0/src/Balanced/Balanced.ttl --- old/lv2-airwindows-36.0/src/Balanced/Balanced.ttl 1970-01-01 01:00:00.000000000 +0100 +++ new/lv2-airwindows-38.0/src/Balanced/Balanced.ttl 2026-06-10 22:27:01.000000000 +0200 @@ -0,0 +1,64 @@ +@prefix doap: <http://usefulinc.com/ns/doap#> . +@prefix foaf: <http://xmlns.com/foaf/0.1/> . +@prefix lv2: <http://lv2plug.in/ns/lv2core#> . +@prefix pprops: <http://lv2plug.in/ns/ext/port-props#> . +@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> . +@prefix units: <http://lv2plug.in/ns/extensions/units#> . + +<https://hannesbraun.net/ns/lv2/airwindows/balanced> + a lv2:Plugin , + lv2:UtilityPlugin , + doap:Project ; + doap:name "Balanced" ; + rdfs:comment "run an XLR input into a stereo input, sum it to mono, and use it" ; + doap:license <https://opensource.org/licenses/MIT> ; + doap:maintainer [ + foaf:name "Hannes Braun" ; + foaf:homepage <https://hannesbraun.net/> + ] ; + + lv2:minorVersion 2 ; + lv2:microVersion 0 ; + + lv2:optionalFeature lv2:hardRTCapable ; + lv2:port [ + a lv2:AudioPort , + lv2:InputPort ; + lv2:index 0 ; + lv2:symbol "inL" ; + lv2:name "In L" + ] , [ + a lv2:AudioPort , + lv2:InputPort ; + lv2:index 1 ; + lv2:symbol "inR" ; + lv2:name "In R" + ] , [ + a lv2:AudioPort , + lv2:OutputPort ; + lv2:index 2 ; + lv2:symbol "outL" ; + lv2:name "Out L" + ] , [ + a lv2:AudioPort , + lv2:OutputPort ; + lv2:index 3 ; + lv2:symbol "outR" ; + lv2:name "Out R" + ] , [ + a lv2:ControlPort , + lv2:InputPort ; + lv2:index 4 ; + lv2:symbol "bitShift" ; + lv2:name "BitShift" ; + lv2:default 0 ; + lv2:minimum 0 ; + lv2:maximum 8 ; + units:unit [ + a units:Unit ; + rdfs:label "Bits" ; + units:symbol "bits" ; + units:render "%d bits" + ] ; + lv2:portProperty pprops:hasStrictBounds + ] . diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lv2-airwindows-36.0/src/YHighpass/YHighpass.c new/lv2-airwindows-38.0/src/YHighpass/YHighpass.c --- old/lv2-airwindows-36.0/src/YHighpass/YHighpass.c 1970-01-01 01:00:00.000000000 +0100 +++ new/lv2-airwindows-38.0/src/YHighpass/YHighpass.c 2026-06-10 22:27:01.000000000 +0200 @@ -0,0 +1,349 @@ +#include <lv2/core/lv2.h> + +#include <math.h> +#include <stdint.h> +#include <stdlib.h> + +#define M_PI 3.14159265358979323846264338327950288 + +#define YHIGHPASS_URI "https://hannesbraun.net/ns/lv2/airwindows/yhighpass"; + +typedef enum { + INPUT_L = 0, + INPUT_R = 1, + OUTPUT_L = 2, + OUTPUT_R = 3, + GAIN = 4, + FREQ = 5, + RESON8 = 6, + RES_EDGE = 7, + OUTPUT = 8, + DRY_WET = 9 +} PortIndex; + +enum { + biq_freq, + biq_reso, + biq_a0, + biq_a1, + biq_a2, + biq_b1, + biq_b2, + biq_aA0, + biq_aA1, + biq_aA2, + biq_bA1, + biq_bA2, + biq_aB0, + biq_aB1, + biq_aB2, + biq_bB1, + biq_bB2, + biq_sL1, + biq_sL2, + biq_sR1, + biq_sR2, + biq_total +}; // coefficient interpolating biquad filter, stereo + +enum { + fix_freq, + fix_reso, + fix_a0, + fix_a1, + fix_a2, + fix_b1, + fix_b2, + fix_sL1, + fix_sL2, + fix_sR1, + fix_sR2, + fix_total +}; // fixed frequency biquad filter for ultrasonics, stereo + +typedef struct { + double sampleRate; + const float* input[2]; + float* output[2]; + const float* gain; + const float* freq; + const float* reson8; + const float* resEdge; + const float* outputGain; + const float* dryWet; + + double biquad[biq_total]; + + double powFactorA; + double powFactorB; + double inTrimA; + double inTrimB; + double outTrimA; + double outTrimB; + + double fixA[fix_total]; + double fixB[fix_total]; + + uint32_t fpdL; + uint32_t fpdR; +} YHighpass; + +static LV2_Handle instantiate( + const LV2_Descriptor* descriptor, + double rate, + const char* bundle_path, + const LV2_Feature* const* features) +{ + YHighpass* yHighpass = (YHighpass*) calloc(1, sizeof(YHighpass)); + yHighpass->sampleRate = rate; + return (LV2_Handle) yHighpass; +} + +static void connect_port(LV2_Handle instance, uint32_t port, void* data) +{ + YHighpass* yHighpass = (YHighpass*) instance; + + switch ((PortIndex) port) { + case INPUT_L: + yHighpass->input[0] = (const float*) data; + break; + case INPUT_R: + yHighpass->input[1] = (const float*) data; + break; + case OUTPUT_L: + yHighpass->output[0] = (float*) data; + break; + case OUTPUT_R: + yHighpass->output[1] = (float*) data; + break; + case GAIN: + yHighpass->gain = (const float*) data; + break; + case FREQ: + yHighpass->freq = (const float*) data; + break; + case RESON8: + yHighpass->reson8 = (const float*) data; + break; + case RES_EDGE: + yHighpass->resEdge = (const float*) data; + break; + case OUTPUT: + yHighpass->outputGain = (const float*) data; + break; + case DRY_WET: + yHighpass->dryWet = (const float*) data; + break; + } +} + +static void activate(LV2_Handle instance) +{ + YHighpass* yHighpass = (YHighpass*) instance; + for (int x = 0; x < biq_total; x++) { + yHighpass->biquad[x] = 0.0; + } + yHighpass->powFactorA = 1.0; + yHighpass->powFactorB = 1.0; + yHighpass->inTrimA = 0.1; + yHighpass->inTrimB = 0.1; + yHighpass->outTrimA = 1.0; + yHighpass->outTrimB = 1.0; + for (int x = 0; x < fix_total; x++) { + yHighpass->fixA[x] = 0.0; + yHighpass->fixB[x] = 0.0; + } + + yHighpass->fpdL = 1.0; + while (yHighpass->fpdL < 16386) yHighpass->fpdL = rand() * UINT32_MAX; + yHighpass->fpdR = 1.0; + while (yHighpass->fpdR < 16386) yHighpass->fpdR = rand() * UINT32_MAX; +} + +static void run(LV2_Handle instance, uint32_t sampleFrames) +{ + YHighpass* yHighpass = (YHighpass*) instance; + + const float* in1 = yHighpass->input[0]; + const float* in2 = yHighpass->input[1]; + float* out1 = yHighpass->output[0]; + float* out2 = yHighpass->output[1]; + + uint32_t inFramesToProcess = sampleFrames; + double overallscale = 1.0; + overallscale /= 44100.0; + overallscale *= yHighpass->sampleRate; + + yHighpass->inTrimA = yHighpass->inTrimB; + yHighpass->inTrimB = *yHighpass->gain * 10.0; + + yHighpass->biquad[biq_freq] = pow(*yHighpass->freq, 3) * 20000.0; + if (yHighpass->biquad[biq_freq] < 15.0) yHighpass->biquad[biq_freq] = 15.0; + yHighpass->biquad[biq_freq] /= yHighpass->sampleRate; + yHighpass->biquad[biq_reso] = (pow(*yHighpass->reson8, 2) * 15.0) + 0.5571; + yHighpass->biquad[biq_aA0] = yHighpass->biquad[biq_aB0]; + yHighpass->biquad[biq_aA1] = yHighpass->biquad[biq_aB1]; + yHighpass->biquad[biq_aA2] = yHighpass->biquad[biq_aB2]; + yHighpass->biquad[biq_bA1] = yHighpass->biquad[biq_bB1]; + yHighpass->biquad[biq_bA2] = yHighpass->biquad[biq_bB2]; + // previous run through the buffer is still in the filter, so we move it + // to the A section and now it's the new starting point. + double K = tan(M_PI * yHighpass->biquad[biq_freq]); + double norm = 1.0 / (1.0 + K / yHighpass->biquad[biq_reso] + K * K); + yHighpass->biquad[biq_aB0] = norm; + yHighpass->biquad[biq_aB1] = -2.0 * yHighpass->biquad[biq_aB0]; + yHighpass->biquad[biq_aB2] = yHighpass->biquad[biq_aB0]; + yHighpass->biquad[biq_bB1] = 2.0 * (K * K - 1.0) * norm; + yHighpass->biquad[biq_bB2] = (1.0 - K / yHighpass->biquad[biq_reso] + K * K) * norm; + // for the coefficient-interpolated biquad filter + + yHighpass->powFactorA = yHighpass->powFactorB; + yHighpass->powFactorB = pow(*yHighpass->resEdge + 0.9, 4); + + // 1.0 == target neutral + + yHighpass->outTrimA = yHighpass->outTrimB; + yHighpass->outTrimB = *yHighpass->outputGain; + + double wet = *yHighpass->dryWet; + + yHighpass->fixA[fix_freq] = yHighpass->fixB[fix_freq] = 20000.0 / yHighpass->sampleRate; + yHighpass->fixA[fix_reso] = yHighpass->fixB[fix_reso] = 0.7071; // butterworth Q + + K = tan(M_PI * yHighpass->fixA[fix_freq]); + norm = 1.0 / (1.0 + K / yHighpass->fixA[fix_reso] + K * K); + yHighpass->fixA[fix_a0] = yHighpass->fixB[fix_a0] = K * K * norm; + yHighpass->fixA[fix_a1] = yHighpass->fixB[fix_a1] = 2.0 * yHighpass->fixA[fix_a0]; + yHighpass->fixA[fix_a2] = yHighpass->fixB[fix_a2] = yHighpass->fixA[fix_a0]; + yHighpass->fixA[fix_b1] = yHighpass->fixB[fix_b1] = 2.0 * (K * K - 1.0) * norm; + yHighpass->fixA[fix_b2] = yHighpass->fixB[fix_b2] = (1.0 - K / yHighpass->fixA[fix_reso] + K * K) * norm; + // for the fixed-position biquad filter + + while (sampleFrames-- > 0) { + + double inputSampleL = *in1; + double inputSampleR = *in2; + if (fabs(inputSampleL) < 1.18e-23) inputSampleL = yHighpass->fpdL * 1.18e-17; + if (fabs(inputSampleR) < 1.18e-23) inputSampleR = yHighpass->fpdR * 1.18e-17; + double drySampleL = inputSampleL; + double drySampleR = inputSampleR; + + double temp = (double) sampleFrames / inFramesToProcess; + yHighpass->biquad[biq_a0] = (yHighpass->biquad[biq_aA0] * temp) + (yHighpass->biquad[biq_aB0] * (1.0 - temp)); + yHighpass->biquad[biq_a1] = (yHighpass->biquad[biq_aA1] * temp) + (yHighpass->biquad[biq_aB1] * (1.0 - temp)); + yHighpass->biquad[biq_a2] = (yHighpass->biquad[biq_aA2] * temp) + (yHighpass->biquad[biq_aB2] * (1.0 - temp)); + yHighpass->biquad[biq_b1] = (yHighpass->biquad[biq_bA1] * temp) + (yHighpass->biquad[biq_bB1] * (1.0 - temp)); + yHighpass->biquad[biq_b2] = (yHighpass->biquad[biq_bA2] * temp) + (yHighpass->biquad[biq_bB2] * (1.0 - temp)); + // this is the interpolation code for the biquad + double powFactor = (yHighpass->powFactorA * temp) + (yHighpass->powFactorB * (1.0 - temp)); + double inTrim = (yHighpass->inTrimA * temp) + (yHighpass->inTrimB * (1.0 - temp)); + double outTrim = (yHighpass->outTrimA * temp) + (yHighpass->outTrimB * (1.0 - temp)); + + inputSampleL *= inTrim; + inputSampleR *= inTrim; + + temp = (inputSampleL * yHighpass->fixA[fix_a0]) + yHighpass->fixA[fix_sL1]; + yHighpass->fixA[fix_sL1] = (inputSampleL * yHighpass->fixA[fix_a1]) - (temp * yHighpass->fixA[fix_b1]) + yHighpass->fixA[fix_sL2]; + yHighpass->fixA[fix_sL2] = (inputSampleL * yHighpass->fixA[fix_a2]) - (temp * yHighpass->fixA[fix_b2]); + inputSampleL = temp; // fixed biquad filtering ultrasonics + temp = (inputSampleR * yHighpass->fixA[fix_a0]) + yHighpass->fixA[fix_sR1]; + yHighpass->fixA[fix_sR1] = (inputSampleR * yHighpass->fixA[fix_a1]) - (temp * yHighpass->fixA[fix_b1]) + yHighpass->fixA[fix_sR2]; + yHighpass->fixA[fix_sR2] = (inputSampleR * yHighpass->fixA[fix_a2]) - (temp * yHighpass->fixA[fix_b2]); + inputSampleR = temp; // fixed biquad filtering ultrasonics + + // encode/decode courtesy of torridgristle under the MIT license + if (inputSampleL > 1.0) inputSampleL = 1.0; + else if (inputSampleL > 0.0) inputSampleL = 1.0 - pow(1.0 - inputSampleL, powFactor); + if (inputSampleL < -1.0) inputSampleL = -1.0; + else if (inputSampleL < 0.0) inputSampleL = -1.0 + pow(1.0 + inputSampleL, powFactor); + if (inputSampleR > 1.0) inputSampleR = 1.0; + else if (inputSampleR > 0.0) inputSampleR = 1.0 - pow(1.0 - inputSampleR, powFactor); + if (inputSampleR < -1.0) inputSampleR = -1.0; + else if (inputSampleR < 0.0) inputSampleR = -1.0 + pow(1.0 + inputSampleR, powFactor); + + temp = (inputSampleL * yHighpass->biquad[biq_a0]) + yHighpass->biquad[biq_sL1]; + yHighpass->biquad[biq_sL1] = (inputSampleL * yHighpass->biquad[biq_a1]) - (temp * yHighpass->biquad[biq_b1]) + yHighpass->biquad[biq_sL2]; + yHighpass->biquad[biq_sL2] = (inputSampleL * yHighpass->biquad[biq_a2]) - (temp * yHighpass->biquad[biq_b2]); + inputSampleL = temp; // coefficient interpolating biquad filter + temp = (inputSampleR * yHighpass->biquad[biq_a0]) + yHighpass->biquad[biq_sR1]; + yHighpass->biquad[biq_sR1] = (inputSampleR * yHighpass->biquad[biq_a1]) - (temp * yHighpass->biquad[biq_b1]) + yHighpass->biquad[biq_sR2]; + yHighpass->biquad[biq_sR2] = (inputSampleR * yHighpass->biquad[biq_a2]) - (temp * yHighpass->biquad[biq_b2]); + inputSampleR = temp; // coefficient interpolating biquad filter + + // encode/decode courtesy of torridgristle under the MIT license + if (inputSampleL > 1.0) inputSampleL = 1.0; + else if (inputSampleL > 0.0) inputSampleL = 1.0 - pow(1.0 - inputSampleL, (1.0 / powFactor)); + if (inputSampleL < -1.0) inputSampleL = -1.0; + else if (inputSampleL < 0.0) inputSampleL = -1.0 + pow(1.0 + inputSampleL, (1.0 / powFactor)); + if (inputSampleR > 1.0) inputSampleR = 1.0; + else if (inputSampleR > 0.0) inputSampleR = 1.0 - pow(1.0 - inputSampleR, (1.0 / powFactor)); + if (inputSampleR < -1.0) inputSampleR = -1.0; + else if (inputSampleR < 0.0) inputSampleR = -1.0 + pow(1.0 + inputSampleR, (1.0 / powFactor)); + + inputSampleL *= outTrim; + inputSampleR *= outTrim; + + temp = (inputSampleL * yHighpass->fixB[fix_a0]) + yHighpass->fixB[fix_sL1]; + yHighpass->fixB[fix_sL1] = (inputSampleL * yHighpass->fixB[fix_a1]) - (temp * yHighpass->fixB[fix_b1]) + yHighpass->fixB[fix_sL2]; + yHighpass->fixB[fix_sL2] = (inputSampleL * yHighpass->fixB[fix_a2]) - (temp * yHighpass->fixB[fix_b2]); + inputSampleL = temp; // fixed biquad filtering ultrasonics + temp = (inputSampleR * yHighpass->fixB[fix_a0]) + yHighpass->fixB[fix_sR1]; + yHighpass->fixB[fix_sR1] = (inputSampleR * yHighpass->fixB[fix_a1]) - (temp * yHighpass->fixB[fix_b1]) + yHighpass->fixB[fix_sR2]; + yHighpass->fixB[fix_sR2] = (inputSampleR * yHighpass->fixB[fix_a2]) - (temp * yHighpass->fixB[fix_b2]); + inputSampleR = temp; // fixed biquad filtering ultrasonics + + if (wet < 1.0) { + inputSampleL = (inputSampleL * wet) + (drySampleL * (1.0 - wet)); + inputSampleR = (inputSampleR * wet) + (drySampleR * (1.0 - wet)); + } + + // begin 32 bit stereo floating point dither + int expon; + frexpf((float) inputSampleL, &expon); + yHighpass->fpdL ^= yHighpass->fpdL << 13; + yHighpass->fpdL ^= yHighpass->fpdL >> 17; + yHighpass->fpdL ^= yHighpass->fpdL << 5; + inputSampleL += (((double) yHighpass->fpdL - (uint32_t) 0x7fffffff) * 5.5e-36l * pow(2, expon + 62)); + frexpf((float) inputSampleR, &expon); + yHighpass->fpdR ^= yHighpass->fpdR << 13; + yHighpass->fpdR ^= yHighpass->fpdR >> 17; + yHighpass->fpdR ^= yHighpass->fpdR << 5; + inputSampleR += (((double) yHighpass->fpdR - (uint32_t) 0x7fffffff) * 5.5e-36l * pow(2, expon + 62)); + // end 32 bit stereo floating point dither + + *out1 = (float) inputSampleL; + *out2 = (float) inputSampleR; + + in1++; + in2++; + out1++; + out2++; + } +} + +static void deactivate(LV2_Handle instance) {} + +static void cleanup(LV2_Handle instance) +{ + free(instance); +} + +static const void* extension_data(const char* uri) +{ + return NULL; +} + +static const LV2_Descriptor descriptor = { + YHIGHPASS_URI, + instantiate, + connect_port, + activate, + run, + deactivate, + cleanup, + extension_data}; + +LV2_SYMBOL_EXPORT const LV2_Descriptor* lv2_descriptor(uint32_t index) +{ + return index == 0 ? &descriptor : NULL; +} diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lv2-airwindows-36.0/src/YHighpass/YHighpass.ttl new/lv2-airwindows-38.0/src/YHighpass/YHighpass.ttl --- old/lv2-airwindows-36.0/src/YHighpass/YHighpass.ttl 1970-01-01 01:00:00.000000000 +0100 +++ new/lv2-airwindows-38.0/src/YHighpass/YHighpass.ttl 2026-06-10 22:27:01.000000000 +0200 @@ -0,0 +1,107 @@ +@prefix doap: <http://usefulinc.com/ns/doap#> . +@prefix foaf: <http://xmlns.com/foaf/0.1/> . +@prefix lv2: <http://lv2plug.in/ns/lv2core#> . +@prefix pprops: <http://lv2plug.in/ns/ext/port-props#> . +@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> . + +<https://hannesbraun.net/ns/lv2/airwindows/yhighpass> + a lv2:Plugin , + lv2:HighpassPlugin , + doap:Project ; + doap:name "YHighpass" ; + rdfs:comment "soft and smooth to nasty, edgy texture-varying filtering" ; + doap:license <https://opensource.org/licenses/MIT> ; + doap:maintainer [ + foaf:name "Hannes Braun" ; + foaf:homepage <https://hannesbraun.net/> + ] ; + + lv2:minorVersion 2 ; + lv2:microVersion 0 ; + + lv2:optionalFeature lv2:hardRTCapable ; + lv2:port [ + a lv2:AudioPort , + lv2:InputPort ; + lv2:index 0 ; + lv2:symbol "inL" ; + lv2:name "In L" + ] , [ + a lv2:AudioPort , + lv2:InputPort ; + lv2:index 1 ; + lv2:symbol "inR" ; + lv2:name "In R" + ] , [ + a lv2:AudioPort , + lv2:OutputPort ; + lv2:index 2 ; + lv2:symbol "outL" ; + lv2:name "Out L" + ] , [ + a lv2:AudioPort , + lv2:OutputPort ; + lv2:index 3 ; + lv2:symbol "outR" ; + lv2:name "Out R" + ] , [ + a lv2:ControlPort , + lv2:InputPort ; + lv2:index 4 ; + lv2:symbol "gain" ; + lv2:name "Gain" ; + lv2:default 0.1 ; + lv2:minimum 0.0 ; + lv2:maximum 1.0 ; + lv2:portProperty pprops:hasStrictBounds + ] , [ + a lv2:ControlPort , + lv2:InputPort ; + lv2:index 5 ; + lv2:symbol "freq" ; + lv2:name "Freq" ; + lv2:default 0.5 ; + lv2:minimum 0.0 ; + lv2:maximum 1.0 ; + lv2:portProperty pprops:hasStrictBounds + ] , [ + a lv2:ControlPort , + lv2:InputPort ; + lv2:index 6 ; + lv2:symbol "reson8" ; + lv2:name "Reson8" ; + lv2:default 0.1 ; + lv2:minimum 0.0 ; + lv2:maximum 1.0 ; + lv2:portProperty pprops:hasStrictBounds + ] , [ + a lv2:ControlPort , + lv2:InputPort ; + lv2:index 7 ; + lv2:symbol "resEdge" ; + lv2:name "ResEdge" ; + lv2:default 0.1 ; + lv2:minimum 0.0 ; + lv2:maximum 1.0 ; + lv2:portProperty pprops:hasStrictBounds + ] , [ + a lv2:ControlPort , + lv2:InputPort ; + lv2:index 8 ; + lv2:symbol "output" ; + lv2:name "Output" ; + lv2:default 1.0 ; + lv2:minimum 0.0 ; + lv2:maximum 1.0 ; + lv2:portProperty pprops:hasStrictBounds + ] , [ + a lv2:ControlPort , + lv2:InputPort ; + lv2:index 9 ; + lv2:symbol "dryWet" ; + lv2:name "Dry/Wet" ; + lv2:default 1.0 ; + lv2:minimum 0.0 ; + lv2:maximum 1.0 ; + lv2:portProperty pprops:hasStrictBounds + ] . diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lv2-airwindows-36.0/src/YNotch/YNotch.c new/lv2-airwindows-38.0/src/YNotch/YNotch.c --- old/lv2-airwindows-36.0/src/YNotch/YNotch.c 1970-01-01 01:00:00.000000000 +0100 +++ new/lv2-airwindows-38.0/src/YNotch/YNotch.c 2026-06-10 22:27:01.000000000 +0200 @@ -0,0 +1,348 @@ +#include <lv2/core/lv2.h> + +#include <math.h> +#include <stdint.h> +#include <stdlib.h> + +#define M_PI 3.14159265358979323846264338327950288 + +#define YNOTCH_URI "https://hannesbraun.net/ns/lv2/airwindows/ynotch"; + +typedef enum { + INPUT_L = 0, + INPUT_R = 1, + OUTPUT_L = 2, + OUTPUT_R = 3, + GAIN = 4, + FREQ = 5, + RESON8 = 6, + RES_EDGE = 7, + OUTPUT = 8, + DRY_WET = 9 +} PortIndex; + +enum { + biq_freq, + biq_reso, + biq_a0, + biq_a1, + biq_a2, + biq_b1, + biq_b2, + biq_aA0, + biq_aA1, + biq_aA2, + biq_bA1, + biq_bA2, + biq_aB0, + biq_aB1, + biq_aB2, + biq_bB1, + biq_bB2, + biq_sL1, + biq_sL2, + biq_sR1, + biq_sR2, + biq_total +}; // coefficient interpolating biquad filter, stereo + +enum { + fix_freq, + fix_reso, + fix_a0, + fix_a1, + fix_a2, + fix_b1, + fix_b2, + fix_sL1, + fix_sL2, + fix_sR1, + fix_sR2, + fix_total +}; // fixed frequency biquad filter for ultrasonics, stereo + +typedef struct { + double sampleRate; + const float* input[2]; + float* output[2]; + const float* gain; + const float* freq; + const float* reson8; + const float* resEdge; + const float* outputGain; + const float* dryWet; + + double biquad[biq_total]; + + double powFactorA; + double powFactorB; + double inTrimA; + double inTrimB; + double outTrimA; + double outTrimB; + + double fixA[fix_total]; + double fixB[fix_total]; + + uint32_t fpdL; + uint32_t fpdR; +} YNotch; + +static LV2_Handle instantiate( + const LV2_Descriptor* descriptor, + double rate, + const char* bundle_path, + const LV2_Feature* const* features) +{ + YNotch* yNotch = (YNotch*) calloc(1, sizeof(YNotch)); + yNotch->sampleRate = rate; + return (LV2_Handle) yNotch; +} + +static void connect_port(LV2_Handle instance, uint32_t port, void* data) +{ + YNotch* yNotch = (YNotch*) instance; + + switch ((PortIndex) port) { + case INPUT_L: + yNotch->input[0] = (const float*) data; + break; + case INPUT_R: + yNotch->input[1] = (const float*) data; + break; + case OUTPUT_L: + yNotch->output[0] = (float*) data; + break; + case OUTPUT_R: + yNotch->output[1] = (float*) data; + break; + case GAIN: + yNotch->gain = (const float*) data; + break; + case FREQ: + yNotch->freq = (const float*) data; + break; + case RESON8: + yNotch->reson8 = (const float*) data; + break; + case RES_EDGE: + yNotch->resEdge = (const float*) data; + break; + case OUTPUT: + yNotch->outputGain = (const float*) data; + break; + case DRY_WET: + yNotch->dryWet = (const float*) data; + break; + } +} + +static void activate(LV2_Handle instance) +{ + YNotch* yNotch = (YNotch*) instance; + for (int x = 0; x < biq_total; x++) { + yNotch->biquad[x] = 0.0; + } + yNotch->powFactorA = 1.0; + yNotch->powFactorB = 1.0; + yNotch->inTrimA = 0.1; + yNotch->inTrimB = 0.1; + yNotch->outTrimA = 1.0; + yNotch->outTrimB = 1.0; + for (int x = 0; x < fix_total; x++) { + yNotch->fixA[x] = 0.0; + yNotch->fixB[x] = 0.0; + } + + yNotch->fpdL = 1.0; + while (yNotch->fpdL < 16386) yNotch->fpdL = rand() * UINT32_MAX; + yNotch->fpdR = 1.0; + while (yNotch->fpdR < 16386) yNotch->fpdR = rand() * UINT32_MAX; +} + +static void run(LV2_Handle instance, uint32_t sampleFrames) +{ + YNotch* yNotch = (YNotch*) instance; + + const float* in1 = yNotch->input[0]; + const float* in2 = yNotch->input[1]; + float* out1 = yNotch->output[0]; + float* out2 = yNotch->output[1]; + + uint32_t inFramesToProcess = sampleFrames; + double overallscale = 1.0; + overallscale /= 44100.0; + overallscale *= yNotch->sampleRate; + + yNotch->inTrimA = yNotch->inTrimB; + yNotch->inTrimB = *yNotch->gain * 10.0; + + yNotch->biquad[biq_freq] = pow(*yNotch->freq, 3) * 20000.0; + if (yNotch->biquad[biq_freq] < 15.0) yNotch->biquad[biq_freq] = 15.0; + yNotch->biquad[biq_freq] /= yNotch->sampleRate; + yNotch->biquad[biq_reso] = (pow(*yNotch->reson8, 2) * 15.0) + 0.0001; + yNotch->biquad[biq_aA0] = yNotch->biquad[biq_aB0]; + yNotch->biquad[biq_aA1] = yNotch->biquad[biq_aB1]; + yNotch->biquad[biq_aA2] = yNotch->biquad[biq_aB2]; + yNotch->biquad[biq_bA1] = yNotch->biquad[biq_bB1]; + yNotch->biquad[biq_bA2] = yNotch->biquad[biq_bB2]; + // previous run through the buffer is still in the filter, so we move it + // to the A section and now it's the new starting point. + double K = tan(M_PI * yNotch->biquad[biq_freq]); + double norm = 1.0 / (1.0 + K / yNotch->biquad[biq_reso] + K * K); + yNotch->biquad[biq_aB0] = (1.0 + K * K) * norm; + yNotch->biquad[biq_aB1] = 2.0 * (K * K - 1) * norm; + yNotch->biquad[biq_aB2] = yNotch->biquad[biq_aB0]; + yNotch->biquad[biq_bB1] = yNotch->biquad[biq_aB1]; + yNotch->biquad[biq_bB2] = (1.0 - K / yNotch->biquad[biq_reso] + K * K) * norm; + // for the coefficient-interpolated biquad filter + + yNotch->powFactorA = yNotch->powFactorB; + yNotch->powFactorB = pow(*yNotch->resEdge + 0.9, 4); + + // 1.0 == target neutral + + yNotch->outTrimA = yNotch->outTrimB; + yNotch->outTrimB = *yNotch->outputGain; + + double wet = *yNotch->dryWet; + + yNotch->fixA[fix_freq] = yNotch->fixB[fix_freq] = 20000.0 / yNotch->sampleRate; + yNotch->fixA[fix_reso] = yNotch->fixB[fix_reso] = 0.7071; // butterworth Q + + K = tan(M_PI * yNotch->fixA[fix_freq]); + norm = 1.0 / (1.0 + K / yNotch->fixA[fix_reso] + K * K); + yNotch->fixA[fix_a0] = yNotch->fixB[fix_a0] = K * K * norm; + yNotch->fixA[fix_a1] = yNotch->fixB[fix_a1] = 2.0 * yNotch->fixA[fix_a0]; + yNotch->fixA[fix_a2] = yNotch->fixB[fix_a2] = yNotch->fixA[fix_a0]; + yNotch->fixA[fix_b1] = yNotch->fixB[fix_b1] = 2.0 * (K * K - 1.0) * norm; + yNotch->fixA[fix_b2] = yNotch->fixB[fix_b2] = (1.0 - K / yNotch->fixA[fix_reso] + K * K) * norm; + // for the fixed-position biquad filter + + while (sampleFrames-- > 0) { + double inputSampleL = *in1; + double inputSampleR = *in2; + if (fabs(inputSampleL) < 1.18e-23) inputSampleL = yNotch->fpdL * 1.18e-17; + if (fabs(inputSampleR) < 1.18e-23) inputSampleR = yNotch->fpdR * 1.18e-17; + double drySampleL = inputSampleL; + double drySampleR = inputSampleR; + + double temp = (double) sampleFrames / inFramesToProcess; + yNotch->biquad[biq_a0] = (yNotch->biquad[biq_aA0] * temp) + (yNotch->biquad[biq_aB0] * (1.0 - temp)); + yNotch->biquad[biq_a1] = (yNotch->biquad[biq_aA1] * temp) + (yNotch->biquad[biq_aB1] * (1.0 - temp)); + yNotch->biquad[biq_a2] = (yNotch->biquad[biq_aA2] * temp) + (yNotch->biquad[biq_aB2] * (1.0 - temp)); + yNotch->biquad[biq_b1] = (yNotch->biquad[biq_bA1] * temp) + (yNotch->biquad[biq_bB1] * (1.0 - temp)); + yNotch->biquad[biq_b2] = (yNotch->biquad[biq_bA2] * temp) + (yNotch->biquad[biq_bB2] * (1.0 - temp)); + // this is the interpolation code for the biquad + double powFactor = (yNotch->powFactorA * temp) + (yNotch->powFactorB * (1.0 - temp)); + double inTrim = (yNotch->inTrimA * temp) + (yNotch->inTrimB * (1.0 - temp)); + double outTrim = (yNotch->outTrimA * temp) + (yNotch->outTrimB * (1.0 - temp)); + + inputSampleL *= inTrim; + inputSampleR *= inTrim; + + temp = (inputSampleL * yNotch->fixA[fix_a0]) + yNotch->fixA[fix_sL1]; + yNotch->fixA[fix_sL1] = (inputSampleL * yNotch->fixA[fix_a1]) - (temp * yNotch->fixA[fix_b1]) + yNotch->fixA[fix_sL2]; + yNotch->fixA[fix_sL2] = (inputSampleL * yNotch->fixA[fix_a2]) - (temp * yNotch->fixA[fix_b2]); + inputSampleL = temp; // fixed biquad filtering ultrasonics + temp = (inputSampleR * yNotch->fixA[fix_a0]) + yNotch->fixA[fix_sR1]; + yNotch->fixA[fix_sR1] = (inputSampleR * yNotch->fixA[fix_a1]) - (temp * yNotch->fixA[fix_b1]) + yNotch->fixA[fix_sR2]; + yNotch->fixA[fix_sR2] = (inputSampleR * yNotch->fixA[fix_a2]) - (temp * yNotch->fixA[fix_b2]); + inputSampleR = temp; // fixed biquad filtering ultrasonics + + // encode/decode courtesy of torridgristle under the MIT license + if (inputSampleL > 1.0) inputSampleL = 1.0; + else if (inputSampleL > 0.0) inputSampleL = 1.0 - pow(1.0 - inputSampleL, powFactor); + if (inputSampleL < -1.0) inputSampleL = -1.0; + else if (inputSampleL < 0.0) inputSampleL = -1.0 + pow(1.0 + inputSampleL, powFactor); + if (inputSampleR > 1.0) inputSampleR = 1.0; + else if (inputSampleR > 0.0) inputSampleR = 1.0 - pow(1.0 - inputSampleR, powFactor); + if (inputSampleR < -1.0) inputSampleR = -1.0; + else if (inputSampleR < 0.0) inputSampleR = -1.0 + pow(1.0 + inputSampleR, powFactor); + + temp = (inputSampleL * yNotch->biquad[biq_a0]) + yNotch->biquad[biq_sL1]; + yNotch->biquad[biq_sL1] = (inputSampleL * yNotch->biquad[biq_a1]) - (temp * yNotch->biquad[biq_b1]) + yNotch->biquad[biq_sL2]; + yNotch->biquad[biq_sL2] = (inputSampleL * yNotch->biquad[biq_a2]) - (temp * yNotch->biquad[biq_b2]); + inputSampleL = temp; // coefficient interpolating biquad filter + temp = (inputSampleR * yNotch->biquad[biq_a0]) + yNotch->biquad[biq_sR1]; + yNotch->biquad[biq_sR1] = (inputSampleR * yNotch->biquad[biq_a1]) - (temp * yNotch->biquad[biq_b1]) + yNotch->biquad[biq_sR2]; + yNotch->biquad[biq_sR2] = (inputSampleR * yNotch->biquad[biq_a2]) - (temp * yNotch->biquad[biq_b2]); + inputSampleR = temp; // coefficient interpolating biquad filter + + // encode/decode courtesy of torridgristle under the MIT license + if (inputSampleL > 1.0) inputSampleL = 1.0; + else if (inputSampleL > 0.0) inputSampleL = 1.0 - pow(1.0 - inputSampleL, (1.0 / powFactor)); + if (inputSampleL < -1.0) inputSampleL = -1.0; + else if (inputSampleL < 0.0) inputSampleL = -1.0 + pow(1.0 + inputSampleL, (1.0 / powFactor)); + if (inputSampleR > 1.0) inputSampleR = 1.0; + else if (inputSampleR > 0.0) inputSampleR = 1.0 - pow(1.0 - inputSampleR, (1.0 / powFactor)); + if (inputSampleR < -1.0) inputSampleR = -1.0; + else if (inputSampleR < 0.0) inputSampleR = -1.0 + pow(1.0 + inputSampleR, (1.0 / powFactor)); + + inputSampleL *= outTrim; + inputSampleR *= outTrim; + + temp = (inputSampleL * yNotch->fixB[fix_a0]) + yNotch->fixB[fix_sL1]; + yNotch->fixB[fix_sL1] = (inputSampleL * yNotch->fixB[fix_a1]) - (temp * yNotch->fixB[fix_b1]) + yNotch->fixB[fix_sL2]; + yNotch->fixB[fix_sL2] = (inputSampleL * yNotch->fixB[fix_a2]) - (temp * yNotch->fixB[fix_b2]); + inputSampleL = temp; // fixed biquad filtering ultrasonics + temp = (inputSampleR * yNotch->fixB[fix_a0]) + yNotch->fixB[fix_sR1]; + yNotch->fixB[fix_sR1] = (inputSampleR * yNotch->fixB[fix_a1]) - (temp * yNotch->fixB[fix_b1]) + yNotch->fixB[fix_sR2]; + yNotch->fixB[fix_sR2] = (inputSampleR * yNotch->fixB[fix_a2]) - (temp * yNotch->fixB[fix_b2]); + inputSampleR = temp; // fixed biquad filtering ultrasonics + + if (wet < 1.0) { + inputSampleL = (inputSampleL * wet) + (drySampleL * (1.0 - wet)); + inputSampleR = (inputSampleR * wet) + (drySampleR * (1.0 - wet)); + } + + // begin 32 bit stereo floating point dither + int expon; + frexpf((float) inputSampleL, &expon); + yNotch->fpdL ^= yNotch->fpdL << 13; + yNotch->fpdL ^= yNotch->fpdL >> 17; + yNotch->fpdL ^= yNotch->fpdL << 5; + inputSampleL += (((double) yNotch->fpdL - (uint32_t) 0x7fffffff) * 5.5e-36l * pow(2, expon + 62)); + frexpf((float) inputSampleR, &expon); + yNotch->fpdR ^= yNotch->fpdR << 13; + yNotch->fpdR ^= yNotch->fpdR >> 17; + yNotch->fpdR ^= yNotch->fpdR << 5; + inputSampleR += (((double) yNotch->fpdR - (uint32_t) 0x7fffffff) * 5.5e-36l * pow(2, expon + 62)); + // end 32 bit stereo floating point dither + + *out1 = (float) inputSampleL; + *out2 = (float) inputSampleR; + + in1++; + in2++; + out1++; + out2++; + } +} + +static void deactivate(LV2_Handle instance) {} + +static void cleanup(LV2_Handle instance) +{ + free(instance); +} + +static const void* extension_data(const char* uri) +{ + return NULL; +} + +static const LV2_Descriptor descriptor = { + YNOTCH_URI, + instantiate, + connect_port, + activate, + run, + deactivate, + cleanup, + extension_data}; + +LV2_SYMBOL_EXPORT const LV2_Descriptor* lv2_descriptor(uint32_t index) +{ + return index == 0 ? &descriptor : NULL; +} diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lv2-airwindows-36.0/src/YNotch/YNotch.ttl new/lv2-airwindows-38.0/src/YNotch/YNotch.ttl --- old/lv2-airwindows-36.0/src/YNotch/YNotch.ttl 1970-01-01 01:00:00.000000000 +0100 +++ new/lv2-airwindows-38.0/src/YNotch/YNotch.ttl 2026-06-10 22:27:01.000000000 +0200 @@ -0,0 +1,107 @@ +@prefix doap: <http://usefulinc.com/ns/doap#> . +@prefix foaf: <http://xmlns.com/foaf/0.1/> . +@prefix lv2: <http://lv2plug.in/ns/lv2core#> . +@prefix pprops: <http://lv2plug.in/ns/ext/port-props#> . +@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> . + +<https://hannesbraun.net/ns/lv2/airwindows/ynotch> + a lv2:Plugin , + lv2:EQPlugin , + doap:Project ; + doap:name "YNotch" ; + rdfs:comment "soft and smooth to nasty, edgy texture-varying filtering" ; + doap:license <https://opensource.org/licenses/MIT> ; + doap:maintainer [ + foaf:name "Hannes Braun" ; + foaf:homepage <https://hannesbraun.net/> + ] ; + + lv2:minorVersion 2 ; + lv2:microVersion 0 ; + + lv2:optionalFeature lv2:hardRTCapable ; + lv2:port [ + a lv2:AudioPort , + lv2:InputPort ; + lv2:index 0 ; + lv2:symbol "inL" ; + lv2:name "In L" + ] , [ + a lv2:AudioPort , + lv2:InputPort ; + lv2:index 1 ; + lv2:symbol "inR" ; + lv2:name "In R" + ] , [ + a lv2:AudioPort , + lv2:OutputPort ; + lv2:index 2 ; + lv2:symbol "outL" ; + lv2:name "Out L" + ] , [ + a lv2:AudioPort , + lv2:OutputPort ; + lv2:index 3 ; + lv2:symbol "outR" ; + lv2:name "Out R" + ] , [ + a lv2:ControlPort , + lv2:InputPort ; + lv2:index 4 ; + lv2:symbol "gain" ; + lv2:name "Gain" ; + lv2:default 0.1 ; + lv2:minimum 0.0 ; + lv2:maximum 1.0 ; + lv2:portProperty pprops:hasStrictBounds + ] , [ + a lv2:ControlPort , + lv2:InputPort ; + lv2:index 5 ; + lv2:symbol "freq" ; + lv2:name "Freq" ; + lv2:default 0.5 ; + lv2:minimum 0.0 ; + lv2:maximum 1.0 ; + lv2:portProperty pprops:hasStrictBounds + ] , [ + a lv2:ControlPort , + lv2:InputPort ; + lv2:index 6 ; + lv2:symbol "reson8" ; + lv2:name "Reson8" ; + lv2:default 0.1 ; + lv2:minimum 0.0 ; + lv2:maximum 1.0 ; + lv2:portProperty pprops:hasStrictBounds + ] , [ + a lv2:ControlPort , + lv2:InputPort ; + lv2:index 7 ; + lv2:symbol "resEdge" ; + lv2:name "ResEdge" ; + lv2:default 0.1 ; + lv2:minimum 0.0 ; + lv2:maximum 1.0 ; + lv2:portProperty pprops:hasStrictBounds + ] , [ + a lv2:ControlPort , + lv2:InputPort ; + lv2:index 8 ; + lv2:symbol "output" ; + lv2:name "Output" ; + lv2:default 1.0 ; + lv2:minimum 0.0 ; + lv2:maximum 1.0 ; + lv2:portProperty pprops:hasStrictBounds + ] , [ + a lv2:ControlPort , + lv2:InputPort ; + lv2:index 9 ; + lv2:symbol "dryWet" ; + lv2:name "Dry/Wet" ; + lv2:default 1.0 ; + lv2:minimum 0.0 ; + lv2:maximum 1.0 ; + lv2:portProperty pprops:hasStrictBounds + ] . diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lv2-airwindows-36.0/src/manifest.ttl.in new/lv2-airwindows-38.0/src/manifest.ttl.in --- old/lv2-airwindows-36.0/src/manifest.ttl.in 2026-03-24 17:39:38.000000000 +0100 +++ new/lv2-airwindows-38.0/src/manifest.ttl.in 2026-06-10 22:27:01.000000000 +0200 @@ -46,6 +46,11 @@ lv2:binary <Air4@CMAKE_SHARED_LIBRARY_SUFFIX@> ; rdfs:seeAlso <Air4.ttl> . +<https://hannesbraun.net/ns/lv2/airwindows/balanced> + a lv2:Plugin ; + lv2:binary <Balanced@CMAKE_SHARED_LIBRARY_SUFFIX@> ; + rdfs:seeAlso <Balanced.ttl> . + <https://hannesbraun.net/ns/lv2/airwindows/bassamp> a lv2:Plugin ; lv2:binary <BassAmp@CMAKE_SHARED_LIBRARY_SUFFIX@> ; @@ -861,11 +866,21 @@ lv2:binary <YBandpass@CMAKE_SHARED_LIBRARY_SUFFIX@> ; rdfs:seeAlso <YBandpass.ttl> . +<https://hannesbraun.net/ns/lv2/airwindows/yhighpass> + a lv2:Plugin ; + lv2:binary <YHighpass@CMAKE_SHARED_LIBRARY_SUFFIX@> ; + rdfs:seeAlso <YHighpass.ttl> . + <https://hannesbraun.net/ns/lv2/airwindows/ylowpass> a lv2:Plugin ; lv2:binary <YLowpass@CMAKE_SHARED_LIBRARY_SUFFIX@> ; rdfs:seeAlso <YLowpass.ttl> . +<https://hannesbraun.net/ns/lv2/airwindows/ynotch> + a lv2:Plugin ; + lv2:binary <YNotch@CMAKE_SHARED_LIBRARY_SUFFIX@> ; + rdfs:seeAlso <YNotch.ttl> . + <https://hannesbraun.net/ns/lv2/airwindows/zoutputstage> a lv2:Plugin ; lv2:binary <ZOutputStage@CMAKE_SHARED_LIBRARY_SUFFIX@> ; diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lv2-airwindows-36.0/substitute.zig new/lv2-airwindows-38.0/substitute.zig --- old/lv2-airwindows-36.0/substitute.zig 2026-03-24 17:39:38.000000000 +0100 +++ new/lv2-airwindows-38.0/substitute.zig 2026-06-10 22:27:01.000000000 +0200 @@ -1,24 +1,21 @@ const std = @import("std"); -pub fn main() !void { - var debug_allocator = std.heap.DebugAllocator(.{}).init; - defer _ = debug_allocator.deinit(); - const allocator = debug_allocator.allocator(); +pub fn main(init: std.process.Init) !void { + const argv = try init.minimal.args.toSlice(init.arena.allocator()); + const input_path = argv[1]; + var buffer = try std.Io.Dir.cwd().readFileAlloc(init.io, input_path, init.gpa, .unlimited); - const input_path = std.os.argv[1]; - var buffer = try std.fs.cwd().readFileAlloc(allocator, std.mem.span(input_path), 100000000); - - for (0..((std.os.argv.len - 2) / 2)) |i| { + for (0..((argv.len - 2) / 2)) |i| { const a = 2 + 2 * i; const b = 2 + 2 * i + 1; - errdefer allocator.free(buffer); - const tmp = try std.mem.replaceOwned(u8, allocator, buffer, std.mem.span(std.os.argv[a]), std.mem.span(std.os.argv[b])); - allocator.free(buffer); + errdefer init.gpa.free(buffer); + const tmp = try std.mem.replaceOwned(u8, init.gpa, buffer, argv[a], argv[b]); + init.gpa.free(buffer); buffer = tmp; } - defer allocator.free(buffer); + defer init.gpa.free(buffer); - var stdout_writer = std.fs.File.stdout().writer(&.{}); + var stdout_writer = std.Io.File.stdout().writer(init.io, &.{}); const stdout = &stdout_writer.interface; try stdout.writeAll(buffer);
