如何生成波形表优化实时音频合成？iOS应用缓冲欠载优化求助

Hey there, I’ve fought through this exact problem when building a synth app for older iPhones a while back—buffer underruns on low-performance hardware are brutal, but there are targeted fixes you can roll out to get things running smoothly without sacrificing audio quality. Let’s break down the most impactful optimizations, tailored to your oscillator bank setup:

1. Precompute All Non-Real-Time Values Offline #

Your current setup calculates harmonic frequencies in the DAC callback, which is a huge waste of CPU cycles on tight real-time threads. Instead:

• Precompute phase increments for every harmonic once (on initialization or when the base frequency changes) using phaseIncrement = 2 * M_PI * harmonicFreq / sampleRate. Store these in a contiguous float array.
• Precompute amplitude scalars (e.g., 1/n for natural harmonic decay) and skip any harmonics with amplitudes below a human-audible threshold (like -60dB) to eliminate unnecessary calculations.

Example precomputation code:

// Run this on the main thread, NOT in the DAC callback
#define NUM_HARMONICS 16
float phaseIncrements[NUM_HARMONICS];
float amplitudes[NUM_HARMONICS];

void updateHarmonics(float baseFreq, float sampleRate) {
    for (int i = 0; i < NUM_HARMONICS; i++) {
        float harmonicFreq = baseFreq * (i + 1);
        phaseIncrements[i] = 2 * M_PI * harmonicFreq / sampleRate;
        // Skip harmonics too quiet to hear to save CPU
        amplitudes[i] = (1.0f / (i+1)) > 0.001f ? 1.0f/(i+1) : 0.0f;
    }
}

2. Replace Real-Time Sin Calculations with Wavetables #

Calling sinf() or cosf() for every harmonic per sample is incredibly CPU-heavy on older devices. Switch to a precomputed wavetable:

• Generate a high-resolution sine wave table (e.g., 4096 samples) once at app launch.
• Use linear interpolation on the table to avoid aliasing and get smooth output.
• Use a power-of-two table size so you can use bitmasking instead of modulo operations for index wrapping (faster execution).

Example wavetable lookup in the callback:

// Precomputed 4096-sample sine table (generated once at launch)
float sineTable[4096];
#define TABLE_MASK 0xFFF // 4096-1, for fast bitmask wrapping

float getSineSample(float phase) {
    // Normalize phase from [0, 2π) to [0, 1)
    float normalizedPhase = phase / (2 * M_PI);
    float tableIndex = normalizedPhase * 4096.0f;
    int idx = (int)tableIndex;
    float frac = tableIndex - idx;
    // Linear interpolation for smooth, aliasing-free output
    float sample = sineTable[idx] * (1.0f - frac) + sineTable[(idx+1) & TABLE_MASK] * frac;
    return sample;
}

3. Strip the DAC Callback to Absolute Essentials #

The audio callback runs on a high-priority real-time thread—any blocking or unnecessary work here will cause underruns immediately. Follow these non-negotiable rules:

• No memory allocation (no malloc, new, or Objective-C object creation) in the callback.
• No Objective-C method calls (message sending has overhead; use C-style functions instead).
• No locks, I/O, or logging (even NSLog will block the thread and kill performance).
• Only do three things: update phase values, look up samples, and accumulate the final output.

4. Optimize Buffer Size & Audio Session Settings #

Older devices can’t handle tiny buffer sizes without choking. Adjust your audio session to balance latency and stability:

• Use AVAudioSession to set a slightly larger preferred buffer duration (e.g., 0.01 seconds = 441 samples at 44.1kHz). Avoid going over 0.02 seconds to keep latency acceptable for real-time use.
• Set the audio session category to AVAudioSessionCategoryPlayback and disable unused features (like Bluetooth input, recording) to reduce system overhead.
• Stick to a 44.1kHz sample rate instead of 48kHz—it cuts down on calculation load by ~8% with no noticeable audio quality loss for most use cases.

5. Leverage NEON SIMD Instructions for Parallel Calculation #

iOS devices support ARM NEON, which lets you compute multiple harmonics at once using vector operations. If your harmonic count is a multiple of 4 (adjust if needed), you can cut loop iterations by 75%:

• Use NEON vector types (float32x4_t) to pack phase increments, amplitudes, and phase values.
• Perform vector additions and multiplications instead of single-sample operations.

Example NEON snippet (processing 4 harmonics at a time):

// Inside DAC callback
float32x4_t outputVec = vdupq_n_f32(0.0f);
for (int i = 0; i < NUM_HARMONICS; i += 4) {
    // Load 4 phases, increments, and amplitudes into vectors
    float32x4_t phaseVec = vld1q_f32(&phases[i]);
    float32x4_t incVec = vld1q_f32(&phaseIncrements[i]);
    float32x4_t ampVec = vld1q_f32(&amplitudes[i]);
    
    // Update phases
    phaseVec = vaddq_f32(phaseVec, incVec);
    // Wrap phases to [0, 2π) to keep values manageable
    phaseVec = vsubq_f32(phaseVec, vmulq_n_f32(vcvtq_f32_s32(vcvtq_s32_f32(vdivq_f32(phaseVec, vdupq_n_f32(2*M_PI)))), vdupq_n_f32(2*M_PI)));
    
    // Get wavetable samples for all 4 phases (vectorized interpolation)
    float32x4_t normPhase = vdivq_f32(phaseVec, vdupq_n_f32(2*M_PI));
    float32x4_t tableIdx = vmulq_n_f32(normPhase, 4096.0f);
    int32x4_t idxVec = vcvtq_s32_f32(tableIdx);
    float32x4_t fracVec = vsubq_f32(tableIdx, vcvtq_f32_s32(idxVec));
    float32x4_t sample1 = vld1q_f32(&sineTable[vgetq_lane_s32(idxVec, 0)]);
    float32x4_t sample2 = vld1q_f32(&sineTable[(vgetq_lane_s32(idxVec, 0)+1) & TABLE_MASK]);
    float32x4_t sampleVec = vmlaq_f32(vmulq_f32(sample1, vsubq_n_f32(vdupq_n_f32(1.0f), fracVec)), sample2, fracVec);
    
    // Scale by amplitudes and add to output
    outputVec = vaddq_f32(outputVec, vmulq_f32(sampleVec, ampVec));
    
    // Store updated phases back
    vst1q_f32(&phases[i], phaseVec);
}
// Convert vector to single sample for output
float finalSample = vgetq_lane_f32(outputVec, 0) + vgetq_lane_f32(outputVec, 1) + vgetq_lane_f32(outputVec, 2) + vgetq_lane_f32(outputVec, 3);

6. Profile to Find Hidden Bottlenecks #

Don’t guess where the CPU is being used—use Xcode’s Instruments to pinpoint issues:

• Use the Core Audio template to check if your callback is exceeding its time budget.
• Use the CPU Profiler to see which functions are taking the most time (you might be surprised by hidden overhead, like a stray lock or debug log you forgot to remove).

内容的提问来源于stack exchange，提问作者E Ludema