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
10.0 KB
Raw Blame
#import "SGTimePitch.h"
#import <stdatomic.h>
#import <stdlib.h>
#import <string.h>

// The FIFO of in place mode, a power of two with room for a few of the largest buffers.
enum { kFifoFrames = 16384 };

struct SGTimePitch {
    AudioUnit unit;
    AudioUnit vari;                   // pull mode only: Varispeed, NULL in place
    atomic_bool follows;
    _Atomic float rate, semitones;
    atomic_bool resampling;           // which unit renders; changed only by SGTimePitchReset
    double sampleRate;
    UInt32 channels;
    SGTimePitchSource source;
    void *context;
    float *fifo[kSGTimePitchMaxChannels];
    uint64_t written, read;           // render thread only
    Float64 sampleTime;
    struct {
        AudioBufferList list;
        AudioBuffer more[kSGTimePitchMaxChannels - 1];
    } output;
    float *outputData[kSGTimePitchMaxChannels];
    atomic_uint underruns, failures, largestPull;
    atomic_uint_fast64_t consumed;
    double latency;
};

static OSStatus input(void *refCon, AudioUnitRenderActionFlags *flags, const AudioTimeStamp *timestamp, UInt32 bus,
                      UInt32 frames, AudioBufferList *data) {
    SGTimePitch *unit = refCon;
    if (frames > atomic_load_explicit(&unit->largestPull, memory_order_relaxed)) {
        atomic_store_explicit(&unit->largestPull, frames, memory_order_relaxed);
    }
    atomic_fetch_add_explicit(&unit->consumed, frames, memory_order_relaxed);
    if (unit->source) return unit->source(unit->context, frames, data);

    uint64_t available = unit->written - unit->read;
    UInt32 served = (UInt32)(available < frames ? available : frames);
    if (served < frames) atomic_fetch_add_explicit(&unit->underruns, 1, memory_order_relaxed);
    for (UInt32 c = 0; c < data->mNumberBuffers && c < unit->channels; c++) {
        float *out = data->mBuffers[c].mData;
        if (!out) continue;
        for (UInt32 i = 0; i < served; i++) out[i] = unit->fifo[c][(unit->read + i) & (kFifoFrames - 1)];
        if (served < frames) memset(out + served, 0, (frames - served) * sizeof(float));
        data->mBuffers[c].mDataByteSize = frames * sizeof(float);
    }
    unit->read += served;
    return noErr;
}

