Skip to content

Liquid Glass and Apple Music touches for the Spotify iOS app. A GPL-3.0 fork of spoti.pw 0.21.1.

C
8.7 KB
Raw Blame
#import "SGDSPEffects.h"
#import <Accelerate/Accelerate.h>
#import <math.h>
#import <pthread.h>
#import <stdlib.h>
#import <string.h>

#pragma mark - the compander

enum { kBands = 7, kCrossovers = kBands - 1, kCompanderStep = 16 };
static const double kMostDB = 12, kQuietDB = -70;

struct SGDSPCompander {
    double rate;
    SGBiquad lows[kCrossovers], highs[kCrossovers], passes[kCrossovers];
    SGBiquadState lowStates[2][kCrossovers][2], highStates[2][kCrossovers][2], passStates[2][15];
    double amount[kBands], fast[kBands], slow[kBands], gain[kBands];
    double attack, release, settle;
    bool primed;
    float bands[kBands][2][kSGDSPEffectMaxFrames];
};

SGDSPCompander *SGDSPCompanderCreate(double rate, double timeConstant, const double frequencies[7], const double gains[7]) {
    SGDSPCompander *compander = calloc(1, sizeof *compander);
    if (!compander) return NULL;
    compander->rate = rate;
    for (int k = 0; k < kCrossovers; k++) {
        double crossover = sqrt(frequencies[k] * frequencies[k + 1]);
        compander->lows[k] = SGBiquadLowPass(rate, crossover, M_SQRT1_2);
        compander->highs[k] = SGBiquadHighPass(rate, crossover, M_SQRT1_2);
        compander->passes[k] = SGBiquadAllPass(rate, crossover, M_SQRT1_2);
    }
    for (int b = 0; b < kBands; b++) compander->gain[b] = 1;
    SGDSPCompanderSet(compander, timeConstant, gains);
    return compander;
}

void SGDSPCompanderSet(SGDSPCompander *compander, double timeConstant, const double gains[7]) {
    double rate = compander->rate, time = fmax(timeConstant, 0.01);
    compander->attack = 1 - exp(-1 / (0.1 * time * rate));
    compander->release = 1 - exp(-1 / (time * rate));
    compander->settle = 1 - exp(-1 / (10 * time * rate));
    for (int b = 0; b < kBands; b++) compander->amount[b] = 0.6 * gains[b];
}

// Each channel into seven bands: a Linkwitz-Riley low pass off what is left at each crossover, the rest
// passing on. A band then goes through the allpasses of the crossovers above it, so the sum is flat.
static void split(SGDSPCompander *compander, int channel, const float *input, uint32_t frames) {
    float *rest = compander->bands[kBands - 1][channel];
    memcpy(rest, input, frames * sizeof(float));
    int pass = 0;
    for (int k = 0; k < kCrossovers; k++) {
        float *band = compander->bands[k][channel];
        memcpy(band, rest, frames * sizeof(float));
        for (int twice = 0; twice < 2; twice++) {
            SGBiquadRun(&compander->lows[k], &compander->lowStates[channel][k][twice], 1, band, frames);
            SGBiquadRun(&compander->highs[k], &compander->highStates[channel][k][twice], 1, rest, frames);
        }
    }
    for (int k = 0; k < kCrossovers - 1; k++) {
        for (int above = k + 1; above < kCrossovers; above++) {
            SGBiquadRun(&compander->passes[above], &compander->passStates[channel][pass++], 1, compander->bands[k][channel], frames);
        }
    }
}

void SGDSPCompanderRun(void *state, float *left, float *right, uint32_t frames) {
    SGDSPCompander *compander = state;
    split(compander, 0, left, frames);
    split(compander, 1, right, frames);
    memset(left, 0, frames * sizeof(float));
    memset(right, 0, frames * sizeof(float));
    for (int b = 0; b < kBands; b++) {
        float *l = compander->bands[b][0], *r = compander->bands[b][1];
        for (uint32_t start = 0; start < frames; start += kCompanderStep) {
            uint32_t end = start + kCompanderStep < frames ? start + kCompanderStep : frames;
            double fast = compander->fast[b], slow = compander->slow[b];
            for (uint32_t i = start; i < end; i++) {
                double power = 0.5 * ((double)l[i] * l[i] + (double)r[i] * r[i]);
                fast += (power - fast) * (power > fast ? compander->attack : compander->release);
                slow += (power - slow) * compander->settle;
            }
            // The running level starts where the band is, not from silence.
            if (!compander->primed) slow = fast;
            compander->fast[b] = fast;
            compander->slow[b] = slow;
            double fastDB = 10 * log10(fast + 1e-12), slowDB = 10 * log10(slow + 1e-12);
            double gainDB = fmax(-kMostDB, fmin(kMostDB, -compander->amount[b] * (fastDB - slowDB)));
            if (fastDB < kQuietDB && gainDB > 0) gainDB = 0;
            double from = compander->gain[b], to = pow(10, gainDB / 20), step = (to - from) / (end - start);
            for (uint32_t i = start; i < end; i++) {
                float g = (float)(from + step * (i - start + 1));
                left[i] += l[i] * g;
                right[i] += r[i] * g;
            }
            compander->gain[b] = to;
        }
    }
    compander->primed = true;
}

