AudioFlinger Thread中的几个buffer

1
2
3
4
5
6
7
8

//hwDevHal对应的是hal primary的so，参数config即为audio_policy.conf中该节点的相关参数，包括支持的采样率、format、ChannelMask(表示可以支持到多少channel)等。
status_t status = hwDevHal->open_output_stream(hwDevHal,
                                               *output,
                                               devices,
                                               flags,
                                               config,
                                               &outStream,
                                               address.string());

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

mSampleRate = mOutput->stream->common.get_sample_rate(&mOutput->stream->common);
mChannelMask = mOutput->stream->common.get_channels(&mOutput->stream->common);
mChannelCount = audio_channel_count_from_out_mask(mChannelMask);
mHALFormat = mOutput->stream->common.get_format(&mOutput->stream->common);
mFormat = mHALFormat;
//确认一帧占多少字节，也是通过format*channel进行转换的。
mFrameSize = audio_stream_out_frame_size(mOutput->stream);
//获取底层缓冲区大小
mBufferSize = mOutput->stream->common.get_buffer_size(&mOutput->stream->common);
//换算出Hal层缓冲区容纳的帧数
mFrameCount = mBufferSize / mFrameSize;
//这边我们先不管multiplier，这个值跟FastMixer相关。
mNormalFrameCount = multiplier * mFrameCount;
//开始初始化SinkBuffer
free(mSinkBuffer);
mSinkBuffer = NULL;
// For sink buffer size, we use the frame size from the downstream sink to avoid problems
// with non PCM formats for compressed music, e.g. AAC, and Offload threads.
// SinkBuffer 这边使用的是上面计算出来的FrameSize，而下面则是重新计算的，这边谷歌给出了说明：
// 为了防止使用了Non PCM Format的一些格式，比如AAC,或者是offload场景下，为了避免存在大小问题，直接从底层获取该帧的位数
const size_t sinkBufferSize = mNormalFrameCount * mFrameSize;
(void)posix_memalign((void**)&mSinkBuffer, 32, sinkBufferSize);

//mMixerBufferEnabled该变量是否为true，是由AudioFlinger::kEnableExtendedPrecision决定的，并且只存在在MixerThread中，如果有扩展的精度的话，就需要用到该缓冲区,默认情况下是开启的
free(mMixerBuffer);
mMixerBuffer = NULL;
if (mMixerBufferEnabled) {
    mMixerBufferFormat = AUDIO_FORMAT_PCM_FLOAT; // also valid: AUDIO_FORMAT_PCM_16_BIT.
    mMixerBufferSize = mNormalFrameCount * mChannelCount
            * audio_bytes_per_sample(mMixerBufferFormat);
    (void)posix_memalign(&mMixerBuffer, 32, mMixerBufferSize);
}
free(mEffectBuffer);
mEffectBuffer = NULL;
//同上面
if (mEffectBufferEnabled) {
    mEffectBufferFormat = AUDIO_FORMAT_PCM_16_BIT; // Note: Effects support 16b only
    mEffectBufferSize = mNormalFrameCount * mChannelCount
            * audio_bytes_per_sample(mEffectBufferFormat);
    (void)posix_memalign(&mEffectBuffer, 32, mEffectBufferSize);
}

1
2
3
4
5

mAudioMixer->setBufferProvider(name, track);
mAudioMixer->setParameter(
        name,
        AudioMixer::TRACK,
        AudioMixer::MAIN_BUFFER, (void *)track->mainBuffer());

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

template <int MIXTYPE, typename TO, typename TI, typename TA>
void AudioMixer::process_NoResampleOneTrack(state_t* state, int64_t pts)
{
    ALOGVV("process_NoResampleOneTrack\n");
    // CLZ is faster than CTZ on ARM, though really not sure if true after 31 - clz.
    const int i = 31 - __builtin_clz(state->enabledTracks);
    ALOG_ASSERT((1 << i) == state->enabledTracks, "more than 1 track enabled");
    track_t *t = &state->tracks[i];
    const uint32_t channels = t->mMixerChannelCount;
    //out 对应的 是track的mainBuffer，其实就是EffectBuffer。
    TO* out = reinterpret_cast<TO*>(t->mainBuffer);
    //这个暂且不关心吧，不知道auxiliary effect是哪种类型，以后发现再来补充
    TA* aux = reinterpret_cast<TA*>(t->auxBuffer);
    const bool ramp = t->needsRamp();

    for (size_t numFrames = state->frameCount; numFrames; ) {
        AudioBufferProvider::Buffer& b(t->buffer);
        // get input buffer
        b.frameCount = numFrames;
        const int64_t outputPTS = calculateOutputPTS(*t, pts, state->frameCount - numFrames);
        //从track中去取数据
        t->bufferProvider->getNextBuffer(&b, outputPTS);
        //in 指向的就是获取到的数据buffer
        const TI *in = reinterpret_cast<TI*>(b.raw);

        const size_t outFrames = b.frameCount;
        //做下音量处理。每种类型的声音，都有各自不同的音量，并且输出到out缓冲区。
        volumeMix<MIXTYPE, is_same<TI, float>::value, false> (
                out, outFrames, in, aux, ramp, t);

        out += outFrames * channels;
        if (aux != NULL) {
            aux += channels;
        }
        numFrames -= b.frameCount;

        // release buffer
        t->bufferProvider->releaseBuffer(&b);
    }
    if (ramp) {
        t->adjustVolumeRamp(aux != NULL, is_same<TI, float>::value);
    }
}

1
2
3
4
5

if (sleepTime == 0 && mType != OFFLOAD) {
    for (size_t i = 0; i < effectChains.size(); i ++) {
        effectChains[i]->process_l();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

void AudioFlinger::EffectModule::process()
{
    if (isProcessEnabled()) {

        // do the actual processing in the effect engine
        int ret = (*mEffectInterface)->process(mEffectInterface,
                                               &mConfig.inputCfg.buffer,
                                               &mConfig.outputCfg.buffer);


    } else if ((mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_INSERT &&
                mConfig.inputCfg.buffer.raw != mConfig.outputCfg.buffer.raw) {
		...
    }
}

1
2
3
4
5
6

int16_t* buffer = reinterpret_cast<int16_t*>(mEffectBufferEnabled
        ? mEffectBuffer : mSinkBuffer);
chain->setThread(this);
chain->setInBuffer(buffer, ownsBuffer);
chain->setOutBuffer(reinterpret_cast<int16_t*>(mEffectBufferEnabled
        ? mEffectBuffer : mSinkBuffer));