SGTimePitch *SGTimePitchCreate(double sampleRate, UInt32 channels, SGTimePitchSource source, void *context) {
    if (sampleRate <= 0 || channels < 1 || channels > kSGTimePitchMaxChannels) return NULL;
    AudioComponentDescription description = {
        .componentType = kAudioUnitType_FormatConverter,
        .componentSubType = kAudioUnitSubType_NewTimePitch,
        .componentManufacturer = kAudioUnitManufacturer_Apple,
    };
    AudioComponent component = AudioComponentFindNext(NULL, &description);
    if (!component) return NULL;
    SGTimePitch *unit = calloc(1, sizeof *unit);
    if (!unit) return NULL;
    unit->sampleRate = sampleRate;
    unit->channels = channels;
    unit->source = source;
    unit->context = context;
    if (AudioComponentInstanceNew(component, &unit->unit) != noErr) {
        free(unit);
        return NULL;
    }
    AudioStreamBasicDescription format = {
        .mSampleRate = sampleRate,
        .mFormatID = kAudioFormatLinearPCM,
        .mFormatFlags = kAudioFormatFlagsNativeFloatPacked | kAudioFormatFlagIsNonInterleaved,
        .mBytesPerPacket = sizeof(float),
        .mFramesPerPacket = 1,
        .mBytesPerFrame = sizeof(float),
        .mChannelsPerFrame = channels,
        .mBitsPerChannel = 32,
    };
    UInt32 maxFrames = kSGTimePitchMaxFrames;
    AURenderCallbackStruct callback = {input, unit};
    OSStatus status = AudioUnitSetProperty(unit->unit, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Input, 0, &format, sizeof format);
    if (!status) status = AudioUnitSetProperty(unit->unit, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Output, 0, &format, sizeof format);
    if (!status) status = AudioUnitSetProperty(unit->unit, kAudioUnitProperty_MaximumFramesPerSlice, kAudioUnitScope_Global, 0, &maxFrames, sizeof maxFrames);
    if (!status) status = AudioUnitSetProperty(unit->unit, kAudioUnitProperty_SetRenderCallback, kAudioUnitScope_Input, 0, &callback, sizeof callback);
    if (!status) status = AudioUnitSetParameter(unit->unit, kNewTimePitchParam_Rate, kAudioUnitScope_Global, 0, 1, 0);
    if (!status) status = AudioUnitInitialize(unit->unit);
    atomic_store(&unit->rate, 1);
    // Varispeed beside it, pulling the same source: a resampler, so speed and pitch move together.
    AudioComponentDescription varispeed = {
        .componentType = kAudioUnitType_FormatConverter,
        .componentSubType = kAudioUnitSubType_Varispeed,
        .componentManufacturer = kAudioUnitManufacturer_Apple,
    };
    AudioComponent variComponent = source ? AudioComponentFindNext(NULL, &varispeed) : NULL;
    if (!status && variComponent && AudioComponentInstanceNew(variComponent, &unit->vari) == noErr) {
        OSStatus vstatus = AudioUnitSetProperty(unit->vari, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Input, 0, &format, sizeof format);
        if (!vstatus) vstatus = AudioUnitSetProperty(unit->vari, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Output, 0, &format, sizeof format);
        if (!vstatus) vstatus = AudioUnitSetProperty(unit->vari, kAudioUnitProperty_MaximumFramesPerSlice, kAudioUnitScope_Global, 0, &maxFrames, sizeof maxFrames);
        if (!vstatus) vstatus = AudioUnitSetProperty(unit->vari, kAudioUnitProperty_SetRenderCallback, kAudioUnitScope_Input, 0, &callback, sizeof callback);
        if (!vstatus) vstatus = AudioUnitInitialize(unit->vari);
        if (vstatus) {
            AudioComponentInstanceDispose(unit->vari);
            unit->vari = NULL;
        }
    }
    if (status) {
        AudioComponentInstanceDispose(unit->unit);
        free(unit);
        return NULL;
    }
    Float64 latency = 0;
    UInt32 size = sizeof latency;
    if (AudioUnitGetProperty(unit->unit, kAudioUnitProperty_Latency, kAudioUnitScope_Global, 0, &latency, &size) == noErr) {
        unit->latency = latency;
    }
    unit->output.list.mNumberBuffers = channels;
    for (UInt32 c = 0; c < channels; c++) {
        if (!source) unit->fifo[c] = calloc(kFifoFrames, sizeof(float));
        unit->outputData[c] = calloc(kSGTimePitchMaxFrames, sizeof(float));
    }
    return unit;
}

double SGTimePitchSampleRate(const SGTimePitch *unit) {
    return unit->sampleRate;
}

UInt32 SGTimePitchChannels(const SGTimePitch *unit) {
    return unit->channels;
}

void SGTimePitchSetRate(SGTimePitch *unit, float rate) {
    AudioUnitSetParameter(unit->unit, kNewTimePitchParam_Rate, kAudioUnitScope_Global, 0, rate, 0);
    if (unit->vari) AudioUnitSetParameter(unit->vari, kVarispeedParam_PlaybackRate, kAudioUnitScope_Global, 0, rate, 0);
    atomic_store(&unit->rate, rate);
}

void SGTimePitchSetFollows(SGTimePitch *unit, bool follows) {
    atomic_store(&unit->follows, follows);
}

