Generate FreeDSP Aurora plugin.ini from SigmaStudio .params file

plugininigen.pl

#!/usr/bin/perl
use strict;
use warnings;

# Process SigmaStudio '.params' file to produce a JSON file for FreeDSP-Aurora
# Written by Sebastian Meyer <github.com/archi>
#
# The Author is not affiliated with FreeDSP.
#
# License: Public Domain, if you use it in your project, it'd be nice to mention me as a contributor.
# I reserve the right to relicense future versions.
#
# Script comes with no warranty - do not blindly trust its output!!
#
# Be aware XOs need to manually fixed since they look just like a pair of LP/HP.
# I am not using them right now.
# 
# Version 0.1, 31.05.2020

# Check user supplied parameters:
my $in_file = shift;
my $out_file = shift;

my $bad = 0;
$bad++ unless defined $in_file;
$bad++ unless defined $out_file;

# make sure user didn't supply more parameters:
$bad++ if defined shift;

if ($bad > 0 || $in_file =~ m/^[-?]-h(elp)?$/) {
    print "Usage: plugininigen.pl <input_file> <output_file>\n",
          "\n",
          "Usually you want:\n",
          "     <input_file>     Parameter file: '<plugin>.params'\n",
          "     <output_file>     'plugin.ini'\n";
    exit $bad > 0 ? 1 : 0;
}

# the aim is to fill an output result hash (and convert that to json):
# i use 'result' to avoid confusion with dsp 'output'
my %result;

# now we want to translate things like 
# > Cell Name         = InputSelect_8.Nx1-1_UAC
# > Parameter Name    = monomuxSigma300ns44index
# > Parameter Address = 20413
# > Parameter Value   = 7
# > Parameter Data :
# > 0x00, 0x00, 0x00, 0x07, 
# into the correct format for plugin.ini
# The aim is to do as much with pattern matching instead of hardcoding detectors.
# so we build this map of pattern (on cell name) -> handler:
# I'll explain the structure on one example.
my %name_to_handler;

# Here we parse the InputSelect's
# So the pattern should grab us the size ($1) and the name ($2)
# Which input this is (e.g. 7) we get from the "Parameter Value"
$name_to_handler{"InputSelect_(.)\.Nx1-1(.*)"} = sub {
    # this is a hash references with the collected data:
    # 1 => regex match 1 (This inputSelect's size, e.g. 8)
    # 2 => regex match 2 (This InputSelect's source, e.g. "_UAC")
    # ... (this goes up to 6, but we're only using two here)
    # cell_name => Cell Name
    # name => Parameter Name
    # address => Parameter Address
    # value => Parameter Value
    my $data = shift;
    
    # Input could be any of "_Analog", "_UAC", "_ESP32" (ignored), "_Exp", "_SPDIF" and "" (= port)
    # Let's normalize that to the plugin.ini format:
    my $input_type = lc $data->{2};
    # "" is "port"
    $input_type = "port" if $input_type =~ m/^\s*$/;
    
    $input_type =~ s/^_//;
    
    # esp32 is ignored for now
    return if $input_type eq "esp32";
        
    # now we have analog, uac, exp, spdif and port -- these are also the names used in the plugin.ini
    # check if the corresponding array already exists in the output hash, if not, create it:
    $result{$input_type} = [] if not defined $result{$input_type};
    
    # now put the address at the correct location in the array
    # and remember, the channel in InputSelect_$$CHANNEL$$ counts from 1 to 8, the array from 0 to 7
    my $channel = int($data->{1});
    $result{$input_type}[$channel - 1] = $data->{address};
    
    # last but not least, the input select tells us how many channels we have
    # make sure this is consistent with whatever we know (or use it as initial knowledge)
    if (not defined $result{nchn} or $result{nchn} < $channel) {
        $result{nchn} = $channel;
    }
};

$name_to_handler{"MasterVolume"} = sub {
    my $data = shift;
    # we have Parameter Name HWGainADAU145XAlg9target and HWGainADAU145XAlg9slew_mode
    # 8channel uses the '...target' variant, so we do the same here:
    return if not $data->{name} =~ m/^HWGainADAU.*target$/;
    if (not defined ($result{master})) {
        $result{master} = $data->{address};
    } elsif ($result{master} ne $data->{address}) {
        die "Can not detect MasterVolume address, is it " . $result{master} . " or " . $data->{address} . "?\n";
    }
};

