3

我使用双簧管在我的 ndk 库中播放声音，并使用带有 Android 扩展的 OpenSL将 wav 文件解码为 PCM。解码后的签名 16 位 PCM 存储在内存中 ( std::forward_list<int16_t>)，然后通过回调将它们发送到双簧管流中。我可以从手机听到的声音在音量级别上与原始 wav 文件相似，但是，这种声音的“质量”却不是——它爆裂和噼啪作响。

我猜我以错误的顺序或格式（采样率？）在音频流中发送 PCM。如何将 OpenSL 解码与双簧管音频流一起使用？

要将文件解码为 PCM，我使用AndroidSimpleBufferQueue作为接收器，使用AndroidFD和AAssetManager作为源：

// Loading asset
AAsset* asset = AAssetManager_open(manager, path, AASSET_MODE_UNKNOWN);
off_t start, length;
int fd = AAsset_openFileDescriptor(asset, &start, &length);
AAsset_close(asset);

// Creating audio source
SLDataLocator_AndroidFD loc_fd = { SL_DATALOCATOR_ANDROIDFD, fd, start, length };
SLDataFormat_MIME format_mime = { SL_DATAFORMAT_MIME, NULL, SL_CONTAINERTYPE_UNSPECIFIED };
SLDataSource audio_source = { &loc_fd, &format_mime };

// Creating audio sink
SLDataLocator_AndroidSimpleBufferQueue loc_bq = { SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE, 1 };
SLDataFormat_PCM pcm = {
    .formatType = SL_DATAFORMAT_PCM,
    .numChannels = 2,
    .samplesPerSec = SL_SAMPLINGRATE_44_1,
    .bitsPerSample = SL_PCMSAMPLEFORMAT_FIXED_16,
    .containerSize = SL_PCMSAMPLEFORMAT_FIXED_16,
    .channelMask = SL_SPEAKER_FRONT_LEFT | SL_SPEAKER_FRONT_RIGHT,
    .endianness = SL_BYTEORDER_LITTLEENDIAN
};
SLDataSink sink = { &loc_bq, &pcm };

然后我注册回调，将缓冲区排入队列并将 PCM 从缓冲区移动到存储，直到完成。

注意：wav 音频文件也是 2 通道签名 16 位 44.1Hz PCM

我的双簧管流配置是一样的：

AudioStreamBuilder builder;
builder.setChannelCount(2);
builder.setSampleRate(44100);
builder.setCallback(this);
builder.setFormat(AudioFormat::I16);
builder.setPerformanceMode(PerformanceMode::LowLatency);
builder.setSharingMode(SharingMode::Exclusive);

音频渲染是这样工作的：

// Oboe stream callback
audio_engine::onAudioReady(AudioStream* self, void* audio_data, int32_t num_frames) {
    auto stream = static_cast<int16_t*>(audio_data);
    sound->render(stream, num_frames);
}

// Sound::render method
sound::render(int16_t* audio_data, int32_t num_frames) {
    auto iter = pcm_data.begin();
    std::advance(iter, cur_frame);

    const int32_t rem_size = std::min(num_frames, size - cur_frame);
    for(int32_t i = 0; i < rem_size; ++i, std::next(iter), ++cur_frame) {
        audio_data[i] += *iter;
    }
}
4

2 回答 2

3

看起来您的 render() 方法混淆了样本和帧。一帧是一组同时的样本。在立体声流中，每一帧都有两个样本。

我认为您的迭代器是在样本基础上工作的。换句话说，next(iter) 将前进到下一个样本，而不是下一帧。试试这个（未经测试的）代码。

sound::render(int16_t* audio_data, int32_t num_frames) {
    auto iter = pcm_data.begin();
    const int samples_per_frame = 2; // stereo
    std::advance(iter, cur_sample);

    const int32_t num_samples = std::min(num_frames * samples_per_frame,
              total_samples - cur_sample);
    for(int32_t i = 0; i < num_samples; ++i, std::next(iter), ++cur_sample) {
        audio_data[i] += *iter;
    }
}
于 2018-11-28T01:21:46.830 回答
0

简而言之：本质上，由于使用std::forward_listPCM 存储，我遇到了欠载。在这种情况下（使用迭代器检索 PCM），必须使用其迭代器实现LegacyRandomAccessIterator（例如std::vector）的容器。

我确信方法的线性复杂性std::advance和std::next我的方法没有任何区别sound::render。但是，当我尝试将原始指针和指针算术（因此，常数复杂性）与评论中建议的调试方法一起使用时（使用 Audacity 从 WAV 中提取 PCM，然后使用AAssetManager直接将该资产加载到内存中），我意识到，输出声音的“损坏”量与渲染方法中的位置参数成正比。std::advance(iter, position)

std::advance因此，如果声音损坏的数量与（以及）的复杂性成正比std::next，那么我必须使复杂性保持不变——通过将std::vector其用作容器。并使用@philburk 的答案，我得到了这个作为工作结果：

class sound {
    private:
        const int samples_per_frame = 2; // stereo
        std::vector<int16_t> pcm_data;
        ...
    public:
        render(int16_t* audio_data, int32_t num_frames) {
            auto iter = std::next(pcm_data.begin(), cur_sample);
            const int32_t s = std::min(num_frames * samples_per_frame,
                                       total_samples - cur_sample);

            for(int32_t i = 0; i < s; ++i, std::advance(iter, 1), ++cur_sample) {
                audio_data[i] += *iter;
            }
        }
}
于 2018-12-09T03:07:55.073 回答