void SGTimePitchSetSemitones(SGTimePitch *unit, float semitones) {
    AudioUnitSetParameter(unit->unit, kNewTimePitchParam_Pitch, kAudioUnitScope_Global, 0, semitones * 100, 0);
    atomic_store(&unit->semitones, semitones);
}

// Varispeed while following, through normal speed too, so coming back to 1x never changes units; the time
// and pitch unit for a stretch, and for pitch alone at normal speed.
static bool wantsVarispeed(const SGTimePitch *unit) {
    return unit->vari && atomic_load(&unit->follows)
           && (atomic_load(&unit->rate) != 1 || atomic_load(&unit->semitones) == 0);
}

bool SGTimePitchSwitchPending(const SGTimePitch *unit) {
    return wantsVarispeed(unit) != atomic_load(&unit->resampling);
}

void SGTimePitchReset(SGTimePitch *unit) {
    AudioUnitReset(unit->unit, kAudioUnitScope_Global, 0);
    if (unit->vari) AudioUnitReset(unit->vari, kAudioUnitScope_Global, 0);
    unit->written = unit->read = 0;
    unit->sampleTime = 0;
    atomic_store(&unit->resampling, wantsVarispeed(unit));
}

OSStatus SGTimePitchRender(SGTimePitch *unit, UInt32 frames, AudioBufferList *data) {
    if (!frames || frames > kSGTimePitchMaxFrames) return kAudioUnitErr_TooManyFramesToProcess;
    AudioTimeStamp timestamp = {.mSampleTime = unit->sampleTime, .mFlags = kAudioTimeStampSampleTimeValid};
    AudioUnitRenderActionFlags flags = 0;
    OSStatus status = AudioUnitRender(atomic_load(&unit->resampling) ? unit->vari : unit->unit, &flags, &timestamp, 0, frames, data);
    unit->sampleTime += frames;
    if (status != noErr) atomic_fetch_add_explicit(&unit->failures, 1, memory_order_relaxed);
    return status;
}

bool SGTimePitchProcess(SGTimePitch *unit, float *const *channels, UInt32 frames) {
    if (unit->source || !frames || frames > kSGTimePitchMaxFrames) return false;
    // A FIFO that would overflow (the unit stopped pulling) starts over rather than wrap onto itself.
    if (unit->written - unit->read + frames > kFifoFrames) {
        unit->written = unit->read = 0;
        atomic_fetch_add_explicit(&unit->failures, 1, memory_order_relaxed);
        return false;
    }
    for (UInt32 c = 0; c < unit->channels; c++) {
        const float *in = channels[c];
        for (UInt32 i = 0; i < frames; i++) unit->fifo[c][(unit->written + i) & (kFifoFrames - 1)] = in[i];
    }
    unit->written += frames;

    for (UInt32 c = 0; c < unit->channels; c++) {
        unit->output.list.mBuffers[c] = (AudioBuffer){1, frames * (UInt32)sizeof(float), unit->outputData[c]};
    }
    if (SGTimePitchRender(unit, frames, &unit->output.list) != noErr) return false;
    for (UInt32 c = 0; c < unit->channels; c++) {
        const float *out = unit->output.list.mBuffers[c].mData;
        if (out) memcpy(channels[c], out, frames * sizeof(float));
    }
    return true;
}

UInt32 SGTimePitchUnderruns(const SGTimePitch *unit) {
    return atomic_load((atomic_uint *)&unit->underruns);
}

UInt32 SGTimePitchFailures(const SGTimePitch *unit) {
    return atomic_load((atomic_uint *)&unit->failures);
}

double SGTimePitchLatency(const SGTimePitch *unit) {
    return unit->latency;
}

UInt32 SGTimePitchLargestPull(const SGTimePitch *unit) {
    return atomic_load((atomic_uint *)&unit->largestPull);
}

uint64_t SGTimePitchConsumed(const SGTimePitch *unit) {
    return atomic_load((atomic_uint_fast64_t *)&unit->consumed);
}