$name_to_handler{"BypassVolPoti"} = sub {
    my $data = shift;
    if (not defined ($result{vpot})) {
        $result{vpot} = $data->{address};
    } elsif ($result{vpot} ne $data->{address}) {
        die "Can not detect MasterVolume address, is it " . $result{vpot} . " or " . $data->{vpot} . "?\n";
    }
};

# high pass and low pass
$name_to_handler{"(L|H)P([0-9]+)_([0-9]+)"} = sub {
    my $data = shift;
    # the high passes have 5 parameter addresses each
    # we're interested in the lowest one, with the name ending in B2_1
    # (i'm not 100% sure on that, so we'll check the address to be safe)
    
    my $pass = ($data->{1} eq "L") ? "lp" : "hp";
    $result{$pass} = [] if (not defined $result{$pass});
    
    # we compute the array index from HPx_y
    # e.g.:
    #  0: HP1_1
    #  1: HP1_2
    #  2: HP1_3
    #  3: HP1_4
    #  4: HP2_1
    my $idx = 4 * (int($data->{2}) - 1) + int($data->{3}) - 1;
    
    # name ending in B2_1 => add the value
    if ($data->{name} =~ m/B2_1$/) {
        $result{$pass}[$idx] = $data->{address};
    } elsif (defined $result{$pass}[$idx]) {
        die "high/low pass address assumption failed!" if $result{$pass}[$idx] > $data->{address};
    }
};

# virtually the same as above, but different index computation
$name_to_handler{"(Low Shelv|High Shelv|Phase) ([0-9]+)"} = sub {
    my $data = shift;
    # the shelfs also have 5 parameter addresses each
    # we're interested in the lowest one, with the name ending in B2_1
    # (i'm not 100% sure on that, so we'll check the address to be safe)
    
    my $arr = undef;
    if (($data->{1} eq "Low Shelv")) {
        $arr = "lshelv";
    } elsif (($data->{1} eq "High Shelv")) {
        $arr = "hshelv";
    } elsif (($data->{1} eq "Phase")) {
        $arr = "phase";
    }
    
    die "Internal error" if not defined $arr;
    $result{$arr} = [] if (not defined $result{$arr});
    
    # index for "Low Shelv x" is probably (x - 1)
    my $idx = (int($data->{2}) - 1);
    
    # name ending in B2_1 => add the value
    if ($data->{name} =~ m/B2_1$/) {
        $result{$arr}[$idx] = $data->{address};
    } elsif (defined $result{$arr}[$idx]) {
        die "high/low shelv address assumption failed!" if $result{$arr}[$idx] > $data->{address};
    }
};

# delay and gain are again pretty similar
$name_to_handler{"(Delay|Gain|FIR) ?([0-9]+)"} = sub {
    my $data = shift;
    
    # delay's name is 'DelaySigma300Alg1delay', and Gain 'HWGainADAU145XAlg2target'
    # filter out 'HWGainADAU145XAlg2slew_mode'
    return if $data->{name} =~ m/slew_mode$/;
    
    my $arr = undef;
    if (($data->{1} eq "Delay")) {
        $arr = "dly";
    } elsif (($data->{1} eq "Gain")) {
        $arr = "gain";
    } elsif (($data->{1} eq "FIR")) {
        $arr = "fir";
    }
    
    die "Internal error" if not defined $arr;
    $result{$arr} = [] if (not defined $result{$arr});
    
    my $idx = (int($data->{2}) - 1);
    $result{$arr}[$idx] = $data->{address};
};

# parametric eq are similar, but a little bit too different again: I want to handle different # of PEQ per channel, so more magic is necessary
$name_to_handler{"Param EQ ([0-9]+)"} = sub {
    my $data = shift;
    # each PEQ consists of multiple bands.
    # eq. "Param EQ 1" has
    #  - General2ndOrderDPSigma300Alg6B2_1 [that's the address we want]
    #  - General2ndOrderDPSigma300Alg6B1_1
    #  - General2ndOrderDPSigma300Alg6B0_1
    #  - General2ndOrderDPSigma300Alg6A2_1
    #  - General2ndOrderDPSigma300Alg6A1_1
    # but now comes the next band, still part of "Param EQ 1":
    #  - General2ndOrderDPSigma300Alg6B2_2
    #  - General2ndOrderDPSigma300Alg6B1_2
    #  - General2ndOrderDPSigma300Alg6B0_2
    #  - General2ndOrderDPSigma300Alg6A2_2
    #  - General2ndOrderDPSigma300Alg6A1_2
    # and so on for all the other bands
    # NOW, careful: I'm doing this because I want to have 15 bands per PEQ in the first two channels, and for the test
    #  i do not care. so we just push them into the array and hope the order in the params-file is what we want in the output array :(
    
    return if (not $data->{name} =~ m/^.*300Alg[0-9]+B2_([0-9])+$/);
    
    $result{peq} = [] if (not defined $result{peq});
    push @{$result{peq}}, $data->{address};
};