#pragma mark - the tube

enum { kTaps = 64, kHistory = kTaps - 1, kPhaseHistory = kTaps / 2 - 1 };
static const float kBias = 0.25f;

// The filter of both the doubling and the halving: a low pass at a quarter of the doubled rate, minimum
// phase, so it delays by a few samples rather than half its length. Made once, the same at every rate.
static float sg_halfband[kTaps];

static double besselI0(double x) {
    double sum = 1, term = 1;
    for (int k = 1; k < 30; k++) {
        term *= (x / (2 * k)) * (x / (2 * k));
        sum += term;
    }
    return sum;
}

static void designHalfband(void) {
    enum { kLength = 63, kLog2n = 12 };
    double linear[kLength], sum = 0, beta = 7;
    for (int n = 0; n < kLength; n++) {
        int m = n - kLength / 2;
        double sinc = m ? sin(M_PI * m / 2) / (M_PI * m) : 0.5;
        double x = (double)m / (kLength / 2);
        linear[n] = sinc * besselI0(beta * sqrt(fmax(0, 1 - x * x))) / besselI0(beta);
        sum += linear[n];
    }
    double magnitude[(1 << kLog2n) / 2 + 1];
    for (int k = 0; k <= (1 << kLog2n) / 2; k++) {
        double re = 0, im = 0, w = 2 * M_PI * k / (1 << kLog2n);
        for (int n = 0; n < kLength; n++) {
            re += linear[n] / sum * cos(w * n);
            im -= linear[n] / sum * sin(w * n);
        }
        magnitude[k] = hypot(re, im);
    }
    SGDSPMinimumPhase(magnitude, kLog2n, sg_halfband, kTaps);
}

struct SGDSPTube {
    float drive, normalize, offset;
    double dcCoefficient, dcIn[2], dcOut[2];
    float input[2][kPhaseHistory + kSGDSPEffectMaxFrames];
    float doubled[2][kHistory + 2 * kSGDSPEffectMaxFrames];
    float scratch[2 * kSGDSPEffectMaxFrames];
};

SGDSPTube *SGDSPTubeCreate(double rate, double driveDB) {
    static pthread_once_t once = PTHREAD_ONCE_INIT;
    pthread_once(&once, designHalfband);
    SGDSPTube *tube = calloc(1, sizeof *tube);
    if (!tube) return NULL;
    tube->dcCoefficient = exp(-2 * M_PI * 10 / rate);
    SGDSPTubeSet(tube, driveDB);
    return tube;
}

// A full scale sound at 0 dB of drive reaches half way up the curve; the output is scaled back by the
// curve's slope at rest, so quiet sounds keep their level.
void SGDSPTubeSet(SGDSPTube *tube, double driveDB) {
    double drive = 0.5 * pow(10, driveDB / 20), slope = 1 - tanh(kBias) * tanh(kBias);
    tube->drive = (float)drive;
    tube->normalize = (float)(1 / (drive * slope));
    tube->offset = tanhf(kBias);
}

static void shape(SGDSPTube *tube, int channel, float *lane, uint32_t frames) {
    float *input = tube->input[channel], *doubled = tube->doubled[channel], *curve = tube->scratch;
    memcpy(input + kPhaseHistory, lane, frames * sizeof(float));
    // Doubled: each output phase is every other tap over the input, times two for the zeros stuffed between.
    for (uint32_t n = 0; n < frames; n++) {
        const float *x = input + kPhaseHistory + n;
        float even = 0, odd = 0;
        for (int k = 0; k < kTaps / 2; k++) {
            even += sg_halfband[2 * k] * x[-k];
            odd += sg_halfband[2 * k + 1] * x[-k];
        }
        curve[2 * n] = 2 * even * tube->drive + kBias;
        curve[2 * n + 1] = 2 * odd * tube->drive + kBias;
    }
    int count = (int)(2 * frames);
    vvtanhf(curve, curve, &count);
    float *shaped = doubled + kHistory;
    for (int i = 0; i < count; i++) shaped[i] = (curve[i] - tube->offset) * tube->normalize;
    // Halved: the same filter, every other output.
    double in = tube->dcIn[channel], out = tube->dcOut[channel];
    for (uint32_t n = 0; n < frames; n++) {
        const float *u = shaped + 2 * n;
        float sum = 0;
        for (int k = 0; k < kTaps; k++) sum += sg_halfband[k] * u[-k];
        out = sum - in + tube->dcCoefficient * out;
        in = sum;
        lane[n] = (float)out;
    }
    tube->dcIn[channel] = in;
    tube->dcOut[channel] = out;
    memmove(input, input + frames, kPhaseHistory * sizeof(float));
    memmove(doubled, doubled + count, kHistory * sizeof(float));
}

void SGDSPTubeRun(void *state, float *left, float *right, uint32_t frames) {
    SGDSPTube *tube = state;
    shape(tube, 0, left, frames);
    shape(tube, 1, right, frames);
}