如何让SDL_AudioCallback实现无缝播放（消除无声卡顿）？

问题背景 #

我正在编写一个基于SDL的简单音频播放程序（代码如下），程序能正常运行，但回调函数触发时存在轻微可感知的无声卡顿。推测原因是回调仅在缓冲区耗尽时才被调用，填充缓冲区的延迟导致了卡顿。

实际场景是接收外部音频流，希望在SDL消费缓冲区的同时填充数据，但目前仅能在回调中访问缓冲区，而此时缓冲区已耗尽，想找更优雅的解决方案，且尽量不使用SDL_mixer。

原程序代码 #

#include <iostream>
#include <SDL.h>


float sine_freq = 200.0f;
float audio_volume = 1.0f;
float audio_frequency;

void SineAudioCallback(void* userdata, Uint8* stream, int len) {
    float* buf = (float*)stream;
    for (int i = 0; i < len / 4; ++i) {
        buf[i] = (float)(audio_volume * sin(2 * M_PI * i * audio_frequency));
    }
    std::cout << "here" << std::endl;
    return;
}

int main(int argc, char* argv[])
{
    if (SDL_Init(SDL_INIT_AUDIO)) {
        return 1;
    }

    std::cout << "[SDL] Audio driver: " << SDL_GetCurrentAudioDriver() << std::endl;

    SDL_AudioSpec want, have;
    SDL_zero(want);

    want.freq = 5000;
    want.format = AUDIO_F32;
    want.channels = 2;
    want.samples = 4096;
    want.callback = SineAudioCallback;

    std::cout <<"[SDL] Desired - frequency: " << want.freq
        << ", format: f " << SDL_AUDIO_ISFLOAT(want.format)  << " s " << SDL_AUDIO_ISSIGNED(want.format) << " be " << SDL_AUDIO_ISBIGENDIAN(want.format) << " sz " << SDL_AUDIO_BITSIZE(want.format)
        << ", channels: " << (int)want.channels << ", samples: " << want.samples << std::endl;


    SDL_AudioDeviceID dev = SDL_OpenAudioDevice(NULL, 0, &want, &have, SDL_AUDIO_ALLOW_ANY_CHANGE);

    if (!dev) {
        SDL_Quit();
        return 1;
    }


    std::cout << "[SDL] Desired - frequency: " << have.freq
        << ", format: f " << SDL_AUDIO_ISFLOAT(have.format) << " s " << SDL_AUDIO_ISSIGNED(have.format) << " be " << SDL_AUDIO_ISBIGENDIAN(have.format) << " sz " << SDL_AUDIO_BITSIZE(have.format)
        << ", channels: " << (int)have.channels << ", samples: " << have.samples << std::endl;

    audio_frequency = sine_freq / have.freq;

    SDL_PauseAudioDevice(dev, 0);
    SDL_Delay(10000);

    SDL_CloseAudioDevice(dev);
    SDL_Quit();

    return 0;
}

解决方案 #

1. 用线程安全环形缓冲预填充数据 #

核心思路是在独立线程中提前将外部音频流写入环形缓冲，回调函数仅从缓冲中读取数据填充SDL音频缓冲区，避免回调中执行耗时的外部数据读取操作。

环形缓冲实现示例

#include <mutex>
#include <vector>
#include <algorithm>

class AudioRingBuffer {
private:
    std::vector<float> buffer;
    size_t write_pos = 0;
    size_t read_pos = 0;
    size_t filled = 0;
    std::mutex mtx;

public:
    AudioRingBuffer(size_t capacity) : buffer(capacity) {}

    // 写入数据，返回实际写入量
    size_t write(const float* data, size_t count) {
        std::lock_guard<std::mutex> lock(mtx);
        size_t available = buffer.size() - filled;
        size_t write_count = std::min(count, available);
        
        // 处理环形缓冲的分段写入
        size_t first_segment = std::min(write_count, buffer.size() - write_pos);
        std::copy(data, data + first_segment, buffer.begin() + write_pos);
        if (write_count > first_segment) {
            std::copy(data + first_segment, data + write_count, buffer.begin());
        }
        
        write_pos = (write_pos + write_count) % buffer.size();
        filled += write_count;
        return write_count;
    }

    // 读取数据，返回实际读取量
    size_t read(float* dest, size_t count) {
        std::lock_guard<std::mutex> lock(mtx);
        size_t read_count = std::min(count, filled);
        
        // 处理环形缓冲的分段读取
        size_t first_segment = std::min(read_count, buffer.size() - read_pos);
        std::copy(buffer.begin() + read_pos, buffer.begin() + read_pos + first_segment, dest);
        if (read_count > first_segment) {
            std::copy(buffer.begin(), buffer.begin() + (read_count - first_segment), dest + first_segment);
        }
        
        read_pos = (read_pos + read_count) % buffer.size();
        filled -= read_count;
        return read_count;
    }

    // 获取已填充数据量
    size_t get_filled_size() {
        std::lock_guard<std::mutex> lock(mtx);
        return filled;
    }
};

修改原程序逻辑

#include <thread>

AudioRingBuffer* ring_buf = nullptr;

void AudioCallback(void* userdata, Uint8* stream, int len) {
    float* buf = (float*)stream;
    size_t sample_count = len / sizeof(float);
    size_t read_count = ring_buf->read(buf, sample_count);
    
    // 数据不足时填充静音
    if (read_count < sample_count) {
        std::fill(buf + read_count, buf + sample_count, 0.0f);
    }
}

int main(int argc, char* argv[]) {
    // SDL初始化代码保持不变

    // 创建环形缓冲，容量设为SDL缓冲区的2-4倍（适配双声道F32格式）
    ring_buf = new AudioRingBuffer(have.samples * have.channels * 4);

    // 启动独立线程填充外部音频流
    std::thread fill_thread([&]() {
        float temp_buf[4096];
        while (/* 外部音频流未结束 */) {
            // 替换为你的外部音频流读取逻辑
            size_t read_size = /* 从外部流读取数据到temp_buf的数量 */;
            if (read_size == 0) break;
            
            // 缓冲满时短暂等待后重试写入
            while (ring_buf->write(temp_buf, read_size) != read_size) {
                SDL_Delay(1);
            }
        }
    });
    fill_thread.detach();

    // 启动音频设备、延迟播放、关闭设备的代码保持不变

    delete ring_buf;
    SDL_Quit();
    return 0;
}

2. 调整SDL音频缓冲区大小 #

原代码中samples = 4096的缓冲区偏大，会拉长回调间隔，增加单次填充的延迟感。可尝试缩小缓冲区（如1024或2048），平衡延迟与CPU负载：

want.samples = 2048; // 按需调整

3. 移除回调中的耗时操作 #

原回调中的std::cout是高耗时IO操作，会阻塞回调线程导致卡顿，必须移除所有回调内的非必要耗时操作，保证回调轻量化。

关键注意事项 #

• 环形缓冲必须保证线程安全，避免填充线程与回调线程的并发冲突
• 外部音频流格式需与SDL设备格式一致，不一致时需在填充线程中做格式转换
• 程序退出时需正确终止填充线程，避免内存泄漏或崩溃

内容的提问来源于stack exchange，提问作者Victor M