# Open the file, and parse it
open my $IN, "<$in_file" or die "Could not open '$in_file' for reading: $!\n";
my %data;
my @name_to_handler_ptrns = keys %name_to_handler;
while (my $line = <$IN>) {
    next unless $line =~ m/^(Cell Name|Parameter Name|Parameter Address|Parameter Value)\s+=\s*(.*)$/;
    my $param = $2;
    my $key = $1;
    $key =~ s/ /_/g;
    $key = lc $key;
    $key =~ s/^parameter_//;
    $param =~ s/\s*$//g;
    $data{$key} = $key eq "address" ? int($param) : $param;
    if ($key eq "cell_name") {
        #print "cell_name = $param\n";
        foreach my $ptrn (@name_to_handler_ptrns) {
            if ($param =~ m/^$ptrn$/) {
                $data{_handler} = $name_to_handler{$ptrn};
                $data{1} = $1 if defined $1;
                $data{2} = $2 if defined $2;
                $data{3} = $3 if defined $3;
                $data{4} = $4 if defined $4;
                $data{5} = $5 if defined $5;
                $data{6} = $6 if defined $6;
                # add more if necessary
            }
        }
    } elsif ($key eq "value") {
        $data{_handler}->(\%data) if defined $data{_handler};
        %data = ();
    }
}
close $IN;

# Generate the "nhp" and so on...
# nxo has to be manually generated from xolp/xohp (once those are added automatically)
foreach my $key ("hp", "lshelv", "peq", "hshelv", "lp", "phase", "dly", "gain", "fir") {
    
    next if defined $result{"n$key"};
    $result{"n$key"} = 0;
    next if not defined $result{$key};
    if ($key =~ m/^(lp|hp)$/) {
        $result{"n$key"} = scalar @{$result{$key}} / 4;
    } else {
        $result{"n$key"} = scalar @{$result{$key}};
    }
}


open my $OUT, ">$out_file" or die "Could not open '$out_file' for writing: $!\n";

# my $!!!@ lovely windows doesn't have JSON.pm, so let's be rude...

# make the output more beautiful by printing one channel per line, unless it's just one datum per channel
my $nchn = $result{nchn};

print $OUT "{\n";
my $first = 1; 
foreach my $k (sort keys %result) {
    print $OUT ",\n" if not $first;
    $first = 0;
    
    print $OUT "\"$k\":";
    my $type = ref $result{$k};
    if ($type eq "") {
        print $OUT $result{$k};
    } elsif ($type eq "ARRAY") {
        my $cnt = scalar @{$result{$k}};
        my $insert_line_break = 4096;
        my $prefix = "";
        if ($cnt > $nchn and $cnt % $nchn == 0) {
            $insert_line_break = $cnt / $nchn;
            $prefix = sprintf("%".(length($k)+4)."s", "");
        }
        print $OUT "[";
        my $afirst = 1;
        foreach my $a (@{$result{$k}}) {
            if ($insert_line_break == 0) {
                print $OUT ",\n$prefix";
                $insert_line_break = $cnt / $nchn;
            } else {
                print $OUT ", " if not $afirst;
            }
            $insert_line_break--;
            $afirst = 0;
            if (not defined $a) {
                $bad++;
                print $OUT "undef";
                print "Undefined array member for '$k'!\n";
            } else {
                print $OUT $a;
            }
        }
        print $OUT "]";
    } else {
        print "Error: Don't know how to print '$k'!\n";
        $bad++;
    }
}
print $OUT "\n}";

close $OUT;

print "Script finished with $bad errors. Remember to ALWAYS review the output. If you're using an XO, adapt the result! (The script can not differentiate between an XO and a LP/HP!\n\n\n";
print "This script (and the result) come with no warranty for correctness. If this kills your speakers or DSP, it is your fault for not properly reviewing the output!\n";

exit 1 if $bad > 0;
exit 0;